[InstCombine] Sink noaliasing calls that can have side-effects

[anna]

Summary

Further improvement to D109917 so that we can sink noalias calls that
have side-effects down to their use. See updated testcases around
allocations.

[anna]

already handled as needed.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

if (isa<CatchSwitchInst>(DestBlock->getTerminator()))
     return false;
 
   // Do not sink convergent call instructions.
   if (auto *CI = dyn_cast<CallInst>(I)) {
     if (CI->isConvergent())
       return false;
   }
   // We can only sink load instructions if there is nothing between the load and
-  // the end of block that could change the value.
-  if (I->mayReadFromMemory()) {
+  // the end of block that could change the value. We do not need to do these
+  // checks if we have a call with noalias return attribute.
+  if (I->mayReadFromMemory() && !isNoAliasCall(I)) {
     // We don't want to do any sophisticated alias analysis, so we only check
     // the instructions after I in I's parent block if we try to sink to its
     // successor block.
     if (DestBlock->getUniquePredecessor() != I->getParent())
       return false;
     for (BasicBlock::iterator Scan = I->getIterator(),
                               E = I->getParent()->end();
          Scan != E; ++Scan)

llvm/test/Transforms/InstCombine/sink_instruction.ll

 
 if:
   call void @checkd(double %A)
   ret void
 else:
   ret void
 }
 
-; TODO: We can sink down the allocation to its only use.
+; We can sink down the allocation to its only use.
 define i8** @test_allocation_sink_bc(i1 %cond) {
 ; CHECK-LABEL: @test_allocation_sink_bc(
-; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
-; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; CHECK:         br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
 ; CHECK:       if:
+; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
 ; CHECK-NEXT:    [[X:%.*]] = bitcast i8* [[A]] to i8**
 ; CHECK-NEXT:    ret i8** [[X]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[B:%.*]] = call dereferenceable_or_null(24000) i8* @malloc(i32 24000)
 ; CHECK-NEXT:    [[Y:%.*]] = bitcast i8* [[B]] to i8**
 ; CHECK-NEXT:    ret i8** [[Y]]
 ;
   %A = call i8* @malloc(i32 16000)
   br i1 %cond, label %if, label %else
 
 if:
   %X = bitcast i8* %A to i8**
   ret i8** %X
 
 
 else:
   %B = call i8* @malloc(i32 24000)
   %Y = bitcast i8* %B to i8**
   ret i8** %Y
 }
 
-; TODO: We can sink down the allocation to its only use.
+; We can sink down the allocation to its only use.
 define void @test_allocation_sink(i1 %cond) {
 ; CHECK-LABEL: @test_allocation_sink(
-; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
-; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; CHECK:         br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
 ; CHECK:       if:
+; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
 ; CHECK-NEXT:    call void @check(i8* [[A]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;
   %A = call i8* @malloc(i32 16000)
   br i1 %cond, label %if, label %else
 
 if:
   call void @check(i8* %A)
   ret void
 
 else:
   ret void
 }
 
-; TODO: We can sink this malloc as well down to the use block.
+; We can sink this malloc as well down to the use block.
 define void @test_allocation_sink_noalias_load(i1 %cond, i32 %i, i32* readonly %P) {
 ; CHECK-LABEL: @test_allocation_sink_noalias_load(
-; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
-; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[I:%.*]] to i64
+; CHECK:         [[IDXPROM:%.*]] = sext i32 [[I:%.*]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i64 [[IDXPROM]]
 ; CHECK-NEXT:    [[L:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
 ; CHECK:       if:
+; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
 ; CHECK-NEXT:    call void @check(i8* [[A]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    [[X:%.*]] = call i32 @foo(i32 [[L]], i32 [[L]])
 ; CHECK-NEXT:    [[Y:%.*]] = call i32 @foo(i32 [[L]], i32 [[L]])
 ; CHECK-NEXT:    ret void
 ;
   %A = call i8* @malloc(i32 16000)
   %idxprom = sext i32 %i to i64
   %arrayidx = getelementptr inbounds i32, i32* %P, i64 %idxprom
   %L = load i32, i32* %arrayidx, align 4
   br i1 %cond, label %if, label %else
 
 if:
   call void @check(i8* %A)
   ret void
 
 else:
   %X = call i32 @foo(i32 %L, i32 %L)
   %Y = call i32 @foo(i32 %L, i32 %L)
   ret void
 }
 
-; TODO: We can sink both allocations to its only use without them being
+; We can sink both allocations to its only use without them being
 ; incorrectly reordered.
 define void @test_allocation_sink2(i1 %cond) {
 ; CHECK-LABEL: @test_allocation_sink2(
+; CHECK:         br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; CHECK:       if:
 ; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(16000) i8* @malloc(i32 16000)
 ; CHECK-NEXT:    [[B:%.*]] = call dereferenceable_or_null(16) i8* @malloc(i32 16)
-; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
-; CHECK:       if:
 ; CHECK-NEXT:    call void @check2(i8* [[A]], i8* [[B]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       else:
 ; CHECK-NEXT:    ret void
 ;
   %A = call i8* @malloc(i32 16000)
   %B = call i8* @malloc(i32 16)
   br i1 %cond, label %if, label %else