[CodeGen] Introduce threshold option to constrain stack slot sharing during stack coloring.

[vpykhtin]

Summary

AMDGPU code with enabled address sanitizer generates tons of stack objects (> 200000) and
takes forever to compile due to the time spent on slot sharing.

I made up the threshold value, not sure what it should be (apparently more than 42) but
on the other hand - the more stack objects you have the more useful is sharing.

[dexonsmith]

I'm not the right person to review this. @Gerolf, perhaps you can suggest an alternate?

[vpykhtin]

Unfortunatelly stack growed x180 times with slot sharing disabled, so this isn't an option.

llvm/lib/CodeGen/StackSlotColoring.cpp

 
 #define DEBUG_TYPE "stack-slot-coloring"
 
 static cl::opt<bool>
 DisableSharing("no-stack-slot-sharing",
              cl::init(false), cl::Hidden,
              cl::desc("Suppress slot sharing during stack coloring"));
 
+static cl::opt<unsigned>
+    SlotSharingThreshold("-stack-slot-sharing-threshold", cl::init(1000),
+                         cl::Hidden,
+                         cl::desc("Suppress slot sharing during stack coloring "
+                                  "if the number of slots exceeds this value"));
+
 static cl::opt<int> DCELimit("ssc-dce-limit", cl::init(-1), cl::Hidden);
 
 STATISTIC(NumEliminated, "Number of stack slots eliminated due to coloring");
 STATISTIC(NumDead,       "Number of trivially dead stack accesses eliminated");
 
 namespace {
 
   class StackSlotColoring : public MachineFunctionPass {
public:
     }
 
     bool runOnMachineFunction(MachineFunction &MF) override;
 
   private:
     void InitializeSlots();
     void ScanForSpillSlotRefs(MachineFunction &MF);
     bool OverlapWithAssignments(LiveInterval *li, int Color) const;
-    int ColorSlot(LiveInterval *li);
+    int ColorSlot(LiveInterval *li, bool TryShareSlots = true);
     bool ColorSlots(MachineFunction &MF);
     void RewriteInstruction(MachineInstr &MI, SmallVectorImpl<int> &SlotMapping,
                             MachineFunction &MF);
     bool RemoveDeadStores(MachineBasicBlock* MBB);
   };
 
 } // end anonymous namespace
 
for (unsigned i = 0, e = OtherLIs.size(); i != e; ++i) {
     LiveInterval *OtherLI = OtherLIs[i];
     if (OtherLI->overlaps(*li))
       return true;
   }
   return false;
 }
 
 /// ColorSlot - Assign a "color" (stack slot) to the specified stack slot.
-int StackSlotColoring::ColorSlot(LiveInterval *li) {
+int StackSlotColoring::ColorSlot(LiveInterval *li, bool TryShareSlots) {
   int Color = -1;
   bool Share = false;
   int FI = Register::stackSlot2Index(li->reg());
   uint8_t StackID = MFI->getStackID(FI);
 
-  if (!DisableSharing) {
+  if (TryShareSlots) {
 
     // Check if it's possible to reuse any of the used colors.
     Color = UsedColors[StackID].find_first();
     while (Color != -1) {
       if (!OverlapWithAssignments(li, Color)) {
         Share = true;
         ++NumEliminated;
         break;

 /// Colorslots - Color all spill stack slots and rewrite all frameindex machine
 /// operands in the function.
 bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
   unsigned NumObjs = MFI->getObjectIndexEnd();
   SmallVector<int, 16> SlotMapping(NumObjs, -1);
   SmallVector<float, 16> SlotWeights(NumObjs, 0.0);
   SmallVector<SmallVector<int, 4>, 16> RevMap(NumObjs);
   BitVector UsedColors(NumObjs);
+  const bool TryShareSlots =
+      !DisableSharing && SSIntervals.size() < SlotSharingThreshold;
 
   LLVM_DEBUG(dbgs() << "Color spill slot intervals:\n");
   bool Changed = false;
   for (LiveInterval *li : SSIntervals) {
     int SS = Register::stackSlot2Index(li->reg());
-    int NewSS = ColorSlot(li);
+    int NewSS = ColorSlot(li, TryShareSlots);
     assert(NewSS >= 0 && "Stack coloring failed?");
     SlotMapping[SS] = NewSS;
     RevMap[NewSS].push_back(SS);
     SlotWeights[NewSS] += li->weight();
     UsedColors.set(NewSS);
     Changed |= (SS != NewSS);
   }