18 changes: 9 additions & 9 deletions llvm/test/Transforms/InferAlignment/gep-array.ll
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s

; ------------------------------------------------------------------------------
; Array of pair
Expand All @@ -18,8 +18,8 @@ define void @simple_pair(i64 %idx) {
; CHECK-LABEL: define void @simple_pair
; CHECK-SAME: (i64 [[IDX:%.*]]) {
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [4 x %pair.simple], ptr @array.simple, i64 0, i64 [[IDX]], i32 1
; CHECK-NEXT: [[RES:%.*]] = load i32, ptr [[GEP]], align 1
; CHECK-NEXT: store i32 0, ptr [[GEP]], align 1
; CHECK-NEXT: [[RES:%.*]] = load i32, ptr [[GEP]], align 8
; CHECK-NEXT: store i32 0, ptr [[GEP]], align 8
; CHECK-NEXT: ret void
;
%gep = getelementptr inbounds [4 x %pair.simple], ptr @array.simple, i64 0, i64 %idx, i32 1
Expand All @@ -39,11 +39,11 @@ define void @simple_pair(i64 %idx) {

define void @load_nested() {
; CHECK-LABEL: define void @load_nested() {
; CHECK-NEXT: [[X_0:%.*]] = load i32, ptr @array.array, align 4
; CHECK-NEXT: [[X_0:%.*]] = load i32, ptr @array.array, align 16
; CHECK-NEXT: [[X_1:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 1), align 4
; CHECK-NEXT: [[X_2:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 4
; CHECK-NEXT: [[X_2:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 8
; CHECK-NEXT: [[X_3:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 3), align 4
; CHECK-NEXT: [[X_4:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 4
; CHECK-NEXT: [[X_4:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 16
; CHECK-NEXT: ret void
;
%x.0 = load i32, ptr @array.array, align 4
Expand All @@ -56,11 +56,11 @@ define void @load_nested() {

define void @store_nested() {
; CHECK-LABEL: define void @store_nested() {
; CHECK-NEXT: store i32 1, ptr @array.array, align 4
; CHECK-NEXT: store i32 1, ptr @array.array, align 16
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 1), align 4
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 4
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 8
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 3), align 4
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 4
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 16
; CHECK-NEXT: ret void
;
store i32 1, ptr @array.array, align 4
Expand Down
20 changes: 10 additions & 10 deletions llvm/test/Transforms/InferAlignment/irregular-size.ll
View file
Original file line number Diff line number Diff line change
@@ -1,12 +1,12 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s

define void @non_pow2_size(i177 %X) {
; CHECK-LABEL: define void @non_pow2_size
; CHECK-SAME: (i177 [[X:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = alloca i177, align 1
; CHECK-NEXT: [[L1:%.*]] = load i177, ptr [[A]], align 1
; CHECK-NEXT: store i177 [[X]], ptr [[A]], align 1
; CHECK-NEXT: [[A:%.*]] = alloca i177, align 8
; CHECK-NEXT: [[L1:%.*]] = load i177, ptr [[A]], align 8
; CHECK-NEXT: store i177 [[X]], ptr [[A]], align 8
; CHECK-NEXT: ret void
;
%A = alloca i177, align 1
Expand All @@ -27,13 +27,13 @@ define void @load_vector_i4(i4 %X) {
; CHECK-NEXT: [[PTR_2:%.*]] = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 4
; CHECK-NEXT: [[PTR_3:%.*]] = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 8
; CHECK-NEXT: [[RES_0:%.*]] = load i4, ptr [[PTR_0]], align 1
; CHECK-NEXT: [[RES_1:%.*]] = load i4, ptr [[PTR_1]], align 1
; CHECK-NEXT: [[RES_2:%.*]] = load i4, ptr [[PTR_2]], align 1
; CHECK-NEXT: [[RES_3:%.*]] = load i4, ptr [[PTR_3]], align 1
; CHECK-NEXT: [[RES_1:%.*]] = load i4, ptr [[PTR_1]], align 2
; CHECK-NEXT: [[RES_2:%.*]] = load i4, ptr [[PTR_2]], align 4
; CHECK-NEXT: [[RES_3:%.*]] = load i4, ptr [[PTR_3]], align 8
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_0]], align 1
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_1]], align 1
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_2]], align 1
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_3]], align 1
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_1]], align 2
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_2]], align 4
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_3]], align 8
; CHECK-NEXT: ret void
;
%ptr.0 = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 1
Expand Down
38 changes: 19 additions & 19 deletions llvm/test/Transforms/InferAlignment/propagate-assume.ll
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s

; ------------------------------------------------------------------------------
; Simple test
Expand All @@ -12,8 +12,8 @@ define void @simple_forwardpropagate(ptr %a) {
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
; CHECK-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
; CHECK-NEXT: ret void
;
%ptrint = ptrtoint ptr %a to i64
Expand All @@ -30,8 +30,8 @@ define void @simple_forwardpropagate(ptr %a) {
define void @simple_backpropagate(ptr %a) {
; CHECK-LABEL: define void @simple_backpropagate
; CHECK-SAME: (ptr [[A:%.*]]) {
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
; CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i64
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
Expand All @@ -53,8 +53,8 @@ define void @simple_forwardpropagate_bundle(ptr %a) {
; CHECK-LABEL: define void @simple_forwardpropagate_bundle
; CHECK-SAME: (ptr [[A:%.*]]) {
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
; CHECK-NEXT: ret void
;
call void @llvm.assume(i1 true) ["align"(ptr %a, i32 32)]
Expand All @@ -66,8 +66,8 @@ define void @simple_forwardpropagate_bundle(ptr %a) {
define void @simple_backpropagate_bundle(ptr %a) {
; CHECK-LABEL: define void @simple_backpropagate_bundle
; CHECK-SAME: (ptr [[A:%.*]]) {
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
; CHECK-NEXT: ret void
;
Expand Down Expand Up @@ -97,10 +97,10 @@ define void @loop_forwardpropagate(ptr %a, ptr %b) {
; CHECK: for.body:
; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[I_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[I]]
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 4
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 64
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[LOAD_B]], 1
; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[I]]
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 4
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 64
; CHECK-NEXT: [[I_NEXT]] = add nuw nsw i64 [[I]], 16
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_NEXT]], 1648
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
Expand Down Expand Up @@ -149,10 +149,10 @@ define void @loop_forwardpropagate_bundle(ptr %a, ptr %b) {
; CHECK: for.body:
; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[I_NEXT:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[I]]
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 4
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 64
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[LOAD_B]], 1
; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[I]]
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 4
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 64
; CHECK-NEXT: [[I_NEXT]] = add nuw nsw i64 [[I]], 16
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_NEXT]], 1648
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
Expand Down Expand Up @@ -190,11 +190,11 @@ define void @complex_backpropagate(ptr %a, ptr %b, ptr %c) {
; CHECK-LABEL: define void @complex_backpropagate
; CHECK-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i64, align 8
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 4
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 32
; CHECK-NEXT: [[OBJ_SIZE:%.*]] = call i64 @llvm.objectsize.i64.p0(ptr [[C]], i1 false, i1 false, i1 false)
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 4
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 8
; CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i64
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
Expand Down Expand Up @@ -222,11 +222,11 @@ define void @complex_backpropagate_bundle(ptr %a, ptr %b, ptr %c) {
; CHECK-LABEL: define void @complex_backpropagate_bundle
; CHECK-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i64, align 8
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 4
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 32
; CHECK-NEXT: [[OBJ_SIZE:%.*]] = call i64 @llvm.objectsize.i64.p0(ptr [[C]], i1 false, i1 false, i1 false)
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 4
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 8
; CHECK-NEXT: tail call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
; CHECK-NEXT: ret void
;
Expand Down
18 changes: 9 additions & 9 deletions llvm/test/Transforms/InferAlignment/ptrmask.ll
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s

; ------------------------------------------------------------------------------
; load instructions
Expand All @@ -11,9 +11,9 @@ define void @load(ptr align 1 %ptr) {
; CHECK-NEXT: [[ALIGNED_0:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -2)
; CHECK-NEXT: [[ALIGNED_1:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -4)
; CHECK-NEXT: [[ALIGNED_2:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr [[ALIGNED_0]], align 1
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[ALIGNED_1]], align 1
; CHECK-NEXT: [[LOAD_2:%.*]] = load <16 x i8>, ptr [[ALIGNED_2]], align 1
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr [[ALIGNED_0]], align 2
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[ALIGNED_1]], align 4
; CHECK-NEXT: [[LOAD_2:%.*]] = load <16 x i8>, ptr [[ALIGNED_2]], align 8
; CHECK-NEXT: ret void
;
%aligned.0 = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2)
Expand All @@ -37,9 +37,9 @@ define void @store(ptr align 1 %ptr) {
; CHECK-NEXT: [[ALIGNED_0:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -2)
; CHECK-NEXT: [[ALIGNED_1:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -4)
; CHECK-NEXT: [[ALIGNED_2:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_0]], align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_1]], align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_2]], align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_0]], align 2
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_1]], align 4
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_2]], align 8
; CHECK-NEXT: ret void
;
%aligned.0 = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2)
Expand All @@ -62,8 +62,8 @@ define void @ptrmask_overaligned(ptr align 16 %ptr) {
; CHECK-LABEL: define void @ptrmask_overaligned
; CHECK-SAME: (ptr align 16 [[PTR:%.*]]) {
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED]], align 1
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 16
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED]], align 16
; CHECK-NEXT: ret void
;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8)
Expand Down
6 changes: 3 additions & 3 deletions llvm/test/Transforms/InferAlignment/undef-and-null.ll
View file
Original file line number Diff line number Diff line change
@@ -1,11 +1,11 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s

define void @load_undef_null(ptr %P) {
; CHECK-LABEL: define void @load_undef_null
; CHECK-SAME: (ptr [[P:%.*]]) {
; CHECK-NEXT: [[RET_0:%.*]] = load i32, ptr undef, align 4
; CHECK-NEXT: [[RET_1:%.*]] = load i32, ptr null, align 4
; CHECK-NEXT: [[RET_1:%.*]] = load i32, ptr null, align 4294967296
; CHECK-NEXT: ret void
;
%ret.0 = load i32, ptr undef
Expand All @@ -17,7 +17,7 @@ define void @store_undef_null(ptr %P) {
; CHECK-LABEL: define void @store_undef_null
; CHECK-SAME: (ptr [[P:%.*]]) {
; CHECK-NEXT: store i32 123, ptr undef, align 4
; CHECK-NEXT: store i32 124, ptr null, align 4
; CHECK-NEXT: store i32 124, ptr null, align 4294967296
; CHECK-NEXT: ret void
;
store i32 123, ptr undef
Expand Down
26 changes: 13 additions & 13 deletions llvm/test/Transforms/InferAlignment/vector.ll
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s

; InferAlignment should be able to prove vector alignment in the
; presence of a few mild address computation tricks.
Expand All @@ -12,8 +12,8 @@ define void @alloca(<2 x i64> %y) {
; CHECK-LABEL: define void @alloca
; CHECK-SAME: (<2 x i64> [[Y:%.*]]) {
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca <2 x i64>, align 16
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[ALLOCA]], align 1
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[ALLOCA]], align 1
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[ALLOCA]], align 16
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[ALLOCA]], align 16
; CHECK-NEXT: ret void
;
%alloca = alloca <2 x i64>
Expand All @@ -31,8 +31,8 @@ define void @alloca(<2 x i64> %y) {
define void @global(<2 x i64> %y) {
; CHECK-LABEL: define void @global
; CHECK-SAME: (<2 x i64> [[Y:%.*]]) {
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr @x.vector, align 1
; CHECK-NEXT: store <2 x i64> [[Y]], ptr @x.vector, align 1
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr @x.vector, align 16
; CHECK-NEXT: store <2 x i64> [[Y]], ptr @x.vector, align 16
; CHECK-NEXT: ret void
;
%load = load <2 x i64>, ptr @x.vector, align 1
Expand All @@ -55,8 +55,8 @@ define void @vector_singular(i32 %i, <2 x i64> %y) {
; CHECK-LABEL: define void @vector_singular
; CHECK-SAME: (i32 [[I:%.*]], <2 x i64> [[Y:%.*]]) {
; CHECK-NEXT: [[GEP:%.*]] = getelementptr <2 x i64>, ptr @vector, i32 [[I]]
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 1
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 1
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 16
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 16
; CHECK-NEXT: ret void
;
%gep = getelementptr <2 x i64>, ptr @vector, i32 %i
Expand All @@ -73,8 +73,8 @@ define void @vector_array(i32 %i, i32 %j, <2 x i64> %y) {
; CHECK-LABEL: define void @vector_array
; CHECK-SAME: (i32 [[I:%.*]], i32 [[J:%.*]], <2 x i64> [[Y:%.*]]) {
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [13 x <2 x i64>], ptr @vector.arr, i32 [[I]], i32 [[J]]
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 1
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 1
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 16
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 16
; CHECK-NEXT: ret void
;
%gep = getelementptr [13 x <2 x i64>], ptr @vector.arr, i32 %i, i32 %j
Expand All @@ -93,11 +93,11 @@ define void @vector_array(i32 %i, i32 %j, <2 x i64> %y) {

define void @nonvector_array() {
; CHECK-LABEL: define void @nonvector_array() {
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr @x.array, align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr @x.array, align 1
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr @x.array, align 16
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr @x.array, align 16
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [4 x i32], ptr @x.array, i16 0, i16 2
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[GEP]], align 1
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[GEP]], align 1
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[GEP]], align 8
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[GEP]], align 8
; CHECK-NEXT: ret void
;
%load.0 = load <16 x i8>, ptr @x.array, align 1
Expand Down
6 changes: 3 additions & 3 deletions llvm/test/Transforms/InferAlignment/volatile.ll
View file
Original file line number Diff line number Diff line change
@@ -1,11 +1,11 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s

define void @load_volatile() {
; CHECK-LABEL: define void @load_volatile() {
; CHECK-NEXT: [[A:%.*]] = alloca { i32 }, align 8
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load volatile i32, ptr [[A]], align 4
; CHECK-NEXT: [[LOAD_A:%.*]] = load volatile i32, ptr [[A]], align 8
; CHECK-NEXT: [[LOAD_B:%.*]] = load volatile i32, ptr [[B]], align 4
; CHECK-NEXT: ret void
;
Expand All @@ -20,7 +20,7 @@ define void @store_volatile() {
; CHECK-LABEL: define void @store_volatile() {
; CHECK-NEXT: [[A:%.*]] = alloca { i32 }, align 8
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: store volatile i32 123, ptr [[A]], align 4
; CHECK-NEXT: store volatile i32 123, ptr [[A]], align 8
; CHECK-NEXT: store volatile i32 123, ptr [[B]], align 4
; CHECK-NEXT: ret void
;
Expand Down
6 changes: 3 additions & 3 deletions llvm/test/Transforms/InferAlignment/vscale.ll
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s

; <4 x i32> -> 16 byte alignment
define void @alignment_sustain(ptr align 16 %ptr) {
Expand All @@ -23,8 +23,8 @@ define void @alignment_increase(ptr align 32 %ptr) {
; CHECK-LABEL: define void @alignment_increase
; CHECK-SAME: (ptr align 32 [[PTR:%.*]]) {
; CHECK-NEXT: [[GEP:%.*]] = getelementptr <vscale x 8 x i32>, ptr [[PTR]], i32 3
; CHECK-NEXT: [[LOAD:%.*]] = load <8 x i32>, ptr [[GEP]], align 16
; CHECK-NEXT: store <8 x i32> zeroinitializer, ptr [[GEP]], align 16
; CHECK-NEXT: [[LOAD:%.*]] = load <8 x i32>, ptr [[GEP]], align 32
; CHECK-NEXT: store <8 x i32> zeroinitializer, ptr [[GEP]], align 32
; CHECK-NEXT: ret void
;
%gep = getelementptr <vscale x 8 x i32>, ptr %ptr, i32 3
Expand Down