[SelectionDAG] Add the option of disabling generic combines.

[kariddi]

Summary

For some targets generic combines don't really do much and they
consume a disproportionate amount of time.
There's not really a mechanism in SDISel to tactically disable
combines, but we can have a switch to disable all of them and
let the targets just implement what they specifically need.

Tested compile time performance on LNT Nightly and didn't make any effect.

[kariddi]

Changing to a disable flag.

[arsenm]

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1654

Why call this for every node? Why not just once when the combiner is constructed?

[kariddi]

Adding an attribute in DAGCombiner that caches disableGenericCombines() calls.

[kariddi]

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1654

That is a very good idea :) Done.

[kariddi]

Inverted condition for error.

[kariddi]

ping

[kariddi]

ping

[kariddi]

ping :)

[arsenm]

llvm/include/llvm/CodeGen/SelectionDAGTargetInfo.h

164–165

This isn't a machine combiner, also should specify DAG combiner?

[kariddi]

Changed comment

llvm/include/llvm/CodeGen/SelectionDAGTargetInfo.h

164–165

I used the same naming other functions (used in DAG combiner) , but I agree is kind of a weird naming honestly, considering the GlobalISel effort (probably the previous naming was pre-GISel itself). I'll change the comment to explicitly mention the DAG combiner.

[hgreving]

nit: s/ didn't make any effect./ didn't have any effect./

[hgreving]

LGTM!

[kariddi]

Thanks for having a look Hendrik. I'm gonna push this considering there has been no push back for a month. If somebody wants to further comment on this or pitch for a revert please let me know.

llvm/include/llvm/CodeGen/SelectionDAGTargetInfo.h

virtual SDValue EmitTargetCodeForSetTag(SelectionDAG &DAG, const SDLoc &dl,
     return SDValue();
   }
 
   // Return true when the decision to generate FMA's (or FMS, FMLA etc) rather
   // than FMUL and ADD is delegated to the machine combiner.
   virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
     return false;
   }
+
+  // Return true if the Machine Combiner should run generic combines.
+  virtual bool runGenericCombines(CodeGenOpt::Level OptLevel) const {
+    return true;
+  }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

static cl::opt<unsigned> StoreMergeDependenceLimit(
     cl::desc("Limit the number of times for the same StoreNode and RootNode "
              "to bail out in store merging dependence check"));
 
 namespace {
 
   class DAGCombiner {
     SelectionDAG &DAG;
     const TargetLowering &TLI;
+    const SelectionDAGTargetInfo &STI;
     CombineLevel Level;
     CodeGenOpt::Level OptLevel;
     bool LegalDAG = false;
     bool LegalOperations = false;
     bool LegalTypes = false;
     bool ForCodeSize;
 
     /// Worklist of all of the nodes that need to be simplified.
SDNode *getNextWorklistEntry() {
       return N;
     }
 
     /// Call the node-specific routine that folds each particular type of node.
     SDValue visit(SDNode *N);
 
   public:
     DAGCombiner(SelectionDAG &D, AliasAnalysis *AA, CodeGenOpt::Level OL)
-        : DAG(D), TLI(D.getTargetLoweringInfo()), Level(BeforeLegalizeTypes),
-          OptLevel(OL), AA(AA) {
+        : DAG(D), TLI(D.getTargetLoweringInfo()), STI(D.getSelectionDAGInfo()),
+          Level(BeforeLegalizeTypes), OptLevel(OL), AA(AA) {
       ForCodeSize = DAG.shouldOptForSize();
 
       MaximumLegalStoreInBits = 0;
       // We use the minimum store size here, since that's all we can guarantee
       // for the scalable vector types.
       for (MVT VT : MVT::all_valuetypes())
         if (EVT(VT).isSimple() && VT != MVT::Other &&
             TLI.isTypeLegal(EVT(VT)) &&
SDValue DAGCombiner::visit(SDNode *N) {
   case ISD::VECREDUCE_UMIN:
   case ISD::VECREDUCE_FMAX:
   case ISD::VECREDUCE_FMIN:     return visitVECREDUCE(N);
   }
   return SDValue();
 }
 
 SDValue DAGCombiner::combine(SDNode *N) {
-  SDValue RV = visit(N);
+  SDValue RV;
+  if (STI.runGenericCombines(OptLevel))
+    RV = visit(N);
 
   // If nothing happened, try a target-specific DAG combine.
   if (!RV.getNode()) {
     assert(N->getOpcode() != ISD::DELETED_NODE &&
            "Node was deleted but visit returned NULL!");
 
     if (N->getOpcode() >= ISD::BUILTIN_OP_END ||
         TLI.hasTargetDAGCombine((ISD::NodeType)N->getOpcode())) {
SDValue DAGCombiner::visitFADDForFMACombine(SDNode *N) {
   SDNodeFlags Flags = N->getFlags();
   bool CanFuse = Options.UnsafeFPMath || isContractable(N);
   bool AllowFusionGlobally = (Options.AllowFPOpFusion == FPOpFusion::Fast ||
                               CanFuse || HasFMAD);
   // If the addition is not contractable, do not combine.
   if (!AllowFusionGlobally && !isContractable(N))
     return SDValue();
 
-  const SelectionDAGTargetInfo *STI = DAG.getSubtarget().getSelectionDAGInfo();
-  if (STI && STI->generateFMAsInMachineCombiner(OptLevel))
+  if (STI.generateFMAsInMachineCombiner(OptLevel))
     return SDValue();
 
   // Always prefer FMAD to FMA for precision.
   unsigned PreferredFusedOpcode = HasFMAD ? ISD::FMAD : ISD::FMA;
   bool Aggressive = TLI.enableAggressiveFMAFusion(VT);
 
   // Is the node an FMUL and contractable either due to global flags or
   // SDNodeFlags.
SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
   bool CanFuse = Options.UnsafeFPMath || isContractable(N);
   bool AllowFusionGlobally = (Options.AllowFPOpFusion == FPOpFusion::Fast ||
                               CanFuse || HasFMAD);
 
   // If the subtraction is not contractable, do not combine.
   if (!AllowFusionGlobally && !isContractable(N))
     return SDValue();
 
-  const SelectionDAGTargetInfo *STI = DAG.getSubtarget().getSelectionDAGInfo();
-  if (STI && STI->generateFMAsInMachineCombiner(OptLevel))
+  if (STI.generateFMAsInMachineCombiner(OptLevel))
     return SDValue();
 
   // Always prefer FMAD to FMA for precision.
   unsigned PreferredFusedOpcode = HasFMAD ? ISD::FMAD : ISD::FMA;
   bool Aggressive = TLI.enableAggressiveFMAFusion(VT);
   bool NoSignedZero = Options.NoSignedZerosFPMath || Flags.hasNoSignedZeros();
 
   // Is the node an FMUL and contractable either due to global flags or