TableGen: BitInit and VarBitInit are typed

[nhaehnle]

Summary

Change-Id: I54e337a0b525e9649534bc5f90e5e07c0772e334

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

protected:
   /// We also explicitly include "first" and "last" values for each
   /// interior node of the inheritance tree, to make it easier to read the
   /// corresponding classof().
   ///
   /// We could pack these a bit tighter by not having the IK_FirstXXXInit
   /// and IK_LastXXXInit be their own values, but that would degrade
   /// readability for really no benefit.
   enum InitKind : uint8_t {
-    IK_BitInit,
+    IK_First, // unused; silence a spurious warning
     IK_FirstTypedInit,
+    IK_BitInit,
     IK_BitsInit,
     IK_CodeInit,
     IK_DagInit,
     IK_DefInit,
     IK_FieldInit,
     IK_IntInit,
     IK_ListInit,
     IK_FirstOpInit,
     IK_BinOpInit,
     IK_TernOpInit,
     IK_UnOpInit,
     IK_LastOpInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarListElementInit,
+    IK_VarBitInit,
     IK_LastTypedInit,
-    IK_UnsetInit,
-    IK_VarBitInit
+    IK_UnsetInit
   };
 
 private:
   const InitKind Kind;
 
 protected:
   uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit
 
Init *getBit(unsigned Bit) const override {
     return const_cast<UnsetInit*>(this);
   }
 
   bool isComplete() const override { return false; }
   std::string getAsString() const override { return "?"; }
 };
 
 /// 'true'/'false' - Represent a concrete initializer for a bit.
-class BitInit : public Init {
+class BitInit final : public TypedInit {
   bool Value;
 
-  explicit BitInit(bool V) : Init(IK_BitInit), Value(V) {}
+  explicit BitInit(bool V) : TypedInit(IK_BitInit, BitRecTy::get()), Value(V) {}
 
 public:
   BitInit(const BitInit &) = delete;
   BitInit &operator=(BitInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_BitInit;
   }
 
   static BitInit *get(bool V);
 
   bool getValue() const { return Value; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
+  Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                    unsigned Elt) const override {
+    llvm_unreachable("Illegal element reference off bit");
+  }
+
   Init *getBit(unsigned Bit) const override {
     assert(Bit < 1 && "Bit index out of range!");
     return const_cast<BitInit*>(this);
   }
 
   std::string getAsString() const override { return Value ? "1" : "0"; }
 };
 
public:
   Init *resolveReferences(Record &R, const RecordVal *RV) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override { return getName(); }
 };
 
 /// Opcode{0} - Represent access to one bit of a variable or field.
-class VarBitInit : public Init {
+class VarBitInit final : public TypedInit {
   TypedInit *TI;
   unsigned Bit;
 
-  VarBitInit(TypedInit *T, unsigned B) : Init(IK_VarBitInit), TI(T), Bit(B) {
+  VarBitInit(TypedInit *T, unsigned B)
+      : TypedInit(IK_VarBitInit, BitRecTy::get()), TI(T), Bit(B) {
     assert(T->getType() &&
            (isa<IntRecTy>(T->getType()) ||
             (isa<BitsRecTy>(T->getType()) &&
              cast<BitsRecTy>(T->getType())->getNumBits() > B)) &&
            "Illegal VarBitInit expression!");
   }
 
 public:
public:
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *getBitVar() const override { return TI; }
   unsigned getBitNum() const override { return Bit; }
 
   std::string getAsString() const override;
   Init *resolveReferences(Record &R, const RecordVal *RV) const override;
 
+  Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                    unsigned Elt) const override {
+    llvm_unreachable("Illegal element reference off bit");
+  }
+
   Init *getBit(unsigned B) const override {
     assert(B < 1 && "Bit index out of range!");
     return const_cast<VarBitInit*>(this);
   }
 };
 
 /// List[4] - Represent access to one element of a var or
 /// field.