diff options
Diffstat (limited to 'utils/TableGen/Record.cpp')
| -rw-r--r-- | utils/TableGen/Record.cpp | 968 |
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() == "dag") { - const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, - CurRec, CurMultiClass); + Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, + CurRec, CurMultiClass); if (Result != 0) { return Result; } else { @@ -946,21 +768,18 @@ static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS, } } - bool change = false; for (int i = 0; i < RHSo->getNumOperands(); ++i) { - const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i)); + OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); if (RHSoo) { - const Init *Result = EvaluateOperation(RHSoo, LHS, Arg, - Type, CurRec, CurMultiClass); + Init *Result = EvaluateOperation(RHSoo, LHS, Arg, + Type, CurRec, CurMultiClass); if (Result != 0) { - change = true; NewOperands.push_back(Result); } else { NewOperands.push_back(Arg); } } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { - change = true; NewOperands.push_back(Arg); } else { NewOperands.push_back(RHSo->getOperand(i)); @@ -968,31 +787,30 @@ static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS, } // Now run the operator and use its result as the new leaf - const OpInit *NewOp = RHSo->clone(NewOperands); - const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); - - if (change) { + OpInit *NewOp = RHSo->clone(NewOperands); + Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); + if (NewVal != NewOp) { + delete NewOp; return NewVal; } return 0; } -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); +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); DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type); ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type); - const OpInit *RHSo = dynamic_cast<const OpInit*>(RHS); + OpInit *RHSo = dynamic_cast<OpInit*>(RHS); if (!RHSo) { throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); } - const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS); + TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); if (!LHSt) { throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); @@ -1000,23 +818,23 @@ static const Init *ForeachHelper(const Init *LHS, const Init *MHS, if ((MHSd && DagType) || (MHSl && ListType)) { if (MHSd) { - const Init *Val = MHSd->getOperator(); - const Init *Result = EvaluateOperation(RHSo, LHS, Val, - Type, CurRec, CurMultiClass); + Init *Val = MHSd->getOperator(); + Init *Result = EvaluateOperation(RHSo, LHS, Val, + Type, CurRec, CurMultiClass); if (Result != 0) { Val = Result; } - std::vector<std::pair<const Init *, std::string> > args; + std::vector<std::pair<Init *, std::string> > args; for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { - const Init *Arg; + Init *Arg; std::string ArgName; Arg = MHSd->getArg(i); ArgName = MHSd->getArgName(i); // Process args - const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, - CurRec, CurMultiClass); + Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, + CurRec, CurMultiClass); if (Result != 0) { Arg = Result; } @@ -1025,17 +843,17 @@ static const Init *ForeachHelper(const Init *LHS, const Init *MHS, args.push_back(std::make_pair(Arg, ArgName)); } - return DagInit::get(Val, "", args); + return new DagInit(Val, "", args); } if (MHSl) { - std::vector<const Init *> NewOperands; - std::vector<const Init *> NewList(MHSl->begin(), MHSl->end()); + std::vector<Init *> NewOperands; + std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); - for (std::vector<const Init *>::iterator li = NewList.begin(), + for (ListInit::iterator li = NewList.begin(), liend = NewList.end(); li != liend; ++li) { - const Init *Item = *li; + Init *Item = *li; NewOperands.clear(); for(int i = 0; i < RHSo->getNumOperands(); ++i) { // First, replace the foreach variable with the list item @@ -1047,33 +865,34 @@ static const Init *ForeachHelper(const Init *LHS, const Init *MHS, } // Now run the operator and use its result as the new list item - const OpInit *NewOp = RHSo->clone(NewOperands); - const Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); + OpInit *NewOp = RHSo->clone(NewOperands); + Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); if (NewItem != NewOp) { *li = NewItem; + delete NewOp; } } - return ListInit::get(NewList, MHSl->getType()); + return new ListInit(NewList, MHSl->getType()); } } return 0; } -const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { +Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { switch (getOpcode()) { default: assert(0 && "Unknown binop"); case SUBST: { - 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 *LHSd = dynamic_cast<DefInit*>(LHS); + VarInit *LHSv = dynamic_cast<VarInit*>(LHS); + StringInit *LHSs = dynamic_cast<StringInit*>(LHS); - 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 *MHSd = dynamic_cast<DefInit*>(MHS); + VarInit *MHSv = dynamic_cast<VarInit*>(MHS); + StringInit *MHSs = dynamic_cast<StringInit*>(MHS); - const DefInit *RHSd = dynamic_cast<const DefInit*>(RHS); - const VarInit *RHSv = dynamic_cast<const VarInit*>(RHS); - const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS); + DefInit *RHSd = dynamic_cast<DefInit*>(RHS); + VarInit *RHSv = dynamic_cast<VarInit*>(RHS); + StringInit *RHSs = dynamic_cast<StringInit*>(RHS); if ((LHSd && MHSd && RHSd) || (LHSv && MHSv && RHSv) @@ -1083,14 +902,14 @@ const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { if (LHSd->getAsString() == RHSd->getAsString()) { Val = MHSd->getDef(); } - return DefInit::get(Val); + return new DefInit(Val); } if (RHSv) { std::string Val = RHSv->getName(); if (LHSv->getAsString() == RHSv->getAsString()) { Val = MHSv->getName(); } - return VarInit::get(Val, getType()); + return new VarInit(Val, getType()); } if (RHSs) { std::string Val = RHSs->getValue(); @@ -1105,14 +924,14 @@ const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { idx = found + MHSs->getValue().size(); } while (found != std::string::npos); - return StringInit::get(Val); + return new StringInit(Val); } } break; } case FOREACH: { - const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), + Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec, CurMultiClass); if (Result != 0) { return Result; @@ -1121,9 +940,9 @@ const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { } case IF: { - const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS); - if (const Init *I = LHS->convertInitializerTo(new IntRecTy())) - LHSi = dynamic_cast<const IntInit*>(I); + IntInit *LHSi = dynamic_cast<IntInit*>(LHS); + if (Init *I = LHS->convertInitializerTo(new IntRecTy())) + LHSi = dynamic_cast<IntInit*>(I); if (LHSi) { if (LHSi->getValue()) { return MHS; @@ -1138,35 +957,32 @@ const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { return this; } -const Init * -TernOpInit::resolveReferences(Record &R, - const RecordVal *RV) const { - const Init *lhs = LHS->resolveReferences(R, RV); +Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) { + Init *lhs = LHS->resolveReferences(R, RV); if (Opc == IF && lhs != LHS) { - const IntInit *Value = dynamic_cast<const IntInit*>(lhs); - if (const Init *I = lhs->convertInitializerTo(new IntRecTy())) - Value = dynamic_cast<const IntInit*>(I); + IntInit *Value = dynamic_cast<IntInit*>(lhs); + if (Init *I = lhs->convertInitializerTo(new IntRecTy())) + Value = dynamic_cast<IntInit*>(I); if (Value != 0) { // Short-circuit if (Value->getValue()) { - const Init *mhs = MHS->resolveReferences(R, RV); - return (TernOpInit::get(getOpcode(), lhs, mhs, - RHS, getType()))->Fold(&R, 0); + Init *mhs = MHS->resolveReferences(R, RV); + return (new TernOpInit(getOpcode(), lhs, mhs, + RHS, getType()))->Fold(&R, 0); } else { - const Init *rhs = RHS->resolveReferences(R, RV); - return (TernOpInit::get(getOpcode(), lhs, MHS, - rhs, getType()))->Fold(&R, 0); + Init *rhs = RHS->resolveReferences(R, RV); + return (new TernOpInit(getOpcode(), lhs, MHS, + rhs, getType()))->Fold(&R, 0); } } } - const Init *mhs = MHS->resolveReferences(R, RV); - const Init *rhs = RHS->resolveReferences(R, RV); + Init *mhs = MHS->resolveReferences(R, RV); + Init *rhs = RHS->resolveReferences(R, RV); if (LHS != lhs || MHS != mhs || RHS != rhs) - return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))-> - Fold(&R, 0); + return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0); return Fold(&R, 0); } @@ -1192,97 +1008,79 @@ RecTy *TypedInit::getFieldType(const std::string &FieldName) const { return 0; } -const Init * -TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { +Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) { BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType()); if (T == 0) return 0; // Cannot subscript a non-bits variable. unsigned NumBits = T->getNumBits(); - SmallVector<const Init *, 16> NewBits(Bits.size()); + BitsInit *BI = new BitsInit(Bits.size()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= NumBits) { + delete BI; return 0; } - NewBits[i] = VarBitInit::get(this, Bits[i]); + BI->setBit(i, new VarBitInit(this, Bits[i])); } - return BitsInit::get(NewBits.begin(), NewBits.end()); + return BI; } -const Init * -TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { +Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) { ListRecTy *T = dynamic_cast<ListRecTy*>(getType()); if (T == 0) return 0; // Cannot subscript a non-list variable. if (Elements.size() == 1) - return VarListElementInit::get(this, Elements[0]); + return new VarListElementInit(this, Elements[0]); - std::vector<const Init*> ListInits; + std::vector<Init*> ListInits; ListInits.reserve(Elements.size()); for (unsigned i = 0, e = Elements.size(); i != e; ++i) - ListInits.push_back(VarListElementInit::get(this, Elements[i])); - return ListInit::get(ListInits, T); + ListInits.push_back(new VarListElementInit(this, Elements[i])); + return new ListInit(ListInits, T); } -const VarInit *VarInit::get(const std::string &VN, RecTy *T) { - FoldingSetNodeID ID; - ID.AddInteger(initVar); - ID.AddString(VN); - ID.AddString(T->getAsString()); - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const VarInit *>(I); - - VarInit *I = InitAllocator.Allocate<VarInit>(); - new (I) VarInit(ID, VN, T); - UniqueInits.InsertNode(I, IP); - return I; -} - -const Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, - unsigned Bit) const { +Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, + unsigned Bit) { 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<const BitsInit*>(RV->getValue())); - const BitsInit *BI = (const BitsInit*)RV->getValue(); + assert(dynamic_cast<BitsInit*>(RV->getValue())); + BitsInit *BI = (BitsInit*)RV->getValue(); assert(Bit < BI->getNumBits() && "Bit reference out of range!"); - const Init *B = BI->getBit(Bit); + 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<const UnsetInit*>(B)) + if (IRV || !dynamic_cast<UnsetInit*>(B)) return B; return 0; } -const Init *VarInit::resolveListElementReference(Record &R, - const RecordVal *IRV, - unsigned Elt) const { +Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV, + unsigned Elt) { 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?"); - const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue()); + ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); if (!LI) { - const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue()); + VarInit *VI = dynamic_cast<VarInit*>(RV->getValue()); assert(VI && "Invalid list element!"); - return VarListElementInit::get(VI, Elt); + return new VarListElementInit(VI, Elt); } if (Elt >= LI->getSize()) return 0; // Out of range reference. - const Init *E = LI->getElement(Elt); + 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<const UnsetInit*>(E)) + if (IRV || !dynamic_cast<UnsetInit*>(E)) return E; return 0; } @@ -1295,15 +1093,15 @@ RecTy *VarInit::getFieldType(const std::string &FieldName) const { return 0; } -const Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) 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<const UnsetInit*>(Val->getValue()))) + if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue()))) return 0; - const Init *TheInit = Val->getValue(); + Init *TheInit = Val->getValue(); assert(TheInit != this && "Infinite loop detected!"); - if (const Init *I = TheInit->getFieldInit(R, RV, FieldName)) + if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) return I; else return 0; @@ -1316,112 +1114,56 @@ const 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. /// -const Init *VarInit::resolveReferences(Record &R, - const RecordVal *RV) const { +Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) { if (RecordVal *Val = R.getValue(VarName)) - if (RV == Val || (RV == 0 - && !dynamic_cast<const UnsetInit*>(Val->getValue()))) + if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue()))) return Val->getValue(); return this; } -const VarBitInit *VarBitInit::get(const TypedInit *T, unsigned B) { - FoldingSetNodeID ID; - ID.AddInteger(initVarBit); - ID.AddPointer(T); - ID.AddInteger(B); - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const VarBitInit *>(I); - - VarBitInit *I = InitAllocator.Allocate<VarBitInit>(); - new (I) VarBitInit(ID, T, B); - UniqueInits.InsertNode(I, IP); - return I; -} - std::string VarBitInit::getAsString() const { return TI->getAsString() + "{" + utostr(Bit) + "}"; } -const Init * -VarBitInit::resolveReferences(Record &R, - const RecordVal *RV) const { - if (const Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) +Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) { + if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) return I; return this; } -const VarListElementInit *VarListElementInit::get(const TypedInit *T, - unsigned E) { - FoldingSetNodeID ID; - ID.AddInteger(initVarListElement); - ID.AddPointer(T); - ID.AddInteger(E); - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const VarListElementInit *>(I); - - VarListElementInit *I = InitAllocator.Allocate<VarListElementInit>(); - new (I) VarListElementInit(ID, T, E); - UniqueInits.InsertNode(I, IP); - return I; -} - std::string VarListElementInit::getAsString() const { return TI->getAsString() + "[" + utostr(Element) + "]"; } -const Init *VarListElementInit::resolveReferences(Record &R, - const RecordVal *RV) const { - if (const Init *I = - getVariable()->resolveListElementReference(R, RV, getElementNum())) +Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) { + if (Init *I = getVariable()->resolveListElementReference(R, RV, + getElementNum())) return I; return this; } -const Init *VarListElementInit::resolveBitReference(Record &R, - const RecordVal *RV, - unsigned Bit) const { +Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) { // FIXME: This should be implemented, to support references like: // bit B = AA[0]{1}; return 0; } -const Init * -VarListElementInit::resolveListElementReference(Record &R, - const RecordVal *RV, - unsigned Elt) const { +Init *VarListElementInit:: +resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) { // FIXME: This should be implemented, to support references like: // int B = AA[0][1]; return 0; } -const DefInit *DefInit::get(Record *D) { - FoldingSetNodeID ID; - ID.AddInteger(initDef); - ID.AddString(D->getName()); - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const DefInit *>(I); - - DefInit *I = InitAllocator.Allocate<DefInit>(); - new (I) DefInit(ID, D); - UniqueInits.InsertNode(I, IP); - return I; -} - RecTy *DefInit::getFieldType(const std::string &FieldName) const { if (const RecordVal *RV = Def->getValue(FieldName)) return RV->getType(); return 0; } -const Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const { +Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const { return Def->getValue(FieldName)->getValue(); } @@ -1430,134 +1172,59 @@ std::string DefInit::getAsString() const { return Def->getName(); } -const FieldInit *FieldInit::get(const Init *R, const std::string &FN) { - FoldingSetNodeID ID; - ID.AddInteger(initField); - ID.AddPointer(R); - ID.AddString(FN); - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const FieldInit *>(I); - - FieldInit *I = InitAllocator.Allocate<FieldInit>(); - new (I) FieldInit(ID, R, FN); - UniqueInits.InsertNode(I, IP); - return I; -} - -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)) { +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)) { assert(Bit < BI->getNumBits() && "Bit reference out of range!"); - const Init *B = BI->getBit(Bit); + Init *B = BI->getBit(Bit); - if (dynamic_cast<const BitInit*>(B)) // If the bit is set. + if (dynamic_cast<BitInit*>(B)) // If the bit is set. return B; // Replace the VarBitInit with it. } return 0; } -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)) { +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)) { if (Elt >= LI->getSize()) return 0; - const Init *E = LI->getElement(Elt); + 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<const UnsetInit*>(E)) + if (RV || !dynamic_cast<UnsetInit*>(E)) return E; } return 0; } -const Init *FieldInit::resolveReferences(Record &R, - const RecordVal *RV) const { - const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; +Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) { + Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; - const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); + Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); if (BitsVal) { - const Init *BVR = BitsVal->resolveReferences(R, RV); + Init *BVR = BitsVal->resolveReferences(R, RV); return BVR->isComplete() ? BVR : this; } if (NewRec != Rec) { - return FieldInit::get(NewRec, FieldName); + return new FieldInit(NewRec, FieldName); } return this; } -const DagInit * -DagInit::get(const Init *V, const std::string &VN, - const std::vector<std::pair<const Init*, std::string> > &args) { - FoldingSetNodeID ID; - ID.AddInteger(initDag); - ID.AddPointer(V); - ID.AddString(VN); - - for (std::vector<std::pair<const Init*, std::string> >::const_iterator a - = args.begin(), - aend = args.end(); - a != aend; - ++a) { - ID.AddPointer(a->first); - ID.AddString(a->second); - } - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const DagInit *>(I); - - DagInit *I = InitAllocator.Allocate<DagInit>(); - new (I) DagInit(ID, V, VN, args); - UniqueInits.InsertNode(I, IP); - return I; -} - -const DagInit * -DagInit::get(const Init *V, const std::string &VN, - const std::vector<const Init *> &args, - const std::vector<std::string> &argNames) { - FoldingSetNodeID ID; - ID.AddInteger(initDag); - ID.AddPointer(V); - ID.AddString(VN); - - std::vector<std::string>::const_iterator s = argNames.begin(); - for (std::vector<const Init*>::const_iterator a - = args.begin(), - aend = args.end(); - a != aend; - ++a, ++s) { - ID.AddPointer(*a); - ID.AddString(*s); - } - - void *IP = 0; - if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP)) - return static_cast<const DagInit *>(I); - - DagInit *I = InitAllocator.Allocate<DagInit>(); - new (I) DagInit(ID, V, VN, args, argNames); - UniqueInits.InsertNode(I, IP); - return I; -} - -const Init *DagInit::resolveReferences(Record &R, - const RecordVal *RV) const { - std::vector<const Init*> NewArgs; +Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) { + std::vector<Init*> NewArgs; for (unsigned i = 0, e = Args.size(); i != e; ++i) NewArgs.push_back(Args[i]->resolveReferences(R, RV)); - const Init *Op = Val->resolveReferences(R, RV); + Init *Op = Val->resolveReferences(R, RV); if (Args != NewArgs || Op != Val) - return DagInit::get(Op, ValName, NewArgs, ArgNames); + return new DagInit(Op, ValName, NewArgs, ArgNames); return this; } @@ -1585,7 +1252,7 @@ std::string DagInit::getAsString() const { RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) : Name(N), Ty(T), Prefix(P) { - Value = Ty->convertValue(UnsetInit::get()); + Value = Ty->convertValue(new UnsetInit()); assert(Value && "Cannot create unset value for current type!"); } @@ -1620,7 +1287,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 (const Init *V = Values[i].getValue()) + if (Init *V = Values[i].getValue()) Values[i].setValue(V->resolveReferences(*this, RV)); } } @@ -1665,7 +1332,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. /// -const Init *Record::getValueInit(StringRef FieldName) 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 `" + @@ -1694,13 +1361,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. /// -const BitsInit *Record::getValueAsBitsInit(StringRef FieldName) 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 (const BitsInit *BI = dynamic_cast<const BitsInit*>(R->getValue())) + if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) return BI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a BitsInit initializer!"; @@ -1710,13 +1377,13 @@ const 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. /// -const ListInit *Record::getValueAsListInit(StringRef FieldName) 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 (const ListInit *LI = dynamic_cast<const ListInit*>(R->getValue())) + if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) return LI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a list initializer!"; @@ -1728,10 +1395,10 @@ const ListInit *Record::getValueAsListInit(StringRef FieldName) const { /// std::vector<Record*> Record::getValueAsListOfDefs(StringRef FieldName) const { - const ListInit *List = getValueAsListInit(FieldName); + ListInit *List = getValueAsListInit(FieldName); std::vector<Record*> Defs; for (unsigned i = 0; i < List->getSize(); i++) { - if (const DefInit *DI = dynamic_cast<const DefInit*>(List->getElement(i))) { + if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { Defs.push_back(DI->getDef()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1751,7 +1418,7 @@ int64_t Record::getValueAsInt(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (const IntInit *II = dynamic_cast<const IntInit*>(R->getValue())) + if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) return II->getValue(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have an int initializer!"; @@ -1763,10 +1430,10 @@ int64_t Record::getValueAsInt(StringRef FieldName) const { /// std::vector<int64_t> Record::getValueAsListOfInts(StringRef FieldName) const { - const ListInit *List = getValueAsListInit(FieldName); + ListInit *List = getValueAsListInit(FieldName); std::vector<int64_t> Ints; for (unsigned i = 0; i < List->getSize(); i++) { - if (const IntInit *II = dynamic_cast<const IntInit*>(List->getElement(i))) { + if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { Ints.push_back(II->getValue()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1782,11 +1449,10 @@ Record::getValueAsListOfInts(StringRef FieldName) const { /// std::vector<std::string> Record::getValueAsListOfStrings(StringRef FieldName) const { - const ListInit *List = getValueAsListInit(FieldName); + ListInit *List = getValueAsListInit(FieldName); std::vector<std::string> Strings; for (unsigned i = 0; i < List->getSize(); i++) { - if (const StringInit *II = - dynamic_cast<const StringInit*>(List->getElement(i))) { + if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { Strings.push_back(II->getValue()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1806,7 +1472,7 @@ Record *Record::getValueAsDef(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValue())) + if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) return DI->getDef(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a def initializer!"; @@ -1822,7 +1488,7 @@ bool Record::getValueAsBit(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (const BitInit *BI = dynamic_cast<const BitInit*>(R->getValue())) + if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) return BI->getValue(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a bit initializer!"; @@ -1832,13 +1498,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. /// -const DagInit *Record::getValueAsDag(StringRef FieldName) 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 (const DagInit *DI = dynamic_cast<const DagInit*>(R->getValue())) + if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) return DI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a dag initializer!"; |