[CodeGenPrepare] Increase the limit on the number of instructions to scan

[chill]

Summary

... when finding all memory uses for an address and make it a parameter.

Now that we have avoided potentially exponential run time of FindAllMemoryUses
in D143893. it'd be beneficial to increase the limit up from 20.

[mkazantsev]

llvm/lib/CodeGen/CodeGenPrepare.cpp

4952–4953

Make it an option?

[mkazantsev]

I don't mind default setting change, but think this should be an option, unless there is a reason why it shouldn't.

llvm/lib/CodeGen/CodeGenPrepare.cpp

 static cl::opt<bool>
     OptimizePhiTypes("cgp-optimize-phi-types", cl::Hidden, cl::init(false),
                      cl::desc("Enable converting phi types in CodeGenPrepare"));
 
 static cl::opt<unsigned>
     HugeFuncThresholdInCGPP("cgpp-huge-func", cl::init(10000), cl::Hidden,
                             cl::desc("Least BB number of huge function."));
 
+static cl::opt<unsigned>
+    MaxAddressUsersToScan("cgp-max-address-users-to-scan", cl::init(100),
+                          cl::Hidden,
+                          cl::desc("Max number of address users to look at"));
 namespace {
 
 enum ExtType {
   ZeroExtension, // Zero extension has been seen.
   SignExtension, // Sign extension has been seen.
   BothExtension  // This extension type is used if we saw sext after
                  // ZeroExtension had been set, or if we saw zext after
                  // SignExtension had been set. It makes the type
for (TargetLowering::AsmOperandInfo &OpInfo : TargetConstraints) {
     if (OpInfo.CallOperandVal == OpVal &&
         (OpInfo.ConstraintType != TargetLowering::C_Memory ||
          !OpInfo.isIndirect))
       return false;
   }
 
   return true;
 }
 
-// Max number of memory uses to look at before aborting the search to conserve
-// compile time.
-static constexpr int MaxMemoryUsesToScan = 20;
-
 /// Recursively walk all the uses of I until we find a memory use.
 /// If we find an obviously non-foldable instruction, return true.
 /// Add accessed addresses and types to MemoryUses.
 static bool FindAllMemoryUses(
     Instruction *I, SmallVectorImpl<std::pair<Value *, Type *>> &MemoryUses,
     SmallPtrSetImpl<Instruction *> &ConsideredInsts, const TargetLowering &TLI,
     const TargetRegisterInfo &TRI, bool OptSize, ProfileSummaryInfo *PSI,
-    BlockFrequencyInfo *BFI, int &SeenInsts) {
+    BlockFrequencyInfo *BFI, unsigned &SeenInsts) {
   // If we already considered this instruction, we're done.
   if (!ConsideredInsts.insert(I).second)
     return false;
 
   // If this is an obviously unfoldable instruction, bail out.
   if (!MightBeFoldableInst(I))
     return true;
 
   // Loop over all the uses, recursively processing them.
   for (Use &U : I->uses()) {
     // Conservatively return true if we're seeing a large number or a deep chain
     // of users. This avoids excessive compilation times in pathological cases.
-    if (SeenInsts++ >= MaxMemoryUsesToScan)
+    if (SeenInsts++ >= MaxAddressUsersToScan)
       return true;
 
     Instruction *UserI = cast<Instruction>(U.getUser());
     if (LoadInst *LI = dyn_cast<LoadInst>(UserI)) {
       MemoryUses.push_back({U.get(), LI->getType()});
       continue;
     }
 
static bool FindAllMemoryUses(
 
   return false;
 }
 
 static bool FindAllMemoryUses(
     Instruction *I, SmallVectorImpl<std::pair<Value *, Type *>> &MemoryUses,
     const TargetLowering &TLI, const TargetRegisterInfo &TRI, bool OptSize,
     ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI) {
-  int SeenInsts = 0;
+  unsigned SeenInsts = 0;
   SmallPtrSet<Instruction *, 16> ConsideredInsts;
   return FindAllMemoryUses(I, MemoryUses, ConsideredInsts, TLI, TRI, OptSize,
                            PSI, BFI, SeenInsts);
 }
 
 
 /// Return true if Val is already known to be live at the use site that we're
 /// folding it into. If so, there is no cost to include it in the addressing

llvm/test/CodeGen/Generic/addr-use-count.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -codegenprepare < %s | FileCheck %s
 ; REQUIRES: aarch64-registered-target
 
-; Test that `%addr` is not sunk, since the number of memory uses to scan exceeds the limit.
+; Test that `%addr` is sunk, after we've increased limit on the number of the memory uses to scan.
 
 target triple = "aarch64-linux"
 
 declare void @g(...)
 
 define void @f(ptr %p) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ADDR:%.*]] = getelementptr i8, ptr [[P:%.*]], i32 4
-; CHECK-NEXT:    br label [[EXIT:%.*]]
-; CHECK:       exit:
-; CHECK-NEXT:    [[T0:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T1:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T2:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T3:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T4:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T5:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T6:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T7:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T8:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T9:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T10:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T11:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T12:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T13:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T14:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T15:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T16:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T17:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[T18:%.*]] = load i32, ptr [[ADDR]], align 4
-; CHECK-NEXT:    [[ADDR_1:%.*]] = getelementptr i8, ptr [[ADDR]], i32 4
-; CHECK-NEXT:    [[T19:%.*]] = load i32, ptr [[ADDR_1]], align 4
+; CHECK-NEXT:    [[SUNKADDR:%.*]] = getelementptr i8, ptr [[P:%.*]], i64 4
+; CHECK-NEXT:    [[T0:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T1:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T2:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T3:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T4:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T5:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T6:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T7:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T8:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T9:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T10:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T11:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T12:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T13:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T14:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T15:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T16:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T17:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[T18:%.*]] = load i32, ptr [[SUNKADDR]], align 4
+; CHECK-NEXT:    [[SUNKADDR1:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; CHECK-NEXT:    [[T19:%.*]] = load i32, ptr [[SUNKADDR1]], align 4
 ; CHECK-NEXT:    call void @g(i32 [[T0]], i32 [[T1]], i32 [[T2]], i32 [[T3]], i32 [[T4]], i32 [[T5]], i32 [[T6]], i32 [[T7]], i32 [[T8]], i32 [[T9]], i32 [[T10]], i32 [[T11]], i32 [[T12]], i32 [[T13]], i32 [[T14]], i32 [[T15]], i32 [[T16]], i32 [[T17]], i32 [[T18]], i32 [[T19]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %addr = getelementptr i8, ptr %p, i32 4
   br label %exit
 
 exit: