[LICM] Don't try to constant fold instructions

[nikic]

Summary

This was introduced in https://github.com/llvm/llvm-project/commit/030f02021b6359ec5641622cf1aa63d873ecf55a as an alleged compile-time optimization. In reality, trying to constant fold instructions is more expensive than just hoisting them. In a standard pipeline, LICM tends to run either after a run of LoopInstSimplify or InstCombine, so LICM doesn't really see constant foldable instructions in the first place, and the attempted fold is futile.

This makes for a very minor compile-time improvement: http://llvm-compile-time-tracker.com/compare.php?from=41c201aabe4220d6d2ff0a07c20e20e932dbac7a&to=057b5f1f3573ddceb04d9eb6fb9973358d53fece&stat=instructions:u

[mkazantsev]

Just curious, what makes it so expensive? Is it SafetyInfo update?

[nikic]

In D149134#4295312, @mkazantsev wrote:

Just curious, what makes it so expensive? Is it SafetyInfo update?

No, it's the constant folding itself. E.g. even if you have some non-foldable operation will all-constant operands (like a load from global or call with constants) it will still do quite a bit of work, such as recursively folding all the constant operands with datalayout.

llvm/lib/Transforms/Scalar/LICM.cpp

 #include "llvm/Transforms/Scalar/LICM.h"
 #include "llvm/ADT/PriorityWorklist.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CaptureTracking.h"
-#include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/GuardUtils.h"
 #include "llvm/Analysis/LazyBlockFrequencyInfo.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/LoopNestAnalysis.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/MemorySSA.h"
bool llvm::hoistRegion(DomTreeNode *N, AAResults *AA, LoopInfo *LI,
   BasicBlock *Preheader = CurLoop->getLoopPreheader();
   for (BasicBlock *BB : Worklist) {
     // Only need to process the contents of this block if it is not part of a
     // subloop (which would already have been processed).
     if (!LoopNestMode && inSubLoop(BB, CurLoop, LI))
       continue;
 
     for (Instruction &I : llvm::make_early_inc_range(*BB)) {
-      // Try constant folding this instruction.  If all the operands are
-      // constants, it is technically hoistable, but it would be better to
-      // just fold it.
-      if (Constant *C = ConstantFoldInstruction(
-              &I, I.getModule()->getDataLayout(), TLI)) {
-        LLVM_DEBUG(dbgs() << "LICM folding inst: " << I << "  --> " << *C
-                          << '\n');
-        // FIXME MSSA: Such replacements may make accesses unoptimized (D51960).
-        I.replaceAllUsesWith(C);
-        if (isInstructionTriviallyDead(&I, TLI))
-          eraseInstruction(I, *SafetyInfo, MSSAU);
-        Changed = true;
-        continue;
-      }
-
       // Try hoisting the instruction out to the preheader.  We can only do
       // this if all of the operands of the instruction are loop invariant and
       // if it is safe to hoist the instruction. We also check block frequency
       // to make sure instruction only gets hoisted into colder blocks.
       // TODO: It may be safe to hoist if we are hoisting to a conditional block
       // and we have accurately duplicated the control flow from the loop header
       // to that block.
       if (CurLoop->hasLoopInvariantOperands(&I) &&

llvm/test/Transforms/LICM/hoisting.ll

loop2:
   br i1 %c, label %Loop, label %Out
 
 Out:
   %C = sub i32 %A, %B
   ret i32 %C
 }
 
 
-; This loop invariant instruction should be constant folded, not hoisted.
+; Don't bother constant folding the add, just hoist it.
 define i32 @test3(i1 %c) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:    [[A:%.*]] = load i32, ptr @X, align 4
+; CHECK-NEXT:    [[B:%.*]] = add i32 4, 2
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       Loop:
-; CHECK-NEXT:    call void @foo2(i32 6)
+; CHECK-NEXT:    call void @foo2(i32 [[B]])
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP]], label [[OUT:%.*]]
 ; CHECK:       Out:
-; CHECK-NEXT:    [[B_LCSSA:%.*]] = phi i32 [ 6, [[LOOP]] ]
+; CHECK-NEXT:    [[B_LCSSA:%.*]] = phi i32 [ [[B]], [[LOOP]] ]
 ; CHECK-NEXT:    [[C:%.*]] = sub i32 [[A]], [[B_LCSSA]]
 ; CHECK-NEXT:    ret i32 [[C]]
 ;
   %A = load i32, ptr @X   ; <i32> [#uses=2]
   br label %Loop
 Loop:
   %B = add i32 4, 2   ; <i32> [#uses=2]
   call void @foo2( i32 %B )

llvm/test/Transforms/LICM/pr32129.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -S -passes=licm,simple-loop-unswitch,licm < %s | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 define void @test() {
 ; CHECK-LABEL: define void @test() {
 ; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp ult i32 0, 400
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[TMP0]], i32 9) [ "deopt"() ]
 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 ; CHECK:       header.loopexit:
 ; CHECK-NEXT:    br label [[HEADER]]
 ; CHECK:       header:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    br i1 true, label [[HEADER_LOOPEXIT:%.*]], label [[LOOP]]
 ;

llvm/test/Transforms/LICM/scalar-promote.ll

 
 Out:
   ret void
 }
 
 define void @test2(i32 %i) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  Entry:
-; CHECK-NEXT:    [[DOTPROMOTED:%.*]] = load i32, ptr getelementptr inbounds (i32, ptr @X, i64 1), align 4
+; CHECK-NEXT:    [[X1:%.*]] = getelementptr i32, ptr @X, i64 1
+; CHECK-NEXT:    [[X2:%.*]] = getelementptr i32, ptr @X, i64 1
+; CHECK-NEXT:    [[X1_PROMOTED:%.*]] = load i32, ptr [[X1]], align 4
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       Loop:
-; CHECK-NEXT:    [[V1:%.*]] = phi i32 [ [[V:%.*]], [[LOOP]] ], [ [[DOTPROMOTED]], [[ENTRY:%.*]] ]
-; CHECK-NEXT:    [[V]] = add i32 [[V1]], 1
+; CHECK-NEXT:    [[A1:%.*]] = phi i32 [ [[V:%.*]], [[LOOP]] ], [ [[X1_PROMOTED]], [[ENTRY:%.*]] ]
+; CHECK-NEXT:    [[V]] = add i32 [[A1]], 1
 ; CHECK-NEXT:    br i1 false, label [[LOOP]], label [[EXIT:%.*]]
 ; CHECK:       Exit:
 ; CHECK-NEXT:    [[V_LCSSA:%.*]] = phi i32 [ [[V]], [[LOOP]] ]
-; CHECK-NEXT:    store i32 [[V_LCSSA]], ptr getelementptr inbounds (i32, ptr @X, i64 1), align 4
+; CHECK-NEXT:    store i32 [[V_LCSSA]], ptr [[X1]], align 4
 ; CHECK-NEXT:    ret void
 ;
 Entry:
   br label %Loop
 
 Loop:   ; preds = %Loop, %0
   %X1 = getelementptr i32, ptr @X, i64 1    ; <ptr> [#uses=1]
   %A = load i32, ptr %X1    ; <i32> [#uses=1]