[AVX] Make Inits Foldable

Manage Inits in a FoldingSet.  This provides several benefits:

- Memory for Inits is properly managed

- Duplicate Inits are folded into Flyweights, saving memory

- It enforces const-correctness, protecting against certain classes
  of bugs

The above benefits allow Inits to be used in more contexts, which in
turn provides more dynamism to TableGen.  This enhanced capability
will be used by the AVX code generator to a fold common patterns
together.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134907 91177308-0d34-0410-b5e6-96231b3b80d8

31 files changed, 1708 insertions, 998 deletions

diff --git a/utils/TableGen/ARMDecoderEmitter.cpp b/utils/TableGen/ARMDecoderEmitter.cpp
index 8a5dc8ba15..3721ed41b2 100644
--- a/utils/TableGen/ARMDecoderEmitter.cpp
+++ b/utils/TableGen/ARMDecoderEmitter.cpp
@@ -114,7 +114,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!");
@@ -125,7 +125,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;
@@ -135,12 +135,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;
 }
 
@@ -183,15 +183,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--) {
@@ -424,7 +424,8 @@ 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);
@@ -1558,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 d9c3b84d6c..3236a199bb 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 c51afd82a3..37758bc1cf 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 26bd8786a4..bca4bb61c2 100644
--- a/utils/TableGen/ClangAttrEmitter.cpp
+++ b/utils/TableGen/ClangAttrEmitter.cpp
@@ -21,17 +21,19 @@ 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;
   Strings.reserve(List->getSize());
 
-  for (ListInit::iterator i = List->begin(), e = List->end(); i != e; ++i) {
+  for (ListInit::const_iterator i = List->begin(), e = List->end();
+       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 0a48e75681..debed97d67 100644
--- a/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -74,7 +74,8 @@ 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 +160,8 @@ 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 +227,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 97739c6b3f..fe54b3689a 100644
--- a/utils/TableGen/ClangSACheckersEmitter.cpp
+++ b/utils/TableGen/ClangSACheckersEmitter.cpp
@@ -28,7 +28,8 @@ 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 +43,8 @@ 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 +65,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 +131,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 +151,23 @@ 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 +208,8 @@ 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 +237,8 @@ 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 d828dfc25d..4b67854d3e 100644
--- a/utils/TableGen/CodeEmitterGen.cpp
+++ b/utils/TableGen/CodeEmitterGen.cpp
@@ -38,21 +38,25 @@ 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();
-    BitsInit *NewBI = new BitsInit(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);
-      NewBI->setBit(bit, BitSwap);
-      NewBI->setBit(bitSwapIdx, OrigBit);
+      const Init *OrigBit = BI->getBit(bit);
+      const Init *BitSwap = BI->getBit(bitSwapIdx);
+      NewBits[bit]        = BitSwap;
+      NewBits[bitSwapIdx] = OrigBit;
     }
     if (numBits % 2) {
       unsigned middle = (numBits + 1) / 2;
-      NewBI->setBit(middle, BI->getBit(middle));
+      NewBits[middle] = BI->getBit(middle);
     }
+ 
+    const BitsInit *NewBI = BitsInit::Create(NewBits.begin(), NewBits.end());
 
     // Update the bits in reversed order so that emitInstrOpBits will get the
     // correct endianness.
@@ -63,12 +67,14 @@ 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;
   }
@@ -77,8 +83,8 @@ int CodeEmitterGen::getVariableBit(const std::string &VarName,
 }
 
 void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
-                        unsigned &NumberedOp,
+AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
+                        const std::string &VarName, unsigned &NumberedOp,
                         std::string &Case, CodeGenTarget &Target) {
   CodeGenInstruction &CGI = Target.getInstruction(R);
 
@@ -181,7 +187,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;
 
@@ -238,12 +244,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 a874d970fe..af890bfe24 100644
--- a/utils/TableGen/CodeEmitterGen.h
+++ b/utils/TableGen/CodeEmitterGen.h
@@ -35,11 +35,11 @@ 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,
-                          unsigned &NumberedOp,
+  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 072893fe5a..a73da717c1 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,8 @@ 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 +867,13 @@ 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 +1023,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 +1100,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 +1157,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 +1321,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 +1331,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 +1384,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 +1393,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 +1653,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 +1703,14 @@ bool TreePatternNode::canPatternMatch(std::string &Reason,
 // TreePattern implementation
 //
 
-TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
+TreePattern::TreePattern(Record *TheRec, const ListInit