TableGen/AMDGPU: Avoid emitting "true" predicates

[arsenm]

Summary

Empty condition strings are considerde always true. This removes a lot
of clutter from the generated matcher tables.

This shrinks the source size of AMDGPUGenDAGISel.inc from 7.3M to
6.1M.

[rampitec]

LGTM

[arsenm]

r367326

lib/Target/AMDGPU/AMDGPUInstructions.td

: Instruction {
      bit hasIEEEFlag = 0;
      bit hasZeroOpFlag = 0;
      let mayLoad = 0;
      let mayStore = 0;
      let hasSideEffects = 0;
      let isCodeGenOnly = 1;
 }
 
-def TruePredicate : Predicate<"true">;
+def TruePredicate : Predicate<"">;
 
 class PredicateControl {
   Predicate SubtargetPredicate = TruePredicate;
   list<Predicate> AssemblerPredicates = [];
   Predicate AssemblerPredicate = TruePredicate;
   Predicate WaveSizePredicate = TruePredicate;
   list<Predicate> OtherPredicates = [];
   list<Predicate> Predicates = !listconcat([SubtargetPredicate,

utils/TableGen/CodeGenDAGPatterns.h

public:
   /// Return a string which contains the C++ condition code that will serve
   /// as a predicate during instruction selection.
   std::string getCondString() const {
     // The string will excute in a subclass of SelectionDAGISel.
     // Cast to std::string explicitly to avoid ambiguity with StringRef.
     std::string C = IsHwMode
         ? std::string("MF->getSubtarget().checkFeatures(\"" + Features + "\")")
         : std::string(Def->getValueAsString("CondString"));
+    if (C.empty())
+      return "";
     return IfCond ? C : "!("+C+')';
   }
+
   bool operator==(const Predicate &P) const {
     return IfCond == P.IfCond && IsHwMode == P.IsHwMode && Def == P.Def;
   }
   bool operator<(const Predicate &P) const {
     if (IsHwMode != P.IsHwMode)
       return IsHwMode < P.IsHwMode;
     assert(!Def == !P.Def && "Inconsistency between Def and IsHwMode");
     if (IfCond != P.IfCond)

utils/TableGen/CodeGenDAGPatterns.cpp

getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
   return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity();
 }
 
 /// getPredicateCheck - Return a single string containing all of this
 /// pattern's predicates concatenated with "&&" operators.
 ///
 std::string PatternToMatch::getPredicateCheck() const {
   SmallVector<const Predicate*,4> PredList;
-  for (const Predicate &P : Predicates)
+  for (const Predicate &P : Predicates) {
+    if (!P.getCondString().empty())
       PredList.push_back(&P);
+  }
   llvm::sort(PredList, deref<llvm::less>());
 
   std::string Check;
   for (unsigned i = 0, e = PredList.size(); i != e; ++i) {
     if (i != 0)
       Check += " && ";
     Check += '(' + PredList[i]->getCondString() + ')';
   }

utils/TableGen/GlobalISelEmitter.cpp

: RK(RK), CGP(RK), Target(CGP.getTargetInfo()),
       CGRegs(RK, Target.getHwModes()) {}
 
 //===- Emitter ------------------------------------------------------------===//
 
 Error
 GlobalISelEmitter::importRulePredicates(RuleMatcher &M,
                                         ArrayRef<Predicate> Predicates) {
   for (const Predicate &P : Predicates) {
-    if (!P.Def)
+    if (!P.Def || P.getCondString().empty())
       continue;
     declareSubtargetFeature(P.Def);
     M.addRequiredFeature(P.Def);
   }
 
   return Error::success();
 }
 

utils/TableGen/SubtargetFeatureInfo.cpp

for (Record *Pred : AllPredicates) {
     // The "AssemblerMatcherPredicate" string should be promoted to an argument
     // if we re-use the machinery for non-assembler purposes in future.
     if (!Pred->getValueAsBit("AssemblerMatcherPredicate"))
       continue;
 
     if (Pred->getName().empty())
       PrintFatalError(Pred->getLoc(), "Predicate has no name!");
 
+    // Ignore always true predicates.
+    if (Pred->getValueAsString("CondString").empty())
+      continue;
+
     SubtargetFeatures.emplace_back(
         Pred, SubtargetFeatureInfo(Pred, SubtargetFeatures.size()));
   }
   return SubtargetFeatures;
 }
 
 void SubtargetFeatureInfo::emitSubtargetFeatureBitEnumeration(
     SubtargetFeatureInfoMap &SubtargetFeatures, raw_ostream &OS) {
void SubtargetFeatureInfo::emitComputeAvailableFeatures(
   OS << "PredicateBitset " << TargetName << ClassName << "::\n"
      << FuncName << "(const " << TargetName << "Subtarget *Subtarget";
   if (!ExtraParams.empty())
     OS << ", " << ExtraParams;
   OS << ") const {\n";
   OS << "  PredicateBitset Features;\n";
   for (const auto &SF : SubtargetFeatures) {
     const SubtargetFeatureInfo &SFI = SF.second;
+    StringRef CondStr = SFI.TheDef->getValueAsString("CondString");
+    assert(!CondStr.empty() && "true predicate should have been filtered");
 
-    OS << "  if (" << SFI.TheDef->getValueAsString("CondString") << ")\n";
+    OS << "  if (" << CondStr << ")\n";
     OS << "    Features[" << SFI.getEnumBitName() << "] = 1;\n";
   }
   OS << "  return Features;\n";
   OS << "}\n\n";
 }
 
 void SubtargetFeatureInfo::emitComputeAssemblerAvailableFeatures(
     StringRef TargetName, StringRef ClassName, StringRef FuncName,