TableGen: Allow !cast of records, cleanup conversion machinery

[nhaehnle]

Summary

Distinguish two relationships between types: is-a and convertible-to.
For example, a bit is not an int or vice versa, but they can be
converted into each other (with range checks that you can think of
as "dynamic": unlike other type checks, those range checks do not
happen during parsing, but only once the final values have been
established).

Actually converting initializers between types is subtle: even
when values of type A can be converted to type B (e.g. int into
string), it may not be possible to do so with a concrete initializer
(e.g., a VarInit that refers to a variable of type int cannot
be immediately converted to a string).

For this reason, distinguish between getCastTo and convertInitializerTo:
the latter implements the actual conversion when appropriate, while
the former will first try to do the actual conversion and fall back
to introducing a !cast operation so that the conversion will be
delayed until variable references have been resolved.

To make the approach of adding !cast operations to work, !cast needs
to fallback to convertInitializerTo when the special string <-> record
logic does not apply.

This enables casting records to a subclass, although that new
functionality is only truly useful together with !isa, which will be
added in a later change.

The test is removed because it uses !srl on a bit sequence,
which cannot really be supported consistently, but luckily
isn't used anywhere either.

Change-Id: I98168bf52649176654ed2ec61a29bdb29970cfe7

[tra]

docs/TableGen/LangIntro.rst

186 ↗

(On Diff #135858)

symbol table may need some disambiguation. I.e. we have more than one kind of symbols (template parameters, class/multiclass names, field names, defined records, temporary variables in !foreach) and not all of them are applicable here.

Does it mean list of all records defined by the time tablegen reaches the end of its input?

190–191 ↗

(On Diff #135858)

Is it going to be limited to records only? We currently allow !cast<string> for other types, though not all of them work. E.g. currently int works, bits and lists do not. It may be worth documenting this in more details.

lib/TableGen/Record.cpp

790–795 ↗

(On Diff #135858)

What makes getBit(0) special for !cast ops?

[nhaehnle]

More documentation in LangIntro.rst, handle the bit --> bits<1> conversion
properly in cases where the bit has not been resolved.

docs/TableGen/LangIntro.rst

186 ↗

(On Diff #135858)

I've tried to make the rules more explicit.

lib/TableGen/Record.cpp

790–795 ↗

(On Diff #135858)

Good point, it shouldn't be special. This was fixing some cases of !cast<bits<1>>(P){0} --> { P }{0} --> P in initializers where P itself was unset.

However, the real fix for this is to handle the case convertInitializerTo(bits<1>) for all inits of type bit. I've added that to TypedInit::convertInitializerTo.

[tra]

docs/TableGen/LangIntro.rst

186 ↗

(On Diff #135858)

Nice. That's a huge improvement over the old description.

[kosarev]

llvm/trunk/test/TableGen/BitsInitOverflow.td

5

How is not folding such explicit casts useful?

llvm/trunk/docs/TableGen/LangIntro.rst

``!strconcat(a, b, ...)``
     of all the strings given.
 
 ``str1#str2``
     "#" (paste) is a shorthand for !strconcat.  It may concatenate things that
     are not quoted strings, in which case an implicit !cast<string> is done on
     the operand of the paste.
 
 ``!cast<type>(a)``
-    A symbol of type *type* obtained by looking up the string 'a' in the symbol
-    table.  If the type of 'a' does not match *type*, TableGen aborts with an
-    error. !cast<string> is a special case in that the argument must be an
-    object defined by a 'def' construct.
+    If 'a' is a string, a record of type *type* obtained by looking up the
+    string 'a' in the list of all records defined by the time that all template
+    arguments in 'a' are fully resolved.
+
+    For example, if !cast<type>(a) appears in a multiclass definition, or in a
+    class instantiated inside of a multiclass definition, and 'a' does not
+    reference any template arguments of the multiclass, then a record of name
+    'a' must be instantiated earlier in the source file. If 'a' does reference
+    a template argument, then the lookup is delayed until defm statements
+    instantiating the multiclass (or later, if the defm occurs in another
+    multiclass and template arguments of the inner multiclass that are
+    referenced by 'a' are substituted by values that themselves contain
+    references to template arguments of the outer multiclass).
+
+    If the type of 'a' does not match *type*, TableGen aborts with an error.
+
+    For historical reasons, 'a' can also be the name of a variable or a
+    template argument in some cases, but this use is unreliable and is
+    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.
 
 ``!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'.

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

 
 class ListRecTy;
 struct MultiClass;
 class Record;
 class RecordKeeper;
 class RecordVal;
 class Resolver;
 class StringInit;
+class TypedInit;
 
 //===----------------------------------------------------------------------===//
 //  Type Classes
 //===----------------------------------------------------------------------===//
 
 class RecTy {
 public:
   /// \brief Subclass discriminator (for dyn_cast<> et al.)
public:
   virtual std::string getAsString() const = 0;
   void print(raw_ostream &OS) const { OS << getAsString(); }
   void dump() const;
 
   /// Return true if all values of 'this' type can be converted to the specified
   /// type.
   virtual bool typeIsConvertibleTo(const RecTy *RHS) const;
 
+  /// Return true if 'this' type is equal to or a subtype of RHS. For example,
+  /// a bit set is not an int, but they are convertible.
+  virtual bool typeIsA(const RecTy *RHS) const;
+
   /// Returns the type representing list<this>.
   ListRecTy *getListTy();
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
   Ty.print(OS);
   return OS;
 }
public:
 
   static BitsRecTy *get(unsigned Sz);
 
   unsigned getNumBits() const { return Size; }
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
+
+  bool typeIsA(const RecTy *RHS) const override;
 };
 
 /// 'code' - Represent a code fragment
 class CodeRecTy : public RecTy {
   static CodeRecTy Shared;
 
   CodeRecTy() : RecTy(CodeRecTyKind) {}
 

 /// 'string' - Represent an string value
 class StringRecTy : public RecTy {
   static StringRecTy Shared;
 
   StringRecTy() : RecTy(StringRecTyKind) {}
 
 public:
   static bool classof(const RecTy *RT) {
-    return RT->getRecTyKind() == StringRecTyKind ||
-           RT->getRecTyKind() == CodeRecTyKind;
+    return RT->getRecTyKind() == StringRecTyKind;
   }
 
   static StringRecTy *get() { return &Shared; }
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
public:
   }
 
   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
   RecTy *getElementType() const { return Ty; }
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
+
+  bool typeIsA(const RecTy *RHS) const override;
 };
 
 /// 'dag' - Represent a dag fragment
 class DagRecTy : public RecTy {
   static DagRecTy Shared;
 
   DagRecTy() : RecTy(DagRecTyKind) {}
 
public:
 
   const_record_iterator classes_begin() const { return getClasses().begin(); }
   const_record_iterator classes_end() const { return getClasses().end(); }
 
   std::string getAsString() const override;
 
   bool isSubClassOf(Record *Class) const;
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
+
+  bool typeIsA(const RecTy *RHS) const override;
 };
 
 /// Find a common type that T1 and T2 convert to.
 /// Return 0 if no such type exists.
 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
 
 //===----------------------------------------------------------------------===//
 //  Initializer Classes
public:
   /// StringInits where we will not surround the string value with
   /// quotes.
   virtual std::string getAsUnquotedString() const { return getAsString(); }
 
   /// Debugging method that may be called through a debugger, just
   /// invokes print on stderr.
   void dump() const;
 
-  /// This virtual function converts to the appropriate
-  /// Init based on the passed in type.
+  /// If this initializer is convertible to Ty, return an initializer whose
+  /// type is-a Ty, generating a !cast operation if required. Otherwise, return
+  /// nullptr.
+  virtual Init *getCastTo(RecTy *Ty) const = 0;
+
+  /// Convert to an initializer whose type is-a Ty, or return nullptr if this
+  /// is not possible (this can happen if the initializer's type is convertible
+  /// to Ty, but there are unresolved references).
   virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
 
   /// This method is used to implement the bitrange
   /// selection operator.  Given an initializer, it selects the specified bits
   /// out, returning them as a new init of bits type.  If it is not legal to use
   /// the bit subscript operator on this initializer, return null.
   virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
     return nullptr;
public:
 
   static bool classof(const Init *I) {
     return I->getKind() >= IK_FirstTypedInit &&
            I->getKind() <= IK_LastTypedInit;
   }
 
   RecTy *getType() const { return Ty; }
 
+  Init *getCastTo(RecTy *Ty) const override;
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
   Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
 
   /// This method is used to implement the FieldInit class.
   /// Implementors of this method should return the type of the named field if
   /// they are of record type.
public:
   UnsetInit &operator=(const UnsetInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_UnsetInit;
   }
 
   static UnsetInit *get();
 
+  Init *getCastTo(RecTy *Ty) const override;
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *getBit(unsigned Bit) const override {
     return const_cast<UnsetInit*>(this);
   }
 
   bool isComplete() const override { return false; }
   std::string getAsString() const override { return "?"; }
public:
   VarBitInit &operator=(const VarBitInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_VarBitInit;
   }
 
   static VarBitInit *get(TypedInit *T, unsigned B);
 
-  Init *convertInitializerTo(RecTy *Ty) const override;
-
   Init *getBitVar() const { return TI; }
   unsigned getBitNum() const { return Bit; }
 
   std::string getAsString() const override;
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned B) const override {
     assert(B < 1 && "Bit index out of range!");
public:
 
   static DagInit *get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
                       ArrayRef<StringInit*> NameRange);
   static DagInit *get(Init *V, StringInit *VN,
                       ArrayRef<std::pair<Init*, StringInit*>> Args);
 
   void Profile(FoldingSetNodeID &ID) const;
 
-  Init *convertInitializerTo(RecTy *Ty) const override;
-
   Init *getOperator() const { return Val; }
 
   StringInit *getName() const { return ValName; }
 
   StringRef getNameStr() const {
     return ValName ? ValName->getValue() : StringRef();
   }
 
public:
   std::string getNameInitAsString() const {
     return getNameInit()->getAsUnquotedString();
   }
 
   bool getPrefix() const { return TyAndPrefix.getInt(); }
   RecTy *getType() const { return TyAndPrefix.getPointer(); }
   Init *getValue() const { return Value; }
 
-  bool setValue(Init *V) {
-    if (V) {
-      Value = V->convertInitializerTo(getType());
-      assert(!Value || !isa<TypedInit>(Value) ||
-             cast<TypedInit>(Value)->getType()->typeIsConvertibleTo(getType()));
-      return Value == nullptr;
-    }
-    Value = nullptr;
-    return false;
-  }
+  bool setValue(Init *V);
 
   void dump() const;
   void print(raw_ostream &OS, bool PrintSem = true) const;
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
   RV.print(OS << "  ");
   return OS;

llvm/trunk/lib/TableGen/Record.cpp

ListRecTy *RecTy::getListTy() {
   return ListTy;
 }
 
 bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   assert(RHS && "NULL pointer");
   return Kind == RHS->getRecTyKind();
 }
 
+bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
+
 bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
   if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
     return true;
   if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
     return BitsTy->getNumBits() == 1;
   return false;
 }
 

 
 bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
     return cast<BitsRecTy>(RHS)->Size == Size;
   RecTyKind kind = RHS->getRecTyKind();
   return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
 }
 
+bool BitsRecTy::typeIsA(const RecTy *RHS) const {
+  if (const BitsRecTy *RHSb = dyn_cast<BitsRecTy>(RHS))
+    return RHSb->Size == Size;
+  return false;
+}
+
 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   RecTyKind kind = RHS->getRecTyKind();
   return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
 }
 
 bool CodeRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   RecTyKind Kind = RHS->getRecTyKind();
   return Kind == CodeRecTyKind || Kind == StringRecTyKind;

 }
 
 bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
     return Ty->typeIsConvertibleTo(ListTy->getElementType());
   return false;
 }
 
+bool ListRecTy::typeIsA(const RecTy *RHS) const {
+  if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
+    return getElementType()->typeIsA(RHSl->getElementType());
+  return false;
+}
+
 std::string DagRecTy::getAsString() const {
   return "dag";
 }
 
 static void ProfileRecordRecTy(FoldingSetNodeID &ID,
                                ArrayRef<Record *> Classes) {
   ID.AddInteger(Classes.size());
   for (Record *R : Classes)
bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   if (!RTy)
     return false;
 
   return llvm::all_of(RTy->getClasses(), [this](Record *TargetClass) {
                                            return isSubClassOf(TargetClass);
                                          });
 }
 
+bool RecordRecTy::typeIsA(const RecTy *RHS) const {
+  return typeIsConvertibleTo(RHS);
+}
+
 static RecordRecTy *resolveRecordTypes(RecordRecTy *T1, RecordRecTy *T2) {
   SmallVector<Record *, 4> CommonSuperClasses;
   SmallVector<Record *, 4> Stack;
 
   Stack.insert(Stack.end(), T1->classes_begin(), T1->classes_end());
 
   while (!Stack.empty()) {
     Record *R = Stack.back();

 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
 #endif
 
 UnsetInit *UnsetInit::get() {
   static UnsetInit TheInit;
   return &TheInit;
 }
 
-Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
-  if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
-    SmallVector<Init *, 16> NewBits(BRT->getNumBits());
-
-    for (unsigned i = 0; i != BRT->getNumBits(); ++i)
-      NewBits[i] = UnsetInit::get();
-
-    return BitsInit::get(NewBits);
-  }
+Init *UnsetInit::getCastTo(RecTy *Ty) const {
+  return const_cast<UnsetInit *>(this);
 
-  // All other types can just be returned.
+Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
   return const_cast<UnsetInit *>(this);
 }
 
 BitInit *BitInit::get(bool V) {
   static BitInit True(true);
   static BitInit False(false);
 
   return V ? &True : &False;
if (isa<StringRecTy>(getType())) {
       if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
         return LHSs;
 
       if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
         return StringInit::get(LHSd->getAsString());
 
       if (IntInit *LHSi = dyn_cast<IntInit>(LHS))
         return StringInit::get(LHSi->getAsString());
-    } else {
+    } else if (isa<RecordRecTy>(getType())) {
       if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
         // From TGParser::ParseIDValue
         if (CurRec) {
           if (const RecordVal *RV = CurRec->getValue(Name)) {
             if (RV->getType() != getType())
               PrintFatalError("type mismatch in cast");
             return VarInit::get(Name, RV->getType());
           }
if (isa<StringRecTy>(getType())) {
         }
         assert(CurRec && "NULL pointer");
         if (Record *D = (CurRec->getRecords()).getDef(Name->getValue()))
           return DefInit::get(D);
 
         PrintFatalError(CurRec->getLoc(),
                         "Undefined reference:'" + Name->getValue() + "'\n");
       }
+    }
 
-      if (isa<IntRecTy>(getType())) {
-        if (BitsInit *BI = dyn_cast<BitsInit>(LHS)) {
-          if (Init *NewInit = BI->convertInitializerTo(IntRecTy::get()))
-            return NewInit;
-          break;
-        }
-      }
-    }
-    break;
+    if (Init *NewInit = LHS->convertInitializerTo(getType()))
 
   case HEAD:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in head");
       return LHSl->getElement(0);
     }
     break;
 
Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
 
   case FOREACH: {
     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
       return Result;
     break;
   }
 
   case IF: {
-    IntInit *LHSi = dyn_cast<IntInit>(LHS);
-    if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
-      LHSi = dyn_cast<IntInit>(I);
-    if (LHSi) {
+    if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
+                            LHS->convertInitializerTo(IntRecTy::get()))) {
       if (LHSi->getValue())
         return MHS;
       return RHS;
     }
     break;
   }
   }
 
   return const_cast<TernOpInit *>(this);
 }
 
 Init *TernOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
 
   if (getOpcode() == IF && lhs != LHS) {
-    IntInit *Value = dyn_cast<IntInit>(lhs);
-    if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
-      Value = dyn_cast<IntInit>(I);
-    if (Value) {
+    if (IntInit *Value = dyn_cast_or_null<IntInit>(
+                             lhs->convertInitializerTo(IntRecTy::get()))) {
       // Short-circuit
-      if (Value->getValue()) {
-        Init *mhs = MHS->resolveReferences(R);
-        return (TernOpInit::get(getOpcode(), lhs, mhs, RHS, getType()))
-            ->Fold(R.getCurrentRecord(), nullptr);
-      }
-      Init *rhs = RHS->resolveReferences(R);
-      return (TernOpInit::get(getOpcode(), lhs, MHS, rhs, getType()))
-          ->Fold(R.getCurrentRecord(), nullptr);
+      if (Value->getValue())
+        return MHS->resolveReferences(R);
+      return RHS->resolveReferences(R);
     }
   }
 
   Init *mhs = MHS->resolveReferences(R);
   Init *rhs;
 
   if (getOpcode() == FOREACH) {
     ShadowResolver SR(R);
for (Record *Rec : RecordType->getClasses()) {
         return Field->getType();
     }
   }
   return nullptr;
 }
 
 Init *
 TypedInit::convertInitializerTo(RecTy *Ty) const {
-  if (isa<IntRecTy>(Ty)) {
-    if (getType()->typeIsConvertibleTo(Ty))
-      return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
-
-  if (isa<StringRecTy>(Ty)) {
-    if (isa<StringRecTy>(getType()))
-      return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
-
-  if (isa<CodeRecTy>(Ty)) {
-    if (isa<CodeRecTy>(getType()))
-      return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
-
-  if (isa<BitRecTy>(Ty)) {
-    // Accept variable if it is already of bit type!
-    if (isa<BitRecTy>(getType()))
-      return const_cast<TypedInit *>(this);
-    if (auto *BitsTy = dyn_cast<BitsRecTy>(getType())) {
-      // Accept only bits<1> expression.
-      if (BitsTy->getNumBits() == 1)
-        return const_cast<TypedInit *>(this);
-      return nullptr;
-    }
-    // Ternary !if can be converted to bit, but only if both sides are
-    // convertible to a bit.
-    if (const auto *TOI = dyn_cast<TernOpInit>(this)) {
-      if (TOI->getOpcode() == TernOpInit::TernaryOp::IF &&
-          TOI->getMHS()->convertInitializerTo(BitRecTy::get()) &&
-          TOI->getRHS()->convertInitializerTo(BitRecTy::get()))
-        return const_cast<TypedInit *>(this);
-      return nullptr;
-    }
-    return nullptr;
-  }
-
-  if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
-    if (BRT->getNumBits() == 1 && isa<BitRecTy>(getType()))
-      return BitsInit::get(const_cast<TypedInit *>(this));
-
-    if (getType()->typeIsConvertibleTo(BRT)) {
-      SmallVector<Init *, 16> NewBits(BRT->getNumBits());
-
-      for (unsigned i = 0; i != BRT->getNumBits(); ++i)
-        NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), i);
-      return BitsInit::get(NewBits);
-    }
-
-    return nullptr;
-  }
-
-  if (auto *DLRT = dyn_cast<ListRecTy>(Ty)) {
-    if (auto *SLRT = dyn_cast<ListRecTy>(getType()))
-      if (SLRT->getElementType()->typeIsConvertibleTo(DLRT->getElementType()))
-        return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
+  if (getType() == Ty || getType()->typeIsA(Ty))
 
-  if (auto *DRT = dyn_cast<DagRecTy>(Ty)) {
-    if (getType()->typeIsConvertibleTo(DRT))
-      return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
-
-  if (auto *SRRT = dyn_cast<RecordRecTy>(Ty)) {
-    if (getType()->typeIsConvertibleTo(SRRT))
-      return const_cast<TypedInit *>(this);
-    return nullptr;
-  }
+  if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
+      cast<BitsRecTy>(Ty)->getNumBits() == 1)
+    return BitsInit::get({const_cast<TypedInit *>(this)});
 
   return nullptr;
 }
 
 Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
   BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
   if (!T) return nullptr;  // Cannot subscript a non-bits variable.
   unsigned NumBits = T->getNumBits();
 
   SmallVector<Init *, 16> NewBits;
   NewBits.reserve(Bits.size());
   for (unsigned Bit : Bits) {
     if (Bit >= NumBits)
       return nullptr;
 
     NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
   }
   return BitsInit::get(NewBits);
 }
 
+Init *TypedInit::getCastTo(RecTy *Ty) const {
+  // Handle the common case quickly
+  if (getType() == Ty || getType()->typeIsA(Ty))
+    return const_cast<TypedInit *>(this);
+
+  if (Init *Converted = convertInitializerTo(Ty)) {
+    assert(!isa<TypedInit>(Converted) ||
+           cast<TypedInit>(Converted)->getType()->typeIsA(Ty));
+    return Converted;
+  }
+
+  if (!getType()->typeIsConvertibleTo(Ty))
+    return nullptr;
+
+  return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
+             ->Fold(nullptr, nullptr);
+}
+
 Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   ListRecTy *T = dyn_cast<ListRecTy>(getType());
   if (!T) return nullptr;  // Cannot subscript a non-list variable.
 
   if (Elements.size() == 1)
     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
 
   SmallVector<Init*, 8> ListInits;
VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
   Key TheKey(std::make_pair(T, B));
 
   VarBitInit *&I = ThePool[TheKey];
   if (!I)
     I = new(Allocator) VarBitInit(T, B);
   return I;
 }
 
-Init *VarBitInit::convertInitializerTo(RecTy *Ty) const {
-  if (isa<BitRecTy>(Ty))
-    return const_cast<VarBitInit *>(this);
-
-  return nullptr;
-}
-
 std::string VarBitInit::getAsString() const {
   return TI->getAsString() + "{" + utostr(Bit) + "}";
 }
 
 Init *VarBitInit::resolveReferences(Resolver &R) const {
   Init *I = TI->resolveReferences(R);
   if (TI != I)
     return I->getBit(getBitNum());
DagInit::get(Init *V, StringInit *VN,
 
   return DagInit::get(V, VN, Args, Names);
 }
 
 void DagInit::Profile(FoldingSetNodeID &ID) const {
   ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init *>(), NumArgs), makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
 }
 
-Init *DagInit::convertInitializerTo(RecTy *Ty) const {
-  if (isa<DagRecTy>(Ty))
-    return const_cast<DagInit *>(this);
-
-  return nullptr;
-}
-
 Init *DagInit::resolveReferences(Resolver &R) const {
   SmallVector<Init*, 8> NewArgs;
   NewArgs.reserve(arg_size());
   bool ArgsChanged = false;
   for (const Init *Arg : getArgs()) {
     Init *NewArg = Arg->resolveReferences(R);
     NewArgs.push_back(NewArg);
     ArgsChanged |= NewArg != Arg;

 }
 
 //===----------------------------------------------------------------------===//
 //    Other implementations
 //===----------------------------------------------------------------------===//
 
 RecordVal::RecordVal(Init *N, RecTy *T, bool P)
   : Name(N), TyAndPrefix(T, P) {
-  Value = UnsetInit::get()->convertInitializerTo(T);
+  setValue(UnsetInit::get());
   assert(Value && "Cannot create unset value for current type!");
 }
 
 StringRef RecordVal::getName() const {
   return cast<StringInit>(getNameInit())->getValue();
 }
 
+bool RecordVal::setValue(Init *V) {
+  if (V) {
+    Value = V->getCastTo(getType());
+    if (Value) {
+      assert(!isa<TypedInit>(Value) ||
+             cast<TypedInit>(Value)->getType()->typeIsA(getType()));
+      if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
+        if (!isa<BitsInit>(Value)) {
+          SmallVector<Init *, 64> Bits;
+          Bits.reserve(BTy->getNumBits());
+          for (unsigned i = 0, e = BTy->getNumBits(); i < e; ++i)
+            Bits.push_back(Value->getBit(i));
+          Value = BitsInit::get(Bits);
+        }
+      }
+    }
+    return Value == nullptr;
+  }
+  Value = nullptr;
+  return false;
+}
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
 #endif
 
 void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
   if (getPrefix()) OS << "field ";
   OS << *getType() << " " << getNameInitAsString();
 

llvm/trunk/lib/TableGen/TGParser.cpp

bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
   //
   if (!BitList.empty()) {
     BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
     if (!CurVal)
       return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
                    "' is not a bits type");
 
     // Convert the incoming value to a bits type of the appropriate size...
-    Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
+    Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
     if (!BI)
       return Error(Loc, "Initializer is not compatible with bit range");
 
-    // We should have a BitsInit type now.
-    BitsInit *BInit = cast<BitsInit>(BI);
-
     SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
 
     // Loop over bits, assigning values as appropriate.
     for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
       unsigned Bit = BitList[i];
       if (NewBits[Bit])
         return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
                      ValName->getAsUnquotedString() + "' more than once");
-      NewBits[Bit] = BInit->getBit(i);
+      NewBits[Bit] = BI->getBit(i);
     }
 
     for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
       if (!NewBits[i])
         NewBits[i] = CurVal->getBit(i);
 
     V = BitsInit::get(NewBits);
   }
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
         if (BitsRecTy *BitsRec = dyn_cast<BitsRecTy>(VI->getType())) {
           for (unsigned i = 0, e = BitsRec->getNumBits(); i != e; ++i)
             NewBits.push_back(VI->getBit((e - i) - 1));
           continue;
         }
         // Fallthrough to try convert this to a bit.
       }
       // All other values must be convertible to just a single bit.
-      Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
+      Init *Bit = Vals[i]->getCastTo(BitRecTy::get());
       if (!Bit) {
         Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
               ") is not convertable to a bit");
         return nullptr;
       }
       NewBits.push_back(Bit);
     }
     std::reverse(NewBits.begin(), NewBits.end());
if (!CurMultiClass) {
     // Let's use the heavy weaponery.
     if (!DefNameString) {
       ResolveMulticlassDefArgs(MC, CurRec.get(), DefmPrefixRange.Start,
                                Lex.getLoc(), TArgs, TemplateVals,
                                false/*Delete args*/);
       DefName = CurRec->getNameInit();
       DefNameString = dyn_cast<StringInit>(DefName);
 
-      if (!DefNameString)
+      if (!DefNameString) {
         DefName = DefName->convertInitializerTo(StringRecTy::get());
-
-      // We ran out of options here...
         DefNameString = dyn_cast<StringInit>(DefName);
+      }
+
       if (!DefNameString) {
         PrintFatalError(CurRec->getLoc()[CurRec->getLoc().size() - 1],
                         DefName->getAsUnquotedString() + " is not a string.");
         return nullptr;
       }
 
       CurRec->setName(DefName);
     }

llvm/trunk/test/TableGen/BitsInit.td

 // CHECK: bits<2> C1;
 // CHECK: bits<3> C2 = { 1, 1, 1 };
 // CHECK: bits<2> D1 = { 0, 0 };
 // CHECK: bits<2> D2 = { 0, 0 };
 // CHECK: bits<3> D3;
 // CHECK: bits<3> D4;
 // CHECK: bits<1> D5 = { 0 };
 // CHECK: bits<1> D6 = { 1 };
-// CHECK: bits<1> D7 = { ? };
+// CHECK: bits<1> D7 = { !cast<bit>(3) };
 // CHECK: bits<2> D8;
 // CHECK: bits<8> E = { 0, 0, 1, ?, 0, 0, 1, 0 };
 // CHECK: bits<8> F1 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<7> F2;
 // CHECK: bits<9> F3;
 // CHECK: bits<8> G1 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<8> G2 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<8> G3 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<16> H = { 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 };
 // CHECK: bits<16> I = { 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: int J = 52275;
 // CHECK: int K = 1;
 // CHECK: }

llvm/trunk/test/TableGen/BitsInitOverflow.td

-// RUN: not llvm-tblgen %s 2> /dev/null
+// RUN: llvm-tblgen %s | FileCheck %s
+
+// Check that a large integer is not truncated to a small bit sequence.
+//
+// CHECK: bits<2> X = { !cast<bits<2>>(5){1}, !cast<bits<2>>(5){0} };
 
 def {
   bits<2> X = 5;  // bitfield is too small, reject
 }

llvm/trunk/test/TableGen/FieldAccess.td

-// RUN: llvm-tblgen %s
+// RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
+// CHECK: --- Defs ---
+
+// CHECK: def a {
+// CHECK:   string blu = "";
+// CHECK: }
+
+// CHECK: def b {
+// CHECK:   string blu = "";
+// CHECK: }
+
+// CHECK: def c {
+// CHECK:   string blu = "";
+// CHECK: }
+
 class Bla<string t>
 {
   string blu = t;
 }
 
 class Bli<Bla t>
 {
   Bla bla = t;
 }
 
 def a : Bli<Bla<"">>;
-def b : Bla<!cast<Bla>(a.bla).blu>; // works
-def c : Bla<a.bla.blu>; // doesn't work: Cannot access field 'blu' of value 'a.bla'
+def b : Bla<!cast<Bla>(a.bla).blu>;
+def c : Bla<a.bla.blu>;

llvm/trunk/test/TableGen/code.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 // CHECK: --- Defs ---
 
-// TODO: Both of these should result in CodeInits, i.e. print [{...}].
 // CHECK: def A0 {
-// CHECK:   code Code = "Simple";
+// CHECK:   code Code = [{Simple}];
 // CHECK: }
 
 // CHECK: def B0 {
-// CHECK:   code Code = "With paste 7";
+// CHECK:   code Code = [{With paste 7}];
 // CHECK: }
 
 class A<code c> {
   code Code = c;
 }
 
 def A0 : A<"Simple">;
 
 class B<int i> : A<"With paste " # i>;
 
 def B0 : B<7>;