Rename to instances

Author: wangpc-pp

llvm/docs/TableGen/ProgRef.rst

@@ -223,10 +223,10 @@ TableGen provides "bang operators" that have a wide variety of uses:
                : !div         !empty       !eq          !exists      !filter
                : !find        !foldl       !foreach     !ge          !getdagarg
                : !getdagname  !getdagop    !gt          !head        !if
-               : !initialized !interleave  !isa         !le          !listconcat
-               : !listflatten !listremove  !listsplat   !logtwo      !lt
-               : !match       !mul         !ne          !not         !or
-               : !range       !records     !repr        !setdagarg   !setdagname
+               : !initialized !instances   !interleave  !isa         !le
+               : !listconcat  !listflatten !listremove  !listsplat   !logtwo
+               : !lt          !match       !mul         !ne          !not
+               : !or          !range       !repr        !setdagarg   !setdagname
                : !setdagop    !shl         !size        !sra         !srl
                : !strconcat   !sub         !subst       !substr      !tail
                : !tolower     !toupper     !xor
@@ -1836,6 +1836,12 @@ and non-0 as true.
   This operator produces 1 if *a* is not the uninitialized value (``?``) and 0
   otherwise.
 
+``!instances<``\ *type*\ ``>([``\ *regex*\ ``])``
+    This operator produces a list of records whose type is *type*. If *regex*
+    is provided, only records whose name matches the regular expression *regex*
+    will be included. The format of *regex* is ERE (Extended POSIX Regular
+    Expressions).
+
 ``!interleave(``\ *list*\ ``,`` *delim*\ ``)``
     This operator concatenates the items in the *list*, interleaving the
     *delim* string between each pair, and produces the resulting string.
@@ -1920,12 +1926,6 @@ and non-0 as true.
 ``!range(``\ *list*\ ``)``
     Equivalent to ``!range(0, !size(list))``.
 
-``!records<``\ *type*\ ``>([``\ *regex*\ ``])``
-    This operator produces a list of records whose type is *type*. If *regex*
-    is provided, only records whose name matches the regular expression *regex*
-    will be included. The format of *regex* is ERE (Extended POSIX Regular
-    Expressions).
-
 ``!repr(``\ *value*\ ``)``
     Represents *value* as a string. String format for the value is not
     guaranteed to be stable. Intended for debugging purposes only.

llvm/include/llvm/TableGen/Record.h

@@ -316,7 +316,7 @@ class Init {
     IK_FoldOpInit,
     IK_IsAOpInit,
     IK_ExistsOpInit,
-    IK_RecordsOpInit,
+    IK_InstancesOpInit,
     IK_AnonymousNameInit,
     IK_StringInit,
     IK_VarInit,
@@ -1193,27 +1193,27 @@ class ExistsOpInit final : public TypedInit, public FoldingSetNode {
   std::string getAsString() const override;
 };
 
-/// !records<type>([regex]) - Produces a list of records whose type is `type`.
+/// !instances<type>([regex]) - Produces a list of records whose type is `type`.
 /// If `regex` is provided, only records whose name matches the regular
 /// expression `regex` will be included.
-class RecordsOpInit final : public TypedInit, public FoldingSetNode {
+class InstancesOpInit final : public TypedInit, public FoldingSetNode {
 private:
   const RecTy *Type;
   const Init *Regex;
 
-  RecordsOpInit(const RecTy *Type, const Init *Regex)
-      : TypedInit(IK_RecordsOpInit, ListRecTy::get(Type)), Type(Type),
+  InstancesOpInit(const RecTy *Type, const Init *Regex)
+      : TypedInit(IK_InstancesOpInit, ListRecTy::get(Type)), Type(Type),
         Regex(Regex) {}
 
 public:
-  RecordsOpInit(const RecordsOpInit &) = delete;
-  RecordsOpInit &operator=(const RecordsOpInit &) = delete;
+  InstancesOpInit(const InstancesOpInit &) = delete;
+  InstancesOpInit &operator=(const InstancesOpInit &) = delete;
 
   static bool classof(const Init *I) {
-    return I->getKind() == IK_RecordsOpInit;
+    return I->getKind() == IK_InstancesOpInit;
   }
 
-  static const RecordsOpInit *get(const RecTy *Type, const Init *Regex);
+  static const InstancesOpInit *get(const RecTy *Type, const Init *Regex);
 
   void Profile(FoldingSetNodeID &ID) const;
 

llvm/lib/TableGen/Record.cpp

@@ -84,7 +84,7 @@ struct RecordKeeperImpl {
   FoldingSet<FoldOpInit> TheFoldOpInitPool;
   FoldingSet<IsAOpInit> TheIsAOpInitPool;
   FoldingSet<ExistsOpInit> TheExistsOpInitPool;
-  FoldingSet<RecordsOpInit> TheRecordsOpInitPool;
+  FoldingSet<InstancesOpInit> TheInstancesOpInitPool;
   DenseMap<std::pair<const RecTy *, const Init *>, VarInit *> TheVarInitPool;
   DenseMap<std::pair<const TypedInit *, unsigned>, VarBitInit *>
       TheVarBitInitPool;
@@ -2223,32 +2223,33 @@ std::string ExistsOpInit::getAsString() const {
       .str();
 }
 
-static void ProfileRecordsOpInit(FoldingSetNodeID &ID, const RecTy *Type,
-                                 const Init *Regex) {
+static void ProfileInstancesOpInit(FoldingSetNodeID &ID, const RecTy *Type,
+                                   const Init *Regex) {
   ID.AddPointer(Type);
   ID.AddPointer(Regex);
 }
 
-const RecordsOpInit *RecordsOpInit::get(const RecTy *Type, const Init *Regex) {
+const InstancesOpInit *InstancesOpInit::get(const RecTy *Type,
+                                            const Init *Regex) {
   FoldingSetNodeID ID;
-  ProfileRecordsOpInit(ID, Type, Regex);
+  ProfileInstancesOpInit(ID, Type, Regex);
 
   detail::RecordKeeperImpl &RK = Regex->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (const RecordsOpInit *I =
-          RK.TheRecordsOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (const InstancesOpInit *I =
+          RK.TheInstancesOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  RecordsOpInit *I = new (RK.Allocator) RecordsOpInit(Type, Regex);
-  RK.TheRecordsOpInitPool.InsertNode(I, IP);
+  InstancesOpInit *I = new (RK.Allocator) InstancesOpInit(Type, Regex);
+  RK.TheInstancesOpInitPool.InsertNode(I, IP);
   return I;
 }
 
-void RecordsOpInit::Profile(FoldingSetNodeID &ID) const {
-  ProfileRecordsOpInit(ID, Type, Regex);
+void InstancesOpInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileInstancesOpInit(ID, Type, Regex);
 }
 
-const Init *RecordsOpInit::Fold() const {
+const Init *InstancesOpInit::Fold() const {
   const auto *RegexInit = dyn_cast<StringInit>(Regex);
   if (!RegexInit)
     return this;
@@ -2267,19 +2268,20 @@ const Init *RecordsOpInit::Fold() const {
   return ListInit::get(Selected, Type);
 }
 
-const Init *RecordsOpInit::resolveReferences(Resolver &R) const {
+const Init *InstancesOpInit::resolveReferences(Resolver &R) const {
   const Init *NewRegex = Regex->resolveReferences(R);
   if (Regex != NewRegex)
     return get(Type, NewRegex)->Fold();
   return this;
 }
 
-const Init *RecordsOpInit::getBit(unsigned Bit) const {
+const Init *InstancesOpInit::getBit(unsigned Bit) const {
   return VarBitInit::get(this, Bit);
 }
 
-std::string RecordsOpInit::getAsString() const {
-  return "!records<" + Type->getAsString() + ">(" + Regex->getAsString() + ")";
+std::string InstancesOpInit::getAsString() const {
+  return "!instances<" + Type->getAsString() + ">(" + Regex->getAsString() +
+         ")";
 }
 
 const RecTy *TypedInit::getFieldType(const StringInit *FieldName) const {

llvm/lib/TableGen/TGLexer.cpp

@@ -629,10 +629,10 @@ tgtok::TokKind TGLexer::LexExclaim() {
           .Case("listsplat", tgtok::XListSplat)
           .Case("listremove", tgtok::XListRemove)
           .Case("range", tgtok::XRange)
-          .Case("records", tgtok::XRecords)
           .Case("strconcat", tgtok::XStrConcat)
           .Case("initialized", tgtok::XInitialized)
           .Case("interleave", tgtok::XInterleave)
+          .Case("instances", tgtok::XInstances)
           .Case("substr", tgtok::XSubstr)
           .Case("find", tgtok::XFind)
           .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.

llvm/lib/TableGen/TGLexer.h

@@ -137,6 +137,7 @@ enum TokKind {
   XSize,
   XEmpty,
   XInitialized,
+  XInstances,
   XIf,
   XCond,
   XEq,
@@ -154,7 +155,6 @@ enum TokKind {
   XToLower,
   XToUpper,
   XRange,
-  XRecords,
   XGetDagArg,
   XGetDagName,
   XSetDagArg,

llvm/lib/TableGen/TGParser.cpp

@@ -1455,16 +1455,16 @@ const Init *TGParser::ParseOperation(Record *CurRec, const RecTy *ItemType) {
     return (ExistsOpInit::get(Type, Expr))->Fold(CurRec);
   }
 
-  case tgtok::XRecords: {
-    // Value ::= !records '<' Type '>' '(' Regex? ')'
+  case tgtok::XInstances: {
+    // Value ::= !instances '<' Type '>' '(' Regex? ')'
     Lex.Lex(); // eat the operation.
 
     const RecTy *Type = ParseOperatorType();
     if (!Type)
       return nullptr;
 
     if (!consume(tgtok::l_paren)) {
-      TokError("expected '(' after type of !records");
+      TokError("expected '(' after type of !instances");
       return nullptr;
     }
 
@@ -1476,13 +1476,13 @@ const Init *TGParser::ParseOperation(Record *CurRec, const RecTy *ItemType) {
 
       const auto *RegexType = dyn_cast<TypedInit>(Regex);
       if (!RegexType) {
-        Error(RegexLoc, "expected string type argument in !records operator");
+        Error(RegexLoc, "expected string type argument in !instances operator");
         return nullptr;
       }
 
       const auto *SType = dyn_cast<StringRecTy>(RegexType->getType());
       if (!SType) {
-        Error(RegexLoc, "expected string type argument in !records operator");
+        Error(RegexLoc, "expected string type argument in !instances operator");
         return nullptr;
       }
     } else {
@@ -1491,11 +1491,11 @@ const Init *TGParser::ParseOperation(Record *CurRec, const RecTy *ItemType) {
     }
 
     if (!consume(tgtok::r_paren)) {
-      TokError("expected ')' in !records");
+      TokError("expected ')' in !instances");
       return nullptr;
     }
 
-    return RecordsOpInit::get(Type, Regex)->Fold();
+    return InstancesOpInit::get(Type, Regex)->Fold();
   }
 
   case tgtok::XConcat:

llvm/test/TableGen/records.td

@@ -12,49 +12,49 @@ class B : A;
 def b0 : B;
 def b1 : B;
 
-def records_A {
-  list<A> records = !records<A>();
+def instances_A {
+  list<A> instances = !instances<A>();
 }
 
-def records_A_x0 {
-  list<A> records = !records<A>(".*0");
+def instances_A_x0 {
+  list<A> instances = !instances<A>(".*0");
 }
 
-def records_A_x1 {
-  list<A> records = !records<A>(".*1");
+def instances_A_x1 {
+  list<A> instances = !instances<A>(".*1");
 }
 
-def records_B {
-  list<B> records = !records<B>();
+def instances_B {
+  list<B> instances = !instances<B>();
 }
 
-// CHECK-LABEL: def records_A {
-// CHECK-NEXT:    list<A> records = [a0, a1, b0, b1];
+// CHECK-LABEL: def instances_A {
+// CHECK-NEXT:    list<A> instances = [a0, a1, b0, b1];
 // CHECK-NEXT:  }
 
-// CHECK-LABEL: def records_A_x0 {
-// CHECK-NEXT:    list<A> records = [a0, b0];
+// CHECK-LABEL: def instances_A_x0 {
+// CHECK-NEXT:    list<A> instances = [a0, b0];
 // CHECK-NEXT:  }
 
-// CHECK-LABEL: def records_A_x1 {
-// CHECK-NEXT:    list<A> records = [a1, b1];
+// CHECK-LABEL: def instances_A_x1 {
+// CHECK-NEXT:    list<A> instances = [a1, b1];
 // CHECK-NEXT:  }
 
-// CHECK-LABEL: def records_B {
-// CHECK-NEXT:    list<B> records = [b0, b1];
+// CHECK-LABEL: def instances_B {
+// CHECK-NEXT:    list<B> instances = [b0, b1];
 // CHECK-NEXT:  }
 
 #ifdef ERROR1
-defvar error1 = !records<A>(123)
-// ERROR1: error: expected string type argument in !records operator
+defvar error1 = !instances<A>(123)
+// ERROR1: error: expected string type argument in !instances operator
 #endif
 
 #ifdef ERROR2
-defvar error2 = !records<1>("")
+defvar error2 = !instances<1>("")
 // ERROR2: error: Unknown token when expecting a type
 #endif
 
 #ifdef ERROR3
-defvar error3 = !records<A>("([)]")
+defvar error3 = !instances<A>("([)]")
 // ERROR3: error: invalid regex '([)]'
 #endif