diff --git a/utils/TableGen/ARMDecoderEmitter.cpp b/utils/TableGen/ARMDecoderEmitter.cpp
index c4bac10cfb2..cc0c5da5cc4 100644
--- a/utils/TableGen/ARMDecoderEmitter.cpp
+++ b/utils/TableGen/ARMDecoderEmitter.cpp
@@ -115,7 +115,7 @@ enum {
 
 /// byteFromBitsInit - Return the byte value from a BitsInit.
 /// Called from getByteField().
-static uint8_t byteFromBitsInit(BitsInit &init) {
+static uint8_t byteFromBitsInit(const BitsInit &init) {
   int width = init.getNumBits();
 
   assert(width <= 8 && "Field is too large for uint8_t!");
@@ -126,7 +126,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) {
   uint8_t ret = 0;
 
   for (index = 0; index < width; index++) {
-    if (static_cast<BitInit*>(init.getBit(index))->getValue())
+    if (static_cast<const BitInit*>(init.getBit(index))->getValue())
       ret |= mask;
 
     mask <<= 1;
@@ -136,12 +136,12 @@ static uint8_t byteFromBitsInit(BitsInit &init) {
 }
 
 static uint8_t getByteField(const Record &def, const char *str) {
-  BitsInit *bits = def.getValueAsBitsInit(str);
+  const BitsInit *bits = def.getValueAsBitsInit(str);
   return byteFromBitsInit(*bits);
 }
 
-static BitsInit &getBitsField(const Record &def, const char *str) {
-  BitsInit *bits = def.getValueAsBitsInit(str);
+static const BitsInit &getBitsField(const Record &def, const char *str) {
+  const BitsInit *bits = def.getValueAsBitsInit(str);
   return *bits;
 }
 
@@ -184,15 +184,15 @@ static bool ValueNotSet(bit_value_t V) {
 static int Value(bit_value_t V) {
   return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
 }
-static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
-  if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
+static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
+  if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
     return bit->getValue() ? BIT_TRUE : BIT_FALSE;
 
   // The bit is uninitialized.
   return BIT_UNSET;
 }
 // Prints the bit value for each position.
-static void dumpBits(raw_ostream &o, BitsInit &bits) {
+static void dumpBits(raw_ostream &o, const BitsInit &bits) {
   unsigned index;
 
   for (index = bits.getNumBits(); index > 0; index--) {
@@ -425,7 +425,7 @@ protected:
     if (AllInstructions[Opcode]->isPseudo)
       return;
 
-    BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
+    const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
 
     for (unsigned i = 0; i < BIT_WIDTH; ++i)
       Insn[i] = bitFromBits(Bits, i);
@@ -1559,7 +1559,7 @@ ARMDEBackend::populateInstruction(const CodeGenInstruction &CGI,
   const StringRef Name = Def.getName();
   uint8_t Form = getByteField(Def, "Form");
 
-  BitsInit &Bits = getBitsField(Def, "Inst");
+  const BitsInit &Bits = getBitsField(Def, "Inst");
 
   // If all the bit positions are not specified; do not decode this instruction.
   // We are bound to fail!  For proper disassembly, the well-known encoding bits
diff --git a/utils/TableGen/AsmMatcherEmitter.cpp b/utils/TableGen/AsmMatcherEmitter.cpp
index d302941061d..8afa76acf09 100644
--- a/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/utils/TableGen/AsmMatcherEmitter.cpp
@@ -869,7 +869,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
                                 int SubOpIdx) {
   Record *Rec = OI.Rec;
   if (SubOpIdx != -1)
-    Rec = dynamic_cast<DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
+    Rec = dynamic_cast<const DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
 
   if (Rec->isSubClassOf("RegisterOperand")) {
     // RegisterOperand may have an associated ParserMatchClass. If it does,
@@ -879,7 +879,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
       throw "Record `" + Rec->getName() +
         "' does not have a ParserMatchClass!\n";
 
-    if (DefInit *DI= dynamic_cast<DefInit*>(R->getValue())) {
+    if (const DefInit *DI= dynamic_cast<const DefInit*>(R->getValue())) {
       Record *MatchClass = DI->getDef();
       if (ClassInfo *CI = AsmOperandClasses[MatchClass])
         return CI;
@@ -1046,9 +1046,9 @@ void AsmMatcherInfo::BuildOperandClasses() {
     ClassInfo *CI = AsmOperandClasses[*it];
     CI->Kind = ClassInfo::UserClass0 + Index;
 
-    ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
+    const ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
     for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
-      DefInit *DI = dynamic_cast<DefInit*>(Supers->getElement(i));
+      const DefInit *DI = dynamic_cast<const DefInit*>(Supers->getElement(i));
       if (!DI) {
         PrintError((*it)->getLoc(), "Invalid super class reference!");
         continue;
@@ -1065,28 +1065,28 @@ void AsmMatcherInfo::BuildOperandClasses() {
     CI->ValueName = (*it)->getName();
 
     // Get or construct the predicate method name.
-    Init *PMName = (*it)->getValueInit("PredicateMethod");
-    if (StringInit *SI = dynamic_cast<StringInit*>(PMName)) {
+    const Init *PMName = (*it)->getValueInit("PredicateMethod");
+    if (const StringInit *SI = dynamic_cast<const StringInit*>(PMName)) {
       CI->PredicateMethod = SI->getValue();
     } else {
-      assert(dynamic_cast<UnsetInit*>(PMName) &&
+      assert(dynamic_cast<const UnsetInit*>(PMName) &&
              "Unexpected PredicateMethod field!");
       CI->PredicateMethod = "is" + CI->ClassName;
     }
 
     // Get or construct the render method name.
-    Init *RMName = (*it)->getValueInit("RenderMethod");
-    if (StringInit *SI = dynamic_cast<StringInit*>(RMName)) {
+    const Init *RMName = (*it)->getValueInit("RenderMethod");
+    if (const StringInit *SI = dynamic_cast<const StringInit*>(RMName)) {
       CI->RenderMethod = SI->getValue();
     } else {
-      assert(dynamic_cast<UnsetInit*>(RMName) &&
+      assert(dynamic_cast<const UnsetInit*>(RMName) &&
              "Unexpected RenderMethod field!");
       CI->RenderMethod = "add" + CI->ClassName + "Operands";
     }
 
     // Get the parse method name or leave it as empty.
-    Init *PRMName = (*it)->getValueInit("ParserMethod");
-    if (StringInit *SI = dynamic_cast<StringInit*>(PRMName))
+    const Init *PRMName = (*it)->getValueInit("ParserMethod");
+    if (const StringInit *SI = dynamic_cast<const StringInit*>(PRMName))
       CI->ParserMethod = SI->getValue();
 
     AsmOperandClasses[*it] = CI;
diff --git a/utils/TableGen/CallingConvEmitter.cpp b/utils/TableGen/CallingConvEmitter.cpp
index c51afd82a37..37758bc1cf5 100644
--- a/utils/TableGen/CallingConvEmitter.cpp
+++ b/utils/TableGen/CallingConvEmitter.cpp
@@ -40,7 +40,7 @@ void CallingConvEmitter::run(raw_ostream &O) {
 
 
 void CallingConvEmitter::EmitCallingConv(Record *CC, raw_ostream &O) {
-  ListInit *CCActions = CC->getValueAsListInit("Actions");
+  const ListInit *CCActions = CC->getValueAsListInit("Actions");
   Counter = 0;
 
   O << "\n\nstatic bool " << CC->getName()
@@ -67,7 +67,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
     O << IndentStr << "if (";
     
     if (Action->isSubClassOf("CCIfType")) {
-      ListInit *VTs = Action->getValueAsListInit("VTs");
+      const ListInit *VTs = Action->getValueAsListInit("VTs");
       for (unsigned i = 0, e = VTs->getSize(); i != e; ++i) {
         Record *VT = VTs->getElementAsRecord(i);
         if (i != 0) O << " ||\n    " << IndentStr;
@@ -91,7 +91,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
         << "(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))\n"
         << IndentStr << "  return false;\n";
     } else if (Action->isSubClassOf("CCAssignToReg")) {
-      ListInit *RegList = Action->getValueAsListInit("RegList");
+      const ListInit *RegList = Action->getValueAsListInit("RegList");
       if (RegList->getSize() == 1) {
         O << IndentStr << "if (unsigned Reg = State.AllocateReg(";
         O << getQualifiedName(RegList->getElementAsRecord(0)) << ")) {\n";
@@ -112,8 +112,8 @@ void CallingConvEmitter::EmitAction(Record *Action,
       O << IndentStr << "  return false;\n";
       O << IndentStr << "}\n";
     } else if (Action->isSubClassOf("CCAssignToRegWithShadow")) {
-      ListInit *RegList = Action->getValueAsListInit("RegList");
-      ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
+      const ListInit *RegList = Action->getValueAsListInit("RegList");
+      const ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
       if (ShadowRegList->getSize() >0 &&
           ShadowRegList->getSize() != RegList->getSize())
         throw "Invalid length of list of shadowed registers";
diff --git a/utils/TableGen/ClangAttrEmitter.cpp b/utils/TableGen/ClangAttrEmitter.cpp
index 40bbb085248..ab74598e6db 100644
--- a/utils/TableGen/ClangAttrEmitter.cpp
+++ b/utils/TableGen/ClangAttrEmitter.cpp
@@ -21,7 +21,7 @@ using namespace llvm;
 
 static const std::vector<StringRef>
 getValueAsListOfStrings(Record &R, StringRef FieldName) {
-  ListInit *List = R.getValueAsListInit(FieldName);
+  const ListInit *List = R.getValueAsListInit(FieldName);
   assert (List && "Got a null ListInit");
 
   std::vector<StringRef> Strings;
@@ -31,9 +31,9 @@ getValueAsListOfStrings(Record &R, StringRef FieldName) {
        i != e;
        ++i) {
     assert(*i && "Got a null element in a ListInit");
-    if (StringInit *S = dynamic_cast<StringInit *>(*i))
+    if (const StringInit *S = dynamic_cast<const StringInit *>(*i))
       Strings.push_back(S->getValue());
-    else if (CodeInit *C = dynamic_cast<CodeInit *>(*i))
+    else if (const CodeInit *C = dynamic_cast<const CodeInit *>(*i))
       Strings.push_back(C->getValue());
     else
       assert(false && "Got a non-string, non-code element in a ListInit");
diff --git a/utils/TableGen/ClangDiagnosticsEmitter.cpp b/utils/TableGen/ClangDiagnosticsEmitter.cpp
index 0a48e75681f..2ef1e8ba341 100644
--- a/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -74,7 +74,7 @@ getCategoryFromDiagGroup(const Record *Group,
 static std::string getDiagnosticCategory(const Record *R,
                                          DiagGroupParentMap &DiagGroupParents) {
   // If the diagnostic is in a group, and that group has a category, use it.
-  if (DefInit *Group = dynamic_cast<DefInit*>(R->getValueInit("Group"))) {
+  if (const DefInit *Group = dynamic_cast<const DefInit*>(R->getValueInit("Group"))) {
     // Check the diagnostic's diag group for a category.
     std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
                                                    DiagGroupParents);
@@ -159,7 +159,7 @@ void ClangDiagsDefsEmitter::run(raw_ostream &OS) {
     OS.write_escaped(R.getValueAsString("Text")) << '"';
     
     // Warning associated with the diagnostic.
-    if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) {
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) {
       OS << ", \"";
       OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"';
     } else {
@@ -225,7 +225,7 @@ void ClangDiagGroupsEmitter::run(raw_ostream &OS) {
     Records.getAllDerivedDefinitions("Diagnostic");
   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     const Record *R = Diags[i];
-    DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"));
+    const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("Group"));
     if (DI == 0) continue;
     std::string GroupName = DI->getDef()->getValueAsString("GroupName");
     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
diff --git a/utils/TableGen/ClangSACheckersEmitter.cpp b/utils/TableGen/ClangSACheckersEmitter.cpp
index 97739c6b3f4..d509173cef8 100644
--- a/utils/TableGen/ClangSACheckersEmitter.cpp
+++ b/utils/TableGen/ClangSACheckersEmitter.cpp
@@ -28,7 +28,7 @@ static bool isHidden(const Record &R) {
   if (R.getValueAsBit("Hidden"))
     return true;
   // Not declared as hidden, check the parent package if it is hidden.
-  if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("ParentPackage")))
+  if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("ParentPackage")))
     return isHidden(*DI->getDef());
 
   return false;
@@ -42,7 +42,7 @@ static std::string getPackageFullName(const Record *R);
 
 static std::string getParentPackageFullName(const Record *R) {
   std::string name;
-  if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
+  if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
     name = getPackageFullName(DI->getDef());
   return name;
 }
@@ -63,8 +63,8 @@ static std::string getCheckerFullName(const Record *R) {
 }
 
 static std::string getStringValue(const Record &R, StringRef field) {
-  if (StringInit *
-        SI = dynamic_cast<StringInit*>(R.getValueInit(field)))
+  if (const StringInit *
+        SI = dynamic_cast<const StringInit*>(R.getValueInit(field)))
     return SI->getValue();
   return std::string();
 }
@@ -129,8 +129,8 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
   for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
     Record *R = checkers[i];
     Record *package = 0;
-    if (DefInit *
-          DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
+    if (const DefInit *
+          DI = dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
       package = DI->getDef();
     if (!isCheckerNamed(R) && !package)
       throw "Checker '" + R->getName() + "' is neither named, nor in a package!";
@@ -149,21 +149,21 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
     Record *currR = isCheckerNamed(R) ? R : package;
     // Insert the checker and its parent packages into the subgroups set of
     // the corresponding parent package.
-    while (DefInit *DI
-             = dynamic_cast<DefInit*>(currR->getValueInit("ParentPackage"))) {
+    while (const DefInit *DI
+             = dynamic_cast<const DefInit*>(currR->getValueInit("ParentPackage"))) {
       Record *parentPackage = DI->getDef();
       recordGroupMap[parentPackage]->SubGroups.insert(currR);
       currR = parentPackage;
     }
     // Insert the checker into the set of its group.
-    if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group")))
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("Group")))
       recordGroupMap[DI->getDef()]->Checkers.insert(R);
   }
 
   // If a package is in group, add all its checkers and its sub-packages
   // checkers into the group.
   for (unsigned i = 0, e = packages.size(); i != e; ++i)
-    if (DefInit *DI = dynamic_cast<DefInit*>(packages[i]->getValueInit("Group")))
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(packages[i]->getValueInit("Group")))
       addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
 
   typedef std::map<std::string, const Record *> SortedRecords;
@@ -204,7 +204,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
       OS << "PACKAGE(" << "\"";
       OS.write_escaped(getPackageFullName(&R)) << "\", ";
       // Group index
-      if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
+      if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
         OS << groupToSortIndex[DI->getDef()] << ", ";
       else
         OS << "-1, ";
@@ -232,7 +232,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
     OS << "\"";
     OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
     // Group index
-    if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
       OS << groupToSortIndex[DI->getDef()] << ", ";
     else
       OS << "-1, ";
diff --git a/utils/TableGen/CodeEmitterGen.cpp b/utils/TableGen/CodeEmitterGen.cpp
index 8b5cddae25e..c11e4d0beb1 100644
--- a/utils/TableGen/CodeEmitterGen.cpp
+++ b/utils/TableGen/CodeEmitterGen.cpp
@@ -38,16 +38,16 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
         R->getValueAsBit("isPseudo"))
       continue;
 
-    BitsInit *BI = R->getValueAsBitsInit("Inst");
+    const BitsInit *BI = R->getValueAsBitsInit("Inst");
 
     unsigned numBits = BI->getNumBits();
  
-    SmallVector<Init *, 16> NewBits(numBits);
+    SmallVector<const Init *, 16> NewBits(numBits);
  
     for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
       unsigned bitSwapIdx = numBits - bit - 1;
-      Init *OrigBit = BI->getBit(bit);
-      Init *BitSwap = BI->getBit(bitSwapIdx);
+      const Init *OrigBit = BI->getBit(bit);
+      const Init *BitSwap = BI->getBit(bitSwapIdx);
       NewBits[bit]        = BitSwap;
       NewBits[bitSwapIdx] = OrigBit;
     }
@@ -56,7 +56,7 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
       NewBits[middle] = BI->getBit(middle);
     }
 
-    BitsInit *NewBI = new BitsInit(ArrayRef<Init *>(NewBits));
+    BitsInit *NewBI = new BitsInit(ArrayRef<const Init *>(NewBits));
 
     // Update the bits in reversed order so that emitInstrOpBits will get the
     // correct endianness.
@@ -67,12 +67,12 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
 // If the VarBitInit at position 'bit' matches the specified variable then
 // return the variable bit position.  Otherwise return -1.
 int CodeEmitterGen::getVariableBit(const std::string &VarName,
-                                   BitsInit *BI, int bit) {
-  if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) {
-    if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable()))
+                                   const BitsInit *BI, int bit) {
+  if (const VarBitInit *VBI = dynamic_cast<const VarBitInit*>(BI->getBit(bit))) {
+    if (const VarInit *VI = dynamic_cast<const VarInit*>(VBI->getVariable()))
       if (VI->getName() == VarName)
         return VBI->getBitNum();
-  } else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) {
+  } else if (const VarInit *VI = dynamic_cast<const VarInit*>(BI->getBit(bit))) {
     if (VI->getName() == VarName)
       return 0;
   }
@@ -81,7 +81,7 @@ int CodeEmitterGen::getVariableBit(const std::string &VarName,
 }
 
 void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName,
                         unsigned &NumberedOp,
                         std::string &Case, CodeGenTarget &Target) {
   CodeGenInstruction &CGI = Target.getInstruction(R);
@@ -185,7 +185,7 @@ std::string CodeEmitterGen::getInstructionCase(Record *R,
                                                CodeGenTarget &Target) {
   std::string Case;
   
-  BitsInit *BI = R->getValueAsBitsInit("Inst");
+  const BitsInit *BI = R->getValueAsBitsInit("Inst");
   const std::vector<RecordVal> &Vals = R->getValues();
   unsigned NumberedOp = 0;
 
@@ -242,12 +242,12 @@ void CodeEmitterGen::run(raw_ostream &o) {
       continue;
     }
 
-    BitsInit *BI = R->getValueAsBitsInit("Inst");
+    const BitsInit *BI = R->getValueAsBitsInit("Inst");
 
     // Start by filling in fixed values.
     unsigned Value = 0;
     for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) {
-      if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1)))
+      if (const BitInit *B = dynamic_cast<const BitInit*>(BI->getBit(e-i-1)))
         Value |= B->getValue() << (e-i-1);
     }
     o << "    " << Value << "U," << '\t' << "// " << R->getName() << "\n";
diff --git a/utils/TableGen/CodeEmitterGen.h b/utils/TableGen/CodeEmitterGen.h
index a874d970fea..1f841c37a3c 100644
--- a/utils/TableGen/CodeEmitterGen.h
+++ b/utils/TableGen/CodeEmitterGen.h
@@ -35,10 +35,10 @@ private:
   void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace);
   void emitGetValueBit(raw_ostream &o, const std::string &Namespace);
   void reverseBits(std::vector<Record*> &Insts);
-  int getVariableBit(const std::string &VarName, BitsInit *BI, int bit);
+  int getVariableBit(const std::string &VarName, const BitsInit *BI, int bit);
   std::string getInstructionCase(Record *R, CodeGenTarget &Target);
   void
-  AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+  AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName,
                           unsigned &NumberedOp,
                           std::string &Case, CodeGenTarget &Target);
     
diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp
index 16585f7a919..2a75849d67e 100644
--- a/utils/TableGen/CodeGenDAGPatterns.cpp
+++ b/utils/TableGen/CodeGenDAGPatterns.cpp
@@ -583,7 +583,7 @@ typedef DepVarMap::const_iterator DepVarMap_citer;
 
 static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) {
   if (N->isLeaf()) {
-    if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL)
+    if (dynamic_cast<const DefInit*>(N->getLeafValue()) != NULL)
       DepMap[N->getName()]++;
   } else {
     for (size_t i = 0, e = N->getNumChildren(); i != e; ++i)
@@ -692,7 +692,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
   unsigned Size = 3;  // The node itself.
   // If the root node is a ConstantSDNode, increases its size.
   // e.g. (set R32:$dst, 0).
-  if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue()))
+  if (P->isLeaf() && dynamic_cast<const IntInit*>(P->getLeafValue()))
     Size += 2;
 
   // FIXME: This is a hack to statically increase the priority of patterns
@@ -716,7 +716,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
         Child->getType(0) != MVT::Other)
       Size += getPatternSize(Child, CGP);
     else if (Child->isLeaf()) {
-      if (dynamic_cast<IntInit*>(Child->getLeafValue()))
+      if (dynamic_cast<const IntInit*>(Child->getLeafValue()))
         Size += 5;  // Matches a ConstantSDNode (+3) and a specific value (+2).
       else if (Child->getComplexPatternInfo(CGP))
         Size += getPatternSize(Child, CGP);
@@ -742,7 +742,7 @@ getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
 std::string PatternToMatch::getPredicateCheck() const {
   std::string PredicateCheck;
   for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) {
-    if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) {
+    if (const DefInit *Pred = dynamic_cast<const DefInit*>(Predicates->getElement(i))) {
       Record *Def = Pred->getDef();
       if (!Def->isSubClassOf("Predicate")) {
 #ifndef NDEBUG
@@ -866,12 +866,12 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     // The NodeToApply must be a leaf node that is a VT.  OtherOperandNum must
     // have an integer type that is smaller than the VT.
     if (!NodeToApply->isLeaf() ||
-        !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) ||
-        !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
+        !dynamic_cast<const DefInit*>(NodeToApply->getLeafValue()) ||
+        !static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef()
                ->isSubClassOf("ValueType"))
       TP.error(N->getOperator()->getName() + " expects a VT operand!");
     MVT::SimpleValueType VT =
-     getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef());
+     getValueType(static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef());
 
     EEVT::TypeSet TypeListTmp(VT, TP);
 
@@ -1021,10 +1021,10 @@ static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
       return PFRec->getOnlyTree()->getNumTypes();
 
     // Get the result tree.
-    DagInit *Tree = Operator->getValueAsDag("Fragment");
+    const DagInit *Tree = Operator->getValueAsDag("Fragment");
     Record *Op = 0;
-    if (Tree && dynamic_cast<DefInit*>(Tree->getOperator()))
-      Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef();
+    if (Tree && dynamic_cast<const DefInit*>(Tree->getOperator()))
+      Op = dynamic_cast<const DefInit*>(Tree->getOperator())->getDef();
     assert(Op && "Invalid Fragment");
     return GetNumNodeResults(Op, CDP);
   }
@@ -1098,8 +1098,8 @@ bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N,
     return false;
 
   if (isLeaf()) {
-    if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
-      if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) {
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
+      if (const DefInit *NDI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
         return ((DI->getDef() == NDI->getDef())
                 && (DepVars.find(getName()) == DepVars.end()
                     || getName() == N->getName()));
@@ -1155,9 +1155,9 @@ SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
   for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
     TreePatternNode *Child = getChild(i);
     if (Child->isLeaf()) {
-      Init *Val = Child->getLeafValue();
-      if (dynamic_cast<DefInit*>(Val) &&
-          static_cast<DefInit*>(Val)->getDef()->getName() == "node") {
+      const Init *Val = Child->getLeafValue();
+      if (dynamic_cast<const DefInit*>(Val) &&
+          static_cast<const DefInit*>(Val)->getDef()->getName() == "node") {
         // We found a use of a formal argument, replace it with its value.
         TreePatternNode *NewChild = ArgMap[Child->getName()];
         assert(NewChild && "Couldn't find formal argument!");
@@ -1319,7 +1319,7 @@ getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const {
     return 0;
 
   unsigned IID =
-    dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue();
+    dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue();
   return &CDP.getIntrinsicInfo(IID);
 }
 
@@ -1329,7 +1329,7 @@ const ComplexPattern *
 TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const {
   if (!isLeaf()) return 0;
 
-  DefInit *DI = dynamic_cast<DefInit*>(getLeafValue());
+  const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue());
   if (DI && DI->getDef()->isSubClassOf("ComplexPattern"))
     return &CGP.getComplexPattern(DI->getDef());
   return 0;
@@ -1382,7 +1382,7 @@ TreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const {
 bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
   CodeGenDAGPatterns &CDP = TP.getDAGPatterns();
   if (isLeaf()) {
-    if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
       // If it's a regclass or something else known, include the type.
       bool MadeChange = false;
       for (unsigned i = 0, e = Types.size(); i != e; ++i)
@@ -1391,7 +1391,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
       return MadeChange;
     }
 
-    if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) {
+    if (const IntInit *II = dynamic_cast<const IntInit*>(getLeafValue())) {
       assert(Types.size() == 1 && "Invalid IntInit");
 
       // Int inits are always integers. :)
@@ -1651,7 +1651,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
 static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
   if (!N->isLeaf() && N->getOperator()->getName() == "imm")
     return true;
-  if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue()))
+  if (N->isLeaf() && dynamic_cast<const IntInit*>(N->getLeafValue()))
     return true;
   return false;
 }
@@ -1701,14 +1701,14 @@ bool TreePatternNode::canPatternMatch(std::string &Reason,
 // TreePattern implementation
 //
 
-TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
+TreePattern::TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
                          CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
   isInputPattern = isInput;
   for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i)
     Trees.push_back(ParseTreePattern(RawPat->getElement(i), ""));
 }
 
-TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
+TreePattern::TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
                          CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
   isInputPattern = isInput;
   Trees.push_back(ParseTreePattern(Pat, ""));
@@ -1739,8 +1739,8 @@ void TreePattern::ComputeNamedNodes(TreePatternNode *N) {
 }
 
 
-TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
-  if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) {
+TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit, StringRef OpName){
+  if (const DefInit *DI = dynamic_cast<const DefInit*>(TheInit)) {
     Record *R = DI->getDef();
 
     // Direct reference to a leaf DagNode or PatFrag?  Turn it into a
@@ -1748,7 +1748,7 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
     ///   (foo GPR, imm) -> (foo GPR, (imm))
     if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))
       return ParseTreePattern(new DagInit(DI, "",
-                          std::vector<std::pair<Init*, std::string> >()),
+                          std::vector<std::pair<const Init*, std::string> >()),
                               OpName);
 
     // Input argument?
@@ -1763,26 +1763,26 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
     return Res;
   }
 
-  if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) {
+  if (const IntInit *II = dynamic_cast<const IntInit*>(TheInit)) {
     if (!OpName.empty())
       error("Constant int argument should not have a name!");
     return new TreePatternNode(II, 1);
   }
 
-  if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) {
+  if (const BitsInit *BI = dynamic_cast<const BitsInit*>(TheInit)) {
     // Turn this into an IntInit.
-    Init *II = BI->convertInitializerTo(IntRecTy::get());
-    if (II == 0 || !dynamic_cast<IntInit*>(II))
+    const Init *II = BI->convertInitializerTo(IntRecTy::get());
+    if (II == 0 || !dynamic_cast<const IntInit*>(II))
       error("Bits value must be constants!");
     return ParseTreePattern(II, OpName);
   }
 
-  DagInit *Dag = dynamic_cast<DagInit*>(TheInit);
+  const DagInit *Dag = dynamic_cast<const DagInit*>(TheInit);
   if (!Dag) {
     TheInit->dump();
     error("Pattern has unexpected init kind!");
   }
-  DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
+  const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
   if (!OpDef) error("Pattern has unexpected operator type!");
   Record *Operator = OpDef->getDef();
 
@@ -1947,7 +1947,7 @@ InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) {
           // us to match things like:
           //  def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>;
           if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) {
-            DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue());
+            const DefInit *DI = dynamic_cast<const DefInit*>(Nodes[i]->getLeafValue());
             if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
                        DI->getDef()->isSubClassOf("RegisterOperand")))
               continue;
@@ -2096,7 +2096,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
 
   // First step, parse all of the fragments.
   for (unsigned i = 0, e = Fragments.size(); i != e; ++i) {
-    DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
+    const DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
     TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this);
     PatternFragments[Fragments[i]] = P;
 
@@ -2108,8 +2108,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
       P->error("Cannot have unnamed 'node' values in pattern fragment!");
 
     // Parse the operands list.
-    DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
-    DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator());
+    const DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
+    const DefInit *OpsOp = dynamic_cast<const DefInit*>(OpsList->getOperator());
     // Special cases: ops == outs == ins. Different names are used to
     // improve readability.
     if (!OpsOp ||
@@ -2121,8 +2121,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
     // Copy over the arguments.
     Args.clear();
     for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) {
-      if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) ||
-          static_cast<DefInit*>(OpsList->getArg(j))->
+      if (!dynamic_cast<const DefInit*>(OpsList->getArg(j)) ||
+          static_cast<const DefInit*>(OpsList->getArg(j))->
           getDef()->getName() != "node")
         P->error("Operands list should all be 'node' values.");
       if (OpsList->getArgName(j).empty())
@@ -2180,19 +2180,19 @@ void CodeGenDAGPatterns::ParseDefaultOperands() {
 
   // Find some SDNode.
   assert(!SDNodes.empty() && "No SDNodes parsed?");
-  Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
+  const Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
 
   for (unsigned iter = 0; iter != 2; ++iter) {
     for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) {
-      DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
+      const DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
 
       // Clone the DefaultInfo dag node, changing the operator from 'ops' to
       // SomeSDnode so that we can parse this.
-      std::vector<std::pair<Init*, std::string> > Ops;
+      std::vector<std::pair<const Init*, std::string> > Ops;
       for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op)
         Ops.push_back(std::make_pair(DefaultInfo->getArg(op),
                                      DefaultInfo->getArgName(op)));
-      DagInit *DI = new DagInit(SomeSDNode, "", Ops);
+      const DagInit *DI = new DagInit(SomeSDNode, "", Ops);
 
       // Create a TreePattern to parse this.
       TreePattern P(DefaultOps[iter][i], DI, false, *this);
@@ -2231,7 +2231,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
   // No name -> not interesting.
   if (Pat->getName().empty()) {
     if (Pat->isLeaf()) {
-      DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
+      const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
       if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
                  DI->getDef()->isSubClassOf("RegisterOperand")))
         I->error("Input " + DI->getDef()->getName() + " must be named!");
@@ -2241,7 +2241,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
 
   Record *Rec;
   if (Pat->isLeaf()) {
-    DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
+    const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
     if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!");
     Rec = DI->getDef();
   } else {
@@ -2259,7 +2259,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
   }
   Record *SlotRec;
   if (Slot->isLeaf()) {
-    SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef();
+    SlotRec = dynamic_cast<const DefInit*>(Slot->getLeafValue())->getDef();
   } else {
     assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
     SlotRec = Slot->getOperator();
@@ -2294,7 +2294,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
       if (!Dest->isLeaf())
         I->error("implicitly defined value should be a register!");
 
-      DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
+      const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
       if (!Val || !Val->getDef()->isSubClassOf("Register"))
         I->error("implicitly defined value should be a register!");
       InstImpResults.push_back(Val->getDef());
@@ -2335,7 +2335,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
     if (!Dest->isLeaf())
       I->error("set destination should be a register!");
 
-    DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
+    const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
     if (!Val)
       I->error("set destination should be a register!");
 
@@ -2401,7 +2401,7 @@ private:
       return false;
 
     const TreePatternNode *N0 = N->getChild(0);
-    if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue()))
+    if (!N0->isLeaf() || !dynamic_cast<const DefInit*>(N0->getLeafValue()))
       return false;
 
     const TreePatternNode *N1 = N->getChild(1);
@@ -2418,7 +2418,7 @@ private:
 
   void AnalyzeNode(const TreePatternNode *N) {
     if (N->isLeaf()) {
-      if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
+      if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
         Record *LeafRec = DI->getDef();
         // Handle ComplexPattern leaves.
         if (LeafRec->isSubClassOf("ComplexPattern")) {
@@ -2525,9 +2525,9 @@ void CodeGenDAGPatterns::ParseInstructions() {
   std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
 
   for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
-    ListInit *LI = 0;
+    const ListInit *LI = 0;
 
-    if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern")))
+    if (dynamic_cast<const ListInit*>(Instrs[i]->getValueInit("Pattern")))
       LI = Instrs[i]->getValueAsListInit("Pattern");
 
     // If there is no pattern, only collect minimal information about the
@@ -2619,7 +2619,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
 
       if (i == 0)
         Res0Node = RNode;
-      Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef();
+      Record *R = dynamic_cast<const DefInit*>(RNode->getLeafValue())->getDef();
       if (R == 0)
         I->error("Operand $" + OpName + " should be a set destination: all "
                  "outputs must occur before inputs in operand list!");
@@ -2664,8 +2664,8 @@ void CodeGenDAGPatterns::ParseInstructions() {
       InstInputsCheck.erase(OpName);   // It occurred, remove from map.
 
       if (InVal->isLeaf() &&
-          dynamic_cast<DefInit*>(InVal->getLeafValue())) {
-        Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
+          dynamic_cast<const DefInit*>(InVal->getLeafValue())) {
+        Record *InRec = static_cast<const DefInit*>(InVal->getLeafValue())->getDef();
         if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern"))
           I->error("Operand $" + OpName + "'s register class disagrees"
                    " between the operand and pattern");
@@ -2865,13 +2865,13 @@ void CodeGenDAGPatterns::ParsePatterns() {
 
   for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
     Record *CurPattern = Patterns[i];
-    DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
+    const DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
     TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this);
 
     // Inline pattern fragments into it.
     Pattern->InlinePatternFragments();
 
-    ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
+    const ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
     if (LI->getSize() == 0) continue;  // no pattern.
 
     // Parse the instruction.
@@ -3183,7 +3183,7 @@ static void GenerateVariantsOf(TreePatternNode *N,
     for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
       TreePatternNode *Child = N->getChild(i);
       if (Child->isLeaf())
-        if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
+        if (const DefInit *DI = dynamic_cast<const DefInit*>(Child->getLeafValue())) {
           Record *RR = DI->getDef();
           if (RR->isSubClassOf("Register"))
             continue;
diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h
index 936fd014645..833eef0653b 100644
--- a/utils/TableGen/CodeGenDAGPatterns.h
+++ b/utils/TableGen/CodeGenDAGPatterns.h
@@ -306,7 +306,7 @@ class TreePatternNode {
 
   /// Val - The init value (e.g. the "GPRC" record, or "7") for a leaf.
   ///
-  Init *Val;
+  const Init *Val;
 
   /// Name - The name given to this node with the :$foo notation.
   ///
@@ -327,7 +327,7 @@ public:
     : Operator(Op), Val(0), TransformFn(0), Children(Ch) {
     Types.resize(NumResults);
   }
-  TreePatternNode(Init *val, unsigned NumResults)    // leaf ctor
+  TreePatternNode(const Init *val, unsigned NumResults)    // leaf ctor
     : Operator(0), Val(val), TransformFn(0) {
     Types.resize(NumResults);
   }
@@ -358,7 +358,7 @@ public:
     return Types[ResNo].isDynamicallyResolved();
   }
 
-  Init *getLeafValue() const { assert(isLeaf()); return Val; }
+  const Init *getLeafValue() const { assert(isLeaf()); return Val; }
   Record *getOperator() const { assert(!isLeaf()); return Operator; }
 
   unsigned getNumChildren() const { return Children.size(); }
@@ -517,9 +517,9 @@ public:
 
   /// TreePattern constructor - Parse the specified DagInits into the
   /// current record.
-  TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
+  TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
               CodeGenDAGPatterns &ise);
-  TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
+  TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
               CodeGenDAGPatterns &ise);
   TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
               CodeGenDAGPatterns &ise);
@@ -576,7 +576,7 @@ public:
   void dump() const;
 
 private:
-  TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
+  TreePatternNode *ParseTreePattern(const Init *DI, StringRef OpName);
   void ComputeNamedNodes();
   void ComputeNamedNodes(TreePatternNode *N);
 };
@@ -631,7 +631,7 @@ public:
 /// processed to produce isel.
 class PatternToMatch {
 public:
-  PatternToMatch(Record *srcrecord, ListInit *preds,
+  PatternToMatch(Record *srcrecord, const ListInit *preds,
                  TreePatternNode *src, TreePatternNode *dst,
                  const std::vector<Record*> &dstregs,
                  unsigned complexity, unsigned uid)
@@ -639,7 +639,7 @@ public:
       Dstregs(dstregs), AddedComplexity(complexity), ID(uid) {}
 
   Record          *SrcRecord;   // Originating Record for the pattern.
-  ListInit        *Predicates;  // Top level predicate conditions to match.
+  const ListInit        *Predicates;  // Top level predicate conditions to match.
   TreePatternNode *SrcPattern;  // Source pattern to match.
   TreePatternNode *DstPattern;  // Resulting pattern.
   std::vector<Record*> Dstregs; // Physical register defs being matched.
@@ -647,7 +647,7 @@ public:
   unsigned         ID;          // Unique ID for the record.
 
   Record          *getSrcRecord()  const { return SrcRecord; }
-  ListInit        *getPredicates() const { return Predicates; }
+  const ListInit        *getPredicates() const { return Predicates; }
   TreePatternNode *getSrcPattern() const { return SrcPattern; }
   TreePatternNode *getDstPattern() const { return DstPattern; }
   const std::vector<Record*> &getDstRegs() const { return Dstregs; }
diff --git a/utils/TableGen/CodeGenInstruction.cpp b/utils/TableGen/CodeGenInstruction.cpp
index 86a377b7a8a..fdeb5073ec2 100644
--- a/utils/TableGen/CodeGenInstruction.cpp
+++ b/utils/TableGen/CodeGenInstruction.cpp
@@ -30,9 +30,9 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
   hasOptionalDef = false;
   isVariadic = false;
 
-  DagInit *OutDI = R->getValueAsDag("OutOperandList");
+  const DagInit *OutDI = R->getValueAsDag("OutOperandList");
 
-  if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) {
+  if (const DefInit *Init = dynamic_cast<const DefInit*>(OutDI->getOperator())) {
     if (Init->getDef()->getName() != "outs")
       throw R->getName() + ": invalid def name for output list: use 'outs'";
   } else
@@ -40,8 +40,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
 
   NumDefs = OutDI->getNumArgs();
 
-  DagInit *InDI = R->getValueAsDag("InOperandList");
-  if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) {
+  const DagInit *InDI = R->getValueAsDag("InOperandList");
+  if (const DefInit *Init = dynamic_cast<const DefInit*>(InDI->getOperator())) {
     if (Init->getDef()->getName() != "ins")
       throw R->getName() + ": invalid def name for input list: use 'ins'";
   } else
@@ -50,7 +50,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
   unsigned MIOperandNo = 0;
   std::set<std::string> OperandNames;
   for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){
-    Init *ArgInit;
+    const Init *ArgInit;
     std::string ArgName;
     if (i < NumDefs) {
       ArgInit = OutDI->getArg(i);
@@ -60,7 +60,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
       ArgName = InDI->getArgName(i-NumDefs);
     }
 
-    DefInit *Arg = dynamic_cast<DefInit*>(ArgInit);
+    const DefInit *Arg = dynamic_cast<const DefInit*>(ArgInit);
     if (!Arg)
       throw "Illegal operand for the '" + R->getName() + "' instruction!";
 
@@ -69,7 +69,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
     std::string EncoderMethod;
     std::string OperandType = "OPERAND_UNKNOWN";
     unsigned NumOps = 1;
-    DagInit *MIOpInfo = 0;
+    const DagInit *MIOpInfo = 0;
     if (Rec->isSubClassOf("RegisterOperand")) {
       PrintMethod = Rec->getValueAsString("PrintMethod");
     } else if (Rec->isSubClassOf("Operand")) {
@@ -80,8 +80,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
       MIOpInfo = Rec->getValueAsDag("MIOperandInfo");
 
       // Verify that MIOpInfo has an 'ops' root value.
-      if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) ||
-          dynamic_cast<DefInit*>(MIOpInfo->getOperator())
+      if (!dynamic_cast<const DefInit*>(MIOpInfo->getOperator()) ||
+          dynamic_cast<const DefInit*>(MIOpInfo->getOperator())
           ->getDef()->getName() != "ops")
         throw "Bad value for MIOperandInfo in operand '" + Rec->getName() +
         "'\n";
@@ -182,7 +182,7 @@ CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) {
   }
 
   // Find the suboperand number involved.
-  DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
+  const DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
   if (MIOpInfo == 0)
     throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'";
 
@@ -405,12 +405,12 @@ FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
 /// constructor.  It checks if an argument in an InstAlias pattern matches
 /// the corresponding operand of the instruction.  It returns true on a
 /// successful match, with ResOp set to the result operand to be used.
-bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
+bool CodeGenInstAlias::tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo,
                                        Record *InstOpRec, bool hasSubOps,
                                        SMLoc Loc, CodeGenTarget &T,
                                        ResultOperand &ResOp) {
-  Init *Arg = Result->getArg(AliasOpNo);
-  DefInit *ADI = dynamic_cast<DefInit*>(Arg);
+  const Init *Arg = Result->getArg(AliasOpNo);
+  const DefInit *ADI = dynamic_cast<const DefInit*>(Arg);
 
   if (ADI && ADI->getDef() == InstOpRec) {
     // If the operand is a record, it must have a name, and the record type
@@ -456,7 +456,7 @@ bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
     return true;
   }
 
-  if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
+  if (const IntInit *II = dynamic_cast<const IntInit*>(Arg)) {
     if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
       return false;
     // Integer arguments can't have names.
@@ -475,7 +475,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
   Result = R->getValueAsDag("ResultInst");
 
   // Verify that the root of the result is an instruction.
-  DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator());
+  const DefInit *DI = dynamic_cast<const DefInit*>(Result->getOperator());
   if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction"))
     throw TGError(R->getLoc(), "result of inst alias should be an instruction");
 
@@ -485,7 +485,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
   // the same class.
   StringMap<Record*> NameClass;
   for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) {
-    DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i));
+    const DefInit *ADI = dynamic_cast<const DefInit*>(Result->getArg(i));
     if (!ADI || Result->getArgName(i).empty())
       continue;
     // Verify we don't have something like: (someinst GR16:$foo, GR32:$foo)
@@ -524,11 +524,11 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
     // If the argument did not match the instruction operand, and the operand
     // is composed of multiple suboperands, try matching the suboperands.
     if (NumSubOps > 1) {
-      DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
+      const DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
       for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
         if (AliasOpNo >= Result->getNumArgs())
           throw TGError(R->getLoc(), "not enough arguments for instruction!");
-        Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef();
+        Record *SubRec = dynamic_cast<const DefInit*>(MIOI->getArg(SubOp))->getDef();
         if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false,
                             R->getLoc(), T, ResOp)) {
           ResultOperands.push_back(ResOp);
diff --git a/utils/TableGen/CodeGenInstruction.h b/utils/TableGen/CodeGenInstruction.h
index 8d7669aca98..5cbe1400e79 100644
--- a/utils/TableGen/CodeGenInstruction.h
+++ b/utils/TableGen/CodeGenInstruction.h
@@ -98,7 +98,7 @@ namespace llvm {
 
       /// MIOperandInfo - Default MI operand type. Note an operand may be made
       /// up of multiple MI operands.
-      DagInit *MIOperandInfo;
+      const DagInit *MIOperandInfo;
 
       /// Constraint info for this operand.  This operand can have pieces, so we
       /// track constraint info for each.
@@ -106,7 +106,7 @@ namespace llvm {
 
       OperandInfo(Record *R, const std::string &N, const std::string &PMN,
                   const std::string &EMN, const std::string &OT, unsigned MION,
-                  unsigned MINO, DagInit *MIOI)
+                  unsigned MINO, const DagInit *MIOI)
       : Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
         OperandType(OT), MIOperandNo(MION), MINumOperands(MINO),
         MIOperandInfo(MIOI) {}
@@ -270,7 +270,7 @@ namespace llvm {
     std::string AsmString;
 
     /// Result - The result instruction.
-    DagInit *Result;
+    const DagInit *Result;
 
     /// ResultInst - The instruction generated by the alias (decoded from
     /// Result).
@@ -316,7 +316,7 @@ namespace llvm {
 
     CodeGenInstAlias(Record *R, CodeGenTarget &T);
 
-    bool tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
+    bool tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo,
                          Record *InstOpRec, bool hasSubOps, SMLoc Loc,
                          CodeGenTarget &T, ResultOperand &ResOp);
   };
diff --git a/utils/TableGen/CodeGenRegisters.cpp b/utils/TableGen/CodeGenRegisters.cpp
index d7816c2c281..298009edc80 100644
--- a/utils/TableGen/CodeGenRegisters.cpp
+++ b/utils/TableGen/CodeGenRegisters.cpp
@@ -91,14 +91,14 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) {
   }
 
   // Process the composites.
-  ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
+  const ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
   for (unsigned i = 0, e = Comps->size(); i != e; ++i) {
-    DagInit *Pat = dynamic_cast<DagInit*>(Comps->getElement(i));
+    const DagInit *Pat = dynamic_cast<const DagInit*>(Comps->getElement(i));
     if (!Pat)
       throw TGError(TheDef->getLoc(), "Invalid dag '" +
                     Comps->getElement(i)->getAsString() +
                     "' in CompositeIndices");
-    DefInit *BaseIdxInit = dynamic_cast<DefInit*>(Pat->getOperator());
+    const DefInit *BaseIdxInit = dynamic_cast<const DefInit*>(Pat->getOperator());
     if (!BaseIdxInit || !BaseIdxInit->getDef()->isSubClassOf("SubRegIndex"))
       throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
                     Pat->getAsString());
@@ -107,7 +107,7 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) {
     CodeGenRegister *R2 = this;
     for (DagInit::const_arg_iterator di = Pat->arg_begin(),
          de = Pat->arg_end(); di != de; ++di) {
-      DefInit *IdxInit = dynamic_cast<DefInit*>(*di);
+      const DefInit *IdxInit = dynamic_cast<const DefInit*>(*di);
       if (!IdxInit || !IdxInit->getDef()->isSubClassOf("SubRegIndex"))
         throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
                       Pat->getAsString());
@@ -163,7 +163,7 @@ struct TupleExpander : SetTheory::Expander {
   void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) {
     std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices");
     unsigned Dim = Indices.size();
-    ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
+    const ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
     if (Dim != SubRegs->getSize())
       throw TGError(Def->getLoc(), "SubRegIndices and SubRegs size mismatch");
     if (Dim < 2)
@@ -183,13 +183,13 @@ struct TupleExpander : SetTheory::Expander {
     // Precompute some types.
     Record *RegisterCl = Def->getRecords().getClass("Register");
     RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl);
-    StringInit *BlankName = new StringInit("");
+    const StringInit *BlankName = new StringInit("");
 
     // Zip them up.
     for (unsigned n = 0; n != Length; ++n) {
       std::string Name;
       Record *Proto = Lists[0][n];
-      std::vector<Init*> Tuple;
+      std::vector<const Init*> Tuple;
       unsigned CostPerUse = 0;
       for (unsigned i = 0; i != Dim; ++i) {
         Record *Reg = Lists[i][n];
@@ -278,7 +278,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
     Members.insert(RegBank.getReg((*Elements)[i]));
 
   // Alternative allocation orders may be subsets.
-  ListInit *Alts = R->getValueAsListInit("AltOrders");
+  const ListInit *Alts = R->getValueAsListInit("AltOrders");
   AltOrders.resize(Alts->size());
   SetTheory::RecSet Order;
   for (unsigned i = 0, e = Alts->size(); i != e; ++i) {
@@ -295,11 +295,11 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
   }
 
   // SubRegClasses is a list<dag> containing (RC, subregindex, ...) dags.
-  ListInit *SRC = R->getValueAsListInit("SubRegClasses");
+  const ListInit *SRC = R->getValueAsListInit("SubRegClasses");
   for (ListInit::const_iterator i = SRC->begin(), e = SRC->end(); i != e; ++i) {
-    DagInit *DAG = dynamic_cast<DagInit*>(*i);
+    const DagInit *DAG = dynamic_cast<const DagInit*>(*i);
     if (!DAG) throw "SubRegClasses must contain DAGs";
-    DefInit *DAGOp = dynamic_cast<DefInit*>(DAG->getOperator());
+    const DefInit *DAGOp = dynamic_cast<const DefInit*>(DAG->getOperator());
     Record *RCRec;
     if (!DAGOp || !(RCRec = DAGOp->getDef())->isSubClassOf("RegisterClass"))
       throw "Operator '" + DAG->getOperator()->getAsString() +
@@ -307,7 +307,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
     // Iterate over args, all SubRegIndex instances.
     for (DagInit::const_arg_iterator ai = DAG->arg_begin(), ae = DAG->arg_end();
          ai != ae; ++ai) {
-      DefInit *Idx = dynamic_cast<DefInit*>(*ai);
+      const DefInit *Idx = dynamic_cast<const DefInit*>(*ai);
       Record *IdxRec;
       if (!Idx || !(IdxRec = Idx->getDef())->isSubClassOf("SubRegIndex"))
         throw "Argument '" + (*ai)->getAsString() +
diff --git a/utils/TableGen/CodeGenTarget.cpp b/utils/TableGen/CodeGenTarget.cpp
index 929791c3182..ceaa82fa05b 100644
--- a/utils/TableGen/CodeGenTarget.cpp
+++ b/utils/TableGen/CodeGenTarget.cpp
@@ -402,7 +402,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
 
   // Parse the list of return types.
   std::vector<MVT::SimpleValueType> OverloadedVTs;
-  ListInit *TypeList = R->getValueAsListInit("RetTypes");
+  const ListInit *TypeList = R->getValueAsListInit("RetTypes");
   for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
     Record *TyEl = TypeList->getElementAsRecord(i);
     assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
@@ -470,7 +470,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
   }
 
   // Parse the intrinsic properties.
-  ListInit *PropList = R->getValueAsListInit("Properties");
+  const ListInit *PropList = R->getValueAsListInit("Properties");
   for (unsigned i = 0, e = PropList->getSize(); i != e; ++i) {
     Record *Property = PropList->getElementAsRecord(i);
     assert(Property->isSubClassOf("IntrinsicProperty") &&
diff --git a/utils/TableGen/DAGISelMatcherGen.cpp b/utils/TableGen/DAGISelMatcherGen.cpp
index c5897c72d36..7e66c05a934 100644
--- a/utils/TableGen/DAGISelMatcherGen.cpp
+++ b/utils/TableGen/DAGISelMatcherGen.cpp
@@ -203,7 +203,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
   assert(N->isLeaf() && "Not a leaf?");
 
   // Direct match against an integer constant.
-  if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
+  if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
     // If this is the root of the dag we're matching, we emit a redundant opcode
     // check to ensure that this gets folded into the normal top-level
     // OpcodeSwitch.
@@ -215,7 +215,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
     return AddMatcher(new CheckIntegerMatcher(II->getValue()));
   }
 
-  DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue());
+  const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue());
   if (DI == 0) {
     errs() << "Unknown leaf kind: " << *DI << "\n";
     abort();
@@ -283,7 +283,7 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
        N->getOperator()->getName() == "or") &&
       N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() &&
       N->getPredicateFns().empty()) {
-    if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) {
+    if (const IntInit *II = dynamic_cast<const IntInit*>(N->getChild(1)->getLeafValue())) {
       if (!isPowerOf2_32(II->getValue())) {  // Don't bother with single bits.
         // If this is at the root of the pattern, we emit a redundant
         // CheckOpcode so that the following checks get factored properly under
@@ -496,7 +496,7 @@ bool MatcherGen::EmitMatcherCode(unsigned Variant) {
     --RecNodeEntry;  // Entries in VariableMap are biased.
 
     const ComplexPattern &CP =
-      CGP.getComplexPattern(((DefInit*)N->getLeafValue())->getDef());
+      CGP.getComplexPattern(((const DefInit*)N->getLeafValue())->getDef());
 
     // Emit a CheckComplexPat operation, which does the match (aborting if it
     // fails) and pushes the matched operands onto the recorded nodes list.
@@ -572,14 +572,14 @@ void MatcherGen::EmitResultLeafAsOperand(const TreePatternNode *N,
                                          SmallVectorImpl<unsigned> &ResultOps) {
   assert(N->isLeaf() && "Must be a leaf");
 
-  if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
+  if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
     AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0)));
     ResultOps.push_back(NextRecordedOperandNo++);
     return;
   }
 
   // If this is an explicit register reference, handle it.
-  if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
+  if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
     Record *Def = DI->getDef();
     if (Def->isSubClassOf("Register")) {
       const CodeGenRegister *Reg =
diff --git a/utils/TableGen/FastISelEmitter.cpp b/utils/TableGen/FastISelEmitter.cpp
index f54e8df40f2..2a86b896c0c 100644
--- a/utils/TableGen/FastISelEmitter.cpp
+++ b/utils/TableGen/FastISelEmitter.cpp
@@ -241,7 +241,7 @@ struct OperandsSignature {
       if (Op->getType(0) != VT)
         return false;
 
-      DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
+      const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
       if (!OpDI)
         return false;
       Record *OpLeafRec = OpDI->getDef();
@@ -401,12 +401,12 @@ static std::string PhyRegForNode(TreePatternNode *Op,
   if (!Op->isLeaf())
     return PhysReg;
 
-  DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
+  const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
   Record *OpLeafRec = OpDI->getDef();
   if (!OpLeafRec->isSubClassOf("Register"))
     return PhysReg;
 
-  PhysReg += static_cast<StringInit*>(OpLeafRec->getValue( \
+  PhysReg += static_cast<const StringInit*>(OpLeafRec->getValue( \
              "Namespace")->getValue())->getValue();
   PhysReg += "::";
   PhysReg += Target.getRegBank().getReg(OpLeafRec)->getName();
@@ -468,7 +468,7 @@ void FastISelMap::collectPatterns(CodeGenDAGPatterns &CGP) {
       // a bit too complicated for now.
       if (!Dst->getChild(1)->isLeaf()) continue;
 
-      DefInit *SR = dynamic_cast<DefInit*>(Dst->getChild(1)->getLeafValue());
+      const DefInit *SR = dynamic_cast<const DefInit*>(Dst->getChild(1)->getLeafValue());
       if (SR)
         SubRegNo = getQualifiedName(SR->getDef());
       else
diff --git a/utils/TableGen/FixedLenDecoderEmitter.cpp b/utils/TableGen/FixedLenDecoderEmitter.cpp
index 80910032886..c2540692103 100644
--- a/utils/TableGen/FixedLenDecoderEmitter.cpp
+++ b/utils/TableGen/FixedLenDecoderEmitter.cpp
@@ -48,15 +48,15 @@ static bool ValueNotSet(bit_value_t V) {
 static int Value(bit_value_t V) {
   return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
 }
-static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
-  if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
+static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
+  if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
     return bit->getValue() ? BIT_TRUE : BIT_FALSE;
 
   // The bit is uninitialized.
   return BIT_UNSET;
 }
 // Prints the bit value for each position.
-static void dumpBits(raw_ostream &o, BitsInit &bits) {
+static void dumpBits(raw_ostream &o, const BitsInit &bits) {
   unsigned index;
 
   for (index = bits.getNumBits(); index > 0; index--) {
@@ -76,8 +76,8 @@ static void dumpBits(raw_ostream &o, BitsInit &bits) {
   }
 }
 
-static BitsInit &getBitsField(const Record &def, const char *str) {
-  BitsInit *bits = def.getValueAsBitsInit(str);
+static const BitsInit &getBitsField(const Record &def, const char *str) {
+  const BitsInit *bits = def.getValueAsBitsInit(str);
   return *bits;
 }
 
@@ -277,7 +277,7 @@ public:
 protected:
   // Populates the insn given the uid.
   void insnWithID(insn_t &Insn, unsigned Opcode) const {
-    BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
+    const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
 
     for (unsigned i = 0; i < BitWidth; ++i)
       Insn.push_back(bitFromBits(Bits, i));
@@ -1194,7 +1194,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
       Def.getValueAsBit("isCodeGenOnly"))
     return false;
 
-  BitsInit &Bits = getBitsField(Def, "Inst");
+  const BitsInit &Bits = getBitsField(Def, "Inst");
   if (Bits.allInComplete()) return false;
 
   std::vector<OperandInfo> InsnOperands;
@@ -1215,9 +1215,9 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
   // Gather the outputs/inputs of the instruction, so we can find their
   // positions in the encoding.  This assumes for now that they appear in the
   // MCInst in the order that they're listed.
-  std::vector<std::pair<Init*, std::string> > InOutOperands;
-  DagInit *Out  = Def.getValueAsDag("OutOperandList");
-  DagInit *In  = Def.getValueAsDag("InOperandList");
+  std::vector<std::pair<const Init*, std::string> > InOutOperands;
+  const DagInit *Out  = Def.getValueAsDag("OutOperandList");
+  const DagInit *In  = Def.getValueAsDag("InOperandList");
   for (unsigned i = 0; i < Out->getNumArgs(); ++i)
     InOutOperands.push_back(std::make_pair(Out->getArg(i), Out->getArgName(i)));
   for (unsigned i = 0; i < In->getNumArgs(); ++i)
@@ -1235,7 +1235,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
   }
 
   // For each operand, see if we can figure out where it is encoded.
-  for (std::vector<std::pair<Init*, std::string> >::iterator
+  for (std::vector<std::pair<const Init*, std::string> >::iterator
        NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) {
     std::string Decoder = "";
 
@@ -1244,7 +1244,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
     // for decoding register classes.
     // FIXME: This need to be extended to handle instructions with custom
     // decoder methods, and operands with (simple) MIOperandInfo's.
-    TypedInit *TI = dynamic_cast<TypedInit*>(NI->first);
+    const TypedInit *TI = dynamic_cast<const TypedInit*>(NI->first);
     RecordRecTy *Type = dynamic_cast<RecordRecTy*>(TI->getType());
     Record *TypeRecord = Type->getRecord();
     bool isReg = false;
@@ -1256,8 +1256,8 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
     }
 
     RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
-    StringInit *String = DecoderString ?
-      dynamic_cast<StringInit*>(DecoderString->getValue()) : 0;
+    const StringInit *String = DecoderString ?
+      dynamic_cast<const StringInit*>(DecoderString->getValue()) : 0;
     if (!isReg && String && String->getValue() != "")
       Decoder = String->getValue();
 
@@ -1267,7 +1267,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
     unsigned Offset = 0;
 
     for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
-      VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi));
+      const VarBitInit *BI = dynamic_cast<const VarBitInit*>(Bits.getBit(bi));
       if (!BI) {
         if (Base != ~0U) {
           OpInfo.addField(Base, Width, Offset);
@@ -1277,8 +1277,9 @@ static bool populateInstruction(const CodeGenInstruction &CGI,
         }
         continue;
       }
+      if (!BI) continue;
 
-      VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
+      const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
       assert(Var);
       if (Var->getName() != NI->second &&
           Var->getName() != TiedNames[NI->second]) {
diff --git a/utils/TableGen/InstrInfoEmitter.cpp b/utils/TableGen/InstrInfoEmitter.cpp
index 5ebaf174655..5004a992286 100644
--- a/utils/TableGen/InstrInfoEmitter.cpp
+++ b/utils/TableGen/InstrInfoEmitter.cpp
@@ -61,7 +61,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) {
     // registers in their multi-operand operands.  It may also be an anonymous
     // operand, which has a single operand, but no declared class for the
     // operand.
-    DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
+    const DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
 
     if (!MIOI || MIOI->getNumArgs() == 0) {
       // Single, anonymous, operand.
@@ -70,7 +70,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) {
       for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) {
         OperandList.push_back(Inst.Operands[i]);
 
-        Record *OpR = dynamic_cast<DefInit*>(MIOI->getArg(j))->getDef();
+        Record *OpR = dynamic_cast<const DefInit*>(MIOI->getArg(j))->getDef();
         OperandList.back().Rec = OpR;
       }
     }
@@ -295,11 +295,11 @@ void InstrInfoEmitter::emitRecord(const CodeGenInstruction &Inst, unsigned Num,
   if (Inst.hasExtraDefRegAllocReq) OS << "|(1<<MCID::ExtraDefRegAllocReq)";
 
   // Emit all of the target-specific flags...
-  BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
+  const BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
   if (!TSF) throw "no TSFlags?";
   uint64_t Value = 0;
   for (unsigned i = 0, e = TSF->getNumBits(); i != e; ++i) {
-    if (BitInit *Bit = dynamic_cast<BitInit*>(TSF->getBit(i)))
+    if (const BitInit *Bit = dynamic_cast<const BitInit*>(TSF->getBit(i)))
       Value |= uint64_t(Bit->getValue()) << i;
     else
       throw "Invalid TSFlags bit in " + Inst.TheDef->getName();
diff --git a/utils/TableGen/LLVMCConfigurationEmitter.cpp b/utils/TableGen/LLVMCConfigurationEmitter.cpp
index cd0cbeb1c6b..563a72789d2 100644
--- a/utils/TableGen/LLVMCConfigurationEmitter.cpp
+++ b/utils/TableGen/LLVMCConfigurationEmitter.cpp
@@ -245,7 +245,7 @@ struct OptionDescription {
   unsigned Flags;
   std::string Help;
   unsigned MultiVal;
-  Init* InitVal;
+  const Init* InitVal;
 
   OptionDescription(OptionType::OptionType t = OptionType::Switch,
                     const std::string& n = "",
@@ -589,7 +589,7 @@ Handler GetHandler(FunctionObject* Obj, const DagInit& Dag) {
 }
 
 template <class FunctionObject>
-void InvokeDagInitHandler(FunctionObject* Obj, Init* I) {
+void InvokeDagInitHandler(FunctionObject* Obj, const Init* I) {
   typedef void (FunctionObject::*Handler) (const DagInit&);
 
   const DagInit& Dag = InitPtrToDag(I);
@@ -658,7 +658,7 @@ public:
 
   /// operator() - Just forwards to the corresponding property
   /// handler.
-  void operator() (Init* I) {
+  void operator() (const Init* I) {
     InvokeDagInitHandler(this, I);
   }
 
@@ -705,10 +705,10 @@ private:
 
   void onInit (const DagInit& d) {
     CheckNumberOfArguments(d, 1);
-    Init* i = d.getArg(0);
+    const Init* i = d.getArg(0);
     const std::string& str = i->getAsString();
 
-    bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
+    bool correct = optDesc_.isParameter() && dynamic_cast<const StringInit*>(i);
     correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
 
     if (!correct)
@@ -821,7 +821,7 @@ void CollectOptionDescriptions (const RecordVector& V,
   for (RecordVector::const_iterator B = V.begin(), E = V.end(); B!=E; ++B)
   {
     // Throws an exception if the value does not exist.
-    ListInit* PropList = (*B)->getValueAsListInit("options");
+    const ListInit* PropList = (*B)->getValueAsListInit("options");
 
     // For every option description in this list: invoke AddOption.
     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
@@ -836,8 +836,8 @@ namespace ToolFlags {
 
 struct ToolDescription : public RefCountedBase<ToolDescription> {
   std::string Name;
-  Init* CmdLine;
-  Init* Actions;
+  const Init* CmdLine;
+  const Init* Actions;
   StrVector InLanguage;
   std::string InFileOption;
   std::string OutFileOption;
@@ -903,7 +903,7 @@ public:
     }
   }
 
-  void operator() (Init* I) {
+  void operator() (const Init* I) {
     InvokeDagInitHandler(this, I);
   }
 
@@ -915,9 +915,9 @@ private:
 
   void onActions (const DagInit& d) {
     CheckNumberOfArguments(d, 1);
-    Init* Case = d.getArg(0);
+    const Init* Case = d.getArg(0);
     if (typeid(*Case) != typeid(DagInit) ||
-        GetOperatorName(static_cast<DagInit&>(*Case)) != "case")
+        GetOperatorName(static_cast<const DagInit&>(*Case)) != "case")
       throw "The argument to (actions) should be a 'case' construct!";
     toolDesc_.Actions = Case;
   }
@@ -954,7 +954,7 @@ private:
       isReallyJoin = true;
     }
     else {
-      Init* I = d.getArg(0);
+      const Init* I = d.getArg(0);
       isReallyJoin = InitPtrToBool(I);
     }
 
@@ -1007,7 +1007,7 @@ void CollectToolDescriptions (const RecordVector& Tools,
          E = Tools.end(); B!=E; ++B) {
     const Record* T = *B;
     // Throws an exception if the value does not exist.
-    ListInit* PropList = T->getValueAsListInit("properties");
+    const ListInit* PropList = T->getValueAsListInit("properties");
 
     IntrusiveRefCntPtr<ToolDescription>
       ToolDesc(new ToolDescription(T->getName()));
@@ -1163,7 +1163,7 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
   unsigned i = 1;
   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
        B != E; ++B) {
-    Init* arg = *B;
+    const Init* arg = *B;
 
     if (!even)
     {
@@ -1181,8 +1181,8 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
     }
     else
     {
-      if (dynamic_cast<DagInit*>(arg)
-          && GetOperatorName(static_cast<DagInit&>(*arg)) == "case") {
+      if (dynamic_cast<const DagInit*>(arg)
+          && GetOperatorName(static_cast<const DagInit&>(*arg)) == "case") {
         // Nested 'case'.
         WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1);
       }
@@ -1210,7 +1210,7 @@ class ExtractOptionNames {
         ActionName == "parameter_equals" || ActionName == "element_in_list") {
       CheckNumberOfArguments(Stmt, 1);
 
-      Init* Arg = Stmt.getArg(0);
+      const Init* Arg = Stmt.getArg(0);
       if (typeid(*Arg) == typeid(StringInit))
         OptionNames_.insert(InitPtrToString(Arg));
     }
@@ -1218,7 +1218,7 @@ class ExtractOptionNames {
              ActionName == "any_not_empty" || ActionName == "any_empty" ||
              ActionName == "not_empty" || ActionName == "empty") {
       for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
-        Init* Arg = Stmt.getArg(i);
+        const Init* Arg = Stmt.getArg(i);
         if (typeid(*Arg) == typeid(StringInit))
           OptionNames_.insert(InitPtrToString(Arg));
       }
@@ -2613,7 +2613,7 @@ void EmitPreprocessOptions (const RecordKeeper& Records,
 
   for (RecordVector::const_iterator B = OptionPreprocessors.begin(),
          E = OptionPreprocessors.end(); B!=E; ++B) {
-    DagInit* Case = (*B)->getValueAsDag("preprocessor");
+    const DagInit* Case = (*B)->getValueAsDag("preprocessor");
     EmitCaseConstructHandler(Case, Indent1,
                              EmitPreprocessOptionsCallback(OptDecs),
                              false, OptDecs, O);
@@ -2645,7 +2645,7 @@ public:
     }
   }
 
-  void operator() (Init* I) {
+  void operator() (const Init* I) {
     InvokeDagInitHandler(this, I);
   }
 
@@ -2655,7 +2655,7 @@ private:
     CheckNumberOfArguments(d, 2);
 
     const std::string& Lang = InitPtrToString(d.getArg(0));
-    Init* Suffixes = d.getArg(1);
+    const Init* Suffixes = d.getArg(1);
 
     // Second argument to lang_to_suffixes is either a single string...
     if (typeid(*Suffixes) == typeid(StringInit)) {
@@ -2688,7 +2688,7 @@ void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
   // Call DoEmitPopulateLanguageMap.
   for (RecordVector::const_iterator B = LangMaps.begin(),
          E = LangMaps.end(); B!=E; ++B) {
-    ListInit* LangMap = (*B)->getValueAsListInit("map");
+    const ListInit* LangMap = (*B)->getValueAsListInit("map");
     std::for_each(LangMap->begin(), LangMap->end(),
                   DoEmitPopulateLanguageMap(O));
   }
@@ -2947,7 +2947,7 @@ void FillInHookNames(const ToolDescriptions& ToolDescs,
     // Look for hook invocations in 'cmd_line'.
     if (!D.CmdLine)
       continue;
-    if (dynamic_cast<StringInit*>(D.CmdLine))
+    if (dynamic_cast<const StringInit*>(D.CmdLine))
       // This is a string.
       ExtractHookNames(HookNames, OptDescs).operator()(D.CmdLine);
     else
diff --git a/utils/TableGen/OptParserEmitter.cpp b/utils/TableGen/OptParserEmitter.cpp
index 431026c669c..f4d7be52db9 100644
--- a/utils/TableGen/OptParserEmitter.cpp
+++ b/utils/TableGen/OptParserEmitter.cpp
@@ -56,7 +56,7 @@ static int CompareOptionRecords(const void *Av, const void *Bv) {
 
 static const std::string getOptionName(const Record &R) {
   // Use the record name unless EnumName is defined.
-  if (dynamic_cast<UnsetInit*>(R.getValueInit("EnumName")))
+  if (dynamic_cast<const UnsetInit*>(R.getValueInit("EnumName")))
     return R.getName();
 
   return R.getValueAsString("EnumName");
@@ -105,7 +105,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
 
       // The containing option group (if any).
       OS << ", ";
-      if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
+      if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
         OS << getOptionName(*DI->getDef());
       else
         OS << "INVALID";
@@ -114,7 +114,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
       OS << ", INVALID, 0, 0";
 
       // The option help text.
-      if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
+      if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
         OS << ",\n";
         OS << "       ";
         write_cstring(OS, R.getValueAsString("HelpText"));
@@ -145,14 +145,14 @@ void OptParserEmitter::run(raw_ostream &OS) {
 
       // The containing option group (if any).
       OS << ", ";
-      if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
+      if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
         OS << getOptionName(*DI->getDef());
       else
         OS << "INVALID";
 
       // The option alias (if any).
       OS << ", ";
-      if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Alias")))
+      if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Alias")))
         OS << getOptionName(*DI->getDef());
       else
         OS << "INVALID";
@@ -166,7 +166,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
         for (unsigned i = 0, e = LI->size(); i != e; ++i) {
           if (i)
             OS << " | ";
-          OS << dynamic_cast<DefInit*>(LI->getElement(i))->getDef()->getName();
+          OS << dynamic_cast<const DefInit*>(LI->getElement(i))->getDef()->getName();
         }
       }
 
@@ -174,7 +174,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
       OS << ", " << R.getValueAsInt("NumArgs");
 
       // The option help text.
-      if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
+      if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
         OS << ",\n";
         OS << "       ";
         write_cstring(OS, R.getValueAsString("HelpText"));
@@ -183,7 +183,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
 
       // The option meta-variable name.
       OS << ", ";
-      if (!dynamic_cast<UnsetInit*>(R.getValueInit("MetaVarName")))
+      if (!dynamic_cast<const UnsetInit*>(R.getValueInit("MetaVarName")))
         write_cstring(OS, R.getValueAsString("MetaVarName"));
       else
         OS << "0";
diff --git a/utils/TableGen/PseudoLoweringEmitter.cpp b/utils/TableGen/PseudoLoweringEmitter.cpp
index db33c1f7f68..5cfa587f1d9 100644
--- a/utils/TableGen/PseudoLoweringEmitter.cpp
+++ b/utils/TableGen/PseudoLoweringEmitter.cpp
@@ -24,11 +24,11 @@ using namespace llvm;
 //        a single dag, so we can do fancier things.
 
 unsigned PseudoLoweringEmitter::
-addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
+addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn,
                      IndexedMap<OpData> &OperandMap, unsigned BaseIdx) {
   unsigned OpsAdded = 0;
   for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
-    if (DefInit *DI = dynamic_cast<DefInit*>(Dag->getArg(i))) {
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(Dag->getArg(i))) {
       // Physical register reference. Explicit check for the special case
       // "zero_reg" definition.
       if (DI->getDef()->isSubClassOf("Register") ||
@@ -54,11 +54,11 @@ addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
       for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
         OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
       OpsAdded += Insn.Operands[i].MINumOperands;
-    } else if (IntInit *II = dynamic_cast<IntInit*>(Dag->getArg(i))) {
+    } else if (const IntInit *II = dynamic_cast<const IntInit*>(Dag->getArg(i))) {
       OperandMap[BaseIdx + i].Kind = OpData::Imm;
       OperandMap[BaseIdx + i].Data.Imm = II->getValue();
       ++OpsAdded;
-    } else if (DagInit *SubDag = dynamic_cast<DagInit*>(Dag->getArg(i))) {
+    } else if (const DagInit *SubDag = dynamic_cast<const DagInit*>(Dag->getArg(i))) {
       // Just add the operands recursively. This is almost certainly
       // a constant value for a complex operand (> 1 MI operand).
       unsigned NewOps =
@@ -77,11 +77,11 @@ void PseudoLoweringEmitter::evaluateExpansion(Record *Rec) {
 
   // Validate that the result pattern has the corrent number and types
   // of arguments for the instruction it references.
-  DagInit *Dag = Rec->getValueAsDag("ResultInst");
+  const DagInit *Dag = Rec->getValueAsDag("ResultInst");
   assert(Dag && "Missing result instruction in pseudo expansion!");
   DEBUG(dbgs() << "  Result: " << *Dag << "\n");
 
-  DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
+  const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
   if (!OpDef)
     throw TGError(Rec->getLoc(), Rec->getName() +
                   " has unexpected operator type!");
diff --git a/utils/TableGen/PseudoLoweringEmitter.h b/utils/TableGen/PseudoLoweringEmitter.h
index 2749280e6a9..6e526381874 100644
--- a/utils/TableGen/PseudoLoweringEmitter.h
+++ b/utils/TableGen/PseudoLoweringEmitter.h
@@ -47,7 +47,7 @@ class PseudoLoweringEmitter : public TableGenBackend {
 
   SmallVector<PseudoExpansion, 64> Expansions;
 
-  unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
+  unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag,
                                 CodeGenInstruction &Insn,
                                 IndexedMap<OpData> &OperandMap,
                                 unsigned BaseIdx);
diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp
index 4f33638eaa7..e2f505e17eb 100644
--- a/utils/TableGen/Record.cpp
+++ b/utils/TableGen/Record.cpp
@@ -85,7 +85,7 @@ ListRecTy *RecTy::getListTy() {
   return ListTy;
 }
 
-Init *BitRecTy::convertValue(BitsInit *BI) {
+const Init *BitRecTy::convertValue(const BitsInit *BI) {
   if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
   return BI->getBit(0);
 }
@@ -94,14 +94,14 @@ bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const {
   return RHS->getNumBits() == 1;
 }
 
-Init *BitRecTy::convertValue(IntInit *II) {
+const Init *BitRecTy::convertValue(const IntInit *II) {
   int64_t Val = II->getValue();
   if (Val != 0 && Val != 1) return 0;  // Only accept 0 or 1 for a bit!
 
   return new BitInit(Val != 0);
 }
 
-Init *BitRecTy::convertValue(TypedInit *VI) {
+const Init *BitRecTy::convertValue(const TypedInit *VI) {
   if (dynamic_cast<BitRecTy*>(VI->getType()))
     return VI;  // Accept variable if it is already of bit type!
   return 0;
@@ -121,18 +121,18 @@ std::string BitsRecTy::getAsString() const {
   return "bits<" + utostr(Size) + ">";
 }
 
-Init *BitsRecTy::convertValue(UnsetInit *UI) {
-  SmallVector<Init *, 16> NewBits(Size);
+const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
+  SmallVector<const Init *, 16> NewBits(Size);
 
   for (unsigned i = 0; i != Size; ++i)
     NewBits[i] = new UnsetInit();
 
-  return new BitsInit(ArrayRef<Init *>(NewBits));
+  return new BitsInit(ArrayRef<const Init *>(NewBits));
 }
 
-Init *BitsRecTy::convertValue(BitInit *UI) {
+const Init *BitsRecTy::convertValue(const BitInit *UI) {
   if (Size != 1) return 0;  // Can only convert single bit.
-  return new BitsInit(ArrayRef<Init *>(UI));
+  return new BitsInit(ArrayRef<const Init *>(UI));
 }
 
 /// canFitInBitfield - Return true if the number of bits is large enough to hold
@@ -146,55 +146,55 @@ static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
 /// convertValue from Int initializer to bits type: Split the integer up into the
 /// appropriate bits.
 ///
-Init *BitsRecTy::convertValue(IntInit *II) {
+const Init *BitsRecTy::convertValue(const IntInit *II) {
   int64_t Value = II->getValue();
   // Make sure this bitfield is large enough to hold the integer value.
   if (!canFitInBitfield(Value, Size))
     return 0;
 
-  SmallVector<Init *, 16> NewBits(Size);
+  SmallVector<const Init *, 16> NewBits(Size);
 
   for (unsigned i = 0; i != Size; ++i)
     NewBits[i] = new BitInit(Value & (1LL << i));
 
-  return new BitsInit(ArrayRef<Init *>(NewBits));
+  return new BitsInit(ArrayRef<const Init *>(NewBits));
 }
 
-Init *BitsRecTy::convertValue(BitsInit *BI) {
+const Init *BitsRecTy::convertValue(const BitsInit *BI) {
   // If the number of bits is right, return it.  Otherwise we need to expand or
   // truncate.
   if (BI->getNumBits() == Size) return BI;
   return 0;
 }
 
-Init *BitsRecTy::convertValue(TypedInit *VI) {
+const Init *BitsRecTy::convertValue(const TypedInit *VI) {
   if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
     if (BRT->Size == Size) {
-      SmallVector<Init *, 16> NewBits(Size);
+      SmallVector<const Init *, 16> NewBits(Size);
  
       for (unsigned i = 0; i != Size; ++i)
         NewBits[i] = new VarBitInit(VI, i);
-      return new BitsInit(ArrayRef<Init *>(NewBits));
+      return new BitsInit(ArrayRef<const Init *>(NewBits));
     }
 
   if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType()))
-    return new BitsInit(VI);
+    return new BitsInit(ArrayRef<const Init *>(VI));
 
-  if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
+  if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) {
     if (Tern->getOpcode() == TernOpInit::IF) {
-      Init *LHS = Tern->getLHS();
-      Init *MHS = Tern->getMHS();
-      Init *RHS = Tern->getRHS();
+      const Init *LHS = Tern->getLHS();
+      const Init *MHS = Tern->getMHS();
+      const Init *RHS = Tern->getRHS();
 
-      IntInit *MHSi = dynamic_cast<IntInit*>(MHS);
-      IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
+      const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS);
+      const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
 
       if (MHSi && RHSi) {
         int64_t MHSVal = MHSi->getValue();
         int64_t RHSVal = RHSi->getValue();
 
         if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
-          SmallVector<Init *, 16> NewBits(Size);
+          SmallVector<const Init *, 16> NewBits(Size);
 
           for (unsigned i = 0; i != Size; ++i)
             NewBits[i] =
@@ -203,14 +203,14 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
                              new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
                              VI->getType());
 
-          return new BitsInit(ArrayRef<Init *>(NewBits));
+          return new BitsInit(ArrayRef<const Init *>(NewBits));
         }
       } else {
-        BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
-        BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
+        const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS);
+        const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS);
 
         if (MHSbs && RHSbs) {
-          SmallVector<Init *, 16> NewBits(Size);
+          SmallVector<const Init *, 16> NewBits(Size);
 
           for (unsigned i = 0; i != Size; ++i)
             NewBits[i] = new TernOpInit(TernOpInit::IF, LHS,
@@ -218,7 +218,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
                                         RHSbs->getBit(i),
                                         VI->getType());
 
-          return new BitsInit(ArrayRef<Init *>(NewBits));
+          return new BitsInit(ArrayRef<const Init *>(NewBits));
         }
       }
     }
@@ -227,14 +227,14 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
   return 0;
 }
 
-Init *IntRecTy::convertValue(BitInit *BI) {
+const Init *IntRecTy::convertValue(const BitInit *BI) {
   return new IntInit(BI->getValue());
 }
 
-Init *IntRecTy::convertValue(BitsInit *BI) {
+const Init *IntRecTy::convertValue(const BitsInit *BI) {
   int64_t Result = 0;
   for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
-    if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
+    if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) {
       Result |= Bit->getValue() << i;
     } else {
       return 0;
@@ -242,39 +242,39 @@ Init *IntRecTy::convertValue(BitsInit *BI) {
   return new IntInit(Result);
 }
 
-Init *IntRecTy::convertValue(TypedInit *TI) {
+const Init *IntRecTy::convertValue(const TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;  // Accept variable if already of the right type!
   return 0;
 }
 
-Init *StringRecTy::convertValue(UnOpInit *BO) {
+const Init *StringRecTy::convertValue(const UnOpInit *BO) {
   if (BO->getOpcode() == UnOpInit::CAST) {
-    Init *L = BO->getOperand()->convertInitializerTo(this);
+    const Init *L = BO->getOperand()->convertInitializerTo(this);
     if (L == 0) return 0;
     if (L != BO->getOperand())
       return new UnOpInit(UnOpInit::CAST, L, new StringRecTy);
     return BO;
   }
 
-  return convertValue((TypedInit*)BO);
+  return convertValue((const TypedInit*)BO);
 }
 
-Init *StringRecTy::convertValue(BinOpInit *BO) {
+const Init *StringRecTy::convertValue(const BinOpInit *BO) {
   if (BO->getOpcode() == BinOpInit::STRCONCAT) {
-    Init *L = BO->getLHS()->convertInitializerTo(this);
-    Init *R = BO->getRHS()->convertInitializerTo(this);
+    const Init *L = BO->getLHS()->convertInitializerTo(this);
+    const Init *R = BO->getRHS()->convertInitializerTo(this);
     if (L == 0 || R == 0) return 0;
     if (L != BO->getLHS() || R != BO->getRHS())
       return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy);
     return BO;
   }
 
-  return convertValue((TypedInit*)BO);
+  return convertValue((const TypedInit*)BO);
 }
 
 
-Init *StringRecTy::convertValue(TypedInit *TI) {
+const Init *StringRecTy::convertValue(const TypedInit *TI) {
   if (dynamic_cast<StringRecTy*>(TI->getType()))
     return TI;  // Accept variable if already of the right type!
   return 0;
@@ -284,13 +284,13 @@ std::string ListRecTy::getAsString() const {
   return "list<" + Ty->getAsString() + ">";
 }
 
-Init *ListRecTy::convertValue(ListInit *LI) {
-  std::vector<Init*> Elements;
+const Init *ListRecTy::convertValue(const ListInit *LI) {
+  std::vector<const Init*> Elements;
 
   // Verify that all of the elements of the list are subclasses of the
   // appropriate class!
   for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
-    if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
+    if (const Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
       Elements.push_back(CI);
     else
       return 0;
@@ -303,7 +303,7 @@ Init *ListRecTy::convertValue(ListInit *LI) {
   return new ListInit(Elements, this);
 }
 
-Init *ListRecTy::convertValue(TypedInit *TI) {
+const Init *ListRecTy::convertValue(const TypedInit *TI) {
   // Ensure that TI is compatible with our class.
   if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
     if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
@@ -311,21 +311,21 @@ Init *ListRecTy::convertValue(TypedInit *TI) {
   return 0;
 }
 
-Init *CodeRecTy::convertValue(TypedInit *TI) {
+const Init *CodeRecTy::convertValue(const TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;
   return 0;
 }
 
-Init *DagRecTy::convertValue(TypedInit *TI) {
+const Init *DagRecTy::convertValue(const TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;
   return 0;
 }
 
-Init *DagRecTy::convertValue(UnOpInit *BO) {
+const Init *DagRecTy::convertValue(const UnOpInit *BO) {
   if (BO->getOpcode() == UnOpInit::CAST) {
-    Init *L = BO->getOperand()->convertInitializerTo(this);
+    const Init *L = BO->getOperand()->convertInitializerTo(this);
     if (L == 0) return 0;
     if (L != BO->getOperand())
       return new UnOpInit(UnOpInit::CAST, L, new DagRecTy);
@@ -334,10 +334,10 @@ Init *DagRecTy::convertValue(UnOpInit *BO) {
   return 0;
 }
 
-Init *DagRecTy::convertValue(BinOpInit *BO) {
+const Init *DagRecTy::convertValue(const BinOpInit *BO) {
   if (BO->getOpcode() == BinOpInit::CONCAT) {
-    Init *L = BO->getLHS()->convertInitializerTo(this);
-    Init *R = BO->getRHS()->convertInitializerTo(this);
+    const Init *L = BO->getLHS()->convertInitializerTo(this);
+    const Init *R = BO->getRHS()->convertInitializerTo(this);
     if (L == 0 || R == 0) return 0;
     if (L != BO->getLHS() || R != BO->getRHS())
       return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy);
@@ -354,14 +354,14 @@ std::string RecordRecTy::getAsString() const {
   return Rec->getName();
 }
 
-Init *RecordRecTy::convertValue(DefInit *DI) {
+const Init *RecordRecTy::convertValue(const DefInit *DI) {
   // Ensure that DI is a subclass of Rec.
   if (!DI->getDef()->isSubClassOf(Rec))
     return 0;
   return DI;
 }
 
-Init *RecordRecTy::convertValue(TypedInit *TI) {
+const Init *RecordRecTy::convertValue(const TypedInit *TI) {
   // Ensure that TI is compatible with Rec.
   if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType()))
     if (RRT->getRecord()->isSubClassOf(getRecord()) ||
@@ -442,22 +442,23 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
 
 void Init::dump() const { return print(errs()); }
 
-Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
-  SmallVector<Init *, 16> NewBits(Bits.size());
+const Init *
+BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+  SmallVector<const Init *, 16> NewBits(Bits.size());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= getNumBits())
       return 0;
     NewBits[i] = getBit(Bits[i]);
   }
-  return new BitsInit(ArrayRef<Init *>(NewBits));
+  return new BitsInit(ArrayRef<const Init *>(NewBits));
 }
 
 std::string BitsInit::getAsString() const {
   std::string Result = "{ ";
   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     if (i) Result += ", ";
-    if (Init *Bit = getBit(e-i-1))
+    if (const Init *Bit = getBit(e-i-1))
       Result += Bit->getAsString();
     else
       Result += "*";
@@ -468,13 +469,13 @@ std::string BitsInit::getAsString() const {
 // resolveReferences - If there are any field references that refer to fields
 // that have been filled in, we can propagate the values now.
 //
-Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
+const Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const {
   bool Changed = false;
-  SmallVector<Init *, 16> NewBits(getNumBits());
+  SmallVector<const Init *, 16> NewBits(getNumBits());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
-    Init *B;
-    Init *CurBit = getBit(i);
+    const Init *B;
+    const Init *CurBit = getBit(i);
 
     do {
       B = CurBit;
@@ -485,7 +486,7 @@ Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
   }
 
   if (Changed)
-    return new BitsInit(ArrayRef<Init *>(NewBits));
+    return new BitsInit(ArrayRef<const Init *>(NewBits));
 
   return this;
 }
@@ -494,8 +495,9 @@ std::string IntInit::getAsString() const {
   return itostr(Value);
 }
 
-Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
-  SmallVector<Init *, 16> NewBits(Bits.size());
+const Init *
+IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+  SmallVector<const Init *, 16> NewBits(Bits.size());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= 64)
@@ -503,11 +505,12 @@ Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
 
     NewBits[i] = new BitInit(Value & (INT64_C(1) << Bits[i]));
   }
-  return new BitsInit(ArrayRef<Init *>(NewBits));
+  return new BitsInit(ArrayRef<const Init *>(NewBits));
 }
 
-Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
-  std::vector<Init*> Vals;
+const Init *
+ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
+  std::vector<const Init*> Vals;
   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
     if (Elements[i] >= getSize())
       return 0;
@@ -518,19 +521,19 @@ Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
 
 Record *ListInit::getElementAsRecord(unsigned i) const {
   assert(i < Values.size() && "List element index out of range!");
-  DefInit *DI = dynamic_cast<DefInit*>(Values[i]);
+  const DefInit *DI = dynamic_cast<const DefInit*>(Values[i]);
   if (DI == 0) throw "Expected record in list!";
   return DI->getDef();
 }
 
-Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
-  std::vector<Init*> Resolved;
+const Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const {
+  std::vector<const Init*> Resolved;
   Resolved.reserve(getSize());
   bool Changed = false;
 
   for (unsigned i = 0, e = getSize(); i != e; ++i) {
-    Init *E;
-    Init *CurElt = getElement(i);
+    const Init *E;
+    const Init *CurElt = getElement(i);
 
     do {
       E = CurElt;
@@ -545,15 +548,16 @@ Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
   return this;
 }
 
-Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
-                                            unsigned Elt) {
+const Init *ListInit::resolveListElementReference(Record &R,
+                                                  const RecordVal *IRV,
+                                                  unsigned Elt) const {
   if (Elt >= getSize())
     return 0;  // Out of range reference.
-  Init *E = getElement(Elt);
+  const Init *E = getElement(Elt);
   // If the element is set to some value, or if we are resolving a reference
   // to a specific variable and that variable is explicitly unset, then
   // replace the VarListElementInit with it.
-  if (IRV || !dynamic_cast<UnsetInit*>(E))
+  if (IRV || !dynamic_cast<const UnsetInit*>(E))
     return E;
   return 0;
 }
@@ -567,12 +571,12 @@ std::string ListInit::getAsString() const {
   return Result + "]";
 }
 
-Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
-                                  unsigned Bit) {
-  Init *Folded = Fold(&R, 0);
+const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
+                                        unsigned Bit) const {
+  const Init *Folded = Fold(&R, 0);
 
   if (Folded != this) {
-    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
+    const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
     if (Typed) {
       return Typed->resolveBitReference(R, IRV, Bit);
     }
@@ -581,12 +585,12 @@ Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
   return 0;
 }
 
-Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
-                                          unsigned Elt) {
-  Init *Folded = Fold(&R, 0);
+const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+                                                unsigned Elt) const {
+  const Init *Folded = Fold(&R, 0);
 
   if (Folded != this) {
-    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
+    const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
     if (Typed) {
       return Typed->resolveListElementReference(R, IRV, Elt);
     }
@@ -595,22 +599,22 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
   return 0;
 }
 
-Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
   default: assert(0 && "Unknown unop");
   case CAST: {
     if (getType()->getAsString() == "string") {
-      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+      const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
       if (LHSs) {
         return LHSs;
       }
 
-      DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
+      const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
       if (LHSd) {
         return new StringInit(LHSd->getDef()->getName());
       }
     } else {
-      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+      const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
       if (LHSs) {
         std::string Name = LHSs->getValue();
 
@@ -656,7 +660,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
     break;
   }
   case HEAD: {
-    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
+    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
         assert(0 && "Empty list in car");
@@ -667,7 +671,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
     break;
   }
   case TAIL: {
-    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
+    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
         assert(0 && "Empty list in cdr");
@@ -679,14 +683,15 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
       // they are not convertible to Init **.  Fortunately,
       // RandomAccessIterator::operator * is guaranteed to return an
       // lvalue.
-      ListInit *Result = new ListInit(ArrayRef<Init *>(&*begin, end - begin),
-                                      LHSl->getType());
+      ListInit *Result =
+        new ListInit(ArrayRef<const Init *>(&*begin, end - begin),
+                     LHSl->getType());
       return Result;
     }
     break;
   }
   case EMPTY: {
-    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
+    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
         return new IntInit(1);
@@ -694,7 +699,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
         return new IntInit(0);
       }
     }
-    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
     if (LHSs) {
       if (LHSs->getValue().empty()) {
         return new IntInit(1);
@@ -709,8 +714,8 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   return this;
 }
 
-Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) {
-  Init *lhs = LHS->resolveReferences(R, RV);
+const Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
+  const Init *lhs = LHS->resolveReferences(R, RV);
 
   if (LHS != lhs)
     return (new UnOpInit(getOpcode(), lhs, getType()))->Fold(&R, 0);
@@ -728,18 +733,18 @@ std::string UnOpInit::getAsString() const {
   return Result + "(" + LHS->getAsString() + ")";
 }
 
-Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
   default: assert(0 && "Unknown binop");
   case CONCAT: {
-    DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
-    DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
+    const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS);
+    const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS);
     if (LHSs && RHSs) {
-      DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
-      DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
+      const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator());
+      const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator());
       if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
         throw "Concated Dag operators do not match!";
-      std::vector<Init*> Args;
+      std::vector<const Init*> Args;
       std::vector<std::string> ArgNames;
       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(LHSs->getArg(i));
@@ -754,8 +759,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
     break;
   }
   case STRCONCAT: {
-    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
-    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+    const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
     if (LHSs && RHSs)
       return new StringInit(LHSs->getValue() + RHSs->getValue());
     break;
@@ -763,16 +768,16 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   case EQ: {
     // try to fold eq comparison for 'bit' and 'int', otherwise fallback
     // to string objects.
-    IntInit* L =
-      dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
-    IntInit* R =
-      dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
+    const IntInit* L =
+      dynamic_cast<const IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
+    const IntInit* R =
+      dynamic_cast<const IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
 
     if (L && R)
       return new IntInit(L->getValue() == R->getValue());
 
-    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
-    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+    const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
 
     // Make sure we've resolved
     if (LHSs && RHSs)
@@ -783,8 +788,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   case SHL:
   case SRA:
   case SRL: {
-    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
-    IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
+    const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
+    const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
     if (LHSi && RHSi) {
       int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
       int64_t Result;
@@ -802,9 +807,9 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   return this;
 }
 
-Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) {
-  Init *lhs = LHS->resolveReferences(R, RV);
-  Init *rhs = RHS->resolveReferences(R, RV);
+const Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
+  const Init *lhs = LHS->resolveReferences(R, RV);
+  const Init *rhs = RHS->resolveReferences(R, RV);
 
   if (LHS != lhs || RHS != rhs)
     return (new BinOpInit(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
@@ -824,19 +829,21 @@ std::string BinOpInit::getAsString() const {
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
-                           Record *CurRec, MultiClass *CurMultiClass);
+static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
+                                 const Init *RHS, RecTy *Type,
+                                 Record *CurRec, MultiClass *CurMultiClass);
 
-static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
-                               RecTy *Type, Record *CurRec,
-                               MultiClass *CurMultiClass) {
-  std::vector<Init *> NewOperands;
+static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
+                                     const Init *Arg,
+                                     RecTy *Type, Record *CurRec,
+                                     MultiClass *CurMultiClass) {
+  std::vector<const Init *> NewOperands;
 
-  TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
+  const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg);
 
   // If this is a dag, recurse
   if (TArg && TArg->getType()->getAsString() == "dag") {
-    Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
+    const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
                                  CurRec, CurMultiClass);
     if (Result != 0) {
       return Result;
@@ -846,10 +853,10 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
   }
 
   for (int i = 0; i < RHSo->getNumOperands(); ++i) {
-    OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i));
+    const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i));
 
     if (RHSoo) {
-      Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
+      const Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
                                        Type, CurRec, CurMultiClass);
       if (Result != 0) {
         NewOperands.push_back(Result);
@@ -864,8 +871,8 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
   }
 
   // Now run the operator and use its result as the new leaf
-  OpInit *NewOp = RHSo->clone(NewOperands);
-  Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
+  const OpInit *NewOp = RHSo->clone(NewOperands);
+  const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
   if (NewVal != NewOp) {
     delete NewOp;
     return NewVal;
@@ -873,21 +880,23 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
   return 0;
 }
 
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
-                           Record *CurRec, MultiClass *CurMultiClass) {
-  DagInit *MHSd = dynamic_cast<DagInit*>(MHS);
-  ListInit *MHSl = dynamic_cast<ListInit*>(MHS);
+static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
+                                 const Init *RHS, RecTy *Type,
+                                 Record *CurRec,
+                                 MultiClass *CurMultiClass) {
+  const DagInit *MHSd = dynamic_cast<const DagInit*>(MHS);
+  const ListInit *MHSl = dynamic_cast<const ListInit*>(MHS);
 
   DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type);
   ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type);
 
-  OpInit *RHSo = dynamic_cast<OpInit*>(RHS);
+  const OpInit *RHSo = dynamic_cast<const OpInit*>(RHS);
 
   if (!RHSo) {
     throw TGError(CurRec->getLoc(), "!foreach requires an operator\n");
   }
 
-  TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
+  const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
 
   if (!LHSt) {
     throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n");
@@ -895,22 +904,22 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
 
   if ((MHSd && DagType) || (MHSl && ListType)) {
     if (MHSd) {
-      Init *Val = MHSd->getOperator();
-      Init *Result = EvaluateOperation(RHSo, LHS, Val,
+      const Init *Val = MHSd->getOperator();
+      const Init *Result = EvaluateOperation(RHSo, LHS, Val,
                                        Type, CurRec, CurMultiClass);
       if (Result != 0) {
         Val = Result;
       }
 
-      std::vector<std::pair<Init *, std::string> > args;
+      std::vector<std::pair<const Init *, std::string> > args;
       for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
-        Init *Arg;
+        const Init *Arg;
         std::string ArgName;
         Arg = MHSd->getArg(i);
         ArgName = MHSd->getArgName(i);
 
         // Process args
-        Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
+        const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
                                          CurRec, CurMultiClass);
         if (Result != 0) {
           Arg = Result;
@@ -923,14 +932,14 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
       return new DagInit(Val, "", args);
     }
     if (MHSl) {
-      std::vector<Init *> NewOperands;
-      std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
+      std::vector<const Init *> NewOperands;
+      std::vector<const Init *> NewList(MHSl->begin(), MHSl->end());
 
-      for (std::vector<Init *>::iterator li = NewList.begin(),
+      for (std::vector<const Init *>::iterator li = NewList.begin(),
              liend = NewList.end();
            li != liend;
            ++li) {
-        Init *Item = *li;
+        const Init *Item = *li;
         NewOperands.clear();
         for(int i = 0; i < RHSo->getNumOperands(); ++i) {
           // First, replace the foreach variable with the list item
@@ -942,8 +951,8 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
         }
 
         // Now run the operator and use its result as the new list item
-        OpInit *NewOp = RHSo->clone(NewOperands);
-        Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
+        const OpInit *NewOp = RHSo->clone(NewOperands);
+        const Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
         if (NewItem != NewOp) {
           *li = NewItem;
           delete NewOp;
@@ -955,21 +964,21 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
   return 0;
 }
 
-Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
   default: assert(0 && "Unknown binop");
   case SUBST: {
-    DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
-    VarInit *LHSv = dynamic_cast<VarInit*>(LHS);
-    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+    const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
+    const VarInit *LHSv = dynamic_cast<const VarInit*>(LHS);
+    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
 
-    DefInit *MHSd = dynamic_cast<DefInit*>(MHS);
-    VarInit *MHSv = dynamic_cast<VarInit*>(MHS);
-    StringInit *MHSs = dynamic_cast<StringInit*>(MHS);
+    const DefInit *MHSd = dynamic_cast<const DefInit*>(MHS);
+    const VarInit *MHSv = dynamic_cast<const VarInit*>(MHS);
+    const StringInit *MHSs = dynamic_cast<const StringInit*>(MHS);
 
-    DefInit *RHSd = dynamic_cast<DefInit*>(RHS);
-    VarInit *RHSv = dynamic_cast<VarInit*>(RHS);
-    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+    const DefInit *RHSd = dynamic_cast<const DefInit*>(RHS);
+    const VarInit *RHSv = dynamic_cast<const VarInit*>(RHS);
+    const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
 
     if ((LHSd && MHSd && RHSd)
         || (LHSv && MHSv && RHSv)
@@ -1008,7 +1017,7 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   }
 
   case FOREACH: {
-    Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
+    const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
                                  CurRec, CurMultiClass);
     if (Result != 0) {
       return Result;
@@ -1017,9 +1026,9 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   }
 
   case IF: {
-    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
-    if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
-      LHSi = dynamic_cast<IntInit*>(I);
+    const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
+    if (const Init *I = LHS->convertInitializerTo(IntRecTy::get()))
+      LHSi = dynamic_cast<const IntInit*>(I);
     if (LHSi) {
       if (LHSi->getValue()) {
         return MHS;
@@ -1034,29 +1043,30 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   return this;
 }
 
-Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) {
-  Init *lhs = LHS->resolveReferences(R, RV);
+const Init *TernOpInit::resolveReferences(Record &R,
+                                          const RecordVal *RV) const {
+  const Init *lhs = LHS->resolveReferences(R, RV);
 
   if (Opc == IF && lhs != LHS) {
-    IntInit *Value = dynamic_cast<IntInit*>(lhs);
-    if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
-      Value = dynamic_cast<IntInit*>(I);
+    const IntInit *Value = dynamic_cast<const IntInit*>(lhs);
+    if (const Init *I = lhs->convertInitializerTo(IntRecTy::get()))
+      Value = dynamic_cast<const IntInit*>(I);
     if (Value != 0) {
       // Short-circuit
       if (Value->getValue()) {
-        Init *mhs = MHS->resolveReferences(R, RV);
+        const Init *mhs = MHS->resolveReferences(R, RV);
         return (new TernOpInit(getOpcode(), lhs, mhs,
                                RHS, getType()))->Fold(&R, 0);
       } else {
-        Init *rhs = RHS->resolveReferences(R, RV);
+        const Init *rhs = RHS->resolveReferences(R, RV);
         return (new TernOpInit(getOpcode(), lhs, MHS,
                                rhs, getType()))->Fold(&R, 0);
       }
     }
   }
 
-  Init *mhs = MHS->resolveReferences(R, RV);
-  Init *rhs = RHS->resolveReferences(R, RV);
+  const Init *mhs = MHS->resolveReferences(R, RV);
+  const Init *rhs = RHS->resolveReferences(R, RV);
 
   if (LHS != lhs || MHS != mhs || RHS != rhs)
     return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0);
@@ -1085,29 +1095,31 @@ RecTy *TypedInit::getFieldType(const std::string &FieldName) const {
   return 0;
 }
 
-Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+const Init *
+TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
   BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
   if (T == 0) return 0;  // Cannot subscript a non-bits variable.
   unsigned NumBits = T->getNumBits();
 
-  SmallVector<Init *, 16> NewBits(Bits.size());
+  SmallVector<const Init *, 16> NewBits(Bits.size());
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= NumBits)
       return 0;
 
     NewBits[i] = new VarBitInit(this, Bits[i]);
   }
-  return new BitsInit(ArrayRef<Init *>(NewBits));
+  return new BitsInit(ArrayRef<const Init *>(NewBits));
 }
 
-Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+const Init *
+TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
   ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
   if (T == 0) return 0;  // Cannot subscript a non-list variable.
 
   if (Elements.size() == 1)
     return new VarListElementInit(this, Elements[0]);
 
-  std::vector<Init*> ListInits;
+  std::vector<const Init*> ListInits;
   ListInits.reserve(Elements.size());
   for (unsigned i = 0, e = Elements.size(); i != e; ++i)
     ListInits.push_back(new VarListElementInit(this, Elements[i]));
@@ -1115,48 +1127,49 @@ Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
 }
 
 
-Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
-                                   unsigned Bit) {
+const Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+                                         unsigned Bit) const {
   if (R.isTemplateArg(getName())) return 0;
   if (IRV && IRV->getName() != getName()) return 0;
 
   RecordVal *RV = R.getValue(getName());
   assert(RV && "Reference to a non-existent variable?");
-  assert(dynamic_cast<BitsInit*>(RV->getValue()));
-  BitsInit *BI = (BitsInit*)RV->getValue();
+  assert(dynamic_cast<const BitsInit*>(RV->getValue()));
+  const BitsInit *BI = (const BitsInit*)RV->getValue();
 
   assert(Bit < BI->getNumBits() && "Bit reference out of range!");
-  Init *B = BI->getBit(Bit);
+  const Init *B = BI->getBit(Bit);
 
   // If the bit is set to some value, or if we are resolving a reference to a
   // specific variable and that variable is explicitly unset, then replace the
   // VarBitInit with it.
-  if (IRV || !dynamic_cast<UnsetInit*>(B))
+  if (IRV || !dynamic_cast<const UnsetInit*>(B))
     return B;
   return 0;
 }
 
-Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
-                                           unsigned Elt) {
+const Init *VarInit::resolveListElementReference(Record &R,
+                                                 const RecordVal *IRV,
+                                                 unsigned Elt) const {
   if (R.isTemplateArg(getName())) return 0;
   if (IRV && IRV->getName() != getName()) return 0;
 
   RecordVal *RV = R.getValue(getName());
   assert(RV && "Reference to a non-existent variable?");
-  ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
+  const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue());
   if (!LI) {
-    VarInit *VI = dynamic_cast<VarInit*>(RV->getValue());
+    const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue());
     assert(VI && "Invalid list element!");
     return new VarListElementInit(VI, Elt);
   }
 
   if (Elt >= LI->getSize())
     return 0;  // Out of range reference.
-  Init *E = LI->getElement(Elt);
+  const Init *E = LI->getElement(Elt);
   // If the element is set to some value, or if we are resolving a reference
   // to a specific variable and that variable is explicitly unset, then
   // replace the VarListElementInit with it.
-  if (IRV || !dynamic_cast<UnsetInit*>(E))
+  if (IRV || !dynamic_cast<const UnsetInit*>(E))
     return E;
   return 0;
 }
@@ -1169,15 +1182,15 @@ RecTy *VarInit::getFieldType(const std::string &FieldName) const {
   return 0;
 }
 
-Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
-                            const std::string &FieldName) const {
+const Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
+                                  const std::string &FieldName) const {
   if (dynamic_cast<RecordRecTy*>(getType()))
     if (const RecordVal *Val = R.getValue(VarName)) {
-      if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue())))
+      if (RV != Val && (RV || dynamic_cast<const UnsetInit*>(Val->getValue())))
         return 0;
-      Init *TheInit = Val->getValue();
+      const Init *TheInit = Val->getValue();
       assert(TheInit != this && "Infinite loop detected!");
-      if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
+      if (const Init *I = TheInit->getFieldInit(R, RV, FieldName))
         return I;
       else
         return 0;
@@ -1190,9 +1203,9 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
 /// 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.
 ///
-Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) {
+const Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
   if (RecordVal *Val = R.getValue(VarName))
-    if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
+    if (RV == Val || (RV == 0 && !dynamic_cast<const UnsetInit*>(Val->getValue())))
       return Val->getValue();
   return this;
 }
@@ -1201,8 +1214,9 @@ std::string VarBitInit::getAsString() const {
    return TI->getAsString() + "{" + utostr(Bit) + "}";
 }
 
-Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) {
-  if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
+const Init *VarBitInit::resolveReferences(Record &R,
+                                          const RecordVal *RV) const {
+  if (const Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
     return I;
   return this;
 }
@@ -1211,22 +1225,25 @@ std::string VarListElementInit::getAsString() const {
   return TI->getAsString() + "[" + utostr(Element) + "]";
 }
 
-Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
-  if (Init *I = getVariable()->resolveListElementReference(R, RV,
+const Init *VarListElementInit::resolveReferences(Record &R,
+                                                  const RecordVal *RV) const {
+  if (const Init *I = getVariable()->resolveListElementReference(R, RV,
                                                            getElementNum()))
     return I;
   return this;
 }
 
-Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
-                                              unsigned Bit) {
+const Init *VarListElementInit::resolveBitReference(Record &R,
+                                                    const RecordVal *RV,
+                                                    unsigned Bit) const {
   // FIXME: This should be implemented, to support references like:
   // bit B = AA[0]{1};
   return 0;
 }
 
-Init *VarListElementInit::
-resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
+const Init *VarListElementInit::
+resolveListElementReference(Record &R, const RecordVal *RV,
+                            unsigned Elt) const {
   // FIXME: This should be implemented, to support references like:
   // int B = AA[0][1];
   return 0;
@@ -1242,8 +1259,8 @@ RecTy *DefInit::getFieldType(const std::string &FieldName) const {
   return 0;
 }
 
-Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
-                            const std::string &FieldName) const {
+const Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
+                                  const std::string &FieldName) const {
   return Def->getValue(FieldName)->getValue();
 }
 
@@ -1252,41 +1269,42 @@ std::string DefInit::getAsString() const {
   return Def->getName();
 }
 
-Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
-                                     unsigned Bit) {
-  if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
-    if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
+const Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+                                           unsigned Bit) const {
+  if (const Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
+    if (const BitsInit *BI = dynamic_cast<const BitsInit*>(BitsVal)) {
       assert(Bit < BI->getNumBits() && "Bit reference out of range!");
-      Init *B = BI->getBit(Bit);
+      const Init *B = BI->getBit(Bit);
 
-      if (dynamic_cast<BitInit*>(B))  // If the bit is set.
+      if (dynamic_cast<const BitInit*>(B))  // If the bit is set.
         return B;                     // Replace the VarBitInit with it.
     }
   return 0;
 }
 
-Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
-                                             unsigned Elt) {
-  if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
-    if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
+const Init *FieldInit::resolveListElementReference(Record &R,
+                                                   const RecordVal *RV,
+                                                   unsigned Elt) const {
+  if (const Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
+    if (const ListInit *LI = dynamic_cast<const ListInit*>(ListVal)) {
       if (Elt >= LI->getSize()) return 0;
-      Init *E = LI->getElement(Elt);
+      const Init *E = LI->getElement(Elt);
 
       // If the element is set to some value, or if we are resolving a
       // reference to a specific variable and that variable is explicitly
       // unset, then replace the VarListElementInit with it.
-      if (RV || !dynamic_cast<UnsetInit*>(E))
+      if (RV || !dynamic_cast<const UnsetInit*>(E))
         return E;
     }
   return 0;
 }
 
-Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
-  Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+const Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
+  const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
 
-  Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
+  const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
   if (BitsVal) {
-    Init *BVR = BitsVal->resolveReferences(R, RV);
+    const Init *BVR = BitsVal->resolveReferences(R, RV);
     return BVR->isComplete() ? BVR : this;
   }
 
@@ -1296,12 +1314,12 @@ Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
   return this;
 }
 
-Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
-  std::vector<Init*> NewArgs;
+const Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const {
+  std::vector<const Init*> NewArgs;
   for (unsigned i = 0, e = Args.size(); i != e; ++i)
     NewArgs.push_back(Args[i]->resolveReferences(R, RV));
 
-  Init *Op = Val->resolveReferences(R, RV);
+  const Init *Op = Val->resolveReferences(R, RV);
 
   if (Args != NewArgs || Op != Val)
     return new DagInit(Op, ValName, NewArgs, ArgNames);
@@ -1373,7 +1391,7 @@ void Record::setName(const std::string &Name) {
 /// references.
 void Record::resolveReferencesTo(const RecordVal *RV) {
   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
-    if (Init *V = Values[i].getValue())
+    if (const Init *V = Values[i].getValue())
       Values[i].setValue(V->resolveReferences(*this, RV));
   }
 }
@@ -1418,7 +1436,7 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
 /// getValueInit - Return the initializer for a value with the specified name,
 /// or throw an exception if the field does not exist.
 ///
-Init *Record::getValueInit(StringRef FieldName) const {
+const Init *Record::getValueInit(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
     throw "Record `" + getName() + "' does not have a field named `" +
@@ -1447,13 +1465,13 @@ std::string Record::getValueAsString(StringRef FieldName) const {
 /// its value as a BitsInit, throwing an exception if the field does not exist
 /// or if the value is not the right type.
 ///
-BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
+const BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
     throw "Record `" + getName() + "' does not have a field named `" +
           FieldName.str() + "'!\n";
 
-  if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
+  if (const BitsInit *BI = dynamic_cast<const BitsInit*>(R->getValue()))
     return BI;
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have a BitsInit initializer!";
@@ -1463,13 +1481,13 @@ BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
 /// its value as a ListInit, throwing an exception if the field does not exist
 /// or if the value is not the right type.
 ///
-ListInit *Record::getValueAsListInit(StringRef FieldName) const {
+const ListInit *Record::getValueAsListInit(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
     throw "Record `" + getName() + "' does not have a field named `" +
           FieldName.str() + "'!\n";
 
-  if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
+  if (const ListInit *LI = dynamic_cast<const ListInit*>(R->getValue()))
     return LI;
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have a list initializer!";
@@ -1481,10 +1499,10 @@ ListInit *Record::getValueAsListInit(StringRef FieldName) const {
 ///
 std::vector<Record*>
 Record::getValueAsListOfDefs(StringRef FieldName) const {
-  ListInit *List = getValueAsListInit(FieldName);
+  const ListInit *List = getValueAsListInit(FieldName);
   std::vector<Record*> Defs;
   for (unsigned i = 0; i < List->getSize(); i++) {
-    if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) {
+    if (const DefInit *DI = dynamic_cast<const DefInit*>(List->getElement(i))) {
       Defs.push_back(DI->getDef());
     } else {
       throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1504,7 +1522,7 @@ int64_t Record::getValueAsInt(StringRef FieldName) const {
     throw "Record `" + getName() + "' does not have a field named `" +
           FieldName.str() + "'!\n";
 
-  if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
+  if (const IntInit *II = dynamic_cast<const IntInit*>(R->getValue()))
     return II->getValue();
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have an int initializer!";
@@ -1516,10 +1534,10 @@ int64_t Record::getValueAsInt(StringRef FieldName) const {
 ///
 std::vector<int64_t>
 Record::getValueAsListOfInts(StringRef FieldName) const {
-  ListInit *List = getValueAsListInit(FieldName);
+  const ListInit *List = getValueAsListInit(FieldName);
   std::vector<int64_t> Ints;
   for (unsigned i = 0; i < List->getSize(); i++) {
-    if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) {
+    if (const IntInit *II = dynamic_cast<const IntInit*>(List->getElement(i))) {
       Ints.push_back(II->getValue());
     } else {
       throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1535,10 +1553,10 @@ Record::getValueAsListOfInts(StringRef FieldName) const {
 ///
 std::vector<std::string>
 Record::getValueAsListOfStrings(StringRef FieldName) const {
-  ListInit *List = getValueAsListInit(FieldName);
+  const ListInit *List = getValueAsListInit(FieldName);
   std::vector<std::string> Strings;
   for (unsigned i = 0; i < List->getSize(); i++) {
-    if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) {
+    if (const StringInit *II = dynamic_cast<const StringInit*>(List->getElement(i))) {
       Strings.push_back(II->getValue());
     } else {
       throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1558,7 +1576,7 @@ Record *Record::getValueAsDef(StringRef FieldName) const {
     throw "Record `" + getName() + "' does not have a field named `" +
       FieldName.str() + "'!\n";
 
-  if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
+  if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValue()))
     return DI->getDef();
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have a def initializer!";
@@ -1574,7 +1592,7 @@ bool Record::getValueAsBit(StringRef FieldName) const {
     throw "Record `" + getName() + "' does not have a field named `" +
       FieldName.str() + "'!\n";
 
-  if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
+  if (const BitInit *BI = dynamic_cast<const BitInit*>(R->getValue()))
     return BI->getValue();
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have a bit initializer!";
@@ -1584,13 +1602,13 @@ bool Record::getValueAsBit(StringRef FieldName) const {
 /// value as an Dag, throwing an exception if the field does not exist or if
 /// the value is not the right type.
 ///
-DagInit *Record::getValueAsDag(StringRef FieldName) const {
+const DagInit *Record::getValueAsDag(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
     throw "Record `" + getName() + "' does not have a field named `" +
       FieldName.str() + "'!\n";
 
-  if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
+  if (const DagInit *DI = dynamic_cast<const DagInit*>(R->getValue()))
     return DI;
   throw "Record `" + getName() + "', field `" + FieldName.str() +
         "' does not have a dag initializer!";
diff --git a/utils/TableGen/Record.h b/utils/TableGen/Record.h
index 599b6dcd5c3..c49a720edd8 100644
--- a/utils/TableGen/Record.h
+++ b/utils/TableGen/Record.h
@@ -82,31 +82,31 @@ public:
   ListRecTy *getListTy();
 
 public:   // These methods should only be called from subclasses of Init
-  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 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( BinOpInit *UI) {
-    return convertValue((TypedInit*)UI);
+  virtual const Init *convertValue( const BinOpInit *UI) {
+    return convertValue((const TypedInit*)UI);
   }
-  virtual Init *convertValue( TernOpInit *UI) {
-    return convertValue((TypedInit*)UI);
+  virtual const Init *convertValue( const TernOpInit *UI) {
+    return convertValue((const TypedInit*)UI);
   }
-  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 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( FieldInit *FI) {
-    return convertValue((TypedInit*)FI);
+  virtual const Init *convertValue( const FieldInit *FI) {
+    return convertValue((const TypedInit*)FI);
   }
 
 public:   // These methods should only be called by subclasses of RecTy.
@@ -136,22 +136,22 @@ class BitRecTy : public RecTy {
 public:
   static BitRecTy *get() { return &Shared; }
 
-  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);}
+  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);}
 
   std::string getAsString() const { return "bit"; }
 
@@ -181,22 +181,22 @@ public:
 
   unsigned getNumBits() const { return Size; }
 
-  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);}
+  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);}
 
   std::string getAsString() const;
 
@@ -225,22 +225,22 @@ class IntRecTy : public RecTy {
 public:
   static IntRecTy *get() { return &Shared; }
 
-  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);}
+  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);}
 
   std::string getAsString() const { return "int"; }
 
@@ -267,23 +267,23 @@ class StringRecTy : public RecTy {
 public:
   static StringRecTy *get() { return &Shared; }
 
-  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 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 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);}
+  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);}
 
   std::string getAsString() const { return "string"; }
 
@@ -314,22 +314,22 @@ public:
   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
   RecTy *getElementType() const { return Ty; }
 
-  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);}
+  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);}
 
   std::string getAsString() const;
 
@@ -357,22 +357,22 @@ class CodeRecTy : public RecTy {
 public:
   static CodeRecTy *get() { return &Shared; }
 
-  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);}
+  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);}
 
   std::string getAsString() const { return "code"; }
 
@@ -397,22 +397,22 @@ class DagRecTy : public RecTy {
 public:
   static DagRecTy *get() { return &Shared; }
 
-  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);}
+  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);}
 
   std::string getAsString() const { return "dag"; }
 
@@ -443,22 +443,22 @@ public:
 
   Record *getRecord() const { return Rec; }
 
-  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);}
+  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);}
 
   std::string getAsString() const;
 
@@ -506,14 +506,15 @@ public:
   /// function that should be overridden to call the appropriate
   /// RecTy::convertValue method.
   ///
-  virtual Init *convertInitializerTo(RecTy *Ty) = 0;
+  virtual const 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 Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+  virtual const Init *
+  convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
     return 0;
   }
 
@@ -522,7 +523,8 @@ 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 Init *convertInitListSlice(const std::vector<unsigned> &Elements) {
+  virtual const Init *
+  convertInitListSlice(const std::vector<unsigned> &Elements) const {
     return 0;
   }
 
@@ -536,8 +538,8 @@ public:
   /// initializer for the specified field.  If getFieldType returns non-null
   /// this method should return non-null, otherwise it returns null.
   ///
-  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
-                             const std::string &FieldName) const {
+  virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+                                   const std::string &FieldName) const {
     return 0;
   }
 
@@ -546,7 +548,7 @@ 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 Init *resolveReferences(Record &R, const RecordVal *RV) {
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const {
     return this;
   }
 };
@@ -565,8 +567,10 @@ public:
 
   RecTy *getType() const { return Ty; }
 
-  virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
-  virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements);
+  virtual const Init *
+  convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
+  virtual const Init *
+  convertInitListSlice(const std::vector<unsigned> &Elements) const;
 
   /// getFieldType - This method is used to implement the FieldInit class.
   /// Implementors of this method should return the type of the named field if
@@ -578,14 +582,14 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) = 0;
+  virtual const 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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt) = 0;
+  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                                  unsigned Elt) const = 0;
 };
 
 
@@ -593,7 +597,7 @@ public:
 ///
 class UnsetInit : public Init {
 public:
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
@@ -611,7 +615,7 @@ public:
 
   bool getValue() const { return Value; }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
@@ -622,22 +626,23 @@ public:
 /// It contains a vector of bits, whose size is determined by the type.
 ///
 class BitsInit : public Init {
-  std::vector<Init*> Bits;
+  std::vector<const Init*> Bits;
 public:
   explicit BitsInit(unsigned Size) : Bits(Size) {}
-  BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
+  BitsInit(ArrayRef<const Init *> Range) : Bits(Range.begin(), Range.end()) {}
 
   unsigned getNumBits() const { return Bits.size(); }
 
-  Init *getBit(unsigned Bit) const {
+  const Init *getBit(unsigned Bit) const {
     assert(Bit < Bits.size() && "Bit index out of range!");
     return Bits[Bit];
   }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
-  virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+  virtual const Init *
+  convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
 
   virtual bool isComplete() const {
     for (unsigned i = 0; i != getNumBits(); ++i)
@@ -651,7 +656,7 @@ public:
   }
   virtual std::string getAsString() const;
 
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 };
 
 
@@ -664,10 +669,11 @@ public:
 
   int64_t getValue() const { return Value; }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
-  virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+  virtual const Init *
+  convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
 
   virtual std::string getAsString() const;
 
@@ -675,8 +681,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) {
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const {
     assert(0 && "Illegal bit reference off int");
     return 0;
   }
@@ -684,8 +690,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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt) {
+  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                                  unsigned Elt) const {
     assert(0 && "Illegal element reference off int");
     return 0;
   }
@@ -702,7 +708,7 @@ public:
 
   const std::string &getValue() const { return Value; }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
@@ -712,8 +718,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) {
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const {
     assert(0 && "Illegal bit reference off string");
     return 0;
   }
@@ -721,8 +727,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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt) {
+  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                                  unsigned Elt) const {
     assert(0 && "Illegal element reference off string");
     return 0;
   }
@@ -737,7 +743,7 @@ public:
 
   const std::string &getValue() const { return Value; }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
@@ -747,28 +753,28 @@ public:
 /// ListInit - [AL, AH, CL] - Represent a list of defs
 ///
 class ListInit : public TypedInit {
-  std::vector<Init*> Values;
+  std::vector<const Init*> Values;
 public:
-  typedef std::vector<Init*>::const_iterator const_iterator;
+  typedef std::vector<const Init*>::const_iterator const_iterator;
 
-  explicit ListInit(std::vector<Init*> &Vs, RecTy *EltTy)
+  explicit ListInit(std::vector<const Init*> &Vs, RecTy *EltTy)
     : TypedInit(ListRecTy::get(EltTy)) {
     Values.swap(Vs);
   }
-  explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
+  explicit ListInit(ArrayRef<const Init *> Range, RecTy *EltTy)
       : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
 
   unsigned getSize() const { return Values.size(); }
-  Init *getElement(unsigned i) const {
+  const Init *getElement(unsigned i) const {
     assert(i < Values.size() && "List element index out of range!");
     return Values[i];
   }
 
   Record *getElementAsRecord(unsigned i) const;
 
-  Init *convertInitListSlice(const std::vector<unsigned> &Elements);
+  const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
@@ -777,11 +783,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 Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 
-  ArrayRef<Init*> getValues() const { return Values; }
+  ArrayRef<const Init*> getValues() const { return Values; }
 
   inline const_iterator begin() const { return Values.begin(); }
   inline const_iterator end  () const { return Values.end();   }
@@ -793,8 +799,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) {
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const {
     assert(0 && "Illegal bit reference off list");
     return 0;
   }
@@ -802,8 +808,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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt);
+  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                                  unsigned Elt) const;
 };
 
 
@@ -814,23 +820,24 @@ public:
   OpInit(RecTy *Type) : TypedInit(Type) {}
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual OpInit *clone(std::vector<Init *> &Operands) = 0;
+  virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0;
 
   virtual int getNumOperands() const = 0;
-  virtual Init *getOperand(int i) = 0;
+  virtual const Init *getOperand(int i) const = 0;
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) = 0;
+  virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit);
-  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt);
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const;
+  virtual const Init *resolveListElementReference(Record &R,
+                                                  const RecordVal *RV,
+                                                  unsigned Elt) const;
 };
 
 
@@ -841,33 +848,33 @@ public:
   enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
 private:
   UnaryOp Opc;
-  Init *LHS;
+  const Init *LHS;
 public:
-  UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) :
+  UnOpInit(UnaryOp opc, const Init *lhs, RecTy *Type) :
       OpInit(Type), Opc(opc), LHS(lhs) {
   }
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual OpInit *clone(std::vector<Init *> &Operands) {
+  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
     assert(Operands.size() == 1 &&
            "Wrong number of operands for unary operation");
     return new UnOpInit(getOpcode(), *Operands.begin(), getType());
   }
 
   int getNumOperands() const { return 1; }
-  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; }
-  Init *getOperand() const { return LHS; }
+  const Init *getOperand() const { return LHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
+  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -879,21 +886,21 @@ public:
   enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
 private:
   BinaryOp Opc;
-  Init *LHS, *RHS;
+  const Init *LHS, *RHS;
 public:
-  BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
+  BinOpInit(BinaryOp opc, const Init *lhs, const Init *rhs, RecTy *Type) :
       OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {
   }
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual OpInit *clone(std::vector<Init *> &Operands) {
+  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
     assert(Operands.size() == 2 &&
            "Wrong number of operands for binary operation");
     return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType());
   }
 
   int getNumOperands() const { return 2; }
-  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();
@@ -903,14 +910,14 @@ public:
   }
 
   BinaryOp getOpcode() const { return Opc; }
-  Init *getLHS() const { return LHS; }
-  Init *getRHS() const { return RHS; }
+  const Init *getLHS() const { return LHS; }
+  const Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
+  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -922,14 +929,15 @@ public:
   enum TernaryOp { SUBST, FOREACH, IF };
 private:
   TernaryOp Opc;
-  Init *LHS, *MHS, *RHS;
+  const Init *LHS, *MHS, *RHS;
 public:
-  TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type) :
+  TernOpInit(TernaryOp opc, const Init *lhs, const Init *mhs, const Init *rhs,
+             RecTy *Type) :
       OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {
   }
 
   // Clone - Clone this operator, replacing arguments with the new list
-  virtual OpInit *clone(std::vector<Init *> &Operands) {
+  virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
     assert(Operands.size() == 3 &&
            "Wrong number of operands for ternary operation");
     return new TernOpInit(getOpcode(), Operands[0], Operands[1], Operands[2],
@@ -937,7 +945,7 @@ public:
   }
 
   int getNumOperands() const { return 3; }
-  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) {
@@ -950,17 +958,17 @@ public:
   }
 
   TernaryOp getOpcode() const { return Opc; }
-  Init *getLHS() const { return LHS; }
-  Init *getMHS() const { return MHS; }
-  Init *getRHS() const { return RHS; }
+  const Init *getLHS() const { return LHS; }
+  const Init *getMHS() const { return MHS; }
+  const Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
+  const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
 
   virtual bool isComplete() const { return false; }
 
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 };
@@ -974,27 +982,27 @@ public:
   explicit VarInit(const std::string &VN, RecTy *T)
     : TypedInit(T), VarName(VN) {}
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
   const std::string &getName() const { return VarName; }
 
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit);
-  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt);
+  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 RecTy *getFieldType(const std::string &FieldName) const;
-  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
-                             const std::string &FieldName) const;
+  virtual const 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 Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const { return VarName; }
 };
@@ -1003,57 +1011,58 @@ public:
 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
 ///
 class VarBitInit : public Init {
-  TypedInit *TI;
+  const TypedInit *TI;
   unsigned Bit;
 public:
-  VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
+  VarBitInit(const TypedInit *T, unsigned B) : TI(T), Bit(B) {
     assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
            ((BitsRecTy*)T->getType())->getNumBits() > B &&
            "Illegal VarBitInit expression!");
   }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
-  TypedInit *getVariable() const { return TI; }
+  const TypedInit *getVariable() const { return TI; }
   unsigned getBitNum() const { return Bit; }
 
   virtual std::string getAsString() const;
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const 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 {
-  TypedInit *TI;
+  const TypedInit *TI;
   unsigned Element;
 public:
-  VarListElementInit(TypedInit *T, unsigned E)
+  VarListElementInit(const TypedInit *T, unsigned E)
     : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
                 TI(T), Element(E) {
     assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
            "Illegal VarBitInit expression!");
   }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
-  TypedInit *getVariable() const { return TI; }
+  const TypedInit *getVariable() const { return TI; }
   unsigned getElementNum() const { return Element; }
 
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit);
+  virtual const 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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt);
+  virtual const Init *resolveListElementReference(Record &R,
+                                                  const RecordVal *RV,
+                                                  unsigned Elt) const;
 
   virtual std::string getAsString() const;
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 };
 
 /// DefInit - AL - Represent a reference to a 'def' in the description
@@ -1065,17 +1074,18 @@ class DefInit : public TypedInit {
 public:
   static DefInit *get(Record*);
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
   Record *getDef() const { return Def; }
 
-  //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+  //virtual const Init *
+  //convertInitializerBitRange(const std::vector<unsigned> &Bits);
 
   virtual RecTy *getFieldType(const std::string &FieldName) const;
-  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
-                             const std::string &FieldName) const;
+  virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+                                   const std::string &FieldName) const;
 
   virtual std::string getAsString() const;
 
@@ -1083,8 +1093,8 @@ public:
   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
   /// simply return the resolved value, otherwise we return null.
   ///
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) {
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const {
     assert(0 && "Illegal bit reference off def");
     return 0;
   }
@@ -1092,8 +1102,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 Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt) {
+  virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+                                                  unsigned Elt) const {
     assert(0 && "Illegal element reference off def");
     return 0;
   }
@@ -1103,24 +1113,25 @@ public:
 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
 ///
 class FieldInit : public TypedInit {
-  Init *Rec;                // Record we are referring to
+  const Init *Rec;                // Record we are referring to
   std::string FieldName;    // Field we are accessing
 public:
-  FieldInit(Init *R, const std::string &FN)
+  FieldInit(const Init *R, const std::string &FN)
     : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
     assert(getType() && "FieldInit with non-record type!");
   }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit);
-  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt);
+  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 *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const {
     return Rec->getAsString() + "." + FieldName;
@@ -1132,13 +1143,13 @@ public:
 /// argument can have a name associated with it.
 ///
 class DagInit : public TypedInit {
-  Init *Val;
+  const Init *Val;
   std::string ValName;
-  std::vector<Init*> Args;
+  std::vector<const Init*> Args;
   std::vector<std::string> ArgNames;
 public:
-  DagInit(Init *V, std::string VN,
-          const std::vector<std::pair<Init*, std::string> > &args)
+  DagInit(const Init *V, std::string VN,
+          const std::vector<std::pair<const Init*, std::string> > &args)
     : TypedInit(DagRecTy::get()), Val(V), ValName(VN) {
     Args.reserve(args.size());
     ArgNames.reserve(args.size());
@@ -1147,21 +1158,21 @@ public:
       ArgNames.push_back(args[i].second);
     }
   }
-  DagInit(Init *V, std::string VN, const std::vector<Init*> &args,
+  DagInit(const Init *V, std::string VN, const std::vector<const Init*> &args,
           const std::vector<std::string> &argNames)
     : TypedInit(DagRecTy::get()), Val(V), ValName(VN), Args(args),
       ArgNames(argNames) { }
 
-  virtual Init *convertInitializerTo(RecTy *Ty) {
+  virtual const Init *convertInitializerTo(RecTy *Ty) const {
     return Ty->convertValue(this);
   }
 
-  Init *getOperator() const { return Val; }
+  const Init *getOperator() const { return Val; }
 
   const std::string &getName() const { return ValName; }
 
   unsigned getNumArgs() const { return Args.size(); }
-  Init *getArg(unsigned Num) const {
+  const Init *getArg(unsigned Num) const {
     assert(Num < Args.size() && "Arg number out of range!");
     return Args[Num];
   }
@@ -1170,11 +1181,11 @@ public:
     return ArgNames[Num];
   }
 
-  virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+  virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
 
   virtual std::string getAsString() const;
 
-  typedef std::vector<Init*>::const_iterator       const_arg_iterator;
+  typedef std::vector<const 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(); }
@@ -1189,14 +1200,15 @@ public:
   inline size_t              name_size () const { return ArgNames.size();  }
   inline bool                name_empty() const { return ArgNames.empty(); }
 
-  virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
-                                    unsigned Bit) {
+  virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+                                          unsigned Bit) const {
     assert(0 && "Illegal bit reference off dag");
     return 0;
   }
 
-  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
-                                            unsigned Elt) {
+  virtual const Init *resolveListElementReference(Record &R,
+                                                  const RecordVal *RV,
+                                                  unsigned Elt) const {
     assert(0 && "Illegal element reference off dag");
     return 0;
   }
@@ -1210,7 +1222,7 @@ class RecordVal {
   std::string Name;
   RecTy *Ty;
   unsigned Prefix;
-  Init *Value;
+  const Init *Value;
 public:
   RecordVal(const std::string &N, RecTy *T, unsigned P);
 
@@ -1218,9 +1230,9 @@ public:
 
   unsigned getPrefix() const { return Prefix; }
   RecTy *getType() const { return Ty; }
-  Init *getValue() const { return Value; }
+  const Init *getValue() const { return Value; }
 
-  bool setValue(Init *V) {
+  bool setValue(const Init *V) {
     if (V) {
       Value = V->convertInitializerTo(Ty);
       return Value == 0;
@@ -1359,7 +1371,7 @@ public:
   /// getValueInit - Return the initializer for a value with the specified name,
   /// or throw an exception if the field does not exist.
   ///
-  Init *getValueInit(StringRef FieldName) const;
+  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
@@ -1371,13 +1383,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.
   ///
-  BitsInit *getValueAsBitsInit(StringRef FieldName) const;
+  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.
   ///
-  ListInit *getValueAsListInit(StringRef FieldName) const;
+  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
@@ -1419,7 +1431,7 @@ public:
   /// value as an Dag, throwing an exception if the field does not exist or if
   /// the value is not the right type.
   ///
-  DagInit *getValueAsDag(StringRef FieldName) const;
+  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
diff --git a/utils/TableGen/RegisterInfoEmitter.cpp b/utils/TableGen/RegisterInfoEmitter.cpp
index 9587245a259..74fe2d194c2 100644
--- a/utils/TableGen/RegisterInfoEmitter.cpp
+++ b/utils/TableGen/RegisterInfoEmitter.cpp
@@ -166,7 +166,7 @@ RegisterInfoEmitter::EmitRegMapping(raw_ostream &OS,
     if (!V || !V->getValue())
       continue;
 
-    DefInit *DI = dynamic_cast<DefInit*>(V->getValue());
+    const DefInit *DI = dynamic_cast<const DefInit*>(V->getValue());
     Record *Alias = DI->getDef();
     DwarfRegNums[Reg] = DwarfRegNums[Alias];
   }
diff --git a/utils/TableGen/SetTheory.cpp b/utils/TableGen/SetTheory.cpp
index 21ac09cb662..0287269c79f 100644
--- a/utils/TableGen/SetTheory.cpp
+++ b/utils/TableGen/SetTheory.cpp
@@ -27,14 +27,14 @@ typedef SetTheory::RecVec RecVec;
 
 // (add a, b, ...) Evaluate and union all arguments.
 struct AddOp : public SetTheory::Operator {
-  void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
+  void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
     ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts);
   }
 };
 
 // (sub Add, Sub, ...) Set difference.
 struct SubOp : public SetTheory::Operator {
-  void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
+  void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
     if (Expr->arg_size() < 2)
       throw "Set difference needs at least two arguments: " +
         Expr->getAsString();
@@ -49,7 +49,7 @@ struct SubOp : public SetTheory::Operator {
 
 // (and S1, S2) Set intersection.
 struct AndOp : public SetTheory::Operator {
-  void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
+  void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
     if (Expr->arg_size() != 2)
       throw "Set intersection requires two arguments: " + Expr->getAsString();
     RecSet S1, S2;
@@ -63,16 +63,16 @@ struct AndOp : public SetTheory::Operator {
 
 // SetIntBinOp - Abstract base class for (Op S, N) operators.
 struct SetIntBinOp : public SetTheory::Operator {
-  virtual void apply2(SetTheory &ST, DagInit *Expr,
+  virtual void apply2(SetTheory &ST, const DagInit *Expr,
                      RecSet &Set, int64_t N,
                      RecSet &Elts) =0;
 
-  void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
+  void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
     if (Expr->arg_size() != 2)
       throw "Operator requires (Op Set, Int) arguments: " + Expr->getAsString();
     RecSet Set;
     ST.evaluate(Expr->arg_begin()[0], Set);
-    IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]);
+    const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]);
     if (!II)
       throw "Second argument must be an integer: " + Expr->getAsString();
     apply2(ST, Expr, Set, II->getValue(), Elts);
@@ -81,7 +81,7 @@ struct SetIntBinOp : public SetTheory::Operator {
 
 // (shl S, N) Shift left, remove the first N elements.
 struct ShlOp : public SetIntBinOp {
-  void apply2(SetTheory &ST, DagInit *Expr,
+  void apply2(SetTheory &ST, const DagInit *Expr,
              RecSet &Set, int64_t N,
              RecSet &Elts) {
     if (N < 0)
@@ -93,7 +93,7 @@ struct ShlOp : public SetIntBinOp {
 
 // (trunc S, N) Truncate after the first N elements.
 struct TruncOp : public SetIntBinOp {
-  void apply2(SetTheory &ST, DagInit *Expr,
+  void apply2(SetTheory &ST, const DagInit *Expr,
              RecSet &Set, int64_t N,
              RecSet &Elts) {
     if (N < 0)
@@ -110,7 +110,7 @@ struct RotOp : public SetIntBinOp {
 
   RotOp(bool Rev) : Reverse(Rev) {}
 
-  void apply2(SetTheory &ST, DagInit *Expr,
+  void apply2(SetTheory &ST, const DagInit *Expr,
              RecSet &Set, int64_t N,
              RecSet &Elts) {
     if (Reverse)
@@ -129,7 +129,7 @@ struct RotOp : public SetIntBinOp {
 
 // (decimate S, N) Pick every N'th element of S.
 struct DecimateOp : public SetIntBinOp {
-  void apply2(SetTheory &ST, DagInit *Expr,
+  void apply2(SetTheory &ST, const DagInit *Expr,
              RecSet &Set, int64_t N,
              RecSet &Elts) {
     if (N <= 0)
@@ -141,25 +141,25 @@ struct DecimateOp : public SetIntBinOp {
 
 // (sequence "Format", From, To) Generate a sequence of records by name.
 struct SequenceOp : public SetTheory::Operator {
-  void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
+  void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
     if (Expr->arg_size() != 3)
       throw "Bad args to (sequence \"Format\", From, To): " +
         Expr->getAsString();
     std::string Format;
-    if (StringInit *SI = dynamic_cast<StringInit*>(Expr->arg_begin()[0]))
+    if (const StringInit *SI = dynamic_cast<const StringInit*>(Expr->arg_begin()[0]))
       Format = SI->getValue();
     else
       throw "Format must be a string: " + Expr->getAsString();
 
     int64_t From, To;
-    if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]))
+    if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]))
       From = II->getValue();
     else
       throw "From must be an integer: " + Expr->getAsString();
     if (From < 0 || From >= (1 << 30))
       throw "From out of range";
 
-    if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[2]))
+    if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[2]))
       To = II->getValue();
     else
       throw "From must be an integer: " + Expr->getAsString();
@@ -167,7 +167,7 @@ struct SequenceOp : public SetTheory::Operator {
       throw "To out of range";
 
     RecordKeeper &Records =
-      dynamic_cast<DefInit&>(*Expr->getOperator()).getDef()->getRecords();
+      dynamic_cast<const DefInit&>(*Expr->getOperator()).getDef()->getRecords();
 
     int Step = From <= To ? 1 : -1;
     for (To += Step; From != To; From += Step) {
@@ -222,9 +222,9 @@ void SetTheory::addFieldExpander(StringRef ClassName, StringRef FieldName) {
   addExpander(ClassName, new FieldExpander(FieldName));
 }
 
-void SetTheory::evaluate(Init *Expr, RecSet &Elts) {
+void SetTheory::evaluate(const Init *Expr, RecSet &Elts) {
   // A def in a list can be a just an element, or it may expand.
-  if (DefInit *Def = dynamic_cast<DefInit*>(Expr)) {
+  if (const DefInit *Def = dynamic_cast<const DefInit*>(Expr)) {
     if (const RecVec *Result = expand(Def->getDef()))
       return Elts.insert(Result->begin(), Result->end());
     Elts.insert(Def->getDef());
@@ -232,14 +232,14 @@ void SetTheory::evaluate(Init *Expr, RecSet &Elts) {
   }
 
   // Lists simply expand.
-  if (ListInit *LI = dynamic_cast<ListInit*>(Expr))
+  if (const ListInit *LI = dynamic_cast<const ListInit*>(Expr))
     return evaluate(LI->begin(), LI->end(), Elts);
 
   // Anything else must be a DAG.
-  DagInit *DagExpr = dynamic_cast<DagInit*>(Expr);
+  const DagInit *DagExpr = dynamic_cast<const DagInit*>(Expr);
   if (!DagExpr)
     throw "Invalid set element: " + Expr->getAsString();
-  DefInit *OpInit = dynamic_cast<DefInit*>(DagExpr->getOperator());
+  const DefInit *OpInit = dynamic_cast<const DefInit*>(DagExpr->getOperator());
   if (!OpInit)
     throw "Bad set expression: " + Expr->getAsString();
   Operator *Op = Operators.lookup(OpInit->getDef()->getName());
diff --git a/utils/TableGen/SetTheory.h b/utils/TableGen/SetTheory.h
index 6e8313be07a..f6123c7d914 100644
--- a/utils/TableGen/SetTheory.h
+++ b/utils/TableGen/SetTheory.h
@@ -70,7 +70,7 @@ public:
 
     /// apply - Apply this operator to Expr's arguments and insert the result
     /// in Elts.
-    virtual void apply(SetTheory&, DagInit *Expr, RecSet &Elts) =0;
+    virtual void apply(SetTheory&, const DagInit *Expr, RecSet &Elts) =0;
   };
 
   /// Expander - A callback function that can transform a Record representing a
@@ -115,7 +115,7 @@ public:
   void addOperator(StringRef Name, Operator*);
 
   /// evaluate - Evaluate Expr and append the resulting set to Elts.
-  void evaluate(Init *Expr, RecSet &Elts);
+  void evaluate(const Init *Expr, RecSet &Elts);
 
   /// evaluate - Evaluate a sequence of Inits and append to Elts.
   template<typename Iter>
diff --git a/utils/TableGen/TGParser.cpp b/utils/TableGen/TGParser.cpp
index d8f5d6301f1..1565959a69b 100644
--- a/utils/TableGen/TGParser.cpp
+++ b/utils/TableGen/TGParser.cpp
@@ -28,7 +28,7 @@ namespace llvm {
 struct SubClassReference {
   SMLoc RefLoc;
   Record *Rec;
-  std::vector<Init*> TemplateArgs;
+  std::vector<const Init*> TemplateArgs;
   SubClassReference() : Rec(0) {}
 
   bool isInvalid() const { return Rec == 0; }
@@ -37,7 +37,7 @@ struct SubClassReference {
 struct SubMultiClassReference {
   SMLoc RefLoc;
   MultiClass *MC;
-  std::vector<Init*> TemplateArgs;
+  std::vector<const Init*> TemplateArgs;
   SubMultiClassReference() : MC(0) {}
 
   bool isInvalid() const { return MC == 0; }
@@ -50,7 +50,7 @@ void SubMultiClassReference::dump() const {
   MC->dump();
 
   errs() << "Template args:\n";
-  for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(),
+  for (std::vector<const Init *>::const_iterator i = TemplateArgs.begin(),
          iend = TemplateArgs.end();
        i != iend;
        ++i) {
@@ -80,7 +80,7 @@ bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
 /// SetValue -
 /// Return true on error, false on success.
 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
-                        const std::vector<unsigned> &BitList, Init *V) {
+                        const std::vector<unsigned> &BitList, const Init *V) {
   if (!V) return false;
 
   if (CurRec == 0) CurRec = &CurMultiClass->Rec;
@@ -92,7 +92,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
   // Do not allow assignments like 'X = X'.  This will just cause infinite loops
   // in the resolution machinery.
   if (BitList.empty())
-    if (VarInit *VI = dynamic_cast<VarInit*>(V))
+    if (const VarInit *VI = dynamic_cast<const VarInit*>(V))
       if (VI->getName() == ValName)
         return false;
 
@@ -101,22 +101,22 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
   // initializer.
   //
   if (!BitList.empty()) {
-    BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
+    const BitsInit *CurVal = dynamic_cast<const BitsInit*>(RV->getValue());
     if (CurVal == 0)
       return Error(Loc, "Value '" + ValName + "' 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()));
+    const Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
     if (BI == 0) {
       V->convertInitializerTo(BitsRecTy::get(BitList.size()));
       return Error(Loc, "Initializer is not compatible with bit range");
     }
 
     // We should have a BitsInit type now.
-    BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
+    const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI);
     assert(BInit != 0);
 
-    SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
+    SmallVector<const Init *, 16> NewBits(CurVal->getNumBits());
 
     // Loop over bits, assigning values as appropriate.
     for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
@@ -131,7 +131,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
       if (NewBits[i] == 0)
         NewBits[i] = CurVal->getBit(i);
 
-    V = new BitsInit(ArrayRef<Init *>(NewBits));
+    V = new BitsInit(ArrayRef<const Init *>(NewBits));
   }
 
   if (RV->setValue(V))
@@ -633,7 +633,7 @@ RecTy *TGParser::ParseType() {
 ///  IDValue ::= ID [multiclass template argument]
 ///  IDValue ::= ID [def name]
 ///
-Init *TGParser::ParseIDValue(Record *CurRec) {
+const Init *TGParser::ParseIDValue(Record *CurRec) {
   assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
   std::string Name = Lex.getCurStrVal();
   SMLoc Loc = Lex.getLoc();
@@ -643,7 +643,7 @@ Init *TGParser::ParseIDValue(Record *CurRec) {
 
 /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
 /// has already been read.
-Init *TGParser::ParseIDValue(Record *CurRec,
+const Init *TGParser::ParseIDValue(Record *CurRec,
                              const std::string &Name, SMLoc NameLoc) {
   if (CurRec) {
     if (const RecordVal *RV = CurRec->getValue(Name))
@@ -677,7 +677,7 @@ Init *TGParser::ParseIDValue(Record *CurRec,
 ///
 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
 ///
-Init *TGParser::ParseOperation(Record *CurRec) {
+const Init *TGParser::ParseOperation(Record *CurRec) {
   switch (Lex.getCode()) {
   default:
     TokError("unknown operation");
@@ -724,15 +724,15 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     }
     Lex.Lex();  // eat the '('
 
-    Init *LHS = ParseValue(CurRec);
+    const Init *LHS = ParseValue(CurRec);
     if (LHS == 0) return 0;
 
     if (Code == UnOpInit::HEAD
         || Code == UnOpInit::TAIL
         || Code == UnOpInit::EMPTY) {
-      ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
-      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
-      TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
+      const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+      const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+      const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
       if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
         TokError("expected list or string type argument in unary operator");
         return 0;
@@ -758,8 +758,8 @@ Init *TGParser::ParseOperation(Record *CurRec) {
           return 0;
         }
         if (LHSl) {
-          Init *Item = LHSl->getElement(0);
-          TypedInit *Itemt = dynamic_cast<TypedInit*>(Item);
+          const Init *Item = LHSl->getElement(0);
+          const TypedInit *Itemt = dynamic_cast<const TypedInit*>(Item);
           if (Itemt == 0) {
             TokError("untyped list element in unary operator");
             return 0;
@@ -825,7 +825,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     }
     Lex.Lex();  // eat the '('
 
-    SmallVector<Init*, 2> InitList;
+    SmallVector<const Init*, 2> InitList;
 
     InitList.push_back(ParseValue(CurRec));
     if (InitList.back() == 0) return 0;
@@ -847,7 +847,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     // shorthand for nesting them.
     if (Code == BinOpInit::STRCONCAT) {
       while (InitList.size() > 2) {
-        Init *RHS = InitList.pop_back_val();
+        const Init *RHS = InitList.pop_back_val();
         RHS = (new BinOpInit(Code, InitList.back(), RHS, Type))
                       ->Fold(CurRec, CurMultiClass);
         InitList.back() = RHS;
@@ -888,7 +888,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     }
     Lex.Lex();  // eat the '('
 
-    Init *LHS = ParseValue(CurRec);
+    const Init *LHS = ParseValue(CurRec);
     if (LHS == 0) return 0;
 
     if (Lex.getCode() != tgtok::comma) {
@@ -897,7 +897,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     }
     Lex.Lex();  // eat the ','
 
-    Init *MHS = ParseValue(CurRec);
+    const Init *MHS = ParseValue(CurRec);
     if (MHS == 0) return 0;
 
     if (Lex.getCode() != tgtok::comma) {
@@ -906,7 +906,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     }
     Lex.Lex();  // eat the ','
 
-    Init *RHS = ParseValue(CurRec);
+    const Init *RHS = ParseValue(CurRec);
     if (RHS == 0) return 0;
 
     if (Lex.getCode() != tgtok::r_paren) {
@@ -920,23 +920,23 @@ Init *TGParser::ParseOperation(Record *CurRec) {
     case tgtok::XIf: {
       // FIXME: The `!if' operator doesn't handle non-TypedInit well at
       // all. This can be made much more robust.
-      TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS);
-      TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS);
+      const TypedInit *MHSt = dynamic_cast<const TypedInit*>(MHS);
+      const TypedInit *RHSt = dynamic_cast<const TypedInit*>(RHS);
 
       RecTy *MHSTy = 0;
       RecTy *RHSTy = 0;
 
       if (MHSt == 0 && RHSt == 0) {
-        BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS);
-        BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS);
+        const BitsInit *MHSbits = dynamic_cast<const BitsInit*>(MHS);
+        const BitsInit *RHSbits = dynamic_cast<const BitsInit*>(RHS);
 
         if (MHSbits && RHSbits &&
             MHSbits->getNumBits() == RHSbits->getNumBits()) {
           Type = BitRecTy::get();
           break;
         } else {
-          BitInit *MHSbit = dynamic_cast<BitInit*>(MHS);
-          BitInit *RHSbit = dynamic_cast<BitInit*>(RHS);
+          const BitInit *MHSbit = dynamic_cast<const BitInit*>(MHS);
+          const BitInit *RHSbit = dynamic_cast<const BitInit*>(RHS);
 
           if (MHSbit && RHSbit) {
             Type = BitRecTy::get();
@@ -964,7 +964,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
       break;
     }
     case tgtok::XForEach: {
-      TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS);
+      const TypedInit *MHSt = dynamic_cast<const TypedInit *>(MHS);
       if (MHSt == 0) {
         TokError("could not get type for !foreach");
         return 0;
@@ -973,7 +973,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
       break;
     }
     case tgtok::XSubst: {
-      TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS);
+      const TypedInit *RHSt = dynamic_cast<const TypedInit *>(RHS);
       if (RHSt == 0) {
         TokError("could not get type for !subst");
         return 0;
@@ -1038,8 +1038,8 @@ RecTy *TGParser::ParseOperatorType() {
 ///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
 ///
-Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
-  Init *R = 0;
+const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
+  const Init *R = 0;
   switch (Lex.getCode()) {
   default: TokError("Unknown token when parsing a value"); break;
   case tgtok::IntVal: R = new IntInit(Lex.getCurIntVal()); Lex.Lex(); break;
@@ -1085,7 +1085,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
       return 0;
     }
 
-    std::vector<Init*> ValueList = ParseValueList(CurRec, Class);
+    std::vector<const Init*> ValueList = ParseValueList(CurRec, Class);
     if (ValueList.empty()) return 0;
 
     if (Lex.getCode() != tgtok::greater) {
@@ -1115,7 +1115,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
   case tgtok::l_brace: {           // Value ::= '{' ValueList '}'
     SMLoc BraceLoc = Lex.getLoc();
     Lex.Lex(); // eat the '{'
-    std::vector<Init*> Vals;
+    std::vector<const Init*> Vals;
 
     if (Lex.getCode() != tgtok::r_brace) {
       Vals = ParseValueList(CurRec);
@@ -1127,10 +1127,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
     }
     Lex.Lex();  // eat the '}'
 
-    SmallVector<Init *, 16> NewBits(Vals.size());
+    SmallVector<const Init *, 16> NewBits(Vals.size());
 
     for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
-      Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
+      const Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
       if (Bit == 0) {
         Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
               ") is not convertable to a bit");
@@ -1138,11 +1138,11 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
       }
       NewBits[Vals.size()-i-1] = Bit;
     }
-    return new BitsInit(ArrayRef<Init *>(NewBits));
+    return new BitsInit(ArrayRef<const Init *>(NewBits));
   }
   case tgtok::l_square: {          // Value ::= '[' ValueList ']'
     Lex.Lex(); // eat the '['
-    std::vector<Init*> Vals;
+    std::vector<const Init*> Vals;
 
     RecTy *DeducedEltTy = 0;
     ListRecTy *GivenListTy = 0;
@@ -1190,10 +1190,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
 
     // Check elements
     RecTy *EltTy = 0;
-    for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
+    for (std::vector<const Init *>::iterator i = Vals.begin(), ie = Vals.end();
          i != ie;
          ++i) {
-      TypedInit *TArg = dynamic_cast<TypedInit*>(*i);
+      const TypedInit *TArg = dynamic_cast<const TypedInit*>(*i);
       if (TArg == 0) {
         TokError("Untyped list element");
         return 0;
@@ -1246,7 +1246,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
       return 0;
     }
 
-    Init *Operator = ParseValue(CurRec);
+    const Init *Operator = ParseValue(CurRec);
     if (Operator == 0) return 0;
 
     // If the operator name is present, parse it.
@@ -1260,7 +1260,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
       Lex.Lex();  // eat the VarName.
     }
 
-    std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
+    std::vector<std::pair<const llvm::Init*, std::string> > DagArgs;
     if (Lex.getCode() != tgtok::r_paren) {
       DagArgs = ParseDagArgList(CurRec);
       if (DagArgs.empty()) return 0;
@@ -1302,8 +1302,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
 ///   ValueSuffix ::= '[' BitList ']'
 ///   ValueSuffix ::= '.' ID
 ///
-Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
-  Init *Result = ParseSimpleValue(CurRec, ItemType);
+const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
+  const Init *Result = ParseSimpleValue(CurRec, ItemType);
   if (Result == 0) return 0;
 
   // Parse the suffixes now if present.
@@ -1373,20 +1373,20 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
 ///
 ///    ParseDagArgList ::= Value (':' VARNAME)?
 ///    ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
-std::vector<std::pair<llvm::Init*, std::string> >
+std::vector<std::pair<const llvm::Init*, std::string> >
 TGParser::ParseDagArgList(Record *CurRec) {
-  std::vector<std::pair<llvm::Init*, std::string> > Result;
+  std::vector<std::pair<const llvm::Init*, std::string> > Result;
 
   while (1) {
-    Init *Val = ParseValue(CurRec);
-    if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
+    const Init *Val = ParseValue(CurRec);
+    if (Val == 0) return std::vector<std::pair<const llvm::Init*, std::string> >();
 
     // If the variable name is present, add it.
     std::string VarName;
     if (Lex.getCode() == tgtok::colon) {
       if (Lex.Lex() != tgtok::VarName) { // eat the ':'
         TokError("expected variable name in dag literal");
-        return std::vector<std::pair<llvm::Init*, std::string> >();
+        return std::vector<std::pair<const llvm::Init*, std::string> >();
       }
       VarName = Lex.getCurStrVal();
       Lex.Lex();  // eat the VarName.
@@ -1408,9 +1408,9 @@ TGParser::ParseDagArgList(Record *CurRec) {
 ///
 ///   ValueList ::= Value (',' Value)
 ///
-std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
+std::vector<const Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
                                             RecTy *EltTy) {
-  std::vector<Init*> Result;
+  std::vector<const Init*> Result;
   RecTy *ItemType = EltTy;
   unsigned int ArgN = 0;
   if (ArgsRec != 0 && EltTy == 0) {
@@ -1421,7 +1421,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
     ++ArgN;
   }
   Result.push_back(ParseValue(CurRec, ItemType));
-  if (Result.back() == 0) return std::vector<Init*>();
+  if (Result.back() == 0) return std::vector<const Init*>();
 
   while (Lex.getCode() == tgtok::comma) {
     Lex.Lex();  // Eat the comma
@@ -1430,7 +1430,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
       const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs();
       if (ArgN >= TArgs.size()) {
         TokError("too many template arguments");
-        return std::vector<Init*>();
+        return std::vector<const Init*>();
       }
       const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
       assert(RV && "Template argument record not found??");
@@ -1438,7 +1438,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
       ++ArgN;
     }
     Result.push_back(ParseValue(CurRec, ItemType));
-    if (Result.back() == 0) return std::vector<Init*>();
+    if (Result.back() == 0) return std::vector<const Init*>();
   }
 
   return Result;
@@ -1491,7 +1491,7 @@ std::string TGParser::ParseDeclaration(Record *CurRec,
   if (Lex.getCode() == tgtok::equal) {
     Lex.Lex();
     SMLoc ValLoc = Lex.getLoc();
-    Init *Val = ParseValue(CurRec, Type);
+    const Init *Val = ParseValue(CurRec, Type);
     if (Val == 0 ||
         SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
       return "";
@@ -1575,7 +1575,7 @@ bool TGParser::ParseBodyItem(Record *CurRec) {
 
   RecTy *Type = Field->getType();
 
-  Init *Val = ParseValue(CurRec, Type);
+  const Init *Val = ParseValue(CurRec, Type);
   if (Val == 0) return true;
 
   if (Lex.getCode() != tgtok::semi)
@@ -1775,7 +1775,7 @@ std::vector<LetRecord> TGParser::ParseLetList() {
     }
     Lex.Lex();  // eat the '='.
 
-    Init *Val = ParseValue(0);
+    const Init *Val = ParseValue(0);
     if (Val == 0) return std::vector<LetRecord>();
 
     // Now that we have everything, add the record.
@@ -1949,7 +1949,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
     // template parameters.
     MultiClass *MC = MultiClasses[Ref.Rec->getName()];
     assert(MC && "Didn't lookup multiclass correctly?");
-    std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
+    std::vector<const Init*> &TemplateVals = Ref.TemplateArgs;
 
     // Verify that the correct number of template arguments were specified.
     const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs();
diff --git a/utils/TableGen/TGParser.h b/utils/TableGen/TGParser.h
index 8b56b8a3290..17de468a054 100644
--- a/utils/TableGen/TGParser.h
+++ b/utils/TableGen/TGParser.h
@@ -33,9 +33,9 @@ namespace llvm {
   struct LetRecord {
     std::string Name;
     std::vector<unsigned> Bits;
-    Init *Value;
+    const Init *Value;
     SMLoc Loc;
-    LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
+    LetRecord(const std::string &N, const std::vector<unsigned> &B, const Init *V,
               SMLoc L)
       : Name(N), Bits(B), Value(V), Loc(L) {
     }
@@ -73,7 +73,7 @@ public:
 private:  // Semantic analysis methods.
   bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
   bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName, 
-                const std::vector<unsigned> &BitList, Init *V);
+                const std::vector<unsigned> &BitList, const Init *V);
   bool AddSubClass(Record *Rec, SubClassReference &SubClass);
   bool AddSubMultiClass(MultiClass *CurMC,
                         SubMultiClassReference &SubMultiClass);
@@ -98,18 +98,18 @@ private:  // Parser methods.
   SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
   SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
 
-  Init *ParseIDValue(Record *CurRec);
-  Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
-  Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
-  Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
-  std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
-  std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
+  const Init *ParseIDValue(Record *CurRec);
+  const Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
+  const Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
+  const Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
+  std::vector<const Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
+  std::vector<std::pair<const llvm::Init*, std::string> > ParseDagArgList(Record *);
   bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
   bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
   std::vector<unsigned> ParseRangeList();
   bool ParseRangePiece(std::vector<unsigned> &Ranges);
   RecTy *ParseType();
-  Init *ParseOperation(Record *CurRec);
+  const Init *ParseOperation(Record *CurRec);
   RecTy *ParseOperatorType();
   std::string ParseObjectName();
   Record *ParseClassID();
diff --git a/utils/TableGen/X86RecognizableInstr.cpp b/utils/TableGen/X86RecognizableInstr.cpp
index 3071d8e2743..998476954ea 100644
--- a/utils/TableGen/X86RecognizableInstr.cpp
+++ b/utils/TableGen/X86RecognizableInstr.cpp
@@ -162,7 +162,7 @@ static bool isRegFormat(uint8_t form) {
 /// @param init - A reference to the BitsInit to be decoded.
 /// @return     - The field, with the first bit in the BitsInit as the lowest
 ///               order bit.
-static uint8_t byteFromBitsInit(BitsInit &init) {
+static uint8_t byteFromBitsInit(const BitsInit &init) {
   int width = init.getNumBits();
 
   assert(width <= 8 && "Field is too large for uint8_t!");
@@ -173,7 +173,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) {
   uint8_t ret = 0;
 
   for (index = 0; index < width; index++) {
-    if (static_cast<BitInit*>(init.getBit(index))->getValue())
+    if (static_cast<const BitInit*>(init.getBit(index))->getValue())
       ret |= mask;
 
     mask <<= 1;
@@ -189,7 +189,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) {
 /// @param name - The name of the field in the record.
 /// @return     - The field, as translated by byteFromBitsInit().
 static uint8_t byteFromRec(const Record* rec, const std::string &name) {
-  BitsInit* bits = rec->getValueAsBitsInit(name);
+  const BitsInit* bits = rec->getValueAsBitsInit(name);
   return byteFromBitsInit(*bits);
 }