Fix tablegen cmake rule.

[jyknight]

Summary

Fix tablegen's PrintFatalError function to run registered file cleanups.

Also, change code in tablegen which printed a message and then called
"exit(1)" to use PrintFatalError, instead.

This fixes instances where an empty output file was left behind after
a failed tablegen invocation, which would confuse subsequent ninja
runs into not attempting to rebuild.

[rnk]

TableGen is supposed to ensure that the output file is deleted after a non-zero exit, even if it crashes. See lib/TableGen/Main.cpp and look for tool_output_file. Is our signal handler failing somehow? It might be worth debugging that. I know the signal handler is already super async-unsafe, but we should be able to limp along well enough to delete an output file.

cmake/modules/TableGen.cmake

31–32 ↗

(On Diff #25334)

I would be surprised if this shell expression works on Windows. =/

[jyknight]

Okay, right, I'll look into fixing it within the tool instead of this.

cmake/modules/TableGen.cmake

31–32 ↗

(On Diff #25334)

Er, damnit, Windows, forgot about that.

[jyknight]

Looks like it doesn't have an atexit handler to call the cleanup function, only a signal handler. And PrintFatalError just calls exit(1), which doesn't unwind the stack to call destructors. So, the cleanup never happens.

[jyknight]

Rework, fixing tablegen binary instead of hacking cmake rule.

[rnk]

lgtm

Ouch, so much exit(1)... Anyway, this is consistent with report_fatal_error, which is the non-tablegen analogue for this.

lib/TableGen/Error.cpp

 //===- Error.cpp - tblgen error handling helper routines --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains error handling helper routines to pretty-print diagnostic
 // messages from tblgen.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TableGen/Error.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 
 namespace llvm {
 
 SourceMgr SrcMgr;
 unsigned ErrorsPrinted = 0;
 

 }
 
 void PrintError(const Twine &Msg) {
   errs() << "error:" << Msg << "\n";
 }
 
 void PrintFatalError(const Twine &Msg) {
   PrintError(Msg);
+  // The following call runs the file cleanup handlers.
+  sys::RunInterruptHandlers();
   std::exit(1);
 }
 
 void PrintFatalError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg) {
   PrintError(ErrorLoc, Msg);
+  // The following call runs the file cleanup handlers.
+  sys::RunInterruptHandlers();
   std::exit(1);
 }
 
 } // end namespace llvm

utils/TableGen/CodeGenDAGPatterns.cpp

if (!MVT(x.SDTCVecEltisVT_Info.VT).isInteger() &&
         !MVT(x.SDTCVecEltisVT_Info.VT).isFloatingPoint())
       PrintFatalError(R->getLoc(), "Must use integer or floating point type "
                                    "as SDTCVecEltisVT");
   } else if (R->isSubClassOf("SDTCisSameNumEltsAs")) {
     ConstraintType = SDTCisSameNumEltsAs;
     x.SDTCisSameNumEltsAs_Info.OtherOperandNum =
       R->getValueAsInt("OtherOperandNum");
   } else {
-    errs() << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n";
-    exit(1);
+    PrintFatalError("Unrecognized SDTypeConstraint '" + R->getName() + "'!\n");
   }
 }
 
 /// getOperandNum - Return the node corresponding to operand #OpNo in tree
 /// N, and the result number in ResNo.
 static TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N,
                                       const SDNodeInfo &NodeInfo,
                                       unsigned &ResNo) {
   unsigned NumResults = NodeInfo.getNumResults();
   if (OpNo < NumResults) {
     ResNo = OpNo;
     return N;
   }
 
   OpNo -= NumResults;
 
   if (OpNo >= N->getNumChildren()) {
-    errs() << "Invalid operand number in type constraint "
+    std::string S;
+    raw_string_ostream OS(S);
+    OS << "Invalid operand number in type constraint "
            << (OpNo+NumResults) << " ";
-    N->dump();
-    errs() << '\n';
-    exit(1);
+    N->print(OS);
+    PrintFatalError(OS.str());
   }
 
   return N->getChild(OpNo);
 }
 
 /// ApplyTypeConstraint - Given a node in a pattern, apply this type
 /// constraint to the nodes operands.  This returns true if it makes a
 /// change, false otherwise.  If a type contradiction is found, flag an error.
if (PropList[i]->getName() == "SDNPCommutative") {
       Properties |= 1 << SDNPMayLoad;
     } else if (PropList[i]->getName() == "SDNPSideEffect") {
       Properties |= 1 << SDNPSideEffect;
     } else if (PropList[i]->getName() == "SDNPMemOperand") {
       Properties |= 1 << SDNPMemOperand;
     } else if (PropList[i]->getName() == "SDNPVariadic") {
       Properties |= 1 << SDNPVariadic;
     } else {
-      errs() << "Unknown SD Node property '" << PropList[i]->getName()
-             << "' on node '" << R->getName() << "'!\n";
-      exit(1);
+      PrintFatalError("Unknown SD Node property '" +
+                      PropList[i]->getName() + "' on node '" +
+                      R->getName() + "'!");
     }
   }
 
 
   // Parse the type constraints.
   std::vector<Record*> ConstraintList =
     TypeProfile->getValueAsListOfDefs("Constraints");
   TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end());
static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
 
   if (Operator->isSubClassOf("ValueType"))
     return 1;  // A type-cast of one result.
 
   if (Operator->isSubClassOf("ComplexPattern"))
     return 1;
 
   Operator->dump();
-  errs() << "Unhandled node in GetNumNodeResults\n";
-  exit(1);
+  PrintFatalError("Unhandled node in GetNumNodeResults");
 }
 
 void TreePatternNode::print(raw_ostream &OS) const {
   if (isLeaf())
     OS << *getLeafValue();
   else
     OS << '(' << getOperator()->getName();
 
CodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) :
   InferInstructionFlags();
 
   // Verify that instruction flags match the patterns.
   VerifyInstructionFlags();
 }
 
 Record *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const {
   Record *N = Records.getDef(Name);
-  if (!N || !N->isSubClassOf("SDNode")) {
-    errs() << "Error getting SDNode '" << Name << "'!\n";
-    exit(1);
-  }
+  if (!N || !N->isSubClassOf("SDNode"))
+    PrintFatalError("Error getting SDNode '" + Name + "'!");
+
   return N;
 }
 
 // Parse all of the SDNode definitions for the target, populating SDNodes.
 void CodeGenDAGPatterns::ParseNodeInfo() {
   std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode");
   while (!Nodes.empty()) {
     SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back()));

utils/TableGen/CodeGenTarget.cpp

if (PropList[i]->getName() == "SDNPHasChain") {
       Properties |= 1 << SDNPMemOperand;
     } else if (PropList[i]->getName() == "SDNPVariadic") {
       Properties |= 1 << SDNPVariadic;
     } else if (PropList[i]->getName() == "SDNPWantRoot") {
       Properties |= 1 << SDNPWantRoot;
     } else if (PropList[i]->getName() == "SDNPWantParent") {
       Properties |= 1 << SDNPWantParent;
     } else {
-      errs() << "Unsupported SD Node property '" << PropList[i]->getName()
-             << "' on ComplexPattern '" << R->getName() << "'!\n";
-      exit(1);
+      PrintFatalError("Unsupported SD Node property '" +
+                      PropList[i]->getName() + "' on ComplexPattern '" +
+                      R->getName() + "'!");
     }
 }
 
 //===----------------------------------------------------------------------===//
 // CodeGenIntrinsic Implementation
 //===----------------------------------------------------------------------===//
 
 std::vector<CodeGenIntrinsic> llvm::LoadIntrinsics(const RecordKeeper &RC,

utils/TableGen/DAGISelMatcherGen.cpp

void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
 
   if (LeafRec->isSubClassOf("CondCode"))
     return AddMatcher(new CheckCondCodeMatcher(LeafRec->getName()));
 
   if (LeafRec->isSubClassOf("ComplexPattern")) {
     // We can't model ComplexPattern uses that don't have their name taken yet.
     // The OPC_CheckComplexPattern operation implicitly records the results.
     if (N->getName().empty()) {
-      errs() << "We expect complex pattern uses to have names: " << *N << "\n";
-      exit(1);
+      std::string S;
+      raw_string_ostream OS(S);
+      OS << "We expect complex pattern uses to have names: " << *N;
+      PrintFatalError(OS.str());
     }
 
     // Remember this ComplexPattern so that we can emit it after all the other
     // structural matches are done.
     unsigned InputOperand = VariableMap[N->getName()] - 1;
     MatchedComplexPatterns.push_back(std::make_pair(N, InputOperand));
     return;
   }

utils/TableGen/InstrInfoEmitter.cpp

void InstrInfoEmitter::emitEnums(raw_ostream &OS) {
 
   OS << "namespace llvm {\n\n";
 
   CodeGenTarget Target(Records);
 
   // We must emit the PHI opcode first...
   std::string Namespace = Target.getInstNamespace();
 
-  if (Namespace.empty()) {
-    fprintf(stderr, "No instructions defined!\n");
-    exit(1);
-  }
+  if (Namespace.empty())
+    PrintFatalError("No instructions defined!");
 
   const std::vector<const CodeGenInstruction*> &NumberedInstructions =
     Target.getInstructionsByEnumValue();
 
   OS << "namespace " << Namespace << " {\n";
   OS << "  enum {\n";
   unsigned Num = 0;
   for (const CodeGenInstruction *Inst : NumberedInstructions)

utils/TableGen/SubtargetEmitter.cpp

void SubtargetEmitter::Enumeration(raw_ostream &OS,
                                    bool isBits) {
   // Get all records of class and sort
   std::vector<Record*> DefList = Records.getAllDerivedDefinitions(ClassName);
   std::sort(DefList.begin(), DefList.end(), LessRecord());
 
   unsigned N = DefList.size();
   if (N == 0)
     return;
-  if (N > 64) {
-    errs() << "Too many (> 64) subtarget features!\n";
-    exit(1);
-  }
+  if (N > 64)
+    PrintFatalError("Too many (> 64) subtarget features!");
 
   OS << "namespace " << Target << " {\n";
 
   // Open enumeration. Use a 64-bit underlying type.
   OS << "enum : uint64_t {\n";
 
   // For each record
   for (unsigned i = 0; i < N;) {