[PM] Use getAnalysisIfAvailable / addUsedIfAvailable with StackProtector

[thegameg]

Summary

When trying to use llc -run-pass stack-coloring or any other pass that
requires the StackProtector pass, the PM will fail with:

Unable to schedule 'Slot index numbering' required by 'Merge disjoint stack slots'
Unable to schedule pass
UNREACHABLE executed at ../lib/IR/LegacyPassManager.cpp:1314!

The problem with StackProtector is that it is an IR pass which is added
as a dependency to an MI pass.

This patch makes it so passes only use the StackProtector pass if it is
available. In general, the pass is added in TargetPassConfig::addISelPrepare.

This allows these passes to be used with -run-pass or
-start-after/before.

It also fixes one machine verifier issue by using -run-pass instead of
re-running ISel on the whole IR.

[thanm]

Thanks for looking into this-- I've definitely run into the "Unable to schedule pass" issue but hadn't been able to sort out the cause.

[mattd]

@thegameg - Good catch, and thanks for hunting this down.

I'm not a pass manager expert, but since the TargetPassConfig will always add StackProtector for code that is generating IR, this seems ok to me. Is there not a way to get MF passes to express a required dependency on an IR analysis pass, I'm guessing not since llc only really deals with lower level machine passes. Perhaps a more helpful diagnostic could have made locating this issue easier "Machine Function pass is dependent on a IR pass that cannot be generated."

[MatzeB]

See also: https://reviews.llvm.org/D37582
(Looks like I never got around comitting it and nobody pinged, oops)

[thegameg]

Thanks all for taking a look. I'll close this and push for D37582.

lib/CodeGen/LocalStackSlotAllocation.cpp

public:
     explicit LocalStackSlotPass() : MachineFunctionPass(ID) {
       initializeLocalStackSlotPassPass(*PassRegistry::getPassRegistry());
     }
 
     bool runOnMachineFunction(MachineFunction &MF) override;
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesCFG();
-      AU.addRequired<StackProtector>();
+      AU.addUsedIfAvailable<StackProtector>();
       MachineFunctionPass::getAnalysisUsage(AU);
     }
   };
 
 } // end anonymous namespace
 
 char LocalStackSlotPass::ID = 0;
 

 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
   // Loop over all of the stack objects, assigning sequential addresses...
   MachineFrameInfo &MFI = Fn.getFrameInfo();
   const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
   bool StackGrowsDown =
     TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsDown;
   int64_t Offset = 0;
   unsigned MaxAlign = 0;
-  StackProtector *SP = &getAnalysis<StackProtector>();
+  StackProtector *SP = getAnalysisIfAvailable<StackProtector>();
 
   // Make sure that the stack protector comes before the local variables on the
   // stack.
   SmallSet<int, 16> ProtectedObjs;
   if (MFI.getStackProtectorIndex() >= 0) {
     StackObjSet LargeArrayObjs;
     StackObjSet SmallArrayObjs;
     StackObjSet AddrOfObjs;
 
     AdjustStackOffset(MFI, MFI.getStackProtectorIndex(), Offset,
                       StackGrowsDown, MaxAlign);
 
     // Assign large stack objects first.
     for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
       if (MFI.isDeadObjectIndex(i))
         continue;
       if (MFI.getStackProtectorIndex() == (int)i)
         continue;
 
+      if (SP) {
         switch (SP->getSSPLayout(MFI.getObjectAllocation(i))) {
         case StackProtector::SSPLK_None:
           continue;
         case StackProtector::SSPLK_SmallArray:
           SmallArrayObjs.insert(i);
           continue;
         case StackProtector::SSPLK_AddrOf:
           AddrOfObjs.insert(i);
           continue;
         case StackProtector::SSPLK_LargeArray:
           LargeArrayObjs.insert(i);
           continue;
         }
+      }
       llvm_unreachable("Unexpected SSPLayoutKind.");
     }
 
     AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
                           Offset, MaxAlign);
     AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
                           Offset, MaxAlign);
     AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,

lib/CodeGen/PrologEpilogInserter.cpp

 
 STATISTIC(NumBytesStackSpace,
           "Number of bytes used for stack in all functions");
 
 void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesCFG();
   AU.addPreserved<MachineLoopInfo>();
   AU.addPreserved<MachineDominatorTree>();
-  AU.addRequired<StackProtector>();
+  AU.addUsedIfAvailable<StackProtector>();
   AU.addRequired<MachineOptimizationRemarkEmitterPass>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 /// StackObjSet - A set of stack object indexes
 using StackObjSet = SmallSetVector<int, 8>;
 
 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
     ProtectedObjs.insert(i);
   }
 }
 
 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
 /// abstract stack objects.
 void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
   const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
-  StackProtector *SP = &getAnalysis<StackProtector>();
+  StackProtector *SP = getAnalysisIfAvailable<StackProtector>();
 
   bool StackGrowsDown =
     TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsDown;
 
   // Loop over all of the stack objects, assigning sequential addresses...
   MachineFrameInfo &MFI = MF.getFrameInfo();
 
   // Start at the beginning of the local area.
for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
       if (RS && RS->isScavengingFrameIndex((int)i))
         continue;
       if (MFI.isDeadObjectIndex(i))
         continue;
       if (MFI.getStackProtectorIndex() == (int)i ||
           EHRegNodeFrameIndex == (int)i)
         continue;
 
+      if (SP) {
         switch (SP->getSSPLayout(MFI.getObjectAllocation(i))) {
         case StackProtector::SSPLK_None:
           continue;
         case StackProtector::SSPLK_SmallArray:
           SmallArrayObjs.insert(i);
           continue;
         case StackProtector::SSPLK_AddrOf:
           AddrOfObjs.insert(i);
           continue;
         case StackProtector::SSPLK_LargeArray:
           LargeArrayObjs.insert(i);
           continue;
         }
+      }
       llvm_unreachable("Unexpected SSPLayoutKind.");
     }
 
     AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
                           Offset, MaxAlign, Skew);
     AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
                           Offset, MaxAlign, Skew);
     AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

SelectionDAGISel::~SelectionDAGISel() {
   delete CurDAG;
   delete FuncInfo;
 }
 
 void SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const {
   if (OptLevel != CodeGenOpt::None)
     AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<GCModuleInfo>();
-  AU.addRequired<StackProtector>();
+  AU.addUsedIfAvailable<StackProtector>();
   AU.addPreserved<StackProtector>();
   AU.addPreserved<GCModuleInfo>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
   AU.addRequired<TargetTransformInfoWrapperPass>();
   if (UseMBPI && OptLevel != CodeGenOpt::None)
     AU.addRequired<BranchProbabilityInfoWrapperPass>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
if (FastIS) {
 
         NumFastIselFailures += NumFastIselRemaining;
         break;
       }
 
       FastIS->recomputeInsertPt();
     }
 
-    if (getAnalysis<StackProtector>().shouldEmitSDCheck(*LLVMBB)) {
+    StackProtector *SP = getAnalysisIfAvailable<StackProtector>();
+    if (SP && SP->shouldEmitSDCheck(*LLVMBB)) {
       bool FunctionBasedInstrumentation =
           TLI->getSSPStackGuardCheck(*Fn.getParent());
       SDB->SPDescriptor.initialize(LLVMBB, FuncInfo->MBBMap[LLVMBB],
                                    FunctionBasedInstrumentation);
     }
 
     if (Begin != BI)
       ++NumDAGBlocks;

lib/CodeGen/StackColoring.cpp

INITIALIZE_PASS_BEGIN(StackColoring, DEBUG_TYPE,
                       "Merge disjoint stack slots", false, false)
 INITIALIZE_PASS_DEPENDENCY(SlotIndexes)
 INITIALIZE_PASS_DEPENDENCY(StackProtector)
 INITIALIZE_PASS_END(StackColoring, DEBUG_TYPE,
                     "Merge disjoint stack slots", false, false)
 
 void StackColoring::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<SlotIndexes>();
-  AU.addRequired<StackProtector>();
+  AU.addUsedIfAvailable<StackProtector>();
+  AU.addPreserved<StackProtector>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void StackColoring::dumpBV(const char *tag,
                                             const BitVector &BV) const {
   dbgs() << tag << " : { ";
   for (unsigned I = 0, E = BV.size(); I != E; ++I)
for (const std::pair<int, int> &SI : SlotRemap) {
     }
 
     // We keep both slots to maintain AliasAnalysis metadata later.
     MergedAllocas.insert(From);
     MergedAllocas.insert(To);
 
     // Allow the stack protector to adjust its value map to account for the
     // upcoming replacement.
+    if (SP)
       SP->adjustForColoring(From, To);
 
     // The new alloca might not be valid in a llvm.dbg.declare for this
     // variable, so undef out the use to make the verifier happy.
     AllocaInst *FromAI = const_cast<AllocaInst *>(From);
     if (FromAI->isUsedByMetadata())
       ValueAsMetadata::handleRAUW(FromAI, UndefValue::get(FromAI->getType()));
     for (auto &Use : FromAI->uses()) {
       if (BitCastInst *BCI = dyn_cast<BitCastInst>(Use.get()))

 }
 
 bool StackColoring::runOnMachineFunction(MachineFunction &Func) {
   LLVM_DEBUG(dbgs() << "********** Stack Coloring **********\n"
                     << "********** Function: " << Func.getName() << '\n');
   MF = &Func;
   MFI = &MF->getFrameInfo();
   Indexes = &getAnalysis<SlotIndexes>();
-  SP = &getAnalysis<StackProtector>();
+  SP = getAnalysisIfAvailable<StackProtector>();
   BlockLiveness.clear();
   BasicBlocks.clear();
   BasicBlockNumbering.clear();
   Markers.clear();
   Intervals.clear();
   LiveStarts.clear();
   VNInfoAllocator.Reset();
 

test/CodeGen/X86/PR37310.mir

-# RUN: llc -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -start-before dwarfehprepare -no-stack-coloring=false -stop-after stack-coloring -o - %s
+# RUN: llc -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -no-stack-coloring=false -run-pass stack-coloring -o - %s
 
 # Test to insure that the liveness analysis in the StackColoring
 # pass gracefully handles statically unreachable blocks. See PR 37310.
 
 # This MIR testcase was created by compiling the following test, first
 # with "clang -emit-llvm -S" and then "llc -stop-before stack-coloring",
 # and finally editing the resulting MIR by hand to introduce a statically
 # unreachable BB (to wit: rename all bb.3 to bb.4, rename bb.2 to bb.3,