diff options
author | Stephen Hines <srhines@google.com> | 2014-05-29 02:49:00 -0700 |
---|---|---|
committer | Stephen Hines <srhines@google.com> | 2014-05-29 02:49:00 -0700 |
commit | dce4a407a24b04eebc6a376f8e62b41aaa7b071f (patch) | |
tree | dcebc53f2b182f145a2e659393bf9a0472cedf23 /lib/TableGen | |
parent | 220b921aed042f9e520c26cffd8282a94c66c3d5 (diff) | |
download | external_llvm-dce4a407a24b04eebc6a376f8e62b41aaa7b071f.zip external_llvm-dce4a407a24b04eebc6a376f8e62b41aaa7b071f.tar.gz external_llvm-dce4a407a24b04eebc6a376f8e62b41aaa7b071f.tar.bz2 |
Update LLVM for 3.5 rebase (r209712).
Change-Id: I149556c940fb7dc92d075273c87ff584f400941f
Diffstat (limited to 'lib/TableGen')
-rw-r--r-- | lib/TableGen/Main.cpp | 1 | ||||
-rw-r--r-- | lib/TableGen/Record.cpp | 190 | ||||
-rw-r--r-- | lib/TableGen/TGLexer.cpp | 11 | ||||
-rw-r--r-- | lib/TableGen/TGLexer.h | 2 | ||||
-rw-r--r-- | lib/TableGen/TGParser.cpp | 398 | ||||
-rw-r--r-- | lib/TableGen/TGParser.h | 12 | ||||
-rw-r--r-- | lib/TableGen/module.modulemap | 1 |
7 files changed, 322 insertions, 293 deletions
diff --git a/lib/TableGen/Main.cpp b/lib/TableGen/Main.cpp index fd81ab4..476026d 100644 --- a/lib/TableGen/Main.cpp +++ b/lib/TableGen/Main.cpp @@ -17,6 +17,7 @@ #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/Support/system_error.h" diff --git a/lib/TableGen/Record.cpp b/lib/TableGen/Record.cpp index a43665b..c553a21 100644 --- a/lib/TableGen/Record.cpp +++ b/lib/TableGen/Record.cpp @@ -101,13 +101,13 @@ bool RecTy::baseClassOf(const RecTy *RHS) const{ } Init *BitRecTy::convertValue(BitsInit *BI) { - if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! + 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 0; // Only accept 0 or 1 for a bit! + if (Val != 0 && Val != 1) return nullptr; // Only accept 0 or 1 for a bit! return BitInit::get(Val != 0); } @@ -116,7 +116,7 @@ Init *BitRecTy::convertValue(TypedInit *VI) { RecTy *Ty = VI->getType(); if (isa<BitRecTy>(Ty) || isa<BitsRecTy>(Ty) || isa<IntRecTy>(Ty)) return VI; // Accept variable if it is already of bit type! - return 0; + return nullptr; } bool BitRecTy::baseClassOf(const RecTy *RHS) const{ @@ -151,7 +151,7 @@ Init *BitsRecTy::convertValue(UnsetInit *UI) { } Init *BitsRecTy::convertValue(BitInit *UI) { - if (Size != 1) return 0; // Can only convert single bit. + if (Size != 1) return nullptr; // Can only convert single bit. return BitsInit::get(UI); } @@ -170,7 +170,7 @@ Init *BitsRecTy::convertValue(IntInit *II) { int64_t Value = II->getValue(); // Make sure this bitfield is large enough to hold the integer value. if (!canFitInBitfield(Value, Size)) - return 0; + return nullptr; SmallVector<Init *, 16> NewBits(Size); @@ -184,7 +184,7 @@ Init *BitsRecTy::convertValue(BitsInit *BI) { // If the number of bits is right, return it. Otherwise we need to expand or // truncate. if (BI->getNumBits() == Size) return BI; - return 0; + return nullptr; } Init *BitsRecTy::convertValue(TypedInit *VI) { @@ -199,7 +199,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { return BitsInit::get(NewBits); } - return 0; + return nullptr; } bool BitsRecTy::baseClassOf(const RecTy *RHS) const{ @@ -219,7 +219,7 @@ Init *IntRecTy::convertValue(BitsInit *BI) { if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) { Result |= Bit->getValue() << i; } else { - return 0; + return nullptr; } return IntInit::get(Result); } @@ -227,7 +227,7 @@ Init *IntRecTy::convertValue(BitsInit *BI) { Init *IntRecTy::convertValue(TypedInit *TI) { if (TI->getType()->typeIsConvertibleTo(this)) return TI; // Accept variable if already of the right type! - return 0; + return nullptr; } bool IntRecTy::baseClassOf(const RecTy *RHS) const{ @@ -238,7 +238,7 @@ bool IntRecTy::baseClassOf(const RecTy *RHS) const{ Init *StringRecTy::convertValue(UnOpInit *BO) { if (BO->getOpcode() == UnOpInit::CAST) { Init *L = BO->getOperand()->convertInitializerTo(this); - if (L == 0) return 0; + if (!L) return nullptr; if (L != BO->getOperand()) return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); return BO; @@ -251,7 +251,7 @@ Init *StringRecTy::convertValue(BinOpInit *BO) { if (BO->getOpcode() == BinOpInit::STRCONCAT) { Init *L = BO->getLHS()->convertInitializerTo(this); Init *R = BO->getRHS()->convertInitializerTo(this); - if (L == 0 || R == 0) return 0; + if (!L || !R) return nullptr; if (L != BO->getLHS() || R != BO->getRHS()) return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); return BO; @@ -264,7 +264,7 @@ Init *StringRecTy::convertValue(BinOpInit *BO) { Init *StringRecTy::convertValue(TypedInit *TI) { if (isa<StringRecTy>(TI->getType())) return TI; // Accept variable if already of the right type! - return 0; + return nullptr; } std::string ListRecTy::getAsString() const { @@ -280,10 +280,10 @@ Init *ListRecTy::convertValue(ListInit *LI) { if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) Elements.push_back(CI); else - return 0; + return nullptr; if (!isa<ListRecTy>(LI->getType())) - return 0; + return nullptr; return ListInit::get(Elements, this); } @@ -293,7 +293,7 @@ Init *ListRecTy::convertValue(TypedInit *TI) { if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType())) if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) return TI; - return 0; + return nullptr; } bool ListRecTy::baseClassOf(const RecTy *RHS) const{ @@ -305,30 +305,30 @@ bool ListRecTy::baseClassOf(const RecTy *RHS) const{ Init *DagRecTy::convertValue(TypedInit *TI) { if (TI->getType()->typeIsConvertibleTo(this)) return TI; - return 0; + return nullptr; } Init *DagRecTy::convertValue(UnOpInit *BO) { if (BO->getOpcode() == UnOpInit::CAST) { Init *L = BO->getOperand()->convertInitializerTo(this); - if (L == 0) return 0; + if (!L) return nullptr; if (L != BO->getOperand()) return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); return BO; } - return 0; + 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 == 0 || R == 0) return 0; + if (!L || !R) return nullptr; if (L != BO->getLHS() || R != BO->getRHS()) return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); return BO; } - return 0; + return nullptr; } RecordRecTy *RecordRecTy::get(Record *R) { @@ -342,7 +342,7 @@ std::string RecordRecTy::getAsString() const { Init *RecordRecTy::convertValue(DefInit *DI) { // Ensure that DI is a subclass of Rec. if (!DI->getDef()->isSubClassOf(Rec)) - return 0; + return nullptr; return DI; } @@ -352,7 +352,7 @@ Init *RecordRecTy::convertValue(TypedInit *TI) { if (RRT->getRecord()->isSubClassOf(getRecord()) || RRT->getRecord() == getRecord()) return TI; - return 0; + return nullptr; } bool RecordRecTy::baseClassOf(const RecTy *RHS) const{ @@ -391,7 +391,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { ++i) { RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); - if (NewType1 != 0) { + if (NewType1) { if (NewType1 != SuperRecTy1) { delete SuperRecTy1; } @@ -409,7 +409,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { ++i) { RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); - if (NewType2 != 0) { + if (NewType2) { if (NewType2 != SuperRecTy2) { delete SuperRecTy2; } @@ -417,7 +417,7 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { } } } - return 0; + return nullptr; } @@ -462,7 +462,7 @@ BitsInit *BitsInit::get(ArrayRef<Init *> Range) { FoldingSetNodeID ID; ProfileBitsInit(ID, Range); - void *IP = 0; + void *IP = nullptr; if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) return I; @@ -482,7 +482,7 @@ BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= getNumBits()) - return 0; + return nullptr; NewBits[i] = getBit(Bits[i]); } return BitsInit::get(NewBits); @@ -516,8 +516,8 @@ Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { bool Changed = false; SmallVector<Init *, 16> NewBits(getNumBits()); - Init *CachedInit = 0; - Init *CachedBitVar = 0; + Init *CachedInit = nullptr; + Init *CachedBitVar = nullptr; bool CachedBitVarChanged = false; for (unsigned i = 0, e = getNumBits(); i != e; ++i) { @@ -590,7 +590,7 @@ IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= 64) - return 0; + return nullptr; NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); } @@ -623,18 +623,18 @@ static void ProfileListInit(FoldingSetNodeID &ID, ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { typedef FoldingSet<ListInit> Pool; static Pool ThePool; + static std::vector<std::unique_ptr<ListInit>> TheActualPool; - // Just use the FoldingSetNodeID to compute a hash. Use a DenseMap - // for actual storage. FoldingSetNodeID ID; ProfileListInit(ID, Range, EltTy); - void *IP = 0; + void *IP = nullptr; if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) return I; ListInit *I = new ListInit(Range, EltTy); ThePool.InsertNode(I, IP); + TheActualPool.push_back(std::unique_ptr<ListInit>(I)); return I; } @@ -651,7 +651,7 @@ 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()) - return 0; + return nullptr; Vals.push_back(getElement(Elements[i])); } return ListInit::get(Vals, getType()); @@ -660,7 +660,7 @@ ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { Record *ListInit::getElementAsRecord(unsigned i) const { assert(i < Values.size() && "List element index out of range!"); DefInit *DI = dyn_cast<DefInit>(Values[i]); - if (DI == 0) + if (!DI) PrintFatalError("Expected record in list!"); return DI->getDef(); } @@ -690,14 +690,14 @@ Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, unsigned Elt) const { if (Elt >= getSize()) - return 0; // Out of range reference. + 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 // to a specific variable and that variable is explicitly unset, then // replace the VarListElementInit with it. if (IRV || !isa<UnsetInit>(E)) return E; - return 0; + return nullptr; } std::string ListInit::getAsString() const { @@ -714,7 +714,7 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, Init *Resolved = resolveReferences(R, IRV); OpInit *OResolved = dyn_cast<OpInit>(Resolved); if (OResolved) { - Resolved = OResolved->Fold(&R, 0); + Resolved = OResolved->Fold(&R, nullptr); } if (Resolved != this) { @@ -728,7 +728,7 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, } } - return 0; + return nullptr; } Init *OpInit::getBit(unsigned Bit) const { @@ -813,7 +813,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { if (LHSl->getSize() == 0) { assert(0 && "Empty list in car"); - return 0; + return nullptr; } return LHSl->getElement(0); } @@ -823,7 +823,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { if (LHSl->getSize() == 0) { assert(0 && "Empty list in cdr"); - return 0; + return nullptr; } // Note the +1. We can't just pass the result of getValues() // directly. @@ -862,8 +862,8 @@ Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *lhs = LHS->resolveReferences(R, RV); if (LHS != lhs) - return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); - return Fold(&R, 0); + return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr); + return Fold(&R, nullptr); } std::string UnOpInit::getAsString() const { @@ -902,7 +902,7 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { if (LHSs && RHSs) { DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator()); DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator()); - if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) + if (!LOp || !ROp || LOp->getDef() != ROp->getDef()) PrintFatalError("Concated Dag operators do not match!"); std::vector<Init*> Args; std::vector<std::string> ArgNames; @@ -918,6 +918,18 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { } break; } + case LISTCONCAT: { + ListInit *LHSs = dyn_cast<ListInit>(LHS); + ListInit *RHSs = dyn_cast<ListInit>(RHS); + if (LHSs && RHSs) { + std::vector<Init *> Args; + 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()); + } + break; + } case STRCONCAT: { StringInit *LHSs = dyn_cast<StringInit>(LHS); StringInit *RHSs = dyn_cast<StringInit>(RHS); @@ -974,8 +986,8 @@ Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *rhs = RHS->resolveReferences(R, RV); if (LHS != lhs || RHS != rhs) - return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); - return Fold(&R, 0); + return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr); + return Fold(&R, nullptr); } std::string BinOpInit::getAsString() const { @@ -987,6 +999,7 @@ std::string BinOpInit::getAsString() const { case SRA: Result = "!sra"; break; case SRL: Result = "!srl"; break; case EQ: Result = "!eq"; break; + case LISTCONCAT: Result = "!listconcat"; break; case STRCONCAT: Result = "!strconcat"; break; } return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; @@ -1031,11 +1044,7 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, if (TArg && TArg->getType()->getAsString() == "dag") { Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass); - if (Result != 0) { - return Result; - } else { - return 0; - } + return Result; } for (int i = 0; i < RHSo->getNumOperands(); ++i) { @@ -1044,7 +1053,7 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, if (RHSoo) { Init *Result = EvaluateOperation(RHSoo, LHS, Arg, Type, CurRec, CurMultiClass); - if (Result != 0) { + if (Result) { NewOperands.push_back(Result); } else { NewOperands.push_back(Arg); @@ -1059,10 +1068,7 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, // Now run the operator and use its result as the new leaf const OpInit *NewOp = RHSo->clone(NewOperands); Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); - if (NewVal != NewOp) - return NewVal; - - return 0; + return (NewVal != NewOp) ? NewVal : nullptr; } static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, @@ -1086,7 +1092,7 @@ 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 != 0) { + if (Result) { Val = Result; } @@ -1100,7 +1106,7 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, // Process args Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, CurRec, CurMultiClass); - if (Result != 0) { + if (Result) { Arg = Result; } @@ -1138,7 +1144,7 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, return ListInit::get(NewList, MHSl->getType()); } } - return 0; + return nullptr; } Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { @@ -1195,7 +1201,7 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { case FOREACH: { Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec, CurMultiClass); - if (Result != 0) { + if (Result) { return Result; } break; @@ -1227,16 +1233,16 @@ Init *TernOpInit::resolveReferences(Record &R, IntInit *Value = dyn_cast<IntInit>(lhs); if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) Value = dyn_cast<IntInit>(I); - if (Value != 0) { + if (Value) { // Short-circuit if (Value->getValue()) { Init *mhs = MHS->resolveReferences(R, RV); return (TernOpInit::get(getOpcode(), lhs, mhs, - RHS, getType()))->Fold(&R, 0); + RHS, getType()))->Fold(&R, nullptr); } else { Init *rhs = RHS->resolveReferences(R, RV); return (TernOpInit::get(getOpcode(), lhs, MHS, - rhs, getType()))->Fold(&R, 0); + rhs, getType()))->Fold(&R, nullptr); } } } @@ -1246,8 +1252,8 @@ Init *TernOpInit::resolveReferences(Record &R, if (LHS != lhs || MHS != mhs || RHS != rhs) return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, - getType()))->Fold(&R, 0); - return Fold(&R, 0); + getType()))->Fold(&R, nullptr); + return Fold(&R, nullptr); } std::string TernOpInit::getAsString() const { @@ -1265,19 +1271,19 @@ RecTy *TypedInit::getFieldType(const std::string &FieldName) const { if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName)) return Field->getType(); - return 0; + return nullptr; } Init * TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); - if (T == 0) return 0; // Cannot subscript a non-bits variable. + if (!T) return nullptr; // Cannot subscript a non-bits variable. unsigned NumBits = T->getNumBits(); SmallVector<Init *, 16> NewBits(Bits.size()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= NumBits) - return 0; + return nullptr; NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); } @@ -1287,7 +1293,7 @@ TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { Init * TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { ListRecTy *T = dyn_cast<ListRecTy>(getType()); - if (T == 0) return 0; // Cannot subscript a non-list variable. + if (!T) return nullptr; // Cannot subscript a non-list variable. if (Elements.size() == 1) return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); @@ -1332,8 +1338,8 @@ Init *VarInit::getBit(unsigned Bit) const { Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV, unsigned Elt) const { - if (R.isTemplateArg(getNameInit())) return 0; - if (IRV && IRV->getNameInit() != getNameInit()) return 0; + if (R.isTemplateArg(getNameInit())) return nullptr; + if (IRV && IRV->getNameInit() != getNameInit()) return nullptr; RecordVal *RV = R.getValue(getNameInit()); assert(RV && "Reference to a non-existent variable?"); @@ -1345,14 +1351,14 @@ Init *VarInit::resolveListElementReference(Record &R, } if (Elt >= LI->getSize()) - return 0; // Out of range reference. + 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 // to a specific variable and that variable is explicitly unset, then // replace the VarListElementInit with it. if (IRV || !isa<UnsetInit>(E)) return E; - return 0; + return nullptr; } @@ -1360,7 +1366,7 @@ RecTy *VarInit::getFieldType(const std::string &FieldName) const { if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType())) if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) return RV->getType(); - return 0; + return nullptr; } Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, @@ -1368,15 +1374,15 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, if (isa<RecordRecTy>(getType())) if (const RecordVal *Val = R.getValue(VarName)) { if (RV != Val && (RV || isa<UnsetInit>(Val->getValue()))) - return 0; + return nullptr; Init *TheInit = Val->getValue(); assert(TheInit != this && "Infinite loop detected!"); if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) return I; else - return 0; + return nullptr; } - return 0; + return nullptr; } /// resolveReferences - This method is used by classes that refer to other @@ -1386,7 +1392,7 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, /// Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { if (RecordVal *Val = R.getValue(VarName)) - if (RV == Val || (RV == 0 && !isa<UnsetInit>(Val->getValue()))) + if (RV == Val || (!RV && !isa<UnsetInit>(Val->getValue()))) return Val->getValue(); return const_cast<VarInit *>(this); } @@ -1462,7 +1468,7 @@ Init *VarListElementInit:: resolveListElementReference(Record &R, return Result; } - return 0; + return nullptr; } DefInit *DefInit::get(Record *R) { @@ -1472,7 +1478,7 @@ DefInit *DefInit::get(Record *R) { RecTy *DefInit::getFieldType(const std::string &FieldName) const { if (const RecordVal *RV = Def->getValue(FieldName)) return RV->getType(); - return 0; + return nullptr; } Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, @@ -1507,7 +1513,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 0; + if (Elt >= LI->getSize()) return nullptr; Init *E = LI->getElement(Elt); // If the element is set to some value, or if we are resolving a @@ -1516,7 +1522,7 @@ Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, if (RV || !isa<UnsetInit>(E)) return E; } - return 0; + return nullptr; } Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { @@ -1560,7 +1566,7 @@ DagInit::get(Init *V, const std::string &VN, FoldingSetNodeID ID; ProfileDagInit(ID, V, VN, ArgRange, NameRange); - void *IP = 0; + void *IP = nullptr; if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) return I; @@ -1784,7 +1790,7 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { /// Init *Record::getValueInit(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); return R->getValue(); @@ -1797,7 +1803,7 @@ Init *Record::getValueInit(StringRef FieldName) const { /// std::string Record::getValueAsString(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1813,7 +1819,7 @@ std::string Record::getValueAsString(StringRef FieldName) const { /// BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1829,7 +1835,7 @@ BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { /// ListInit *Record::getValueAsListInit(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1864,7 +1870,7 @@ Record::getValueAsListOfDefs(StringRef FieldName) const { /// int64_t Record::getValueAsInt(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1918,7 +1924,7 @@ Record::getValueAsListOfStrings(StringRef FieldName) const { /// Record *Record::getValueAsDef(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1934,7 +1940,7 @@ Record *Record::getValueAsDef(StringRef FieldName) const { /// bool Record::getValueAsBit(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); @@ -1946,7 +1952,7 @@ bool Record::getValueAsBit(StringRef FieldName) const { bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"); @@ -1967,7 +1973,7 @@ bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { /// DagInit *Record::getValueAsDag(StringRef FieldName) const { const RecordVal *R = getValue(FieldName); - if (R == 0 || R->getValue() == 0) + if (!R || !R->getValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); diff --git a/lib/TableGen/TGLexer.cpp b/lib/TableGen/TGLexer.cpp index c6be4f8..1ec2eea 100644 --- a/lib/TableGen/TGLexer.cpp +++ b/lib/TableGen/TGLexer.cpp @@ -30,7 +30,7 @@ TGLexer::TGLexer(SourceMgr &SM) : SrcMgr(SM) { CurBuffer = 0; CurBuf = SrcMgr.getMemoryBuffer(CurBuffer); CurPtr = CurBuf->getBufferStart(); - TokStart = 0; + TokStart = nullptr; } SMLoc TGLexer::getLoc() const { @@ -389,12 +389,12 @@ tgtok::TokKind TGLexer::LexNumber() { return ReturnError(TokStart, "Invalid hexadecimal number"); errno = 0; - CurIntVal = strtoll(NumStart, 0, 16); + CurIntVal = strtoll(NumStart, nullptr, 16); if (errno == EINVAL) return ReturnError(TokStart, "Invalid hexadecimal number"); if (errno == ERANGE) { errno = 0; - CurIntVal = (int64_t)strtoull(NumStart, 0, 16); + CurIntVal = (int64_t)strtoull(NumStart, nullptr, 16); if (errno == EINVAL) return ReturnError(TokStart, "Invalid hexadecimal number"); if (errno == ERANGE) @@ -410,7 +410,7 @@ tgtok::TokKind TGLexer::LexNumber() { // Requires at least one binary digit. if (CurPtr == NumStart) return ReturnError(CurPtr-2, "Invalid binary number"); - CurIntVal = strtoll(NumStart, 0, 2); + CurIntVal = strtoll(NumStart, nullptr, 2); return tgtok::IntVal; } } @@ -425,7 +425,7 @@ tgtok::TokKind TGLexer::LexNumber() { while (isdigit(CurPtr[0])) ++CurPtr; - CurIntVal = strtoll(TokStart, 0, 10); + CurIntVal = strtoll(TokStart, nullptr, 10); return tgtok::IntVal; } @@ -478,6 +478,7 @@ tgtok::TokKind TGLexer::LexExclaim() { .Case("empty", tgtok::XEmpty) .Case("subst", tgtok::XSubst) .Case("foreach", tgtok::XForEach) + .Case("listconcat", tgtok::XListConcat) .Case("strconcat", tgtok::XStrConcat) .Default(tgtok::Error); diff --git a/lib/TableGen/TGLexer.h b/lib/TableGen/TGLexer.h index d1bd70d..1e599f8 100644 --- a/lib/TableGen/TGLexer.h +++ b/lib/TableGen/TGLexer.h @@ -47,7 +47,7 @@ namespace tgtok { MultiClass, String, // !keywords. - XConcat, XADD, XSRA, XSRL, XSHL, XStrConcat, XCast, XSubst, + XConcat, XADD, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast, XSubst, XForEach, XHead, XTail, XEmpty, XIf, XEq, // Integer value. diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp index 4ba769c..038e018 100644 --- a/lib/TableGen/TGParser.cpp +++ b/lib/TableGen/TGParser.cpp @@ -29,18 +29,18 @@ struct SubClassReference { SMRange RefRange; Record *Rec; std::vector<Init*> TemplateArgs; - SubClassReference() : Rec(0) {} + SubClassReference() : Rec(nullptr) {} - bool isInvalid() const { return Rec == 0; } + bool isInvalid() const { return Rec == nullptr; } }; struct SubMultiClassReference { SMRange RefRange; MultiClass *MC; std::vector<Init*> TemplateArgs; - SubMultiClassReference() : MC(0) {} + SubMultiClassReference() : MC(nullptr) {} - bool isInvalid() const { return MC == 0; } + bool isInvalid() const { return MC == nullptr; } void dump() const; }; @@ -61,7 +61,7 @@ void SubMultiClassReference::dump() const { } // end namespace llvm bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { - if (CurRec == 0) + if (!CurRec) CurRec = &CurMultiClass->Rec; if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) { @@ -83,10 +83,10 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, const std::vector<unsigned> &BitList, Init *V) { if (!V) return false; - if (CurRec == 0) CurRec = &CurMultiClass->Rec; + if (!CurRec) CurRec = &CurMultiClass->Rec; RecordVal *RV = CurRec->getValue(ValName); - if (RV == 0) + if (!RV) return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' unknown!"); @@ -103,19 +103,19 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, // if (!BitList.empty()) { BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue()); - if (CurVal == 0) + if (!CurVal) 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 == 0) { + 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 != 0); + assert(BInit != nullptr); SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); @@ -129,7 +129,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, } for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) - if (NewBits[i] == 0) + if (!NewBits[i]) NewBits[i] = CurVal->getBit(i); V = BitsInit::get(NewBits); @@ -314,14 +314,14 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ assert(IterVals.size() < Loops.size()); ForeachLoop &CurLoop = Loops[IterVals.size()]; ListInit *List = dyn_cast<ListInit>(CurLoop.ListValue); - if (List == 0) { + if (!List) { Error(Loc, "Loop list is not a list"); return true; } // Process each value. for (int64_t i = 0; i < List->getSize(); ++i) { - Init *ItemVal = List->resolveListElementReference(*CurRec, 0, i); + Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i); IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal)); if (ProcessForeachDefs(CurRec, Loc, IterVals)) return true; @@ -339,7 +339,7 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ for (unsigned i = 0, e = IterVals.size(); i != e; ++i) { VarInit *IterVar = IterVals[i].IterVar; TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue); - if (IVal == 0) { + if (!IVal) { Error(Loc, "foreach iterator value is untyped"); return true; } @@ -400,21 +400,21 @@ Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { // 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. - return 0; + return nullptr; default: break; } - Record *CurRec = 0; + Record *CurRec = nullptr; if (CurMultiClass) CurRec = &CurMultiClass->Rec; - RecTy *Type = 0; + RecTy *Type = nullptr; if (CurRec) { const TypedInit *CurRecName = dyn_cast<TypedInit>(CurRec->getNameInit()); if (!CurRecName) { TokError("Record name is not typed!"); - return 0; + return nullptr; } Type = CurRecName->getType(); } @@ -430,11 +430,11 @@ Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { Record *TGParser::ParseClassID() { if (Lex.getCode() != tgtok::Id) { TokError("expected name for ClassID"); - return 0; + return nullptr; } Record *Result = Records.getClass(Lex.getCurStrVal()); - if (Result == 0) + if (!Result) TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); Lex.Lex(); @@ -449,11 +449,11 @@ Record *TGParser::ParseClassID() { MultiClass *TGParser::ParseMultiClassID() { if (Lex.getCode() != tgtok::Id) { TokError("expected name for MultiClassID"); - return 0; + return nullptr; } MultiClass *Result = MultiClasses[Lex.getCurStrVal()]; - if (Result == 0) + if (!Result) TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); Lex.Lex(); @@ -477,7 +477,7 @@ ParseSubClassReference(Record *CurRec, bool isDefm) { } else { Result.Rec = ParseClassID(); } - if (Result.Rec == 0) return Result; + if (!Result.Rec) return Result; // If there is no template arg list, we're done. if (Lex.getCode() != tgtok::less) { @@ -488,19 +488,19 @@ ParseSubClassReference(Record *CurRec, bool isDefm) { if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); - Result.Rec = 0; + Result.Rec = nullptr; return Result; } Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); if (Result.TemplateArgs.empty()) { - Result.Rec = 0; // Error parsing value list. + Result.Rec = nullptr; // Error parsing value list. return Result; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' in template value list"); - Result.Rec = 0; + Result.Rec = nullptr; return Result; } Lex.Lex(); @@ -522,7 +522,7 @@ ParseSubMultiClassReference(MultiClass *CurMC) { Result.RefRange.Start = Lex.getLoc(); Result.MC = ParseMultiClassID(); - if (Result.MC == 0) return Result; + if (!Result.MC) return Result; // If there is no template arg list, we're done. if (Lex.getCode() != tgtok::less) { @@ -533,19 +533,19 @@ ParseSubMultiClassReference(MultiClass *CurMC) { if (Lex.getCode() == tgtok::greater) { TokError("subclass reference requires a non-empty list of template values"); - Result.MC = 0; + Result.MC = nullptr; return Result; } Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); if (Result.TemplateArgs.empty()) { - Result.MC = 0; // Error parsing value list. + Result.MC = nullptr; // Error parsing value list. return Result; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' in template value list"); - Result.MC = 0; + Result.MC = nullptr; return Result; } Lex.Lex(); @@ -677,7 +677,7 @@ bool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) { /// RecTy *TGParser::ParseType() { switch (Lex.getCode()) { - default: TokError("Unknown token when expecting a type"); return 0; + default: TokError("Unknown token when expecting a type"); return nullptr; case tgtok::String: Lex.Lex(); return StringRecTy::get(); case tgtok::Code: Lex.Lex(); return StringRecTy::get(); case tgtok::Bit: Lex.Lex(); return BitRecTy::get(); @@ -685,20 +685,20 @@ RecTy *TGParser::ParseType() { case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); case tgtok::Id: if (Record *R = ParseClassID()) return RecordRecTy::get(R); - return 0; + return nullptr; case tgtok::Bits: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' TokError("expected '<' after bits type"); - return 0; + return nullptr; } if (Lex.Lex() != tgtok::IntVal) { // Eat '<' TokError("expected integer in bits<n> type"); - return 0; + return nullptr; } uint64_t Val = Lex.getCurIntVal(); if (Lex.Lex() != tgtok::greater) { // Eat count. TokError("expected '>' at end of bits<n> type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '>' return BitsRecTy::get(Val); @@ -706,15 +706,15 @@ RecTy *TGParser::ParseType() { case tgtok::List: { if (Lex.Lex() != tgtok::less) { // Eat 'bits' TokError("expected '<' after list type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '<' RecTy *SubType = ParseType(); - if (SubType == 0) return 0; + if (!SubType) return nullptr; if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of list<ty> type"); - return 0; + return nullptr; } Lex.Lex(); // Eat '>' return ListRecTy::get(SubType); @@ -772,7 +772,7 @@ Init *TGParser::ParseIDValue(Record *CurRec, if (Mode == ParseValueMode) { Error(NameLoc, "Variable not defined: '" + Name + "'"); - return 0; + return nullptr; } return StringInit::get(Name); @@ -786,13 +786,13 @@ Init *TGParser::ParseOperation(Record *CurRec) { switch (Lex.getCode()) { default: TokError("unknown operation"); - return 0; + return nullptr; case tgtok::XHead: case tgtok::XTail: case tgtok::XEmpty: case tgtok::XCast: { // Value ::= !unop '(' Value ')' UnOpInit::UnaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; switch (Lex.getCode()) { default: llvm_unreachable("Unhandled code!"); @@ -802,9 +802,9 @@ Init *TGParser::ParseOperation(Record *CurRec) { Type = ParseOperatorType(); - if (Type == 0) { + if (!Type) { TokError("did not get type for unary operator"); - return 0; + return nullptr; } break; @@ -824,12 +824,12 @@ Init *TGParser::ParseOperation(Record *CurRec) { } if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after unary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' Init *LHS = ParseValue(CurRec); - if (LHS == 0) return 0; + if (!LHS) return nullptr; if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL @@ -837,36 +837,36 @@ Init *TGParser::ParseOperation(Record *CurRec) { ListInit *LHSl = dyn_cast<ListInit>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS); - if (LHSl == 0 && LHSs == 0 && LHSt == 0) { + if (!LHSl && !LHSs && !LHSt) { TokError("expected list or string type argument in unary operator"); - return 0; + return nullptr; } if (LHSt) { ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType()); - if (LType == 0 && SType == 0) { + if (!LType && !SType) { TokError("expected list or string type argumnet in unary operator"); - return 0; + return nullptr; } } if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) { - if (LHSl == 0 && LHSt == 0) { + if (!LHSl && !LHSt) { TokError("expected list type argumnet in unary operator"); - return 0; + return nullptr; } if (LHSl && LHSl->getSize() == 0) { TokError("empty list argument in unary operator"); - return 0; + return nullptr; } if (LHSl) { Init *Item = LHSl->getElement(0); TypedInit *Itemt = dyn_cast<TypedInit>(Item); - if (Itemt == 0) { + if (!Itemt) { TokError("untyped list element in unary operator"); - return 0; + return nullptr; } if (Code == UnOpInit::HEAD) { Type = Itemt->getType(); @@ -876,9 +876,9 @@ Init *TGParser::ParseOperation(Record *CurRec) { } else { assert(LHSt && "expected list type argument in unary operator"); ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); - if (LType == 0) { + if (!LType) { TokError("expected list type argumnet in unary operator"); - return 0; + return nullptr; } if (Code == UnOpInit::HEAD) { Type = LType->getElementType(); @@ -891,7 +891,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in unary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass); @@ -903,13 +903,14 @@ Init *TGParser::ParseOperation(Record *CurRec) { case tgtok::XSRL: case tgtok::XSHL: case tgtok::XEq: + case tgtok::XListConcat: case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')' tgtok::TokKind OpTok = Lex.getCode(); SMLoc OpLoc = Lex.getLoc(); Lex.Lex(); // eat the operation BinOpInit::BinaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; switch (OpTok) { default: llvm_unreachable("Unhandled code!"); @@ -919,6 +920,10 @@ Init *TGParser::ParseOperation(Record *CurRec) { case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break; case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break; case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break; + case tgtok::XListConcat: + Code = BinOpInit::LISTCONCAT; + // We don't know the list type until we parse the first argument + break; case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; Type = StringRecTy::get(); @@ -927,31 +932,44 @@ Init *TGParser::ParseOperation(Record *CurRec) { if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after binary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' SmallVector<Init*, 2> InitList; InitList.push_back(ParseValue(CurRec)); - if (InitList.back() == 0) return 0; + if (!InitList.back()) return nullptr; while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // eat the ',' InitList.push_back(ParseValue(CurRec)); - if (InitList.back() == 0) return 0; + if (!InitList.back()) return nullptr; } if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' + // If we are doing !listconcat, we should know the type by now + if (OpTok == tgtok::XListConcat) { + if (VarInit *Arg0 = dyn_cast<VarInit>(InitList[0])) + Type = Arg0->getType(); + else if (ListInit *Arg0 = dyn_cast<ListInit>(InitList[0])) + Type = Arg0->getType(); + else { + InitList[0]->dump(); + Error(OpLoc, "expected a list"); + return nullptr; + } + } + // We allow multiple operands to associative operators like !strconcat as // shorthand for nesting them. - if (Code == BinOpInit::STRCONCAT) { + if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT) { while (InitList.size() > 2) { Init *RHS = InitList.pop_back_val(); RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type)) @@ -965,14 +983,14 @@ Init *TGParser::ParseOperation(Record *CurRec) { ->Fold(CurRec, CurMultiClass); Error(OpLoc, "expected two operands to operator"); - return 0; + return nullptr; } case tgtok::XIf: case tgtok::XForEach: case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' TernOpInit::TernaryOp Code; - RecTy *Type = 0; + RecTy *Type = nullptr; tgtok::TokKind LexCode = Lex.getCode(); Lex.Lex(); // eat the operation @@ -990,42 +1008,42 @@ Init *TGParser::ParseOperation(Record *CurRec) { } if (Lex.getCode() != tgtok::l_paren) { TokError("expected '(' after ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the '(' Init *LHS = ParseValue(CurRec); - if (LHS == 0) return 0; + if (!LHS) return nullptr; if (Lex.getCode() != tgtok::comma) { TokError("expected ',' in ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ',' Init *MHS = ParseValue(CurRec); - if (MHS == 0) return 0; + if (!MHS) return nullptr; if (Lex.getCode() != tgtok::comma) { TokError("expected ',' in ternary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ',' Init *RHS = ParseValue(CurRec); - if (RHS == 0) return 0; + if (!RHS) return nullptr; if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in binary operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' switch (LexCode) { default: llvm_unreachable("Unhandled code!"); case tgtok::XIf: { - RecTy *MHSTy = 0; - RecTy *RHSTy = 0; + RecTy *MHSTy = nullptr; + RecTy *RHSTy = nullptr; if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS)) MHSTy = MHSt->getType(); @@ -1049,7 +1067,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { if (!MHSTy || !RHSTy) { TokError("could not get type for !if"); - return 0; + return nullptr; } if (MHSTy->typeIsConvertibleTo(RHSTy)) { @@ -1058,24 +1076,24 @@ Init *TGParser::ParseOperation(Record *CurRec) { Type = MHSTy; } else { TokError("inconsistent types for !if"); - return 0; + return nullptr; } break; } case tgtok::XForEach: { TypedInit *MHSt = dyn_cast<TypedInit>(MHS); - if (MHSt == 0) { + if (!MHSt) { TokError("could not get type for !foreach"); - return 0; + return nullptr; } Type = MHSt->getType(); break; } case tgtok::XSubst: { TypedInit *RHSt = dyn_cast<TypedInit>(RHS); - if (RHSt == 0) { + if (!RHSt) { TokError("could not get type for !subst"); - return 0; + return nullptr; } Type = RHSt->getType(); break; @@ -1093,24 +1111,24 @@ Init *TGParser::ParseOperation(Record *CurRec) { /// OperatorType ::= '<' Type '>' /// RecTy *TGParser::ParseOperatorType() { - RecTy *Type = 0; + RecTy *Type = nullptr; if (Lex.getCode() != tgtok::less) { TokError("expected type name for operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the < Type = ParseType(); - if (Type == 0) { + if (!Type) { TokError("expected type name for operator"); - return 0; + return nullptr; } if (Lex.getCode() != tgtok::greater) { TokError("expected type name for operator"); - return 0; + return nullptr; } Lex.Lex(); // eat the > @@ -1134,11 +1152,12 @@ RecTy *TGParser::ParseOperatorType() { /// SimpleValue ::= SHLTOK '(' Value ',' Value ')' /// SimpleValue ::= SRATOK '(' Value ',' Value ')' /// SimpleValue ::= SRLTOK '(' Value ',' Value ')' +/// SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')' /// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' /// Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { - Init *R = 0; + Init *R = nullptr; switch (Lex.getCode()) { default: TokError("Unknown token when parsing a value"); break; case tgtok::paste: @@ -1177,7 +1196,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, // Value ::= ID '<' ValueListNE '>' if (Lex.Lex() == tgtok::greater) { TokError("expected non-empty value list"); - return 0; + return nullptr; } // This is a CLASS<initvalslist> expression. This is supposed to synthesize @@ -1186,15 +1205,15 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Record *Class = Records.getClass(Name); if (!Class) { Error(NameLoc, "Expected a class name, got '" + Name + "'"); - return 0; + return nullptr; } std::vector<Init*> ValueList = ParseValueList(CurRec, Class); - if (ValueList.empty()) return 0; + if (ValueList.empty()) return nullptr; if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of value list"); - return 0; + return nullptr; } Lex.Lex(); // eat the '>' SMLoc EndLoc = Lex.getLoc(); @@ -1208,7 +1227,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, SCRef.TemplateArgs = ValueList; // Add info about the subclass to NewRec. if (AddSubClass(NewRec, SCRef)) - return 0; + return nullptr; if (!CurMultiClass) { NewRec->resolveReferences(); Records.addDef(NewRec); @@ -1250,11 +1269,11 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, if (Lex.getCode() != tgtok::r_brace) { Vals = ParseValueList(CurRec); - if (Vals.empty()) return 0; + if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit list value"); - return 0; + return nullptr; } Lex.Lex(); // eat the '}' @@ -1262,10 +1281,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, for (unsigned i = 0, e = Vals.size(); i != e; ++i) { Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); - if (Bit == 0) { + if (!Bit) { Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ ") is not convertable to a bit"); - return 0; + return nullptr; } NewBits[Vals.size()-i-1] = Bit; } @@ -1275,87 +1294,87 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Lex.Lex(); // eat the '[' std::vector<Init*> Vals; - RecTy *DeducedEltTy = 0; - ListRecTy *GivenListTy = 0; + RecTy *DeducedEltTy = nullptr; + ListRecTy *GivenListTy = nullptr; - if (ItemType != 0) { + if (ItemType) { ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType); - if (ListType == 0) { + if (!ListType) { std::string s; raw_string_ostream ss(s); ss << "Type mismatch for list, expected list type, got " << ItemType->getAsString(); TokError(ss.str()); - return 0; + return nullptr; } GivenListTy = ListType; } if (Lex.getCode() != tgtok::r_square) { - Vals = ParseValueList(CurRec, 0, - GivenListTy ? GivenListTy->getElementType() : 0); - if (Vals.empty()) return 0; + Vals = ParseValueList(CurRec, nullptr, + GivenListTy ? GivenListTy->getElementType() : nullptr); + if (Vals.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_square) { TokError("expected ']' at end of list value"); - return 0; + return nullptr; } Lex.Lex(); // eat the ']' - RecTy *GivenEltTy = 0; + RecTy *GivenEltTy = nullptr; if (Lex.getCode() == tgtok::less) { // Optional list element type Lex.Lex(); // eat the '<' GivenEltTy = ParseType(); - if (GivenEltTy == 0) { + if (!GivenEltTy) { // Couldn't parse element type - return 0; + return nullptr; } if (Lex.getCode() != tgtok::greater) { TokError("expected '>' at end of list element type"); - return 0; + return nullptr; } Lex.Lex(); // eat the '>' } // Check elements - RecTy *EltTy = 0; + RecTy *EltTy = nullptr; for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); i != ie; ++i) { TypedInit *TArg = dyn_cast<TypedInit>(*i); - if (TArg == 0) { + if (!TArg) { TokError("Untyped list element"); - return 0; + return nullptr; } - if (EltTy != 0) { + if (EltTy) { EltTy = resolveTypes(EltTy, TArg->getType()); - if (EltTy == 0) { + if (!EltTy) { TokError("Incompatible types in list elements"); - return 0; + return nullptr; } } else { EltTy = TArg->getType(); } } - if (GivenEltTy != 0) { - if (EltTy != 0) { + if (GivenEltTy) { + if (EltTy) { // Verify consistency if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { TokError("Incompatible types in list elements"); - return 0; + return nullptr; } } EltTy = GivenEltTy; } - if (EltTy == 0) { - if (ItemType == 0) { + if (!EltTy) { + if (!ItemType) { TokError("No type for list"); - return 0; + return nullptr; } DeducedEltTy = GivenListTy->getElementType(); } else { @@ -1363,7 +1382,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, if (GivenListTy) { if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { TokError("Element type mismatch for list"); - return 0; + return nullptr; } } DeducedEltTy = EltTy; @@ -1375,18 +1394,18 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, Lex.Lex(); // eat the '(' if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) { TokError("expected identifier in dag init"); - return 0; + return nullptr; } Init *Operator = ParseValue(CurRec); - if (Operator == 0) return 0; + if (!Operator) return nullptr; // If the operator name is present, parse it. std::string OperatorName; if (Lex.getCode() == tgtok::colon) { if (Lex.Lex() != tgtok::VarName) { // eat the ':' TokError("expected variable name in dag operator"); - return 0; + return nullptr; } OperatorName = Lex.getCurStrVal(); Lex.Lex(); // eat the VarName. @@ -1395,12 +1414,12 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, std::vector<std::pair<llvm::Init*, std::string> > DagArgs; if (Lex.getCode() != tgtok::r_paren) { DagArgs = ParseDagArgList(CurRec); - if (DagArgs.empty()) return 0; + if (DagArgs.empty()) return nullptr; } if (Lex.getCode() != tgtok::r_paren) { TokError("expected ')' in dag init"); - return 0; + return nullptr; } Lex.Lex(); // eat the ')' @@ -1417,6 +1436,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, case tgtok::XSRL: case tgtok::XSHL: case tgtok::XEq: + case tgtok::XListConcat: case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')' case tgtok::XIf: case tgtok::XForEach: @@ -1437,7 +1457,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, /// Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { Init *Result = ParseSimpleValue(CurRec, ItemType, Mode); - if (Result == 0) return 0; + if (!Result) return nullptr; // Parse the suffixes now if present. while (1) { @@ -1451,20 +1471,20 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { SMLoc CurlyLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' std::vector<unsigned> Ranges = ParseRangeList(); - if (Ranges.empty()) return 0; + if (Ranges.empty()) return nullptr; // Reverse the bitlist. std::reverse(Ranges.begin(), Ranges.end()); Result = Result->convertInitializerBitRange(Ranges); - if (Result == 0) { + if (!Result) { Error(CurlyLoc, "Invalid bit range for value"); - return 0; + return nullptr; } // Eat the '}'. if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit range list"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1473,18 +1493,18 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { SMLoc SquareLoc = Lex.getLoc(); Lex.Lex(); // eat the '[' std::vector<unsigned> Ranges = ParseRangeList(); - if (Ranges.empty()) return 0; + if (Ranges.empty()) return nullptr; Result = Result->convertInitListSlice(Ranges); - if (Result == 0) { + if (!Result) { Error(SquareLoc, "Invalid range for list slice"); - return 0; + return nullptr; } // Eat the ']'. if (Lex.getCode() != tgtok::r_square) { TokError("expected ']' at end of list slice"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1492,12 +1512,12 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { case tgtok::period: if (Lex.Lex() != tgtok::Id) { // eat the . TokError("expected field identifier after '.'"); - return 0; + return nullptr; } if (!Result->getFieldType(Lex.getCurStrVal())) { TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + Result->getAsString() + "'"); - return 0; + return nullptr; } Result = FieldInit::get(Result, Lex.getCurStrVal()); Lex.Lex(); // eat field name @@ -1512,14 +1532,14 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { TypedInit *LHS = dyn_cast<TypedInit>(Result); if (!LHS) { Error(PasteLoc, "LHS of paste is not typed!"); - return 0; + return nullptr; } if (LHS->getType() != StringRecTy::get()) { LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get()); } - TypedInit *RHS = 0; + TypedInit *RHS = nullptr; Lex.Lex(); // Eat the '#'. switch (Lex.getCode()) { @@ -1539,7 +1559,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { RHS = dyn_cast<TypedInit>(RHSResult); if (!RHS) { Error(PasteLoc, "RHS of paste is not typed!"); - return 0; + return nullptr; } if (RHS->getType() != StringRecTy::get()) { @@ -1575,7 +1595,7 @@ TGParser::ParseDagArgList(Record *CurRec) { } else { // DagArg ::= Value (':' VARNAME)? Init *Val = ParseValue(CurRec); - if (Val == 0) + if (!Val) return std::vector<std::pair<llvm::Init*, std::string> >(); // If the variable name is present, add it. @@ -1610,7 +1630,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, std::vector<Init*> Result; RecTy *ItemType = EltTy; unsigned int ArgN = 0; - if (ArgsRec != 0 && EltTy == 0) { + if (ArgsRec && !EltTy) { const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs(); if (!TArgs.size()) { TokError("template argument provided to non-template class"); @@ -1626,12 +1646,12 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector<Init*>(); + if (!Result.back()) return std::vector<Init*>(); while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // Eat the comma - if (ArgsRec != 0 && EltTy == 0) { + if (ArgsRec && !EltTy) { const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs(); if (ArgN >= TArgs.size()) { TokError("too many template arguments"); @@ -1643,7 +1663,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector<Init*>(); + if (!Result.back()) return std::vector<Init*>(); } return Result; @@ -1667,11 +1687,11 @@ Init *TGParser::ParseDeclaration(Record *CurRec, if (HasField) Lex.Lex(); RecTy *Type = ParseType(); - if (Type == 0) return 0; + if (!Type) return nullptr; if (Lex.getCode() != tgtok::Id) { TokError("Expected identifier in declaration"); - return 0; + return nullptr; } SMLoc IdLoc = Lex.getLoc(); @@ -1691,16 +1711,16 @@ Init *TGParser::ParseDeclaration(Record *CurRec, // Add the value. if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField))) - return 0; + return nullptr; // If a value is present, parse it. if (Lex.getCode() == tgtok::equal) { Lex.Lex(); SMLoc ValLoc = Lex.getLoc(); Init *Val = ParseValue(CurRec, Type); - if (Val == 0 || + if (!Val || SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val)) - return 0; + return nullptr; } return DeclName; @@ -1717,7 +1737,7 @@ Init *TGParser::ParseDeclaration(Record *CurRec, VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { if (Lex.getCode() != tgtok::Id) { TokError("Expected identifier in foreach declaration"); - return 0; + return nullptr; } Init *DeclName = StringInit::get(Lex.getCurStrVal()); @@ -1726,27 +1746,27 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { // If a value is present, parse it. if (Lex.getCode() != tgtok::equal) { TokError("Expected '=' in foreach declaration"); - return 0; + return nullptr; } Lex.Lex(); // Eat the '=' - RecTy *IterType = 0; + RecTy *IterType = nullptr; std::vector<unsigned> Ranges; switch (Lex.getCode()) { - default: TokError("Unknown token when expecting a range list"); return 0; + default: TokError("Unknown token when expecting a range list"); return nullptr; case tgtok::l_square: { // '[' ValueList ']' - Init *List = ParseSimpleValue(0, 0, ParseForeachMode); + Init *List = ParseSimpleValue(nullptr, nullptr, ParseForeachMode); ForeachListValue = dyn_cast<ListInit>(List); - if (ForeachListValue == 0) { + if (!ForeachListValue) { TokError("Expected a Value list"); - return 0; + return nullptr; } RecTy *ValueType = ForeachListValue->getType(); ListRecTy *ListType = dyn_cast<ListRecTy>(ValueType); - if (ListType == 0) { + if (!ListType) { TokError("Value list is not of list type"); - return 0; + return nullptr; } IterType = ListType->getElementType(); break; @@ -1754,7 +1774,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { case tgtok::IntVal: { // RangePiece. if (ParseRangePiece(Ranges)) - return 0; + return nullptr; break; } @@ -1763,7 +1783,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { Ranges = ParseRangeList(); if (Lex.getCode() != tgtok::r_brace) { TokError("expected '}' at end of bit range list"); - return 0; + return nullptr; } Lex.Lex(); break; @@ -1780,7 +1800,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { } if (!IterType) - return 0; + return nullptr; return VarInit::get(DeclName, IterType); } @@ -1800,7 +1820,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { // Read the first declaration. Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); - if (TemplArg == 0) + if (!TemplArg) return true; TheRecToAddTo->addTemplateArg(TemplArg); @@ -1810,7 +1830,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { // Read the following declarations. TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); - if (TemplArg == 0) + if (!TemplArg) return true; TheRecToAddTo->addTemplateArg(TemplArg); } @@ -1828,7 +1848,7 @@ bool TGParser::ParseTemplateArgList(Record *CurRec) { /// BodyItem ::= LET ID OptionalBitList '=' Value ';' bool TGParser::ParseBodyItem(Record *CurRec) { if (Lex.getCode() != tgtok::Let) { - if (ParseDeclaration(CurRec, false) == 0) + if (!ParseDeclaration(CurRec, false)) return true; if (Lex.getCode() != tgtok::semi) @@ -1855,13 +1875,13 @@ bool TGParser::ParseBodyItem(Record *CurRec) { Lex.Lex(); // eat the '='. RecordVal *Field = CurRec->getValue(FieldName); - if (Field == 0) + if (!Field) return TokError("Value '" + FieldName + "' unknown!"); RecTy *Type = Field->getType(); Init *Val = ParseValue(CurRec, Type); - if (Val == 0) return true; + if (!Val) return true; if (Lex.getCode() != tgtok::semi) return TokError("expected ';' after let expression"); @@ -1927,7 +1947,7 @@ bool TGParser::ParseObjectBody(Record *CurRec) { SubClassReference SubClass = ParseSubClassReference(CurRec, false); while (1) { // Check for error. - if (SubClass.Rec == 0) return true; + if (!SubClass.Rec) return true; // Add it. if (AddSubClass(CurRec, SubClass)) @@ -1998,7 +2018,7 @@ bool TGParser::ParseDef(MultiClass *CurMultiClass) { } else if (ParseObjectBody(CurRec)) return true; - if (CurMultiClass == 0) // Def's in multiclasses aren't really defs. + if (!CurMultiClass) // Def's in multiclasses aren't really defs. // 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. @@ -2040,9 +2060,9 @@ bool TGParser::ParseForeach(MultiClass *CurMultiClass) { // Make a temporary object to record items associated with the for // loop. - ListInit *ListValue = 0; + ListInit *ListValue = nullptr; VarInit *IterName = ParseForeachDeclaration(ListValue); - if (IterName == 0) + if (!IterName) return TokError("expected declaration in for"); if (Lex.getCode() != tgtok::In) @@ -2144,8 +2164,8 @@ std::vector<LetRecord> TGParser::ParseLetList() { } Lex.Lex(); // eat the '='. - Init *Val = ParseValue(0); - if (Val == 0) return std::vector<LetRecord>(); + Init *Val = ParseValue(nullptr); + if (!Val) return std::vector<LetRecord>(); // Now that we have everything, add the record. Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); @@ -2228,7 +2248,7 @@ bool TGParser::ParseMultiClass() { // If there are template args, parse them. if (Lex.getCode() == tgtok::less) - if (ParseTemplateArgList(0)) + if (ParseTemplateArgList(nullptr)) return true; bool inherits = false; @@ -2244,7 +2264,7 @@ bool TGParser::ParseMultiClass() { ParseSubMultiClassReference(CurMultiClass); while (1) { // Check for error. - if (SubMultiClass.MC == 0) return true; + if (!SubMultiClass.MC) return true; // Add it. if (AddSubMultiClass(CurMultiClass, SubMultiClass)) @@ -2283,7 +2303,7 @@ bool TGParser::ParseMultiClass() { Lex.Lex(); // eat the '}'. } - CurMultiClass = 0; + CurMultiClass = nullptr; return false; } @@ -2301,7 +2321,7 @@ InstantiateMulticlassDef(MultiClass &MC, // as a prefix. bool IsAnonymous = false; - if (DefmPrefix == 0) { + if (!DefmPrefix) { DefmPrefix = StringInit::get(GetNewAnonymousName()); IsAnonymous = true; } @@ -2310,7 +2330,7 @@ InstantiateMulticlassDef(MultiClass &MC, StringInit *DefNameString = dyn_cast<StringInit>(DefName); - if (DefNameString != 0) { + if (DefNameString) { // We have a fully expanded string so there are no operators to // resolve. We should concatenate the given prefix and name. DefName = @@ -2338,13 +2358,13 @@ InstantiateMulticlassDef(MultiClass &MC, Error(DefmPrefixRange.Start, "Could not resolve " + CurRec->getNameInitAsString() + ":NAME to '" + DefmPrefix->getAsUnquotedString() + "'"); - return 0; + return nullptr; } // If the DefNameString didn't resolve, we probably have a reference to // NAME and need to replace it. We need to do at least this much greedily, // otherwise nested multiclasses will end up with incorrect NAME expansions. - if (DefNameString == 0) { + if (!DefNameString) { RecordVal *DefNameRV = CurRec->getValue("NAME"); CurRec->resolveReferencesTo(DefNameRV); } @@ -2369,7 +2389,7 @@ InstantiateMulticlassDef(MultiClass &MC, Error(DefmPrefixRange.Start, "def '" + CurRec->getNameInitAsString() + "' already defined, instantiating defm with subdef '" + DefProto->getNameInitAsString() + "'"); - return 0; + return nullptr; } Records.addDef(CurRec); @@ -2453,7 +2473,7 @@ bool TGParser::ResolveMulticlassDef(MultiClass &MC, bool TGParser::ParseDefm(MultiClass *CurMultiClass) { assert(Lex.getCode() == tgtok::Defm && "Unexpected token!"); SMLoc DefmLoc = Lex.getLoc(); - Init *DefmPrefix = 0; + Init *DefmPrefix = nullptr; if (Lex.Lex() == tgtok::Id) { // eat the defm. DefmPrefix = ParseObjectName(CurMultiClass); @@ -2473,10 +2493,10 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { Lex.Lex(); SMLoc SubClassLoc = Lex.getLoc(); - SubClassReference Ref = ParseSubClassReference(0, true); + SubClassReference Ref = ParseSubClassReference(nullptr, true); while (1) { - if (Ref.Rec == 0) return true; + if (!Ref.Rec) return true; // To instantiate a multiclass, we need to first get the multiclass, then // instantiate each def contained in the multiclass with the SubClassRef @@ -2522,21 +2542,21 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { // A defm can inherit from regular classes (non-multiclass) as // long as they come in the end of the inheritance list. - InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0); + InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr); if (InheritFromClass) break; - Ref = ParseSubClassReference(0, true); + Ref = ParseSubClassReference(nullptr, true); } if (InheritFromClass) { // Process all the classes to inherit as if they were part of a // regular 'def' and inherit all record values. - SubClassReference SubClass = ParseSubClassReference(0, false); + SubClassReference SubClass = ParseSubClassReference(nullptr, false); while (1) { // Check for error. - if (SubClass.Rec == 0) return true; + if (!SubClass.Rec) return true; // Get the expanded definition prototypes and teach them about // the record values the current class to inherit has @@ -2553,7 +2573,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { if (Lex.getCode() != tgtok::comma) break; Lex.Lex(); // eat ','. - SubClass = ParseSubClassReference(0, false); + SubClass = ParseSubClassReference(nullptr, false); } } diff --git a/lib/TableGen/TGParser.h b/lib/TableGen/TGParser.h index ce31f8e..6fd442a 100644 --- a/lib/TableGen/TGParser.h +++ b/lib/TableGen/TGParser.h @@ -85,7 +85,7 @@ class TGParser { public: TGParser(SourceMgr &SrcMgr, RecordKeeper &records) - : Lex(SrcMgr), CurMultiClass(0), Records(records), AnonCounter(0) {} + : Lex(SrcMgr), CurMultiClass(nullptr), Records(records), AnonCounter(0) {} /// ParseFile - Main entrypoint for parsing a tblgen file. These parser /// routines return true on error, or false on success. @@ -131,7 +131,7 @@ private: // Semantic analysis methods. bool ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals); private: // Parser methods. - bool ParseObjectList(MultiClass *MC = 0); + bool ParseObjectList(MultiClass *MC = nullptr); bool ParseObject(MultiClass *MC); bool ParseClass(); bool ParseMultiClass(); @@ -169,12 +169,12 @@ private: // Parser methods. Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc, IDParseMode Mode = ParseValueMode); - Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0, + Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr, IDParseMode Mode = ParseValueMode); - Init *ParseValue(Record *CurRec, RecTy *ItemType = 0, + Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr, IDParseMode Mode = ParseValueMode); - std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, - RecTy *EltTy = 0); + std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = nullptr, + RecTy *EltTy = nullptr); std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *); bool ParseOptionalRangeList(std::vector<unsigned> &Ranges); bool ParseOptionalBitList(std::vector<unsigned> &Ranges); diff --git a/lib/TableGen/module.modulemap b/lib/TableGen/module.modulemap new file mode 100644 index 0000000..8dac0a2 --- /dev/null +++ b/lib/TableGen/module.modulemap @@ -0,0 +1 @@ +module TableGen { requires cplusplus umbrella "." module * { export * } } |