Skip to content

Commit 7bfaa40

Browse files
echristoechristo
committed
Temporarily Revert "[AssumeBundles] Use operand bundles to encode alignment assumptions"
due to the performance bugs filed in https://bugs.llvm.org/show_bug.cgi?id=46753. An SROA change soon may obviate some of these problems. This reverts commit 8d09f20.
1 parent 8f0a8ed commit 7bfaa40

35 files changed

+627
-369
lines changed

‎clang/lib/CodeGen/CodeGenFunction.cpp

Lines changed: 5 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -2154,39 +2154,13 @@ void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue,
21542154
SourceLocation AssumptionLoc,
21552155
llvm::Value *Alignment,
21562156
llvm::Value *OffsetValue) {
2157-
if (Alignment->getType() != IntPtrTy)
2158-
Alignment =
2159-
Builder.CreateIntCast(Alignment, IntPtrTy, false, "casted.align");
2160-
if (OffsetValue && OffsetValue->getType() != IntPtrTy)
2161-
OffsetValue =
2162-
Builder.CreateIntCast(OffsetValue, IntPtrTy, true, "casted.offset");
2163-
llvm::Value *TheCheck = nullptr;
2157+
llvm::Value *TheCheck;
2158+
llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2159+
CGM.getDataLayout(), PtrValue, Alignment, OffsetValue, &TheCheck);
21642160
if (SanOpts.has(SanitizerKind::Alignment)) {
2165-
llvm::Value *PtrIntValue =
2166-
Builder.CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
2167-
2168-
if (OffsetValue) {
2169-
bool IsOffsetZero = false;
2170-
if (const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
2171-
IsOffsetZero = CI->isZero();
2172-
2173-
if (!IsOffsetZero)
2174-
PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue, "offsetptr");
2175-
}
2176-
2177-
llvm::Value *Zero = llvm::ConstantInt::get(IntPtrTy, 0);
2178-
llvm::Value *Mask =
2179-
Builder.CreateSub(Alignment, llvm::ConstantInt::get(IntPtrTy, 1));
2180-
llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask, "maskedptr");
2181-
TheCheck = Builder.CreateICmpEQ(MaskedPtr, Zero, "maskcond");
2161+
emitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2162+
OffsetValue, TheCheck, Assumption);
21822163
}
2183-
llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2184-
CGM.getDataLayout(), PtrValue, Alignment, OffsetValue);
2185-
2186-
if (!SanOpts.has(SanitizerKind::Alignment))
2187-
return;
2188-
emitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2189-
OffsetValue, TheCheck, Assumption);
21902164
}
21912165

21922166
void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue,

‎clang/test/CodeGen/align_value.cpp

Lines changed: 24 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,10 @@ struct ad_struct {
2929
// CHECK-NEXT: [[TMP0:%.*]] = load %struct.ad_struct*, %struct.ad_struct** [[X_ADDR]], align 8
3030
// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[STRUCT_AD_STRUCT:%.*]], %struct.ad_struct* [[TMP0]], i32 0, i32 0
3131
// CHECK-NEXT: [[TMP1:%.*]] = load double*, double** [[A]], align 8
32-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]
32+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64
33+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
34+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
35+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
3336
// CHECK-NEXT: ret double* [[TMP1]]
3437
//
3538
double *foo(ad_struct& x) {
@@ -45,7 +48,10 @@ double *foo(ad_struct& x) {
4548
// CHECK-NEXT: [[TMP0:%.*]] = load %struct.ad_struct*, %struct.ad_struct** [[X_ADDR]], align 8
4649
// CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[STRUCT_AD_STRUCT:%.*]], %struct.ad_struct* [[TMP0]], i32 0, i32 0
4750
// CHECK-NEXT: [[TMP1:%.*]] = load double*, double** [[A]], align 8
48-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]
51+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64
52+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
53+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
54+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
4955
// CHECK-NEXT: ret double* [[TMP1]]
5056
//
5157
double *goo(ad_struct *x) {
@@ -60,7 +66,10 @@ double *goo(ad_struct *x) {
6066
// CHECK-NEXT: store double** [[X]], double*** [[X_ADDR]], align 8
6167
// CHECK-NEXT: [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8
6268
// CHECK-NEXT: [[TMP1:%.*]] = load double*, double** [[TMP0]], align 8
63-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]
69+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64
70+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
71+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
72+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
6473
// CHECK-NEXT: ret double* [[TMP1]]
6574
//
6675
double *bar(aligned_double *x) {
@@ -75,7 +84,10 @@ double *bar(aligned_double *x) {
7584
// CHECK-NEXT: store double** [[X]], double*** [[X_ADDR]], align 8
7685
// CHECK-NEXT: [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8
7786
// CHECK-NEXT: [[TMP1:%.*]] = load double*, double** [[TMP0]], align 8
78-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]
87+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64
88+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
89+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
90+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
7991
// CHECK-NEXT: ret double* [[TMP1]]
8092
//
8193
double *car(aligned_double &x) {
@@ -91,7 +103,10 @@ double *car(aligned_double &x) {
91103
// CHECK-NEXT: [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8
92104
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds double*, double** [[TMP0]], i64 5
93105
// CHECK-NEXT: [[TMP1:%.*]] = load double*, double** [[ARRAYIDX]], align 8
94-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]
106+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64
107+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
108+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
109+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
95110
// CHECK-NEXT: ret double* [[TMP1]]
96111
//
97112
double *dar(aligned_double *x) {
@@ -103,7 +118,10 @@ aligned_double eep();
103118
// CHECK-LABEL: define {{[^@]+}}@_Z3retv() #0
104119
// CHECK-NEXT: entry:
105120
// CHECK-NEXT: [[CALL:%.*]] = call double* @_Z3eepv()
106-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(double* [[CALL]], i64 64) ]
121+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint double* [[CALL]] to i64
122+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63
123+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
124+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
107125
// CHECK-NEXT: ret double* [[CALL]]
108126
//
109127
double *ret() {

‎clang/test/CodeGen/alloc-align-attr.c

Lines changed: 34 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,12 @@ __INT32_TYPE__*m1(__INT32_TYPE__ i) __attribute__((alloc_align(1)));
1111
// CHECK-NEXT: store i32 [[A]], i32* [[A_ADDR]], align 4
1212
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4
1313
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m1(i32 [[TMP0]])
14-
// CHECK-NEXT: [[CASTED_ALIGN:%.*]] = zext i32 [[TMP0]] to i64
15-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]
14+
// CHECK-NEXT: [[ALIGNMENTCAST:%.*]] = zext i32 [[TMP0]] to i64
15+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1
16+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
17+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
18+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
19+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
1620
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4
1721
// CHECK-NEXT: ret i32 [[TMP1]]
1822
//
@@ -28,8 +32,12 @@ __INT32_TYPE__ test1(__INT32_TYPE__ a) {
2832
// CHECK-NEXT: [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
2933
// CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[TMP0]] to i32
3034
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m1(i32 [[CONV]])
31-
// CHECK-NEXT: [[CASTED_ALIGN:%.*]] = zext i32 [[CONV]] to i64
32-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]
35+
// CHECK-NEXT: [[ALIGNMENTCAST:%.*]] = zext i32 [[CONV]] to i64
36+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1
37+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
38+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
39+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
40+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
3341
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4
3442
// CHECK-NEXT: ret i32 [[TMP1]]
3543
//
@@ -47,7 +55,11 @@ __INT32_TYPE__ *m2(__SIZE_TYPE__ i) __attribute__((alloc_align(1)));
4755
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4
4856
// CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP0]] to i64
4957
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m2(i64 [[CONV]])
50-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CONV]]) ]
58+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[CONV]], 1
59+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
60+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
61+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
62+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
5163
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4
5264
// CHECK-NEXT: ret i32 [[TMP1]]
5365
//
@@ -63,7 +75,11 @@ __INT32_TYPE__ test3(__INT32_TYPE__ a) {
6375
// CHECK-NEXT: store i64 [[A]], i64* [[A_ADDR]], align 8
6476
// CHECK-NEXT: [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
6577
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m2(i64 [[TMP0]])
66-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[TMP0]]) ]
78+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[TMP0]], 1
79+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
80+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
81+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
82+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
6783
// CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4
6884
// CHECK-NEXT: ret i32 [[TMP1]]
6985
//
@@ -99,8 +115,12 @@ __INT32_TYPE__ *m3(struct Empty s, __int128_t i) __attribute__((alloc_align(2)))
99115
// CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP4]], i32 0, i32 1
100116
// CHECK-NEXT: [[TMP8:%.*]] = load i64, i64* [[TMP7]], align 8
101117
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m3(i64 [[TMP6]], i64 [[TMP8]])
102-
// CHECK-NEXT: [[CASTED_ALIGN:%.*]] = trunc i128 [[TMP3]] to i64
103-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]
118+
// CHECK-NEXT: [[ALIGNMENTCAST:%.*]] = trunc i128 [[TMP3]] to i64
119+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1
120+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
121+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
122+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
123+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
104124
// CHECK-NEXT: [[TMP9:%.*]] = load i32, i32* [[CALL]], align 4
105125
// CHECK-NEXT: ret i32 [[TMP9]]
106126
//
@@ -137,8 +157,12 @@ __INT32_TYPE__ *m4(struct MultiArgs s, __int128_t i) __attribute__((alloc_align(
137157
// CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP9]], i32 0, i32 1
138158
// CHECK-NEXT: [[TMP13:%.*]] = load i64, i64* [[TMP12]], align 8
139159
// CHECK-NEXT: [[CALL:%.*]] = call i32* @m4(i64 [[TMP6]], i64 [[TMP8]], i64 [[TMP11]], i64 [[TMP13]])
140-
// CHECK-NEXT: [[CASTED_ALIGN:%.*]] = trunc i128 [[TMP3]] to i64
141-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]
160+
// CHECK-NEXT: [[ALIGNMENTCAST:%.*]] = trunc i128 [[TMP3]] to i64
161+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1
162+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64
163+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
164+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
165+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
142166
// CHECK-NEXT: [[TMP14:%.*]] = load i32, i32* [[CALL]], align 4
143167
// CHECK-NEXT: ret i32 [[TMP14]]
144168
//

‎clang/test/CodeGen/assume-aligned-and-alloc-align-attributes.c

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -36,8 +36,12 @@ void *t2_immediate2() {
3636
// CHECK-NEXT: store i32 [[ALIGNMENT:%.*]], i32* [[ALIGNMENT_ADDR]], align 4
3737
// CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ALIGNMENT_ADDR]], align 4
3838
// CHECK-NEXT: [[CALL:%.*]] = call align 32 i8* @my_aligned_alloc(i32 320, i32 [[TMP0]])
39-
// CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[TMP0]] to i64
40-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[CALL]], i64 [[TMP1]]) ]
39+
// CHECK-NEXT: [[ALIGNMENTCAST:%.*]] = zext i32 [[TMP0]] to i64
40+
// CHECK-NEXT: [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1
41+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i8* [[CALL]] to i64
42+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]
43+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
44+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
4145
// CHECK-NEXT: ret i8* [[CALL]]
4246
//
4347
void *t3_variable(int alignment) {

‎clang/test/CodeGen/builtin-align-array.c

Lines changed: 22 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4,26 +4,32 @@
44

55
extern int func(char *c);
66

7-
// CHECK-LABEL: @test_array(
7+
// CHECK-LABEL: define {{[^@]+}}@test_array() #0
88
// CHECK-NEXT: entry:
99
// CHECK-NEXT: [[BUF:%.*]] = alloca [1024 x i8], align 16
1010
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 44
1111
// CHECK-NEXT: [[INTPTR:%.*]] = ptrtoint i8* [[ARRAYIDX]] to i64
1212
// CHECK-NEXT: [[ALIGNED_INTPTR:%.*]] = and i64 [[INTPTR]], -16
1313
// CHECK-NEXT: [[DIFF:%.*]] = sub i64 [[ALIGNED_INTPTR]], [[INTPTR]]
1414
// CHECK-NEXT: [[ALIGNED_RESULT:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX]], i64 [[DIFF]]
15-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT]], i64 16) ]
15+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i8* [[ALIGNED_RESULT]] to i64
16+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 15
17+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
18+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
1619
// CHECK-NEXT: [[CALL:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT]])
1720
// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 22
1821
// CHECK-NEXT: [[INTPTR2:%.*]] = ptrtoint i8* [[ARRAYIDX1]] to i64
1922
// CHECK-NEXT: [[OVER_BOUNDARY:%.*]] = add i64 [[INTPTR2]], 31
2023
// CHECK-NEXT: [[ALIGNED_INTPTR4:%.*]] = and i64 [[OVER_BOUNDARY]], -32
2124
// CHECK-NEXT: [[DIFF5:%.*]] = sub i64 [[ALIGNED_INTPTR4]], [[INTPTR2]]
2225
// CHECK-NEXT: [[ALIGNED_RESULT6:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX1]], i64 [[DIFF5]]
23-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT6]], i64 32) ]
24-
// CHECK-NEXT: [[CALL7:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])
25-
// CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 16
26-
// CHECK-NEXT: [[SRC_ADDR:%.*]] = ptrtoint i8* [[ARRAYIDX8]] to i64
26+
// CHECK-NEXT: [[PTRINT7:%.*]] = ptrtoint i8* [[ALIGNED_RESULT6]] to i64
27+
// CHECK-NEXT: [[MASKEDPTR8:%.*]] = and i64 [[PTRINT7]], 31
28+
// CHECK-NEXT: [[MASKCOND9:%.*]] = icmp eq i64 [[MASKEDPTR8]], 0
29+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND9]])
30+
// CHECK-NEXT: [[CALL10:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])
31+
// CHECK-NEXT: [[ARRAYIDX11:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 16
32+
// CHECK-NEXT: [[SRC_ADDR:%.*]] = ptrtoint i8* [[ARRAYIDX11]] to i64
2733
// CHECK-NEXT: [[SET_BITS:%.*]] = and i64 [[SRC_ADDR]], 63
2834
// CHECK-NEXT: [[IS_ALIGNED:%.*]] = icmp eq i64 [[SET_BITS]], 0
2935
// CHECK-NEXT: [[CONV:%.*]] = zext i1 [[IS_ALIGNED]] to i32
@@ -36,24 +42,30 @@ int test_array(void) {
3642
return __builtin_is_aligned(&buf[16], 64);
3743
}
3844

39-
// CHECK-LABEL: @test_array_should_not_mask(
45+
// CHECK-LABEL: define {{[^@]+}}@test_array_should_not_mask() #0
4046
// CHECK-NEXT: entry:
4147
// CHECK-NEXT: [[BUF:%.*]] = alloca [1024 x i8], align 32
4248
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 64
4349
// CHECK-NEXT: [[INTPTR:%.*]] = ptrtoint i8* [[ARRAYIDX]] to i64
4450
// CHECK-NEXT: [[ALIGNED_INTPTR:%.*]] = and i64 [[INTPTR]], -16
4551
// CHECK-NEXT: [[DIFF:%.*]] = sub i64 [[ALIGNED_INTPTR]], [[INTPTR]]
4652
// CHECK-NEXT: [[ALIGNED_RESULT:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX]], i64 [[DIFF]]
47-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT]], i64 16) ]
53+
// CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint i8* [[ALIGNED_RESULT]] to i64
54+
// CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 15
55+
// CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
56+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND]])
4857
// CHECK-NEXT: [[CALL:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT]])
4958
// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 32
5059
// CHECK-NEXT: [[INTPTR2:%.*]] = ptrtoint i8* [[ARRAYIDX1]] to i64
5160
// CHECK-NEXT: [[OVER_BOUNDARY:%.*]] = add i64 [[INTPTR2]], 31
5261
// CHECK-NEXT: [[ALIGNED_INTPTR4:%.*]] = and i64 [[OVER_BOUNDARY]], -32
5362
// CHECK-NEXT: [[DIFF5:%.*]] = sub i64 [[ALIGNED_INTPTR4]], [[INTPTR2]]
5463
// CHECK-NEXT: [[ALIGNED_RESULT6:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX1]], i64 [[DIFF5]]
55-
// CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT6]], i64 32) ]
56-
// CHECK-NEXT: [[CALL7:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])
64+
// CHECK-NEXT: [[PTRINT7:%.*]] = ptrtoint i8* [[ALIGNED_RESULT6]] to i64
65+
// CHECK-NEXT: [[MASKEDPTR8:%.*]] = and i64 [[PTRINT7]], 31
66+
// CHECK-NEXT: [[MASKCOND9:%.*]] = icmp eq i64 [[MASKEDPTR8]], 0
67+
// CHECK-NEXT: call void @llvm.assume(i1 [[MASKCOND9]])
68+
// CHECK-NEXT: [[CALL10:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])
5769
// CHECK-NEXT: ret i32 1
5870
//
5971
int test_array_should_not_mask(void) {

0 commit comments

Comments
 (0)