[TableGen] Suppress type validation when parsing pattern fragments

[uweigand]

Summary

Currently, any attempt to define a PatFrag involving any floating-point only (or vector only) node causes a hard assertion failure in TableGen if the current target does not have any floating-point (or vector) types.

This is annoying if you want to provide convenience fragments in common code (e.g. include/llvm/Target/TargetSelectionDAG.td) that is parsed on all platforms, including those that miss such types.

But really, there's no reason not accept this when parsing the fragment -- of course it would be an error for such a target to actually *use* such a fragment anywhere, but as long as it doesn't, I think TableGen shouldn't error out.

The immediate cause of the assertion failure is the test inside the ValidateOnExit destructor. This patch simply disables that check while infering types during parsing of pattern fragments (only).

If there's a cleaner / simpler way to achieve the same effect, please let me know ...

[uweigand]

Ping?

[hfinkel]

LGTM

utils/TableGen/CodeGenDAGPatterns.cpp

3026 ↗

(On Diff #153943)

I'd name this SV, or something, instead of _1. Seeing a name with an underscore, at least for me, draws attention unnecessarily.

[kparzysz]

Sorry for the delay in reviewing. Yes, I think it's ok for now. At some point I will probably revisit this to try to generate better diagnostics, but this change is fine now.

llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h

#ifndef NDEBUG
     ~ValidateOnExit();
   #else
     ~ValidateOnExit() {}  // Empty destructor with NDEBUG.
   #endif
     TypeInfer &Infer;
     TypeSetByHwMode &VTS;
   };
 
+  struct SuppressValidation {
+    SuppressValidation(TypeInfer &TI) : Infer(TI), SavedValidate(TI.Validate) {
+      Infer.Validate = false;
+    }
+    ~SuppressValidation() {
+      Infer.Validate = SavedValidate;
+    }
+    TypeInfer &Infer;
+    bool SavedValidate;
+  };
+
   TreePattern &TP;
   unsigned ForceMode;     // Mode to use when set.
   bool CodeGen = false;   // Set during generation of matcher code.
+  bool Validate = true;   // Indicate whether to validate types.
 
 private:
   TypeSetByHwMode getLegalTypes();
 
   /// Cached legal types.
   bool LegalTypesCached = false;
   TypeSetByHwMode::SetType LegalCache = {};
 };

llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp

TypeSetByHwMode TypeInfer::getLegalTypes() {
   }
   TypeSetByHwMode VTS;
   VTS.getOrCreate(DefaultMode) = LegalCache;
   return VTS;
 }
 
 #ifndef NDEBUG
 TypeInfer::ValidateOnExit::~ValidateOnExit() {
-  if (!VTS.validate()) {
+  if (Infer.Validate && !VTS.validate()) {
     dbgs() << "Type set is empty for each HW mode:\n"
               "possible type contradiction in the pattern below "
               "(use -print-records with llvm-tblgen to see all "
               "expanded records).\n";
     Infer.TP.dump();
     llvm_unreachable(nullptr);
   }
 }
void CodeGenDAGPatterns::ParsePatternFragments(bool OutFrags) {
   for (Record *Frag : Fragments) {
     if (OutFrags != Frag->isSubClassOf("OutPatFrag"))
       continue;
 
     TreePattern &ThePat = *PatternFragments[Frag];
     ThePat.InlinePatternFragments();
 
     // Infer as many types as possible.  Don't worry about it if we don't infer
-    // all of them, some may depend on the inputs of the pattern.
+    // all of them, some may depend on the inputs of the pattern.  Also, don't
+    // validate type sets; validation may cause spurious failures e.g. if a
+    // fragment needs floating-point types but the current target does not have
+    // any (this is only an error if that fragment is ever used!).
+    {
+      TypeInfer::SuppressValidation SV(ThePat.getInfer());
       ThePat.InferAllTypes();
       ThePat.resetError();
+    }
 
     // If debugging, print out the pattern fragment result.
     LLVM_DEBUG(ThePat.dump());
   }
 }
 
 void CodeGenDAGPatterns::ParseDefaultOperands() {
   std::vector<Record*> DefaultOps;