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;< |