summaryrefslogtreecommitdiffstats
path: root/contrib/llvm/lib/TableGen
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/llvm/lib/TableGen')
-rw-r--r--contrib/llvm/lib/TableGen/Error.cpp5
-rw-r--r--contrib/llvm/lib/TableGen/Main.cpp36
-rw-r--r--contrib/llvm/lib/TableGen/Record.cpp527
-rw-r--r--contrib/llvm/lib/TableGen/SetTheory.cpp43
-rw-r--r--contrib/llvm/lib/TableGen/TGLexer.h3
-rw-r--r--contrib/llvm/lib/TableGen/TGParser.cpp246
-rw-r--r--contrib/llvm/lib/TableGen/TGParser.h4
-rw-r--r--contrib/llvm/lib/TableGen/TableGenBackend.cpp35
8 files changed, 383 insertions, 516 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..9783922 100644
--- a/contrib/llvm/lib/TableGen/Record.cpp
+++ b/contrib/llvm/lib/TableGen/Record.cpp
@@ -91,11 +91,11 @@ 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{
+bool RecTy::baseClassOf(const RecTy *RHS) const {
assert (RHS && "NULL pointer");
return Kind == RHS->getRecTyKind();
}
@@ -112,16 +112,16 @@ Init *BitRecTy::convertValue(IntInit *II) {
return BitInit::get(Val != 0);
}
-Init *BitRecTy::convertValue(TypedInit *VI) {
- RecTy *Ty = VI->getType();
+Init *BitRecTy::convertValue(TypedInit *TI) {
+ RecTy *Ty = TI->getType();
if (isa<BitRecTy>(Ty))
- return VI; // Accept variable if it is already of bit type!
+ return TI; // 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;
+ return BitsTy->getNumBits() == 1 ? TI : 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 (TernOpInit *TOI = dyn_cast<TernOpInit>(TI)) {
if (TOI->getOpcode() != TernOpInit::TernaryOp::IF)
return nullptr;
if (!TOI->getMHS()->convertInitializerTo(BitRecTy::get()) ||
@@ -133,7 +133,7 @@ Init *BitRecTy::convertValue(TypedInit *VI) {
}
bool BitRecTy::baseClassOf(const RecTy *RHS) const{
- if(RecTy::baseClassOf(RHS) || getRecTyKind() == IntRecTyKind)
+ if(RecTy::baseClassOf(RHS) || RHS->getRecTyKind() == IntRecTyKind)
return true;
if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
return BitsTy->getNumBits() == 1;
@@ -141,13 +141,13 @@ bool BitRecTy::baseClassOf(const RecTy *RHS) const{
}
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 {
@@ -163,9 +163,9 @@ Init *BitsRecTy::convertValue(UnsetInit *UI) {
return BitsInit::get(NewBits);
}
-Init *BitsRecTy::convertValue(BitInit *UI) {
+Init *BitsRecTy::convertValue(BitInit *BI) {
if (Size != 1) return nullptr; // Can only convert single bit.
- return BitsInit::get(UI);
+ return BitsInit::get(BI);
}
/// canFitInBitfield - Return true if the number of bits is large enough to hold
@@ -200,15 +200,15 @@ Init *BitsRecTy::convertValue(BitsInit *BI) {
return nullptr;
}
-Init *BitsRecTy::convertValue(TypedInit *VI) {
- if (Size == 1 && isa<BitRecTy>(VI->getType()))
- return BitsInit::get(VI);
+Init *BitsRecTy::convertValue(TypedInit *TI) {
+ if (Size == 1 && isa<BitRecTy>(TI->getType()))
+ return BitsInit::get(TI);
- if (VI->getType()->typeIsConvertibleTo(this)) {
+ if (TI->getType()->typeIsConvertibleTo(this)) {
SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
- NewBits[i] = VarBitInit::get(VI, i);
+ NewBits[i] = VarBitInit::get(TI, i);
return BitsInit::get(NewBits);
}
@@ -229,11 +229,10 @@ Init *IntRecTy::convertValue(BitInit *BI) {
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 {
+ if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i)))
+ Result |= static_cast<int64_t>(Bit->getValue()) << i;
+ else
return nullptr;
- }
return IntInit::get(Result);
}
@@ -248,16 +247,16 @@ bool IntRecTy::baseClassOf(const RecTy *RHS) const{
return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
}
-Init *StringRecTy::convertValue(UnOpInit *BO) {
- if (BO->getOpcode() == UnOpInit::CAST) {
- Init *L = BO->getOperand()->convertInitializerTo(this);
+Init *StringRecTy::convertValue(UnOpInit *UO) {
+ if (UO->getOpcode() == UnOpInit::CAST) {
+ Init *L = UO->getOperand()->convertInitializerTo(this);
if (!L) return nullptr;
- if (L != BO->getOperand())
- return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy);
- return BO;
+ if (L != UO->getOperand())
+ return UnOpInit::get(UnOpInit::CAST, L, StringRecTy::get());
+ return UO;
}
- return convertValue((TypedInit*)BO);
+ return convertValue((TypedInit*)UO);
}
Init *StringRecTy::convertValue(BinOpInit *BO) {
@@ -266,7 +265,7 @@ Init *StringRecTy::convertValue(BinOpInit *BO) {
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 BinOpInit::get(BinOpInit::STRCONCAT, L, R, StringRecTy::get());
return BO;
}
@@ -321,13 +320,13 @@ Init *DagRecTy::convertValue(TypedInit *TI) {
return nullptr;
}
-Init *DagRecTy::convertValue(UnOpInit *BO) {
- if (BO->getOpcode() == UnOpInit::CAST) {
- Init *L = BO->getOperand()->convertInitializerTo(this);
+Init *DagRecTy::convertValue(UnOpInit *UO) {
+ if (UO->getOpcode() == UnOpInit::CAST) {
+ Init *L = UO->getOperand()->convertInitializerTo(this);
if (!L) return nullptr;
- if (L != BO->getOperand())
- return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy);
- return BO;
+ if (L != UO->getOperand())
+ return UnOpInit::get(UnOpInit::CAST, L, DagRecTy::get());
+ return UO;
}
return nullptr;
}
@@ -338,7 +337,7 @@ Init *DagRecTy::convertValue(BinOpInit *BO) {
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 BinOpInit::get(BinOpInit::CONCAT, L, R, DagRecTy::get());
return BO;
}
return nullptr;
@@ -385,7 +384,7 @@ bool RecordRecTy::baseClassOf(const RecTy *RHS) const{
}
/// 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 +395,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;
@@ -461,16 +442,13 @@ 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 +459,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;
}
@@ -517,7 +495,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,27 +548,12 @@ 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 {
@@ -613,11 +576,11 @@ IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
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();
}
static void ProfileListInit(FoldingSetNodeID &ID,
@@ -626,16 +589,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,9 +611,7 @@ 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);
}
@@ -731,14 +688,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,13 +705,13 @@ 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 {
@@ -787,7 +740,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 +753,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 +778,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 +830,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 +872,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 +956,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 +966,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 +974,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 +985,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;
- }
+ if (auto *TArg = dyn_cast<TypedInit>(Arg))
+ if (TArg->getType()->getAsString() == "dag")
+ return ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass);
+ std::vector<Init *> NewOperands;
for (int i = 0; i < RHSo->getNumOperands(); ++i) {
- OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i));
-
- if (RHSoo) {
- Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
- Type, CurRec, CurMultiClass);
- if (Result) {
+ 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 {
@@ -1090,9 +1018,8 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
OpInit *RHSo = dyn_cast<OpInit>(RHS);
- if (!RHSo) {
+ if (!RHSo)
PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n");
- }
TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
@@ -1104,9 +1031,8 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
Init *Val = MHSd->getOperator();
Init *Result = EvaluateOperation(RHSo, LHS, Val,
Type, CurRec, CurMultiClass);
- if (Result) {
+ if (Result)
Val = Result;
- }
std::vector<std::pair<Init *, std::string> > args;
for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
@@ -1118,9 +1044,8 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
// Process args
Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
CurRec, CurMultiClass);
- if (Result) {
+ if (Result)
Arg = Result;
- }
// TODO: Process arg names
args.push_back(std::make_pair(Arg, ArgName));
@@ -1132,26 +1057,21 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
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;
+ for (Init *&Item : NewList) {
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()) {
+ if (LHS->getAsString() == RHSo->getOperand(i)->getAsString())
NewOperands.push_back(Item);
- } else {
+ 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;
+ Item = NewItem;
}
return ListInit::get(NewList, MHSl->getType());
}
@@ -1174,48 +1094,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 +1136,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 +1161,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 +1183,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 {
@@ -1326,18 +1235,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,11 +1264,8 @@ 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())
return nullptr; // Out of range reference.
@@ -1391,8 +1296,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 +1315,17 @@ 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();
}
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 +1339,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 +1369,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);
+ return VarListElementInit::get(TInit, Elt);
}
return Result;
}
-
+
return nullptr;
}
@@ -1505,14 +1403,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 {
@@ -1540,15 +1437,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 +1467,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 +1479,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);
@@ -1629,7 +1519,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) {
@@ -1658,9 +1548,7 @@ RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
}
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>(Name)->getValue();
}
void RecordVal::dump() const { errs() << *this; }
@@ -1688,23 +1576,24 @@ 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!");
+ const TypedInit *TypedName = cast<const TypedInit>(Name);
RecTy *Type = TypedName->getType();
if (!isa<StringRecTy>(Type))
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 +1625,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);
@@ -1859,12 +1747,11 @@ 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))) {
+ if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i)))
Defs.push_back(DI->getDef());
- } else {
+ else
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
FieldName + "' list is not entirely DefInit!");
- }
}
return Defs;
}
@@ -1894,12 +1781,11 @@ 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))) {
+ if (IntInit *II = dyn_cast<IntInit>(List->getElement(i)))
Ints.push_back(II->getValue());
- } else {
+ else
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
FieldName + "' does not have a list of ints initializer!");
- }
}
return Ints;
}
@@ -1913,12 +1799,11 @@ 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))) {
+ if (StringInit *II = dyn_cast<StringInit>(List->getElement(i)))
Strings.push_back(II->getValue());
- } else {
+ else
PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
FieldName + "' does not have a list of strings initializer!");
- }
}
return Strings;
}
@@ -1961,7 +1846,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 +1879,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 +1888,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,7 +1919,7 @@ 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,
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..0e654f9 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());
@@ -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;
}
@@ -184,9 +177,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 #" +
+ utostr(i) + " (" + TArgs[i]->getAsUnquotedString() +
+ ") of subclass '" + SC->getNameInitAsString() + "'!");
}
}
@@ -216,27 +209,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 +271,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 #" +
+ utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString() +
+ ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!");
}
}
@@ -385,8 +372,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 +577,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 +743,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 +759,7 @@ Init *TGParser::ParseIDValue(Record *CurRec,
Error(NameLoc, "Variable not defined: '" + Name + "'");
return nullptr;
}
-
+
return StringInit::get(Name);
}
@@ -833,9 +816,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 +835,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 +852,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 +861,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 +1231,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);
}
@@ -1384,10 +1356,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 +1548,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 +1563,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 +1579,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
if (RHS->getType() != StringRecTy::get()) {
RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get());
}
-
+
break;
}
@@ -1676,7 +1646,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 +1713,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,
"::");
@@ -2053,9 +2022,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 +2042,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 +2084,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 +2123,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 =
@@ -2359,7 +2322,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 +2340,6 @@ InstantiateMulticlassDef(MultiClass &MC,
}
Init *DefName = DefProto->getNameInit();
-
StringInit *DefNameString = dyn_cast<StringInit>(DefName);
if (DefNameString) {
@@ -2403,9 +2367,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 +2387,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 +2458,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 #" +
+ utostr(i) + " (" + TArgs[i]->getAsUnquotedString() +
+ ") of multiclassclass '" + MC.Rec.getNameInitAsString() +
+ "'");
}
}
return false;
@@ -2497,20 +2489,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 +2551,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 +2610,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 +2626,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, "\\*===", '-', "===*/");
OpenPOWER on IntegriCloud