[InstCombine] Deduce attributes for aligned_alloc in InstCombine

[bondhugula]

Summary

Make InstCombine aware of the aligned_alloc library function.

Signed-off-by: Uday Bondhugula <[e-mail]>

Depends on D76970.

[jdoerfert]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

When Op0C is set (regardless of Op1C), we can set the alignment attribute on the return value, can't we?

[bondhugula]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

Would it be correct to set the alignment attribute for 0 sized allocations?

[jdoerfert]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

Would it be correct to set the alignment attribute for 0 sized allocations?

Not in general, but: The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a multiple of alignment. So for a non-zero alignment size need to be non-zero. Please correct me if I'm wrong though.

[bondhugula]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

The size could still be zero. (zero as size would be a multiple of any alignment. :-))

[jdoerfert]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

The size could still be zero. (zero as size would be a multiple of any alignment. :-))

True, it was late.

Then remove the "(regardless of Op1C),") from my original comment. We still can and should add alignment information.

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

39

I mean, we can add align 32 here can't we not?

[bondhugula]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

4461

Sure, we should. I was just making sure under what circumstances we could. Will add this, thanks.

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

39

Absolutely!

[bondhugula]

Address review comments; add alignment attribute to aligned_alloc sites

[bondhugula]

Thanks for the review, @jdoerfert Done.

[bondhugula]

add attribute only if the alignment is a power of two

[xbolva00]

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

37

aligned_alloc(i64 %align, i64 512)
aligned_alloc(i64 0, i64 512)

Please add such tests

[bondhugula]

More test cases.

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

37

Thanks!

[xbolva00]

Looks good to me. Wait a day or so before landing.

[jdoerfert]

LGTM as well. Thx and sorry for the confusion.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

static IntrinsicInst *findInitTrampoline(Value *Callee) {
   return nullptr;
 }
 
 static void annotateAnyAllocSite(CallBase &Call, const TargetLibraryInfo *TLI) {
   unsigned NumArgs = Call.getNumArgOperands();
   ConstantInt *Op0C = dyn_cast<ConstantInt>(Call.getOperand(0));
   ConstantInt *Op1C =
       (NumArgs == 1) ? nullptr : dyn_cast<ConstantInt>(Call.getOperand(1));
-  // Bail out if the allocation size is zero.
+  // Bail out if the allocation size is zero (or an invalid alignment of zero
+  // with aligned_alloc).
   if ((Op0C && Op0C->isNullValue()) || (Op1C && Op1C->isNullValue()))
     return;
 
   if (isMallocLikeFn(&Call, TLI) && Op0C) {
     if (isOpNewLikeFn(&Call, TLI))
       Call.addAttribute(AttributeList::ReturnIndex,
                         Attribute::getWithDereferenceableBytes(
                             Call.getContext(), Op0C->getZExtValue()));
     else
       Call.addAttribute(AttributeList::ReturnIndex,
                         Attribute::getWithDereferenceableOrNullBytes(
                             Call.getContext(), Op0C->getZExtValue()));
+  } else if (isAlignedAllocLikeFn(&Call, TLI) && Op1C) {
+    Call.addAttribute(AttributeList::ReturnIndex,
+                      Attribute::getWithDereferenceableOrNullBytes(
+                          Call.getContext(), Op1C->getZExtValue()));
+    // Add alignment attribute if alignment is a power of two constant.
+    if (Op0C) {
+      uint64_t AlignmentVal = Op0C->getZExtValue();
+      if (llvm::isPowerOf2_64(AlignmentVal))
+        Call.addAttribute(AttributeList::ReturnIndex,
+                          Attribute::getWithAlignment(Call.getContext(),
+                                                      Align(AlignmentVal)));
+    }
   } else if (isReallocLikeFn(&Call, TLI) && Op1C) {
     Call.addAttribute(AttributeList::ReturnIndex,
                       Attribute::getWithDereferenceableOrNullBytes(
                           Call.getContext(), Op1C->getZExtValue()));
   } else if (isCallocLikeFn(&Call, TLI) && Op0C && Op1C) {
     bool Overflow;
     const APInt &N = Op0C->getValue();
     APInt Size = N.umul_ov(Op1C->getValue(), Overflow);

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine  -S < %s | FileCheck %s
 
 declare noalias i8* @malloc(i64)
 declare noalias i8* @calloc(i64, i64)
 declare noalias i8* @realloc(i8* nocapture, i64)
 declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new'
 declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new'
 declare noalias i8* @strdup(i8*)
+declare noalias i8* @aligned_alloc(i64, i64)
 
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 
 define noalias i8* @malloc_nonconstant_size(i64 %n) {
 ; CHECK-LABEL: @malloc_nonconstant_size(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias i8* @malloc(i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call noalias i8* @malloc(i64 %n)
   ret i8* %call
 }
 
 define noalias i8* @malloc_constant_size() {
 ; CHECK-LABEL: @malloc_constant_size(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias dereferenceable_or_null(40) i8* @malloc(i64 40)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call noalias i8* @malloc(i64 40)
   ret i8* %call
 }
 
+define noalias i8* @aligned_alloc_constant_size() {
+; CHECK-LABEL: @aligned_alloc_constant_size(
+; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @aligned_alloc(i64 32, i64 512)
+; CHECK-NEXT:    ret i8* [[CALL]]
+;
+  %call = tail call noalias i8* @aligned_alloc(i64 32, i64 512)
+  ret i8* %call
+}
+
+declare noalias i8* @foo(i8*, i8*, i8*)
+
+define noalias i8* @aligned_alloc_dynamic_args(i64 %align, i64 %size) {
+; CHECK-LABEL: @aligned_alloc_dynamic_args(
+; CHECK-NEXT:    tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 %{{.*}}, i64 1024)
+; CHECK-NEXT:    tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
+; CHECK-NEXT:    tail call noalias i8* @aligned_alloc(i64 32, i64 %{{.*}})
+;
+  %call = tail call noalias i8* @aligned_alloc(i64 %align, i64 1024)
+  %call_1 = tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
+  %call_2 = tail call noalias i8* @aligned_alloc(i64 32, i64 %size)
+
+  call i8* @foo(i8* %call, i8* %call_1, i8* %call_2)
+  ret i8* %call
+}
+
 define noalias i8* @malloc_constant_size2() {
 ; CHECK-LABEL: @malloc_constant_size2(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias dereferenceable_or_null(80) i8* @malloc(i64 40)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call noalias dereferenceable_or_null(80) i8* @malloc(i64 40)
   ret i8* %call
 }
 
 define noalias i8* @malloc_constant_size3() {
 ; CHECK-LABEL: @malloc_constant_size3(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias dereferenceable(80) dereferenceable_or_null(40) i8* @malloc(i64 40)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call noalias dereferenceable(80) i8* @malloc(i64 40)
   ret i8* %call
 }
 
-
 define noalias i8* @malloc_constant_zero_size() {
 ; CHECK-LABEL: @malloc_constant_zero_size(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias i8* @malloc(i64 0)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = tail call noalias i8* @malloc(i64 0)
   ret i8* %call
 }

llvm/test/Transforms/InstCombine/malloc-free-delete.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 ; PR1201
 define i32 @main(i32 %argc, i8** %argv) {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:    ret i32 0
 ;
   %c_19 = alloca i8*
   %malloc_206 = tail call i8* @malloc(i32 mul (i32 ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i32), i32 10))
   store i8* %malloc_206, i8** %c_19
   %tmp_207 = load i8*, i8** %c_19
   tail call void @free(i8* %tmp_207)
   ret i32 0
 }
 
+define i32 @dead_aligned_alloc(i32 %size, i32 %alignment, i8 %value) {
+; CHECK-LABEL: @dead_aligned_alloc(
+; CHECK-NEXT:    ret i32 0
+;
+  %aligned_allocation = tail call i8* @aligned_alloc(i32 %alignment, i32 %size)
+  store i8 %value, i8* %aligned_allocation
+  tail call void @free(i8* %aligned_allocation)
+  ret i32 0
+}
+
 declare noalias i8* @calloc(i32, i32) nounwind
 declare noalias i8* @malloc(i32)
+declare noalias i8* @aligned_alloc(i32, i32)
 declare void @free(i8*)
 
 define i1 @foo() {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:    ret i1 false
 ;
   %m = call i8* @malloc(i32 1)
   %z = icmp eq i8* %m, null