1 files changed, 16 insertions, 15 deletions

diff --git a/utils/TableGen/CodeGenRegisters.cpp b/utils/TableGen/CodeGenRegisters.cpp
index 1acf3a85b6..2e82ae5a3a 100644
--- a/utils/TableGen/CodeGenRegisters.cpp
+++ b/utils/TableGen/CodeGenRegisters.cpp
@@ -91,14 +91,15 @@ 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 +108,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 +164,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,19 +184,19 @@ struct TupleExpander : SetTheory::Expander {
     // Precompute some types.
     Record *RegisterCl = Def->getRecords().getClass("Register");
     RecTy *RegisterRecTy = new RecordRecTy(RegisterCl);
-    StringInit *BlankName = new StringInit("");
+    const StringInit *BlankName = StringInit::Create("");
 
     // 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];
         if (i) Name += '_';
         Name += Reg->getName();
-        Tuple.push_back(new DefInit(Reg));
+        Tuple.push_back(DefInit::Create(Reg));
         CostPerUse = std::max(CostPerUse,
                               unsigned(Reg->getValueAsInt("CostPerUse")));
       }
@@ -216,7 +217,7 @@ struct TupleExpander : SetTheory::Expander {
 
         // Replace the sub-register list with Tuple.
         if (RV.getName() == "SubRegs")
-          RV.setValue(new ListInit(Tuple, RegisterRecTy));
+          RV.setValue(ListInit::Create(Tuple, RegisterRecTy));
 
         // Provide a blank AsmName. MC hacks are required anyway.
         if (RV.getName() == "AsmName")
@@ -224,7 +225,7 @@ struct TupleExpander : SetTheory::Expander {
 
         // CostPerUse is aggregated from all Tuple members.
         if (RV.getName() == "CostPerUse")
-          RV.setValue(new IntInit(CostPerUse));
+          RV.setValue(IntInit::Create(CostPerUse));
 
         // Copy fields from the RegisterTuples def.
         if (RV.getName() == "SubRegIndices" ||
@@ -278,7 +279,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 +296,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 +308,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() +