Unconstify Inits

[oota-llvm.git] / utils / TableGen / Record.h

diff --git a/utils/TableGen/Record.h b/utils/TableGen/Record.h
index 351625ac4e0b936285909dff6bd16beef6eac664..a8ab8001c98a1c138878805d479e576ef32ce86b 100644 (file)
--- a/utils/TableGen/Record.h
+++ b/utils/TableGen/Record.h
@@ -85,31 +85,31 @@ public:
   ListRecTy *getListTy();
 
 public:   // These methods should only be called from subclasses of Init
-  virtual const Init *convertValue( const UnsetInit *UI) { return 0; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) {
-    return convertValue((const TypedInit*)UI);
+  virtual Init *convertValue( UnsetInit *UI) { return 0; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) {
+    return convertValue((TypedInit*)UI);
   }
-  virtual const Init *convertValue( const BinOpInit *UI) {
-    return convertValue((const TypedInit*)UI);
+  virtual Init *convertValue( BinOpInit *UI) {
+    return convertValue((TypedInit*)UI);
   }
-  virtual const Init *convertValue( const TernOpInit *UI) {
-    return convertValue((const TypedInit*)UI);
+  virtual Init *convertValue( TernOpInit *UI) {
+    return convertValue((TypedInit*)UI);
   }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const TypedInit *TI) { return 0; }
-  virtual const Init *convertValue(   const VarInit *VI) {
-    return convertValue((const TypedInit*)VI);
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( TypedInit *TI) { return 0; }
+  virtual Init *convertValue(   VarInit *VI) {
+    return convertValue((TypedInit*)VI);
   }
-  virtual const Init *convertValue( const FieldInit *FI) {
-    return convertValue((const TypedInit*)FI);
+  virtual Init *convertValue( FieldInit *FI) {
+    return convertValue((TypedInit*)FI);
   }
 
 public:   // These methods should only be called by subclasses of RecTy.
@@ -139,22 +139,22 @@ class BitRecTy : public RecTy {
 public:
   static BitRecTy *get() { return &Shared; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return (const Init*)BI; }
-  virtual const Init *convertValue(  const BitsInit *BI);
-  virtual const Init *convertValue(   const IntInit *II);
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return (const Init*)VB; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return (Init*)BI; }
+  virtual Init *convertValue(  BitsInit *BI);
+  virtual Init *convertValue(   IntInit *II);
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const { return "bit"; }
 
@@ -184,22 +184,22 @@ public:
 
   unsigned getNumBits() const { return Size; }
 
-  virtual const Init *convertValue( const UnsetInit *UI);
-  virtual const Init *convertValue(   const BitInit *UI);
-  virtual const Init *convertValue(  const BitsInit *BI);
-  virtual const Init *convertValue(   const IntInit *II);
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI);
+  virtual Init *convertValue(   BitInit *UI);
+  virtual Init *convertValue(  BitsInit *BI);
+  virtual Init *convertValue(   IntInit *II);
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const;
 
@@ -228,22 +228,22 @@ class IntRecTy : public RecTy {
 public:
   static IntRecTy *get() { return &Shared; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI);
-  virtual const Init *convertValue(  const BitsInit *BI);
-  virtual const Init *convertValue(   const IntInit *II) { return (const Init*)II; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI);
+  virtual Init *convertValue(  BitsInit *BI);
+  virtual Init *convertValue(   IntInit *II) { return (Init*)II; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const { return "int"; }
 
@@ -270,23 +270,23 @@ class StringRecTy : public RecTy {
 public:
   static StringRecTy *get() { return &Shared; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return (const Init*)SI; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *BO);
-  virtual const Init *convertValue( const BinOpInit *BO);
-  virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
-
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue( UnOpInit *BO);
+  virtual Init *convertValue( BinOpInit *BO);
+  virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const { return "string"; }
 
@@ -317,22 +317,22 @@ public:
   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
   RecTy *getElementType() const { return Ty; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI);
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI);
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const;
 
@@ -360,22 +360,22 @@ class CodeRecTy : public RecTy {
 public:
   static CodeRecTy *get() { return &Shared; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return (const Init*)CI; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return (Init*)CI; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const { return "code"; }
 
@@ -400,22 +400,22 @@ class DagRecTy : public RecTy {
 public:
   static DagRecTy *get() { return &Shared; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue(   const DefInit *DI) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *BO);
-  virtual const Init *convertValue( const BinOpInit *BO);
-  virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
-  virtual const Init *convertValue(   const DagInit *CI) { return (const Init*)CI; }
-  virtual const Init *convertValue( const TypedInit *TI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue(   DefInit *DI) { return 0; }
+  virtual Init *convertValue( UnOpInit *BO);
+  virtual Init *convertValue( BinOpInit *BO);
+  virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+  virtual Init *convertValue(   DagInit *CI) { return (Init*)CI; }
+  virtual Init *convertValue( TypedInit *TI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const { return "dag"; }
 
@@ -446,22 +446,22 @@ public:
 
   Record *getRecord() const { return Rec; }
 
-  virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
-  virtual const Init *convertValue(   const BitInit *BI) { return 0; }
-  virtual const Init *convertValue(  const BitsInit *BI) { return 0; }
-  virtual const Init *convertValue(   const IntInit *II) { return 0; }
-  virtual const Init *convertValue(const StringInit *SI) { return 0; }
-  virtual const Init *convertValue(  const ListInit *LI) { return 0; }
-  virtual const Init *convertValue(  const CodeInit *CI) { return 0; }
-  virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
-  virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
-  virtual const Init *convertValue(   const DefInit *DI);
-  virtual const Init *convertValue(   const DagInit *DI) { return 0; }
-  virtual const Init *convertValue( const TypedInit *VI);
-  virtual const Init *convertValue(   const VarInit *VI) { return RecTy::convertValue(VI);}
-  virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+  virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+  virtual Init *convertValue(   BitInit *BI) { return 0; }
+  virtual Init *convertValue(  BitsInit *BI) { return 0; }
+  virtual Init *convertValue(   IntInit *II) { return 0; }
+  virtual Init *convertValue(StringInit *SI) { return 0; }
+  virtual Init *convertValue(  ListInit *LI) { return 0; }
+  virtual Init *convertValue(  CodeInit *CI) { return 0; }
+  virtual Init *convertValue(VarBitInit *VB) { return 0; }
+  virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+  virtual Init *convertValue(   DefInit *DI);
+  virtual Init *convertValue(   DagInit *DI) { return 0; }
+  virtual Init *convertValue( TypedInit *VI);
+  virtual Init *convertValue(   VarInit *VI) { return RecTy::convertValue(VI);}
+  virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
 
   std::string getAsString() const;
 
@@ -515,14 +515,14 @@ public:
   /// function that should be overridden to call the appropriate
   /// RecTy::convertValue method.
   ///
-  virtual const Init *convertInitializerTo(RecTy *Ty) const = 0;
+  virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
 
   /// convertInitializerBitRange - 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 const Init *
+  virtual Init *
   convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
     return 0;
   }
@@ -532,7 +532,7 @@ public:
   /// elements, returning them as a new init of list type.  If it is not legal
   /// to take a slice of this, return null.
   ///
-  virtual const Init *
+  virtual Init *
   convertInitListSlice(const std::vector<unsigned> &Elements) const {
     return 0;
   }
@@ -547,8 +547,8 @@ public:
   /// initializer for the specified field.  If getFieldType returns non-null
   /// this method should return non-null, otherwise it returns null.
   ///
-  virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
-                                   const std::string &FieldName) const {
+  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+                             const std::string &FieldName) const {
     return 0;
   }
 
@@ -557,8 +557,8 @@ public:
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
   ///
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const {
-    return this;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
+    return const_cast<Init *>(this);
   }
 };
 
@@ -581,9 +581,9 @@ protected:
 public:
   RecTy *getType() const { return Ty; }
 
-  virtual const Init *
+  virtual Init *
   convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
-  virtual const Init *
+  virtual Init *
   convertInitListSlice(const std::vector<unsigned> &Elements) const;
 
   /// getFieldType - This method is used to implement the FieldInit class.
@@ -596,14 +596,14 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const = 0;
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const = 0;
 
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const = 0;
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const = 0;
 };
 
 
@@ -615,10 +615,10 @@ class UnsetInit : public Init {
   UnsetInit &operator=(const UnsetInit &Other);  // Do not define.
 
 public:
-  static const UnsetInit *get();
+  static UnsetInit *get();
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<UnsetInit *>(this));
   }
 
   virtual bool isComplete() const { return false; }
@@ -636,12 +636,12 @@ class BitInit : public Init {
   BitInit &operator=(BitInit &Other);  // Do not define.
 
 public:
-  static const BitInit *get(bool V);
+  static BitInit *get(bool V);
 
   bool getValue() const { return Value; }
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<BitInit *>(this));
   }
 
   virtual std::string getAsString() const { return Value ? "1" : "0"; }
@@ -651,29 +651,29 @@ public:
 /// It contains a vector of bits, whose size is determined by the type.
 ///
 class BitsInit : public Init, public FoldingSetNode {
-  std::vector<const Init*> Bits;
+  std::vector<Init*> Bits;
 
-  BitsInit(ArrayRef<const Init *> Range) : Bits(Range.begin(), Range.end()) {}
+  BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
 
   BitsInit(const BitsInit &Other);  // Do not define.
   BitsInit &operator=(const BitsInit &Other);  // Do not define.
 
 public:
-  static const BitsInit *get(ArrayRef<const Init *> Range);
+  static BitsInit *get(ArrayRef<Init *> Range);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   unsigned getNumBits() const { return Bits.size(); }
 
-  const Init *getBit(unsigned Bit) const {
+  Init *getBit(unsigned Bit) const {
     assert(Bit < Bits.size() && "Bit index out of range!");
     return Bits[Bit];
   }
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<BitsInit *>(this));
   }
-  virtual const Init *
+  virtual Init *
   convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
 
   virtual bool isComplete() const {
@@ -688,7 +688,7 @@ public:
   }
   virtual std::string getAsString() const;
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 };
 
 
@@ -703,14 +703,14 @@ class IntInit : public TypedInit {
   IntInit &operator=(const IntInit &Other);  // Do note define.
 
 public:
-  static const IntInit *get(int64_t V);
+  static IntInit *get(int64_t V);
 
   int64_t getValue() const { return Value; }
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<IntInit *>(this));
   }
-  virtual const Init *
+  virtual Init *
   convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
 
   virtual std::string getAsString() const;
@@ -719,8 +719,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const {
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const {
     assert(0 && "Illegal bit reference off int");
     return 0;
   }
@@ -728,8 +728,8 @@ public:
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const {
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const {
     assert(0 && "Illegal element reference off int");
     return 0;
   }
@@ -748,12 +748,12 @@ class StringInit : public TypedInit {
   StringInit &operator=(const StringInit &Other);  // Do not define.
 
 public:
-  static const StringInit *get(const std::string &V);
+  static StringInit *get(const std::string &V);
 
   const std::string &getValue() const { return Value; }
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<StringInit *>(this));
   }
 
   virtual std::string getAsString() const { return "\"" + Value + "\""; }
@@ -762,8 +762,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const {
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const {
     assert(0 && "Illegal bit reference off string");
     return 0;
   }
@@ -771,8 +771,8 @@ public:
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const {
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const {
     assert(0 && "Illegal element reference off string");
     return 0;
   }
@@ -789,12 +789,12 @@ class CodeInit : public Init {
   CodeInit &operator=(const CodeInit &Other);  // Do not define.
 
 public:
-  static const CodeInit *get(const std::string &V);
+  static CodeInit *get(const std::string &V);
 
   const std::string &getValue() const { return Value; }
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<CodeInit *>(this));
   }
 
   virtual std::string getAsString() const { return "[{" + Value + "}]"; }
@@ -803,34 +803,34 @@ public:
 /// ListInit - [AL, AH, CL] - Represent a list of defs
 ///
 class ListInit : public TypedInit, public FoldingSetNode {
-  std::vector<const Init*> Values;
+  std::vector<Init*> Values;
 public:
-  typedef std::vector<const Init*>::const_iterator const_iterator;
+  typedef std::vector<Init*>::const_iterator const_iterator;
 
 private:
-  explicit ListInit(ArrayRef<const Init *> Range, RecTy *EltTy)
+  explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
       : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
 
   ListInit(const ListInit &Other);  // Do not define.
   ListInit &operator=(const ListInit &Other);  // Do not define.
 
 public:
-  static const ListInit *get(ArrayRef<const Init *> Range, RecTy *EltTy);
+  static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   unsigned getSize() const { return Values.size(); }
-  const Init *getElement(unsigned i) const {
+  Init *getElement(unsigned i) const {
     assert(i < Values.size() && "List element index out of range!");
     return Values[i];
   }
 
   Record *getElementAsRecord(unsigned i) const;
 
-  const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
+  Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<ListInit *>(this));
   }
 
   /// resolveReferences - This method is used by classes that refer to other
@@ -838,11 +838,11 @@ public:
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
   ///
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 
-  ArrayRef<const Init*> getValues() const { return Values; }
+  ArrayRef<Init*> getValues() const { return Values; }
 
   inline const_iterator begin() const { return Values.begin(); }
   inline const_iterator end  () const { return Values.end();   }
@@ -854,8 +854,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const {
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const {
     assert(0 && "Illegal bit reference off list");
     return 0;
   }
@@ -863,8 +863,8 @@ public:
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const;
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const;
 };
 
 
@@ -879,24 +879,23 @@ protected:
 
 public:
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0;
+  virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
 
   virtual int getNumOperands() const = 0;
-  virtual const Init *getOperand(int i) const = 0;
+  virtual Init *getOperand(int i) const = 0;
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
+  virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<OpInit *>(this));
   }
 
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const;
-  virtual const Init *resolveListElementReference(Record &R,
-                                                  const RecordVal *RV,
-                                                  unsigned Elt) const;
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const;
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const;
 };
 
 
@@ -907,38 +906,38 @@ public:
   enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
 private:
   UnaryOp Opc;
-  const Init *LHS;
+  Init *LHS;
 
-  UnOpInit(UnaryOp opc, const Init *lhs, RecTy *Type)
+  UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
       : OpInit(Type), Opc(opc), LHS(lhs) {}
 
   UnOpInit(const UnOpInit &Other);  // Do not define.
   UnOpInit &operator=(const UnOpInit &Other);  // Do not define.
 
 public:
-  static const UnOpInit *get(UnaryOp opc, const Init *lhs, RecTy *Type);
+  static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+  virtual OpInit *clone(std::vector<Init *> &Operands) const {
     assert(Operands.size() == 1 &&
            "Wrong number of operands for unary operation");
     return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
   }
 
   int getNumOperands() const { return 1; }
-  const Init *getOperand(int i) const {
+  Init *getOperand(int i) const {
     assert(i == 0 && "Invalid operand id for unary operator");
     return getOperand();
   }
 
   UnaryOp getOpcode() const { return Opc; }
-  const Init *getOperand() const { return LHS; }
+  Init *getOperand() const { return LHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -950,27 +949,27 @@ public:
   enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
 private:
   BinaryOp Opc;
-  const Init *LHS, *RHS;
+  Init *LHS, *RHS;
 
-  BinOpInit(BinaryOp opc, const Init *lhs, const Init *rhs, RecTy *Type) :
+  BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {}
 
   BinOpInit(const BinOpInit &Other);  // Do not define.
   BinOpInit &operator=(const BinOpInit &Other);  // Do not define.
 
 public:
-  static const BinOpInit *get(BinaryOp opc, const Init *lhs, const Init *rhs,
-                              RecTy *Type);
+  static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
+                        RecTy *Type);
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+  virtual OpInit *clone(std::vector<Init *> &Operands) const {
     assert(Operands.size() == 2 &&
            "Wrong number of operands for binary operation");
     return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
   }
 
   int getNumOperands() const { return 2; }
-  const Init *getOperand(int i) const {
+  Init *getOperand(int i) const {
     assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
     if (i == 0) {
       return getLHS();
@@ -980,14 +979,14 @@ public:
   }
 
   BinaryOp getOpcode() const { return Opc; }
-  const Init *getLHS() const { return LHS; }
-  const Init *getRHS() const { return RHS; }
+  Init *getLHS() const { return LHS; }
+  Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -999,9 +998,9 @@ public:
   enum TernaryOp { SUBST, FOREACH, IF };
 private:
   TernaryOp Opc;
-  const Init *LHS, *MHS, *RHS;
+  Init *LHS, *MHS, *RHS;
 
-  TernOpInit(TernaryOp opc, const Init *lhs, const Init *mhs, const Init *rhs,
+  TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
              RecTy *Type) :
       OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
 
@@ -1009,12 +1008,12 @@ private:
   TernOpInit &operator=(const TernOpInit &Other);  // Do not define.
 
 public:
-  static const TernOpInit *get(TernaryOp opc, const Init *lhs,
-                               const Init *mhs, const Init *rhs,
-                               RecTy *Type);
+  static TernOpInit *get(TernaryOp opc, Init *lhs,
+                         Init *mhs, Init *rhs,
+                         RecTy *Type);
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+  virtual OpInit *clone(std::vector<Init *> &Operands) const {
     assert(Operands.size() == 3 &&
            "Wrong number of operands for ternary operation");
     return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
@@ -1022,7 +1021,7 @@ public:
   }
 
   int getNumOperands() const { return 3; }
-  const Init *getOperand(int i) const {
+  Init *getOperand(int i) const {
     assert((i == 0 || i == 1 || i == 2) &&
            "Invalid operand id for ternary operator");
     if (i == 0) {
@@ -1035,17 +1034,17 @@ public:
   }
 
   TernaryOp getOpcode() const { return Opc; }
-  const Init *getLHS() const { return LHS; }
-  const Init *getMHS() const { return MHS; }
-  const Init *getRHS() const { return RHS; }
+  Init *getLHS() const { return LHS; }
+  Init *getMHS() const { return MHS; }
+  Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
   virtual bool isComplete() const { return false; }
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -1063,30 +1062,30 @@ class VarInit : public TypedInit {
   VarInit &operator=(const VarInit &Other);  // Do not define.
 
 public:
-  static const VarInit *get(const std::string &VN, RecTy *T);
-  static const VarInit *get(const Init *VN, RecTy *T);
+  static VarInit *get(const std::string &VN, RecTy *T);
+  static VarInit *get(Init *VN, RecTy *T);
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<VarInit *>(this));
   }
 
   const std::string &getName() const { return VarName; }
 
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const;
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const;
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const;
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const;
 
   virtual RecTy *getFieldType(const std::string &FieldName) const;
-  virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
-                                   const std::string &FieldName) const;
+  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+                             const std::string &FieldName) const;
 
   /// resolveReferences - This method is used by classes that refer to other
   /// variables which may not be defined at the time they expression is formed.
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
   ///
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const { return VarName; }
 };
@@ -1095,10 +1094,10 @@ public:
 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
 ///
 class VarBitInit : public Init {
-  const TypedInit *TI;
+  TypedInit *TI;
   unsigned Bit;
 
-  VarBitInit(const TypedInit *T, unsigned B) : TI(T), Bit(B) {
+  VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
     assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
            ((BitsRecTy*)T->getType())->getNumBits() > B &&
            "Illegal VarBitInit expression!");
@@ -1108,26 +1107,26 @@ class VarBitInit : public Init {
   VarBitInit &operator=(const VarBitInit &Other);  // Do not define.
 
 public:
-  static const VarBitInit *get(const TypedInit *T, unsigned B);
+  static VarBitInit *get(TypedInit *T, unsigned B);
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<VarBitInit *>(this));
   }
 
-  const TypedInit *getVariable() const { return TI; }
+  TypedInit *getVariable() const { return TI; }
   unsigned getBitNum() const { return Bit; }
 
   virtual std::string getAsString() const;
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 };
 
 /// VarListElementInit - List[4] - Represent access to one element of a var or
 /// field.
 class VarListElementInit : public TypedInit {
-  const TypedInit *TI;
+  TypedInit *TI;
   unsigned Element;
 
-  VarListElementInit(const TypedInit *T, unsigned E)
+  VarListElementInit(TypedInit *T, unsigned E)
       : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
           TI(T), Element(E) {
     assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
@@ -1140,27 +1139,27 @@ class VarListElementInit : public TypedInit {
                                                                    // define.
 
 public:
-  static const VarListElementInit *get(const TypedInit *T, unsigned E);
+  static VarListElementInit *get(TypedInit *T, unsigned E);
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<VarListElementInit *>(this));
   }
 
-  const TypedInit *getVariable() const { return TI; }
+  TypedInit *getVariable() const { return TI; }
   unsigned getElementNum() const { return Element; }
 
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const;
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const;
 
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R,
-                                                  const RecordVal *RV,
-                                                  unsigned Elt) const;
+  virtual Init *resolveListElementReference(Record &R,
+                                            const RecordVal *RV,
+                                            unsigned Elt) const;
 
   virtual std::string getAsString() const;
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 };
 
 /// DefInit - AL - Represent a reference to a 'def' in the description
@@ -1175,20 +1174,19 @@ class DefInit : public TypedInit {
   DefInit &operator=(const DefInit &Other);  // Do not define.
 
 public:
-  static const DefInit *get(Record*);
+  static DefInit *get(Record*);
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<DefInit *>(this));
   }
 
   Record *getDef() const { return Def; }
 
-  //virtual const Init *
-  //convertInitializerBitRange(const std::vector<unsigned> &Bits);
+  //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
 
   virtual RecTy *getFieldType(const std::string &FieldName) const;
-  virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
-                                   const std::string &FieldName) const;
+  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+                             const std::string &FieldName) const;
 
   virtual std::string getAsString() const;
 
@@ -1196,8 +1194,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const {
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const {
     assert(0 && "Illegal bit reference off def");
     return 0;
   }
@@ -1205,8 +1203,8 @@ public:
   /// resolveListElementReference - This method is used to implement
   /// VarListElementInit::resolveReferences.  If the list element is resolvable
   /// now, we return the resolved value, otherwise we return null.
-  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                                  unsigned Elt) const {
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const {
     assert(0 && "Illegal element reference off def");
     return 0;
   }
@@ -1216,10 +1214,10 @@ public:
 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
 ///
 class FieldInit : public TypedInit {
-  const Init *Rec;                // Record we are referring to
+  Init *Rec;                // Record we are referring to
   std::string FieldName;    // Field we are accessing
 
-  FieldInit(const Init *R, const std::string &FN)
+  FieldInit(Init *R, const std::string &FN)
       : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
     assert(getType() && "FieldInit with non-record type!");
   }
@@ -1228,20 +1226,20 @@ class FieldInit : public TypedInit {
   FieldInit &operator=(const FieldInit &Other);  // Do not define.
 
 public:
-  static const FieldInit *get(const Init *R, const std::string &FN);
-  static const FieldInit *get(const Init *R, const Init *FN);
+  static FieldInit *get(Init *R, const std::string &FN);
+  static FieldInit *get(Init *R, const Init *FN);
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<FieldInit *>(this));
   }
 
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const;
-  virtual const Init *resolveListElementReference(Record &R,
-                                                  const RecordVal *RV,
-                                                  unsigned Elt) const;
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const;
+  virtual Init *resolveListElementReference(Record &R,
+                                            const RecordVal *RV,
+                                            unsigned Elt) const;
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const {
     return Rec->getAsString() + "." + FieldName;
@@ -1253,13 +1251,13 @@ public:
 /// argument can have a name associated with it.
 ///
 class DagInit : public TypedInit, public FoldingSetNode {
-  const Init *Val;
+  Init *Val;
   std::string ValName;
-  std::vector<const Init*> Args;
+  std::vector<Init*> Args;
   std::vector<std::string> ArgNames;
 
-  DagInit(const Init *V, const std::string &VN,
-          ArrayRef<const Init *> ArgRange,
+  DagInit(Init *V, const std::string &VN,
+          ArrayRef<Init *> ArgRange,
           ArrayRef<std::string> NameRange)
       : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
           Args(ArgRange.begin(), ArgRange.end()),
@@ -1269,25 +1267,25 @@ class DagInit : public TypedInit, public FoldingSetNode {
   DagInit &operator=(const DagInit &Other);  // Do not define.
 
 public:
-  static const DagInit *get(const Init *V, const std::string &VN,
-                            ArrayRef<const Init *> ArgRange,
-                            ArrayRef<std::string> NameRange);
-  static const DagInit *get(const Init *V, const std::string &VN,
-                            const std::vector<
-                              std::pair<const Init*, std::string> > &args);
+  static DagInit *get(Init *V, const std::string &VN,
+                      ArrayRef<Init *> ArgRange,
+                      ArrayRef<std::string> NameRange);
+  static DagInit *get(Init *V, const std::string &VN,
+                      const std::vector<
+                        std::pair<Init*, std::string> > &args);
 
   void Profile(FoldingSetNodeID &ID) const;
 
-  virtual const Init *convertInitializerTo(RecTy *Ty) const {
-    return Ty->convertValue(this);
+  virtual Init *convertInitializerTo(RecTy *Ty) const {
+    return Ty->convertValue(const_cast<DagInit *>(this));
   }
 
-  const Init *getOperator() const { return Val; }
+  Init *getOperator() const { return Val; }
 
   const std::string &getName() const { return ValName; }
 
   unsigned getNumArgs() const { return Args.size(); }
-  const Init *getArg(unsigned Num) const {
+  Init *getArg(unsigned Num) const {
     assert(Num < Args.size() && "Arg number out of range!");
     return Args[Num];
   }
@@ -1296,11 +1294,11 @@ public:
     return ArgNames[Num];
   }
 
-  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 
-  typedef std::vector<const Init*>::const_iterator       const_arg_iterator;
+  typedef std::vector<Init*>::const_iterator       const_arg_iterator;
   typedef std::vector<std::string>::const_iterator const_name_iterator;
 
   inline const_arg_iterator  arg_begin() const { return Args.begin(); }
@@ -1315,15 +1313,14 @@ public:
   inline size_t              name_size () const { return ArgNames.size();  }
   inline bool                name_empty() const { return ArgNames.empty(); }
 
-  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                          unsigned Bit) const {
+  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                    unsigned Bit) const {
     assert(0 && "Illegal bit reference off dag");
     return 0;
   }
 
-  virtual const Init *resolveListElementReference(Record &R,
-                                                  const RecordVal *RV,
-                                                  unsigned Elt) const {
+  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                            unsigned Elt) const {
     assert(0 && "Illegal element reference off dag");
     return 0;
   }
@@ -1337,7 +1334,7 @@ class RecordVal {
   std::string Name;
   RecTy *Ty;
   unsigned Prefix;
-  const Init *Value;
+  Init *Value;
 public:
   RecordVal(const std::string &N, RecTy *T, unsigned P);
 
@@ -1345,9 +1342,9 @@ public:
 
   unsigned getPrefix() const { return Prefix; }
   RecTy *getType() const { return Ty; }
-  const Init *getValue() const { return Value; }
+  Init *getValue() const { return Value; }
 
-  bool setValue(const Init *V) {
+  bool setValue(Init *V) {
     if (V) {
       Value = V->convertInitializerTo(Ty);
       return Value == 0;
@@ -1486,7 +1483,7 @@ public:
   /// getValueInit - Return the initializer for a value with the specified name,
   /// or throw an exception if the field does not exist.
   ///
-  const Init *getValueInit(StringRef FieldName) const;
+  Init *getValueInit(StringRef FieldName) const;
 
   /// getValueAsString - This method looks up the specified field and returns
   /// its value as a string, throwing an exception if the field does not exist
@@ -1498,13 +1495,13 @@ public:
   /// its value as a BitsInit, throwing an exception if the field does not exist
   /// or if the value is not the right type.
   ///
-  const BitsInit *getValueAsBitsInit(StringRef FieldName) const;
+  BitsInit *getValueAsBitsInit(StringRef FieldName) const;
 
   /// getValueAsListInit - This method looks up the specified field and returns
   /// its value as a ListInit, throwing an exception if the field does not exist
   /// or if the value is not the right type.
   ///
-  const ListInit *getValueAsListInit(StringRef FieldName) const;
+  ListInit *getValueAsListInit(StringRef FieldName) const;
 
   /// getValueAsListOfDefs - This method looks up the specified field and
   /// returns its value as a vector of records, throwing an exception if the
@@ -1546,7 +1543,7 @@ public:
   /// value as an Dag, throwing an exception if the field does not exist or if
   /// the value is not the right type.
   ///
-  const DagInit *getValueAsDag(StringRef FieldName) const;
+  DagInit *getValueAsDag(StringRef FieldName) const;
 
   /// getValueAsCode - This method looks up the specified field and returns
   /// its value as the string data in a CodeInit, throwing an exception if the