diff options
Diffstat (limited to 'contrib/llvm/lib/TableGen')
| -rw-r--r-- | contrib/llvm/lib/TableGen/Error.cpp | 5 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/Main.cpp | 36 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/Record.cpp | 1101 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/SetTheory.cpp | 43 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/TGLexer.h | 3 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/TGParser.cpp | 285 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/TGParser.h | 4 | ||||
| -rw-r--r-- | contrib/llvm/lib/TableGen/TableGenBackend.cpp | 35 |
8 files changed, 683 insertions, 829 deletions
diff --git a/contrib/llvm/lib/TableGen/Error.cpp b/contrib/llvm/lib/TableGen/Error.cpp index 8d9ae20..fd08935 100644 --- a/contrib/llvm/lib/TableGen/Error.cpp +++ b/contrib/llvm/lib/TableGen/Error.cpp @@ -14,6 +14,7 @@ #include "llvm/TableGen/Error.h" #include "llvm/ADT/Twine.h" +#include "llvm/Support/Signals.h" #include "llvm/Support/raw_ostream.h" #include <cstdlib> @@ -64,11 +65,15 @@ void PrintError(const Twine &Msg) { void PrintFatalError(const Twine &Msg) { PrintError(Msg); + // The following call runs the file cleanup handlers. + sys::RunInterruptHandlers(); std::exit(1); } void PrintFatalError(ArrayRef<SMLoc> ErrorLoc, const Twine &Msg) { PrintError(ErrorLoc, Msg); + // The following call runs the file cleanup handlers. + sys::RunInterruptHandlers(); std::exit(1); } diff --git a/contrib/llvm/lib/TableGen/Main.cpp b/contrib/llvm/lib/TableGen/Main.cpp index c440451..bb590c7 100644 --- a/contrib/llvm/lib/TableGen/Main.cpp +++ b/contrib/llvm/lib/TableGen/Main.cpp @@ -15,37 +15,35 @@ // //===----------------------------------------------------------------------===// +#include "llvm/TableGen/Main.h" #include "TGParser.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/ToolOutputFile.h" #include "llvm/TableGen/Error.h" -#include "llvm/TableGen/Main.h" #include "llvm/TableGen/Record.h" #include <algorithm> #include <cstdio> #include <system_error> using namespace llvm; -namespace { - cl::opt<std::string> - OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), - cl::init("-")); +static cl::opt<std::string> +OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), + cl::init("-")); - cl::opt<std::string> - DependFilename("d", - cl::desc("Dependency filename"), - cl::value_desc("filename"), - cl::init("")); +static cl::opt<std::string> +DependFilename("d", + cl::desc("Dependency filename"), + cl::value_desc("filename"), + cl::init("")); - cl::opt<std::string> - InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-")); +static cl::opt<std::string> +InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-")); - cl::list<std::string> - IncludeDirs("I", cl::desc("Directory of include files"), - cl::value_desc("directory"), cl::Prefix); -} +static cl::list<std::string> +IncludeDirs("I", cl::desc("Directory of include files"), + cl::value_desc("directory"), cl::Prefix); /// \brief Create a dependency file for `-d` option. /// @@ -72,9 +70,7 @@ static int createDependencyFile(const TGParser &Parser, const char *argv0) { return 0; } -namespace llvm { - -int TableGenMain(char *argv0, TableGenMainFn *MainFn) { +int llvm::TableGenMain(char *argv0, TableGenMainFn *MainFn) { RecordKeeper Records; // Parse the input file. @@ -122,5 +118,3 @@ int TableGenMain(char *argv0, TableGenMainFn *MainFn) { Out.keep(); return 0; } - -} diff --git a/contrib/llvm/lib/TableGen/Record.cpp b/contrib/llvm/lib/TableGen/Record.cpp index 3a2ae96..97e796c 100644 --- a/contrib/llvm/lib/TableGen/Record.cpp +++ b/contrib/llvm/lib/TableGen/Record.cpp @@ -86,262 +86,69 @@ IntRecTy IntRecTy::Shared; StringRecTy StringRecTy::Shared; DagRecTy DagRecTy::Shared; -void RecTy::anchor() { } void RecTy::dump() const { print(errs()); } ListRecTy *RecTy::getListTy() { if (!ListTy) - ListTy = new ListRecTy(this); - return ListTy; + ListTy.reset(new ListRecTy(this)); + return ListTy.get(); } -bool RecTy::baseClassOf(const RecTy *RHS) const{ - assert (RHS && "NULL pointer"); +bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const { + assert(RHS && "NULL pointer"); return Kind == RHS->getRecTyKind(); } -Init *BitRecTy::convertValue(BitsInit *BI) { - if (BI->getNumBits() != 1) return nullptr; // Only accept if just one bit! - return BI->getBit(0); -} - -Init *BitRecTy::convertValue(IntInit *II) { - int64_t Val = II->getValue(); - if (Val != 0 && Val != 1) return nullptr; // Only accept 0 or 1 for a bit! - - return BitInit::get(Val != 0); -} - -Init *BitRecTy::convertValue(TypedInit *VI) { - RecTy *Ty = VI->getType(); - if (isa<BitRecTy>(Ty)) - return VI; // Accept variable if it is already of bit type! - if (auto *BitsTy = dyn_cast<BitsRecTy>(Ty)) - // Accept only bits<1> expression. - return BitsTy->getNumBits() == 1 ? VI : nullptr; - // Ternary !if can be converted to bit, but only if both sides are - // convertible to a bit. - if (TernOpInit *TOI = dyn_cast<TernOpInit>(VI)) { - if (TOI->getOpcode() != TernOpInit::TernaryOp::IF) - return nullptr; - if (!TOI->getMHS()->convertInitializerTo(BitRecTy::get()) || - !TOI->getRHS()->convertInitializerTo(BitRecTy::get())) - return nullptr; - return TOI; - } - return nullptr; -} - -bool BitRecTy::baseClassOf(const RecTy *RHS) const{ - if(RecTy::baseClassOf(RHS) || getRecTyKind() == IntRecTyKind) +bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{ + if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind) return true; - if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS)) + if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS)) return BitsTy->getNumBits() == 1; return false; } BitsRecTy *BitsRecTy::get(unsigned Sz) { - static std::vector<BitsRecTy*> Shared; + static std::vector<std::unique_ptr<BitsRecTy>> Shared; if (Sz >= Shared.size()) Shared.resize(Sz + 1); - BitsRecTy *&Ty = Shared[Sz]; + std::unique_ptr<BitsRecTy> &Ty = Shared[Sz]; if (!Ty) - Ty = new BitsRecTy(Sz); - return Ty; + Ty.reset(new BitsRecTy(Sz)); + return Ty.get(); } std::string BitsRecTy::getAsString() const { return "bits<" + utostr(Size) + ">"; } -Init *BitsRecTy::convertValue(UnsetInit *UI) { - SmallVector<Init *, 16> NewBits(Size); - - for (unsigned i = 0; i != Size; ++i) - NewBits[i] = UnsetInit::get(); - - return BitsInit::get(NewBits); -} - -Init *BitsRecTy::convertValue(BitInit *UI) { - if (Size != 1) return nullptr; // Can only convert single bit. - return BitsInit::get(UI); -} - -/// canFitInBitfield - Return true if the number of bits is large enough to hold -/// the integer value. -static bool canFitInBitfield(int64_t Value, unsigned NumBits) { - // For example, with NumBits == 4, we permit Values from [-7 .. 15]. - return (NumBits >= sizeof(Value) * 8) || - (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); -} - -/// convertValue from Int initializer to bits type: Split the integer up into the -/// appropriate bits. -/// -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 nullptr; - - SmallVector<Init *, 16> NewBits(Size); - - for (unsigned i = 0; i != Size; ++i) - NewBits[i] = BitInit::get(Value & (1LL << i)); - - return BitsInit::get(NewBits); -} - -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 nullptr; -} - -Init *BitsRecTy::convertValue(TypedInit *VI) { - if (Size == 1 && isa<BitRecTy>(VI->getType())) - return BitsInit::get(VI); - - if (VI->getType()->typeIsConvertibleTo(this)) { - SmallVector<Init *, 16> NewBits(Size); - - for (unsigned i = 0; i != Size; ++i) - NewBits[i] = VarBitInit::get(VI, i); - return BitsInit::get(NewBits); - } - - return nullptr; -} - -bool BitsRecTy::baseClassOf(const RecTy *RHS) const{ - if (RecTy::baseClassOf(RHS)) //argument and the receiver are the same type +bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const { + if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type return cast<BitsRecTy>(RHS)->Size == Size; RecTyKind kind = RHS->getRecTyKind(); return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind); } -Init *IntRecTy::convertValue(BitInit *BI) { - return IntInit::get(BI->getValue()); -} - -Init *IntRecTy::convertValue(BitsInit *BI) { - int64_t Result = 0; - for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) - if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) { - Result |= Bit->getValue() << i; - } else { - return nullptr; - } - return IntInit::get(Result); -} - -Init *IntRecTy::convertValue(TypedInit *TI) { - if (TI->getType()->typeIsConvertibleTo(this)) - return TI; // Accept variable if already of the right type! - return nullptr; -} - -bool IntRecTy::baseClassOf(const RecTy *RHS) const{ +bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const { RecTyKind kind = RHS->getRecTyKind(); return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind; } -Init *StringRecTy::convertValue(UnOpInit *BO) { - if (BO->getOpcode() == UnOpInit::CAST) { - Init *L = BO->getOperand()->convertInitializerTo(this); - if (!L) return nullptr; - if (L != BO->getOperand()) - return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); - return BO; - } - - return convertValue((TypedInit*)BO); -} - -Init *StringRecTy::convertValue(BinOpInit *BO) { - if (BO->getOpcode() == BinOpInit::STRCONCAT) { - Init *L = BO->getLHS()->convertInitializerTo(this); - Init *R = BO->getRHS()->convertInitializerTo(this); - if (!L || !R) return nullptr; - if (L != BO->getLHS() || R != BO->getRHS()) - return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); - return BO; - } - - return convertValue((TypedInit*)BO); -} - - -Init *StringRecTy::convertValue(TypedInit *TI) { - if (isa<StringRecTy>(TI->getType())) - return TI; // Accept variable if already of the right type! - return nullptr; +std::string StringRecTy::getAsString() const { + return "string"; } std::string ListRecTy::getAsString() const { return "list<" + Ty->getAsString() + ">"; } -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 (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) - Elements.push_back(CI); - else - return nullptr; - - if (!isa<ListRecTy>(LI->getType())) - return nullptr; - - return ListInit::get(Elements, this); -} - -Init *ListRecTy::convertValue(TypedInit *TI) { - // Ensure that TI is compatible with our class. - if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType())) - if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) - return TI; - return nullptr; -} - -bool ListRecTy::baseClassOf(const RecTy *RHS) const{ - if(const ListRecTy* ListTy = dyn_cast<ListRecTy>(RHS)) - return ListTy->getElementType()->typeIsConvertibleTo(Ty); +bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const { + if (const auto *ListTy = dyn_cast<ListRecTy>(RHS)) + return Ty->typeIsConvertibleTo(ListTy->getElementType()); return false; } -Init *DagRecTy::convertValue(TypedInit *TI) { - if (TI->getType()->typeIsConvertibleTo(this)) - return TI; - return nullptr; -} - -Init *DagRecTy::convertValue(UnOpInit *BO) { - if (BO->getOpcode() == UnOpInit::CAST) { - Init *L = BO->getOperand()->convertInitializerTo(this); - if (!L) return nullptr; - if (L != BO->getOperand()) - return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); - return BO; - } - return nullptr; -} - -Init *DagRecTy::convertValue(BinOpInit *BO) { - if (BO->getOpcode() == BinOpInit::CONCAT) { - Init *L = BO->getLHS()->convertInitializerTo(this); - Init *R = BO->getRHS()->convertInitializerTo(this); - if (!L || !R) return nullptr; - if (L != BO->getLHS() || R != BO->getRHS()) - return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); - return BO; - } - return nullptr; +std::string DagRecTy::getAsString() const { + return "dag"; } RecordRecTy *RecordRecTy::get(Record *R) { @@ -352,40 +159,23 @@ std::string RecordRecTy::getAsString() const { return Rec->getName(); } -Init *RecordRecTy::convertValue(DefInit *DI) { - // Ensure that DI is a subclass of Rec. - if (!DI->getDef()->isSubClassOf(Rec)) - return nullptr; - return DI; -} - -Init *RecordRecTy::convertValue(TypedInit *TI) { - // Ensure that TI is compatible with Rec. - if (RecordRecTy *RRT = dyn_cast<RecordRecTy>(TI->getType())) - if (RRT->getRecord()->isSubClassOf(getRecord()) || - RRT->getRecord() == getRecord()) - return TI; - return nullptr; -} - -bool RecordRecTy::baseClassOf(const RecTy *RHS) const{ +bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const { const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS); if (!RTy) return false; - if (Rec == RTy->getRecord() || RTy->getRecord()->isSubClassOf(Rec)) + if (RTy->getRecord() == Rec || Rec->isSubClassOf(RTy->getRecord())) return true; - const std::vector<Record*> &SC = Rec->getSuperClasses(); - for (unsigned i = 0, e = SC.size(); i != e; ++i) - if (RTy->getRecord()->isSubClassOf(SC[i])) + for (Record *SC : RTy->getRecord()->getSuperClasses()) + if (Rec->isSubClassOf(SC)) return true; return false; } /// resolveTypes - Find a common type that T1 and T2 convert to. -/// Return 0 if no such type exists. +/// Return null if no such type exists. /// RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { if (T1->typeIsConvertibleTo(T2)) @@ -396,38 +186,20 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { // If one is a Record type, check superclasses if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) { // See if T2 inherits from a type T1 also inherits from - const std::vector<Record *> &T1SuperClasses = - RecTy1->getRecord()->getSuperClasses(); - for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), - iend = T1SuperClasses.end(); - i != iend; - ++i) { - RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); + for (Record *SuperRec1 : RecTy1->getRecord()->getSuperClasses()) { + RecordRecTy *SuperRecTy1 = RecordRecTy::get(SuperRec1); RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); - if (NewType1) { - if (NewType1 != SuperRecTy1) { - delete SuperRecTy1; - } + if (NewType1) return NewType1; - } } } if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2)) { // See if T1 inherits from a type T2 also inherits from - const std::vector<Record *> &T2SuperClasses = - RecTy2->getRecord()->getSuperClasses(); - for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), - iend = T2SuperClasses.end(); - i != iend; - ++i) { - RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); + for (Record *SuperRec2 : RecTy2->getRecord()->getSuperClasses()) { + RecordRecTy *SuperRecTy2 = RecordRecTy::get(SuperRec2); RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); - if (NewType2) { - if (NewType2 != SuperRecTy2) { - delete SuperRecTy2; - } + if (NewType2) return NewType2; - } } } return nullptr; @@ -441,14 +213,24 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { void Init::anchor() { } void Init::dump() const { return print(errs()); } -void UnsetInit::anchor() { } - UnsetInit *UnsetInit::get() { static UnsetInit TheInit; return &TheInit; } -void BitInit::anchor() { } +Init *UnsetInit::convertInitializerTo(RecTy *Ty) const { + if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) { + SmallVector<Init *, 16> NewBits(BRT->getNumBits()); + + for (unsigned i = 0; i != BRT->getNumBits(); ++i) + NewBits[i] = UnsetInit::get(); + + return BitsInit::get(NewBits); + } + + // All other types can just be returned. + return const_cast<UnsetInit *>(this); +} BitInit *BitInit::get(bool V) { static BitInit True(true); @@ -457,20 +239,33 @@ BitInit *BitInit::get(bool V) { return V ? &True : &False; } +Init *BitInit::convertInitializerTo(RecTy *Ty) const { + if (isa<BitRecTy>(Ty)) + return const_cast<BitInit *>(this); + + if (isa<IntRecTy>(Ty)) + return IntInit::get(getValue()); + + if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) { + // Can only convert single bit. + if (BRT->getNumBits() == 1) + return BitsInit::get(const_cast<BitInit *>(this)); + } + + return nullptr; +} + static void ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { ID.AddInteger(Range.size()); - for (ArrayRef<Init *>::iterator i = Range.begin(), - iend = Range.end(); - i != iend; - ++i) - ID.AddPointer(*i); + for (Init *I : Range) + ID.AddPointer(I); } BitsInit *BitsInit::get(ArrayRef<Init *> Range) { - typedef FoldingSet<BitsInit> Pool; - static Pool ThePool; + static FoldingSet<BitsInit> ThePool; + static std::vector<std::unique_ptr<BitsInit>> TheActualPool; FoldingSetNodeID ID; ProfileBitsInit(ID, Range); @@ -481,7 +276,7 @@ BitsInit *BitsInit::get(ArrayRef<Init *> Range) { BitsInit *I = new BitsInit(Range); ThePool.InsertNode(I, IP); - + TheActualPool.push_back(std::unique_ptr<BitsInit>(I)); return I; } @@ -489,6 +284,32 @@ void BitsInit::Profile(FoldingSetNodeID &ID) const { ProfileBitsInit(ID, Bits); } +Init *BitsInit::convertInitializerTo(RecTy *Ty) const { + if (isa<BitRecTy>(Ty)) { + if (getNumBits() != 1) return nullptr; // Only accept if just one bit! + return getBit(0); + } + + if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) { + // If the number of bits is right, return it. Otherwise we need to expand + // or truncate. + if (getNumBits() != BRT->getNumBits()) return nullptr; + return const_cast<BitsInit *>(this); + } + + if (isa<IntRecTy>(Ty)) { + int64_t Result = 0; + for (unsigned i = 0, e = getNumBits(); i != e; ++i) + if (auto *Bit = dyn_cast<BitInit>(getBit(i))) + Result |= static_cast<int64_t>(Bit->getValue()) << i; + else + return nullptr; + return IntInit::get(Result); + } + + return nullptr; +} + Init * BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { SmallVector<Init *, 16> NewBits(Bits.size()); @@ -517,7 +338,7 @@ std::string BitsInit::getAsString() const { // bits initializer will resolve into VarBitInit to keep the field name and bit // number used in targets with fixed insn length. static Init *fixBitInit(const RecordVal *RV, Init *Before, Init *After) { - if (RV || After != UnsetInit::get()) + if (RV || !isa<UnsetInit>(After)) return After; return Before; } @@ -570,33 +391,52 @@ Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { return const_cast<BitsInit *>(this); } -namespace { - template<typename T> - class Pool : public T { - public: - ~Pool(); - }; - template<typename T> - Pool<T>::~Pool() { - for (typename T::iterator I = this->begin(), E = this->end(); I != E; ++I) { - typename T::value_type &Item = *I; - delete Item.second; - } - } -} - IntInit *IntInit::get(int64_t V) { - static Pool<DenseMap<int64_t, IntInit *> > ThePool; + static DenseMap<int64_t, std::unique_ptr<IntInit>> ThePool; - IntInit *&I = ThePool[V]; - if (!I) I = new IntInit(V); - return I; + std::unique_ptr<IntInit> &I = ThePool[V]; + if (!I) I.reset(new IntInit(V)); + return I.get(); } std::string IntInit::getAsString() const { return itostr(Value); } +/// canFitInBitfield - Return true if the number of bits is large enough to hold +/// the integer value. +static bool canFitInBitfield(int64_t Value, unsigned NumBits) { + // For example, with NumBits == 4, we permit Values from [-7 .. 15]. + return (NumBits >= sizeof(Value) * 8) || + (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); +} + +Init *IntInit::convertInitializerTo(RecTy *Ty) const { + if (isa<IntRecTy>(Ty)) + return const_cast<IntInit *>(this); + + if (isa<BitRecTy>(Ty)) { + int64_t Val = getValue(); + if (Val != 0 && Val != 1) return nullptr; // Only accept 0 or 1 for a bit! + return BitInit::get(Val != 0); + } + + if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) { + int64_t Value = getValue(); + // Make sure this bitfield is large enough to hold the integer value. + if (!canFitInBitfield(Value, BRT->getNumBits())) + return nullptr; + + SmallVector<Init *, 16> NewBits(BRT->getNumBits()); + for (unsigned i = 0; i != BRT->getNumBits(); ++i) + NewBits[i] = BitInit::get(Value & (1LL << i)); + + return BitsInit::get(NewBits); + } + + return nullptr; +} + Init * IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { SmallVector<Init *, 16> NewBits(Bits.size()); @@ -610,14 +450,19 @@ IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { return BitsInit::get(NewBits); } -void StringInit::anchor() { } - StringInit *StringInit::get(StringRef V) { - static Pool<StringMap<StringInit *> > ThePool; + static StringMap<std::unique_ptr<StringInit>> ThePool; - StringInit *&I = ThePool[V]; - if (!I) I = new StringInit(V); - return I; + std::unique_ptr<StringInit> &I = ThePool[V]; + if (!I) I.reset(new StringInit(V)); + return I.get(); +} + +Init *StringInit::convertInitializerTo(RecTy *Ty) const { + if (isa<StringRecTy>(Ty)) + return const_cast<StringInit *>(this); + + return nullptr; } static void ProfileListInit(FoldingSetNodeID &ID, @@ -626,16 +471,12 @@ static void ProfileListInit(FoldingSetNodeID &ID, ID.AddInteger(Range.size()); ID.AddPointer(EltTy); - for (ArrayRef<Init *>::iterator i = Range.begin(), - iend = Range.end(); - i != iend; - ++i) - ID.AddPointer(*i); + for (Init *I : Range) + ID.AddPointer(I); } ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { - typedef FoldingSet<ListInit> Pool; - static Pool ThePool; + static FoldingSet<ListInit> ThePool; static std::vector<std::unique_ptr<ListInit>> TheActualPool; FoldingSetNodeID ID; @@ -652,18 +493,35 @@ ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { } void ListInit::Profile(FoldingSetNodeID &ID) const { - ListRecTy *ListType = dyn_cast<ListRecTy>(getType()); - assert(ListType && "Bad type for ListInit!"); - RecTy *EltTy = ListType->getElementType(); + RecTy *EltTy = cast<ListRecTy>(getType())->getElementType(); ProfileListInit(ID, Values, EltTy); } +Init *ListInit::convertInitializerTo(RecTy *Ty) const { + if (auto *LRT = dyn_cast<ListRecTy>(Ty)) { + std::vector<Init*> Elements; + + // Verify that all of the elements of the list are subclasses of the + // appropriate class! + for (Init *I : getValues()) + if (Init *CI = I->convertInitializerTo(LRT->getElementType())) + Elements.push_back(CI); + else + return nullptr; + + if (isa<ListRecTy>(getType())) + return ListInit::get(Elements, Ty); + } + + return nullptr; +} + Init * ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { std::vector<Init*> Vals; for (unsigned i = 0, e = Elements.size(); i != e; ++i) { - if (Elements[i] >= getSize()) + if (Elements[i] >= size()) return nullptr; Vals.push_back(getElement(Elements[i])); } @@ -680,12 +538,11 @@ Record *ListInit::getElementAsRecord(unsigned i) const { Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { std::vector<Init*> Resolved; - Resolved.reserve(getSize()); + Resolved.reserve(size()); bool Changed = false; - for (unsigned i = 0, e = getSize(); i != e; ++i) { + for (Init *CurElt : getValues()) { Init *E; - Init *CurElt = getElement(i); do { E = CurElt; @@ -702,7 +559,7 @@ Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, unsigned Elt) const { - if (Elt >= getSize()) + if (Elt >= size()) return nullptr; // Out of range reference. Init *E = getElement(Elt); // If the element is set to some value, or if we are resolving a reference @@ -731,14 +588,10 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, } if (Resolved != this) { - TypedInit *Typed = dyn_cast<TypedInit>(Resolved); - assert(Typed && "Expected typed init for list reference"); - if (Typed) { - Init *New = Typed->resolveListElementReference(R, IRV, Elt); - if (New) - return New; - return VarListElementInit::get(Typed, Elt); - } + TypedInit *Typed = cast<TypedInit>(Resolved); + if (Init *New = Typed->resolveListElementReference(R, IRV, Elt)) + return New; + return VarListElementInit::get(Typed, Elt); } return nullptr; @@ -752,24 +605,24 @@ Init *OpInit::getBit(unsigned Bit) const { UnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; - static Pool<DenseMap<Key, UnOpInit *> > ThePool; + static DenseMap<Key, std::unique_ptr<UnOpInit>> ThePool; Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); - UnOpInit *&I = ThePool[TheKey]; - if (!I) I = new UnOpInit(opc, lhs, Type); - return I; + std::unique_ptr<UnOpInit> &I = ThePool[TheKey]; + if (!I) I.reset(new UnOpInit(opc, lhs, Type)); + return I.get(); } Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { switch (getOpcode()) { case CAST: { - if (getType()->getAsString() == "string") { + if (isa<StringRecTy>(getType())) { if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) return LHSs; if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) - return StringInit::get(LHSd->getDef()->getName()); + return StringInit::get(LHSd->getAsString()); if (IntInit *LHSi = dyn_cast<IntInit>(LHS)) return StringInit::get(LHSi->getAsString()); @@ -787,7 +640,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":"); - + if (CurRec->isTemplateArg(TemplateArgName)) { const RecordVal *RV = CurRec->getValue(TemplateArgName); assert(RV && "Template arg doesn't exist??"); @@ -800,7 +653,8 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { } if (CurMultiClass) { - Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); + Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, + "::"); if (CurMultiClass->Rec.isTemplateArg(MCName)) { const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); @@ -824,40 +678,25 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { } case HEAD: { if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { - assert(LHSl->getSize() != 0 && "Empty list in car"); + assert(!LHSl->empty() && "Empty list in head"); return LHSl->getElement(0); } break; } case TAIL: { if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { - assert(LHSl->getSize() != 0 && "Empty list in cdr"); + assert(!LHSl->empty() && "Empty list in tail"); // Note the +1. We can't just pass the result of getValues() // directly. - ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; - ArrayRef<Init *>::iterator end = LHSl->getValues().end(); - ListInit *Result = - ListInit::get(ArrayRef<Init *>(begin, end - begin), - LHSl->getType()); - return Result; + return ListInit::get(LHSl->getValues().slice(1), LHSl->getType()); } break; } case EMPTY: { - if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { - if (LHSl->getSize() == 0) { - return IntInit::get(1); - } else { - return IntInit::get(0); - } - } - if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { - if (LHSs->getValue().empty()) { - return IntInit::get(1); - } else { - return IntInit::get(0); - } - } + if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) + return IntInit::get(LHSl->empty()); + if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) + return IntInit::get(LHSs->getValue().empty()); break; } @@ -891,14 +730,14 @@ BinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, RecTy * > Key; - static Pool<DenseMap<Key, BinOpInit *> > ThePool; + static DenseMap<Key, std::unique_ptr<BinOpInit>> ThePool; Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), Type)); - BinOpInit *&I = ThePool[TheKey]; - if (!I) I = new BinOpInit(opc, lhs, rhs, Type); - return I; + std::unique_ptr<BinOpInit> &I = ThePool[TheKey]; + if (!I) I.reset(new BinOpInit(opc, lhs, rhs, Type)); + return I.get(); } Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { @@ -933,7 +772,7 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { Args.insert(Args.end(), LHSs->begin(), LHSs->end()); Args.insert(Args.end(), RHSs->begin(), RHSs->end()); return ListInit::get( - Args, static_cast<ListRecTy *>(LHSs->getType())->getElementType()); + Args, cast<ListRecTy>(LHSs->getType())->getElementType()); } break; } @@ -1017,9 +856,8 @@ std::string BinOpInit::getAsString() const { return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; } -TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, - Init *mhs, Init *rhs, - RecTy *Type) { +TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, + RecTy *Type) { typedef std::pair< std::pair< std::pair<std::pair<unsigned, RecTy *>, Init *>, @@ -1028,8 +866,7 @@ TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, Init * > Key; - typedef DenseMap<Key, TernOpInit *> Pool; - static Pool ThePool; + static DenseMap<Key, std::unique_ptr<TernOpInit>> ThePool; Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, Type), @@ -1037,9 +874,9 @@ TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, mhs), rhs)); - TernOpInit *&I = ThePool[TheKey]; - if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); - return I; + std::unique_ptr<TernOpInit> &I = ThePool[TheKey]; + if (!I) I.reset(new TernOpInit(opc, lhs, mhs, rhs, Type)); + return I.get(); } static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, @@ -1048,28 +885,19 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, RecTy *Type, Record *CurRec, MultiClass *CurMultiClass) { - std::vector<Init *> NewOperands; - - TypedInit *TArg = dyn_cast<TypedInit>(Arg); - // If this is a dag, recurse - if (TArg && TArg->getType()->getAsString() == "dag") { - Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, - CurRec, CurMultiClass); - return Result; - } - - for (int i = 0; i < RHSo->getNumOperands(); ++i) { - OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i)); + if (auto *TArg = dyn_cast<TypedInit>(Arg)) + if (isa<DagRecTy>(TArg->getType())) + return ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass); - if (RHSoo) { - Init *Result = EvaluateOperation(RHSoo, LHS, Arg, - Type, CurRec, CurMultiClass); - if (Result) { + std::vector<Init *> NewOperands; + for (unsigned i = 0; i < RHSo->getNumOperands(); ++i) { + if (auto *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i))) { + if (Init *Result = EvaluateOperation(RHSoo, LHS, Arg, + Type, CurRec, CurMultiClass)) NewOperands.push_back(Result); - } else { + else NewOperands.push_back(Arg); - } } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { NewOperands.push_back(Arg); } else { @@ -1085,76 +913,63 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, Record *CurRec, MultiClass *CurMultiClass) { - DagInit *MHSd = dyn_cast<DagInit>(MHS); - ListInit *MHSl = dyn_cast<ListInit>(MHS); OpInit *RHSo = dyn_cast<OpInit>(RHS); - if (!RHSo) { + if (!RHSo) PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n"); - } TypedInit *LHSt = dyn_cast<TypedInit>(LHS); if (!LHSt) PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n"); - if ((MHSd && isa<DagRecTy>(Type)) || (MHSl && isa<ListRecTy>(Type))) { - if (MHSd) { - Init *Val = MHSd->getOperator(); - Init *Result = EvaluateOperation(RHSo, LHS, Val, - Type, CurRec, CurMultiClass); - if (Result) { - Val = Result; - } + DagInit *MHSd = dyn_cast<DagInit>(MHS); + if (MHSd && isa<DagRecTy>(Type)) { + Init *Val = MHSd->getOperator(); + if (Init *Result = EvaluateOperation(RHSo, LHS, Val, + Type, CurRec, CurMultiClass)) + Val = Result; + + std::vector<std::pair<Init *, std::string> > args; + for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { + Init *Arg = MHSd->getArg(i); + std::string ArgName = MHSd->getArgName(i); + + // Process args + if (Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, + CurRec, CurMultiClass)) + Arg = Result; + + // TODO: Process arg names + args.push_back(std::make_pair(Arg, ArgName)); + } - std::vector<std::pair<Init *, std::string> > args; - for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { - Init *Arg; - std::string ArgName; - Arg = MHSd->getArg(i); - ArgName = MHSd->getArgName(i); - - // Process args - Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, - CurRec, CurMultiClass); - if (Result) { - Arg = Result; - } + return DagInit::get(Val, "", args); + } - // TODO: Process arg names - args.push_back(std::make_pair(Arg, ArgName)); + ListInit *MHSl = dyn_cast<ListInit>(MHS); + if (MHSl && isa<ListRecTy>(Type)) { + std::vector<Init *> NewOperands; + std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); + + for (Init *&Item : NewList) { + NewOperands.clear(); + for(unsigned i = 0; i < RHSo->getNumOperands(); ++i) { + // First, replace the foreach variable with the list item + if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) + NewOperands.push_back(Item); + else + NewOperands.push_back(RHSo->getOperand(i)); } - return DagInit::get(Val, "", args); - } - if (MHSl) { - std::vector<Init *> NewOperands; - std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); - - for (std::vector<Init *>::iterator li = NewList.begin(), - liend = NewList.end(); - li != liend; - ++li) { - Init *Item = *li; - NewOperands.clear(); - for(int i = 0; i < RHSo->getNumOperands(); ++i) { - // First, replace the foreach variable with the list item - if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { - NewOperands.push_back(Item); - } else { - NewOperands.push_back(RHSo->getOperand(i)); - } - } - - // Now run the operator and use its result as the new list item - const OpInit *NewOp = RHSo->clone(NewOperands); - Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); - if (NewItem != NewOp) - *li = NewItem; - } - return ListInit::get(NewList, MHSl->getType()); + // Now run the operator and use its result as the new list item + const OpInit *NewOp = RHSo->clone(NewOperands); + Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); + if (NewItem != NewOp) + Item = NewItem; } + return ListInit::get(NewList, MHSl->getType()); } return nullptr; } @@ -1174,48 +989,40 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { VarInit *RHSv = dyn_cast<VarInit>(RHS); StringInit *RHSs = dyn_cast<StringInit>(RHS); - if ((LHSd && MHSd && RHSd) - || (LHSv && MHSv && RHSv) - || (LHSs && MHSs && RHSs)) { - if (RHSd) { - Record *Val = RHSd->getDef(); - if (LHSd->getAsString() == RHSd->getAsString()) { - Val = MHSd->getDef(); - } - return DefInit::get(Val); - } - if (RHSv) { - std::string Val = RHSv->getName(); - if (LHSv->getAsString() == RHSv->getAsString()) { - Val = MHSv->getName(); - } - return VarInit::get(Val, getType()); + if (LHSd && MHSd && RHSd) { + Record *Val = RHSd->getDef(); + if (LHSd->getAsString() == RHSd->getAsString()) + Val = MHSd->getDef(); + return DefInit::get(Val); + } + if (LHSv && MHSv && RHSv) { + std::string Val = RHSv->getName(); + if (LHSv->getAsString() == RHSv->getAsString()) + Val = MHSv->getName(); + return VarInit::get(Val, getType()); + } + if (LHSs && MHSs && RHSs) { + std::string Val = RHSs->getValue(); + + std::string::size_type found; + std::string::size_type idx = 0; + while (true) { + found = Val.find(LHSs->getValue(), idx); + if (found == std::string::npos) + break; + Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); + idx = found + MHSs->getValue().size(); } - if (RHSs) { - std::string Val = RHSs->getValue(); - - std::string::size_type found; - std::string::size_type idx = 0; - do { - found = Val.find(LHSs->getValue(), idx); - if (found != std::string::npos) { - Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); - } - idx = found + MHSs->getValue().size(); - } while (found != std::string::npos); - return StringInit::get(Val); - } + return StringInit::get(Val); } break; } case FOREACH: { - Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), - CurRec, CurMultiClass); - if (Result) { + if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), + CurRec, CurMultiClass)) return Result; - } break; } @@ -1224,11 +1031,9 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) LHSi = dyn_cast<IntInit>(I); if (LHSi) { - if (LHSi->getValue()) { + if (LHSi->getValue()) return MHS; - } else { - return RHS; - } + return RHS; } break; } @@ -1251,11 +1056,10 @@ Init *TernOpInit::resolveReferences(Record &R, Init *mhs = MHS->resolveReferences(R, RV); return (TernOpInit::get(getOpcode(), lhs, mhs, RHS, getType()))->Fold(&R, nullptr); - } else { - Init *rhs = RHS->resolveReferences(R, RV); - return (TernOpInit::get(getOpcode(), lhs, MHS, - rhs, getType()))->Fold(&R, nullptr); } + Init *rhs = RHS->resolveReferences(R, RV); + return (TernOpInit::get(getOpcode(), lhs, MHS, + rhs, getType()))->Fold(&R, nullptr); } } @@ -1274,9 +1078,9 @@ std::string TernOpInit::getAsString() const { case SUBST: Result = "!subst"; break; case FOREACH: Result = "!foreach"; break; case IF: Result = "!if"; break; - } - return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " - + RHS->getAsString() + ")"; + } + return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " + + RHS->getAsString() + ")"; } RecTy *TypedInit::getFieldType(const std::string &FieldName) const { @@ -1287,6 +1091,82 @@ RecTy *TypedInit::getFieldType(const std::string &FieldName) const { } Init * +TypedInit::convertInitializerTo(RecTy *Ty) const { + if (isa<IntRecTy>(Ty)) { + if (getType()->typeIsConvertibleTo(Ty)) + return const_cast<TypedInit *>(this); + return nullptr; + } + + if (isa<StringRecTy>(Ty)) { + if (isa<StringRecTy>(getType())) + return const_cast<TypedInit *>(this); + return nullptr; + } + + if (isa<BitRecTy>(Ty)) { + // Accept variable if it is already of bit type! + if (isa<BitRecTy>(getType())) + return const_cast<TypedInit *>(this); + if (auto *BitsTy = dyn_cast<BitsRecTy>(getType())) { + // Accept only bits<1> expression. + if (BitsTy->getNumBits() == 1) + return const_cast<TypedInit *>(this); + return nullptr; + } + // Ternary !if can be converted to bit, but only if both sides are + // convertible to a bit. + if (const auto *TOI = dyn_cast<TernOpInit>(this)) { + if (TOI->getOpcode() == TernOpInit::TernaryOp::IF && + TOI->getMHS()->convertInitializerTo(BitRecTy::get()) && + TOI->getRHS()->convertInitializerTo(BitRecTy::get())) + return const_cast<TypedInit *>(this); + return nullptr; + } + return nullptr; + } + + if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) { + if (BRT->getNumBits() == 1 && isa<BitRecTy>(getType())) + return BitsInit::get(const_cast<TypedInit *>(this)); + + if (getType()->typeIsConvertibleTo(BRT)) { + SmallVector<Init *, 16> NewBits(BRT->getNumBits()); + + for (unsigned i = 0; i != BRT->getNumBits(); ++i) + NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), i); + return BitsInit::get(NewBits); + } + + return nullptr; + } + + if (auto *DLRT = dyn_cast<ListRecTy>(Ty)) { + if (auto *SLRT = dyn_cast<ListRecTy>(getType())) + if (SLRT->getElementType()->typeIsConvertibleTo(DLRT->getElementType())) + return const_cast<TypedInit *>(this); + return nullptr; + } + + if (auto *DRT = dyn_cast<DagRecTy>(Ty)) { + if (getType()->typeIsConvertibleTo(DRT)) + return const_cast<TypedInit *>(this); + return nullptr; + } + + if (auto *SRRT = dyn_cast<RecordRecTy>(Ty)) { + // Ensure that this is compatible with Rec. + if (RecordRecTy *DRRT = dyn_cast<RecordRecTy>(getType())) + if (DRRT->getRecord()->isSubClassOf(SRRT->getRecord()) || + DRRT->getRecord() == SRRT->getRecord()) + return const_cast<TypedInit *>(this); + return nullptr; + } + + return nullptr; +} + +Init * TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); if (!T) return nullptr; // Cannot subscript a non-bits variable. @@ -1326,18 +1206,17 @@ VarInit *VarInit::get(const std::string &VN, RecTy *T) { VarInit *VarInit::get(Init *VN, RecTy *T) { typedef std::pair<RecTy *, Init *> Key; - static Pool<DenseMap<Key, VarInit *> > ThePool; + static DenseMap<Key, std::unique_ptr<VarInit>> ThePool; Key TheKey(std::make_pair(T, VN)); - VarInit *&I = ThePool[TheKey]; - if (!I) I = new VarInit(VN, T); - return I; + std::unique_ptr<VarInit> &I = ThePool[TheKey]; + if (!I) I.reset(new VarInit(VN, T)); + return I.get(); } const std::string &VarInit::getName() const { - StringInit *NameString = dyn_cast<StringInit>(getNameInit()); - assert(NameString && "VarInit name is not a string!"); + StringInit *NameString = cast<StringInit>(getNameInit()); return NameString->getValue(); } @@ -1356,13 +1235,10 @@ Init *VarInit::resolveListElementReference(Record &R, RecordVal *RV = R.getValue(getNameInit()); assert(RV && "Reference to a non-existent variable?"); ListInit *LI = dyn_cast<ListInit>(RV->getValue()); - if (!LI) { - TypedInit *VI = dyn_cast<TypedInit>(RV->getValue()); - assert(VI && "Invalid list element!"); - return VarListElementInit::get(VI, Elt); - } + if (!LI) + return VarListElementInit::get(cast<TypedInit>(RV->getValue()), Elt); - if (Elt >= LI->getSize()) + if (Elt >= LI->size()) return nullptr; // Out of range reference. Init *E = LI->getElement(Elt); // If the element is set to some value, or if we are resolving a reference @@ -1391,8 +1267,7 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, assert(TheInit != this && "Infinite loop detected!"); if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) return I; - else - return nullptr; + return nullptr; } return nullptr; } @@ -1411,19 +1286,24 @@ Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { typedef std::pair<TypedInit *, unsigned> Key; - typedef DenseMap<Key, VarBitInit *> Pool; - - static Pool ThePool; + static DenseMap<Key, std::unique_ptr<VarBitInit>> ThePool; Key TheKey(std::make_pair(T, B)); - VarBitInit *&I = ThePool[TheKey]; - if (!I) I = new VarBitInit(T, B); - return I; + std::unique_ptr<VarBitInit> &I = ThePool[TheKey]; + if (!I) I.reset(new VarBitInit(T, B)); + return I.get(); +} + +Init *VarBitInit::convertInitializerTo(RecTy *Ty) const { + if (isa<BitRecTy>(Ty)) + return const_cast<VarBitInit *>(this); + + return nullptr; } std::string VarBitInit::getAsString() const { - return TI->getAsString() + "{" + utostr(Bit) + "}"; + return TI->getAsString() + "{" + utostr(Bit) + "}"; } Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { @@ -1437,15 +1317,13 @@ Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { VarListElementInit *VarListElementInit::get(TypedInit *T, unsigned E) { typedef std::pair<TypedInit *, unsigned> Key; - typedef DenseMap<Key, VarListElementInit *> Pool; - - static Pool ThePool; + static DenseMap<Key, std::unique_ptr<VarListElementInit>> ThePool; Key TheKey(std::make_pair(T, E)); - VarListElementInit *&I = ThePool[TheKey]; - if (!I) I = new VarListElementInit(T, E); - return I; + std::unique_ptr<VarListElementInit> &I = ThePool[TheKey]; + if (!I) I.reset(new VarListElementInit(T, E)); + return I.get(); } std::string VarListElementInit::getAsString() const { @@ -1469,17 +1347,15 @@ Init *VarListElementInit::getBit(unsigned Bit) const { Init *VarListElementInit:: resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const { - Init *Result = TI->resolveListElementReference(R, RV, Element); - - if (Result) { + if (Init *Result = TI->resolveListElementReference(R, RV, Element)) { if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) { - Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); - if (Result2) return Result2; - return new VarListElementInit(TInit, Elt); + if (Init *Result2 = TInit->resolveListElementReference(R, RV, Elt)) + return Result2; + return VarListElementInit::get(TInit, Elt); } return Result; } - + return nullptr; } @@ -1487,6 +1363,13 @@ DefInit *DefInit::get(Record *R) { return R->getDefInit(); } +Init *DefInit::convertInitializerTo(RecTy *Ty) const { + if (auto *RRT = dyn_cast<RecordRecTy>(Ty)) + if (getDef()->isSubClassOf(RRT->getRecord())) + return const_cast<DefInit *>(this); + return nullptr; +} + RecTy *DefInit::getFieldType(const std::string &FieldName) const { if (const RecordVal *RV = Def->getValue(FieldName)) return RV->getType(); @@ -1505,14 +1388,13 @@ std::string DefInit::getAsString() const { FieldInit *FieldInit::get(Init *R, const std::string &FN) { typedef std::pair<Init *, TableGenStringKey> Key; - typedef DenseMap<Key, FieldInit *> Pool; - static Pool ThePool; + static DenseMap<Key, std::unique_ptr<FieldInit>> ThePool; Key TheKey(std::make_pair(R, FN)); - FieldInit *&I = ThePool[TheKey]; - if (!I) I = new FieldInit(R, FN); - return I; + std::unique_ptr<FieldInit> &I = ThePool[TheKey]; + if (!I) I.reset(new FieldInit(R, FN)); + return I.get(); } Init *FieldInit::getBit(unsigned Bit) const { @@ -1525,7 +1407,7 @@ Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const { if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) if (ListInit *LI = dyn_cast<ListInit>(ListVal)) { - if (Elt >= LI->getSize()) return nullptr; + if (Elt >= LI->size()) return nullptr; Init *E = LI->getElement(Elt); // If the element is set to some value, or if we are resolving a @@ -1540,15 +1422,13 @@ Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; - Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); - if (BitsVal) { + if (Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName)) { Init *BVR = BitsVal->resolveReferences(R, RV); return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); } - if (NewRec != Rec) { + if (NewRec != Rec) return FieldInit::get(NewRec, FieldName); - } return const_cast<FieldInit *>(this); } @@ -1572,8 +1452,8 @@ DagInit * DagInit::get(Init *V, const std::string &VN, ArrayRef<Init *> ArgRange, ArrayRef<std::string> NameRange) { - typedef FoldingSet<DagInit> Pool; - static Pool ThePool; + static FoldingSet<DagInit> ThePool; + static std::vector<std::unique_ptr<DagInit>> TheActualPool; FoldingSetNodeID ID; ProfileDagInit(ID, V, VN, ArgRange, NameRange); @@ -1584,24 +1464,19 @@ DagInit::get(Init *V, const std::string &VN, DagInit *I = new DagInit(V, VN, ArgRange, NameRange); ThePool.InsertNode(I, IP); - + TheActualPool.push_back(std::unique_ptr<DagInit>(I)); return I; } DagInit * DagInit::get(Init *V, const std::string &VN, const std::vector<std::pair<Init*, std::string> > &args) { - typedef std::pair<Init*, std::string> PairType; - std::vector<Init *> Args; std::vector<std::string> Names; - for (std::vector<PairType>::const_iterator i = args.begin(), - iend = args.end(); - i != iend; - ++i) { - Args.push_back(i->first); - Names.push_back(i->second); + for (const auto &Arg : args) { + Args.push_back(Arg.first); + Names.push_back(Arg.second); } return DagInit::get(V, VN, Args, Names); @@ -1611,6 +1486,13 @@ void DagInit::Profile(FoldingSetNodeID &ID) const { ProfileDagInit(ID, Val, ValName, Args, ArgNames); } +Init *DagInit::convertInitializerTo(RecTy *Ty) const { + if (isa<DagRecTy>(Ty)) + return const_cast<DagInit *>(this); + + return nullptr; +} + Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { std::vector<Init*> NewArgs; for (unsigned i = 0, e = Args.size(); i != e; ++i) @@ -1629,7 +1511,7 @@ std::string DagInit::getAsString() const { std::string Result = "(" + Val->getAsString(); if (!ValName.empty()) Result += ":" + ValName; - if (Args.size()) { + if (!Args.empty()) { Result += " " + Args[0]->getAsString(); if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; for (unsigned i = 1, e = Args.size(); i != e; ++i) { @@ -1645,22 +1527,20 @@ std::string DagInit::getAsString() const { // Other implementations //===----------------------------------------------------------------------===// -RecordVal::RecordVal(Init *N, RecTy *T, unsigned P) - : Name(N), Ty(T), Prefix(P) { - Value = Ty->convertValue(UnsetInit::get()); +RecordVal::RecordVal(Init *N, RecTy *T, bool P) + : NameAndPrefix(N, P), Ty(T) { + Value = UnsetInit::get()->convertInitializerTo(Ty); assert(Value && "Cannot create unset value for current type!"); } -RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) - : Name(StringInit::get(N)), Ty(T), Prefix(P) { - Value = Ty->convertValue(UnsetInit::get()); +RecordVal::RecordVal(const std::string &N, RecTy *T, bool P) + : NameAndPrefix(StringInit::get(N), P), Ty(T) { + Value = UnsetInit::get()->convertInitializerTo(Ty); assert(Value && "Cannot create unset value for current type!"); } const std::string &RecordVal::getName() const { - StringInit *NameString = dyn_cast<StringInit>(Name); - assert(NameString && "RecordVal name is not a string!"); - return NameString->getValue(); + return cast<StringInit>(getNameInit())->getValue(); } void RecordVal::dump() const { errs() << *this; } @@ -1688,23 +1568,23 @@ void Record::init() { void Record::checkName() { // Ensure the record name has string type. - const TypedInit *TypedName = dyn_cast<const TypedInit>(Name); - assert(TypedName && "Record name is not typed!"); - RecTy *Type = TypedName->getType(); - if (!isa<StringRecTy>(Type)) + const TypedInit *TypedName = cast<const TypedInit>(Name); + if (!isa<StringRecTy>(TypedName->getType())) PrintFatalError(getLoc(), "Record name is not a string!"); } DefInit *Record::getDefInit() { - if (!TheInit) - TheInit = new DefInit(this, new RecordRecTy(this)); - return TheInit; + static DenseMap<Record *, std::unique_ptr<DefInit>> ThePool; + if (TheInit) + return TheInit; + + std::unique_ptr<DefInit> &I = ThePool[this]; + if (!I) I.reset(new DefInit(this, new RecordRecTy(this))); + return I.get(); } const std::string &Record::getName() const { - const StringInit *NameString = dyn_cast<StringInit>(Name); - assert(NameString && "Record name is not a string!"); - return NameString->getValue(); + return cast<StringInit>(Name)->getValue(); } void Record::setName(Init *NewName) { @@ -1736,14 +1616,13 @@ void Record::resolveReferencesTo(const RecordVal *RV) { continue; if (Init *V = Values[i].getValue()) if (Values[i].setValue(V->resolveReferences(*this, RV))) - PrintFatalError(getLoc(), "Invalid value is found when setting '" - + Values[i].getNameInitAsString() - + "' after resolving references" - + (RV ? " against '" + RV->getNameInitAsString() - + "' of (" - + RV->getValue()->getAsUnquotedString() + ")" - : "") - + "\n"); + PrintFatalError(getLoc(), "Invalid value is found when setting '" + + Values[i].getNameInitAsString() + + "' after resolving references" + + (RV ? " against '" + RV->getNameInitAsString() + + "' of (" + RV->getValue()->getAsUnquotedString() + + ")" + : "") + "\n"); } Init *OldName = getNameInit(); Init *NewName = Name->resolveReferences(*this, RV); @@ -1761,9 +1640,11 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { const std::vector<Init *> &TArgs = R.getTemplateArgs(); if (!TArgs.empty()) { OS << "<"; - for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { - if (i) OS << ", "; - const RecordVal *RV = R.getValue(TArgs[i]); + bool NeedComma = false; + for (const Init *TA : TArgs) { + if (NeedComma) OS << ", "; + NeedComma = true; + const RecordVal *RV = R.getValue(TA); assert(RV && "Template argument record not found??"); RV->print(OS, false); } @@ -1774,18 +1655,17 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { const std::vector<Record*> &SC = R.getSuperClasses(); if (!SC.empty()) { OS << "\t//"; - for (unsigned i = 0, e = SC.size(); i != e; ++i) - OS << " " << SC[i]->getNameInitAsString(); + for (const Record *Super : SC) + OS << " " << Super->getNameInitAsString(); } OS << "\n"; - const std::vector<RecordVal> &Vals = R.getValues(); - for (unsigned i = 0, e = Vals.size(); i != e; ++i) - if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) - OS << Vals[i]; - for (unsigned i = 0, e = Vals.size(); i != e; ++i) - if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) - OS << Vals[i]; + for (const RecordVal &Val : R.getValues()) + if (Val.getPrefix() && !R.isTemplateArg(Val.getName())) + OS << Val; + for (const RecordVal &Val : R.getValues()) + if (!Val.getPrefix() && !R.isTemplateArg(Val.getName())) + OS << Val; return OS << "}\n"; } @@ -1858,13 +1738,12 @@ std::vector<Record*> Record::getValueAsListOfDefs(StringRef FieldName) const { ListInit *List = getValueAsListInit(FieldName); std::vector<Record*> Defs; - for (unsigned i = 0; i < List->getSize(); i++) { - if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) { + for (Init *I : List->getValues()) { + if (DefInit *DI = dyn_cast<DefInit>(I)) Defs.push_back(DI->getDef()); - } else { + else PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName + "' list is not entirely DefInit!"); - } } return Defs; } @@ -1893,13 +1772,12 @@ std::vector<int64_t> Record::getValueAsListOfInts(StringRef FieldName) const { ListInit *List = getValueAsListInit(FieldName); std::vector<int64_t> Ints; - for (unsigned i = 0; i < List->getSize(); i++) { - if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) { + for (Init *I : List->getValues()) { + if (IntInit *II = dyn_cast<IntInit>(I)) Ints.push_back(II->getValue()); - } else { + else PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName + "' does not have a list of ints initializer!"); - } } return Ints; } @@ -1912,13 +1790,12 @@ std::vector<std::string> Record::getValueAsListOfStrings(StringRef FieldName) const { ListInit *List = getValueAsListInit(FieldName); std::vector<std::string> Strings; - for (unsigned i = 0; i < List->getSize(); i++) { - if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) { - Strings.push_back(II->getValue()); - } else { + for (Init *I : List->getValues()) { + if (StringInit *SI = dyn_cast<StringInit>(I)) + Strings.push_back(SI->getValue()); + else PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + FieldName + "' does not have a list of strings initializer!"); - } } return Strings; } @@ -1961,7 +1838,7 @@ bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"); - if (R->getValue() == UnsetInit::get()) { + if (isa<UnsetInit>(R->getValue())) { Unset = true; return false; } @@ -1994,12 +1871,8 @@ void MultiClass::dump() const { Rec.dump(); errs() << "Defs:\n"; - for (RecordVector::const_iterator r = DefPrototypes.begin(), - rend = DefPrototypes.end(); - r != rend; - ++r) { - (*r)->dump(); - } + for (const auto &Proto : DefPrototypes) + Proto->dump(); } @@ -2007,13 +1880,11 @@ void RecordKeeper::dump() const { errs() << *this; } raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { OS << "------------- Classes -----------------\n"; - const auto &Classes = RK.getClasses(); - for (const auto &C : Classes) + for (const auto &C : RK.getClasses()) OS << "class " << *C.second; OS << "------------- Defs -----------------\n"; - const auto &Defs = RK.getDefs(); - for (const auto &D : Defs) + for (const auto &D : RK.getDefs()) OS << "def " << *D.second; return OS; } @@ -2040,26 +1911,26 @@ RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { /// to CurRec's name. Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, Init *Name, const std::string &Scoper) { - RecTy *Type = dyn_cast<TypedInit>(Name)->getType(); + RecTy *Type = cast<TypedInit>(Name)->getType(); BinOpInit *NewName = - BinOpInit::get(BinOpInit::STRCONCAT, - BinOpInit::get(BinOpInit::STRCONCAT, - CurRec.getNameInit(), - StringInit::get(Scoper), - Type)->Fold(&CurRec, CurMultiClass), - Name, - Type); + BinOpInit::get(BinOpInit::STRCONCAT, + BinOpInit::get(BinOpInit::STRCONCAT, + CurRec.getNameInit(), + StringInit::get(Scoper), + Type)->Fold(&CurRec, CurMultiClass), + Name, + Type); if (CurMultiClass && Scoper != "::") { NewName = - BinOpInit::get(BinOpInit::STRCONCAT, - BinOpInit::get(BinOpInit::STRCONCAT, - CurMultiClass->Rec.getNameInit(), - StringInit::get("::"), - Type)->Fold(&CurRec, CurMultiClass), - NewName->Fold(&CurRec, CurMultiClass), - Type); + BinOpInit::get(BinOpInit::STRCONCAT, + BinOpInit::get(BinOpInit::STRCONCAT, + CurMultiClass->Rec.getNameInit(), + StringInit::get("::"), + Type)->Fold(&CurRec, CurMultiClass), + NewName->Fold(&CurRec, CurMultiClass), + Type); } return NewName->Fold(&CurRec, CurMultiClass); diff --git a/contrib/llvm/lib/TableGen/SetTheory.cpp b/contrib/llvm/lib/TableGen/SetTheory.cpp index c99c2ba..92f5b2d 100644 --- a/contrib/llvm/lib/TableGen/SetTheory.cpp +++ b/contrib/llvm/lib/TableGen/SetTheory.cpp @@ -12,10 +12,10 @@ // //===----------------------------------------------------------------------===// +#include "llvm/TableGen/SetTheory.h" #include "llvm/Support/Format.h" #include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" -#include "llvm/TableGen/SetTheory.h" using namespace llvm; @@ -245,28 +245,28 @@ void SetTheory::Expander::anchor() {} SetTheory::SetTheory() { - addOperator("add", new AddOp); - addOperator("sub", new SubOp); - addOperator("and", new AndOp); - addOperator("shl", new ShlOp); - addOperator("trunc", new TruncOp); - addOperator("rotl", new RotOp(false)); - addOperator("rotr", new RotOp(true)); - addOperator("decimate", new DecimateOp); - addOperator("interleave", new InterleaveOp); - addOperator("sequence", new SequenceOp); + addOperator("add", llvm::make_unique<AddOp>()); + addOperator("sub", llvm::make_unique<SubOp>()); + addOperator("and", llvm::make_unique<AndOp>()); + addOperator("shl", llvm::make_unique<ShlOp>()); + addOperator("trunc", llvm::make_unique<TruncOp>()); + addOperator("rotl", llvm::make_unique<RotOp>(false)); + addOperator("rotr", llvm::make_unique<RotOp>(true)); + addOperator("decimate", llvm::make_unique<DecimateOp>()); + addOperator("interleave", llvm::make_unique<InterleaveOp>()); + addOperator("sequence", llvm::make_unique<SequenceOp>()); } -void SetTheory::addOperator(StringRef Name, Operator *Op) { - Operators[Name] = Op; +void SetTheory::addOperator(StringRef Name, std::unique_ptr<Operator> Op) { + Operators[Name] = std::move(Op); } -void SetTheory::addExpander(StringRef ClassName, Expander *E) { - Expanders[ClassName] = E; +void SetTheory::addExpander(StringRef ClassName, std::unique_ptr<Expander> E) { + Expanders[ClassName] = std::move(E); } void SetTheory::addFieldExpander(StringRef ClassName, StringRef FieldName) { - addExpander(ClassName, new FieldExpander(FieldName)); + addExpander(ClassName, llvm::make_unique<FieldExpander>(FieldName)); } void SetTheory::evaluate(Init *Expr, RecSet &Elts, ArrayRef<SMLoc> Loc) { @@ -289,10 +289,10 @@ void SetTheory::evaluate(Init *Expr, RecSet &Elts, ArrayRef<SMLoc> Loc) { DefInit *OpInit = dyn_cast<DefInit>(DagExpr->getOperator()); if (!OpInit) PrintFatalError(Loc, "Bad set expression: " + Expr->getAsString()); - Operator *Op = Operators.lookup(OpInit->getDef()->getName()); - if (!Op) + auto I = Operators.find(OpInit->getDef()->getName()); + if (I == Operators.end()) PrintFatalError(Loc, "Unknown set operator: " + Expr->getAsString()); - Op->apply(*this, DagExpr, Elts, Loc); + I->second->apply(*this, DagExpr, Elts, Loc); } const RecVec *SetTheory::expand(Record *Set) { @@ -307,11 +307,12 @@ const RecVec *SetTheory::expand(Record *Set) { // Skip unnamed superclasses. if (!dyn_cast<StringInit>(SC[i]->getNameInit())) continue; - if (Expander *Exp = Expanders.lookup(SC[i]->getName())) { + auto I = Expanders.find(SC[i]->getName()); + if (I != Expanders.end()) { // This breaks recursive definitions. RecVec &EltVec = Expansions[Set]; RecSet Elts; - Exp->expand(*this, Set, Elts); + I->second->expand(*this, Set, Elts); EltVec.assign(Elts.begin(), Elts.end()); return &EltVec; } diff --git a/contrib/llvm/lib/TableGen/TGLexer.h b/contrib/llvm/lib/TableGen/TGLexer.h index 1f750fc..cbc30be 100644 --- a/contrib/llvm/lib/TableGen/TGLexer.h +++ b/contrib/llvm/lib/TableGen/TGLexer.h @@ -87,8 +87,7 @@ private: public: TGLexer(SourceMgr &SrcMgr); - ~TGLexer() {} - + tgtok::TokKind Lex() { return CurCode = LexToken(); } diff --git a/contrib/llvm/lib/TableGen/TGParser.cpp b/contrib/llvm/lib/TableGen/TGParser.cpp index a438cb6..15df25a 100644 --- a/contrib/llvm/lib/TableGen/TGParser.cpp +++ b/contrib/llvm/lib/TableGen/TGParser.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "TGParser.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/CommandLine.h" @@ -50,12 +51,8 @@ void SubMultiClassReference::dump() const { MC->dump(); errs() << "Template args:\n"; - for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(), - iend = TemplateArgs.end(); - i != iend; - ++i) { - (*i)->dump(); - } + for (Init *TA : TemplateArgs) + TA->dump(); } } // end namespace llvm @@ -87,8 +84,8 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, RecordVal *RV = CurRec->getValue(ValName); if (!RV) - return Error(Loc, "Value '" + ValName->getAsUnquotedString() - + "' unknown!"); + return Error(Loc, "Value '" + ValName->getAsUnquotedString() + + "' unknown!"); // Do not allow assignments like 'X = X'. This will just cause infinite loops // in the resolution machinery. @@ -104,18 +101,16 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, if (!BitList.empty()) { BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue()); if (!CurVal) - return Error(Loc, "Value '" + ValName->getAsUnquotedString() - + "' is not a bits type"); + return Error(Loc, "Value '" + ValName->getAsUnquotedString() + + "' is not a bits type"); // Convert the incoming value to a bits type of the appropriate size... Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size())); - if (!BI) { + if (!BI) return Error(Loc, "Initializer is not compatible with bit range"); - } // We should have a BitsInit type now. - BitsInit *BInit = dyn_cast<BitsInit>(BI); - assert(BInit != nullptr); + BitsInit *BInit = cast<BitsInit>(BI); SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); @@ -123,7 +118,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, for (unsigned i = 0, e = BitList.size(); i != e; ++i) { unsigned Bit = BitList[i]; if (NewBits[Bit]) - return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" + + return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" + ValName->getAsUnquotedString() + "' more than once"); NewBits[Bit] = BInit->getBit(i); } @@ -137,15 +132,13 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, if (RV->setValue(V)) { std::string InitType = ""; - if (BitsInit *BI = dyn_cast<BitsInit>(V)) { + if (BitsInit *BI = dyn_cast<BitsInit>(V)) InitType = (Twine("' of type bit initializer with length ") + Twine(BI->getNumBits())).str(); - } - return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' of type '" - + RV->getType()->getAsString() + - "' is incompatible with initializer '" + V->getAsString() - + InitType - + "'"); + return Error(Loc, "Value '" + ValName->getAsUnquotedString() + + "' of type '" + RV->getType()->getAsString() + + "' is incompatible with initializer '" + V->getAsString() + + InitType + "'"); } return false; } @@ -155,9 +148,8 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { Record *SC = SubClass.Rec; // Add all of the values in the subclass into the current class. - const std::vector<RecordVal> &Vals = SC->getValues(); - for (unsigned i = 0, e = Vals.size(); i != e; ++i) - if (AddValue(CurRec, SubClass.RefRange.Start, Vals[i])) + for (const RecordVal &Val : SC->getValues()) + if (AddValue(CurRec, SubClass.RefRange.Start, Val)) return true; const std::vector<Init *> &TArgs = SC->getTemplateArgs(); @@ -184,9 +176,9 @@ bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { return Error(SubClass.RefRange.Start, - "Value not specified for template argument #" - + utostr(i) + " (" + TArgs[i]->getAsUnquotedString() - + ") of subclass '" + SC->getNameInitAsString() + "'!"); + "Value not specified for template argument #" + + Twine(i) + " (" + TArgs[i]->getAsUnquotedString() + + ") of subclass '" + SC->getNameInitAsString() + "'!"); } } @@ -216,27 +208,21 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, MultiClass *SMC = SubMultiClass.MC; Record *CurRec = &CurMC->Rec; - const std::vector<RecordVal> &MCVals = CurRec->getValues(); - // Add all of the values in the subclass into the current class. - const std::vector<RecordVal> &SMCVals = SMC->Rec.getValues(); - for (unsigned i = 0, e = SMCVals.size(); i != e; ++i) - if (AddValue(CurRec, SubMultiClass.RefRange.Start, SMCVals[i])) + for (const auto &SMCVal : SMC->Rec.getValues()) + if (AddValue(CurRec, SubMultiClass.RefRange.Start, SMCVal)) return true; unsigned newDefStart = CurMC->DefPrototypes.size(); // Add all of the defs in the subclass into the current multiclass. - for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(), - iend = SMC->DefPrototypes.end(); - i != iend; - ++i) { + for (const std::unique_ptr<Record> &R : SMC->DefPrototypes) { // Clone the def and add it to the current multiclass - auto NewDef = make_unique<Record>(**i); + auto NewDef = make_unique<Record>(*R); // Add all of the values in the superclass into the current def. - for (unsigned i = 0, e = MCVals.size(); i != e; ++i) - if (AddValue(NewDef.get(), SubMultiClass.RefRange.Start, MCVals[i])) + for (const auto &MCVal : CurRec->getValues()) + if (AddValue(NewDef.get(), SubMultiClass.RefRange.Start, MCVal)) return true; CurMC->DefPrototypes.push_back(std::move(NewDef)); @@ -284,9 +270,9 @@ bool TGParser::AddSubMultiClass(MultiClass *CurMC, } } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) { return Error(SubMultiClass.RefRange.Start, - "Value not specified for template argument #" - + utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString() - + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!"); + "Value not specified for template argument #" + + Twine(i) + " (" + SMCTArgs[i]->getAsUnquotedString() + + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!"); } } @@ -322,7 +308,7 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ } // Process each value. - for (int64_t i = 0; i < List->getSize(); ++i) { + for (unsigned i = 0; i < List->size(); ++i) { Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i); IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal)); if (ProcessForeachDefs(CurRec, Loc, IterVals)) @@ -338,9 +324,9 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ auto IterRec = make_unique<Record>(*CurRec); // Set the iterator values now. - for (unsigned i = 0, e = IterVals.size(); i != e; ++i) { - VarInit *IterVar = IterVals[i].IterVar; - TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue); + for (IterRecord &IR : IterVals) { + VarInit *IterVar = IR.IterVar; + TypedInit *IVal = dyn_cast<TypedInit>(IR.IterValue); if (!IVal) return Error(Loc, "foreach iterator value is untyped"); @@ -385,8 +371,7 @@ static bool isObjectStart(tgtok::TokKind K) { /// GetNewAnonymousName - Generate a unique anonymous name that can be used as /// an identifier. std::string TGParser::GetNewAnonymousName() { - unsigned Tmp = AnonCounter++; // MSVC2012 ICEs without this. - return "anonymous_" + utostr(Tmp); + return "anonymous_" + utostr(AnonCounter++); } /// ParseObjectName - If an object name is specified, return it. Otherwise, @@ -591,13 +576,12 @@ bool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) { Lex.Lex(); // Add to the range. - if (Start < End) { + if (Start < End) for (; Start <= End; ++Start) Ranges.push_back(Start); - } else { + else for (; Start >= End; --Start) Ranges.push_back(Start); - } return false; } @@ -758,10 +742,8 @@ Init *TGParser::ParseIDValue(Record *CurRec, } // If this is in a foreach loop, make sure it's not a loop iterator - for (LoopVector::iterator i = Loops.begin(), iend = Loops.end(); - i != iend; - ++i) { - VarInit *IterVar = dyn_cast<VarInit>(i->IterVar); + for (const auto &L : Loops) { + VarInit *IterVar = dyn_cast<VarInit>(L.IterVar); if (IterVar && IterVar->getName() == Name) return IterVar; } @@ -776,7 +758,7 @@ Init *TGParser::ParseIDValue(Record *CurRec, Error(NameLoc, "Variable not defined: '" + Name + "'"); return nullptr; } - + return StringInit::get(Name); } @@ -833,9 +815,9 @@ Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { Init *LHS = ParseValue(CurRec); if (!LHS) return nullptr; - if (Code == UnOpInit::HEAD - || Code == UnOpInit::TAIL - || Code == UnOpInit::EMPTY) { + if (Code == UnOpInit::HEAD || + Code == UnOpInit::TAIL || + Code == UnOpInit::EMPTY) { ListInit *LHSl = dyn_cast<ListInit>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS); @@ -852,14 +834,13 @@ Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { } } - if (Code == UnOpInit::HEAD - || Code == UnOpInit::TAIL) { + if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) { if (!LHSl && !LHSt) { TokError("expected list type argument in unary operator"); return nullptr; } - if (LHSl && LHSl->getSize() == 0) { + if (LHSl && LHSl->empty()) { TokError("empty list argument in unary operator"); return nullptr; } @@ -870,11 +851,8 @@ Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { TokError("untyped list element in unary operator"); return nullptr; } - if (Code == UnOpInit::HEAD) { - Type = Itemt->getType(); - } else { - Type = ListRecTy::get(Itemt->getType()); - } + Type = (Code == UnOpInit::HEAD) ? Itemt->getType() + : ListRecTy::get(Itemt->getType()); } else { assert(LHSt && "expected list type argument in unary operator"); ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); @@ -882,11 +860,7 @@ Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) { TokError("expected list type argument in unary operator"); return nullptr; } - if (Code == UnOpInit::HEAD) { - Type = LType->getElementType(); - } else { - Type = LType; - } + Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType; } } } @@ -1256,11 +1230,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, CurMultiClass->DefPrototypes.push_back(std::move(NewRecOwner)); // Copy the template arguments for the multiclass into the def. - const std::vector<Init *> &TArgs = - CurMultiClass->Rec.getTemplateArgs(); - - for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { - const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); + for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TArg); assert(RV && "Template arg doesn't exist?"); NewRec->addValue(*RV); } @@ -1324,7 +1295,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, // All other values must be convertible to just a single bit. Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); if (!Bit) { - Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ + Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() + ") is not convertable to a bit"); return nullptr; } @@ -1343,11 +1314,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, if (ItemType) { ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType); if (!ListType) { - std::string s; - raw_string_ostream ss(s); - ss << "Type mismatch for list, expected list type, got " - << ItemType->getAsString(); - TokError(ss.str()); + TokError(Twine("Type mismatch for list, expected list type, got ") + + ItemType->getAsString()); return nullptr; } GivenListTy = ListType; @@ -1384,10 +1352,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, // Check elements RecTy *EltTy = nullptr; - for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); - i != ie; - ++i) { - TypedInit *TArg = dyn_cast<TypedInit>(*i); + for (Init *V : Vals) { + TypedInit *TArg = dyn_cast<TypedInit>(V); if (!TArg) { TokError("Untyped list element"); return nullptr; @@ -1578,7 +1544,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { Error(PasteLoc, "LHS of paste is not typed!"); return nullptr; } - + if (LHS->getType() != StringRecTy::get()) { LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get()); } @@ -1593,7 +1559,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { // These are all of the tokens that can begin an object body. // Some of these can also begin values but we disallow those cases // because they are unlikely to be useful. - + // Trailing paste, concat with an empty string. RHS = StringInit::get(""); break; @@ -1609,7 +1575,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { if (RHS->getType() != StringRecTy::get()) { RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get()); } - + break; } @@ -1634,7 +1600,7 @@ TGParser::ParseDagArgList(Record *CurRec) { // DagArg ::= VARNAME if (Lex.getCode() == tgtok::VarName) { // A missing value is treated like '?'. - Result.push_back(std::make_pair(UnsetInit::get(), Lex.getCurStrVal())); + Result.emplace_back(UnsetInit::get(), Lex.getCurStrVal()); Lex.Lex(); } else { // DagArg ::= Value (':' VARNAME)? @@ -1676,7 +1642,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, unsigned int ArgN = 0; if (ArgsRec && !EltTy) { const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs(); - if (!TArgs.size()) { + if (TArgs.empty()) { TokError("template argument provided to non-template class"); return std::vector<Init*>(); } @@ -1743,11 +1709,10 @@ Init *TGParser::ParseDeclaration(Record *CurRec, Lex.Lex(); if (ParsingTemplateArgs) { - if (CurRec) { + if (CurRec) DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":"); - } else { + else assert(CurMultiClass); - } if (CurMultiClass) DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName, "::"); @@ -1841,8 +1806,8 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { assert(!IterType && "Type already initialized?"); IterType = IntRecTy::get(); std::vector<Init*> Values; - for (unsigned i = 0, e = Ranges.size(); i != e; ++i) - Values.push_back(IntInit::get(Ranges[i])); + for (unsigned R : Ranges) + Values.push_back(IntInit::get(R)); ForeachListValue = ListInit::get(Values, IterType); } @@ -1968,10 +1933,9 @@ bool TGParser::ParseBody(Record *CurRec) { /// \brief Apply the current let bindings to \a CurRec. /// \returns true on error, false otherwise. bool TGParser::ApplyLetStack(Record *CurRec) { - for (unsigned i = 0, e = LetStack.size(); i != e; ++i) - for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) - if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, - LetStack[i][j].Bits, LetStack[i][j].Value)) + for (std::vector<LetRecord> &LetInfo : LetStack) + for (LetRecord &LR : LetInfo) + if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value)) return true; return false; } @@ -2053,9 +2017,8 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { return true; // Otherwise, a def inside a multiclass, add it to the multiclass. - for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i) - if (CurMultiClass->DefPrototypes[i]->getNameInit() - == CurRec->getNameInit()) + for (const auto &Proto : CurMultiClass->DefPrototypes) + if (Proto->getNameInit() == CurRec->getNameInit()) return Error(DefLoc, "def '" + CurRec->getNameInitAsString() + "' already defined in this multiclass!"); CurMultiClass->DefPrototypes.push_back(std::move(CurRecOwner)); @@ -2074,20 +2037,16 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { if (CurMultiClass) { // Copy the template arguments for the multiclass into the def. - const std::vector<Init *> &TArgs = - CurMultiClass->Rec.getTemplateArgs(); - - for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { - const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); + for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TArg); assert(RV && "Template arg doesn't exist?"); CurRec->addValue(*RV); } } - if (ProcessForeachDefs(CurRec, DefLoc)) { + if (ProcessForeachDefs(CurRec, DefLoc)) return Error(DefLoc, "Could not process loops for def" + CurRec->getNameInitAsString()); - } return false; } @@ -2120,8 +2079,7 @@ bool TGParser::ParseForeach(MultiClass *CurMultiClass) { // FOREACH Declaration IN Object if (ParseObject(CurMultiClass)) return true; - } - else { + } else { SMLoc BraceLoc = Lex.getLoc(); // Otherwise, this is a group foreach. Lex.Lex(); // eat the '{'. @@ -2160,8 +2118,8 @@ bool TGParser::ParseClass() { if (CurRec->getValues().size() > 1 || // Account for NAME. !CurRec->getSuperClasses().empty() || !CurRec->getTemplateArgs().empty()) - return TokError("Class '" + CurRec->getNameInitAsString() - + "' already defined"); + return TokError("Class '" + CurRec->getNameInitAsString() + + "' already defined"); } else { // If this is the first reference to this class, create and add it. auto NewRec = @@ -2214,7 +2172,7 @@ std::vector<LetRecord> TGParser::ParseLetList() { if (!Val) return std::vector<LetRecord>(); // Now that we have everything, add the record. - Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); + Result.emplace_back(std::move(Name), std::move(Bits), Val, NameLoc); if (Lex.getCode() != tgtok::comma) return Result; @@ -2359,7 +2317,9 @@ Record *TGParser:: InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, Init *&DefmPrefix, - SMRange DefmPrefixRange) { + SMRange DefmPrefixRange, + const std::vector<Init *> &TArgs, + std::vector<Init *> &TemplateVals) { // We need to preserve DefProto so it can be reused for later // instantiations, so create a new Record to inherit from it. @@ -2375,7 +2335,6 @@ InstantiateMulticlassDef(MultiClass &MC, } Init *DefName = DefProto->getNameInit(); - StringInit *DefNameString = dyn_cast<StringInit>(DefName); if (DefNameString) { @@ -2403,9 +2362,9 @@ InstantiateMulticlassDef(MultiClass &MC, // confused. if (SetValue(CurRec.get(), Ref.RefRange.Start, "NAME", std::vector<unsigned>(), DefmPrefix)) { - Error(DefmPrefixRange.Start, "Could not resolve " - + CurRec->getNameInitAsString() + ":NAME to '" - + DefmPrefix->getAsUnquotedString() + "'"); + Error(DefmPrefixRange.Start, "Could not resolve " + + CurRec->getNameInitAsString() + ":NAME to '" + + DefmPrefix->getAsUnquotedString() + "'"); return nullptr; } @@ -2423,12 +2382,40 @@ InstantiateMulticlassDef(MultiClass &MC, RecordVal *DefNameRV = CurRec->getValue("NAME"); CurRec->resolveReferencesTo(DefNameRV); + // Check if the name is a complex pattern. + // If so, resolve it. + DefName = CurRec->getNameInit(); + DefNameString = dyn_cast<StringInit>(DefName); + + // OK the pattern is more complex than simply using NAME. + // Let's use the heavy weaponery. + if (!DefNameString) { + ResolveMulticlassDefArgs(MC, CurRec.get(), DefmPrefixRange.Start, + Lex.getLoc(), TArgs, TemplateVals, + false/*Delete args*/); + DefName = CurRec->getNameInit(); + DefNameString = dyn_cast<StringInit>(DefName); + + if (!DefNameString) + DefName = DefName->convertInitializerTo(StringRecTy::get()); + + // We ran out of options here... + DefNameString = dyn_cast<StringInit>(DefName); + if (!DefNameString) { + PrintFatalError(CurRec->getLoc()[CurRec->getLoc().size() - 1], + DefName->getAsUnquotedString() + " is not a string."); + return nullptr; + } + + CurRec->setName(DefName); + } + // Now that NAME references are resolved and we're at the top level of // any multiclass expansions, add the record to the RecordKeeper. If we are // currently in a multiclass, it means this defm appears inside a // multiclass and its name won't be fully resolvable until we see - // the top-level defm. Therefore, we don't add this to the - // RecordKeeper at this point. If we did we could get duplicate + // the top-level defm. Therefore, we don't add this to the + // RecordKeeper at this point. If we did we could get duplicate // defs as more than one probably refers to NAME or some other // common internal placeholder. @@ -2466,19 +2453,19 @@ bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(), TemplateVals[i])) return true; - + // Resolve it next. CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); if (DeleteArgs) // Now remove it. CurRec->removeValue(TArgs[i]); - + } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { - return Error(SubClassLoc, "value not specified for template argument #"+ - utostr(i) + " (" + TArgs[i]->getAsUnquotedString() - + ") of multiclassclass '" + MC.Rec.getNameInitAsString() - + "'"); + return Error(SubClassLoc, "value not specified for template argument #" + + Twine(i) + " (" + TArgs[i]->getAsUnquotedString() + + ") of multiclassclass '" + MC.Rec.getNameInitAsString() + + "'"); } } return false; @@ -2497,20 +2484,15 @@ bool TGParser::ResolveMulticlassDef(MultiClass &MC, // with the new created definition. if (!CurMultiClass) return false; - for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); - i != e; ++i) - if (CurMultiClass->DefPrototypes[i]->getNameInit() - == CurRec->getNameInit()) + for (const auto &Proto : CurMultiClass->DefPrototypes) + if (Proto->getNameInit() == CurRec->getNameInit()) return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() + "' already defined in this multiclass!"); CurMultiClass->DefPrototypes.push_back(std::unique_ptr<Record>(CurRec)); // Copy the template arguments for the multiclass into the new def. - const std::vector<Init *> &TA = - CurMultiClass->Rec.getTemplateArgs(); - - for (unsigned i = 0, e = TA.size(); i != e; ++i) { - const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]); + for (Init * TA : CurMultiClass->Rec.getTemplateArgs()) { + const RecordVal *RV = CurMultiClass->Rec.getValue(TA); assert(RV && "Template arg doesn't exist?"); CurRec->addValue(*RV); } @@ -2564,20 +2546,25 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { "more template args specified than multiclass expects"); // Loop over all the def's in the multiclass, instantiating each one. - for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) { - Record *DefProto = MC->DefPrototypes[i].get(); - - Record *CurRec = InstantiateMulticlassDef(*MC, DefProto, DefmPrefix, + for (const std::unique_ptr<Record> &DefProto : MC->DefPrototypes) { + // The record name construction goes as follow: + // - If the def name is a string, prepend the prefix. + // - If the def name is a more complex pattern, use that pattern. + // As a result, the record is instanciated before resolving + // arguments, as it would make its name a string. + Record *CurRec = InstantiateMulticlassDef(*MC, DefProto.get(), DefmPrefix, SMRange(DefmLoc, - DefmPrefixEndLoc)); + DefmPrefixEndLoc), + TArgs, TemplateVals); if (!CurRec) return true; + // Now that the record is instanciated, we can resolve arguments. if (ResolveMulticlassDefArgs(*MC, CurRec, DefmLoc, SubClassLoc, TArgs, TemplateVals, true/*Delete args*/)) return Error(SubClassLoc, "could not instantiate def"); - if (ResolveMulticlassDef(*MC, CurRec, DefProto, DefmLoc)) + if (ResolveMulticlassDef(*MC, CurRec, DefProto.get(), DefmLoc)) return Error(SubClassLoc, "could not instantiate def"); // Defs that can be used by other definitions should be fully resolved @@ -2618,9 +2605,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { // Get the expanded definition prototypes and teach them about // the record values the current class to inherit has - for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) { - Record *CurRec = NewRecDefs[i]; - + for (Record *CurRec : NewRecDefs) { // Add it. if (AddSubClass(CurRec, SubClass)) return true; @@ -2636,11 +2621,11 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { } if (!CurMultiClass) - for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) + for (Record *CurRec : NewRecDefs) // See Record::setName(). This resolve step will see any new // name for the def that might have been created when resolving // inheritance, values and arguments above. - NewRecDefs[i]->resolveReferences(); + CurRec->resolveReferences(); if (Lex.getCode() != tgtok::semi) return TokError("expected ';' at end of defm"); diff --git a/contrib/llvm/lib/TableGen/TGParser.h b/contrib/llvm/lib/TableGen/TGParser.h index 22a00e5..d69d1f4 100644 --- a/contrib/llvm/lib/TableGen/TGParser.h +++ b/contrib/llvm/lib/TableGen/TGParser.h @@ -138,7 +138,9 @@ private: // Parser methods. Record *InstantiateMulticlassDef(MultiClass &MC, Record *DefProto, Init *&DefmPrefix, - SMRange DefmPrefixRange); + SMRange DefmPrefixRange, + const std::vector<Init *> &TArgs, + std::vector<Init *> &TemplateVals); bool ResolveMulticlassDefArgs(MultiClass &MC, Record *DefProto, SMLoc DefmPrefixLoc, diff --git a/contrib/llvm/lib/TableGen/TableGenBackend.cpp b/contrib/llvm/lib/TableGen/TableGenBackend.cpp index 79d5677..77ed841 100644 --- a/contrib/llvm/lib/TableGen/TableGenBackend.cpp +++ b/contrib/llvm/lib/TableGen/TableGenBackend.cpp @@ -11,10 +11,9 @@ // //===----------------------------------------------------------------------===// +#include "llvm/TableGen/TableGenBackend.h" #include "llvm/ADT/Twine.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/TableGen/TableGenBackend.h" -#include <algorithm> using namespace llvm; @@ -23,32 +22,30 @@ const size_t MAX_LINE_LEN = 80U; static void printLine(raw_ostream &OS, const Twine &Prefix, char Fill, StringRef Suffix) { size_t Pos = (size_t)OS.tell(); - assert((MAX_LINE_LEN - Prefix.str().size() - Suffix.size() > 0) && - "header line exceeds max limit"); + assert((Prefix.str().size() + Suffix.size() <= MAX_LINE_LEN) && + "header line exceeds max limit"); OS << Prefix; - const size_t e = MAX_LINE_LEN - Suffix.size(); - for (size_t i = (size_t)OS.tell() - Pos; i < e; ++i) + for (size_t i = (size_t)OS.tell() - Pos, e = MAX_LINE_LEN - Suffix.size(); + i < e; ++i) OS << Fill; OS << Suffix << '\n'; } void llvm::emitSourceFileHeader(StringRef Desc, raw_ostream &OS) { printLine(OS, "/*===- TableGen'erated file ", '-', "*- C++ -*-===*\\"); - printLine(OS, "|*", ' ', "*|"); - size_t Pos = 0U; - size_t PosE; - StringRef Prefix("|*"); + StringRef Prefix("|* "); StringRef Suffix(" *|"); - do{ - size_t PSLen = Suffix.size() + Prefix.size(); - PosE = Pos + ((MAX_LINE_LEN > (Desc.size() - PSLen)) ? - Desc.size() : - MAX_LINE_LEN - PSLen); - printLine(OS, Prefix + Desc.slice(Pos, PosE), ' ', Suffix); - Pos = PosE; - } while(Pos < Desc.size()); printLine(OS, Prefix, ' ', Suffix); - printLine(OS, Prefix + " Automatically generated file, do not edit!", ' ', + size_t PSLen = Prefix.size() + Suffix.size(); + assert(PSLen < MAX_LINE_LEN); + size_t Pos = 0U; + do { + size_t Length = std::min(Desc.size() - Pos, MAX_LINE_LEN - PSLen); + printLine(OS, Prefix + Desc.substr(Pos, Length), ' ', Suffix); + Pos += Length; + } while (Pos < Desc.size()); + printLine(OS, Prefix, ' ', Suffix); + printLine(OS, Prefix + "Automatically generated file, do not edit!", ' ', Suffix); printLine(OS, Prefix, ' ', Suffix); printLine(OS, "\\*===", '-', "===*/"); |
