Lines Matching full:record
19 #include "llvm/TableGen/Record.h"
31 Record *Rec;
60 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
79 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
148 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
149 Record *SC = SubClass.Rec;
186 // current record.
187 ArrayRef<Record *> SCs = SC->getSuperClasses();
209 Record *CurRec = &CurMC->Rec;
219 for (const std::unique_ptr<Record> &R : SMC->DefPrototypes) {
221 auto NewDef = make_unique<Record>(*R);
282 /// ProcessForeachDefs - Given a record, apply all of the variable
285 bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc) {
296 /// ProcessForeachDefs - Given a record, a loop and a loop iterator,
299 bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){
322 // for this point in the iteration space. Instantiate a new record to
324 auto IterRec = make_unique<Record>(*CurRec);
347 // If this record is anonymous, it's no problem, just generate a new name
354 Record *IterRecSave = IterRec.get(); // Keep a copy before release.
395 Record *CurRec = nullptr;
403 TokError("Record name is not typed!");
417 Record *TGParser::ParseClassID() {
423 Record *Result = Records.getClass(Lex.getCurStrVal());
451 /// subclass. This returns a SubClassRefTy with a null Record* on error.
457 ParseSubClassReference(Record *CurRec, bool isDefm) {
501 /// Record* on error.
662 /// Type ::= ClassID // Record Type
673 if (Record *R = ParseClassID()) return RecordRecTy::get(R);
713 Init *TGParser::ParseIDValue(Record *CurRec,
754 if (Record *D = Records.getDef(Name))
769 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
1138 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
1194 Record *Class = Records.getClass(Name);
1210 // Create the new record, set it as CurRec temporarily.
1211 auto NewRecOwner = llvm::make_unique<Record>(GetNewAnonymousName(), NameLoc,
1213 Record *NewRec = NewRecOwner.get(); // Keep a copy since we may release.
1242 assert(MCNameRV && "multiclass record must have a NAME");
1253 // The result of the expression is a reference to the new record.
1468 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
1596 TGParser::ParseDagArgList(Record *CurRec) {
1638 std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
1654 assert(RV && "Template argument record not found??");
1671 assert(RV && "Template argument record not found??");
1693 Init *TGParser::ParseDeclaration(Record *CurRec,
1827 bool TGParser::ParseTemplateArgList(Record *CurRec) {
1831 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
1861 bool TGParser::ParseBodyItem(Record *CurRec) {
1912 bool TGParser::ParseBody(Record *CurRec) {
1935 bool TGParser::ApplyLetStack(Record *CurRec) {
1952 bool TGParser::ParseObjectBody(Record *CurRec) {
1979 /// ParseDef - Parse and return a top level or multiclass def, return the record
1989 // Parse ObjectName and make a record for it.
1990 std::unique_ptr<Record> CurRecOwner;
1993 CurRecOwner = make_unique<Record>(Name, DefLoc, Records);
1995 CurRecOwner = llvm::make_unique<Record>(GetNewAnonymousName(), DefLoc,
1997 Record *CurRec = CurRecOwner.get(); // Keep a copy since we may release.
2030 // See Record::setName(). This resolve step will see any new name
2054 /// ParseForeach - Parse a for statement. Return the record corresponding
2064 // Make a temporary object to record items associated with the for
2115 Record *CurRec = Records.getClass(Lex.getCurStrVal());
2126 llvm::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records);
2174 // Now that we have everything, add the record.
2316 Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto,
2322 // instantiations, so create a new Record to inherit from it.
2351 auto CurRec = make_unique<Record>(DefName, Locs, Records, IsAnonymous);
2412 // any multiclass expansions, add the record to the RecordKeeper. If we are
2428 Record *CurRecSave = CurRec.get(); // Keep a copy before we release.
2438 bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, Record *CurRec,
2471 Record *CurRec,
2472 Record *DefProto,
2487 CurMultiClass->DefPrototypes.push_back(std::unique_ptr<Record>(CurRec));
2516 // Keep track of the new generated record definitions.
2517 std::vector<Record*> NewRecDefs;
2519 // This record also inherits from a regular class (non-multiclass)?
2545 for (const std::unique_ptr<Record> &DefProto : MC->DefPrototypes) {
2546 // The record name construction goes as follow:
2549 // As a result, the record is instanciated before resolving
2551 Record *CurRec = InstantiateMulticlassDef(*MC, DefProto.get(), DefmPrefix,
2558 // Now that the record is instanciated, we can resolve arguments.
2596 // regular 'def' and inherit all record values.
2603 // the record values the current class to inherit has
2604 for (Record *CurRec : NewRecDefs) {
2620 for (Record *CurRec : NewRecDefs)
2621 // See Record::setName(). This resolve step will see any new
