Revert r134921, 134917, 134908 and 134907. They're causing failures

in multiple buildbots.


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

1 files changed, 317 insertions, 651 deletions

diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp
index a373806508..730eca1b3c 100644
--- a/utils/TableGen/Record.cpp
+++ b/utils/TableGen/Record.cpp
@@ -15,8 +15,6 @@
 #include "Error.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Format.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace llvm;
@@ -27,7 +25,7 @@ using namespace llvm;
 
 void RecTy::dump() const { print(errs()); }
 
-const Init *BitRecTy::convertValue(const BitsInit *BI) {
+Init *BitRecTy::convertValue(BitsInit *BI) {
   if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
   return BI->getBit(0);
 }
@@ -36,14 +34,14 @@ bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const {
   return RHS->getNumBits() == 1;
 }
 
-const Init *BitRecTy::convertValue(const IntInit *II) {
+Init *BitRecTy::convertValue(IntInit *II) {
   int64_t Val = II->getValue();
   if (Val != 0 && Val != 1) return 0;  // Only accept 0 or 1 for a bit!
 
-  return BitInit::get(Val != 0);
+  return new BitInit(Val != 0);
 }
 
-const Init *BitRecTy::convertValue(const TypedInit *VI) {
+Init *BitRecTy::convertValue(TypedInit *VI) {
   if (dynamic_cast<BitRecTy*>(VI->getType()))
     return VI;  // Accept variable if it is already of bit type!
   return 0;
@@ -53,21 +51,19 @@ std::string BitsRecTy::getAsString() const {
   return "bits<" + utostr(Size) + ">";
 }
 
-const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
-  SmallVector<const Init *, 16> Bits(Size);
+Init *BitsRecTy::convertValue(UnsetInit *UI) {
+  BitsInit *Ret = new BitsInit(Size);
 
   for (unsigned i = 0; i != Size; ++i)
-    Bits[i] = UnsetInit::get();
- 
-  return BitsInit::get(Bits.begin(), Bits.end());
+    Ret->setBit(i, new UnsetInit());
+  return Ret;
 }
 
-const Init *BitsRecTy::convertValue(const BitInit *UI) {
+Init *BitsRecTy::convertValue(BitInit *UI) {
   if (Size != 1) return 0;  // Can only convert single bit.
-
-  const Init *Bits[1] = { UI };
-
-  return BitsInit::get(Bits, array_endof(Bits));
+  BitsInit *Ret = new BitsInit(1);
+  Ret->setBit(0, UI);
+  return Ret;
 }
 
 /// canFitInBitfield - Return true if the number of bits is large enough to hold
@@ -78,85 +74,82 @@ static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
          (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
 }
 
-/// convertValue from Int initializer to bits type: Split the integer
-/// up into the appropriate bits.
+/// convertValue from Int initializer to bits type: Split the integer up into the
+/// appropriate bits.
 ///
-const Init *BitsRecTy::convertValue(const IntInit *II) {
+Init *BitsRecTy::convertValue(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<const Init *, 16> Bits(Size); 
-
+  BitsInit *Ret = new BitsInit(Size);
   for (unsigned i = 0; i != Size; ++i)
-    Bits[i] = BitInit::get(Value & (1LL << i));
+    Ret->setBit(i, new BitInit(Value & (1LL << i)));
 
-  return BitsInit::get(Bits.begin(), Bits.end());
+  return Ret;
 }
 
-const Init *BitsRecTy::convertValue(const BitsInit *BI) {
+Init *BitsRecTy::convertValue(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;
 }
 
-const Init *BitsRecTy::convertValue(const TypedInit *VI) {
+Init *BitsRecTy::convertValue(TypedInit *VI) {
   if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
     if (BRT->Size == Size) {
-      SmallVector<const Init *, 16> Bits(Size);
- 
+      BitsInit *Ret = new BitsInit(Size);
       for (unsigned i = 0; i != Size; ++i)
-         Bits[i] = VarBitInit::get(VI, i);
-      return BitsInit::get(Bits.begin(), Bits.end());
+        Ret->setBit(i, new VarBitInit(VI, i));
+      return Ret;
     }
 
   if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
-    const Init *Bits[1] = { VI };
- 
-    return BitsInit::get(Bits, array_endof(Bits));
+    BitsInit *Ret = new BitsInit(1);
+    Ret->setBit(0, VI);
+    return Ret;
   }
 
-  if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) {
+  if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
     if (Tern->getOpcode() == TernOpInit::IF) {
-      const Init *LHS = Tern->getLHS();
-      const Init *MHS = Tern->getMHS();
-      const Init *RHS = Tern->getRHS();
+      Init *LHS = Tern->getLHS();
+      Init *MHS = Tern->getMHS();
+      Init *RHS = Tern->getRHS();
 
-      const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS);
-      const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+      IntInit *MHSi = dynamic_cast<IntInit*>(MHS);
+      IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
 
       if (MHSi && RHSi) {
         int64_t MHSVal = MHSi->getValue();
         int64_t RHSVal = RHSi->getValue();
 
         if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
-          SmallVector<const Init *, 16> NewBits(Size);
+          BitsInit *Ret = new BitsInit(Size);
 
           for (unsigned i = 0; i != Size; ++i)
-            NewBits[i] =
-              TernOpInit::get(TernOpInit::IF, LHS,
-                                 IntInit::get((MHSVal & (1LL << i)) ? 1 : 0),
-                                 IntInit::get((RHSVal & (1LL << i)) ? 1 : 0),
-                                 VI->getType());
-          
-          return BitsInit::get(NewBits.begin(), NewBits.end());
+            Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
+                                          new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
+                                          new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
+                                          VI->getType()));
+
+          return Ret;
         }
       } else {
-        const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS);
-        const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS);
+        BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
+        BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
 
         if (MHSbs && RHSbs) {
-          SmallVector<const Init *, 16> NewBits(Size);
+          BitsInit *Ret = new BitsInit(Size);
 
           for (unsigned i = 0; i != Size; ++i)
-            NewBits[i] = TernOpInit::get(TernOpInit::IF, LHS,
-                                            MHSbs->getBit(i),
-                                            RHSbs->getBit(i),
-                                            VI->getType());
+            Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
+                                          MHSbs->getBit(i),
+                                          RHSbs->getBit(i),
+                                          VI->getType()));
 
-          return BitsInit::get(NewBits.begin(), NewBits.end());
+          return Ret;
         }
       }
     }
@@ -165,54 +158,54 @@ const Init *BitsRecTy::convertValue(const TypedInit *VI) {
   return 0;
 }
 
-const Init *IntRecTy::convertValue(const BitInit *BI) {
-  return IntInit::get(BI->getValue());
+Init *IntRecTy::convertValue(BitInit *BI) {
+  return new IntInit(BI->getValue());
 }
 
-const Init *IntRecTy::convertValue(const BitsInit *BI) {
+Init *IntRecTy::convertValue(BitsInit *BI) {
   int64_t Result = 0;
   for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
-    if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) {
+    if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
       Result |= Bit->getValue() << i;
     } else {
       return 0;
     }
-  return IntInit::get(Result);
+  return new IntInit(Result);
 }
 
-const Init *IntRecTy::convertValue(const TypedInit *TI) {
+Init *IntRecTy::convertValue(TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;  // Accept variable if already of the right type!
   return 0;
 }
 
-const Init *StringRecTy::convertValue(const UnOpInit *BO) {
+Init *StringRecTy::convertValue(UnOpInit *BO) {
   if (BO->getOpcode() == UnOpInit::CAST) {
-    const Init *L = BO->getOperand()->convertInitializerTo(this);
+    Init *L = BO->getOperand()->convertInitializerTo(this);
     if (L == 0) return 0;
     if (L != BO->getOperand())
-      return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy);
+      return new UnOpInit(UnOpInit::CAST, L, new StringRecTy);
     return BO;
   }
 
-  return convertValue((const TypedInit*)BO);
+  return convertValue((TypedInit*)BO);
 }
 
-const Init *StringRecTy::convertValue(const BinOpInit *BO) {
+Init *StringRecTy::convertValue(BinOpInit *BO) {
   if (BO->getOpcode() == BinOpInit::STRCONCAT) {
-    const Init *L = BO->getLHS()->convertInitializerTo(this);
-    const Init *R = BO->getRHS()->convertInitializerTo(this);
+    Init *L = BO->getLHS()->convertInitializerTo(this);
+    Init *R = BO->getRHS()->convertInitializerTo(this);
     if (L == 0 || R == 0) return 0;
     if (L != BO->getLHS() || R != BO->getRHS())
-      return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy);
+      return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy);
     return BO;
   }
 
-  return convertValue((const TypedInit*)BO);
+  return convertValue((TypedInit*)BO);
 }
 
 
-const Init *StringRecTy::convertValue(const TypedInit *TI) {
+Init *StringRecTy::convertValue(TypedInit *TI) {
   if (dynamic_cast<StringRecTy*>(TI->getType()))
     return TI;  // Accept variable if already of the right type!
   return 0;
@@ -222,13 +215,13 @@ std::string ListRecTy::getAsString() const {
   return "list<" + Ty->getAsString() + ">";
 }
 
-const Init *ListRecTy::convertValue(const ListInit *LI) {
-  std::vector<const Init*> Elements;
+Init *ListRecTy::convertValue(ListInit *LI) {
+  std::vector<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 (const Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
+    if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
       Elements.push_back(CI);
     else
       return 0;
@@ -238,10 +231,10 @@ const Init *ListRecTy::convertValue(const ListInit *LI) {
     return 0;
   }
 
-  return ListInit::get(Elements, new ListRecTy(Ty));
+  return new ListInit(Elements, new ListRecTy(Ty));
 }
 
-const Init *ListRecTy::convertValue(const TypedInit *TI) {
+Init *ListRecTy::convertValue(TypedInit *TI) {
   // Ensure that TI is compatible with our class.
   if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
     if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
@@ -249,36 +242,36 @@ const Init *ListRecTy::convertValue(const TypedInit *TI) {
   return 0;
 }
 
-const Init *CodeRecTy::convertValue(const TypedInit *TI) {
+Init *CodeRecTy::convertValue(TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;
   return 0;
 }
 
-const Init *DagRecTy::convertValue(const TypedInit *TI) {
+Init *DagRecTy::convertValue(TypedInit *TI) {
   if (TI->getType()->typeIsConvertibleTo(this))
     return TI;
   return 0;
 }
 
-const Init *DagRecTy::convertValue(const UnOpInit *BO) {
+Init *DagRecTy::convertValue(UnOpInit *BO) {
   if (BO->getOpcode() == UnOpInit::CAST) {
-    const Init *L = BO->getOperand()->convertInitializerTo(this);
+    Init *L = BO->getOperand()->convertInitializerTo(this);
     if (L == 0) return 0;
     if (L != BO->getOperand())
-      return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy);
+      return new UnOpInit(UnOpInit::CAST, L, new DagRecTy);
     return BO;
   }
   return 0;
 }
 
-const Init *DagRecTy::convertValue(const BinOpInit *BO) {
+Init *DagRecTy::convertValue(BinOpInit *BO) {
   if (BO->getOpcode() == BinOpInit::CONCAT) {
-    const Init *L = BO->getLHS()->convertInitializerTo(this);
-    const Init *R = BO->getRHS()->convertInitializerTo(this);
+    Init *L = BO->getLHS()->convertInitializerTo(this);
+    Init *R = BO->getRHS()->convertInitializerTo(this);
     if (L == 0 || R == 0) return 0;
     if (L != BO->getLHS() || R != BO->getRHS())
-      return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy);
+      return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy);
     return BO;
   }
   return 0;
@@ -288,14 +281,14 @@ std::string RecordRecTy::getAsString() const {
   return Rec->getName();
 }
 
-const Init *RecordRecTy::convertValue(const DefInit *DI) {
+Init *RecordRecTy::convertValue(DefInit *DI) {
   // Ensure that DI is a subclass of Rec.
   if (!DI->getDef()->isSubClassOf(Rec))
     return 0;
   return DI;
 }
 
-const Init *RecordRecTy::convertValue(const TypedInit *TI) {
+Init *RecordRecTy::convertValue(TypedInit *TI) {
   // Ensure that TI is compatible with Rec.
   if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType()))
     if (RRT->getRecord()->isSubClassOf(getRecord()) ||
@@ -374,59 +367,25 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
 //    Initializer implementations
 //===----------------------------------------------------------------------===//
 
-FoldingSet<Init> Init::UniqueInits;
-BumpPtrAllocator Init::InitAllocator;
-
 void Init::dump() const { return print(errs()); }
 
-const UnsetInit *UnsetInit::get() {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initUnset);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const UnsetInit *>(I);
-
-  UnsetInit *I = InitAllocator.Allocate<UnsetInit>();
-  new (I) UnsetInit(ID);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const BitInit *BitInit::get(bool V) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initBit);
-  ID.AddBoolean(V);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const BitInit *>(I);
-
-  BitInit *I = InitAllocator.Allocate<BitInit>();
-  new (I) BitInit(ID, V);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const Init *
-BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
-  SmallVector<const Init *, 16> NewBits(Bits.size());
-
+Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+  BitsInit *BI = new BitsInit(Bits.size());
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= getNumBits()) {
+      delete BI;
       return 0;
     }
-    NewBits[i] = getBit(Bits[i]);
+    BI->setBit(i, getBit(Bits[i]));
   }
-
-  return BitsInit::get(NewBits.begin(), NewBits.end());
+  return BI;
 }
 
 std::string BitsInit::getAsString() const {
   std::string Result = "{ ";
   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     if (i) Result += ", ";
-    if (const Init *Bit = getBit(e-i-1))
+    if (Init *Bit = getBit(e-i-1))
       Result += Bit->getAsString();
     else
       Result += "*";
@@ -437,141 +396,70 @@ 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.
 //
-const Init *BitsInit::resolveReferences(Record &R,
-                                        const RecordVal *RV) const {
+Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
   bool Changed = false;
+  BitsInit *New = new BitsInit(getNumBits());
 
-  SmallVector<const Init *, 16> Bits(getNumBits());
-
-  for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
-    const Init *B;
-    const Init *CurBit = getBit(i);
+  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+    Init *B;
+    Init *CurBit = getBit(i);
 
     do {
       B = CurBit;
       CurBit = CurBit->resolveReferences(R, RV);
       Changed |= B != CurBit;
     } while (B != CurBit);
-    Bits[i] = CurBit;
+    New->setBit(i, CurBit);
   }
 
   if (Changed)
-    return BitsInit::get(Bits.begin(), Bits.end());
-
+    return New;
+  delete New;
   return this;
 }
 
-const IntInit *IntInit::get(int64_t V) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initInt);
-  ID.AddInteger(V);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const IntInit *>(I);
-
-  IntInit *I = InitAllocator.Allocate<IntInit>();
-  new (I) IntInit(ID, V);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
 std::string IntInit::getAsString() const {
   return itostr(Value);
 }
 
-const Init *
-IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
-  SmallVector<const Init *, 16> NewBits(Bits.size());
+Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+  BitsInit *BI = new BitsInit(Bits.size());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
-    if (Bits[i] >= 64)
+    if (Bits[i] >= 64) {
+      delete BI;
       return 0;
-
-    NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
-  }
-
-  return BitsInit::get(NewBits.begin(), NewBits.end());
-}
-
-const StringInit *StringInit::get(const std::string &V) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initString);
-  ID.AddString(V);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const StringInit *>(I);
-
-  StringInit *I = InitAllocator.Allocate<StringInit>();
-  new (I) StringInit(ID, V);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const CodeInit *CodeInit::get(const std::string &V) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initCode);
-  ID.AddString(V);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const CodeInit *>(I);
-
-  CodeInit *I = InitAllocator.Allocate<CodeInit>();
-  new (I) CodeInit(ID, V);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const ListInit *ListInit::get(std::vector<const Init *> &Vs, RecTy *EltTy) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initList);
-  ID.AddString(EltTy->getAsString());
-
-  for (std::vector<const Init *>::iterator i = Vs.begin(), iend = Vs.end();
-       i != iend;
-       ++i) {
-    ID.AddPointer(*i); 
+    }
+    BI->setBit(i, new BitInit(Value & (INT64_C(1) << Bits[i])));
   }
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const ListInit *>(I);
-
-  ListInit *I = InitAllocator.Allocate<ListInit>();
-  new (I) ListInit(ID, Vs, EltTy);
-  UniqueInits.InsertNode(I, IP);
-  return I;
+  return BI;
 }
 
-const Init *
-ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
-  std::vector<const Init*> Vals;
+Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+  std::vector<Init*> Vals;
   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
     if (Elements[i] >= getSize())
       return 0;
     Vals.push_back(getElement(Elements[i]));
   }
-  return ListInit::get(Vals, getType());
+  return new ListInit(Vals, getType());
 }
 
 Record *ListInit::getElementAsRecord(unsigned i) const {
   assert(i < Values.size() && "List element index out of range!");
-  const DefInit *DI = dynamic_cast<const DefInit*>(Values[i]);
+  DefInit *DI = dynamic_cast<DefInit*>(Values[i]);
   if (DI == 0) throw "Expected record in list!";
   return DI->getDef();
 }
 
-const Init *ListInit::resolveReferences(Record &R,
-                                        const RecordVal *RV) const {
-  std::vector<const Init*> Resolved;
+Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
+  std::vector<Init*> Resolved;
   Resolved.reserve(getSize());
   bool Changed = false;
 
   for (unsigned i = 0, e = getSize(); i != e; ++i) {
-    const Init *E;
-    const Init *CurElt = getElement(i);
+    Init *E;
+    Init *CurElt = getElement(i);
 
     do {
       E = CurElt;
@@ -582,25 +470,20 @@ const Init *ListInit::resolveReferences(Record &R,
   }
 
   if (Changed)
-    return ListInit::get(Resolved, getType());
- 
+    return new ListInit(Resolved, getType());
   return this;
 }
 
-const Init *ListInit::resolveListElementReference(Record &R,
-                                                  const RecordVal *IRV,
-                                                  unsigned Elt) const {
+Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+                                            unsigned Elt) {
   if (Elt >= getSize())
     return 0;  // Out of range reference.
-
-  const Init *E = getElement(Elt);
-
+  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<const UnsetInit*>(E))
+  if (IRV || !dynamic_cast<UnsetInit*>(E))
     return E;
-
   return 0;
 }
 
@@ -613,12 +496,12 @@ std::string ListInit::getAsString() const {
   return Result + "]";
 }
 
-const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
-                                        unsigned Bit) const {
-  const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
+                                  unsigned Bit) {
+  Init *Folded = Fold(&R, 0);
 
   if (Folded != this) {
-    const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
     if (Typed) {
       return Typed->resolveBitReference(R, IRV, Bit);
     }
@@ -627,12 +510,12 @@ const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
   return 0;
 }
 
-const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
-                                                unsigned Elt) const {
-  const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+                                          unsigned Elt) {
+  Init *Folded = Fold(&R, 0);
 
   if (Folded != this) {
-    const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
     if (Typed) {
       return Typed->resolveListElementReference(R, IRV, Elt);
     }
@@ -641,39 +524,22 @@ const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
   return 0;
 }
 
-const UnOpInit *UnOpInit::get(UnaryOp opc, const Init *lhs, RecTy *Type) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initUnOp);
-  ID.AddInteger(opc);
-  ID.AddString(Type->getAsString());
-  ID.AddPointer(lhs);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const UnOpInit *>(I);
-
-  UnOpInit *I = InitAllocator.Allocate<UnOpInit>();
-  new (I) UnOpInit(ID, opc, lhs, Type);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   switch (getOpcode()) {
   default: assert(0 && "Unknown unop");
   case CAST: {
     if (getType()->getAsString() == "string") {
-      const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
       if (LHSs) {
         return LHSs;
       }
 
-      const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
+      DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
       if (LHSd) {
-        return StringInit::get(LHSd->getDef()->getName());
+        return new StringInit(LHSd->getDef()->getName());
       }
     } else {
-      const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
       if (LHSs) {
         std::string Name = LHSs->getValue();
 
@@ -682,7 +548,7 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
           if (const RecordVal *RV = CurRec->getValue(Name)) {
             if (RV->getType() != getType())
               throw "type mismatch in cast";
-            return VarInit::get(Name, RV->getType());
+            return new VarInit(Name, RV->getType());
           }
 
           std::string TemplateArgName = CurRec->getName()+":"+Name;
@@ -693,7 +559,7 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
             if (RV->getType() != getType())
               throw "type mismatch in cast";
 
-            return VarInit::get(TemplateArgName, RV->getType());
+            return new VarInit(TemplateArgName, RV->getType());
           }
         }
 
@@ -706,12 +572,12 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
             if (RV->getType() != getType())
               throw "type mismatch in cast";
 
-            return VarInit::get(MCName, RV->getType());
+            return new VarInit(MCName, RV->getType());
           }
         }
 
         if (Record *D = (CurRec->getRecords()).getDef(Name))
-          return DefInit::get(D);
+          return new DefInit(D);
 
         throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n");
       }
@@ -719,7 +585,7 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
     break;
   }
   case HEAD: {
-    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
         assert(0 && "Empty list in car");
@@ -730,33 +596,33 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
     break;
   }
   case TAIL: {
-    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
         assert(0 && "Empty list in cdr");
         return 0;
       }
-      const ListInit *Result = ListInit::get(LHSl->begin()+1, LHSl->end(),
-                                          LHSl->getType());
+      ListInit *Result = new ListInit(LHSl->begin()+1, LHSl->end(),
+                                      LHSl->getType());
       return Result;
     }
     break;
   }
   case EMPTY: {
-    const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
     if (LHSl) {
       if (LHSl->getSize() == 0) {
-        return IntInit::get(1);
+        return new IntInit(1);
       } else {
-        return IntInit::get(0);
+        return new IntInit(0);
       }
     }
-    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
     if (LHSs) {
       if (LHSs->getValue().empty()) {
-        return IntInit::get(1);
+        return new IntInit(1);
       } else {
-        return IntInit::get(0);
+        return new IntInit(0);
       }
     }
 
@@ -766,12 +632,11 @@ const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   return this;
 }
 
-const Init *UnOpInit::resolveReferences(Record &R,
-                                        const RecordVal *RV) const {
-  const Init *lhs = LHS->resolveReferences(R, RV);
+Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+  Init *lhs = LHS->resolveReferences(R, RV);
 
   if (LHS != lhs)
-    return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0);
+    return (new UnOpInit(getOpcode(), lhs, getType()))->Fold(&R, 0);
   return Fold(&R, 0);
 }
 
@@ -786,37 +651,18 @@ std::string UnOpInit::getAsString() const {
   return Result + "(" + LHS->getAsString() + ")";
 }
 
-const BinOpInit *BinOpInit::get(BinaryOp opc, const Init *lhs,
-                                   const Init *rhs, RecTy *Type) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initBinOp);
-  ID.AddInteger(opc);
-  ID.AddString(Type->getAsString());
-  ID.AddPointer(lhs);
-  ID.AddPointer(rhs);
-
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const BinOpInit *>(I);
-
-  BinOpInit *I = InitAllocator.Allocate<BinOpInit>();
-  new (I) BinOpInit(ID, opc, lhs, rhs, Type);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
-
-const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
   switch (getOpcode()) {
   default: assert(0 && "Unknown binop");
   case CONCAT: {
-    const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS);
-    const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS);
+    DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
+    DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
     if (LHSs && RHSs) {
-      const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator());
-      const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator());
+      DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
+      DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
       if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
         throw "Concated Dag operators do not match!";
-      std::vector<const Init*> Args;
+      std::vector<Init*> Args;
       std::vector<std::string> ArgNames;
       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(LHSs->getArg(i));
@@ -826,42 +672,42 @@ const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
         Args.push_back(RHSs->getArg(i));
         ArgNames.push_back(RHSs->getArgName(i));
       }
-      return DagInit::get(LHSs->getOperator(), "", Args, ArgNames);
+      return new DagInit(LHSs->getOperator(), "", Args, ArgNames);
     }
     break;
   }
   case STRCONCAT: {
-    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
-    const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
     if (LHSs && RHSs)
-      return StringInit::get(LHSs->getValue() + RHSs->getValue());
+      return new StringInit(LHSs->getValue() + RHSs->getValue());
     break;
   }
   case EQ: {
     // try to fold eq comparison for 'bit' and 'int', otherwise fallback
     // to string objects.
-    const IntInit* L =
-      dynamic_cast<const IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
-    const IntInit* R =
-      dynamic_cast<const IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
+    IntInit* L =
+      dynamic_cast<IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
+    IntInit* R =
+      dynamic_cast<IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
 
     if (L && R)
-      return IntInit::get(L->getValue() == R->getValue());
+      return new IntInit(L->getValue() == R->getValue());
 
-    const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
-    const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
 
     // Make sure we've resolved
     if (LHSs && RHSs)
-      return IntInit::get(LHSs->getValue() == RHSs->getValue());
+      return new IntInit(LHSs->getValue() == RHSs->getValue());
 
     break;
   }
   case SHL:
   case SRA:
   case SRL: {
-    const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
-    const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+    IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
     if (LHSi && RHSi) {
       int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
       int64_t Result;
@@ -871,7 +717,7 @@ const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
       case SRA: Result = LHSv >> RHSv; break;
       case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
       }
-      return IntInit::get(Result);
+      return new IntInit(Result);
     }
     break;
   }
@@ -879,13 +725,12 @@ const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   return this;
 }
 
-const Init *BinOpInit::resolveReferences(Record &R,
-                                         const RecordVal *RV) const {
-  const Init *lhs = LHS->resolveReferences(R, RV);
-  const Init *rhs = RHS->resolveReferences(R, RV);
+Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+  Init *lhs = LHS->resolveReferences(R, RV);
+  Init *rhs = RHS->resolveReferences(R, RV);
 
   if (LHS != lhs || RHS != rhs)
-    return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
+    return (new BinOpInit(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
   return Fold(&R, 0);
 }
 
@@ -902,43 +747,20 @@ std::string BinOpInit::getAsString() const {
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
-const TernOpInit *TernOpInit::get(TernaryOp opc, const Init *lhs,
-                                     const Init *mhs, const Init *rhs,
-                                     RecTy *Type) {
-  FoldingSetNodeID ID;
-  ID.AddInteger(initTernOp);
-  ID.AddInteger(opc);
-  ID.AddString(Type->getAsString());
-  ID.AddPointer(lhs);
-  ID.AddPointer(mhs);
-  ID.AddPointer(rhs);
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+                           Record *CurRec, MultiClass *CurMultiClass);
 
-  void *IP = 0;
-  if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
-    return static_cast<const TernOpInit *>(I);
-
-  TernOpInit *I = InitAllocator.Allocate<TernOpInit>();
-  new (I) TernOpInit(ID, opc, lhs, mhs, rhs, Type);
-  UniqueInits.InsertNode(I, IP);
-  return I;
-}
+static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
+                               RecTy *Type, Record *CurRec,
+                               MultiClass *CurMultiClass) {
+  std::vector<Init *> NewOperands;
 
-static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
-                                 const Init *RHS, RecTy *Type,
-                                 Record *CurRec, MultiClass *CurMultiClass);
-
-static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
-                                     const Init *Arg, RecTy *Type,
-                                     Record *CurRec,
-                                     MultiClass *CurMultiClass) {
-  std::vector<const Init *> NewOperands;
-
-  const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg);
+  TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
 
   // If this is a dag, recurse
   if (TArg && TArg->getType()->getAsString(