[TableGen] Eliminte source location from CodeInit

[Paul-C-Anagnostopoulos]

Summary

This is the first step in eliminating the 'code' type from TableGen. The CodeInit class, which represents a code value, has a slot for the source location of the code. This patch eliminates that slot.

The only backend that uses this source location is CICombinerEmitter. I reworked it so that it does not use the location.

[Paul-C-Anagnostopoulos]

I deleted some obsolete lines of code in Record.h.

llvm/docs/TableGen/BackGuide.rst

 * A function that gets a bit specified by an integer index.
 
 ``CodeInit``
 ~~~~~~~~~~~~
 
 The ``CodeInit`` class is a subclass of ``TypedInit``. Its instances
 represent arbitrary-length strings produced from ``code`` literals in the
 TableGen files. It includes a data member that contains a ``StringRef`` of
-the value. It also includes a data member specifying the source code
-location of the code string.
+the value.
 
 The class provides the usual ``get()`` and ``getValue()`` functions. The
 latter function returns the ``StringRef``.
 
-The ``getLoc()`` function returns the source code location.
-
 
 ``DagInit``
 ~~~~~~~~~~~
 
 The ``DagInit`` class is a subclass of ``TypedInit``. Its instances
 represent the possible direct acyclic graphs (``dag``). 
 
 The class includes a pointer to an ``Init`` for the DAG operator and a
===-------------------------------------------------------------------------===
      1.1388 (  0.2%)   0.0000 (  0.0%)   1.1388 (  0.2%)   1.1401 (  0.2%)  Optimize matchers
      0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0050 (  0.0%)  Write output
     746.2308 (100.0%)   0.1560 (100.0%)  746.3868 (100.0%)  747.1447 (100.0%)  Total
 
 The backend has been divided into four phases and timed separately.
 
 If you want to instrument a backend, refer to the backend ``DAGISelEmitter.cpp``
 and search for ``Records.startTimer``.
 No newline at end of file

llvm/include/llvm/TableGen/Record.h

public:
 
   Init *getBit(unsigned Bit) const override {
     return BitInit::get((Value & (1ULL << Bit)) != 0);
   }
 };
 
 /// "foo" - Represent an initialization by a string value.
 class StringInit : public TypedInit {
+////  enum StringFormat {
+////    SF_String,  // Format as "text"
+////    SF_Code,    // Format as [{text}]
+////  };
+
   StringRef Value;
+////  StringFormat Format;
 
   explicit StringInit(StringRef V)
       : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {}
 
 public:
   StringInit(const StringInit &) = delete;
   StringInit &operator=(const StringInit &) = delete;
 
public:
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off string");
   }
 };
 
 class CodeInit : public TypedInit {
   StringRef Value;
-  SMLoc Loc;
+////  SMLoc Loc;
 
-  explicit CodeInit(StringRef V, const SMLoc &Loc)
+  explicit CodeInit(StringRef V)
       : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
-        Value(V), Loc(Loc) {}
+        Value(V) {}
+////  explicit CodeInit(StringRef V, const SMLoc &Loc)
+////      : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
+////        Value(V), Loc(Loc) {}
 
 public:
   CodeInit(const StringInit &) = delete;
   CodeInit &operator=(const StringInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_CodeInit;
   }
 
-  static CodeInit *get(StringRef, const SMLoc &Loc);
+  static CodeInit *get(StringRef);
+////  static CodeInit *get(StringRef, const SMLoc &Loc);
 
   StringRef getValue() const { return Value; }
-  const SMLoc &getLoc() const { return Loc; }
+////  const SMLoc &getLoc() const { return Loc; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   bool isConcrete() const override { return true; }
   std::string getAsString() const override {
     return "[{" + Value.str() + "}]";
   }
 
public:
 
   void print(raw_ostream &OS) const;
   void dump() const;
 
   //===--------------------------------------------------------------------===//
   // High-level methods useful to tablegen back-ends
   //
 
+  ///Return the source location for the named field.
+  SMLoc getFieldLoc(StringRef FieldName) const;
+
   /// Return the initializer for a value with the specified name,
   /// or throw an exception if the field does not exist.
   Init *getValueInit(StringRef FieldName) const;
 
   /// Return true if the named field is unset.
   bool isValueUnset(StringRef FieldName) const {
     return isa<UnsetInit>(getValueInit(FieldName));
   }

llvm/lib/TableGen/Record.cpp

for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= 64)
       return nullptr;
 
     NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
   }
   return BitsInit::get(NewBits);
 }
 
-CodeInit *CodeInit::get(StringRef V, const SMLoc &Loc) {
-  static StringSet<BumpPtrAllocator &> ThePool(Allocator);
+CodeInit *CodeInit::get(StringRef V) {
+  static StringMap<CodeInit*, BumpPtrAllocator &> ThePool(Allocator);
 
-  CodeInitsConstructed++;
-
-  // Unlike StringMap, StringSet doesn't accept empty keys.
-  if (V.empty())
-    return new (Allocator) CodeInit("", Loc);
-
-  // Location tracking prevents us from de-duping CodeInits as we're never
-  // called with the same string and same location twice. However, we can at
-  // least de-dupe the strings for a modest saving.
-  auto &Entry = *ThePool.insert(V).first;
-  return new(Allocator) CodeInit(Entry.getKey(), Loc);
+  auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
+  if (!Entry.second)
+    Entry.second = new(Allocator) CodeInit(Entry.getKey());
+  return Entry.second;
 }
 
 StringInit *StringInit::get(StringRef V) {
   static StringMap<StringInit*, BumpPtrAllocator &> ThePool(Allocator);
 
   auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
   if (!Entry.second)
     Entry.second = new(Allocator) StringInit(Entry.getKey());
   return Entry.second;
 }
 
 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<StringRecTy>(Ty))
     return const_cast<StringInit *>(this);
   if (isa<CodeRecTy>(Ty))
-    return CodeInit::get(getValue(), SMLoc());
+    return CodeInit::get(getValue());
 
   return nullptr;
 }
 
 Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<CodeRecTy>(Ty))
     return const_cast<CodeInit *>(this);
   if (isa<StringRecTy>(Ty))
if (LHSs && RHSs) {
       case NE: Result = LHSs->getValue() != RHSs->getValue(); break;
       case LE: Result = LHSs->getValue() <= RHSs->getValue(); break;
       case LT: Result = LHSs->getValue() <  RHSs->getValue(); break;
       case GE: Result = LHSs->getValue() >= RHSs->getValue(); break;
       case GT: Result = LHSs->getValue() >  RHSs->getValue(); break;
       default: llvm_unreachable("unhandled comparison");
       }
       return BitInit::get(Result);
-////      bool Equal = LHSs->getValue() == RHSs->getValue();
-////      return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
     }
 
     // Finally, !eq and !ne can be used with records.
     if (getOpcode() == EQ || getOpcode() == NE) {
       DefInit *LHSd = dyn_cast<DefInit>(LHS);
       DefInit *RHSd = dyn_cast<DefInit>(RHS);
       if (LHSd && RHSd)
         return BitInit::get((getOpcode() == EQ) ? LHSd == RHSd
if (Value) {
       }
     }
     return Value == nullptr;
   }
   Value = nullptr;
   return false;
 }
 
-// This version of setValue takes an source location and resets the
+// This version of setValue takes a source location and resets the
 // location in the RecordVal.
 bool RecordVal::setValue(Init *V, SMLoc NewLoc) {
   Loc = NewLoc;
   if (V) {
     Value = V->getCastTo(getType());
     if (Value) {
       assert(!isa<TypedInit>(Value) ||
              cast<TypedInit>(Value)->getType()->typeIsA(getType()));
if (Val.getPrefix() && !R.isTemplateArg(Val.getNameInit()))
       OS << Val;
   for (const RecordVal &Val : R.getValues())
     if (!Val.getPrefix() && !R.isTemplateArg(Val.getNameInit()))
       OS << Val;
 
   return OS << "}\n";
 }
 
+SMLoc Record::getFieldLoc(StringRef FieldName) const {
+  const RecordVal *R = getValue(FieldName);
+  if (!R)
+    PrintFatalError(getLoc(), "Record `" + getName() +
+      "' does not have a field named `" + FieldName + "'!\n");
+  return R->getLoc();
+}
+
 Init *Record::getValueInit(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (!R || !R->getValue())
     PrintFatalError(getLoc(), "Record `" + getName() +
       "' does not have a field named `" + FieldName + "'!\n");
   return R->getValue();
 }
 

llvm/lib/TableGen/TGParser.cpp

while (Lex.getCode() == tgtok::StrVal) {
       Val += Lex.getCurStrVal();
       Lex.Lex();
     }
 
     R = StringInit::get(Val);
     break;
   }
   case tgtok::CodeFragment:
-    R = CodeInit::get(Lex.getCurStrVal(), Lex.getLoc());
+    R = CodeInit::get(Lex.getCurStrVal());
     Lex.Lex();
     break;
   case tgtok::question:
     R = UnsetInit::get();
     Lex.Lex();
     break;
   case tgtok::Id: {
     SMLoc NameLoc = Lex.getLoc();

llvm/unittests/TableGen/CodeExpanderTest.cpp

TEST(CodeExpander, NotAnExpansion) {
   raw_string_ostream OS(Result);
   CodeExpansions Expansions;
 
   RAIIDiagnosticChecker DiagChecker;
   StringRef In = bufferize(" $foo");
   CodeExpander(" $foo", Expansions, SMLoc::getFromPointer(In.data()), false)
       .emit(OS);
   EXPECT_EQ(OS.str(), " $foo");
   DiagChecker.expect(SMDiagnostic(
-      SrcMgr, SMLoc::getFromPointer(In.data() + 1), "TestBuffer", 1, 1,
-      SourceMgr::DK_Warning, "Assuming missing escape character", " $foo", {}));
+      SrcMgr, SMLoc::getFromPointer(In.data()), "TestBuffer", 1, 0,
+      SourceMgr::DK_Warning, "Assuming missing escape character: \\$", " $foo", {}));
 }
 
 // \$foo is not an expansion but shouldn't warn as it's using the escape.
 TEST(CodeExpander, EscapedNotAnExpansion) {
   std::string Result;
   raw_string_ostream OS(Result);
   CodeExpansions Expansions;
 
TEST(CodeExpander, UndefinedExpansion) {
   CodeExpansions Expansions;
   Expansions.declare("bar", "expansion");
 
   RAIIDiagnosticChecker DiagChecker;
   CodeExpander("${foo}${bar}", Expansions, SMLoc(), false).emit(OS);
   EXPECT_EQ(OS.str(), "expansion");
   DiagChecker.expect(
       SMDiagnostic(SrcMgr, SMLoc(), "<unknown>", 0, -1, SourceMgr::DK_Error,
-                   "Attempting to expand an undeclared variable foo", "", {}));
-}
-
-// ${foo} is an undefined expansion and should error. When given a valid
-// location for the start of the buffer it should correctly point at the
-// expansion being performed.
-TEST(CodeExpander, UndefinedExpansionWithLoc) {
-  std::string Result;
-  raw_string_ostream OS(Result);
-  CodeExpansions Expansions;
-  Expansions.declare("bar", "expansion");
-
-  RAIIDiagnosticChecker DiagChecker;
-  StringRef In = bufferize("Padding ${foo}${bar}");
-  CodeExpander(In, Expansions, SMLoc::getFromPointer(In.data()), false)
-      .emit(OS);
-  EXPECT_EQ(OS.str(), "Padding expansion");
-  DiagChecker.expect(SMDiagnostic(
-      SrcMgr, SMLoc::getFromPointer(In.data() + 8), "TestBuffer", 1, 8,
-      SourceMgr::DK_Error, "Attempting to expand an undeclared variable foo",
-      "Padding ${foo}${bar}", {}));
+                   "Attempt to expand an undeclared variable 'foo'", "", {}));
 }
 
 // ${bar is an unterminated expansion. Warn and implicitly terminate it.
 TEST(CodeExpander, UnterminatedExpansion) {
   std::string Result;
   raw_string_ostream OS(Result);
   CodeExpansions Expansions;
   Expansions.declare("bar", "expansion");
 
   RAIIDiagnosticChecker DiagChecker;
   StringRef In = bufferize(" ${bar");
   CodeExpander(In, Expansions, SMLoc::getFromPointer(In.data()), false)
       .emit(OS);
   EXPECT_EQ(OS.str(), " expansion");
-  DiagChecker.expect(SMDiagnostic(SrcMgr, SMLoc::getFromPointer(In.data() + 1),
-                                  "TestBuffer", 1, 1, SourceMgr::DK_Warning,
-                                  "Unterminated expansion", " ${bar", {}));
+  DiagChecker.expect(SMDiagnostic(SrcMgr, SMLoc::getFromPointer(In.data()),
+                                  "TestBuffer", 1, 0, SourceMgr::DK_Warning,
+                                  "Unterminated expansion '${bar'", " ${bar", {}));
 }

llvm/utils/TableGen/GICombinerEmitter.cpp

for (const auto &VarBinding : Leaf.var_bindings()) {
                                "]->getOperand(" +
                                to_string(VarBinding.getOpIdx()) + ")");
     }
     Rule->declareExpansions(Expansions);
 
     DagInit *Applyer = RuleDef.getValueAsDag("Apply");
     if (Applyer->getOperatorAsDef(RuleDef.getLoc())->getName() !=
         "apply") {
-      PrintError(RuleDef.getLoc(), "Expected apply operator");
+      PrintError(RuleDef.getLoc(), "Expected 'apply' operator in Apply DAG");
       return;
     }
 
     OS << Indent << "  if (1\n";
 
     // Attempt to emit code for any untested predicates left over. Note that
     // isFullyTested() will remain false even if we succeed here and therefore
     // combine rule elision will not be performed. This is because we do not
if (Rule->getMatchingFixupCode() &&
       // defer some work to successive patches but we need to eliminate this
       // before the ruleset grows to small-moderate size. Last time, it became
       // a big problem for low-mem systems around the 500 rule mark but by the
       // time we grow that large we should have merged the ISel match table
       // mechanism with the Combiner.
       OS << Indent << "      && [&]() {\n"
          << Indent << "      "
          << CodeExpander(Rule->getMatchingFixupCode()->getValue(), Expansions,
-                         Rule->getMatchingFixupCode()->getLoc(), ShowExpansions)
+                         RuleDef.getLoc(), ShowExpansions)
          << "\n"
          << Indent << "      return true;\n"
          << Indent << "  }()";
     }
     OS << ") {\n" << Indent << "   ";
 
     if (const CodeInit *Code = dyn_cast<CodeInit>(Applyer->getArg(0))) {
       OS << CodeExpander(Code->getAsUnquotedString(), Expansions,
-                         Code->getLoc(), ShowExpansions)
+                         RuleDef.getLoc(), ShowExpansions)
          << "\n"
          << Indent << "    return true;\n"
          << Indent << "  }\n";
     } else {
       PrintError(RuleDef.getLoc(), "Expected apply code block");
       return;
     }
 

llvm/utils/TableGen/GlobalISel/CodeExpander.cpp

if (Current.startswith("${")) {
       StringRef StartVar = Current;
       Current = Current.drop_front(2);
       StringRef Var;
       std::tie(Var, Current) = Current.split("}");
 
       // Warn if we split because no terminator was found.
       StringRef EndVar = StartVar.drop_front(2 /* ${ */ + Var.size());
       if (EndVar.empty()) {
-        size_t LocOffset = StartVar.data() - Code.data();
-        PrintWarning(
-            Loc.size() > 0 && Loc[0].isValid()
-                ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
-                : SMLoc(),
-            "Unterminated expansion");
+        PrintWarning(Loc, "Unterminated expansion '${" + Var + "'");
+        PrintNote("Code: [{" + Code + "}]");
       }
 
       auto ValueI = Expansions.find(Var);
       if (ValueI == Expansions.end()) {
-        size_t LocOffset = StartVar.data() - Code.data();
-        PrintError(Loc.size() > 0 && Loc[0].isValid()
-                       ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
-                       : SMLoc(),
-                   "Attempting to expand an undeclared variable " + Var);
+        PrintError(Loc,
+                   "Attempt to expand an undeclared variable '" + Var + "'");
+        PrintNote("Code: [{" + Code + "}]");
       }
       if (ShowExpansions)
         OS << "/*$" << Var << "{*/";
       OS << Expansions.lookup(Var);
       if (ShowExpansions)
         OS << "/*}*/";
       continue;
     }
 
-    size_t LocOffset = Current.data() - Code.data();
-    PrintWarning(Loc.size() > 0 && Loc[0].isValid()
-                     ? SMLoc::getFromPointer(Loc[0].getPointer() + LocOffset)
-                     : SMLoc(),
-                 "Assuming missing escape character");
+    PrintWarning(Loc, "Assuming missing escape character: \\$");
+    PrintNote("Code: [{" + Code + "}]");
     OS << "$";
     Current = Current.drop_front(1);
   }
 }