[TableGen][VarLenCodeEmitterGen] Improve the error message

[0x59616e]

Summary

This gives a approximate error location. Although not very
accurate, it suffices to debug.

[0x59616e]

clang-format

[0x59616e]

rebase

[0x59616e]

clang-format

[0x59616e]

address feedback

[0x59616e]

update diff. I use arc incorrectly.

[myhsu]

llvm/utils/TableGen/VarLenCodeEmitterGen.cpp

95

please initialize TheDef with nullptr in default ctor.

143

just want to be safe, maybe we should assert on TheDef here to make sure it's not null.

[0x59616e]

address feedback

[myhsu]

LGTM cheers

[0x59616e]

Thanks @myhsu ;)

llvm/utils/TableGen/VarLenCodeEmitterGen.cpp

class VarLenCodeEmitterGen {
 
   struct EncodingSegment {
     unsigned BitWidth;
     const Init *Value;
     StringRef CustomEncoder = "";
   };
 
   class VarLenInst {
+    RecordVal *TheDef;
     size_t NumBits;
 
     // Set if any of the segment is not fixed value.
     bool HasDynamicSegment;
 
     SmallVector<EncodingSegment, 4> Segments;
 
     void buildRec(const DagInit *DI);
 
     StringRef getCustomEncoderName(const Init *EI) const {
       if (const auto *DI = dyn_cast<DagInit>(EI)) {
         if (DI->getNumArgs() && isa<StringInit>(DI->getArg(0)))
           return cast<StringInit>(DI->getArg(0))->getValue();
       }
       return "";
     }
 
   public:
-    VarLenInst() : NumBits(0U), HasDynamicSegment(false) {}
+    VarLenInst() : TheDef(nullptr), NumBits(0U), HasDynamicSegment(false) {}
 
-    explicit VarLenInst(const DagInit *DI);
+    explicit VarLenInst(const DagInit *DI, RecordVal *TheDef);
 
     /// Number of bits
     size_t size() const { return NumBits; }
 
     using const_iterator = decltype(Segments)::const_iterator;
 
     const_iterator begin() const { return Segments.begin(); }
     const_iterator end() const { return Segments.end(); }

 public:
   explicit VarLenCodeEmitterGen(RecordKeeper &R) : Records(R) {}
 
   void run(raw_ostream &OS);
 };
 
 } // end anonymous namespace
 
-VarLenCodeEmitterGen::VarLenInst::VarLenInst(const DagInit *DI) : NumBits(0U) {
+VarLenCodeEmitterGen::VarLenInst::VarLenInst(const DagInit *DI,
+                                             RecordVal *TheDef)
+    : TheDef(TheDef), NumBits(0U) {
   buildRec(DI);
   for (const auto &S : Segments)
     NumBits += S.BitWidth;
 }
 
 void VarLenCodeEmitterGen::VarLenInst::buildRec(const DagInit *DI) {
+  assert(TheDef && "The def record is nullptr ?");
+
   std::string Op = DI->getOperator()->getAsString();
 
   if (Op == "ascend" || Op == "descend") {
     bool Reverse = Op == "descend";
     int i = Reverse ? DI->getNumArgs() - 1 : 0;
     int e = Reverse ? -1 : DI->getNumArgs();
     int s = Reverse ? -1 : 1;
     for (; i != e; i += s) {
       const Init *Arg = DI->getArg(i);
       if (const auto *BI = dyn_cast<BitsInit>(Arg)) {
         if (!BI->isComplete())
-          PrintFatalError("Expecting complete bits init in `" + Op + "`");
+          PrintFatalError(TheDef->getLoc(),
+                          "Expecting complete bits init in `" + Op + "`");
         Segments.push_back({BI->getNumBits(), BI});
       } else if (const auto *BI = dyn_cast<BitInit>(Arg)) {
         if (!BI->isConcrete())
-          PrintFatalError("Expecting concrete bit init in `" + Op + "`");
+          PrintFatalError(TheDef->getLoc(),
+                          "Expecting concrete bit init in `" + Op + "`");
         Segments.push_back({1, BI});
       } else if (const auto *SubDI = dyn_cast<DagInit>(Arg)) {
         buildRec(SubDI);
       } else {
-        PrintFatalError("Unrecognized type of argument in `" + Op +
-                        "`: " + Arg->getAsString());
+        PrintFatalError(TheDef->getLoc(), "Unrecognized type of argument in `" +
+                                              Op + "`: " + Arg->getAsString());
       }
     }
   } else if (Op == "operand") {
     // (operand <operand name>, <# of bits>, [(encoder <custom encoder>)])
     if (DI->getNumArgs() < 2)
-      PrintFatalError("Expecting at least 2 arguments for `operand`");
+      PrintFatalError(TheDef->getLoc(),
+                      "Expecting at least 2 arguments for `operand`");
     HasDynamicSegment = true;
     const Init *OperandName = DI->getArg(0), *NumBits = DI->getArg(1);
     if (!isa<StringInit>(OperandName) || !isa<IntInit>(NumBits))
-      PrintFatalError("Invalid argument types for `operand`");
+      PrintFatalError(TheDef->getLoc(), "Invalid argument types for `operand`");
 
     auto NumBitsVal = cast<IntInit>(NumBits)->getValue();
     if (NumBitsVal <= 0)
-      PrintFatalError("Invalid number of bits for `operand`");
+      PrintFatalError(TheDef->getLoc(), "Invalid number of bits for `operand`");
 
     StringRef CustomEncoder;
     if (DI->getNumArgs() >= 3)
       CustomEncoder = getCustomEncoderName(DI->getArg(2));
     Segments.push_back(
         {static_cast<unsigned>(NumBitsVal), OperandName, CustomEncoder});
   } else if (Op == "slice") {
     // (slice <operand name>, <high / low bit>, <low / high bit>,
     //        [(encoder <custom encoder>)])
     if (DI->getNumArgs() < 3)
-      PrintFatalError("Expecting at least 3 arguments for `slice`");
+      PrintFatalError(TheDef->getLoc(),
+                      "Expecting at least 3 arguments for `slice`");
     HasDynamicSegment = true;
     Init *OperandName = DI->getArg(0), *HiBit = DI->getArg(1),
          *LoBit = DI->getArg(2);
     if (!isa<StringInit>(OperandName) || !isa<IntInit>(HiBit) ||
         !isa<IntInit>(LoBit))
-      PrintFatalError("Invalid argument types for `slice`");
+      PrintFatalError(TheDef->getLoc(), "Invalid argument types for `slice`");
 
     auto HiBitVal = cast<IntInit>(HiBit)->getValue(),
          LoBitVal = cast<IntInit>(LoBit)->getValue();
     if (HiBitVal < 0 || LoBitVal < 0)
-      PrintFatalError("Invalid bit range for `slice`");
+      PrintFatalError(TheDef->getLoc(), "Invalid bit range for `slice`");
     bool NeedSwap = false;
     unsigned NumBits = 0U;
     if (HiBitVal < LoBitVal) {
       NeedSwap = true;
       NumBits = static_cast<unsigned>(LoBitVal - HiBitVal + 1);
     } else {
       NumBits = static_cast<unsigned>(HiBitVal - LoBitVal + 1);
     }
if (R->getValueAsString("Namespace") == "TargetOpcode" ||
       continue;
 
     if (const RecordVal *RV = R->getValue("EncodingInfos")) {
       if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) {
         EncodingInfoByHwMode EBM(DI->getDef(), HWM);
         for (auto &KV : EBM) {
           HwModes.insert(KV.first);
           Record *EncodingDef = KV.second;
-          auto *DI = EncodingDef->getValueAsDag("Inst");
-          VarLenInsts.insert({EncodingDef, VarLenInst(DI)});
+          RecordVal *RV = EncodingDef->getValue("Inst");
+          DagInit *DI = cast<DagInit>(RV->getValue());
+          VarLenInsts.insert({EncodingDef, VarLenInst(DI, RV)});
         }
         continue;
       }
     }
-    auto *DI = R->getValueAsDag("Inst");
-    VarLenInsts.insert({R, VarLenInst(DI)});
+    RecordVal *RV = R->getValue("Inst");
+    DagInit *DI = cast<DagInit>(RV->getValue());
+    VarLenInsts.insert({R, VarLenInst(DI, RV)});
   }
 
   // Emit function declaration
   OS << "void " << Target.getName()
      << "MCCodeEmitter::getBinaryCodeForInstr(const MCInst &MI,\n"
      << "    SmallVectorImpl<MCFixup> &Fixups,\n"
      << "    APInt &Inst,\n"
      << "    APInt &Scratch,\n"