//===----------------------------------------------------------------------===//
#include "TGParser.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CommandLine.h"
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
/// SetValue -
/// Return true on error, false on success.
bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
- const std::vector<unsigned> &BitList, Init *V) {
+ ArrayRef<unsigned> BitList, Init *V,
+ bool AllowSelfAssignment) {
if (!V) return false;
if (!CurRec) CurRec = &CurMultiClass->Rec;
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.
if (BitList.empty())
if (VarInit *VI = dyn_cast<VarInit>(V))
- if (VI->getNameInit() == ValName)
- return false;
+ if (VI->getNameInit() == ValName && !AllowSelfAssignment)
+ return true;
// If we are assigning to a subset of the bits in the value... then we must be
// assigning to a field of BitsRecTy, which must have a BitsInit
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());
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
unsigned Bit = BitList[i];
if (NewBits[Bit])
- return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
+ return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
ValName->getAsUnquotedString() + "' more than once");
NewBits[Bit] = BInit->getBit(i);
}
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;
}
bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
Record *SC = SubClass.Rec;
// Add all of the values in the subclass into the current class.
- const std::vector<RecordVal> &Vals = SC->getValues();
- for (unsigned i = 0, e = Vals.size(); i != e; ++i)
- if (AddValue(CurRec, SubClass.RefRange.Start, Vals[i]))
+ for (const RecordVal &Val : SC->getValues())
+ if (AddValue(CurRec, SubClass.RefRange.Start, Val))
return true;
- const std::vector<Init *> &TArgs = SC->getTemplateArgs();
+ ArrayRef<Init *> TArgs = SC->getTemplateArgs();
// Ensure that an appropriate number of template arguments are specified.
if (TArgs.size() < SubClass.TemplateArgs.size())
if (i < SubClass.TemplateArgs.size()) {
// If a value is specified for this template arg, set it now.
if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i],
- std::vector<unsigned>(), SubClass.TemplateArgs[i]))
+ None, SubClass.TemplateArgs[i]))
return true;
// Resolve it next.
} else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
return Error(SubClass.RefRange.Start,
- "Value not specified for template argument #"
- + utostr(i) + " (" + TArgs[i]->getAsUnquotedString()
- + ") of subclass '" + SC->getNameInitAsString() + "'!");
+ "Value not specified for template argument #" +
+ Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
+ ") of subclass '" + SC->getNameInitAsString() + "'!");
}
}
// Since everything went well, we can now set the "superclass" list for the
// current record.
- const std::vector<Record*> &SCs = SC->getSuperClasses();
+ ArrayRef<Record *> SCs = SC->getSuperClasses();
ArrayRef<SMRange> SCRanges = SC->getSuperClassRanges();
for (unsigned i = 0, e = SCs.size(); i != e; ++i) {
if (CurRec->isSubClassOf(SCs[i]))
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));
}
- const std::vector<Init *> &SMCTArgs = SMC->Rec.getTemplateArgs();
+ ArrayRef<Init *> SMCTArgs = SMC->Rec.getTemplateArgs();
// Ensure that an appropriate number of template arguments are
// specified.
// If a value is specified for this template arg, set it in the
// superclass now.
if (SetValue(CurRec, SubMultiClass.RefRange.Start, SMCTArgs[i],
- std::vector<unsigned>(),
- SubMultiClass.TemplateArgs[i]))
+ None, SubMultiClass.TemplateArgs[i]))
return true;
// Resolve it next.
for (const auto &Def :
makeArrayRef(CurMC->DefPrototypes).slice(newDefStart)) {
if (SetValue(Def.get(), SubMultiClass.RefRange.Start, SMCTArgs[i],
- std::vector<unsigned>(),
- SubMultiClass.TemplateArgs[i]))
+ None, SubMultiClass.TemplateArgs[i]))
return true;
// Resolve it next.
}
} else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) {
return Error(SubMultiClass.RefRange.Start,
- "Value not specified for template argument #"
- + utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString()
- + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!");
+ "Value not specified for template argument #" +
+ Twine(i) + " (" + SMCTArgs[i]->getAsUnquotedString() +
+ ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!");
}
}
}
// Process each value.
- for (int64_t i = 0; i < List->getSize(); ++i) {
+ for (unsigned i = 0; i < List->size(); ++i) {
Init *ItemVal = List->resolveListElementReference(*CurRec, nullptr, i);
IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal));
if (ProcessForeachDefs(CurRec, Loc, IterVals))
auto IterRec = make_unique<Record>(*CurRec);
// Set the iterator values now.
- for (unsigned i = 0, e = IterVals.size(); i != e; ++i) {
- VarInit *IterVar = IterVals[i].IterVar;
- TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue);
+ for (IterRecord &IR : IterVals) {
+ VarInit *IterVar = IR.IterVar;
+ TypedInit *IVal = dyn_cast<TypedInit>(IR.IterValue);
if (!IVal)
return Error(Loc, "foreach iterator value is untyped");
IterRec->addValue(RecordVal(IterVar->getName(), IVal->getType(), false));
- if (SetValue(IterRec.get(), Loc, IterVar->getName(),
- std::vector<unsigned>(), IVal))
+ if (SetValue(IterRec.get(), Loc, IterVar->getName(), None, IVal))
return Error(Loc, "when instantiating this def");
// Resolve it next.
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;
}
}
// 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;
}
Error(NameLoc, "Variable not defined: '" + Name + "'");
return nullptr;
}
-
+
return StringInit::get(Name);
}
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);
}
}
- 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;
}
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());
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;
}
}
}
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);
}
// All other values must be convertible to just a single bit.
Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
if (!Bit) {
- Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
+ Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
") is not convertable to a bit");
return nullptr;
}
if (ItemType) {
ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType);
if (!ListType) {
- std::string s;
- raw_string_ostream ss(s);
- ss << "Type mismatch for list, expected list type, got "
- << ItemType->getAsString();
- TokError(ss.str());
+ TokError(Twine("Type mismatch for list, expected list type, got ") +
+ ItemType->getAsString());
return nullptr;
}
GivenListTy = ListType;
// 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;
Error(PasteLoc, "LHS of paste is not typed!");
return nullptr;
}
-
+
if (LHS->getType() != StringRecTy::get()) {
LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get());
}
// 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;
if (RHS->getType() != StringRecTy::get()) {
RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get());
}
-
+
break;
}
// DagArg ::= VARNAME
if (Lex.getCode() == tgtok::VarName) {
// A missing value is treated like '?'.
- Result.push_back(std::make_pair(UnsetInit::get(), Lex.getCurStrVal()));
+ Result.emplace_back(UnsetInit::get(), Lex.getCurStrVal());
Lex.Lex();
} else {
// DagArg ::= Value (':' VARNAME)?
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec && !EltTy) {
- const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
+ ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
if (TArgs.empty()) {
TokError("template argument provided to non-template class");
return std::vector<Init*>();
Lex.Lex(); // Eat the comma
if (ArgsRec && !EltTy) {
- const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
+ ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
if (ArgN >= TArgs.size()) {
TokError("too many template arguments");
return std::vector<Init*>();
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,
"::");
SMLoc ValLoc = Lex.getLoc();
Init *Val = ParseValue(CurRec, Type);
if (!Val ||
- SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
+ SetValue(CurRec, ValLoc, DeclName, None, Val))
// Return the name, even if an error is thrown. This is so that we can
// continue to make some progress, even without the value having been
// initialized.
assert(!IterType && "Type already initialized?");
IterType = IntRecTy::get();
std::vector<Init*> Values;
- for (unsigned i = 0, e = Ranges.size(); i != e; ++i)
- Values.push_back(IntInit::get(Ranges[i]));
+ for (unsigned R : Ranges)
+ Values.push_back(IntInit::get(R));
ForeachListValue = ListInit::get(Values, IterType);
}
/// \brief Apply the current let bindings to \a CurRec.
/// \returns true on error, false otherwise.
bool TGParser::ApplyLetStack(Record *CurRec) {
- for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
- for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
- if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
- LetStack[i][j].Bits, LetStack[i][j].Value))
+ for (std::vector<LetRecord> &LetInfo : LetStack)
+ for (LetRecord &LR : LetInfo)
+ if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
return true;
return false;
}
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));
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;
}
// 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 '{'.
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 =
if (!Val) return std::vector<LetRecord>();
// Now that we have everything, add the record.
- Result.push_back(LetRecord(Name, Bits, Val, NameLoc));
+ Result.emplace_back(std::move(Name), std::move(Bits), Val, NameLoc);
if (Lex.getCode() != tgtok::comma)
return Result;
return false;
}
-Record *TGParser::
-InstantiateMulticlassDef(MultiClass &MC,
- Record *DefProto,
- Init *&DefmPrefix,
- SMRange DefmPrefixRange) {
+Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto,
+ Init *&DefmPrefix,
+ SMRange DefmPrefixRange,
+ ArrayRef<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.
}
Init *DefName = DefProto->getNameInit();
-
StringInit *DefNameString = dyn_cast<StringInit>(DefName);
if (DefNameString) {
// Set the value for NAME. We don't resolve references to it 'til later,
// though, so that uses in nested multiclass names don't get
// 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() + "'");
+ if (SetValue(CurRec.get(), Ref.RefRange.Start, "NAME", None, DefmPrefix,
+ /*AllowSelfAssignment*/true)) {
+ Error(DefmPrefixRange.Start, "Could not resolve " +
+ CurRec->getNameInitAsString() + ":NAME to '" +
+ DefmPrefix->getAsUnquotedString() + "'");
return nullptr;
}
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.
return CurRec.release();
}
-bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC,
- Record *CurRec,
- SMLoc DefmPrefixLoc,
- SMLoc SubClassLoc,
- const std::vector<Init *> &TArgs,
+bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, Record *CurRec,
+ SMLoc DefmPrefixLoc, SMLoc SubClassLoc,
+ ArrayRef<Init *> TArgs,
std::vector<Init *> &TemplateVals,
bool DeleteArgs) {
// Loop over all of the template arguments, setting them to the specified
// Check if a value is specified for this temp-arg.
if (i < TemplateVals.size()) {
// Set it now.
- if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(),
- TemplateVals[i]))
+ if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], None, TemplateVals[i]))
return true;
-
+
// Resolve it next.
CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
if (DeleteArgs)
// Now remove it.
CurRec->removeValue(TArgs[i]);
-
+
} else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
- return Error(SubClassLoc, "value not specified for template argument #"+
- utostr(i) + " (" + TArgs[i]->getAsUnquotedString()
- + ") of multiclassclass '" + MC.Rec.getNameInitAsString()
- + "'");
+ return Error(SubClassLoc, "value not specified for template argument #" +
+ Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
+ ") of multiclassclass '" + MC.Rec.getNameInitAsString() +
+ "'");
}
}
return false;
// 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);
}
std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
// Verify that the correct number of template arguments were specified.
- const std::vector<Init *> &TArgs = MC->Rec.getTemplateArgs();
+ ArrayRef<Init *> TArgs = MC->Rec.getTemplateArgs();
if (TArgs.size() < TemplateVals.size())
return Error(SubClassLoc,
"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
// 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;
}
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");