[llvm] 9a3e399 - [MergeICmps] Convert tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Jan 4 08:05:00 PST 2023
Author: Nikita Popov
Date: 2023-01-04T17:04:34+01:00
New Revision: 9a3e39996320793ec5fe5c6bb4873f82cbc1bbf3
URL: https://github.com/llvm/llvm-project/commit/9a3e39996320793ec5fe5c6bb4873f82cbc1bbf3
DIFF: https://github.com/llvm/llvm-project/commit/9a3e39996320793ec5fe5c6bb4873f82cbc1bbf3.diff
LOG: [MergeICmps] Convert tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Transforms/MergeICmps/X86/addressspaces.ll
llvm/test/Transforms/MergeICmps/X86/alias-merge-blocks.ll
llvm/test/Transforms/MergeICmps/X86/atomic.ll
llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled-2.ll
llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled.ll
llvm/test/Transforms/MergeICmps/X86/gep-references-bb.ll
llvm/test/Transforms/MergeICmps/X86/gep-used-outside.ll
llvm/test/Transforms/MergeICmps/X86/int64-and-ptr.ll
llvm/test/Transforms/MergeICmps/X86/last-block-produce-no-value.ll
llvm/test/Transforms/MergeICmps/X86/multiple-blocks-does-work.ll
llvm/test/Transforms/MergeICmps/X86/no-gep-other-work.ll
llvm/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
llvm/test/Transforms/MergeICmps/X86/pr36557.ll
llvm/test/Transforms/MergeICmps/X86/pr41917.ll
llvm/test/Transforms/MergeICmps/X86/pr53959.ll
llvm/test/Transforms/MergeICmps/X86/split-block-does-work.ll
llvm/test/Transforms/MergeICmps/X86/tuple-four-int8.ll
llvm/test/Transforms/MergeICmps/X86/two-complex-bb.ll
llvm/test/Transforms/MergeICmps/X86/volatile.ll
llvm/test/Transforms/MergeICmps/pair-int32-int32.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/MergeICmps/X86/addressspaces.ll b/llvm/test/Transforms/MergeICmps/X86/addressspaces.ll
index cc981902b2d35..28464c795ff23 100644
--- a/llvm/test/Transforms/MergeICmps/X86/addressspaces.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/addressspaces.ll
@@ -3,41 +3,33 @@
target triple = "x86_64"
; First check that we try to from a memcmp.
-define void @form_memcmp([2 x i64]* dereferenceable(16) %a, [2 x i64]* dereferenceable(16) %b) {
+define void @form_memcmp(ptr dereferenceable(16) %a, ptr dereferenceable(16) %b) {
; CHECK-LABEL: @form_memcmp(
; CHECK-NEXT: bb0:
-; CHECK-NEXT: [[PTR_A0:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[A:%.*]], i64 0, i64 0
-; CHECK-NEXT: [[PTR_A1:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[A]], i64 0, i64 1
-; CHECK-NEXT: [[PTR_B0:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[B:%.*]], i64 0, i64 0
-; CHECK-NEXT: [[PTR_B1:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[B]], i64 0, i64 1
+; CHECK-NEXT: [[PTR_A1:%.*]] = getelementptr inbounds [2 x i64], ptr [[A:%.*]], i64 0, i64 1
+; CHECK-NEXT: [[PTR_B1:%.*]] = getelementptr inbounds [2 x i64], ptr [[B:%.*]], i64 0, i64 1
; CHECK-NEXT: br label %"bb1+bb2"
; CHECK: "bb1+bb2":
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[A]], i64 0, i64 0
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[B]], i64 0, i64 0
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i64* [[TMP0]] to i8*
-; CHECK-NEXT: [[CSTR1:%.*]] = bitcast i64* [[TMP1]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 16)
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A]], ptr [[B]], i64 16)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[BB3:%.*]]
; CHECK: bb3:
; CHECK-NEXT: ret void
;
bb0:
- %ptr_a0 = getelementptr inbounds [2 x i64], [2 x i64]* %a, i64 0, i64 0
- %ptr_a1 = getelementptr inbounds [2 x i64], [2 x i64]* %a, i64 0, i64 1
- %ptr_b0 = getelementptr inbounds [2 x i64], [2 x i64]* %b, i64 0, i64 0
- %ptr_b1 = getelementptr inbounds [2 x i64], [2 x i64]* %b, i64 0, i64 1
+ %ptr_a1 = getelementptr inbounds [2 x i64], ptr %a, i64 0, i64 1
+ %ptr_b1 = getelementptr inbounds [2 x i64], ptr %b, i64 0, i64 1
br label %bb1
bb1: ; preds = %bb0
- %a0 = load i64, i64* %ptr_a0
- %b0 = load i64, i64* %ptr_b0
+ %a0 = load i64, ptr %a
+ %b0 = load i64, ptr %b
%cond0 = icmp eq i64 %a0, %b0
br i1 %cond0, label %bb2, label %bb3
bb2: ; preds = %bb1
- %a1 = load i64, i64* %ptr_a1
- %b1 = load i64, i64* %ptr_b1
+ %a1 = load i64, ptr %ptr_a1
+ %b1 = load i64, ptr %ptr_b1
%cond1 = icmp eq i64 %a1, %b1
br label %bb3
@@ -47,22 +39,20 @@ bb3: ; preds = %bb2, %bb1
}
; We can't use memcmp between arbitrary addressesspaces
-define void @no_memcmp([2 x i64] addrspace(11)* dereferenceable(16) %a, [2 x i64] addrspace(11)* dereferenceable(16) %b) {
+define void @no_memcmp(ptr addrspace(11) dereferenceable(16) %a, ptr addrspace(11) dereferenceable(16) %b) {
; CHECK-LABEL: @no_memcmp(
; CHECK-NEXT: bb0:
-; CHECK-NEXT: [[PTR_A0:%.*]] = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* [[A:%.*]], i64 0, i64 0
-; CHECK-NEXT: [[PTR_A1:%.*]] = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* [[A]], i64 0, i64 1
-; CHECK-NEXT: [[PTR_B0:%.*]] = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* [[B:%.*]], i64 0, i64 0
-; CHECK-NEXT: [[PTR_B1:%.*]] = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* [[B]], i64 0, i64 1
+; CHECK-NEXT: [[PTR_A1:%.*]] = getelementptr inbounds [2 x i64], ptr addrspace(11) [[A:%.*]], i64 0, i64 1
+; CHECK-NEXT: [[PTR_B1:%.*]] = getelementptr inbounds [2 x i64], ptr addrspace(11) [[B:%.*]], i64 0, i64 1
; CHECK-NEXT: br label [[BB1:%.*]]
; CHECK: bb1:
-; CHECK-NEXT: [[A0:%.*]] = load i64, i64 addrspace(11)* [[PTR_A0]], align 4
-; CHECK-NEXT: [[B0:%.*]] = load i64, i64 addrspace(11)* [[PTR_B0]], align 4
+; CHECK-NEXT: [[A0:%.*]] = load i64, ptr addrspace(11) [[A]], align 4
+; CHECK-NEXT: [[B0:%.*]] = load i64, ptr addrspace(11) [[B]], align 4
; CHECK-NEXT: [[COND0:%.*]] = icmp eq i64 [[A0]], [[B0]]
; CHECK-NEXT: br i1 [[COND0]], label [[BB2:%.*]], label [[BB3:%.*]]
; CHECK: bb2:
-; CHECK-NEXT: [[A1:%.*]] = load i64, i64 addrspace(11)* [[PTR_A1]], align 4
-; CHECK-NEXT: [[B1:%.*]] = load i64, i64 addrspace(11)* [[PTR_B1]], align 4
+; CHECK-NEXT: [[A1:%.*]] = load i64, ptr addrspace(11) [[PTR_A1]], align 4
+; CHECK-NEXT: [[B1:%.*]] = load i64, ptr addrspace(11) [[PTR_B1]], align 4
; CHECK-NEXT: [[COND1:%.*]] = icmp eq i64 [[A1]], [[B1]]
; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3:
@@ -70,21 +60,19 @@ define void @no_memcmp([2 x i64] addrspace(11)* dereferenceable(16) %a, [2 x i64
; CHECK-NEXT: ret void
;
bb0:
- %ptr_a0 = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* %a, i64 0, i64 0
- %ptr_a1 = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* %a, i64 0, i64 1
- %ptr_b0 = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* %b, i64 0, i64 0
- %ptr_b1 = getelementptr inbounds [2 x i64], [2 x i64] addrspace(11)* %b, i64 0, i64 1
+ %ptr_a1 = getelementptr inbounds [2 x i64], ptr addrspace(11) %a, i64 0, i64 1
+ %ptr_b1 = getelementptr inbounds [2 x i64], ptr addrspace(11) %b, i64 0, i64 1
br label %bb1
bb1: ; preds = %bb0
- %a0 = load i64, i64 addrspace(11)* %ptr_a0
- %b0 = load i64, i64 addrspace(11)* %ptr_b0
+ %a0 = load i64, ptr addrspace(11) %a
+ %b0 = load i64, ptr addrspace(11) %b
%cond0 = icmp eq i64 %a0, %b0
br i1 %cond0, label %bb2, label %bb3
bb2: ; preds = %bb1
- %a1 = load i64, i64 addrspace(11)* %ptr_a1
- %b1 = load i64, i64 addrspace(11)* %ptr_b1
+ %a1 = load i64, ptr addrspace(11) %ptr_a1
+ %b1 = load i64, ptr addrspace(11) %ptr_b1
%cond1 = icmp eq i64 %a1, %b1
br label %bb3
diff --git a/llvm/test/Transforms/MergeICmps/X86/alias-merge-blocks.ll b/llvm/test/Transforms/MergeICmps/X86/alias-merge-blocks.ll
index 54210232e4f51..09ef757cbdf9f 100644
--- a/llvm/test/Transforms/MergeICmps/X86/alias-merge-blocks.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/alias-merge-blocks.ll
@@ -7,52 +7,46 @@ define zeroext i1 @opeq1(
; X86-LABEL: @opeq1(
; X86-NEXT: "entry+land.rhs.i+land.rhs.i.2+land.rhs.i.3":
; X86-NEXT: [[PTR:%.*]] = alloca i32, align 4
-; X86-NEXT: store i32 42, i32* [[PTR]], align 4
-; X86-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 16)
+; X86-NEXT: store i32 42, ptr [[PTR]], align 4
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A:%.*]], ptr [[B:%.*]], i64 16)
; X86-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT:%.*]]
; X86: opeq1.exit:
; X86-NEXT: ret i1 [[TMP2]]
;
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
%ptr = alloca i32
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
; Does other work, has no interference, merge block
- store i32 42, i32* %ptr
+ store i32 42, ptr %ptr
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/atomic.ll b/llvm/test/Transforms/MergeICmps/X86/atomic.ll
index 9cbeb5d0b84ad..a2a948aa0e5f3 100644
--- a/llvm/test/Transforms/MergeICmps/X86/atomic.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/atomic.ll
@@ -6,38 +6,34 @@
define zeroext i1 @opeq(
; CHECK-LABEL: @opeq(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; CHECK-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; CHECK-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; CHECK-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; CHECK: land.rhs.i:
-; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, i32* [[SECOND_I]] seq_cst, align 4
-; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, ptr [[SECOND_I]] seq_cst, align 4
+; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; CHECK-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; CHECK-NEXT: br label [[OPEQ1_EXIT]]
; CHECK: opeq1.exit:
; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; CHECK-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(8) %a,
- %S* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load atomic i32, i32* %second.i seq_cst, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load atomic i32, ptr %second.i seq_cst, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled-2.ll b/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled-2.ll
index e23653228d8fa..3335f276c5ee9 100644
--- a/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled-2.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled-2.ll
@@ -3,7 +3,7 @@
target triple = "x86_64-unknown-linux-gnu"
-%"struct.a::c" = type { i32, i32*, i8* }
+%"struct.a::c" = type { i32, ptr, ptr }
; The entry block cannot be merged as the comparison is not continuous.
; While it compares the highest address, it should not be moved after the
@@ -14,20 +14,16 @@ define i1 @test() {
; CHECK-NEXT: "land.lhs.true+entry":
; CHECK-NEXT: [[H:%.*]] = alloca %"struct.a::c", align 8
; CHECK-NEXT: [[I:%.*]] = alloca %"struct.a::c", align 8
-; CHECK-NEXT: call void @init(%"struct.a::c"* [[H]])
-; CHECK-NEXT: call void @init(%"struct.a::c"* [[I]])
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds %"struct.a::c", %"struct.a::c"* [[H]], i64 0, i32 1
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds %"struct.a::c", %"struct.a::c"* [[I]], i64 0, i32 1
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i32** [[TMP0]] to i8*
-; CHECK-NEXT: [[CSTR2:%.*]] = bitcast i32** [[TMP1]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR2]], i64 16)
+; CHECK-NEXT: call void @init(ptr [[H]])
+; CHECK-NEXT: call void @init(ptr [[I]])
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds %"struct.a::c", ptr [[H]], i64 0, i32 1
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds %"struct.a::c", ptr [[I]], i64 0, i32 1
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP0]], ptr [[TMP1]], i64 16)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br i1 [[TMP2]], label [[LAND_RHS1:%.*]], label [[LAND_END:%.*]]
; CHECK: land.rhs1:
-; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds %"struct.a::c", %"struct.a::c"* [[H]], i64 0, i32 0
-; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds %"struct.a::c", %"struct.a::c"* [[I]], i64 0, i32 0
-; CHECK-NEXT: [[TMP5:%.*]] = load i32, i32* [[TMP3]], align 4
-; CHECK-NEXT: [[TMP6:%.*]] = load i32, i32* [[TMP4]], align 4
+; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[H]], align 4
+; CHECK-NEXT: [[TMP6:%.*]] = load i32, ptr [[I]], align 4
; CHECK-NEXT: [[TMP7:%.*]] = icmp eq i32 [[TMP5]], [[TMP6]]
; CHECK-NEXT: br label [[LAND_END]]
; CHECK: land.end:
@@ -37,28 +33,26 @@ define i1 @test() {
entry:
%h = alloca %"struct.a::c", align 8
%i = alloca %"struct.a::c", align 8
- call void @init(%"struct.a::c"* %h)
- call void @init(%"struct.a::c"* %i)
- %e = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %h, i64 0, i32 2
- %v3 = load i8*, i8** %e, align 8
- %e2 = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %i, i64 0, i32 2
- %v4 = load i8*, i8** %e2, align 8
- %cmp = icmp eq i8* %v3, %v4
+ call void @init(ptr %h)
+ call void @init(ptr %i)
+ %e = getelementptr inbounds %"struct.a::c", ptr %h, i64 0, i32 2
+ %v3 = load ptr, ptr %e, align 8
+ %e2 = getelementptr inbounds %"struct.a::c", ptr %i, i64 0, i32 2
+ %v4 = load ptr, ptr %e2, align 8
+ %cmp = icmp eq ptr %v3, %v4
br i1 %cmp, label %land.lhs.true, label %land.end
land.lhs.true: ; preds = %entry
- %d = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %h, i64 0, i32 1
- %v5 = load i32*, i32** %d, align 8
- %d3 = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %i, i64 0, i32 1
- %v6 = load i32*, i32** %d3, align 8
- %cmp4 = icmp eq i32* %v5, %v6
+ %d = getelementptr inbounds %"struct.a::c", ptr %h, i64 0, i32 1
+ %v5 = load ptr, ptr %d, align 8
+ %d3 = getelementptr inbounds %"struct.a::c", ptr %i, i64 0, i32 1
+ %v6 = load ptr, ptr %d3, align 8
+ %cmp4 = icmp eq ptr %v5, %v6
br i1 %cmp4, label %land.rhs, label %land.end
land.rhs: ; preds = %land.lhs.true
- %j = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %h, i64 0, i32 0
- %v7 = load i32, i32* %j, align 8
- %j5 = getelementptr inbounds %"struct.a::c", %"struct.a::c"* %i, i64 0, i32 0
- %v8 = load i32, i32* %j5, align 8
+ %v7 = load i32, ptr %h, align 8
+ %v8 = load i32, ptr %i, align 8
%cmp6 = icmp eq i32 %v7, %v8
br label %land.end
@@ -67,4 +61,4 @@ land.end: ; preds = %land.rhs, %land.lhs
ret i1 %v9
}
-declare void @init(%"struct.a::c"*)
+declare void @init(ptr)
diff --git a/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled.ll b/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled.ll
index f097aed0d8af6..bc6beefb2caee 100644
--- a/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/entry-block-shuffled.ll
@@ -9,63 +9,57 @@
define zeroext i1 @opeq1(
; CHECK-LABEL: @opeq1(
-; CHECK-NEXT: entry3:
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 3
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 2
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: entry2:
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A:%.*]], i64 0, i32 3
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], ptr [[B:%.*]], i64 0, i32 2
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; CHECK-NEXT: br i1 [[TMP4]], label %"land.rhs.i+land.rhs.i.2", label [[OPEQ1_EXIT:%.*]]
; CHECK: "land.rhs.i+land.rhs.i.2":
-; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 0
-; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 0
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP5]] to i8*
-; CHECK-NEXT: [[CSTR2:%.*]] = bitcast i32* [[TMP6]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR2]], i64 8)
-; CHECK-NEXT: [[TMP7:%.*]] = icmp eq i32 [[MEMCMP]], 0
-; CHECK-NEXT: br i1 [[TMP7]], label [[LAND_RHS_I_31:%.*]], label [[OPEQ1_EXIT]]
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A]], ptr [[B]], i64 8)
+; CHECK-NEXT: [[TMP5:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; CHECK-NEXT: br i1 [[TMP5]], label [[LAND_RHS_I_31:%.*]], label [[OPEQ1_EXIT]]
; CHECK: land.rhs.i.31:
-; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 3
-; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 3
-; CHECK-NEXT: [[TMP10:%.*]] = load i32, i32* [[TMP8]], align 4
-; CHECK-NEXT: [[TMP11:%.*]] = load i32, i32* [[TMP9]], align 4
-; CHECK-NEXT: [[TMP12:%.*]] = icmp eq i32 [[TMP10]], [[TMP11]]
+; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 3
+; CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 3
+; CHECK-NEXT: [[TMP8:%.*]] = load i32, ptr [[TMP6]], align 4
+; CHECK-NEXT: [[TMP9:%.*]] = load i32, ptr [[TMP7]], align 4
+; CHECK-NEXT: [[TMP10:%.*]] = icmp eq i32 [[TMP8]], [[TMP9]]
; CHECK-NEXT: br label [[OPEQ1_EXIT]]
; CHECK: opeq1.exit:
-; CHECK-NEXT: [[TMP13:%.*]] = phi i1 [ [[TMP12]], [[LAND_RHS_I_31]] ], [ false, %"land.rhs.i+land.rhs.i.2" ], [ false, [[ENTRY3:%.*]] ]
-; CHECK-NEXT: ret i1 [[TMP13]]
+; CHECK-NEXT: [[TMP11:%.*]] = phi i1 [ [[TMP10]], [[LAND_RHS_I_31]] ], [ false, %"land.rhs.i+land.rhs.i.2" ], [ false, [[ENTRY2:%.*]] ]
+; CHECK-NEXT: ret i1 [[TMP11]]
;
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %1 = load i32, i32* %first1.i, align 4
+ %first.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %0 = load i32, ptr %first.i, align 4
+ %first1.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %1 = load i32, ptr %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %3 = load i32, i32* %second2.i, align 4
+ %2 = load i32, ptr %a, align 4
+ %3 = load i32, ptr %b, align 4
%cmp3.i = icmp eq i32 %2, %3
br i1 %cmp3.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %5 = load i32, ptr %third2.i, align 4
%cmp4.i = icmp eq i32 %4, %5
br i1 %cmp4.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp5.i = icmp eq i32 %6, %7
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/gep-references-bb.ll b/llvm/test/Transforms/MergeICmps/X86/gep-references-bb.ll
index f40787ae22dc0..6f24d581f8d70 100644
--- a/llvm/test/Transforms/MergeICmps/X86/gep-references-bb.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/gep-references-bb.ll
@@ -8,23 +8,18 @@ target triple = "x86_64"
; bb1 references a gep introduced in bb0. The gep must remain available after
; the merge.
-define i1 @bug(%Triple* nonnull dereferenceable(16) %lhs, %Triple* nonnull dereferenceable(16) %rhs) nofree nosync {
+define i1 @bug(ptr nonnull dereferenceable(16) %lhs, ptr nonnull dereferenceable(16) %rhs) nofree nosync {
; CHECK-LABEL: @bug(
; CHECK-NEXT: bb0:
-; CHECK-NEXT: [[GEP:%.*]] = getelementptr [[TRIPLE:%.*]], %Triple* [[RHS:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[L0_ADDR:%.*]] = getelementptr inbounds [[TRIPLE]], %Triple* [[LHS:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[L0:%.*]] = load i32, i32* [[L0_ADDR]], align 4
-; CHECK-NEXT: [[R0_ADDR:%.*]] = getelementptr inbounds [[TRIPLE]], %Triple* [[RHS]], i64 0, i32 0
-; CHECK-NEXT: [[R0:%.*]] = load i32, i32* [[R0_ADDR]], align 4
-; CHECK-NEXT: store i32 1, i32* @g, align 4
+; CHECK-NEXT: [[L0:%.*]] = load i32, ptr [[LHS:%.*]], align 4
+; CHECK-NEXT: [[R0:%.*]] = load i32, ptr [[RHS:%.*]], align 4
+; CHECK-NEXT: store i32 1, ptr @g, align 4
; CHECK-NEXT: [[CMP0:%.*]] = icmp eq i32 [[L0]], [[R0]]
; CHECK-NEXT: br i1 [[CMP0]], label %"bb1+bb2", label [[FINAL:%.*]]
; CHECK: "bb1+bb2":
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[TRIPLE]], %Triple* [[LHS]], i64 0, i32 2
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[GEP]], i64 2
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; CHECK-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[TRIPLE:%.*]], ptr [[LHS]], i64 0, i32 2
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[RHS]], i64 2
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP0]], ptr [[TMP1]], i64 8)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[FINAL]]
; CHECK: final:
@@ -32,28 +27,25 @@ define i1 @bug(%Triple* nonnull dereferenceable(16) %lhs, %Triple* nonnull deref
; CHECK-NEXT: ret i1 [[RET]]
;
bb0:
- %gep = getelementptr %Triple, %Triple* %rhs, i64 0, i32 0
- %l0_addr = getelementptr inbounds %Triple, %Triple* %lhs, i64 0, i32 0
- %l0 = load i32, i32* %l0_addr, align 4
- %r0_addr = getelementptr inbounds %Triple, %Triple* %rhs, i64 0, i32 0
- %r0 = load i32, i32* %r0_addr, align 4
- store i32 1, i32* @g
+ %l0 = load i32, ptr %lhs, align 4
+ %r0 = load i32, ptr %rhs, align 4
+ store i32 1, ptr @g
%cmp0 = icmp eq i32 %l0, %r0
br i1 %cmp0, label %bb1, label %final
bb1: ; preds = %bb0
- %l1_addr = getelementptr inbounds %Triple, %Triple* %lhs, i64 0, i32 2
- %l1 = load i32, i32* %l1_addr, align 4
- %r1_addr = getelementptr inbounds i32, i32* %gep, i64 2
- %r1 = load i32, i32* %r1_addr, align 4
+ %l1_addr = getelementptr inbounds %Triple, ptr %lhs, i64 0, i32 2
+ %l1 = load i32, ptr %l1_addr, align 4
+ %r1_addr = getelementptr inbounds i32, ptr %rhs, i64 2
+ %r1 = load i32, ptr %r1_addr, align 4
%cmp1 = icmp eq i32 %l1, %r1
br i1 %cmp1, label %bb2, label %final
bb2: ; preds = %bb1
- %l2_addr = getelementptr inbounds %Triple, %Triple* %lhs, i64 0, i32 3
- %l2 = load i32, i32* %l2_addr, align 4
- %r2_addr = getelementptr inbounds i32, i32* %gep, i64 3
- %r2 = load i32, i32* %r2_addr, align 4
+ %l2_addr = getelementptr inbounds %Triple, ptr %lhs, i64 0, i32 3
+ %l2 = load i32, ptr %l2_addr, align 4
+ %r2_addr = getelementptr inbounds i32, ptr %rhs, i64 3
+ %r2 = load i32, ptr %r2_addr, align 4
%cmp2 = icmp eq i32 %l2, %r2
br label %final
diff --git a/llvm/test/Transforms/MergeICmps/X86/gep-used-outside.ll b/llvm/test/Transforms/MergeICmps/X86/gep-used-outside.ll
index 62185c8b501b2..b46526029d979 100644
--- a/llvm/test/Transforms/MergeICmps/X86/gep-used-outside.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/gep-used-outside.ll
@@ -9,47 +9,43 @@
define zeroext i32 @opeq1(
; CHECK-LABEL: @opeq1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 1
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; CHECK-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 1
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; CHECK-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A:%.*]], i64 0, i32 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[FIRST_I]], align 4
+; CHECK-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], ptr [[B:%.*]], i64 0, i32 1
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[FIRST1_I]], align 4
; CHECK-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; CHECK-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; CHECK: land.rhs.i:
-; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 0
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 0
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; CHECK-NEXT: br label [[OPEQ1_EXIT]]
; CHECK: opeq1.exit:
; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
-; CHECK-NEXT: [[TMP5:%.*]] = load i32, i32* [[FIRST_I]], align 4
+; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[FIRST_I]], align 4
; CHECK-NEXT: [[TMP6:%.*]] = select i1 [[TMP4]], i32 [[TMP5]], i32 0
; CHECK-NEXT: ret i32 [[TMP6]]
;
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %1 = load i32, i32* %first1.i, align 4
+ %first.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %0 = load i32, ptr %first.i, align 4
+ %first1.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %1 = load i32, ptr %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %3 = load i32, i32* %second2.i, align 4
+ %2 = load i32, ptr %a, align 4
+ %3 = load i32, ptr %b, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
opeq1.exit:
%4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i]
- %5 = load i32, i32* %first.i, align 4
+ %5 = load i32, ptr %first.i, align 4
%6 = select i1 %4, i32 %5, i32 0
ret i32 %6
}
diff --git a/llvm/test/Transforms/MergeICmps/X86/int64-and-ptr.ll b/llvm/test/Transforms/MergeICmps/X86/int64-and-ptr.ll
index 18909d6b3d7e0..179d6e6dcfdf5 100644
--- a/llvm/test/Transforms/MergeICmps/X86/int64-and-ptr.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/int64-and-ptr.ll
@@ -3,37 +3,31 @@
; 8-byte int and 8-byte pointer should merge into a 16-byte memcmp.
-%struct.outer = type { i64, %struct.inner* }
+%struct.outer = type { i64, ptr }
%struct.inner = type { i32, i32, i32 }
; Function Attrs: nounwind uwtable
-define i1 @test(%struct.outer* align 8 dereferenceable(16) %o1, %struct.outer* align 8 dereferenceable(116) %o2) local_unnamed_addr nofree nosync {
+define i1 @test(ptr align 8 dereferenceable(16) %o1, ptr align 8 dereferenceable(116) %o2) local_unnamed_addr nofree nosync {
; CHECK-LABEL: @test(
; CHECK-NEXT: "entry+if.then":
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_OUTER:%.*]], %struct.outer* [[O1:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_OUTER]], %struct.outer* [[O2:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i64* [[TMP0]] to i8*
-; CHECK-NEXT: [[CSTR1:%.*]] = bitcast i64* [[TMP1]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 16)
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[O1:%.*]], ptr [[O2:%.*]], i64 16)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[IF_END5:%.*]]
; CHECK: if.end5:
; CHECK-NEXT: ret i1 [[TMP2]]
;
entry:
- %p1 = getelementptr inbounds %struct.outer, %struct.outer* %o1, i64 0, i32 0
- %0 = load i64, i64* %p1, align 8
- %p11 = getelementptr inbounds %struct.outer, %struct.outer* %o2, i64 0, i32 0
- %1 = load i64, i64* %p11, align 8
+ %0 = load i64, ptr %o1, align 8
+ %1 = load i64, ptr %o2, align 8
%cmp = icmp eq i64 %0, %1
br i1 %cmp, label %if.then, label %if.end5
if.then: ; preds = %entry
- %p2 = getelementptr inbounds %struct.outer, %struct.outer* %o1, i64 0, i32 1
- %2 = load %struct.inner*, %struct.inner** %p2, align 8
- %p22 = getelementptr inbounds %struct.outer, %struct.outer* %o2, i64 0, i32 1
- %3 = load %struct.inner*, %struct.inner** %p22, align 8
- %cmp3 = icmp eq %struct.inner* %2, %3
+ %p2 = getelementptr inbounds %struct.outer, ptr %o1, i64 0, i32 1
+ %2 = load ptr, ptr %p2, align 8
+ %p22 = getelementptr inbounds %struct.outer, ptr %o2, i64 0, i32 1
+ %3 = load ptr, ptr %p22, align 8
+ %cmp3 = icmp eq ptr %2, %3
br label %if.end5
if.end5: ; preds = %if.then, %entry
@@ -41,10 +35,10 @@ if.end5: ; preds = %if.then, %entry
ret i1 %rez.0
}
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #1
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #1
attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind }
diff --git a/llvm/test/Transforms/MergeICmps/X86/last-block-produce-no-value.ll b/llvm/test/Transforms/MergeICmps/X86/last-block-produce-no-value.ll
index d63ef306fd89b..70fa7c3be1fc1 100644
--- a/llvm/test/Transforms/MergeICmps/X86/last-block-produce-no-value.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/last-block-produce-no-value.ll
@@ -11,17 +11,15 @@
define zeroext i1 @opeq1(
; CHECK-LABEL: @opeq1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; CHECK-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; CHECK-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; CHECK-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; CHECK: land.rhs.i:
-; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; CHECK-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; CHECK-NEXT: br i1 [[CMP3_I]], label [[LAND_RHS_I_2:%.*]], label [[OPEQ1_EXIT]]
; CHECK: land.rhs.i.2:
@@ -30,21 +28,19 @@ define zeroext i1 @opeq1(
; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ false, [[LAND_RHS_I]] ], [ [[CMP3_I]], [[LAND_RHS_I_2]] ]
; CHECK-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(12) %a,
- %S* nocapture readonly dereferenceable(12) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(12) %a,
+ ptr nocapture readonly dereferenceable(12) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3
br i1 %cmp3.i, label %land.rhs.i.2, label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/multiple-blocks-does-work.ll b/llvm/test/Transforms/MergeICmps/X86/multiple-blocks-does-work.ll
index 347209b7d8f4e..4a6e734c6a371 100644
--- a/llvm/test/Transforms/MergeICmps/X86/multiple-blocks-does-work.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/multiple-blocks-does-work.ll
@@ -9,68 +9,62 @@ declare void @foo(...)
define zeroext i1 @opeq1(
; X86-LABEL: @opeq1(
; X86-NEXT: entry:
-; X86-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; X86-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; X86-NEXT: call void (...) @foo()
; X86-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; X86: land.rhs.i:
-; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; X86-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; X86-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; X86-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; X86-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; X86-NEXT: call void (...) @foo()
; X86-NEXT: [[CMP2_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; X86-NEXT: br i1 [[CMP2_I]], label %"land.rhs.i.2+land.rhs.i.3", label [[OPEQ1_EXIT]]
; X86: "land.rhs.i.2+land.rhs.i.3":
-; X86-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 2
-; X86-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 2
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP4]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP5]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
+; X86-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 2
+; X86-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 2
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP4]], ptr [[TMP5]], i64 8)
; X86-NEXT: [[TMP6:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT]]
; X86: opeq1.exit:
; X86-NEXT: [[TMP7:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ false, [[LAND_RHS_I]] ], [ [[TMP6]], %"land.rhs.i.2+land.rhs.i.3" ]
; X86-NEXT: ret i1 [[TMP7]]
;
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
; Does other work.
call void (...) @foo()
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
; Does other work.
call void (...) @foo()
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/no-gep-other-work.ll b/llvm/test/Transforms/MergeICmps/X86/no-gep-other-work.ll
index 7038ae011bf5d..0cbc8dce5bd51 100644
--- a/llvm/test/Transforms/MergeICmps/X86/no-gep-other-work.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/no-gep-other-work.ll
@@ -8,11 +8,11 @@ target triple = "x86_64-grtev4-linux-gnu"
declare void @other_work()
-define i1 @test(i8* dereferenceable(2) %arg, i8* dereferenceable(2) %arg1) {
+define i1 @test(ptr dereferenceable(2) %arg, ptr dereferenceable(2) %arg1) {
; CHECK-LABEL: @test(
; CHECK-NEXT: "if+entry":
; CHECK-NEXT: call void @other_work()
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[ARG:%.*]], i8* [[ARG1:%.*]], i64 2)
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[ARG:%.*]], ptr [[ARG1:%.*]], i64 2)
; CHECK-NEXT: [[TMP0:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[JOIN:%.*]]
; CHECK: join:
@@ -20,16 +20,16 @@ define i1 @test(i8* dereferenceable(2) %arg, i8* dereferenceable(2) %arg1) {
;
entry:
call void @other_work()
- %arg.off = getelementptr inbounds i8, i8* %arg, i64 1
- %arg1.off = getelementptr inbounds i8, i8* %arg1, i64 1
- %arg.off.val = load i8, i8* %arg.off
- %arg1.off.val = load i8, i8* %arg1.off
+ %arg.off = getelementptr inbounds i8, ptr %arg, i64 1
+ %arg1.off = getelementptr inbounds i8, ptr %arg1, i64 1
+ %arg.off.val = load i8, ptr %arg.off
+ %arg1.off.val = load i8, ptr %arg1.off
%cmp.off = icmp eq i8 %arg.off.val, %arg1.off.val
br i1 %cmp.off, label %if, label %join
if:
- %arg.val = load i8, i8* %arg
- %arg1.val = load i8, i8* %arg1
+ %arg.val = load i8, ptr %arg
+ %arg1.val = load i8, ptr %arg1
%cmp = icmp eq i8 %arg.val, %arg1.val
br label %join
diff --git a/llvm/test/Transforms/MergeICmps/X86/pair-int32-int32.ll b/llvm/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
index bd0dbda1f7e3b..1ec8b20a89da1 100644
--- a/llvm/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
@@ -7,50 +7,42 @@
define zeroext i1 @opeq1(
; X86-LABEL: @opeq1(
; X86-NEXT: "entry+land.rhs.i":
-; X86-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
-; X86-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A:%.*]], ptr [[B:%.*]], i64 8)
+; X86-NEXT: [[TMP0:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT:%.*]]
; X86: opeq1.exit:
-; X86-NEXT: ret i1 [[TMP2]]
+; X86-NEXT: ret i1 [[TMP0]]
;
; X86-NOBUILTIN-LABEL: @opeq1(
; X86-NOBUILTIN-NEXT: entry:
-; X86-NOBUILTIN-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NOBUILTIN-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NOBUILTIN-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NOBUILTIN-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NOBUILTIN-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; X86-NOBUILTIN-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; X86-NOBUILTIN-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NOBUILTIN-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; X86-NOBUILTIN: land.rhs.i:
-; X86-NOBUILTIN-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; X86-NOBUILTIN-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; X86-NOBUILTIN-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; X86-NOBUILTIN-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; X86-NOBUILTIN-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; X86-NOBUILTIN-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; X86-NOBUILTIN-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; X86-NOBUILTIN-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; X86-NOBUILTIN-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; X86-NOBUILTIN-NEXT: br label [[OPEQ1_EXIT]]
; X86-NOBUILTIN: opeq1.exit:
; X86-NOBUILTIN-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; X86-NOBUILTIN-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(8) %a,
- %S* nocapture readonly dereferenceable(8) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
@@ -67,50 +59,42 @@ opeq1.exit:
define zeroext i1 @opeq1_inverse(
; X86-LABEL: @opeq1_inverse(
; X86-NEXT: "land.rhs.i+entry":
-; X86-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
-; X86-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A:%.*]], ptr [[B:%.*]], i64 8)
+; X86-NEXT: [[TMP0:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT:%.*]]
; X86: opeq1.exit:
-; X86-NEXT: ret i1 [[TMP2]]
+; X86-NEXT: ret i1 [[TMP0]]
;
; X86-NOBUILTIN-LABEL: @opeq1_inverse(
; X86-NOBUILTIN-NEXT: entry:
-; X86-NOBUILTIN-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 1
-; X86-NOBUILTIN-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NOBUILTIN-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 1
-; X86-NOBUILTIN-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NOBUILTIN-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A:%.*]], i64 0, i32 1
+; X86-NOBUILTIN-NEXT: [[TMP0:%.*]] = load i32, ptr [[FIRST_I]], align 4
+; X86-NOBUILTIN-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], ptr [[B:%.*]], i64 0, i32 1
+; X86-NOBUILTIN-NEXT: [[TMP1:%.*]] = load i32, ptr [[FIRST1_I]], align 4
; X86-NOBUILTIN-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NOBUILTIN-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; X86-NOBUILTIN: land.rhs.i:
-; X86-NOBUILTIN-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 0
-; X86-NOBUILTIN-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; X86-NOBUILTIN-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 0
-; X86-NOBUILTIN-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; X86-NOBUILTIN-NEXT: [[TMP2:%.*]] = load i32, ptr [[A]], align 4
+; X86-NOBUILTIN-NEXT: [[TMP3:%.*]] = load i32, ptr [[B]], align 4
; X86-NOBUILTIN-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; X86-NOBUILTIN-NEXT: br label [[OPEQ1_EXIT]]
; X86-NOBUILTIN: opeq1.exit:
; X86-NOBUILTIN-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; X86-NOBUILTIN-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(8) %a,
- %S* nocapture readonly dereferenceable(8) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %1 = load i32, i32* %first1.i, align 4
+ %first.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %0 = load i32, ptr %first.i, align 4
+ %first1.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %1 = load i32, ptr %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %3 = load i32, i32* %second2.i, align 4
+ %2 = load i32, ptr %a, align 4
+ %3 = load i32, ptr %b, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/pr36557.ll b/llvm/test/Transforms/MergeICmps/X86/pr36557.ll
index 965220474bf29..d31fb97c7664b 100644
--- a/llvm/test/Transforms/MergeICmps/X86/pr36557.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/pr36557.ll
@@ -15,66 +15,59 @@ $_ZN1D7compareI1BS1_EEbRKT_RKT0_PKcS9_S9_i = comdat any
@.str = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
; Function Attrs: uwtable
-define linkonce_odr dso_local zeroext i1 @_ZN1D7compareI1BS1_EEbRKT_RKT0_PKcS9_S9_i(%class.D* %this, %class.B* dereferenceable(8) %p1, %class.B* dereferenceable(8) %p2, i8*, i8*, i8*, i32) local_unnamed_addr #0 comdat align 2 {
+define linkonce_odr dso_local zeroext i1 @_ZN1D7compareI1BS1_EEbRKT_RKT0_PKcS9_S9_i(ptr %this, ptr dereferenceable(8) %p1, ptr dereferenceable(8) %p2, ptr, ptr, ptr, i32) local_unnamed_addr #0 comdat align 2 {
; X86-LABEL: @_ZN1D7compareI1BS1_EEbRKT_RKT0_PKcS9_S9_i(
; X86-NEXT: entry:
; X86-NEXT: [[REF_TMP:%.*]] = alloca [[CLASS_C:%.*]], align 1
-; X86-NEXT: [[C_I:%.*]] = getelementptr inbounds [[CLASS_B:%.*]], %class.B* [[P2:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP4:%.*]] = load i32, i32* [[C_I]], align 4
-; X86-NEXT: [[C2_I:%.*]] = getelementptr inbounds [[CLASS_B]], %class.B* [[P1:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP5:%.*]] = load i32, i32* [[C2_I]], align 4
+; X86-NEXT: [[TMP4:%.*]] = load i32, ptr [[P2:%.*]], align 4
+; X86-NEXT: [[TMP5:%.*]] = load i32, ptr [[P1:%.*]], align 4
; X86-NEXT: [[CMP_ENTRY:%.*]] = icmp eq i32 [[TMP4]], [[TMP5]]
; X86-NEXT: br i1 [[CMP_ENTRY]], label [[BB1:%.*]], label [[BB2:%.*]]
; X86: bb1:
-; X86-NEXT: [[M_I:%.*]] = getelementptr inbounds [[CLASS_B]], %class.B* [[P2]], i64 0, i32 1
-; X86-NEXT: [[TMP6:%.*]] = load i32, i32* [[M_I]], align 4
-; X86-NEXT: [[M3_I:%.*]] = getelementptr inbounds [[CLASS_B]], %class.B* [[P1]], i64 0, i32 1
-; X86-NEXT: [[TMP7:%.*]] = load i32, i32* [[M3_I]], align 4
+; X86-NEXT: [[M_I:%.*]] = getelementptr inbounds [[CLASS_B:%.*]], ptr [[P2]], i64 0, i32 1
+; X86-NEXT: [[TMP6:%.*]] = load i32, ptr [[M_I]], align 4
+; X86-NEXT: [[M3_I:%.*]] = getelementptr inbounds [[CLASS_B]], ptr [[P1]], i64 0, i32 1
+; X86-NEXT: [[TMP7:%.*]] = load i32, ptr [[M3_I]], align 4
; X86-NEXT: [[CMP1:%.*]] = icmp eq i32 [[TMP6]], [[TMP7]]
; X86-NEXT: br label [[BB2]]
; X86: bb2:
; X86-NEXT: [[TMP8:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP1]], [[BB1]] ]
-; X86-NEXT: [[FAILUREREPORTINGMODE:%.*]] = getelementptr inbounds [[CLASS_D:%.*]], %class.D* [[THIS:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP9:%.*]] = load i32, i32* [[FAILUREREPORTINGMODE]], align 4
+; X86-NEXT: [[TMP9:%.*]] = load i32, ptr [[THIS:%.*]], align 4
; X86-NEXT: [[COND:%.*]] = icmp eq i32 [[TMP9]], 0
; X86-NEXT: br i1 [[COND]], label [[BB3:%.*]], label [[SW_EPILOG:%.*]]
; X86: bb3:
; X86-NEXT: br i1 [[CMP_ENTRY]], label [[BB4:%.*]], label [[BB5:%.*]]
; X86: bb4:
-; X86-NEXT: [[M_I_I:%.*]] = getelementptr inbounds [[CLASS_B]], %class.B* [[P2]], i64 0, i32 1
-; X86-NEXT: [[TMP10:%.*]] = load i32, i32* [[M_I_I]], align 4
-; X86-NEXT: [[M3_I_I:%.*]] = getelementptr inbounds [[CLASS_B]], %class.B* [[P1]], i64 0, i32 1
-; X86-NEXT: [[TMP11:%.*]] = load i32, i32* [[M3_I_I]], align 4
+; X86-NEXT: [[M_I_I:%.*]] = getelementptr inbounds [[CLASS_B]], ptr [[P2]], i64 0, i32 1
+; X86-NEXT: [[TMP10:%.*]] = load i32, ptr [[M_I_I]], align 4
+; X86-NEXT: [[M3_I_I:%.*]] = getelementptr inbounds [[CLASS_B]], ptr [[P1]], i64 0, i32 1
+; X86-NEXT: [[TMP11:%.*]] = load i32, ptr [[M3_I_I]], align 4
; X86-NEXT: [[CMP4:%.*]] = icmp eq i32 [[TMP10]], [[TMP11]]
; X86-NEXT: br label [[BB5]]
; X86: bb5:
; X86-NEXT: [[TMP12:%.*]] = phi i1 [ false, [[BB3]] ], [ [[CMP4]], [[BB4]] ]
-; X86-NEXT: [[TMP13:%.*]] = getelementptr inbounds [[CLASS_C]], %class.C* [[REF_TMP]], i64 0, i32 0
; X86-NEXT: br label [[SW_EPILOG]]
; X86: sw.epilog:
; X86-NEXT: ret i1 [[TMP8]]
;
entry:
%ref.tmp = alloca %class.C, align 1
- %c.i = getelementptr inbounds %class.B, %class.B* %p2, i64 0, i32 0
- %4 = load i32, i32* %c.i, align 4
- %c2.i = getelementptr inbounds %class.B, %class.B* %p1, i64 0, i32 0
- %5 = load i32, i32* %c2.i, align 4
+ %4 = load i32, ptr %p2, align 4
+ %5 = load i32, ptr %p1, align 4
%cmp_entry = icmp eq i32 %4, %5
br i1 %cmp_entry, label %bb1, label %bb2
bb1: ; preds = %entry
- %m.i = getelementptr inbounds %class.B, %class.B* %p2, i64 0, i32 1
- %6 = load i32, i32* %m.i, align 4
- %m3.i = getelementptr inbounds %class.B, %class.B* %p1, i64 0, i32 1
- %7 = load i32, i32* %m3.i, align 4
+ %m.i = getelementptr inbounds %class.B, ptr %p2, i64 0, i32 1
+ %6 = load i32, ptr %m.i, align 4
+ %m3.i = getelementptr inbounds %class.B, ptr %p1, i64 0, i32 1
+ %7 = load i32, ptr %m3.i, align 4
%cmp1 = icmp eq i32 %6, %7
br label %bb2
bb2: ; preds = %entry, %bb1
%8 = phi i1 [ false, %entry ], [ %cmp1, %bb1 ]
- %failureReportingMode = getelementptr inbounds %class.D, %class.D* %this, i64 0, i32 0
- %9 = load i32, i32* %failureReportingMode, align 4
+ %9 = load i32, ptr %this, align 4
%cond = icmp eq i32 %9, 0
br i1 %cond, label %bb3, label %sw.epilog
@@ -82,16 +75,15 @@ bb3: ; preds = %bb2
br i1 %cmp_entry, label %bb4, label %bb5
bb4: ; preds = %bb3
- %m.i.i = getelementptr inbounds %class.B, %class.B* %p2, i64 0, i32 1
- %10 = load i32, i32* %m.i.i, align 4
- %m3.i.i = getelementptr inbounds %class.B, %class.B* %p1, i64 0, i32 1
- %11 = load i32, i32* %m3.i.i, align 4
+ %m.i.i = getelementptr inbounds %class.B, ptr %p2, i64 0, i32 1
+ %10 = load i32, ptr %m.i.i, align 4
+ %m3.i.i = getelementptr inbounds %class.B, ptr %p1, i64 0, i32 1
+ %11 = load i32, ptr %m3.i.i, align 4
%cmp4 = icmp eq i32 %10, %11
br label %bb5
bb5: ; preds = %bb3, %bb4
%12 = phi i1 [ false, %bb3 ], [ %cmp4, %bb4 ]
- %13 = getelementptr inbounds %class.C, %class.C* %ref.tmp, i64 0, i32 0
br label %sw.epilog
sw.epilog: ; preds = %bb2
diff --git a/llvm/test/Transforms/MergeICmps/X86/pr41917.ll b/llvm/test/Transforms/MergeICmps/X86/pr41917.ll
index a6a8e8d6f0533..d4fd34afc1452 100644
--- a/llvm/test/Transforms/MergeICmps/X86/pr41917.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/pr41917.ll
@@ -7,7 +7,7 @@ target triple = "i386-pc-windows-msvc19.11.0"
%class.a = type { i32, i32, i32, i32, i32 }
; Function Attrs: nounwind optsize
-define dso_local zeroext i1 @pr41917(%class.a* byval(%class.a) nocapture readonly align 4 %g, %class.a* byval(%class.a) nocapture readonly align 4 %p2) local_unnamed_addr #0 {
+define dso_local zeroext i1 @pr41917(ptr byval(%class.a) nocapture readonly align 4 %g, ptr byval(%class.a) nocapture readonly align 4 %p2) local_unnamed_addr #0 {
; CHECK-LABEL: @pr41917(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CALL:%.*]] = tail call zeroext i1 @f2() #[[ATTR3:[0-9]+]]
@@ -16,11 +16,9 @@ define dso_local zeroext i1 @pr41917(%class.a* byval(%class.a) nocapture readonl
; CHECK-NEXT: [[CALL1:%.*]] = tail call zeroext i1 @f2() #[[ATTR3]]
; CHECK-NEXT: br label %"land.end+land.rhs3"
; CHECK: "land.end+land.rhs3":
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[CLASS_A:%.*]], %class.a* [[G:%.*]], i32 0, i32 1
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[CLASS_A]], %class.a* [[P2:%.*]], i32 0, i32 1
-; CHECK-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; CHECK-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i32 8)
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[CLASS_A:%.*]], ptr [[G:%.*]], i32 0, i32 1
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[CLASS_A]], ptr [[P2:%.*]], i32 0, i32 1
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP0]], ptr [[TMP1]], i32 8)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[LAND_END6:%.*]]
; CHECK: land.end6:
@@ -35,18 +33,18 @@ land.rhs: ; preds = %entry
br label %land.end
land.end: ; preds = %land.rhs, %entry
- %c = getelementptr inbounds %class.a, %class.a* %g, i32 0, i32 1
- %0 = load i32, i32* %c, align 4, !tbaa !3
- %c2 = getelementptr inbounds %class.a, %class.a* %p2, i32 0, i32 1
- %1 = load i32, i32* %c2, align 4, !tbaa !3
+ %c = getelementptr inbounds %class.a, ptr %g, i32 0, i32 1
+ %0 = load i32, ptr %c, align 4, !tbaa !3
+ %c2 = getelementptr inbounds %class.a, ptr %p2, i32 0, i32 1
+ %1 = load i32, ptr %c2, align 4, !tbaa !3
%cmp = icmp eq i32 %0, %1
br i1 %cmp, label %land.rhs3, label %land.end6
land.rhs3: ; preds = %land.end
- %h = getelementptr inbounds %class.a, %class.a* %g, i32 0, i32 2
- %2 = load i32, i32* %h, align 4, !tbaa !8
- %h4 = getelementptr inbounds %class.a, %class.a* %p2, i32 0, i32 2
- %3 = load i32, i32* %h4, align 4, !tbaa !8
+ %h = getelementptr inbounds %class.a, ptr %g, i32 0, i32 2
+ %2 = load i32, ptr %h, align 4, !tbaa !8
+ %h4 = getelementptr inbounds %class.a, ptr %p2, i32 0, i32 2
+ %3 = load i32, ptr %h4, align 4, !tbaa !8
%cmp5 = icmp eq i32 %2, %3
br label %land.end6
diff --git a/llvm/test/Transforms/MergeICmps/X86/pr53959.ll b/llvm/test/Transforms/MergeICmps/X86/pr53959.ll
index 1721d530445f5..23fe181be04d7 100644
--- a/llvm/test/Transforms/MergeICmps/X86/pr53959.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/pr53959.ll
@@ -9,14 +9,12 @@ define i1 @d() {
; CHECK-LABEL: @d(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[G:%.*]] = alloca [8 x i64], align 16
-; CHECK-NEXT: [[IDX1:%.*]] = getelementptr inbounds [8 x i64], [8 x i64]* [[G]], i64 0, i64 0
-; CHECK-NEXT: [[V1:%.*]] = load i64, i64* [[IDX1]], align 8
-; CHECK-NEXT: [[IDX2:%.*]] = getelementptr inbounds [8 x i64], [8 x i64]* [[G]], i64 0, i64 0
-; CHECK-NEXT: [[V2:%.*]] = load i64, i64* [[IDX2]], align 8
+; CHECK-NEXT: [[V1:%.*]] = load i64, ptr [[G]], align 8
+; CHECK-NEXT: [[V2:%.*]] = load i64, ptr [[G]], align 8
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[V1]], [[V2]]
; CHECK-NEXT: br label [[SPLIT:%.*]]
; CHECK: split:
-; CHECK-NEXT: [[X:%.*]] = load volatile i32, i32* @c, align 4
+; CHECK-NEXT: [[X:%.*]] = load volatile i32, ptr @c, align 4
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[EXIT:%.*]]
; CHECK: if:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
@@ -27,15 +25,13 @@ define i1 @d() {
;
entry:
%g = alloca [8 x i64], align 16
- %idx1 = getelementptr inbounds [8 x i64], [8 x i64]* %g, i64 0, i64 0
- %v1 = load i64, i64* %idx1, align 8
- %idx2 = getelementptr inbounds [8 x i64], [8 x i64]* %g, i64 0, i64 0
- %v2 = load i64, i64* %idx2, align 8
+ %v1 = load i64, ptr %g, align 8
+ %v2 = load i64, ptr %g, align 8
%cmp = icmp eq i64 %v1, %v2
br label %split
split:
- %x = load volatile i32, i32* @c, align 4
+ %x = load volatile i32, ptr @c, align 4
br i1 %cmp, label %if, label %exit
if:
diff --git a/llvm/test/Transforms/MergeICmps/X86/split-block-does-work.ll b/llvm/test/Transforms/MergeICmps/X86/split-block-does-work.ll
index d317cbe3ba38b..c53d86d76ff3b 100644
--- a/llvm/test/Transforms/MergeICmps/X86/split-block-does-work.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/split-block-does-work.ll
@@ -10,50 +10,44 @@ define zeroext i1 @opeq1(
; X86-LABEL: @opeq1(
; X86-NEXT: "entry+land.rhs.i+land.rhs.i.2+land.rhs.i.3":
; X86-NEXT: call void (...) @foo() #[[ATTR2:[0-9]+]]
-; X86-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 16)
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A:%.*]], ptr [[B:%.*]], i64 16)
; X86-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT:%.*]]
; X86: opeq1.exit:
; X86-NEXT: ret i1 [[TMP2]]
;
; Make sure this call is moved to the beginning of the entry block.
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
; Does other work.
call void (...) @foo() inaccessiblememonly
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
@@ -67,32 +61,31 @@ opeq1.exit:
define zeroext i1 @opeq1_discontiguous(
; X86-LABEL: @opeq1_discontiguous(
; X86-NEXT: entry:
-; X86-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 1
-; X86-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A:%.*]], i64 0, i32 1
+; X86-NEXT: [[TMP0:%.*]] = load i32, ptr [[FIRST_I]], align 4
+; X86-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; X86-NEXT: call void (...) @foo() #[[ATTR2]]
; X86-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; X86: land.rhs.i:
-; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 2
-; X86-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; X86-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 2
+; X86-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; X86-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; X86-NEXT: [[CMP2_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; X86-NEXT: br i1 [[CMP2_I]], label [[LAND_RHS_I_2:%.*]], label [[OPEQ1_EXIT]]
; X86: land.rhs.i.2:
-; X86-NEXT: [[THIRD_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 2
-; X86-NEXT: [[TMP4:%.*]] = load i32, i32* [[THIRD_I]], align 4
-; X86-NEXT: [[THIRD2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 3
-; X86-NEXT: [[TMP5:%.*]] = load i32, i32* [[THIRD2_I]], align 4
+; X86-NEXT: [[THIRD_I:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 2
+; X86-NEXT: [[TMP4:%.*]] = load i32, ptr [[THIRD_I]], align 4
+; X86-NEXT: [[THIRD2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 3
+; X86-NEXT: [[TMP5:%.*]] = load i32, ptr [[THIRD2_I]], align 4
; X86-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP4]], [[TMP5]]
; X86-NEXT: br i1 [[CMP3_I]], label [[LAND_RHS_I_3:%.*]], label [[OPEQ1_EXIT]]
; X86: land.rhs.i.3:
-; X86-NEXT: [[FOURTH_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; X86-NEXT: [[TMP6:%.*]] = load i32, i32* [[FOURTH_I]], align 4
-; X86-NEXT: [[FOURTH2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 3
-; X86-NEXT: [[TMP7:%.*]] = load i32, i32* [[FOURTH2_I]], align 4
+; X86-NEXT: [[FOURTH_I:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 1
+; X86-NEXT: [[TMP6:%.*]] = load i32, ptr [[FOURTH_I]], align 4
+; X86-NEXT: [[FOURTH2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 3
+; X86-NEXT: [[TMP7:%.*]] = load i32, ptr [[FOURTH2_I]], align 4
; X86-NEXT: [[CMP4_I:%.*]] = icmp eq i32 [[TMP6]], [[TMP7]]
; X86-NEXT: br label [[OPEQ1_EXIT]]
; X86: opeq1.exit:
@@ -100,39 +93,38 @@ define zeroext i1 @opeq1_discontiguous(
; X86-NEXT: ret i1 [[TMP8]]
;
; Make sure this call is moved in the entry block.
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %first.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %0 = load i32, ptr %first.i, align 4
+ %1 = load i32, ptr %b, align 4
; Does other work.
call void (...) @foo() inaccessiblememonly
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
@@ -146,49 +138,43 @@ define zeroext i1 @opeq1_call_before_loads(
; X86-LABEL: @opeq1_call_before_loads(
; X86-NEXT: "entry+land.rhs.i+land.rhs.i.2+land.rhs.i.3":
; X86-NEXT: call void (...) @foo()
-; X86-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP0]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP1]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 16)
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A:%.*]], ptr [[B:%.*]], i64 16)
; X86-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT:%.*]]
; X86: opeq1.exit:
; X86-NEXT: ret i1 [[TMP2]]
;
; Make sure this call is moved to the beginning of the entry block.
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
call void (...) @foo()
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
@@ -201,19 +187,15 @@ opeq1.exit:
define zeroext i1 @opeq1_call_after_loads(
; X86-LABEL: @opeq1_call_after_loads(
; X86-NEXT: entry:
-; X86-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; X86-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; X86-NEXT: call void (...) @foo()
; X86-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NEXT: br i1 [[CMP_I]], label %"land.rhs.i+land.rhs.i.2+land.rhs.i.3", label [[OPEQ1_EXIT:%.*]]
; X86: "land.rhs.i+land.rhs.i.2+land.rhs.i.3":
-; X86-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; X86-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; X86-NEXT: [[CSTR:%.*]] = bitcast i32* [[TMP2]] to i8*
-; X86-NEXT: [[CSTR1:%.*]] = bitcast i32* [[TMP3]] to i8*
-; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 12)
+; X86-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[S]], ptr [[A]], i64 0, i32 1
+; X86-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; X86-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP2]], ptr [[TMP3]], i64 12)
; X86-NEXT: [[TMP4:%.*]] = icmp eq i32 [[MEMCMP]], 0
; X86-NEXT: br label [[OPEQ1_EXIT]]
; X86: opeq1.exit:
@@ -221,38 +203,36 @@ define zeroext i1 @opeq1_call_after_loads(
; X86-NEXT: ret i1 [[TMP5]]
;
; Make sure this call is moved to the beginning of the entry block.
- %S* nocapture readonly dereferenceable(16) %a,
- %S* nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
+ ptr nocapture readonly dereferenceable(16) %a,
+ ptr nocapture readonly dereferenceable(16) %b) local_unnamed_addr nofree nosync {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
call void (...) @foo()
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp2.i = icmp eq i32 %2, %3
br i1 %cmp2.i, label %land.rhs.i.2, label %opeq1.exit
land.rhs.i.2:
- %third.i = getelementptr inbounds %S, %S* %a, i64 0, i32 2
- %4 = load i32, i32* %third.i, align 4
- %third2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 2
- %5 = load i32, i32* %third2.i, align 4
+ %third.i = getelementptr inbounds %S, ptr %a, i64 0, i32 2
+ %4 = load i32, ptr %third.i, align 4
+ %third2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 2
+ %5 = load i32, ptr %third2.i, align 4
%cmp3.i = icmp eq i32 %4, %5
br i1 %cmp3.i, label %land.rhs.i.3, label %opeq1.exit
land.rhs.i.3:
- %fourth.i = getelementptr inbounds %S, %S* %a, i64 0, i32 3
- %6 = load i32, i32* %fourth.i, align 4
- %fourth2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 3
- %7 = load i32, i32* %fourth2.i, align 4
+ %fourth.i = getelementptr inbounds %S, ptr %a, i64 0, i32 3
+ %6 = load i32, ptr %fourth.i, align 4
+ %fourth2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 3
+ %7 = load i32, ptr %fourth2.i, align 4
%cmp4.i = icmp eq i32 %6, %7
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/tuple-four-int8.ll b/llvm/test/Transforms/MergeICmps/X86/tuple-four-int8.ll
index a245e01551999..32a38ee16c945 100644
--- a/llvm/test/Transforms/MergeICmps/X86/tuple-four-int8.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/tuple-four-int8.ll
@@ -24,53 +24,49 @@ define zeroext i1 @opeq(
; These 2 instructions are split. Then we can merge 3 bytes, instead of 2.
; CHECK: br label [[LAND_ELEM0:%.*]]
; CHECK: land.elem1:
-; CHECK-NEXT: [[A_ELEM1_ADDR:%.*]] = getelementptr inbounds i8, i8* %a.base, i64 1
-; CHECK-NEXT: [[B_ELEM1_ADDR:%.*]] = getelementptr inbounds i8, i8* %b.base, i64 1
-; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[A_ELEM1_ADDR]], i8* [[B_ELEM1_ADDR]], i64 3)
+; CHECK-NEXT: [[A_ELEM1_ADDR:%.*]] = getelementptr inbounds i8, ptr %a.base, i64 1
+; CHECK-NEXT: [[B_ELEM1_ADDR:%.*]] = getelementptr inbounds i8, ptr %b.base, i64 1
+; CHECK-NEXT: [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[A_ELEM1_ADDR]], ptr [[B_ELEM1_ADDR]], i64 3)
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[MEMCMP]], 0
; CHECK-NEXT: br label [[OPEQ_EXIT:%.*]]
; CHECK: land.elem0:
-; CHECK: [[A_BASE:%.*]] = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* [[A:%.*]], i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
-; CHECK: [[B_BASE:%.*]] = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* [[B:%.*]], i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
-; CHECK-NEXT: [[TMP3:%.*]] = load i8, i8* [[A_BASE]], align 1
-; CHECK-NEXT: [[TMP4:%.*]] = load i8, i8* [[B_BASE]], align 1
+; CHECK-NEXT: [[TMP3:%.*]] = load i8, ptr [[A:%.*]], align 1
+; CHECK-NEXT: [[TMP4:%.*]] = load i8, ptr [[B:%.*]], align 1
; CHECK-NEXT: [[CMP_ELEM0:%.*]] = icmp eq i8 [[TMP3]], [[TMP4]]
; CHECK-NEXT: br i1 [[CMP_ELEM0]], label [[LAND_ELEM1:%.*]], label [[OPEQ_EXIT]]
; CHECK: opeq.exit:
; CHECK-NEXT: [[TMP5:%.*]] = phi i1 [ [[CMP_ELEM0]], [[LAND_ELEM0]] ], [ [[TMP2]], [[LAND_ELEM1]] ]
; CHECK-NEXT: ret i1 [[TMP5]]
;
- %"class.std::tuple"* nocapture readonly dereferenceable(4) %a,
- %"class.std::tuple"* nocapture readonly dereferenceable(4) %b) local_unnamed_addr #1 {
+ ptr nocapture readonly dereferenceable(4) %a,
+ ptr nocapture readonly dereferenceable(4) %b) local_unnamed_addr #1 {
entry:
- %a.base = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* %a, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
- %a.elem3.addr = getelementptr inbounds i8, i8* %a.base, i64 3
- %0 = load i8, i8* %a.elem3.addr, align 1
- %b.base = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* %b, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
- %b.elem3.addr = getelementptr inbounds i8, i8* %b.base, i64 3
- %1 = load i8, i8* %b.elem3.addr, align 1
+ %a.elem3.addr = getelementptr inbounds i8, ptr %a, i64 3
+ %0 = load i8, ptr %a.elem3.addr, align 1
+ %b.elem3.addr = getelementptr inbounds i8, ptr %b, i64 3
+ %1 = load i8, ptr %b.elem3.addr, align 1
%cmp.elem3 = icmp eq i8 %0, %1
br i1 %cmp.elem3, label %land.elem2, label %opeq.exit
land.elem2:
- %a.elem2.addr = getelementptr inbounds i8, i8* %a.base, i64 2
- %2 = load i8, i8* %a.elem2.addr, align 1
- %b.elem2.addr = getelementptr inbounds i8, i8* %b.base, i64 2
- %3 = load i8, i8* %b.elem2.addr, align 1
+ %a.elem2.addr = getelementptr inbounds i8, ptr %a, i64 2
+ %2 = load i8, ptr %a.elem2.addr, align 1
+ %b.elem2.addr = getelementptr inbounds i8, ptr %b, i64 2
+ %3 = load i8, ptr %b.elem2.addr, align 1
%cmp.elem2 = icmp eq i8 %2, %3
br i1 %cmp.elem2, label %land.elem1, label %opeq.exit
land.elem1:
- %a.elem1.addr = getelementptr inbounds i8, i8* %a.base, i64 1
- %4 = load i8, i8* %a.elem1.addr, align 1
- %b.elem1.addr = getelementptr inbounds i8, i8* %b.base, i64 1
- %5 = load i8, i8* %b.elem1.addr, align 1
+ %a.elem1.addr = getelementptr inbounds i8, ptr %a, i64 1
+ %4 = load i8, ptr %a.elem1.addr, align 1
+ %b.elem1.addr = getelementptr inbounds i8, ptr %b, i64 1
+ %5 = load i8, ptr %b.elem1.addr, align 1
%cmp.elem1 = icmp eq i8 %4, %5
br i1 %cmp.elem1, label %land.elem0, label %opeq.exit
land.elem0:
- %6 = load i8, i8* %a.base, align 1
- %7 = load i8, i8* %b.base, align 1
+ %6 = load i8, ptr %a, align 1
+ %7 = load i8, ptr %b, align 1
%cmp.elem0 = icmp eq i8 %6, %7
br label %opeq.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/two-complex-bb.ll b/llvm/test/Transforms/MergeICmps/X86/two-complex-bb.ll
index be113601ef376..c9b3ccc890e33 100644
--- a/llvm/test/Transforms/MergeICmps/X86/two-complex-bb.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/two-complex-bb.ll
@@ -7,18 +7,16 @@
define zeroext i1 @twocomplexblocks(
; X86-LABEL: @twocomplexblocks(
; X86-NEXT: entry:
-; X86-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; X86-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; X86-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; X86-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; X86-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; X86-NEXT: [[EXTRAWORK:%.*]] = add i32 [[TMP0]], [[TMP1]]
; X86-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; X86-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; X86: land.rhs.i:
-; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; X86-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; X86-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; X86-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; X86-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; X86-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; X86-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; X86-NEXT: [[EXTRAWORK2:%.*]] = add i32 [[TMP2]], [[TMP3]]
; X86-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; X86-NEXT: br label [[OPEQ1_EXIT]]
@@ -26,24 +24,22 @@ define zeroext i1 @twocomplexblocks(
; X86-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; X86-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(8) %a,
- %S* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry:
; This is a complex BCE Basic Block.
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%extrawork = add i32 %0, %1
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
; This is a complex BCE Basic Block.
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%extrawork2 = add i32 %2, %3
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/X86/volatile.ll b/llvm/test/Transforms/MergeICmps/X86/volatile.ll
index f6084c49e771b..08d7b05e710f1 100644
--- a/llvm/test/Transforms/MergeICmps/X86/volatile.ll
+++ b/llvm/test/Transforms/MergeICmps/X86/volatile.ll
@@ -6,38 +6,34 @@
define zeroext i1 @opeq(
; CHECK-LABEL: @opeq(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds [[S:%.*]], %S* [[A:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; CHECK-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds [[S]], %S* [[B:%.*]], i64 0, i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; CHECK-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; CHECK-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; CHECK: land.rhs.i:
-; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S]], %S* [[A]], i64 0, i32 1
-; CHECK-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[SECOND_I]], align 4
-; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], %S* [[B]], i64 0, i32 1
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; CHECK-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds [[S:%.*]], ptr [[A]], i64 0, i32 1
+; CHECK-NEXT: [[TMP2:%.*]] = load volatile i32, ptr [[SECOND_I]], align 4
+; CHECK-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds [[S]], ptr [[B]], i64 0, i32 1
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; CHECK-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; CHECK-NEXT: br label [[OPEQ1_EXIT]]
; CHECK: opeq1.exit:
; CHECK-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; CHECK-NEXT: ret i1 [[TMP4]]
;
- %S* nocapture readonly dereferenceable(8) %a,
- %S* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %S, %S* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %S, %S* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %S, %S* %a, i64 0, i32 1
- %2 = load volatile i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %S, %S* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %S, ptr %a, i64 0, i32 1
+ %2 = load volatile i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %S, ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
diff --git a/llvm/test/Transforms/MergeICmps/pair-int32-int32.ll b/llvm/test/Transforms/MergeICmps/pair-int32-int32.ll
index 38caaba860a4f..a8069fb52020b 100644
--- a/llvm/test/Transforms/MergeICmps/pair-int32-int32.ll
+++ b/llvm/test/Transforms/MergeICmps/pair-int32-int32.ll
@@ -6,38 +6,34 @@
define zeroext i1 @opeq1(
; NOEXPANSION-LABEL: @opeq1(
; NOEXPANSION-NEXT: entry:
-; NOEXPANSION-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 0
-; NOEXPANSION-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; NOEXPANSION-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 0
-; NOEXPANSION-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; NOEXPANSION-NEXT: [[TMP0:%.*]] = load i32, ptr [[A:%.*]], align 4
+; NOEXPANSION-NEXT: [[TMP1:%.*]] = load i32, ptr [[B:%.*]], align 4
; NOEXPANSION-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; NOEXPANSION-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; NOEXPANSION: land.rhs.i:
-; NOEXPANSION-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A]], i64 0, i32 1
-; NOEXPANSION-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; NOEXPANSION-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B]], i64 0, i32 1
-; NOEXPANSION-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; NOEXPANSION-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", ptr [[A]], i64 0, i32 1
+; NOEXPANSION-NEXT: [[TMP2:%.*]] = load i32, ptr [[SECOND_I]], align 4
+; NOEXPANSION-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", ptr [[B]], i64 0, i32 1
+; NOEXPANSION-NEXT: [[TMP3:%.*]] = load i32, ptr [[SECOND2_I]], align 4
; NOEXPANSION-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; NOEXPANSION-NEXT: br label [[OPEQ1_EXIT]]
; NOEXPANSION: opeq1.exit:
; NOEXPANSION-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; NOEXPANSION-NEXT: ret i1 [[TMP4]]
;
- %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
- %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
- %1 = load i32, i32* %first1.i, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
- %3 = load i32, i32* %second2.i, align 4
+ %second.i = getelementptr inbounds %"struct.std::pair", ptr %a, i64 0, i32 1
+ %2 = load i32, ptr %second.i, align 4
+ %second2.i = getelementptr inbounds %"struct.std::pair", ptr %b, i64 0, i32 1
+ %3 = load i32, ptr %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
@@ -50,38 +46,34 @@ opeq1.exit:
define zeroext i1 @opeq1_inverse(
; NOEXPANSION-LABEL: @opeq1_inverse(
; NOEXPANSION-NEXT: entry:
-; NOEXPANSION-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 1
-; NOEXPANSION-NEXT: [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
-; NOEXPANSION-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 1
-; NOEXPANSION-NEXT: [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; NOEXPANSION-NEXT: [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", ptr [[A:%.*]], i64 0, i32 1
+; NOEXPANSION-NEXT: [[TMP0:%.*]] = load i32, ptr [[FIRST_I]], align 4
+; NOEXPANSION-NEXT: [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", ptr [[B:%.*]], i64 0, i32 1
+; NOEXPANSION-NEXT: [[TMP1:%.*]] = load i32, ptr [[FIRST1_I]], align 4
; NOEXPANSION-NEXT: [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
; NOEXPANSION-NEXT: br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
; NOEXPANSION: land.rhs.i:
-; NOEXPANSION-NEXT: [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A]], i64 0, i32 0
-; NOEXPANSION-NEXT: [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
-; NOEXPANSION-NEXT: [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B]], i64 0, i32 0
-; NOEXPANSION-NEXT: [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; NOEXPANSION-NEXT: [[TMP2:%.*]] = load i32, ptr [[A]], align 4
+; NOEXPANSION-NEXT: [[TMP3:%.*]] = load i32, ptr [[B]], align 4
; NOEXPANSION-NEXT: [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
; NOEXPANSION-NEXT: br label [[OPEQ1_EXIT]]
; NOEXPANSION: opeq1.exit:
; NOEXPANSION-NEXT: [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
; NOEXPANSION-NEXT: ret i1 [[TMP4]]
;
- %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
- %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+ ptr nocapture readonly dereferenceable(8) %a,
+ ptr nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry:
- %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
- %0 = load i32, i32* %first.i, align 4
- %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
- %1 = load i32, i32* %first1.i, align 4
+ %first.i = getelementptr inbounds %"struct.std::pair", ptr %a, i64 0, i32 1
+ %0 = load i32, ptr %first.i, align 4
+ %first1.i = getelementptr inbounds %"struct.std::pair", ptr %b, i64 0, i32 1
+ %1 = load i32, ptr %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i:
- %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
- %2 = load i32, i32* %second.i, align 4
- %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
- %3 = load i32, i32* %second2.i, align 4
+ %2 = load i32, ptr %a, align 4
+ %3 = load i32, ptr %b, align 4
%cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit
More information about the llvm-commits
mailing list