TableGen: add !isa operation

[nhaehnle]

Summary

Change-Id: Iddb724c3ae706d82933a2d82c91d07e0e36b30e3

[tra]

docs/TableGen/LangIntro.rst

213–216 ↗

(On Diff #137053)

I've found this confusing. Why would anyone expect a string argument to !isa<>() to be magically cast to a record? I would after this comment, though. :-) IMO the first line of the description alone is sufficient.

lib/TableGen/Record.cpp

1235–1238 ↗

(On Diff #137053)

Why not use FoldingSet we use everywhere else?

I can't tell whether we're in danger of pointer reuse here, though if we are we'd need both CheckType and Expr to be freed, reallocated and passed to this function simultaneously in order to trigger a problem. Still...

lib/TableGen/TGParser.cpp

958 ↗

(On Diff #137053)

Did you mean "in !isa operator" ?

[nhaehnle]

Use folding set, change docs, and improve parser error messages

[nhaehnle]

docs/TableGen/LangIntro.rst

213–216 ↗

(On Diff #137053)

Done.

lib/TableGen/Record.cpp

1235–1238 ↗

(On Diff #137053)

Changed to use FoldingSet.

Yes, the pointer reuse thing is indeed a theoretical problem, but it's pretty pervasive for all objects that can directly or indirectly reference a Record. This should really be cleaned up at some point.

lib/TableGen/TGParser.cpp

958 ↗

(On Diff #137053)

The dangers of copy & paste :)

Fixed.

llvm/trunk/docs/TableGen/LangIntro.rst

``!cast<type>(a)``
     discouraged.
 
     Otherwise, perform a normal type cast e.g. between an int and a bit, or
     between record types. This allows casting a record to a subclass, though if
     the types do not match, constant folding will be inhibited. !cast<string>
     is a special case in that the argument can be an int or a record. In the
     latter case, the record's name is returned.
 
+``!isa<type>(a)``
+    Returns an integer: 1 if 'a' is dynamically of the given type, 0 otherwise.
+
 ``!subst(a, b, c)``
     If 'a' and 'b' are of string type or are symbol references, substitute 'b'
     for 'a' in 'c.'  This operation is analogous to $(subst) in GNU make.
 
 ``!foreach(a, b, c)``
     For each member of dag or list 'b' apply operator 'c'. 'a' is the name
     of a variable that will be substituted by members of 'b' in 'c'.
     This operation is analogous to $(foreach) in GNU make.

llvm/trunk/docs/TableGen/LangRef.rst

 wide variety of meanings:
 
 .. productionlist::
    BangOperator: one of
                :!eq     !if      !head    !tail      !con
                :!add    !shl     !sra     !srl       !and
                :!or     !empty   !subst   !foreach   !strconcat
                :!cast   !listconcat       !size      !foldl
+               :!isa
 
 
 Syntax
 ======
 
 TableGen has an ``include`` mechanism. It does not play a role in the
 syntax per se, since it is lexically replaced with the contents of the
 included file.

llvm/trunk/include/llvm/TableGen/Record.h

enum InitKind : uint8_t {
     IK_IntInit,
     IK_ListInit,
     IK_FirstOpInit,
     IK_BinOpInit,
     IK_TernOpInit,
     IK_UnOpInit,
     IK_LastOpInit,
     IK_FoldOpInit,
+    IK_IsAOpInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarListElementInit,
     IK_VarBitInit,
     IK_VarDefInit,
     IK_LastTypedInit,
     IK_UnsetInit
   };
public:
 
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
 
+/// !isa<type>(expr) - Dynamically determine the type of an expression.
+class IsAOpInit : public TypedInit, public FoldingSetNode {
+private:
+  RecTy *CheckType;
+  Init *Expr;
+
+  IsAOpInit(RecTy *CheckType, Init *Expr)
+      : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType),
+        Expr(Expr) {}
+
+public:
+  IsAOpInit(const IsAOpInit &) = delete;
+  IsAOpInit &operator=(const IsAOpInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_IsAOpInit; }
+
+  static IsAOpInit *get(RecTy *CheckType, Init *Expr);
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  // Fold - If possible, fold this to a simpler init.  Return this if not
+  // possible to fold.
+  Init *Fold() const;
+
+  bool isComplete() const override { return false; }
+
+  Init *resolveReferences(Resolver &R) const override;
+
+  Init *getBit(unsigned Bit) const override;
+
+  std::string getAsString() const override;
+};
+
 /// 'Opcode' - Represent a reference to an entire variable object.
 class VarInit : public TypedInit {
   Init *VarName;
 
   explicit VarInit(Init *VN, RecTy *T)
       : TypedInit(IK_VarInit, T), VarName(VN) {}
 
 public:

llvm/trunk/lib/TableGen/Record.cpp

 
 std::string FoldOpInit::getAsString() const {
   return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
           ", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
           ", " + Expr->getAsString() + ")")
       .str();
 }
 
+static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
+                             Init *Expr) {
+  ID.AddPointer(CheckType);
+  ID.AddPointer(Expr);
+}
+
+IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
+  static FoldingSet<IsAOpInit> ThePool;
+
+  FoldingSetNodeID ID;
+  ProfileIsAOpInit(ID, CheckType, Expr);
+
+  void *IP = nullptr;
+  if (IsAOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  IsAOpInit *I = new (Allocator) IsAOpInit(CheckType, Expr);
+  ThePool.InsertNode(I, IP);
+  return I;
+}
+
+void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileIsAOpInit(ID, CheckType, Expr);
+}
+
+Init *IsAOpInit::Fold() const {
+  if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
+    // Is the expression type known to be (a subclass of) the desired type?
+    if (TI->getType()->typeIsConvertibleTo(CheckType))
+      return IntInit::get(1);
+
+    if (isa<RecordRecTy>(CheckType)) {
+      // If the target type is not a subclass of the expression type, or if
+      // the expression has fully resolved to a record, we know that it can't
+      // be of the required type.
+      if (!CheckType->typeIsConvertibleTo(TI->getType()) || isa<DefInit>(Expr))
+        return IntInit::get(0);
+    } else {
+      // We treat non-record types as not castable.
+      return IntInit::get(0);
+    }
+  }
+  return const_cast<IsAOpInit *>(this);
+}
+
+Init *IsAOpInit::resolveReferences(Resolver &R) const {
+  Init *NewExpr = Expr->resolveReferences(R);
+  if (Expr != NewExpr)
+    return get(CheckType, NewExpr)->Fold();
+  return const_cast<IsAOpInit *>(this);
+}
+
+Init *IsAOpInit::getBit(unsigned Bit) const {
+  return VarBitInit::get(const_cast<IsAOpInit *>(this), Bit);
+}
+
+std::string IsAOpInit::getAsString() const {
+  return (Twine("!isa<") + CheckType->getAsString() + ">(" +
+          Expr->getAsString() + ")")
+      .str();
+}
+
 RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
   if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
     for (Record *Rec : RecordType->getClasses()) {
       if (RecordVal *Field = Rec->getValue(FieldName))
         return Field->getType();
     }
   }
   return nullptr;

llvm/trunk/lib/TableGen/TGLexer.h

enum TokKind {
     paste,              // #
 
     // Keywords.
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
     MultiClass, String,
 
     // !keywords.
     XConcat, XADD, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast,
-    XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XEq,
+    XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XEq, XIsA,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
     

llvm/trunk/lib/TableGen/TGLexer.cpp

tgtok::TokKind TGLexer::LexExclaim() {
   while (isalpha(*CurPtr))
     ++CurPtr;
   
   // Check to see which operator this is.
   tgtok::TokKind Kind =
     StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
     .Case("eq", tgtok::XEq)
     .Case("if", tgtok::XIf)
+    .Case("isa", tgtok::XIsA)
     .Case("head", tgtok::XHead)
     .Case("tail", tgtok::XTail)
     .Case("size", tgtok::XSize)
     .Case("con", tgtok::XConcat)
     .Case("add", tgtok::XADD)
     .Case("and", tgtok::XAND)
     .Case("or", tgtok::XOR)
     .Case("shl", tgtok::XSHL)

llvm/trunk/lib/TableGen/TGParser.cpp

case tgtok::XCast: {  // Value ::= !unop '(' Value ')'
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in unary operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
     return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
   }
 
+  case tgtok::XIsA: {
+    // Value ::= !isa '<' Type '>' '(' Value ')'
+    Lex.Lex(); // eat the operation
+
+    RecTy *Type = ParseOperatorType();
+    if (!Type)
+      return nullptr;
+
+    if (Lex.getCode() != tgtok::l_paren) {
+      TokError("expected '(' after type of !isa");
+      return nullptr;
+    }
+    Lex.Lex(); // eat the '('
+
+    Init *LHS = ParseValue(CurRec);
+    if (!LHS)
+      return nullptr;
+
+    if (Lex.getCode() != tgtok::r_paren) {
+      TokError("expected ')' in !isa");
+      return nullptr;
+    }
+    Lex.Lex(); // eat the ')'
+
+    return (IsAOpInit::get(Type, LHS))->Fold();
+  }
+
   case tgtok::XConcat:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:  // Value ::= !unop '(' Value ')'
+  case tgtok::XIsA:
   case tgtok::XConcat:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:

llvm/trunk/test/TableGen/isa.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// CHECK: def X0 {
+// CHECK:   int ret = 0;
+// CHECK: }
+
+// CHECK: def X1 {
+// CHECK:   int ret = 1;
+// CHECK: }
+
+// CHECK: def Y0 {
+// CHECK:   int ret = 0;
+// CHECK: }
+
+// CHECK: def Y1 {
+// CHECK:   int ret = 11;
+// CHECK: }
+
+class A<int dummy>;
+class B<int num> : A<num> {
+  int Num = num;
+}
+
+class X<A a> {
+  int ret = !isa<B>(a);
+}
+
+class Y<A a> {
+  int ret = !if(!isa<B>(a), !cast<B>(a).Num, 0);
+}
+
+def X0 : X<A<0>>;
+def X1 : X<B<0>>;
+
+def Y0 : Y<A<10>>;
+def Y1 : Y<B<11>>;