[GlobalISel] Add a bisection point after instruction selection.

[aemerson]

Summary

This uses the bisection support in D113030.

[qcolombet]

Hi Amara,

I like the approach but I wonder if we can avoid the BisectClient to trickle down to every optimization. (see inline comment)

Regarding the key for shouldPerformBisectAction, how do we handle the cases of optimizations running several times?
E.g., let say you want the first instance of instcombine to run, but not the second one. Same question if we want to run a specific combine, but not another one (when bisecting fast math optimizations for instance.)

Cheers,
-Quentin

llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp

310

Instead of pushing the BisectClient on every optimization, could we embedded this information within the IR itself?

What I have in mind is something similar to optnone, but that would control each optimization separately. Essentially optnone would be an equivalent of a 0xfffff on disabling all optimizations.

llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp

 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/Config/config.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/RemoteBisectorClient.h"
 #include "llvm/Target/TargetMachine.h"
 
 #define DEBUG_TYPE "instruction-select"
 
 using namespace llvm;
 
 #ifdef LLVM_GISEL_COV_PREFIX
 static cl::opt<std::string>
     CoveragePrefix("gisel-coverage-prefix", cl::init(LLVM_GISEL_COV_PREFIX),
                    cl::desc("Record GlobalISel rule coverage files of this "
                             "prefix if instrumentation was generated"));
 #else
 static const std::string CoveragePrefix;
 #endif
 
+cl::opt<bool>
+    BisectISel("gisel-bisect-selection",
+               cl::desc("Enable remote bisection in GlobalISel after isel"),
+               cl::init(false));
+
 char InstructionSelect::ID = 0;
 INITIALIZE_PASS_BEGIN(InstructionSelect, DEBUG_TYPE,
                       "Select target instructions out of generic instructions",
                       false, false)
 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 INITIALIZE_PASS_DEPENDENCY(GISelKnownBitsAnalysis)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LazyBlockFrequencyInfoPass)
for (const auto &MBB : MF) {
     for (const auto &MI : MBB) {
       if ((MI.isCall() && !MI.isReturn()) || MI.isStackAligningInlineAsm())
         MFI.setHasCalls(true);
       if (MI.isInlineAsm())
         MF.setHasInlineAsm(true);
     }
   }
 
+  if (BisectISel) {
+    RemoteBisectClient BisectClient;
+    // If we're building with multiple architectures, we could have conflicts
+    // with using just the module + function name. Add the triple arch to
+    // disambiguate further.
+    auto &M = *MF.getFunction().getParent();
+    std::string Arch = Triple(M.getTargetTriple()).getArchName().str();
+    std::string Key = Arch + " " +
+                      MF.getFunction().getParent()->getSourceFileName() + " " +
+                      MF.getFunction().getName().str();
+    if (!BisectClient.shouldPerformBisectAction(Key)) {
+      MachineOptimizationRemarkMissed R("gisel-bisect", "GISelFailure",
+                                        MF.getFunction().getSubprogram(),
+                                        &*MF.begin());
+      R << "bisection specified fall back";
+      reportGISelFailure(MF, TPC, MORE, R);
+      return false;
+    }
+  }
+
   // FIXME: FinalizeISel pass calls finalizeLowering, so it's called twice.
   auto &TLI = *MF.getSubtarget().getTargetLowering();
   TLI.finalizeLowering(MF);
 
   LLVM_DEBUG({
     dbgs() << "Rules covered by selecting function: " << MF.getName() << ":";
     for (auto RuleID : CoverageInfo.covered())
       dbgs() << " id" << RuleID;