Commit 8d09f207 authored by Tyker's avatar Tyker
Browse files

[AssumeBundles] Use operand bundles to encode alignment assumptions 

Summary:
NOTE: There is a mailing list discussion on this: http://lists.llvm.org/pipermail/llvm-dev/2019-December/137632.html

Complemantary to the assumption outliner prototype in D71692, this patch
shows how we could simplify the code emitted for an alignemnt
assumption. The generated code is smaller, less fragile, and it makes it
easier to recognize the additional use as a "assumption use".

As mentioned in D71692 and on the mailing list, we could adopt this
scheme, and similar schemes for other patterns, without adopting the
assumption outlining.

Reviewers: hfinkel, xbolva00, lebedev.ri, nikic, rjmccall, spatel, jdoerfert, sstefan1

Reviewed By: jdoerfert

Subscribers: thopre, yamauchi, kuter, fhahn, merge_guards_bot, hiraditya, bollu, rkruppe, cfe-commits, llvm-commits

Tags: #clang, #llvm

Differential Revision: https://reviews.llvm.org/D71739
parent e9583795

clang/lib/CodeGen/CodeGenFunction.cpp

+31 −5
Original line number Diff line number Diff line
@@ -2154,14 +2154,40 @@ void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue, 
                                              SourceLocation AssumptionLoc,

                                              llvm::Value *Alignment,

                                              llvm::Value *OffsetValue) {

  llvm::Value *TheCheck;

  llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(

      CGM.getDataLayout(), PtrValue, Alignment, OffsetValue, &TheCheck);

  if (Alignment->getType() != IntPtrTy)

    Alignment =

        Builder.CreateIntCast(Alignment, IntPtrTy, false, "casted.align");

  if (OffsetValue && OffsetValue->getType() != IntPtrTy)

    OffsetValue =

        Builder.CreateIntCast(OffsetValue, IntPtrTy, true, "casted.offset");

  llvm::Value *TheCheck = nullptr;

  if (SanOpts.has(SanitizerKind::Alignment)) {

    llvm::Value *PtrIntValue =

        Builder.CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");



    if (OffsetValue) {

      bool IsOffsetZero = false;

      if (const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))

        IsOffsetZero = CI->isZero();



      if (!IsOffsetZero)

        PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue, "offsetptr");

    }



    llvm::Value *Zero = llvm::ConstantInt::get(IntPtrTy, 0);

    llvm::Value *Mask =

        Builder.CreateSub(Alignment, llvm::ConstantInt::get(IntPtrTy, 1));

    llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask, "maskedptr");

    TheCheck = Builder.CreateICmpEQ(MaskedPtr, Zero, "maskcond");

  }

  llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(

      CGM.getDataLayout(), PtrValue, Alignment, OffsetValue);



  if (!SanOpts.has(SanitizerKind::Alignment))

    return;

  emitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, Alignment,

                               OffsetValue, TheCheck, Assumption);

}

}



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

                                              const Expr *E,

clang/test/CodeGen/align_value.cpp

+6 −24
Original line number Diff line number Diff line
@@ -29,10 +29,7 @@ struct ad_struct { 
// CHECK-NEXT:    [[TMP0:%.*]] = load %struct.ad_struct*, %struct.ad_struct** [[X_ADDR]], align 8

// CHECK-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_AD_STRUCT:%.*]], %struct.ad_struct* [[TMP0]], i32 0, i32 0

// CHECK-NEXT:    [[TMP1:%.*]] = load double*, double** [[A]], align 8

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]

// CHECK-NEXT:    ret double* [[TMP1]]

//

double *foo(ad_struct& x) {
@@ -48,10 +45,7 @@ double *foo(ad_struct& x) { 
// CHECK-NEXT:    [[TMP0:%.*]] = load %struct.ad_struct*, %struct.ad_struct** [[X_ADDR]], align 8

// CHECK-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_AD_STRUCT:%.*]], %struct.ad_struct* [[TMP0]], i32 0, i32 0

// CHECK-NEXT:    [[TMP1:%.*]] = load double*, double** [[A]], align 8

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]

// CHECK-NEXT:    ret double* [[TMP1]]

//

double *goo(ad_struct *x) {
@@ -66,10 +60,7 @@ double *goo(ad_struct *x) { 
// CHECK-NEXT:    store double** [[X]], double*** [[X_ADDR]], align 8

// CHECK-NEXT:    [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8

// CHECK-NEXT:    [[TMP1:%.*]] = load double*, double** [[TMP0]], align 8

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]

// CHECK-NEXT:    ret double* [[TMP1]]

//

double *bar(aligned_double *x) {
@@ -84,10 +75,7 @@ double *bar(aligned_double *x) { 
// CHECK-NEXT:    store double** [[X]], double*** [[X_ADDR]], align 8

// CHECK-NEXT:    [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8

// CHECK-NEXT:    [[TMP1:%.*]] = load double*, double** [[TMP0]], align 8

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]

// CHECK-NEXT:    ret double* [[TMP1]]

//

double *car(aligned_double &x) {
@@ -103,10 +91,7 @@ double *car(aligned_double &x) { 
// CHECK-NEXT:    [[TMP0:%.*]] = load double**, double*** [[X_ADDR]], align 8

// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds double*, double** [[TMP0]], i64 5

// CHECK-NEXT:    [[TMP1:%.*]] = load double*, double** [[ARRAYIDX]], align 8

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[TMP1]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[TMP1]], i64 64) ]

// CHECK-NEXT:    ret double* [[TMP1]]

//

double *dar(aligned_double *x) {
@@ -118,10 +103,7 @@ aligned_double eep(); 
// CHECK-LABEL: define {{[^@]+}}@_Z3retv() #0

// CHECK-NEXT:  entry:

// CHECK-NEXT:    [[CALL:%.*]] = call double* @_Z3eepv()

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint double* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 63

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(double* [[CALL]], i64 64) ]

// CHECK-NEXT:    ret double* [[CALL]]

//

double *ret() {

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

+10 −34
Original line number Diff line number Diff line
@@ -11,12 +11,8 @@ __INT32_TYPE__*m1(__INT32_TYPE__ i) __attribute__((alloc_align(1))); 
// CHECK-NEXT:    store i32 [[A]], i32* [[A_ADDR]], align 4

// CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m1(i32 [[TMP0]])

// CHECK-NEXT:    [[ALIGNMENTCAST:%.*]] = zext i32 [[TMP0]] to i64

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    [[CASTED_ALIGN:%.*]] = zext i32 [[TMP0]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]

// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP1]]

//
@@ -32,12 +28,8 @@ __INT32_TYPE__ test1(__INT32_TYPE__ a) { 
// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8

// CHECK-NEXT:    [[CONV:%.*]] = trunc i64 [[TMP0]] to i32

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m1(i32 [[CONV]])

// CHECK-NEXT:    [[ALIGNMENTCAST:%.*]] = zext i32 [[CONV]] to i64

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    [[CASTED_ALIGN:%.*]] = zext i32 [[CONV]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]

// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP1]]

//
@@ -55,11 +47,7 @@ __INT32_TYPE__ *m2(__SIZE_TYPE__ i) __attribute__((alloc_align(1))); 
// CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4

// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP0]] to i64

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m2(i64 [[CONV]])

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[CONV]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CONV]]) ]

// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP1]]

//
@@ -75,11 +63,7 @@ __INT32_TYPE__ test3(__INT32_TYPE__ a) { 
// CHECK-NEXT:    store i64 [[A]], i64* [[A_ADDR]], align 8

// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m2(i64 [[TMP0]])

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[TMP0]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[TMP0]]) ]

// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP1]]

//
@@ -115,12 +99,8 @@ __INT32_TYPE__ *m3(struct Empty s, __int128_t i) __attribute__((alloc_align(2))) 
// CHECK-NEXT:    [[TMP7:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP4]], i32 0, i32 1

// CHECK-NEXT:    [[TMP8:%.*]] = load i64, i64* [[TMP7]], align 8

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m3(i64 [[TMP6]], i64 [[TMP8]])

// CHECK-NEXT:    [[ALIGNMENTCAST:%.*]] = trunc i128 [[TMP3]] to i64

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    [[CASTED_ALIGN:%.*]] = trunc i128 [[TMP3]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]

// CHECK-NEXT:    [[TMP9:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP9]]

//
@@ -157,12 +137,8 @@ __INT32_TYPE__ *m4(struct MultiArgs s, __int128_t i) __attribute__((alloc_align( 
// CHECK-NEXT:    [[TMP12:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP9]], i32 0, i32 1

// CHECK-NEXT:    [[TMP13:%.*]] = load i64, i64* [[TMP12]], align 8

// CHECK-NEXT:    [[CALL:%.*]] = call i32* @m4(i64 [[TMP6]], i64 [[TMP8]], i64 [[TMP11]], i64 [[TMP13]])

// CHECK-NEXT:    [[ALIGNMENTCAST:%.*]] = trunc i128 [[TMP3]] to i64

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    [[CASTED_ALIGN:%.*]] = trunc i128 [[TMP3]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[CALL]], i64 [[CASTED_ALIGN]]) ]

// CHECK-NEXT:    [[TMP14:%.*]] = load i32, i32* [[CALL]], align 4

// CHECK-NEXT:    ret i32 [[TMP14]]

//

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

+2 −6
Original line number Diff line number Diff line
@@ -36,12 +36,8 @@ void *t2_immediate2() { 
// CHECK-NEXT:    store i32 [[ALIGNMENT:%.*]], i32* [[ALIGNMENT_ADDR]], align 4

// CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ALIGNMENT_ADDR]], align 4

// CHECK-NEXT:    [[CALL:%.*]] = call align 32 i8* @my_aligned_alloc(i32 320, i32 [[TMP0]])

// CHECK-NEXT:    [[ALIGNMENTCAST:%.*]] = zext i32 [[TMP0]] to i64

// CHECK-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENTCAST]], 1

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i8* [[CALL]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[MASK]]

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    [[TMP1:%.*]] = zext i32 [[TMP0]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[CALL]], i64 [[TMP1]]) ]

// CHECK-NEXT:    ret i8* [[CALL]]

//

void *t3_variable(int alignment) {

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

+10 −22
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ 


extern int func(char *c);



// CHECK-LABEL: define {{[^@]+}}@test_array() #0

// CHECK-LABEL: @test_array(

// CHECK-NEXT:  entry:

// CHECK-NEXT:    [[BUF:%.*]] = alloca [1024 x i8], align 16

// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 44
@@ -12,10 +12,7 @@ extern int func(char *c); 
// CHECK-NEXT:    [[ALIGNED_INTPTR:%.*]] = and i64 [[INTPTR]], -16

// CHECK-NEXT:    [[DIFF:%.*]] = sub i64 [[ALIGNED_INTPTR]], [[INTPTR]]

// CHECK-NEXT:    [[ALIGNED_RESULT:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX]], i64 [[DIFF]]

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i8* [[ALIGNED_RESULT]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 15

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT]], i64 16) ]

// CHECK-NEXT:    [[CALL:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT]])

// CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 22

// CHECK-NEXT:    [[INTPTR2:%.*]] = ptrtoint i8* [[ARRAYIDX1]] to i64
@@ -23,13 +20,10 @@ extern int func(char *c); 
// CHECK-NEXT:    [[ALIGNED_INTPTR4:%.*]] = and i64 [[OVER_BOUNDARY]], -32

// CHECK-NEXT:    [[DIFF5:%.*]] = sub i64 [[ALIGNED_INTPTR4]], [[INTPTR2]]

// CHECK-NEXT:    [[ALIGNED_RESULT6:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX1]], i64 [[DIFF5]]

// CHECK-NEXT:    [[PTRINT7:%.*]] = ptrtoint i8* [[ALIGNED_RESULT6]] to i64

// CHECK-NEXT:    [[MASKEDPTR8:%.*]] = and i64 [[PTRINT7]], 31

// CHECK-NEXT:    [[MASKCOND9:%.*]] = icmp eq i64 [[MASKEDPTR8]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND9]])

// CHECK-NEXT:    [[CALL10:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])

// CHECK-NEXT:    [[ARRAYIDX11:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 16

// CHECK-NEXT:    [[SRC_ADDR:%.*]] = ptrtoint i8* [[ARRAYIDX11]] to i64

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT6]], i64 32) ]

// CHECK-NEXT:    [[CALL7:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])

// CHECK-NEXT:    [[ARRAYIDX8:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 16

// CHECK-NEXT:    [[SRC_ADDR:%.*]] = ptrtoint i8* [[ARRAYIDX8]] to i64

// CHECK-NEXT:    [[SET_BITS:%.*]] = and i64 [[SRC_ADDR]], 63

// CHECK-NEXT:    [[IS_ALIGNED:%.*]] = icmp eq i64 [[SET_BITS]], 0

// CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[IS_ALIGNED]] to i32
@@ -42,7 +36,7 @@ int test_array(void) { 
  return __builtin_is_aligned(&buf[16], 64);

}



// CHECK-LABEL: define {{[^@]+}}@test_array_should_not_mask() #0

// CHECK-LABEL: @test_array_should_not_mask(

// CHECK-NEXT:  entry:

// CHECK-NEXT:    [[BUF:%.*]] = alloca [1024 x i8], align 32

// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 64
@@ -50,10 +44,7 @@ int test_array(void) { 
// CHECK-NEXT:    [[ALIGNED_INTPTR:%.*]] = and i64 [[INTPTR]], -16

// CHECK-NEXT:    [[DIFF:%.*]] = sub i64 [[ALIGNED_INTPTR]], [[INTPTR]]

// CHECK-NEXT:    [[ALIGNED_RESULT:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX]], i64 [[DIFF]]

// CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i8* [[ALIGNED_RESULT]] to i64

// CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 15

// CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT]], i64 16) ]

// CHECK-NEXT:    [[CALL:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT]])

// CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BUF]], i64 0, i64 32

// CHECK-NEXT:    [[INTPTR2:%.*]] = ptrtoint i8* [[ARRAYIDX1]] to i64
@@ -61,11 +52,8 @@ int test_array(void) { 
// CHECK-NEXT:    [[ALIGNED_INTPTR4:%.*]] = and i64 [[OVER_BOUNDARY]], -32

// CHECK-NEXT:    [[DIFF5:%.*]] = sub i64 [[ALIGNED_INTPTR4]], [[INTPTR2]]

// CHECK-NEXT:    [[ALIGNED_RESULT6:%.*]] = getelementptr inbounds i8, i8* [[ARRAYIDX1]], i64 [[DIFF5]]

// CHECK-NEXT:    [[PTRINT7:%.*]] = ptrtoint i8* [[ALIGNED_RESULT6]] to i64

// CHECK-NEXT:    [[MASKEDPTR8:%.*]] = and i64 [[PTRINT7]], 31

// CHECK-NEXT:    [[MASKCOND9:%.*]] = icmp eq i64 [[MASKEDPTR8]], 0

// CHECK-NEXT:    call void @llvm.assume(i1 [[MASKCOND9]])

// CHECK-NEXT:    [[CALL10:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])

// CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[ALIGNED_RESULT6]], i64 32) ]

// CHECK-NEXT:    [[CALL7:%.*]] = call i32 @func(i8* [[ALIGNED_RESULT6]])

// CHECK-NEXT:    ret i32 1

//

int test_array_should_not_mask(void) {