[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

1 files changed, 16 insertions, 15 deletions

diff --git a/utils/TableGen/CodeGenRegisters.cpp b/utils/TableGen/CodeGenRegisters.cpp
index 1acf3a85b60..2e82ae5a3a4 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() +