[llvm] d17f4f2 - HardwareLoops: Convert tests to opaque pointers
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Mon Nov 28 06:08:39 PST 2022
Author: Matt Arsenault
Date: 2022-11-28T09:08:31-05:00
New Revision: d17f4f267d9b084d9cacaf7e2f135dab370cd6fe
URL: https://github.com/llvm/llvm-project/commit/d17f4f267d9b084d9cacaf7e2f135dab370cd6fe
DIFF: https://github.com/llvm/llvm-project/commit/d17f4f267d9b084d9cacaf7e2f135dab370cd6fe.diff
LOG: HardwareLoops: Convert tests to opaque pointers
Added:
Modified:
llvm/test/Transforms/HardwareLoops/ARM/calls-codegen.ll
llvm/test/Transforms/HardwareLoops/ARM/calls.ll
llvm/test/Transforms/HardwareLoops/ARM/counter.ll
llvm/test/Transforms/HardwareLoops/ARM/do-rem.ll
llvm/test/Transforms/HardwareLoops/ARM/fp-emulation.ll
llvm/test/Transforms/HardwareLoops/ARM/simple-do.ll
llvm/test/Transforms/HardwareLoops/ARM/structure.ll
llvm/test/Transforms/HardwareLoops/loop-guards.ll
llvm/test/Transforms/HardwareLoops/scalar-while.ll
llvm/test/Transforms/HardwareLoops/sibling-loops.ll
llvm/test/Transforms/HardwareLoops/unconditional-latch.ll
llvm/test/Transforms/HardwareLoops/unscevable.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/calls-codegen.ll b/llvm/test/Transforms/HardwareLoops/ARM/calls-codegen.ll
index 37050d57d9c3e..0144a8d9f7a0d 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/calls-codegen.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/calls-codegen.ll
@@ -12,16 +12,16 @@
; CHECK-NOT: b .
; CHECK: @ %exit
-define i32 @test_target_specific(i32* %a, i32* %b) {
+define i32 @test_target_specific(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%acc = phi i32 [ 0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr i32, i32* %a, i32 %count
- %addr.b = getelementptr i32, i32* %b, i32 %count
- %load.a = load i32, i32* %addr.a
- %load.b = load i32, i32* %addr.b
+ %addr.a = getelementptr i32, ptr %a, i32 %count
+ %addr.b = getelementptr i32, ptr %b, i32 %count
+ %load.a = load i32, ptr %addr.a
+ %load.b = load i32, ptr %addr.b
%res = call i32 @llvm.arm.smlad(i32 %load.a, i32 %load.b, i32 %acc)
%count.next = add nuw i32 %count, 2
%cmp = icmp ne i32 %count.next, 100
@@ -40,14 +40,14 @@ exit:
; CHECK-NOT: b .
; CHECK: @ %exit
-define float @test_fabs(float* %a) {
+define float @test_fabs(ptr %a) {
entry:
br label %loop
loop:
%acc = phi float [ 0.0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr float, float* %a, i32 %count
- %load.a = load float, float* %addr.a
+ %addr.a = getelementptr float, ptr %a, i32 %count
+ %load.a = load float, ptr %addr.a
%abs = call float @llvm.fabs.f32(float %load.a)
%res = fadd float %abs, %acc
%count.next = add nuw i32 %count, 1
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/calls.ll b/llvm/test/Transforms/HardwareLoops/ARM/calls.ll
index 80daff02c5665..38c14b261a922 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/calls.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/calls.ll
@@ -22,7 +22,7 @@ while.body.preheader:
while.body:
%i.08 = phi i32 [ %inc1, %while.body ], [ 0, %while.body.preheader ]
%res.07 = phi i32 [ %add, %while.body ], [ 0, %while.body.preheader ]
- %call = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)() #2
+ %call = tail call i32 @bar() #2
%add = add nsw i32 %call, %res.07
%inc1 = add nuw i32 %i.08, 1
%exitcond = icmp eq i32 %inc1, %n
@@ -43,16 +43,16 @@ while.end:
; CHECK: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK: br i1 [[CMP]], label %loop, label %exit
-define i32 @test_target_specific(i32* %a, i32* %b) {
+define i32 @test_target_specific(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%acc = phi i32 [ 0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr i32, i32* %a, i32 %count
- %addr.b = getelementptr i32, i32* %b, i32 %count
- %load.a = load i32, i32* %addr.a
- %load.b = load i32, i32* %addr.b
+ %addr.a = getelementptr i32, ptr %a, i32 %count
+ %addr.b = getelementptr i32, ptr %b, i32 %count
+ %load.a = load i32, ptr %addr.a
+ %load.b = load i32, ptr %addr.b
%res = call i32 @llvm.arm.smlad(i32 %load.a, i32 %load.b, i32 %acc)
%count.next = add nuw i32 %count, 2
%cmp = icmp ne i32 %count.next, 100
@@ -66,16 +66,16 @@ exit:
; CHECK-MVE-NOT: call i32 @llvm.start.loop.iterations
; CHECK-FP: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define void @test_fabs_f16(half* %a, half* %b) {
+define void @test_fabs_f16(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr half, half* %a, i32 %count
- %load.a = load half, half* %addr.a
+ %addr.a = getelementptr half, ptr %a, i32 %count
+ %load.a = load half, ptr %addr.a
%abs = call half @llvm.fabs.f16(half %load.a)
- %addr.b = getelementptr half, half* %b, i32 %count
- store half %abs, half *%addr.b
+ %addr.b = getelementptr half, ptr %b, i32 %count
+ store half %abs, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -89,14 +89,14 @@ exit:
; CHECK-FP: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define float @test_fabs(float* %a) {
+define float @test_fabs(ptr %a) {
entry:
br label %loop
loop:
%acc = phi float [ 0.0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr float, float* %a, i32 %count
- %load.a = load float, float* %addr.a
+ %addr.a = getelementptr float, ptr %a, i32 %count
+ %load.a = load float, ptr %addr.a
%abs = call float @llvm.fabs.f32(float %load.a)
%res = fadd float %abs, %acc
%count.next = add nuw i32 %count, 1
@@ -112,16 +112,16 @@ exit:
; CHECK-FP-NOT: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-FP64: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP-NOT: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define void @test_fabs_64(double* %a, double* %b) {
+define void @test_fabs_64(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr double, double* %a, i32 %count
- %load.a = load double, double* %addr.a
+ %addr.a = getelementptr double, ptr %a, i32 %count
+ %load.a = load double, ptr %addr.a
%abs = call double @llvm.fabs.f64(double %load.a)
- %addr.b = getelementptr double, double* %b, i32 %count
- store double %abs, double *%addr.b
+ %addr.b = getelementptr double, ptr %b, i32 %count
+ store double %abs, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -136,14 +136,14 @@ exit:
; CHECK-MVEFP: [[LOOP_DEC]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[COUNT]], i32 1)
; CHECK-MVEFP: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-MVEFP: br i1 [[CMP]], label %loop, label %exit
-define <4 x float> @test_fabs_vec(<4 x float>* %a) {
+define <4 x float> @test_fabs_vec(ptr %a) {
entry:
br label %loop
loop:
%acc = phi <4 x float> [ zeroinitializer, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr <4 x float>, <4 x float>* %a, i32 %count
- %load.a = load <4 x float>, <4 x float>* %addr.a
+ %addr.a = getelementptr <4 x float>, ptr %a, i32 %count
+ %load.a = load <4 x float>, ptr %addr.a
%abs = call <4 x float> @llvm.fabs.v4f32(<4 x float> %load.a)
%res = fadd <4 x float> %abs, %acc
%count.next = add nuw i32 %count, 1
@@ -156,14 +156,14 @@ exit:
; CHECK-LABEL: test_log
; CHECK-NOT: call i32 @llvm.start.loop.iterations
; CHECK-NOT: llvm.loop.decrement
-define float @test_log(float* %a) {
+define float @test_log(ptr %a) {
entry:
br label %loop
loop:
%acc = phi float [ 0.0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr float, float* %a, i32 %count
- %load.a = load float, float* %addr.a
+ %addr.a = getelementptr float, ptr %a, i32 %count
+ %load.a = load float, ptr %addr.a
%abs = call float @llvm.log.f32(float %load.a)
%res = fadd float %abs, %acc
%count.next = add nuw i32 %count, 1
@@ -179,16 +179,16 @@ exit:
; CHECK-FP: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-FP64: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define void @test_sqrt_16(half* %a, half* %b) {
+define void @test_sqrt_16(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr half, half* %a, i32 %count
- %load.a = load half, half* %addr.a
+ %addr.a = getelementptr half, ptr %a, i32 %count
+ %load.a = load half, ptr %addr.a
%sqrt = call half @llvm.sqrt.f16(half %load.a)
- %addr.b = getelementptr half, half* %b, i32 %count
- store half %sqrt, half *%addr.b
+ %addr.b = getelementptr half, ptr %b, i32 %count
+ store half %sqrt, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -204,16 +204,16 @@ exit:
; CHECK-MVEFP: [[LOOP_DEC]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[COUNT]], i32 1)
; CHECK-MVEFP: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-MVEFP: br i1 [[CMP]], label %loop, label %exit
-define void @test_sqrt(float* %a, float* %b) {
+define void @test_sqrt(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr float, float* %a, i32 %count
- %load.a = load float, float* %addr.a
+ %addr.a = getelementptr float, ptr %a, i32 %count
+ %load.a = load float, ptr %addr.a
%sqrt = call float @llvm.sqrt.f32(float %load.a)
- %addr.b = getelementptr float, float* %b, i32 %count
- store float %sqrt, float* %addr.b
+ %addr.b = getelementptr float, ptr %b, i32 %count
+ store float %sqrt, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -227,16 +227,16 @@ exit:
; CHECK-FP-NOT: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP-NOT: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-FP64: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define void @test_sqrt_64(double* %a, double* %b) {
+define void @test_sqrt_64(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr double, double* %a, i32 %count
- %load.a = load double, double* %addr.a
+ %addr.a = getelementptr double, ptr %a, i32 %count
+ %load.a = load double, ptr %addr.a
%sqrt = call double @llvm.sqrt.f64(double %load.a)
- %addr.b = getelementptr double, double* %b, i32 %count
- store double %sqrt, double *%addr.b
+ %addr.b = getelementptr double, ptr %b, i32 %count
+ store double %sqrt, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -249,16 +249,16 @@ exit:
; CHECK-MVE-NOT: call i32 @llvm.start.loop.iterations
; CHECK-FP: call i32 @llvm.start.loop.iterations.i32(i32 100)
; CHECK-MVEFP: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define void @test_sqrt_vec(<4 x float>* %a, <4 x float>* %b) {
+define void @test_sqrt_vec(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr <4 x float>, <4 x float>* %a, i32 %count
- %load.a = load <4 x float>, <4 x float>* %addr.a
+ %addr.a = getelementptr <4 x float>, ptr %a, i32 %count
+ %load.a = load <4 x float>, ptr %addr.a
%sqrt = call <4 x float> @llvm.sqrt.v4f32(<4 x float> %load.a)
- %addr.b = getelementptr <4 x float>, <4 x float>* %b, i32 %count
- store <4 x float> %sqrt, <4 x float>* %addr.b
+ %addr.b = getelementptr <4 x float>, ptr %b, i32 %count
+ store <4 x float> %sqrt, ptr %addr.b
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -268,16 +268,16 @@ exit:
; CHECK-LABEL: test_overflow
; CHECK: call i32 @llvm.start.loop.iterations
-define i32 @test_overflow(i32* %a, i32* %b) {
+define i32 @test_overflow(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%acc = phi i32 [ 0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr i32, i32* %a, i32 %count
- %addr.b = getelementptr i32, i32* %b, i32 %count
- %load.a = load i32, i32* %addr.a
- %load.b = load i32, i32* %addr.b
+ %addr.a = getelementptr i32, ptr %a, i32 %count
+ %addr.b = getelementptr i32, ptr %b, i32 %count
+ %load.a = load i32, ptr %addr.a
+ %load.b = load i32, ptr %addr.b
%sadd = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %load.a, i32 %load.b)
%res = extractvalue {i32, i1} %sadd, 0
%count.next = add nuw i32 %count, 1
@@ -290,16 +290,16 @@ exit:
; TODO: We should be able to generate a qadd/sub
; CHECK-LABEL: test_sat
; CHECK: call i32 @llvm.start.loop.iterations.i32(i32 100)
-define i32 @test_sat(i32* %a, i32* %b) {
+define i32 @test_sat(ptr %a, ptr %b) {
entry:
br label %loop
loop:
%acc = phi i32 [ 0, %entry ], [ %res, %loop ]
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr i32, i32* %a, i32 %count
- %addr.b = getelementptr i32, i32* %b, i32 %count
- %load.a = load i32, i32* %addr.a
- %load.b = load i32, i32* %addr.b
+ %addr.a = getelementptr i32, ptr %a, i32 %count
+ %addr.b = getelementptr i32, ptr %b, i32 %count
+ %load.a = load i32, ptr %addr.a
+ %load.b = load i32, ptr %addr.b
%res = call i32 @llvm.sadd.sat.i32(i32 %load.a, i32 %load.b)
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
@@ -316,18 +316,18 @@ exit:
; CHECK-MVE: [[LOOP_DEC]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[COUNT]], i32 1)
; CHECK-MVE: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-MVE: br i1 [[CMP]], label %loop, label %exit
-define arm_aapcs_vfpcc void @test_masked_i32(<4 x i1> %mask, <4 x i32>* %a, <4 x i32>* %b, <4 x i32>* %c, <4 x i32> %passthru) {
+define arm_aapcs_vfpcc void @test_masked_i32(<4 x i1> %mask, ptr %a, ptr %b, ptr %c, <4 x i32> %passthru) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr <4 x i32>, <4 x i32>* %a, i32 %count
- %addr.b = getelementptr <4 x i32>, <4 x i32>* %b, i32 %count
- %addr.c = getelementptr <4 x i32>, <4 x i32>* %c, i32 %count
- %load.a = call <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x i32>* %addr.a, i32 4, <4 x i1> %mask, <4 x i32> %passthru)
- %load.b = call <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x i32>* %addr.b, i32 4, <4 x i1> %mask, <4 x i32> %passthru)
+ %addr.a = getelementptr <4 x i32>, ptr %a, i32 %count
+ %addr.b = getelementptr <4 x i32>, ptr %b, i32 %count
+ %addr.c = getelementptr <4 x i32>, ptr %c, i32 %count
+ %load.a = call <4 x i32> @llvm.masked.load.v4i32.p0(ptr %addr.a, i32 4, <4 x i1> %mask, <4 x i32> %passthru)
+ %load.b = call <4 x i32> @llvm.masked.load.v4i32.p0(ptr %addr.b, i32 4, <4 x i1> %mask, <4 x i32> %passthru)
%res = add <4 x i32> %load.a, %load.b
- call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> %res, <4 x i32>* %addr.c, i32 4, <4 x i1> %mask)
+ call void @llvm.masked.store.v4i32.p0(<4 x i32> %res, ptr %addr.c, i32 4, <4 x i1> %mask)
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -343,18 +343,18 @@ exit:
; CHECK-MVE: [[LOOP_DEC]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[COUNT]], i32 1)
; CHECK-MVE: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-MVE: br i1 [[CMP]], label %loop, label %exit
-define arm_aapcs_vfpcc void @test_masked_f32(<4 x i1> %mask, <4 x float>* %a, <4 x float>* %b, <4 x float>* %c, <4 x float> %passthru) {
+define arm_aapcs_vfpcc void @test_masked_f32(<4 x i1> %mask, ptr %a, ptr %b, ptr %c, <4 x float> %passthru) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %addr.a = getelementptr <4 x float>, <4 x float>* %a, i32 %count
- %addr.b = getelementptr <4 x float>, <4 x float>* %b, i32 %count
- %addr.c = getelementptr <4 x float>, <4 x float>* %c, i32 %count
- %load.a = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %addr.a, i32 4, <4 x i1> %mask, <4 x float> %passthru)
- %load.b = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %addr.b, i32 4, <4 x i1> %mask, <4 x float> %passthru)
+ %addr.a = getelementptr <4 x float>, ptr %a, i32 %count
+ %addr.b = getelementptr <4 x float>, ptr %b, i32 %count
+ %addr.c = getelementptr <4 x float>, ptr %c, i32 %count
+ %load.a = call <4 x float> @llvm.masked.load.v4f32.p0(ptr %addr.a, i32 4, <4 x i1> %mask, <4 x float> %passthru)
+ %load.b = call <4 x float> @llvm.masked.load.v4f32.p0(ptr %addr.b, i32 4, <4 x i1> %mask, <4 x float> %passthru)
%res = fadd <4 x float> %load.a, %load.b
- call void @llvm.masked.store.v4f32.p0v4f32(<4 x float> %res, <4 x float>* %addr.c, i32 4, <4 x i1> %mask)
+ call void @llvm.masked.store.v4f32.p0(<4 x float> %res, ptr %addr.c, i32 4, <4 x i1> %mask)
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -370,15 +370,15 @@ exit:
; CHECK-MVE: [[LOOP_DEC]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[COUNT]], i32 1)
; CHECK-MVE: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-MVE: br i1 [[CMP]], label %loop, label %exit
-define arm_aapcs_vfpcc void @test_gather_scatter(<4 x i1> %mask, <4 x float*> %a, <4 x float*> %b, <4 x float*> %c, <4 x float> %passthru) {
+define arm_aapcs_vfpcc void @test_gather_scatter(<4 x i1> %mask, <4 x ptr> %a, <4 x ptr> %b, <4 x ptr> %c, <4 x float> %passthru) {
entry:
br label %loop
loop:
%count = phi i32 [ 0, %entry ], [ %count.next, %loop ]
- %load.a = call <4 x float> @llvm.masked.gather.v4f32.p0v4f32(<4 x float*> %a, i32 4, <4 x i1> %mask, <4 x float> %passthru)
- %load.b = call <4 x float> @llvm.masked.gather.v4f32.p0v4f32(<4 x float*> %b, i32 4, <4 x i1> %mask, <4 x float> %passthru)
+ %load.a = call <4 x float> @llvm.masked.gather.v4f32.p0(<4 x ptr> %a, i32 4, <4 x i1> %mask, <4 x float> %passthru)
+ %load.b = call <4 x float> @llvm.masked.gather.v4f32.p0(<4 x ptr> %b, i32 4, <4 x i1> %mask, <4 x float> %passthru)
%res = fadd <4 x float> %load.a, %load.b
- call void @llvm.masked.scatter.v4f32.p0v4f32(<4 x float> %res, <4 x float*> %c, i32 4, <4 x i1> %mask)
+ call void @llvm.masked.scatter.v4f32.p0(<4 x float> %res, <4 x ptr> %c, i32 4, <4 x i1> %mask)
%count.next = add nuw i32 %count, 1
%cmp = icmp ne i32 %count.next, 100
br i1 %cmp, label %loop, label %exit
@@ -399,9 +399,9 @@ declare double @llvm.sqrt.f64(double)
declare <4 x float> @llvm.sqrt.v4f32(<4 x float>)
declare i32 @llvm.sadd.sat.i32(i32, i32)
declare {i32, i1} @llvm.sadd.with.overflow.i32(i32, i32)
-declare <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x i32>*, i32, <4 x i1>, <4 x i32>)
-declare void @llvm.masked.store.v4i32.p0v4i32(<4 x i32>, <4 x i32>*, i32, <4 x i1>)
-declare <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>*, i32, <4 x i1>, <4 x float>)
-declare void @llvm.masked.store.v4f32.p0v4f32(<4 x float>, <4 x float>*, i32, <4 x i1>)
-declare <4 x float> @llvm.masked.gather.v4f32.p0v4f32(<4 x float*>, i32, <4 x i1>, <4 x float>)
-declare void @llvm.masked.scatter.v4f32.p0v4f32(<4 x float>, <4 x float*>, i32, <4 x i1>)
+declare <4 x i32> @llvm.masked.load.v4i32.p0(ptr, i32, <4 x i1>, <4 x i32>)
+declare void @llvm.masked.store.v4i32.p0(<4 x i32>, ptr, i32, <4 x i1>)
+declare <4 x float> @llvm.masked.load.v4f32.p0(ptr, i32, <4 x i1>, <4 x float>)
+declare void @llvm.masked.store.v4f32.p0(<4 x float>, ptr, i32, <4 x i1>)
+declare <4 x float> @llvm.masked.gather.v4f32.p0(<4 x ptr>, i32, <4 x i1>, <4 x float>)
+declare void @llvm.masked.scatter.v4f32.p0(<4 x float>, <4 x ptr>, i32, <4 x i1>)
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/counter.ll b/llvm/test/Transforms/HardwareLoops/ARM/counter.ll
index fd216d9f356ad..74879320a2dec 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/counter.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/counter.ll
@@ -1,6 +1,6 @@
; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -o - | FileCheck %s
- at g = common local_unnamed_addr global i32* null, align 4
+ at g = common local_unnamed_addr global ptr null, align 4
; CHECK-LABEL: counter_too_large
; CHECK-NOT: call void @llvm.set.loop.iterations
@@ -12,15 +12,15 @@ entry:
br i1 %cmp7, label %while.end, label %while.body.lr.ph
while.body.lr.ph:
- %0 = load i32*, i32** @g, align 4
+ %0 = load ptr, ptr @g, align 4
br label %while.body
while.body:
%i.09 = phi i64 [ 0, %while.body.lr.ph ], [ %inc1, %while.body ]
%res.08 = phi i32 [ 0, %while.body.lr.ph ], [ %add, %while.body ]
%idxprom = trunc i64 %i.09 to i32
- %arrayidx = getelementptr inbounds i32, i32* %0, i32 %idxprom
- %1 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %0, i32 %idxprom
+ %1 = load i32, ptr %arrayidx, align 4
%add = add nsw i32 %1, %res.08
%inc1 = add nuw i64 %i.09, 1
%cmp = icmp ult i64 %inc1, %n
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/do-rem.ll b/llvm/test/Transforms/HardwareLoops/ARM/do-rem.ll
index da315a238546f..ef366fc835a70 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/do-rem.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/do-rem.ll
@@ -1,6 +1,6 @@
; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -S -o - | FileCheck %s
- at g = common local_unnamed_addr global i32* null, align 4
+ at g = common local_unnamed_addr global ptr null, align 4
; CHECK-LABEL: do_with_i32_urem
; CHECK: entry:
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/fp-emulation.ll b/llvm/test/Transforms/HardwareLoops/ARM/fp-emulation.ll
index 5de4e3be5a95b..ce28a0fe9f86e 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/fp-emulation.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/fp-emulation.ll
@@ -16,15 +16,15 @@
; CHECK-FP: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-FP: br i1 [[CMP]], label %while.body, label %cleanup.loopexit
-define void @test_fptosi(i32 %n, i32** %g, double** %d) {
+define void @test_fptosi(i32 %n, ptr %g, ptr %d) {
entry:
%n.off = add i32 %n, -1
%0 = icmp ult i32 %n.off, 500
br i1 %0, label %while.body.lr.ph, label %cleanup
while.body.lr.ph:
- %1 = load double*, double** %d, align 4
- %2 = load i32*, i32** %g, align 4
+ %1 = load ptr, ptr %d, align 4
+ %2 = load ptr, ptr %g, align 4
br label %while.body
while.body:
@@ -34,11 +34,11 @@ while.body:
br i1 %tobool, label %if.end4, label %if.then2
if.then2:
- %arrayidx = getelementptr inbounds double, double* %1, i32 %i.012
- %3 = load double, double* %arrayidx, align 8
+ %arrayidx = getelementptr inbounds double, ptr %1, i32 %i.012
+ %3 = load double, ptr %arrayidx, align 8
%conv = fptosi double %3 to i32
- %arrayidx3 = getelementptr inbounds i32, i32* %2, i32 %i.012
- store i32 %conv, i32* %arrayidx3, align 4
+ %arrayidx3 = getelementptr inbounds i32, ptr %2, i32 %i.012
+ store i32 %conv, ptr %arrayidx3, align 4
br label %if.end4
if.end4:
@@ -67,15 +67,15 @@ cleanup:
; CHECK-SOFT-NOT: call i32 @llvm.start.loop.iterations
-define void @test_fptoui(i32 %n, i32** %g, double** %d) {
+define void @test_fptoui(i32 %n, ptr %g, ptr %d) {
entry:
%n.off = add i32 %n, -1
%0 = icmp ult i32 %n.off, 500
br i1 %0, label %while.body.lr.ph, label %cleanup
while.body.lr.ph:
- %1 = load double*, double** %d, align 4
- %2 = load i32*, i32** %g, align 4
+ %1 = load ptr, ptr %d, align 4
+ %2 = load ptr, ptr %g, align 4
br label %while.body
while.body:
@@ -85,11 +85,11 @@ while.body:
br i1 %tobool, label %if.end4, label %if.then2
if.then2:
- %arrayidx = getelementptr inbounds double, double* %1, i32 %i.012
- %3 = load double, double* %arrayidx, align 8
+ %arrayidx = getelementptr inbounds double, ptr %1, i32 %i.012
+ %3 = load double, ptr %arrayidx, align 8
%conv = fptoui double %3 to i32
- %arrayidx3 = getelementptr inbounds i32, i32* %2, i32 %i.012
- store i32 %conv, i32* %arrayidx3, align 4
+ %arrayidx3 = getelementptr inbounds i32, ptr %2, i32 %i.012
+ store i32 %conv, ptr %arrayidx3, align 4
br label %if.end4
if.end4:
@@ -116,15 +116,15 @@ cleanup:
; CHECK: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK: br i1 [[CMP]], label %while.body, label %cleanup.loopexit
-define void @load_store_float(i32 %n, double** %d, double** %g) {
+define void @load_store_float(i32 %n, ptr %d, ptr %g) {
entry:
%n.off = add i32 %n, -1
%0 = icmp ult i32 %n.off, 500
br i1 %0, label %while.body.lr.ph, label %cleanup
while.body.lr.ph:
- %1 = load double*, double** %d, align 4
- %2 = load double*, double** %g, align 4
+ %1 = load ptr, ptr %d, align 4
+ %2 = load ptr, ptr %g, align 4
br label %while.body
while.body:
@@ -134,10 +134,10 @@ while.body:
br i1 %tobool, label %if.end4, label %if.then2
if.then2:
- %arrayidx = getelementptr inbounds double, double* %1, i32 %i.012
- %3 = load double, double* %arrayidx, align 8
- %arrayidx3 = getelementptr inbounds double, double* %2, i32 %i.012
- store double %3, double* %arrayidx3, align 8
+ %arrayidx = getelementptr inbounds double, ptr %1, i32 %i.012
+ %3 = load double, ptr %arrayidx, align 8
+ %arrayidx3 = getelementptr inbounds double, ptr %2, i32 %i.012
+ store double %3, ptr %arrayidx3, align 8
br label %if.end4
if.end4:
@@ -167,15 +167,15 @@ cleanup:
; CHECK-FP: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK-FP: br i1 [[CMP]], label %while.body, label %cleanup.loopexit
-define void @fp_add(i32 %n, float** %d, float** %g) {
+define void @fp_add(i32 %n, ptr %d, ptr %g) {
entry:
%n.off = add i32 %n, -1
%0 = icmp ult i32 %n.off, 500
br i1 %0, label %while.body.lr.ph, label %cleanup
while.body.lr.ph:
- %1 = load float*, float** %d, align 4
- %2 = load float*, float** %g, align 4
+ %1 = load ptr, ptr %d, align 4
+ %2 = load ptr, ptr %g, align 4
br label %while.body
while.body:
@@ -185,12 +185,12 @@ while.body:
br i1 %tobool, label %if.end4, label %if.then2
if.then2:
- %arrayidx = getelementptr inbounds float, float* %1, i32 %i.012
- %3 = load float, float* %arrayidx, align 4
- %arrayidx3 = getelementptr inbounds float, float* %2, i32 %i.012
- %4 = load float, float* %arrayidx3, align 4
+ %arrayidx = getelementptr inbounds float, ptr %1, i32 %i.012
+ %3 = load float, ptr %arrayidx, align 4
+ %arrayidx3 = getelementptr inbounds float, ptr %2, i32 %i.012
+ %4 = load float, ptr %arrayidx3, align 4
%add = fadd float %3, %4
- store float %add, float* %arrayidx3, align 4
+ store float %add, ptr %arrayidx3, align 4
br label %if.end4
if.end4:
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/simple-do.ll b/llvm/test/Transforms/HardwareLoops/ARM/simple-do.ll
index 836da6bdc4da9..4a5d979341c8c 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/simple-do.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/simple-do.ll
@@ -5,7 +5,7 @@
; DISABLED-NOT: llvm.{{.*}}.loop.iterations
; DISABLED-NOT: llvm.loop.decrement
- at g = common local_unnamed_addr global i32* null, align 4
+ at g = common local_unnamed_addr global ptr null, align 4
; CHECK-LABEL: do_copy
; CHECK: [[START:%[^ ]+]] = call i32 @llvm.start.loop.iterations.i32(i32 %n)
@@ -24,19 +24,19 @@
; CHECK-LLC: le lr, [[LOOP_HEADER]]
; CHECK-LLC-NOT: b [[LOOP_EXIT:\.LBB[0-9._]+]]
; CHECK-LLC: @ %while.end
-define i32 @do_copy(i32 %n, i32* nocapture %p, i32* nocapture readonly %q) {
+define i32 @do_copy(i32 %n, ptr nocapture %p, ptr nocapture readonly %q) {
entry:
br label %while.body
while.body:
- %q.addr.05 = phi i32* [ %incdec.ptr, %while.body ], [ %q, %entry ]
- %p.addr.04 = phi i32* [ %incdec.ptr1, %while.body ], [ %p, %entry ]
+ %q.addr.05 = phi ptr [ %incdec.ptr, %while.body ], [ %q, %entry ]
+ %p.addr.04 = phi ptr [ %incdec.ptr1, %while.body ], [ %p, %entry ]
%x.addr.03 = phi i32 [ %dec, %while.body ], [ %n, %entry ]
%dec = add nsw i32 %x.addr.03, -1
- %incdec.ptr = getelementptr inbounds i32, i32* %q.addr.05, i32 1
- %0 = load i32, i32* %q.addr.05, align 4
- %incdec.ptr1 = getelementptr inbounds i32, i32* %p.addr.04, i32 1
- store i32 %0, i32* %p.addr.04, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %q.addr.05, i32 1
+ %0 = load i32, ptr %q.addr.05, align 4
+ %incdec.ptr1 = getelementptr inbounds i32, ptr %p.addr.04, i32 1
+ store i32 %0, ptr %p.addr.04, align 4
%tobool = icmp eq i32 %dec, 0
br i1 %tobool, label %while.end, label %while.body
@@ -73,14 +73,14 @@ entry:
br i1 %cmp7, label %while.end, label %while.body.lr.ph
while.body.lr.ph:
- %0 = load i32*, i32** @g, align 4
+ %0 = load ptr, ptr @g, align 4
br label %while.body
while.body:
%i.09 = phi i32 [ 0, %while.body.lr.ph ], [ %inc1, %while.body ]
%res.08 = phi i32 [ 0, %while.body.lr.ph ], [ %add, %while.body ]
- %arrayidx = getelementptr inbounds i32, i32* %0, i32 %i.09
- %1 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %0, i32 %i.09
+ %1 = load i32, ptr %arrayidx, align 4
%add = add nsw i32 %1, %res.08
%inc1 = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc1, %n
@@ -123,14 +123,14 @@ entry:
br i1 %cmp7, label %while.body.lr.ph, label %while.end
while.body.lr.ph:
- %0 = load i32*, i32** @g, align 4
+ %0 = load ptr, ptr @g, align 4
br label %while.body
while.body:
%i.09 = phi i32 [ 0, %while.body.lr.ph ], [ %add1, %while.body ]
%res.08 = phi i32 [ 0, %while.body.lr.ph ], [ %add, %while.body ]
- %arrayidx = getelementptr inbounds i32, i32* %0, i32 %i.09
- %1 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %0, i32 %i.09
+ %1 = load i32, ptr %arrayidx, align 4
%add = add nsw i32 %1, %res.08
%add1 = add nuw nsw i32 %i.09, 2
%cmp = icmp slt i32 %add1, %n
@@ -176,14 +176,14 @@ entry:
br i1 %cmp6, label %while.body.lr.ph, label %while.end
while.body.lr.ph:
- %0 = load i32*, i32** @g, align 4
+ %0 = load ptr, ptr @g, align 4
br label %while.body
while.body:
%i.08 = phi i32 [ %n, %while.body.lr.ph ], [ %sub, %while.body ]
%res.07 = phi i32 [ 0, %while.body.lr.ph ], [ %add, %while.body ]
- %arrayidx = getelementptr inbounds i32, i32* %0, i32 %i.08
- %1 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %0, i32 %i.08
+ %1 = load i32, ptr %arrayidx, align 4
%add = add nsw i32 %1, %res.07
%sub = add nsw i32 %i.08, -2
%cmp = icmp sgt i32 %i.08, 2
diff --git a/llvm/test/Transforms/HardwareLoops/ARM/structure.ll b/llvm/test/Transforms/HardwareLoops/ARM/structure.ll
index 0c7417ceaaec3..8c9ea6c146b4b 100644
--- a/llvm/test/Transforms/HardwareLoops/ARM/structure.ll
+++ b/llvm/test/Transforms/HardwareLoops/ARM/structure.ll
@@ -22,14 +22,14 @@
; CHECK-LABEL: early_exit
; CHECK-NOT: llvm.set.loop.iterations
; CHECK-NOT: llvm.loop.decrement
-define i32 @early_exit(i32* nocapture readonly %a, i32 %max, i32 %n) {
+define i32 @early_exit(ptr nocapture readonly %a, i32 %max, i32 %n) {
entry:
br label %do.body
do.body:
%i.0 = phi i32 [ 0, %entry ], [ %inc, %if.end ]
- %arrayidx = getelementptr inbounds i32, i32* %a, i32 %i.0
- %0 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %a, i32 %i.0
+ %0 = load i32, ptr %arrayidx, align 4
%cmp = icmp sgt i32 %0, %max
br i1 %cmp, label %do.end, label %if.end
@@ -39,8 +39,8 @@ if.end:
br i1 %cmp1, label %do.body, label %if.end.do.end_crit_edge
if.end.do.end_crit_edge:
- %arrayidx2.phi.trans.insert = getelementptr inbounds i32, i32* %a, i32 %inc
- %.pre = load i32, i32* %arrayidx2.phi.trans.insert, align 4
+ %arrayidx2.phi.trans.insert = getelementptr inbounds i32, ptr %a, i32 %inc
+ %.pre = load i32, ptr %arrayidx2.phi.trans.insert, align 4
br label %do.end
do.end:
@@ -62,7 +62,7 @@ do.end:
; CHECK-NOT: %{{[^ ]+}} = call i1 @llvm.loop.decrement.i32(i32 1)
-define void @nested(i32* nocapture %A, i32 %N) {
+define void @nested(ptr nocapture %A, i32 %N) {
entry:
%cmp20 = icmp eq i32 %N, 0
br i1 %cmp20, label %while.end7, label %while.cond1.preheader.us
@@ -75,8 +75,8 @@ while.cond1.preheader.us:
while.body3.us:
%j.019.us = phi i32 [ 0, %while.cond1.preheader.us ], [ %inc.us, %while.body3.us ]
%add.us = add i32 %j.019.us, %mul.us
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %add.us
- store i32 %add.us, i32* %arrayidx.us, align 4
+ %arrayidx.us = getelementptr inbounds i32, ptr %A, i32 %add.us
+ store i32 %add.us, ptr %arrayidx.us, align 4
%inc.us = add nuw i32 %j.019.us, 1
%exitcond = icmp eq i32 %inc.us, %N
br i1 %exitcond, label %while.cond1.while.end_crit_edge.us, label %while.body3.us
@@ -95,19 +95,19 @@ while.end7:
; CHECK-NOT: llvm.start.loop.iterations
; CHECK: call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
; CHECK-NOT: call i32 @llvm.loop.decrement.reg
-define i32 @pre_existing(i32 %n, i32* nocapture %p, i32* nocapture readonly %q) {
+define i32 @pre_existing(i32 %n, ptr nocapture %p, ptr nocapture readonly %q) {
entry:
%start = call i32 @llvm.start.loop.iterations.i32(i32 %n)
br label %while.body
while.body: ; preds = %while.body, %entry
- %q.addr.05 = phi i32* [ %incdec.ptr, %while.body ], [ %q, %entry ]
- %p.addr.04 = phi i32* [ %incdec.ptr1, %while.body ], [ %p, %entry ]
+ %q.addr.05 = phi ptr [ %incdec.ptr, %while.body ], [ %q, %entry ]
+ %p.addr.04 = phi ptr [ %incdec.ptr1, %while.body ], [ %p, %entry ]
%0 = phi i32 [ %start, %entry ], [ %2, %while.body ]
- %incdec.ptr = getelementptr inbounds i32, i32* %q.addr.05, i32 1
- %1 = load i32, i32* %q.addr.05, align 4
- %incdec.ptr1 = getelementptr inbounds i32, i32* %p.addr.04, i32 1
- store i32 %1, i32* %p.addr.04, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %q.addr.05, i32 1
+ %1 = load i32, ptr %q.addr.05, align 4
+ %incdec.ptr1 = getelementptr inbounds i32, ptr %p.addr.04, i32 1
+ store i32 %1, ptr %p.addr.04, align 4
%2 = call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
%3 = icmp ne i32 %2, 0
br i1 %3, label %while.body, label %while.end
@@ -121,7 +121,7 @@ while.end: ; preds = %while.body
; CHECK-NOT: llvm.set{{.*}}.loop.iterations
; CHECK: call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
; CHECK-NOT: call i32 @llvm.loop.decrement.reg
-define i32 @pre_existing_test_set(i32 %n, i32* nocapture %p, i32* nocapture readonly %q) {
+define i32 @pre_existing_test_set(i32 %n, ptr nocapture %p, ptr nocapture readonly %q) {
entry:
%guard = call { i32, i1 } @llvm.test.start.loop.iterations.i32(i32 %n)
%g0 = extractvalue { i32, i1 } %guard, 0
@@ -132,13 +132,13 @@ while.preheader:
br label %while.body
while.body: ; preds = %while.body, %entry
- %q.addr.05 = phi i32* [ %incdec.ptr, %while.body ], [ %q, %while.preheader ]
- %p.addr.04 = phi i32* [ %incdec.ptr1, %while.body ], [ %p, %while.preheader ]
+ %q.addr.05 = phi ptr [ %incdec.ptr, %while.body ], [ %q, %while.preheader ]
+ %p.addr.04 = phi ptr [ %incdec.ptr1, %while.body ], [ %p, %while.preheader ]
%0 = phi i32 [ %g0, %while.preheader ], [ %2, %while.body ]
- %incdec.ptr = getelementptr inbounds i32, i32* %q.addr.05, i32 1
- %1 = load i32, i32* %q.addr.05, align 4
- %incdec.ptr1 = getelementptr inbounds i32, i32* %p.addr.04, i32 1
- store i32 %1, i32* %p.addr.04, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %q.addr.05, i32 1
+ %1 = load i32, ptr %q.addr.05, align 4
+ %incdec.ptr1 = getelementptr inbounds i32, ptr %p.addr.04, i32 1
+ store i32 %1, ptr %p.addr.04, align 4
%2 = call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
%3 = icmp ne i32 %2, 0
br i1 %3, label %while.body, label %while.end
@@ -154,7 +154,7 @@ while.end: ; preds = %while.body
; CHECK: call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
; CHECK: br i1
; CHECK-NOT: call i32 @llvm.loop.decrement
-define void @pre_existing_inner(i32* nocapture %A, i32 %N) {
+define void @pre_existing_inner(ptr nocapture %A, i32 %N) {
entry:
%cmp20 = icmp eq i32 %N, 0
br i1 %cmp20, label %while.end7, label %while.cond1.preheader.us
@@ -169,8 +169,8 @@ while.body3.us:
%j.019.us = phi i32 [ 0, %while.cond1.preheader.us ], [ %inc.us, %while.body3.us ]
%0 = phi i32 [ %start, %while.cond1.preheader.us ], [ %1, %while.body3.us ]
%add.us = add i32 %j.019.us, %mul.us
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %add.us
- store i32 %add.us, i32* %arrayidx.us, align 4
+ %arrayidx.us = getelementptr inbounds i32, ptr %A, i32 %add.us
+ store i32 %add.us, ptr %arrayidx.us, align 4
%inc.us = add nuw i32 %j.019.us, 1
%1 = call i32 @llvm.loop.decrement.reg.i32(i32 %0, i32 1)
%2 = icmp ne i32 %1, 0
@@ -188,7 +188,7 @@ while.end7:
; CHECK-LABEL: not_rotated
; CHECK-NOT: call i32 @llvm.start.loop.iterations
; CHECK-NOT: call i32 @llvm.loop.decrement.i32
-define void @not_rotated(i32, i16* nocapture, i16 signext) {
+define void @not_rotated(i32, ptr nocapture, i16 signext) {
br label %4
4:
@@ -207,10 +207,10 @@ define void @not_rotated(i32, i16* nocapture, i16 signext) {
12:
%13 = add i32 %10, %8
- %14 = getelementptr inbounds i16, i16* %1, i32 %13
- %15 = load i16, i16* %14, align 2
+ %14 = getelementptr inbounds i16, ptr %1, i32 %13
+ %15 = load i16, ptr %14, align 2
%16 = add i16 %15, %2
- store i16 %16, i16* %14, align 2
+ store i16 %16, ptr %14, align 2
%17 = add i32 %10, 1
br label %9
@@ -225,7 +225,7 @@ define void @not_rotated(i32, i16* nocapture, i16 signext) {
; CHECK-LABEL: multi_latch
; CHECK-NOT: call i32 @llvm.start.loop.iterations
; CHECK-NOT: call i32 @llvm.loop.decrement
-define void @multi_latch(i32* %a, i32* %b, i32 %N) {
+define void @multi_latch(ptr %a, ptr %b, i32 %N) {
entry:
%half = lshr i32 %N, 1
br label %header
@@ -233,16 +233,16 @@ entry:
header:
%iv = phi i32 [ 0, %entry ], [ %count.next, %latch.0 ], [ %count.next, %latch.1 ]
%cmp = icmp ult i32 %iv, %half
- %addr.a = getelementptr i32, i32* %a, i32 %iv
- %addr.b = getelementptr i32, i32* %b, i32 %iv
+ %addr.a = getelementptr i32, ptr %a, i32 %iv
+ %addr.b = getelementptr i32, ptr %b, i32 %iv
br i1 %cmp, label %if.then, label %if.else
if.then:
- store i32 %iv, i32* %addr.a
+ store i32 %iv, ptr %addr.a
br label %latch.0
if.else:
- store i32 %iv, i32* %addr.b
+ store i32 %iv, ptr %addr.b
br label %latch.0
latch.0:
@@ -251,8 +251,8 @@ latch.0:
br i1 %cmp.1, label %header, label %latch.1
latch.1:
- %ld = load i32, i32* %addr.a
- store i32 %ld, i32* %addr.b
+ %ld = load i32, ptr %addr.a
+ store i32 %ld, ptr %addr.b
%cmp.2 = icmp ult i32 %count.next, %N
br i1 %cmp.2, label %header, label %latch.1
@@ -272,7 +272,7 @@ exit:
; CHECK: [[LOOP_DEC:%[^ ]+]] = call i32 @llvm.loop.decrement.reg.i32(
; CHECK: [[CMP:%[^ ]+]] = icmp ne i32 [[LOOP_DEC]], 0
; CHECK: br i1 [[CMP]], label %for.body, label %for.cond.cleanup
-define i32 @search(i8* nocapture readonly %c, i32 %N) {
+define i32 @search(ptr nocapture readonly %c, i32 %N) {
entry:
%cmp11 = icmp eq i32 %N, 0
br i1 %cmp11, label %for.cond.cleanup, label %for.body
@@ -287,8 +287,8 @@ for.body:
%i.014 = phi i32 [ %inc3, %for.inc ], [ 0, %entry ]
%spaces.013 = phi i32 [ %spaces.1, %for.inc ], [ 0, %entry ]
%found.012 = phi i32 [ %found.1, %for.inc ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i8, i8* %c, i32 %i.014
- %0 = load i8, i8* %arrayidx, align 1
+ %arrayidx = getelementptr inbounds i8, ptr %c, i32 %i.014
+ %0 = load i8, ptr %arrayidx, align 1
switch i8 %0, label %for.inc [
i8 108, label %sw.bb
i8 111, label %sw.bb
@@ -326,7 +326,7 @@ for.inc: ; preds = %sw.bb, %sw.bb1, %fo
; CHECK-UNROLL: le lr, [[EPIL]]
; CHECK-UNROLL-NEXT: [[EXIT]]
-define void @unroll_inc_int(i32* nocapture %a, i32* nocapture readonly %b, i32* nocapture readonly %c, i32 %N) {
+define void @unroll_inc_int(ptr nocapture %a, ptr nocapture readonly %b, ptr nocapture readonly %c, i32 %N) {
entry:
%cmp8 = icmp sgt i32 %N, 0
br i1 %cmp8, label %for.body, label %for.cond.cleanup
@@ -336,13 +336,13 @@ for.cond.cleanup:
for.body:
%i.09 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %b, i32 %i.09
- %0 = load i32, i32* %arrayidx, align 4
- %arrayidx1 = getelementptr inbounds i32, i32* %c, i32 %i.09
- %1 = load i32, i32* %arrayidx1, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %b, i32 %i.09
+ %0 = load i32, ptr %arrayidx, align 4
+ %arrayidx1 = getelementptr inbounds i32, ptr %c, i32 %i.09
+ %1 = load i32, ptr %arrayidx1, align 4
%mul = mul nsw i32 %1, %0
- %arrayidx2 = getelementptr inbounds i32, i32* %a, i32 %i.09
- store i32 %mul, i32* %arrayidx2, align 4
+ %arrayidx2 = getelementptr inbounds i32, ptr %a, i32 %i.09
+ store i32 %mul, ptr %arrayidx2, align 4
%inc = add nuw nsw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %for.cond.cleanup, label %for.body
@@ -362,7 +362,7 @@ for.body:
; CHECK-UNROLL: le lr, [[EPIL]]
; CHECK-UNROLL: [[EPIL_EXIT]]:
; CHECK-UNROLL: pop
-define void @unroll_inc_unsigned(i32* nocapture %a, i32* nocapture readonly %b, i32* nocapture readonly %c, i32 %N) {
+define void @unroll_inc_unsigned(ptr nocapture %a, ptr nocapture readonly %b, ptr nocapture readonly %c, i32 %N) {
entry:
%cmp8 = icmp eq i32 %N, 0
br i1 %cmp8, label %for.cond.cleanup, label %for.body
@@ -372,13 +372,13 @@ for.cond.cleanup:
for.body:
%i.09 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %b, i32 %i.09
- %0 = load i32, i32* %arrayidx, align 4
- %arrayidx1 = getelementptr inbounds i32, i32* %c, i32 %i.09
- %1 = load i32, i32* %arrayidx1, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %b, i32 %i.09
+ %0 = load i32, ptr %arrayidx, align 4
+ %arrayidx1 = getelementptr inbounds i32, ptr %c, i32 %i.09
+ %1 = load i32, ptr %arrayidx1, align 4
%mul = mul nsw i32 %1, %0
- %arrayidx2 = getelementptr inbounds i32, i32* %a, i32 %i.09
- store i32 %mul, i32* %arrayidx2, align 4
+ %arrayidx2 = getelementptr inbounds i32, ptr %a, i32 %i.09
+ store i32 %mul, ptr %arrayidx2, align 4
%inc = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %for.cond.cleanup, label %for.body
@@ -397,7 +397,7 @@ for.body:
; CHECK-UNROLL: le lr, [[BODY]]
; CHECK-UNROLL-NOT: b
; CHECK-UNROLL: pop
-define void @unroll_dec_int(i32* nocapture %a, i32* nocapture readonly %b, i32* nocapture readonly %c, i32 %N) {
+define void @unroll_dec_int(ptr nocapture %a, ptr nocapture readonly %b, ptr nocapture readonly %c, i32 %N) {
entry:
%cmp8 = icmp sgt i32 %N, 0
br i1 %cmp8, label %for.body, label %for.cond.cleanup
@@ -407,13 +407,13 @@ for.cond.cleanup:
for.body:
%i.09 = phi i32 [ %dec, %for.body ], [ %N, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %b, i32 %i.09
- %0 = load i32, i32* %arrayidx, align 4
- %arrayidx1 = getelementptr inbounds i32, i32* %c, i32 %i.09
- %1 = load i32, i32* %arrayidx1, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %b, i32 %i.09
+ %0 = load i32, ptr %arrayidx, align 4
+ %arrayidx1 = getelementptr inbounds i32, ptr %c, i32 %i.09
+ %1 = load i32, ptr %arrayidx1, align 4
%mul = mul nsw i32 %1, %0
- %arrayidx2 = getelementptr inbounds i32, i32* %a, i32 %i.09
- store i32 %mul, i32* %arrayidx2, align 4
+ %arrayidx2 = getelementptr inbounds i32, ptr %a, i32 %i.09
+ store i32 %mul, ptr %arrayidx2, align 4
%dec = add nsw i32 %i.09, -1
%cmp = icmp sgt i32 %dec, 0
br i1 %cmp, label %for.body, label %for.cond.cleanup
diff --git a/llvm/test/Transforms/HardwareLoops/loop-guards.ll b/llvm/test/Transforms/HardwareLoops/loop-guards.ll
index 0c0b8e7e3a84b..7b001771399ca 100644
--- a/llvm/test/Transforms/HardwareLoops/loop-guards.ll
+++ b/llvm/test/Transforms/HardwareLoops/loop-guards.ll
@@ -13,18 +13,18 @@
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 [[COUNT]])
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32 [[COUNT]])
; CHECK: br label %do.body
-define void @test1(i1 zeroext %t1, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test1(i1 zeroext %t1, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
br i1 %t1, label %do.body, label %if.end
do.body: ; preds = %do.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr1, %do.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr1, %do.body ], [ %a, %entry ]
%i.0 = phi i32 [ %inc, %do.body ], [ 1, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr1 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr1 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add nuw i32 %i.0, 1
%cmp = icmp ult i32 %inc, %N
br i1 %cmp, label %do.body, label %if.end
@@ -37,18 +37,18 @@ if.end: ; preds = %do.body, %entry
; CHECK-NOT: call i1 @llvm.test.set.loop.iterations
; CHECK-NOT: call void @llvm.set.loop.iterations
; CHECK-NOT: call i32 @llvm.start.loop.iterations
-define void @test2(i1 zeroext %t1, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test2(i1 zeroext %t1, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
br i1 %t1, label %do.body, label %if.end
do.body: ; preds = %do.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr1, %do.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr1, %do.body ], [ %a, %entry ]
%i.0 = phi i32 [ %add, %do.body ], [ 1, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr1 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr1 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%add = add i32 %i.0, 2
%cmp = icmp ult i32 %add, %N
br i1 %cmp, label %do.body, label %if.end
@@ -65,19 +65,19 @@ if.end: ; preds = %do.body, %entry
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 [[COUNT]])
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32 [[COUNT]])
; CHECK: br label %do.body
-define void @test3(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test3(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%brmerge.demorgan = and i1 %t1, %t2
br i1 %brmerge.demorgan, label %do.body, label %if.end
do.body: ; preds = %do.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr3, %do.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr3, %do.body ], [ %a, %entry ]
%i.0 = phi i32 [ %inc, %do.body ], [ 0, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add nuw i32 %i.0, 1
%cmp = icmp ult i32 %inc, %N
br i1 %cmp, label %do.body, label %if.end
@@ -95,23 +95,23 @@ if.end: ; preds = %do.body, %entry
; CHECK-EXIT: [[COUNT:%[^ ]+]] = add i32 %N, 1
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 [[COUNT]])
; CHECK-EXIT: br label %while.cond
-define void @test4(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test4(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%brmerge.demorgan = and i1 %t1, %t2
br i1 %brmerge.demorgan, label %while.cond, label %if.end
while.cond: ; preds = %while.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %while.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr3, %while.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %while.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr3, %while.body ], [ %a, %entry ]
%i.0 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
%exitcond = icmp eq i32 %i.0, %N
br i1 %exitcond, label %if.end, label %while.body
while.body: ; preds = %while.cond
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add i32 %i.0, 1
br label %while.cond
@@ -126,7 +126,7 @@ if.end: ; preds = %while.cond, %entry
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 %N)
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32 %N)
; CHECK: br label %while.body
-define void @test5(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test5(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%brmerge.demorgan = and i1 %t1, %t2
%cmp6 = icmp ne i32 %N, 0
@@ -135,12 +135,12 @@ entry:
while.body: ; preds = %while.body, %entry
%i.09 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
- %a.addr.08 = phi i32* [ %incdec.ptr3, %while.body ], [ %a, %entry ]
- %b.addr.07 = phi i32* [ %incdec.ptr, %while.body ], [ %b, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.07, i32 1
- %tmp = load i32, i32* %b.addr.07, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.08, i32 1
- store i32 %tmp, i32* %a.addr.08, align 4
+ %a.addr.08 = phi ptr [ %incdec.ptr3, %while.body ], [ %a, %entry ]
+ %b.addr.07 = phi ptr [ %incdec.ptr, %while.body ], [ %b, %entry ]
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.07, i32 1
+ %tmp = load i32, ptr %b.addr.07, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.08, i32 1
+ store i32 %tmp, ptr %a.addr.08, align 4
%inc = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %if.end, label %while.body
@@ -159,7 +159,7 @@ if.end: ; preds = %while.body, %entry
; CHECK: br i1 [[TEST]], label %while.body.preheader, label %if.end
; CHECK: while.body.preheader:
; CHECK: br label %while.body
-define void @test6(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test6(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%brmerge.demorgan = and i1 %t1, %t2
br i1 %brmerge.demorgan, label %while.preheader, label %if.end
@@ -170,12 +170,12 @@ while.preheader: ; preds = %entry
while.body: ; preds = %while.body, %while.preheader
%i.09 = phi i32 [ %inc, %while.body ], [ 0, %while.preheader ]
- %a.addr.08 = phi i32* [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
- %b.addr.07 = phi i32* [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.07, i32 1
- %tmp = load i32, i32* %b.addr.07, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.08, i32 1
- store i32 %tmp, i32* %a.addr.08, align 4
+ %a.addr.08 = phi ptr [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
+ %b.addr.07 = phi ptr [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.07, i32 1
+ %tmp = load i32, ptr %b.addr.07, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.08, i32 1
+ store i32 %tmp, ptr %a.addr.08, align 4
%inc = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %if.end, label %while.body
@@ -194,7 +194,7 @@ if.end: ; preds = %while.body, %while.
; CHECK: br i1 [[TEST]], label %while.body.preheader, label %if.end
; CHECK: while.body.preheader:
; CHECK: br label %while.body
-define void @test7(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test7(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%brmerge.demorgan = and i1 %t1, %t2
br i1 %brmerge.demorgan, label %while.preheader, label %if.end
@@ -205,12 +205,12 @@ while.preheader: ; preds = %entry
while.body: ; preds = %while.body, %while.preheader
%i.09 = phi i32 [ %inc, %while.body ], [ 0, %while.preheader ]
- %a.addr.08 = phi i32* [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
- %b.addr.07 = phi i32* [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.07, i32 1
- %tmp = load i32, i32* %b.addr.07, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.08, i32 1
- store i32 %tmp, i32* %a.addr.08, align 4
+ %a.addr.08 = phi ptr [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
+ %b.addr.07 = phi ptr [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.07, i32 1
+ %tmp = load i32, ptr %b.addr.07, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.08, i32 1
+ store i32 %tmp, ptr %a.addr.08, align 4
%inc = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %if.end, label %while.body
@@ -230,7 +230,7 @@ if.end: ; preds = %while.body, %while.
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 %N)
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32 %N)
; CHECK: br label %while.body
-define void @test8(i1 zeroext %t1, i1 zeroext %t2, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test8(i1 zeroext %t1, i1 zeroext %t2, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%cmp = icmp ne i32 %N, 0
br i1 %cmp, label %while.preheader, label %if.end
@@ -241,12 +241,12 @@ while.preheader: ; preds = %entry
while.body: ; preds = %while.body, %while.preheader
%i.09 = phi i32 [ %inc, %while.body ], [ 0, %while.preheader ]
- %a.addr.08 = phi i32* [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
- %b.addr.07 = phi i32* [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.07, i32 1
- %tmp = load i32, i32* %b.addr.07, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.08, i32 1
- store i32 %tmp, i32* %a.addr.08, align 4
+ %a.addr.08 = phi ptr [ %incdec.ptr3, %while.body ], [ %a, %while.preheader ]
+ %b.addr.07 = phi ptr [ %incdec.ptr, %while.body ], [ %b, %while.preheader ]
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.07, i32 1
+ %tmp = load i32, ptr %b.addr.07, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.08, i32 1
+ store i32 %tmp, ptr %a.addr.08, align 4
%inc = add nuw i32 %i.09, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %if.end, label %while.body
@@ -262,20 +262,20 @@ if.end: ; preds = %while.body, %while.
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32 %N)
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32 %N)
; CHECK: br label %do.body
-define void @test9(i1 zeroext %t1, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test9(i1 zeroext %t1, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%cmp = icmp ne i32 %N, 0
%brmerge.demorgan = and i1 %t1, %cmp
br i1 %brmerge.demorgan, label %do.body, label %if.end
do.body: ; preds = %do.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr3, %do.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr3, %do.body ], [ %a, %entry ]
%i.0 = phi i32 [ %inc, %do.body ], [ 0, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add nuw i32 %i.0, 1
%cmp.1 = icmp ult i32 %inc, %N
br i1 %cmp.1, label %do.body, label %if.end
@@ -291,7 +291,7 @@ if.end: ; preds = %do.body, %entry
; CHECK-EXIT: call void @llvm.set.loop.iterations.i32(i32
; CHECK-LATCH: call i32 @llvm.start.loop.iterations.i32(i32
; CHECK: br label %do.body
-define void @test10(i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test10(ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
%cmp = icmp ne i32 %N, 0
%sub = sub i32 %N, 1
@@ -300,13 +300,13 @@ entry:
br i1 %cmp.1, label %do.body, label %if.end
do.body: ; preds = %do.body, %entry
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %entry ]
- %a.addr.0 = phi i32* [ %incdec.ptr3, %do.body ], [ %a, %entry ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %entry ]
+ %a.addr.0 = phi ptr [ %incdec.ptr3, %do.body ], [ %a, %entry ]
%i.0 = phi i32 [ %inc, %do.body ], [ 0, %entry ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add nuw i32 %i.0, 1
%cmp.2 = icmp ult i32 %inc, %N
br i1 %cmp.2, label %do.body, label %if.end
@@ -325,7 +325,7 @@ if.end: ; preds = %do.body, %entry
; CHECK: br i1 [[TEST]], label %do.body.preheader1, label %if.end
; CHECK: do.body.preheader1:
; CHECK: br label %do.body
-define void @test11(i1 zeroext %t1, i32* nocapture %a, i32* nocapture readonly %b, i32 %N) {
+define void @test11(i1 zeroext %t1, ptr nocapture %a, ptr nocapture readonly %b, i32 %N) {
entry:
br label %do.body.preheader
@@ -334,13 +334,13 @@ do.body.preheader:
br i1 %cmp, label %do.body, label %if.end
do.body:
- %b.addr.0 = phi i32* [ %incdec.ptr, %do.body ], [ %b, %do.body.preheader ]
- %a.addr.0 = phi i32* [ %incdec.ptr3, %do.body ], [ %a, %do.body.preheader ]
+ %b.addr.0 = phi ptr [ %incdec.ptr, %do.body ], [ %b, %do.body.preheader ]
+ %a.addr.0 = phi ptr [ %incdec.ptr3, %do.body ], [ %a, %do.body.preheader ]
%i.0 = phi i32 [ %inc, %do.body ], [ 0, %do.body.preheader ]
- %incdec.ptr = getelementptr inbounds i32, i32* %b.addr.0, i32 1
- %tmp = load i32, i32* %b.addr.0, align 4
- %incdec.ptr3 = getelementptr inbounds i32, i32* %a.addr.0, i32 1
- store i32 %tmp, i32* %a.addr.0, align 4
+ %incdec.ptr = getelementptr inbounds i32, ptr %b.addr.0, i32 1
+ %tmp = load i32, ptr %b.addr.0, align 4
+ %incdec.ptr3 = getelementptr inbounds i32, ptr %a.addr.0, i32 1
+ store i32 %tmp, ptr %a.addr.0, align 4
%inc = add nuw i32 %i.0, 1
%cmp.1 = icmp ult i32 %inc, %N
br i1 %cmp.1, label %do.body, label %if.end
@@ -358,7 +358,7 @@ if.end: ; preds = %do.body, %entry
; CHECK: for.body.preheader:
; CHECK: br label %for.body
-define void @test12(i32* nocapture %a, i32* nocapture readonly %b, i16 zeroext %length) {
+define void @test12(ptr nocapture %a, ptr nocapture readonly %b, i16 zeroext %length) {
entry:
%conv = zext i16 %length to i32
%cmp8.not = icmp eq i16 %length, 0
@@ -366,10 +366,10 @@ entry:
for.body: ; preds = %entry, %for.body
%i.09 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %b, i32 %i.09
- %0 = load i32, i32* %arrayidx, align 4
- %arrayidx2 = getelementptr inbounds i32, i32* %a, i32 %i.09
- store i32 %0, i32* %arrayidx2, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %b, i32 %i.09
+ %0 = load i32, ptr %arrayidx, align 4
+ %arrayidx2 = getelementptr inbounds i32, ptr %a, i32 %i.09
+ store i32 %0, ptr %arrayidx2, align 4
%inc = add nuw nsw i32 %i.09, 1
%exitcond.not = icmp eq i32 %inc, %conv
br i1 %exitcond.not, label %for.end, label %for.body
diff --git a/llvm/test/Transforms/HardwareLoops/scalar-while.ll b/llvm/test/Transforms/HardwareLoops/scalar-while.ll
index 9d5695e401678..46e4f7721c1ae 100644
--- a/llvm/test/Transforms/HardwareLoops/scalar-while.ll
+++ b/llvm/test/Transforms/HardwareLoops/scalar-while.ll
@@ -5,7 +5,7 @@
; RUN: opt -hardware-loops -force-hardware-loops=true -hardware-loop-decrement=1 -hardware-loop-counter-bitwidth=32 -force-hardware-loop-guard=true -S %s -o - | FileCheck %s --check-prefix=CHECK-GUARD
; RUN: opt -hardware-loops -force-hardware-loops=true -hardware-loop-decrement=1 -hardware-loop-counter-bitwidth=32 -force-hardware-loop-phi=true -force-hardware-loop-guard=true -S %s -o - | FileCheck %s --check-prefix=CHECK-PHIGUARD
-define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
+define void @while_lt(i32 %i, i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_lt(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP4:%.*]] = icmp ult i32 [[I:%.*]], [[N:%.*]]
@@ -16,8 +16,8 @@ define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-DEC-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -35,8 +35,8 @@ define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP2:%.*]] = phi i32 [ [[TMP1]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP3:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHI-NEXT: [[TMP3]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP2]], i32 1)
; CHECK-PHI-NEXT: [[TMP4:%.*]] = icmp ne i32 [[TMP3]], 0
@@ -54,8 +54,8 @@ define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-NESTED-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -72,8 +72,8 @@ define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-GUARD-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -91,8 +91,8 @@ define void @while_lt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP2:%.*]] = phi i32 [ [[TMP1]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP3:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHIGUARD-NEXT: [[TMP3]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP2]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP4:%.*]] = icmp ne i32 [[TMP3]], 0
@@ -106,8 +106,8 @@ entry:
while.body:
%i.addr.05 = phi i32 [ %inc, %while.body ], [ %i, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%inc = add nuw i32 %i.addr.05, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %while.end, label %while.body
@@ -116,7 +116,7 @@ while.end:
ret void
}
-define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
+define void @while_gt(i32 %i, i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_gt(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[I:%.*]], [[N:%.*]]
@@ -127,8 +127,8 @@ define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-DEC-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -146,8 +146,8 @@ define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP2:%.*]] = phi i32 [ [[TMP1]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP3:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-PHI-NEXT: [[TMP3]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP2]], i32 1)
; CHECK-PHI-NEXT: [[TMP4:%.*]] = icmp ne i32 [[TMP3]], 0
@@ -165,8 +165,8 @@ define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-NESTED-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -183,8 +183,8 @@ define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-GUARD-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -202,8 +202,8 @@ define void @while_gt(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP2:%.*]] = phi i32 [ [[TMP1]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP3:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-PHIGUARD-NEXT: [[TMP3]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP2]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP4:%.*]] = icmp ne i32 [[TMP3]], 0
@@ -217,8 +217,8 @@ entry:
while.body:
%i.addr.05 = phi i32 [ %dec, %while.body ], [ %i, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%dec = add nsw i32 %i.addr.05, -1
%cmp = icmp sgt i32 %dec, %N
br i1 %cmp, label %while.body, label %while.end
@@ -227,7 +227,7 @@ while.end:
ret void
}
-define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
+define void @while_gte(i32 %i, i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_gte(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP4:%.*]] = icmp slt i32 [[I:%.*]], [[N:%.*]]
@@ -239,8 +239,8 @@ define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-DEC-NEXT: [[TMP2:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP2]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -259,8 +259,8 @@ define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP2]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP4:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-PHI-NEXT: [[TMP4]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP3]], i32 1)
; CHECK-PHI-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
@@ -279,8 +279,8 @@ define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-NESTED-NEXT: [[TMP2:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP2]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -298,8 +298,8 @@ define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-GUARD-NEXT: [[TMP2:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP2]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -318,8 +318,8 @@ define void @while_gte(i32 %i, i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[DEC:%.*]], [[WHILE_BODY]] ], [ [[I]], [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP2]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP4:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[DEC]] = add nsw i32 [[I_ADDR_05]], -1
; CHECK-PHIGUARD-NEXT: [[TMP4]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP3]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
@@ -333,8 +333,8 @@ entry:
while.body:
%i.addr.05 = phi i32 [ %dec, %while.body ], [ %i, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%dec = add nsw i32 %i.addr.05, -1
%cmp = icmp sgt i32 %i.addr.05, %N
br i1 %cmp, label %while.body, label %while.end
@@ -343,7 +343,7 @@ while.end:
ret void
}
-define void @while_ne(i32 %N, i32* nocapture %A) {
+define void @while_ne(i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_ne(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP:%.*]] = icmp ne i32 [[N:%.*]], 0
@@ -353,8 +353,8 @@ define void @while_ne(i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-DEC-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -371,8 +371,8 @@ define void @while_ne(i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP2:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHI-NEXT: [[TMP2]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP1]], i32 1)
; CHECK-PHI-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP2]], 0
@@ -389,8 +389,8 @@ define void @while_ne(i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-NESTED-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -406,8 +406,8 @@ define void @while_ne(i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-GUARD-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -426,8 +426,8 @@ define void @while_ne(i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP2]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP4:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHIGUARD-NEXT: [[TMP4]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP3]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
@@ -441,8 +441,8 @@ entry:
while.body:
%i.addr.05 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%inc = add nuw i32 %i.addr.05, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %while.end, label %while.body
@@ -451,7 +451,7 @@ while.end:
ret void
}
-define void @while_eq(i32 %N, i32* nocapture %A) {
+define void @while_eq(i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_eq(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP:%.*]] = icmp eq i32 [[N:%.*]], 0
@@ -461,8 +461,8 @@ define void @while_eq(i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-DEC-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -479,8 +479,8 @@ define void @while_eq(i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP2:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHI-NEXT: [[TMP2]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP1]], i32 1)
; CHECK-PHI-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP2]], 0
@@ -497,8 +497,8 @@ define void @while_eq(i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-NESTED-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -514,8 +514,8 @@ define void @while_eq(i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-GUARD-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -534,8 +534,8 @@ define void @while_eq(i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP2]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP4:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHIGUARD-NEXT: [[TMP4]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP3]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
@@ -549,8 +549,8 @@ entry:
while.body:
%i.addr.05 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%inc = add nuw i32 %i.addr.05, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %while.end, label %while.body
@@ -559,7 +559,7 @@ while.end:
ret void
}
-define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
+define void @while_preheader_eq(i32 %N, ptr nocapture %A) {
; CHECK-DEC-LABEL: @while_preheader_eq(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: br label [[PREHEADER:%.*]]
@@ -571,8 +571,8 @@ define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
; CHECK-DEC-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-DEC: while.body:
; CHECK-DEC-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-DEC-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-DEC-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-DEC-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -591,8 +591,8 @@ define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
; CHECK-PHI: while.body:
; CHECK-PHI-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHI-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP2:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHI-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHI-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHI-NEXT: [[TMP2]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP1]], i32 1)
; CHECK-PHI-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP2]], 0
@@ -611,8 +611,8 @@ define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
; CHECK-NESTED-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-NESTED: while.body:
; CHECK-NESTED-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-NESTED-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-NESTED-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-NESTED-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP0]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -630,8 +630,8 @@ define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
; CHECK-GUARD-NEXT: br label [[WHILE_BODY:%.*]]
; CHECK-GUARD: while.body:
; CHECK-GUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
-; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-GUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-GUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-GUARD-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP1]], label [[WHILE_BODY]], label [[WHILE_END]]
@@ -652,8 +652,8 @@ define void @while_preheader_eq(i32 %N, i32* nocapture %A) {
; CHECK-PHIGUARD: while.body:
; CHECK-PHIGUARD-NEXT: [[I_ADDR_05:%.*]] = phi i32 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[WHILE_BODY_PREHEADER]] ]
; CHECK-PHIGUARD-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP2]], [[WHILE_BODY_PREHEADER]] ], [ [[TMP4:%.*]], [[WHILE_BODY]] ]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_ADDR_05]]
-; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], i32* [[ARRAYIDX]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[I_ADDR_05]]
+; CHECK-PHIGUARD-NEXT: store i32 [[I_ADDR_05]], ptr [[ARRAYIDX]], align 4
; CHECK-PHIGUARD-NEXT: [[INC]] = add nuw i32 [[I_ADDR_05]], 1
; CHECK-PHIGUARD-NEXT: [[TMP4]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP3]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
@@ -670,8 +670,8 @@ preheader:
while.body:
%i.addr.05 = phi i32 [ %inc, %while.body ], [ 0, %preheader ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.addr.05
- store i32 %i.addr.05, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.addr.05
+ store i32 %i.addr.05, ptr %arrayidx, align 4
%inc = add nuw i32 %i.addr.05, 1
%exitcond = icmp eq i32 %inc, %N
br i1 %exitcond, label %while.end, label %while.body
@@ -680,7 +680,7 @@ while.end:
ret void
}
-define void @nested(i32* nocapture %A, i32 %N) {
+define void @nested(ptr nocapture %A, i32 %N) {
; CHECK-DEC-LABEL: @nested(
; CHECK-DEC-NEXT: entry:
; CHECK-DEC-NEXT: [[CMP20:%.*]] = icmp eq i32 [[N:%.*]], 0
@@ -693,8 +693,8 @@ define void @nested(i32* nocapture %A, i32 %N) {
; CHECK-DEC: while.body3.us:
; CHECK-DEC-NEXT: [[J_019_US:%.*]] = phi i32 [ 0, [[WHILE_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-DEC-NEXT: [[ADD_US:%.*]] = add i32 [[J_019_US]], [[MUL_US]]
-; CHECK-DEC-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD_US]]
-; CHECK-DEC-NEXT: store i32 [[ADD_US]], i32* [[ARRAYIDX_US]], align 4
+; CHECK-DEC-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[ADD_US]]
+; CHECK-DEC-NEXT: store i32 [[ADD_US]], ptr [[ARRAYIDX_US]], align 4
; CHECK-DEC-NEXT: [[INC_US]] = add nuw i32 [[J_019_US]], 1
; CHECK-DEC-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-DEC-NEXT: br i1 [[TMP0]], label [[WHILE_BODY3_US]], label [[WHILE_COND1_WHILE_END_CRIT_EDGE_US]]
@@ -718,8 +718,8 @@ define void @nested(i32* nocapture %A, i32 %N) {
; CHECK-PHI-NEXT: [[J_019_US:%.*]] = phi i32 [ 0, [[WHILE_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-PHI-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[WHILE_COND1_PREHEADER_US]] ], [ [[TMP2:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-PHI-NEXT: [[ADD_US:%.*]] = add i32 [[J_019_US]], [[MUL_US]]
-; CHECK-PHI-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD_US]]
-; CHECK-PHI-NEXT: store i32 [[ADD_US]], i32* [[ARRAYIDX_US]], align 4
+; CHECK-PHI-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[ADD_US]]
+; CHECK-PHI-NEXT: store i32 [[ADD_US]], ptr [[ARRAYIDX_US]], align 4
; CHECK-PHI-NEXT: [[INC_US]] = add nuw i32 [[J_019_US]], 1
; CHECK-PHI-NEXT: [[TMP2]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP1]], i32 1)
; CHECK-PHI-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP2]], 0
@@ -746,8 +746,8 @@ define void @nested(i32* nocapture %A, i32 %N) {
; CHECK-NESTED: while.body3.us:
; CHECK-NESTED-NEXT: [[J_019_US:%.*]] = phi i32 [ 0, [[WHILE_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-NESTED-NEXT: [[ADD_US:%.*]] = add i32 [[J_019_US]], [[MUL_US]]
-; CHECK-NESTED-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD_US]]
-; CHECK-NESTED-NEXT: store i32 [[ADD_US]], i32* [[ARRAYIDX_US]], align 4
+; CHECK-NESTED-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[ADD_US]]
+; CHECK-NESTED-NEXT: store i32 [[ADD_US]], ptr [[ARRAYIDX_US]], align 4
; CHECK-NESTED-NEXT: [[INC_US]] = add nuw i32 [[J_019_US]], 1
; CHECK-NESTED-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NESTED-NEXT: br i1 [[TMP0]], label [[WHILE_BODY3_US]], label [[WHILE_COND1_WHILE_END_CRIT_EDGE_US]]
@@ -770,8 +770,8 @@ define void @nested(i32* nocapture %A, i32 %N) {
; CHECK-GUARD: while.body3.us:
; CHECK-GUARD-NEXT: [[J_019_US:%.*]] = phi i32 [ 0, [[WHILE_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-GUARD-NEXT: [[ADD_US:%.*]] = add i32 [[J_019_US]], [[MUL_US]]
-; CHECK-GUARD-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD_US]]
-; CHECK-GUARD-NEXT: store i32 [[ADD_US]], i32* [[ARRAYIDX_US]], align 4
+; CHECK-GUARD-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[ADD_US]]
+; CHECK-GUARD-NEXT: store i32 [[ADD_US]], ptr [[ARRAYIDX_US]], align 4
; CHECK-GUARD-NEXT: [[INC_US]] = add nuw i32 [[J_019_US]], 1
; CHECK-GUARD-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-GUARD-NEXT: br i1 [[TMP0]], label [[WHILE_BODY3_US]], label [[WHILE_COND1_WHILE_END_CRIT_EDGE_US]]
@@ -795,8 +795,8 @@ define void @nested(i32* nocapture %A, i32 %N) {
; CHECK-PHIGUARD-NEXT: [[J_019_US:%.*]] = phi i32 [ 0, [[WHILE_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-PHIGUARD-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[WHILE_COND1_PREHEADER_US]] ], [ [[TMP2:%.*]], [[WHILE_BODY3_US]] ]
; CHECK-PHIGUARD-NEXT: [[ADD_US:%.*]] = add i32 [[J_019_US]], [[MUL_US]]
-; CHECK-PHIGUARD-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD_US]]
-; CHECK-PHIGUARD-NEXT: store i32 [[ADD_US]], i32* [[ARRAYIDX_US]], align 4
+; CHECK-PHIGUARD-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, ptr [[A:%.*]], i32 [[ADD_US]]
+; CHECK-PHIGUARD-NEXT: store i32 [[ADD_US]], ptr [[ARRAYIDX_US]], align 4
; CHECK-PHIGUARD-NEXT: [[INC_US]] = add nuw i32 [[J_019_US]], 1
; CHECK-PHIGUARD-NEXT: [[TMP2]] = call i32 @llvm.loop.decrement.reg.i32(i32 [[TMP1]], i32 1)
; CHECK-PHIGUARD-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP2]], 0
@@ -820,8 +820,8 @@ while.cond1.preheader.us:
while.body3.us:
%j.019.us = phi i32 [ 0, %while.cond1.preheader.us ], [ %inc.us, %while.body3.us ]
%add.us = add i32 %j.019.us, %mul.us
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %add.us
- store i32 %add.us, i32* %arrayidx.us, align 4
+ %arrayidx.us = getelementptr inbounds i32, ptr %A, i32 %add.us
+ store i32 %add.us, ptr %arrayidx.us, align 4
%inc.us = add nuw i32 %j.019.us, 1
%exitcond = icmp eq i32 %inc.us, %N
br i1 %exitcond, label %while.cond1.while.end_crit_edge.us, label %while.body3.us
diff --git a/llvm/test/Transforms/HardwareLoops/sibling-loops.ll b/llvm/test/Transforms/HardwareLoops/sibling-loops.ll
index 9a4c89fea853d..50b89f141cc2f 100644
--- a/llvm/test/Transforms/HardwareLoops/sibling-loops.ll
+++ b/llvm/test/Transforms/HardwareLoops/sibling-loops.ll
@@ -1,7 +1,7 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -hardware-loops -force-hardware-loops=true -hardware-loop-decrement=1 -hardware-loop-counter-bitwidth=32 -S | FileCheck %s
-define arm_aapcs_vfpcc void @test(i16* noalias nocapture readonly %off, i16* noalias nocapture %data, i16* noalias nocapture %dst, i32 %n) {
+define arm_aapcs_vfpcc void @test(ptr noalias nocapture readonly %off, ptr noalias nocapture %data, ptr noalias nocapture %dst, i32 %n) {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP252:%.*]] = icmp sgt i32 [[N:%.*]], 0
@@ -13,14 +13,14 @@ define arm_aapcs_vfpcc void @test(i16* noalias nocapture readonly %off, i16* noa
; CHECK-NEXT: br label [[FOR_BODY4_US:%.*]]
; CHECK: for.body4.us:
; CHECK-NEXT: [[J_053_US:%.*]] = phi i32 [ 0, [[FOR_COND1_PREHEADER_US]] ], [ [[INC_US:%.*]], [[FOR_BODY4_US]] ]
-; CHECK-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i16, i16* [[OFF:%.*]], i32 [[J_053_US]]
-; CHECK-NEXT: [[L2:%.*]] = load i16, i16* [[ARRAYIDX_US]], align 2
-; CHECK-NEXT: [[ARRAYIDX5_US:%.*]] = getelementptr inbounds i16, i16* [[DATA:%.*]], i32 [[J_053_US]]
-; CHECK-NEXT: [[L3:%.*]] = load i16, i16* [[ARRAYIDX5_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i16, ptr [[OFF:%.*]], i32 [[J_053_US]]
+; CHECK-NEXT: [[L2:%.*]] = load i16, ptr [[ARRAYIDX_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX5_US:%.*]] = getelementptr inbounds i16, ptr [[DATA:%.*]], i32 [[J_053_US]]
+; CHECK-NEXT: [[L3:%.*]] = load i16, ptr [[ARRAYIDX5_US]], align 2
; CHECK-NEXT: [[ADD_US:%.*]] = add i16 [[L3]], [[L2]]
; CHECK-NEXT: [[ADD8_US:%.*]] = add i32 [[J_053_US]], [[MUL_US]]
-; CHECK-NEXT: [[ARRAYIDX9_US:%.*]] = getelementptr inbounds i16, i16* [[DATA]], i32 [[ADD8_US]]
-; CHECK-NEXT: store i16 [[ADD_US]], i16* [[ARRAYIDX9_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX9_US:%.*]] = getelementptr inbounds i16, ptr [[DATA]], i32 [[ADD8_US]]
+; CHECK-NEXT: store i16 [[ADD_US]], ptr [[ARRAYIDX9_US]], align 2
; CHECK-NEXT: [[INC_US]] = add nuw nsw i32 [[J_053_US]], 1
; CHECK-NEXT: [[TMP0:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NEXT: br i1 [[TMP0]], label [[FOR_BODY4_US]], label [[FOR_BODY15_US_PREHEADER:%.*]]
@@ -29,14 +29,14 @@ define arm_aapcs_vfpcc void @test(i16* noalias nocapture readonly %off, i16* noa
; CHECK-NEXT: br label [[FOR_BODY15_US:%.*]]
; CHECK: for.body15.us:
; CHECK-NEXT: [[J10_055_US:%.*]] = phi i32 [ [[INC26_US:%.*]], [[FOR_BODY15_US]] ], [ 0, [[FOR_BODY15_US_PREHEADER]] ]
-; CHECK-NEXT: [[ARRAYIDX16_US:%.*]] = getelementptr inbounds i16, i16* [[OFF]], i32 [[J10_055_US]]
-; CHECK-NEXT: [[L0:%.*]] = load i16, i16* [[ARRAYIDX16_US]], align 2
-; CHECK-NEXT: [[ARRAYIDX18_US:%.*]] = getelementptr inbounds i16, i16* [[DATA]], i32 [[J10_055_US]]
-; CHECK-NEXT: [[L1:%.*]] = load i16, i16* [[ARRAYIDX18_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX16_US:%.*]] = getelementptr inbounds i16, ptr [[OFF]], i32 [[J10_055_US]]
+; CHECK-NEXT: [[L0:%.*]] = load i16, ptr [[ARRAYIDX16_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX18_US:%.*]] = getelementptr inbounds i16, ptr [[DATA]], i32 [[J10_055_US]]
+; CHECK-NEXT: [[L1:%.*]] = load i16, ptr [[ARRAYIDX18_US]], align 2
; CHECK-NEXT: [[ADD20_US:%.*]] = add i16 [[L1]], [[L0]]
; CHECK-NEXT: [[ADD23_US:%.*]] = add i32 [[J10_055_US]], [[MUL_US]]
-; CHECK-NEXT: [[ARRAYIDX24_US:%.*]] = getelementptr inbounds i16, i16* [[DST:%.*]], i32 [[ADD23_US]]
-; CHECK-NEXT: store i16 [[ADD20_US]], i16* [[ARRAYIDX24_US]], align 2
+; CHECK-NEXT: [[ARRAYIDX24_US:%.*]] = getelementptr inbounds i16, ptr [[DST:%.*]], i32 [[ADD23_US]]
+; CHECK-NEXT: store i16 [[ADD20_US]], ptr [[ARRAYIDX24_US]], align 2
; CHECK-NEXT: [[INC26_US]] = add nuw nsw i32 [[J10_055_US]], 1
; CHECK-NEXT: [[TMP1:%.*]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-NEXT: br i1 [[TMP1]], label [[FOR_BODY15_US]], label [[FOR_COND_CLEANUP14_US]]
@@ -58,28 +58,28 @@ for.cond1.preheader.us: ; preds = %entry, %for.cond.cleanup14.us
for.body4.us: ; preds = %for.body4.us, %for.cond1.preheader.us
%j.053.us = phi i32 [ 0, %for.cond1.preheader.us ], [ %inc.us, %for.body4.us ]
- %arrayidx.us = getelementptr inbounds i16, i16* %off, i32 %j.053.us
- %l2 = load i16, i16* %arrayidx.us, align 2
- %arrayidx5.us = getelementptr inbounds i16, i16* %data, i32 %j.053.us
- %l3 = load i16, i16* %arrayidx5.us, align 2
+ %arrayidx.us = getelementptr inbounds i16, ptr %off, i32 %j.053.us
+ %l2 = load i16, ptr %arrayidx.us, align 2
+ %arrayidx5.us = getelementptr inbounds i16, ptr %data, i32 %j.053.us
+ %l3 = load i16, ptr %arrayidx5.us, align 2
%add.us = add i16 %l3, %l2
%add8.us = add i32 %j.053.us, %mul.us
- %arrayidx9.us = getelementptr inbounds i16, i16* %data, i32 %add8.us
- store i16 %add.us, i16* %arrayidx9.us, align 2
+ %arrayidx9.us = getelementptr inbounds i16, ptr %data, i32 %add8.us
+ store i16 %add.us, ptr %arrayidx9.us, align 2
%inc.us = add nuw nsw i32 %j.053.us, 1
%exitcond = icmp eq i32 %inc.us, %n
br i1 %exitcond, label %for.body15.us, label %for.body4.us
for.body15.us: ; preds = %for.body4.us, %for.body15.us
%j10.055.us = phi i32 [ %inc26.us, %for.body15.us ], [ 0, %for.body4.us ]
- %arrayidx16.us = getelementptr inbounds i16, i16* %off, i32 %j10.055.us
- %l0 = load i16, i16* %arrayidx16.us, align 2
- %arrayidx18.us = getelementptr inbounds i16, i16* %data, i32 %j10.055.us
- %l1 = load i16, i16* %arrayidx18.us, align 2
+ %arrayidx16.us = getelementptr inbounds i16, ptr %off, i32 %j10.055.us
+ %l0 = load i16, ptr %arrayidx16.us, align 2
+ %arrayidx18.us = getelementptr inbounds i16, ptr %data, i32 %j10.055.us
+ %l1 = load i16, ptr %arrayidx18.us, align 2
%add20.us = add i16 %l1, %l0
%add23.us = add i32 %j10.055.us, %mul.us
- %arrayidx24.us = getelementptr inbounds i16, i16* %dst, i32 %add23.us
- store i16 %add20.us, i16* %arrayidx24.us, align 2
+ %arrayidx24.us = getelementptr inbounds i16, ptr %dst, i32 %add23.us
+ store i16 %add20.us, ptr %arrayidx24.us, align 2
%inc26.us = add nuw nsw i32 %j10.055.us, 1
%exitcond93 = icmp eq i32 %inc26.us, %n
br i1 %exitcond93, label %for.cond.cleanup14.us, label %for.body15.us
diff --git a/llvm/test/Transforms/HardwareLoops/unconditional-latch.ll b/llvm/test/Transforms/HardwareLoops/unconditional-latch.ll
index 4a3cd989d941f..847d92fa0f260 100644
--- a/llvm/test/Transforms/HardwareLoops/unconditional-latch.ll
+++ b/llvm/test/Transforms/HardwareLoops/unconditional-latch.ll
@@ -15,7 +15,7 @@
; CHECK-ALLOW: [[CMP:%[^ ]+]] = call i1 @llvm.loop.decrement.i32(i32 1)
; CHECK-ALLOW: br i1 [[CMP]], label %bb10, label %bb16
-define void @not_rotated(i32 %arg, i16* nocapture %arg1, i16 signext %arg2) {
+define void @not_rotated(i32 %arg, ptr nocapture %arg1, i16 signext %arg2) {
bb:
br label %bb3
@@ -35,10 +35,10 @@ bb7: ; preds = %bb10, %bb5
bb10: ; preds = %bb7
%tmp11 = add i32 %tmp8, %tmp6
- %tmp12 = getelementptr inbounds i16, i16* %arg1, i32 %tmp11
- %tmp13 = load i16, i16* %tmp12, align 2
+ %tmp12 = getelementptr inbounds i16, ptr %arg1, i32 %tmp11
+ %tmp13 = load i16, ptr %tmp12, align 2
%tmp14 = add i16 %tmp13, %arg2
- store i16 %tmp14, i16* %tmp12, align 2
+ store i16 %tmp14, ptr %tmp12, align 2
%tmp15 = add i32 %tmp8, 1
br label %bb7
diff --git a/llvm/test/Transforms/HardwareLoops/unscevable.ll b/llvm/test/Transforms/HardwareLoops/unscevable.ll
index cd9c3e7863b4c..5cde63c4ac85b 100644
--- a/llvm/test/Transforms/HardwareLoops/unscevable.ll
+++ b/llvm/test/Transforms/HardwareLoops/unscevable.ll
@@ -5,15 +5,15 @@
; CHECK-LABEL: float_counter
; CHECK-NOT: set.loop.iterations
; CHECK-NOT: loop.decrement
-define void @float_counter(i32* nocapture %A, float %N) {
+define void @float_counter(ptr nocapture %A, float %N) {
entry:
%cmp6 = fcmp ogt float %N, 0.000000e+00
br i1 %cmp6, label %while.body, label %while.end
while.body:
%i.07 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.07
- store i32 %i.07, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.07
+ store i32 %i.07, ptr %arrayidx, align 4
%inc = add i32 %i.07, 1
%conv = uitofp i32 %inc to float
%cmp = fcmp olt float %conv, %N
@@ -26,19 +26,19 @@ while.end:
; CHECK-LABEL: variant_counter
; CHECK-NOT: set.loop.iterations
; CHECK-NOT: loop.decrement
-define void @variant_counter(i32* nocapture %A, i32* nocapture readonly %B) {
+define void @variant_counter(ptr nocapture %A, ptr nocapture readonly %B) {
entry:
- %0 = load i32, i32* %B, align 4
+ %0 = load i32, ptr %B, align 4
%cmp7 = icmp eq i32 %0, 0
br i1 %cmp7, label %while.end, label %while.body
while.body:
%i.08 = phi i32 [ %inc, %while.body ], [ 0, %entry ]
- %arrayidx1 = getelementptr inbounds i32, i32* %A, i32 %i.08
- store i32 %i.08, i32* %arrayidx1, align 4
+ %arrayidx1 = getelementptr inbounds i32, ptr %A, i32 %i.08
+ store i32 %i.08, ptr %arrayidx1, align 4
%inc = add nuw i32 %i.08, 1
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %inc
- %1 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds i32, ptr %B, i32 %inc
+ %1 = load i32, ptr %arrayidx, align 4
%cmp = icmp ult i32 %inc, %1
br i1 %cmp, label %while.body, label %while.end
@@ -49,17 +49,17 @@ while.end:
; CHECK-LABEL: variant_counter2
; CHECK-NOT: set.loop.iterations
; CHECK-NOT: loop.decrement
-define void @variant_counter2(i8*, i8*, i64*) {
- %4 = icmp eq i8* %0, %1
+define void @variant_counter2(ptr, ptr, ptr) {
+ %4 = icmp eq ptr %0, %1
br i1 %4, label %9, label %5
5: ; preds = %3
- %6 = getelementptr inbounds i64, i64* %2, i64 1
- %7 = load i64, i64* %6, align 8
+ %6 = getelementptr inbounds i64, ptr %2, i64 1
+ %7 = load i64, ptr %6, align 8
br label %10
8: ; preds = %10
- store i64 %14, i64* %6, align 8
+ store i64 %14, ptr %6, align 8
br label %9
9: ; preds = %8, %3
@@ -68,12 +68,12 @@ define void @variant_counter2(i8*, i8*, i64*) {
10: ; preds = %5, %10
%11 = phi i64 [ %7, %5 ], [ %14, %10 ]
%12 = phi i32 [ 0, %5 ], [ %15, %10 ]
- %13 = phi i8* [ %0, %5 ], [ %16, %10 ]
+ %13 = phi ptr [ %0, %5 ], [ %16, %10 ]
%14 = shl nsw i64 %11, 4
%15 = add nuw nsw i32 %12, 1
- %16 = getelementptr inbounds i8, i8* %13, i64 1
+ %16 = getelementptr inbounds i8, ptr %13, i64 1
%17 = icmp ugt i32 %12, 14
- %18 = icmp eq i8* %16, %1
+ %18 = icmp eq ptr %16, %1
%19 = or i1 %18, %17
br i1 %19, label %8, label %10
}
More information about the llvm-commits
mailing list