TGParser.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1//===- TGParser.cpp - Parser for TableGen Files ---------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Implement the Parser for TableGen. 11// 12//===----------------------------------------------------------------------===// 13 14#include "TGParser.h" 15#include "llvm/ADT/SmallVector.h" 16#include "llvm/ADT/StringExtras.h" 17#include "llvm/Support/CommandLine.h" 18#include "llvm/TableGen/Record.h" 19#include <algorithm> 20#include <sstream> 21using namespace llvm; 22 23//===----------------------------------------------------------------------===// 24// Support Code for the Semantic Actions. 25//===----------------------------------------------------------------------===// 26 27namespace llvm { 28struct SubClassReference { 29 SMRange RefRange; 30 Record *Rec; 31 std::vector<Init*> TemplateArgs; 32 SubClassReference() : Rec(0) {} 33 34 bool isInvalid() const { return Rec == 0; } 35}; 36 37struct SubMultiClassReference { 38 SMRange RefRange; 39 MultiClass *MC; 40 std::vector<Init*> TemplateArgs; 41 SubMultiClassReference() : MC(0) {} 42 43 bool isInvalid() const { return MC == 0; } 44 void dump() const; 45}; 46 47void SubMultiClassReference::dump() const { 48 errs() << "Multiclass:\n"; 49 50 MC->dump(); 51 52 errs() << "Template args:\n"; 53 for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(), 54 iend = TemplateArgs.end(); 55 i != iend; 56 ++i) { 57 (*i)->dump(); 58 } 59} 60 61} // end namespace llvm 62 63bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { 64 if (CurRec == 0) 65 CurRec = &CurMultiClass->Rec; 66 67 if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) { 68 // The value already exists in the class, treat this as a set. 69 if (ERV->setValue(RV.getValue())) 70 return Error(Loc, "New definition of '" + RV.getName() + "' of type '" + 71 RV.getType()->getAsString() + "' is incompatible with " + 72 "previous definition of type '" + 73 ERV->getType()->getAsString() + "'"); 74 } else { 75 CurRec->addValue(RV); 76 } 77 return false; 78} 79 80/// SetValue - 81/// Return true on error, false on success. 82bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName, 83 const std::vector<unsigned> &BitList, Init *V) { 84 if (!V) return false; 85 86 if (CurRec == 0) CurRec = &CurMultiClass->Rec; 87 88 RecordVal *RV = CurRec->getValue(ValName); 89 if (RV == 0) 90 return Error(Loc, "Value '" + ValName->getAsUnquotedString() 91 + "' unknown!"); 92 93 // Do not allow assignments like 'X = X'. This will just cause infinite loops 94 // in the resolution machinery. 95 if (BitList.empty()) 96 if (VarInit *VI = dyn_cast<VarInit>(V)) 97 if (VI->getNameInit() == ValName) 98 return false; 99 100 // If we are assigning to a subset of the bits in the value... then we must be 101 // assigning to a field of BitsRecTy, which must have a BitsInit 102 // initializer. 103 // 104 if (!BitList.empty()) { 105 BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue()); 106 if (CurVal == 0) 107 return Error(Loc, "Value '" + ValName->getAsUnquotedString() 108 + "' is not a bits type"); 109 110 // Convert the incoming value to a bits type of the appropriate size... 111 Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size())); 112 if (BI == 0) { 113 return Error(Loc, "Initializer is not compatible with bit range"); 114 } 115 116 // We should have a BitsInit type now. 117 BitsInit *BInit = dyn_cast<BitsInit>(BI); 118 assert(BInit != 0); 119 120 SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); 121 122 // Loop over bits, assigning values as appropriate. 123 for (unsigned i = 0, e = BitList.size(); i != e; ++i) { 124 unsigned Bit = BitList[i]; 125 if (NewBits[Bit]) 126 return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" + 127 ValName->getAsUnquotedString() + "' more than once"); 128 NewBits[Bit] = BInit->getBit(i); 129 } 130 131 for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) 132 if (NewBits[i] == 0) 133 NewBits[i] = CurVal->getBit(i); 134 135 V = BitsInit::get(NewBits); 136 } 137 138 if (RV->setValue(V)) 139 return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' of type '" 140 + RV->getType()->getAsString() + 141 "' is incompatible with initializer '" + V->getAsString() 142 + "'"); 143 return false; 144} 145 146/// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template 147/// args as SubClass's template arguments. 148bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { 149 Record *SC = SubClass.Rec; 150 // Add all of the values in the subclass into the current class. 151 const std::vector<RecordVal> &Vals = SC->getValues(); 152 for (unsigned i = 0, e = Vals.size(); i != e; ++i) 153 if (AddValue(CurRec, SubClass.RefRange.Start, Vals[i])) 154 return true; 155 156 const std::vector<Init *> &TArgs = SC->getTemplateArgs(); 157 158 // Ensure that an appropriate number of template arguments are specified. 159 if (TArgs.size() < SubClass.TemplateArgs.size()) 160 return Error(SubClass.RefRange.Start, 161 "More template args specified than expected"); 162 163 // Loop over all of the template arguments, setting them to the specified 164 // value or leaving them as the default if necessary. 165 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 166 if (i < SubClass.TemplateArgs.size()) { 167 // If a value is specified for this template arg, set it now. 168 if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i], 169 std::vector<unsigned>(), SubClass.TemplateArgs[i])) 170 return true; 171 172 // Resolve it next. 173 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 174 175 // Now remove it. 176 CurRec->removeValue(TArgs[i]); 177 178 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 179 return Error(SubClass.RefRange.Start, 180 "Value not specified for template argument #" 181 + utostr(i) + " (" + TArgs[i]->getAsUnquotedString() 182 + ") of subclass '" + SC->getNameInitAsString() + "'!"); 183 } 184 } 185 186 // Since everything went well, we can now set the "superclass" list for the 187 // current record. 188 const std::vector<Record*> &SCs = SC->getSuperClasses(); 189 ArrayRef<SMRange> SCRanges = SC->getSuperClassRanges(); 190 for (unsigned i = 0, e = SCs.size(); i != e; ++i) { 191 if (CurRec->isSubClassOf(SCs[i])) 192 return Error(SubClass.RefRange.Start, 193 "Already subclass of '" + SCs[i]->getName() + "'!\n"); 194 CurRec->addSuperClass(SCs[i], SCRanges[i]); 195 } 196 197 if (CurRec->isSubClassOf(SC)) 198 return Error(SubClass.RefRange.Start, 199 "Already subclass of '" + SC->getName() + "'!\n"); 200 CurRec->addSuperClass(SC, SubClass.RefRange); 201 return false; 202} 203 204/// AddSubMultiClass - Add SubMultiClass as a subclass to 205/// CurMC, resolving its template args as SubMultiClass's 206/// template arguments. 207bool TGParser::AddSubMultiClass(MultiClass *CurMC, 208 SubMultiClassReference &SubMultiClass) { 209 MultiClass *SMC = SubMultiClass.MC; 210 Record *CurRec = &CurMC->Rec; 211 212 const std::vector<RecordVal> &MCVals = CurRec->getValues(); 213 214 // Add all of the values in the subclass into the current class. 215 const std::vector<RecordVal> &SMCVals = SMC->Rec.getValues(); 216 for (unsigned i = 0, e = SMCVals.size(); i != e; ++i) 217 if (AddValue(CurRec, SubMultiClass.RefRange.Start, SMCVals[i])) 218 return true; 219 220 int newDefStart = CurMC->DefPrototypes.size(); 221 222 // Add all of the defs in the subclass into the current multiclass. 223 for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(), 224 iend = SMC->DefPrototypes.end(); 225 i != iend; 226 ++i) { 227 // Clone the def and add it to the current multiclass 228 Record *NewDef = new Record(**i); 229 230 // Add all of the values in the superclass into the current def. 231 for (unsigned i = 0, e = MCVals.size(); i != e; ++i) 232 if (AddValue(NewDef, SubMultiClass.RefRange.Start, MCVals[i])) 233 return true; 234 235 CurMC->DefPrototypes.push_back(NewDef); 236 } 237 238 const std::vector<Init *> &SMCTArgs = SMC->Rec.getTemplateArgs(); 239 240 // Ensure that an appropriate number of template arguments are 241 // specified. 242 if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size()) 243 return Error(SubMultiClass.RefRange.Start, 244 "More template args specified than expected"); 245 246 // Loop over all of the template arguments, setting them to the specified 247 // value or leaving them as the default if necessary. 248 for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) { 249 if (i < SubMultiClass.TemplateArgs.size()) { 250 // If a value is specified for this template arg, set it in the 251 // superclass now. 252 if (SetValue(CurRec, SubMultiClass.RefRange.Start, SMCTArgs[i], 253 std::vector<unsigned>(), 254 SubMultiClass.TemplateArgs[i])) 255 return true; 256 257 // Resolve it next. 258 CurRec->resolveReferencesTo(CurRec->getValue(SMCTArgs[i])); 259 260 // Now remove it. 261 CurRec->removeValue(SMCTArgs[i]); 262 263 // If a value is specified for this template arg, set it in the 264 // new defs now. 265 for (MultiClass::RecordVector::iterator j = 266 CurMC->DefPrototypes.begin() + newDefStart, 267 jend = CurMC->DefPrototypes.end(); 268 j != jend; 269 ++j) { 270 Record *Def = *j; 271 272 if (SetValue(Def, SubMultiClass.RefRange.Start, SMCTArgs[i], 273 std::vector<unsigned>(), 274 SubMultiClass.TemplateArgs[i])) 275 return true; 276 277 // Resolve it next. 278 Def->resolveReferencesTo(Def->getValue(SMCTArgs[i])); 279 280 // Now remove it 281 Def->removeValue(SMCTArgs[i]); 282 } 283 } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) { 284 return Error(SubMultiClass.RefRange.Start, 285 "Value not specified for template argument #" 286 + utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString() 287 + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!"); 288 } 289 } 290 291 return false; 292} 293 294/// ProcessForeachDefs - Given a record, apply all of the variable 295/// values in all surrounding foreach loops, creating new records for 296/// each combination of values. 297bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc) { 298 if (Loops.empty()) 299 return false; 300 301 // We want to instantiate a new copy of CurRec for each combination 302 // of nested loop iterator values. We don't want top instantiate 303 // any copies until we have values for each loop iterator. 304 IterSet IterVals; 305 return ProcessForeachDefs(CurRec, Loc, IterVals); 306} 307 308/// ProcessForeachDefs - Given a record, a loop and a loop iterator, 309/// apply each of the variable values in this loop and then process 310/// subloops. 311bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){ 312 // Recursively build a tuple of iterator values. 313 if (IterVals.size() != Loops.size()) { 314 assert(IterVals.size() < Loops.size()); 315 ForeachLoop &CurLoop = Loops[IterVals.size()]; 316 ListInit *List = dyn_cast<ListInit>(CurLoop.ListValue); 317 if (List == 0) { 318 Error(Loc, "Loop list is not a list"); 319 return true; 320 } 321 322 // Process each value. 323 for (int64_t i = 0; i < List->getSize(); ++i) { 324 Init *ItemVal = List->resolveListElementReference(*CurRec, 0, i); 325 IterVals.push_back(IterRecord(CurLoop.IterVar, ItemVal)); 326 if (ProcessForeachDefs(CurRec, Loc, IterVals)) 327 return true; 328 IterVals.pop_back(); 329 } 330 return false; 331 } 332 333 // This is the bottom of the recursion. We have all of the iterator values 334 // for this point in the iteration space. Instantiate a new record to 335 // reflect this combination of values. 336 Record *IterRec = new Record(*CurRec); 337 338 // Set the iterator values now. 339 for (unsigned i = 0, e = IterVals.size(); i != e; ++i) { 340 VarInit *IterVar = IterVals[i].IterVar; 341 TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue); 342 if (IVal == 0) { 343 Error(Loc, "foreach iterator value is untyped"); 344 return true; 345 } 346 347 IterRec->addValue(RecordVal(IterVar->getName(), IVal->getType(), false)); 348 349 if (SetValue(IterRec, Loc, IterVar->getName(), 350 std::vector<unsigned>(), IVal)) { 351 Error(Loc, "when instantiating this def"); 352 return true; 353 } 354 355 // Resolve it next. 356 IterRec->resolveReferencesTo(IterRec->getValue(IterVar->getName())); 357 358 // Remove it. 359 IterRec->removeValue(IterVar->getName()); 360 } 361 362 if (Records.getDef(IterRec->getNameInitAsString())) { 363 Error(Loc, "def already exists: " + IterRec->getNameInitAsString()); 364 return true; 365 } 366 367 Records.addDef(IterRec); 368 IterRec->resolveReferences(); 369 return false; 370} 371 372//===----------------------------------------------------------------------===// 373// Parser Code 374//===----------------------------------------------------------------------===// 375 376/// isObjectStart - Return true if this is a valid first token for an Object. 377static bool isObjectStart(tgtok::TokKind K) { 378 return K == tgtok::Class || K == tgtok::Def || 379 K == tgtok::Defm || K == tgtok::Let || 380 K == tgtok::MultiClass || K == tgtok::Foreach; 381} 382 383/// GetNewAnonymousName - Generate a unique anonymous name that can be used as 384/// an identifier. 385std::string TGParser::GetNewAnonymousName() { 386 unsigned Tmp = AnonCounter++; // MSVC2012 ICEs without this. 387 return "anonymous_" + utostr(Tmp); 388} 389 390/// ParseObjectName - If an object name is specified, return it. Otherwise, 391/// return 0. 392/// ObjectName ::= Value [ '#' Value ]* 393/// ObjectName ::= /*empty*/ 394/// 395Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) { 396 switch (Lex.getCode()) { 397 case tgtok::colon: 398 case tgtok::semi: 399 case tgtok::l_brace: 400 // These are all of the tokens that can begin an object body. 401 // Some of these can also begin values but we disallow those cases 402 // because they are unlikely to be useful. 403 return 0; 404 default: 405 break; 406 } 407 408 Record *CurRec = 0; 409 if (CurMultiClass) 410 CurRec = &CurMultiClass->Rec; 411 412 RecTy *Type = 0; 413 if (CurRec) { 414 const TypedInit *CurRecName = dyn_cast<TypedInit>(CurRec->getNameInit()); 415 if (!CurRecName) { 416 TokError("Record name is not typed!"); 417 return 0; 418 } 419 Type = CurRecName->getType(); 420 } 421 422 return ParseValue(CurRec, Type, ParseNameMode); 423} 424 425/// ParseClassID - Parse and resolve a reference to a class name. This returns 426/// null on error. 427/// 428/// ClassID ::= ID 429/// 430Record *TGParser::ParseClassID() { 431 if (Lex.getCode() != tgtok::Id) { 432 TokError("expected name for ClassID"); 433 return 0; 434 } 435 436 Record *Result = Records.getClass(Lex.getCurStrVal()); 437 if (Result == 0) 438 TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); 439 440 Lex.Lex(); 441 return Result; 442} 443 444/// ParseMultiClassID - Parse and resolve a reference to a multiclass name. 445/// This returns null on error. 446/// 447/// MultiClassID ::= ID 448/// 449MultiClass *TGParser::ParseMultiClassID() { 450 if (Lex.getCode() != tgtok::Id) { 451 TokError("expected name for MultiClassID"); 452 return 0; 453 } 454 455 MultiClass *Result = MultiClasses[Lex.getCurStrVal()]; 456 if (Result == 0) 457 TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); 458 459 Lex.Lex(); 460 return Result; 461} 462 463/// ParseSubClassReference - Parse a reference to a subclass or to a templated 464/// subclass. This returns a SubClassRefTy with a null Record* on error. 465/// 466/// SubClassRef ::= ClassID 467/// SubClassRef ::= ClassID '<' ValueList '>' 468/// 469SubClassReference TGParser:: 470ParseSubClassReference(Record *CurRec, bool isDefm) { 471 SubClassReference Result; 472 Result.RefRange.Start = Lex.getLoc(); 473 474 if (isDefm) { 475 if (MultiClass *MC = ParseMultiClassID()) 476 Result.Rec = &MC->Rec; 477 } else { 478 Result.Rec = ParseClassID(); 479 } 480 if (Result.Rec == 0) return Result; 481 482 // If there is no template arg list, we're done. 483 if (Lex.getCode() != tgtok::less) { 484 Result.RefRange.End = Lex.getLoc(); 485 return Result; 486 } 487 Lex.Lex(); // Eat the '<' 488 489 if (Lex.getCode() == tgtok::greater) { 490 TokError("subclass reference requires a non-empty list of template values"); 491 Result.Rec = 0; 492 return Result; 493 } 494 495 Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); 496 if (Result.TemplateArgs.empty()) { 497 Result.Rec = 0; // Error parsing value list. 498 return Result; 499 } 500 501 if (Lex.getCode() != tgtok::greater) { 502 TokError("expected '>' in template value list"); 503 Result.Rec = 0; 504 return Result; 505 } 506 Lex.Lex(); 507 Result.RefRange.End = Lex.getLoc(); 508 509 return Result; 510} 511 512/// ParseSubMultiClassReference - Parse a reference to a subclass or to a 513/// templated submulticlass. This returns a SubMultiClassRefTy with a null 514/// Record* on error. 515/// 516/// SubMultiClassRef ::= MultiClassID 517/// SubMultiClassRef ::= MultiClassID '<' ValueList '>' 518/// 519SubMultiClassReference TGParser:: 520ParseSubMultiClassReference(MultiClass *CurMC) { 521 SubMultiClassReference Result; 522 Result.RefRange.Start = Lex.getLoc(); 523 524 Result.MC = ParseMultiClassID(); 525 if (Result.MC == 0) return Result; 526 527 // If there is no template arg list, we're done. 528 if (Lex.getCode() != tgtok::less) { 529 Result.RefRange.End = Lex.getLoc(); 530 return Result; 531 } 532 Lex.Lex(); // Eat the '<' 533 534 if (Lex.getCode() == tgtok::greater) { 535 TokError("subclass reference requires a non-empty list of template values"); 536 Result.MC = 0; 537 return Result; 538 } 539 540 Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); 541 if (Result.TemplateArgs.empty()) { 542 Result.MC = 0; // Error parsing value list. 543 return Result; 544 } 545 546 if (Lex.getCode() != tgtok::greater) { 547 TokError("expected '>' in template value list"); 548 Result.MC = 0; 549 return Result; 550 } 551 Lex.Lex(); 552 Result.RefRange.End = Lex.getLoc(); 553 554 return Result; 555} 556 557/// ParseRangePiece - Parse a bit/value range. 558/// RangePiece ::= INTVAL 559/// RangePiece ::= INTVAL '-' INTVAL 560/// RangePiece ::= INTVAL INTVAL 561bool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) { 562 if (Lex.getCode() != tgtok::IntVal) { 563 TokError("expected integer or bitrange"); 564 return true; 565 } 566 int64_t Start = Lex.getCurIntVal(); 567 int64_t End; 568 569 if (Start < 0) 570 return TokError("invalid range, cannot be negative"); 571 572 switch (Lex.Lex()) { // eat first character. 573 default: 574 Ranges.push_back(Start); 575 return false; 576 case tgtok::minus: 577 if (Lex.Lex() != tgtok::IntVal) { 578 TokError("expected integer value as end of range"); 579 return true; 580 } 581 End = Lex.getCurIntVal(); 582 break; 583 case tgtok::IntVal: 584 End = -Lex.getCurIntVal(); 585 break; 586 } 587 if (End < 0) 588 return TokError("invalid range, cannot be negative"); 589 Lex.Lex(); 590 591 // Add to the range. 592 if (Start < End) { 593 for (; Start <= End; ++Start) 594 Ranges.push_back(Start); 595 } else { 596 for (; Start >= End; --Start) 597 Ranges.push_back(Start); 598 } 599 return false; 600} 601 602/// ParseRangeList - Parse a list of scalars and ranges into scalar values. 603/// 604/// RangeList ::= RangePiece (',' RangePiece)* 605/// 606std::vector<unsigned> TGParser::ParseRangeList() { 607 std::vector<unsigned> Result; 608 609 // Parse the first piece. 610 if (ParseRangePiece(Result)) 611 return std::vector<unsigned>(); 612 while (Lex.getCode() == tgtok::comma) { 613 Lex.Lex(); // Eat the comma. 614 615 // Parse the next range piece. 616 if (ParseRangePiece(Result)) 617 return std::vector<unsigned>(); 618 } 619 return Result; 620} 621 622/// ParseOptionalRangeList - Parse either a range list in <>'s or nothing. 623/// OptionalRangeList ::= '<' RangeList '>' 624/// OptionalRangeList ::= /*empty*/ 625bool TGParser::ParseOptionalRangeList(std::vector<unsigned> &Ranges) { 626 if (Lex.getCode() != tgtok::less) 627 return false; 628 629 SMLoc StartLoc = Lex.getLoc(); 630 Lex.Lex(); // eat the '<' 631 632 // Parse the range list. 633 Ranges = ParseRangeList(); 634 if (Ranges.empty()) return true; 635 636 if (Lex.getCode() != tgtok::greater) { 637 TokError("expected '>' at end of range list"); 638 return Error(StartLoc, "to match this '<'"); 639 } 640 Lex.Lex(); // eat the '>'. 641 return false; 642} 643 644/// ParseOptionalBitList - Parse either a bit list in {}'s or nothing. 645/// OptionalBitList ::= '{' RangeList '}' 646/// OptionalBitList ::= /*empty*/ 647bool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) { 648 if (Lex.getCode() != tgtok::l_brace) 649 return false; 650 651 SMLoc StartLoc = Lex.getLoc(); 652 Lex.Lex(); // eat the '{' 653 654 // Parse the range list. 655 Ranges = ParseRangeList(); 656 if (Ranges.empty()) return true; 657 658 if (Lex.getCode() != tgtok::r_brace) { 659 TokError("expected '}' at end of bit list"); 660 return Error(StartLoc, "to match this '{'"); 661 } 662 Lex.Lex(); // eat the '}'. 663 return false; 664} 665 666 667/// ParseType - Parse and return a tblgen type. This returns null on error. 668/// 669/// Type ::= STRING // string type 670/// Type ::= CODE // code type 671/// Type ::= BIT // bit type 672/// Type ::= BITS '<' INTVAL '>' // bits<x> type 673/// Type ::= INT // int type 674/// Type ::= LIST '<' Type '>' // list<x> type 675/// Type ::= DAG // dag type 676/// Type ::= ClassID // Record Type 677/// 678RecTy *TGParser::ParseType() { 679 switch (Lex.getCode()) { 680 default: TokError("Unknown token when expecting a type"); return 0; 681 case tgtok::String: Lex.Lex(); return StringRecTy::get(); 682 case tgtok::Code: Lex.Lex(); return StringRecTy::get(); 683 case tgtok::Bit: Lex.Lex(); return BitRecTy::get(); 684 case tgtok::Int: Lex.Lex(); return IntRecTy::get(); 685 case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); 686 case tgtok::Id: 687 if (Record *R = ParseClassID()) return RecordRecTy::get(R); 688 return 0; 689 case tgtok::Bits: { 690 if (Lex.Lex() != tgtok::less) { // Eat 'bits' 691 TokError("expected '<' after bits type"); 692 return 0; 693 } 694 if (Lex.Lex() != tgtok::IntVal) { // Eat '<' 695 TokError("expected integer in bits<n> type"); 696 return 0; 697 } 698 uint64_t Val = Lex.getCurIntVal(); 699 if (Lex.Lex() != tgtok::greater) { // Eat count. 700 TokError("expected '>' at end of bits<n> type"); 701 return 0; 702 } 703 Lex.Lex(); // Eat '>' 704 return BitsRecTy::get(Val); 705 } 706 case tgtok::List: { 707 if (Lex.Lex() != tgtok::less) { // Eat 'bits' 708 TokError("expected '<' after list type"); 709 return 0; 710 } 711 Lex.Lex(); // Eat '<' 712 RecTy *SubType = ParseType(); 713 if (SubType == 0) return 0; 714 715 if (Lex.getCode() != tgtok::greater) { 716 TokError("expected '>' at end of list<ty> type"); 717 return 0; 718 } 719 Lex.Lex(); // Eat '>' 720 return ListRecTy::get(SubType); 721 } 722 } 723} 724 725/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID 726/// has already been read. 727Init *TGParser::ParseIDValue(Record *CurRec, 728 const std::string &Name, SMLoc NameLoc, 729 IDParseMode Mode) { 730 if (CurRec) { 731 if (const RecordVal *RV = CurRec->getValue(Name)) 732 return VarInit::get(Name, RV->getType()); 733 734 Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":"); 735 736 if (CurMultiClass) 737 TemplateArgName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, 738 "::"); 739 740 if (CurRec->isTemplateArg(TemplateArgName)) { 741 const RecordVal *RV = CurRec->getValue(TemplateArgName); 742 assert(RV && "Template arg doesn't exist??"); 743 return VarInit::get(TemplateArgName, RV->getType()); 744 } 745 } 746 747 if (CurMultiClass) { 748 Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, 749 "::"); 750 751 if (CurMultiClass->Rec.isTemplateArg(MCName)) { 752 const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 753 assert(RV && "Template arg doesn't exist??"); 754 return VarInit::get(MCName, RV->getType()); 755 } 756 } 757 758 // If this is in a foreach loop, make sure it's not a loop iterator 759 for (LoopVector::iterator i = Loops.begin(), iend = Loops.end(); 760 i != iend; 761 ++i) { 762 VarInit *IterVar = dyn_cast<VarInit>(i->IterVar); 763 if (IterVar && IterVar->getName() == Name) 764 return IterVar; 765 } 766 767 if (Mode == ParseNameMode) 768 return StringInit::get(Name); 769 770 if (Record *D = Records.getDef(Name)) 771 return DefInit::get(D); 772 773 if (Mode == ParseValueMode) { 774 Error(NameLoc, "Variable not defined: '" + Name + "'"); 775 return 0; 776 } 777 778 return StringInit::get(Name); 779} 780 781/// ParseOperation - Parse an operator. This returns null on error. 782/// 783/// Operation ::= XOperator ['<' Type '>'] '(' Args ')' 784/// 785Init *TGParser::ParseOperation(Record *CurRec) { 786 switch (Lex.getCode()) { 787 default: 788 TokError("unknown operation"); 789 return 0; 790 case tgtok::XHead: 791 case tgtok::XTail: 792 case tgtok::XEmpty: 793 case tgtok::XCast: { // Value ::= !unop '(' Value ')' 794 UnOpInit::UnaryOp Code; 795 RecTy *Type = 0; 796 797 switch (Lex.getCode()) { 798 default: llvm_unreachable("Unhandled code!"); 799 case tgtok::XCast: 800 Lex.Lex(); // eat the operation 801 Code = UnOpInit::CAST; 802 803 Type = ParseOperatorType(); 804 805 if (Type == 0) { 806 TokError("did not get type for unary operator"); 807 return 0; 808 } 809 810 break; 811 case tgtok::XHead: 812 Lex.Lex(); // eat the operation 813 Code = UnOpInit::HEAD; 814 break; 815 case tgtok::XTail: 816 Lex.Lex(); // eat the operation 817 Code = UnOpInit::TAIL; 818 break; 819 case tgtok::XEmpty: 820 Lex.Lex(); // eat the operation 821 Code = UnOpInit::EMPTY; 822 Type = IntRecTy::get(); 823 break; 824 } 825 if (Lex.getCode() != tgtok::l_paren) { 826 TokError("expected '(' after unary operator"); 827 return 0; 828 } 829 Lex.Lex(); // eat the '(' 830 831 Init *LHS = ParseValue(CurRec); 832 if (LHS == 0) return 0; 833 834 if (Code == UnOpInit::HEAD 835 || Code == UnOpInit::TAIL 836 || Code == UnOpInit::EMPTY) { 837 ListInit *LHSl = dyn_cast<ListInit>(LHS); 838 StringInit *LHSs = dyn_cast<StringInit>(LHS); 839 TypedInit *LHSt = dyn_cast<TypedInit>(LHS); 840 if (LHSl == 0 && LHSs == 0 && LHSt == 0) { 841 TokError("expected list or string type argument in unary operator"); 842 return 0; 843 } 844 if (LHSt) { 845 ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); 846 StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType()); 847 if (LType == 0 && SType == 0) { 848 TokError("expected list or string type argumnet in unary operator"); 849 return 0; 850 } 851 } 852 853 if (Code == UnOpInit::HEAD 854 || Code == UnOpInit::TAIL) { 855 if (LHSl == 0 && LHSt == 0) { 856 TokError("expected list type argumnet in unary operator"); 857 return 0; 858 } 859 860 if (LHSl && LHSl->getSize() == 0) { 861 TokError("empty list argument in unary operator"); 862 return 0; 863 } 864 if (LHSl) { 865 Init *Item = LHSl->getElement(0); 866 TypedInit *Itemt = dyn_cast<TypedInit>(Item); 867 if (Itemt == 0) { 868 TokError("untyped list element in unary operator"); 869 return 0; 870 } 871 if (Code == UnOpInit::HEAD) { 872 Type = Itemt->getType(); 873 } else { 874 Type = ListRecTy::get(Itemt->getType()); 875 } 876 } else { 877 assert(LHSt && "expected list type argument in unary operator"); 878 ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType()); 879 if (LType == 0) { 880 TokError("expected list type argumnet in unary operator"); 881 return 0; 882 } 883 if (Code == UnOpInit::HEAD) { 884 Type = LType->getElementType(); 885 } else { 886 Type = LType; 887 } 888 } 889 } 890 } 891 892 if (Lex.getCode() != tgtok::r_paren) { 893 TokError("expected ')' in unary operator"); 894 return 0; 895 } 896 Lex.Lex(); // eat the ')' 897 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass); 898 } 899 900 case tgtok::XConcat: 901 case tgtok::XADD: 902 case tgtok::XSRA: 903 case tgtok::XSRL: 904 case tgtok::XSHL: 905 case tgtok::XEq: 906 case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')' 907 tgtok::TokKind OpTok = Lex.getCode(); 908 SMLoc OpLoc = Lex.getLoc(); 909 Lex.Lex(); // eat the operation 910 911 BinOpInit::BinaryOp Code; 912 RecTy *Type = 0; 913 914 switch (OpTok) { 915 default: llvm_unreachable("Unhandled code!"); 916 case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break; 917 case tgtok::XADD: Code = BinOpInit::ADD; Type = IntRecTy::get(); break; 918 case tgtok::XSRA: Code = BinOpInit::SRA; Type = IntRecTy::get(); break; 919 case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break; 920 case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break; 921 case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break; 922 case tgtok::XStrConcat: 923 Code = BinOpInit::STRCONCAT; 924 Type = StringRecTy::get(); 925 break; 926 } 927 928 if (Lex.getCode() != tgtok::l_paren) { 929 TokError("expected '(' after binary operator"); 930 return 0; 931 } 932 Lex.Lex(); // eat the '(' 933 934 SmallVector<Init*, 2> InitList; 935 936 InitList.push_back(ParseValue(CurRec)); 937 if (InitList.back() == 0) return 0; 938 939 while (Lex.getCode() == tgtok::comma) { 940 Lex.Lex(); // eat the ',' 941 942 InitList.push_back(ParseValue(CurRec)); 943 if (InitList.back() == 0) return 0; 944 } 945 946 if (Lex.getCode() != tgtok::r_paren) { 947 TokError("expected ')' in operator"); 948 return 0; 949 } 950 Lex.Lex(); // eat the ')' 951 952 // We allow multiple operands to associative operators like !strconcat as 953 // shorthand for nesting them. 954 if (Code == BinOpInit::STRCONCAT) { 955 while (InitList.size() > 2) { 956 Init *RHS = InitList.pop_back_val(); 957 RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type)) 958 ->Fold(CurRec, CurMultiClass); 959 InitList.back() = RHS; 960 } 961 } 962 963 if (InitList.size() == 2) 964 return (BinOpInit::get(Code, InitList[0], InitList[1], Type)) 965 ->Fold(CurRec, CurMultiClass); 966 967 Error(OpLoc, "expected two operands to operator"); 968 return 0; 969 } 970 971 case tgtok::XIf: 972 case tgtok::XForEach: 973 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 974 TernOpInit::TernaryOp Code; 975 RecTy *Type = 0; 976 977 tgtok::TokKind LexCode = Lex.getCode(); 978 Lex.Lex(); // eat the operation 979 switch (LexCode) { 980 default: llvm_unreachable("Unhandled code!"); 981 case tgtok::XIf: 982 Code = TernOpInit::IF; 983 break; 984 case tgtok::XForEach: 985 Code = TernOpInit::FOREACH; 986 break; 987 case tgtok::XSubst: 988 Code = TernOpInit::SUBST; 989 break; 990 } 991 if (Lex.getCode() != tgtok::l_paren) { 992 TokError("expected '(' after ternary operator"); 993 return 0; 994 } 995 Lex.Lex(); // eat the '(' 996 997 Init *LHS = ParseValue(CurRec); 998 if (LHS == 0) return 0; 999 1000 if (Lex.getCode() != tgtok::comma) { 1001 TokError("expected ',' in ternary operator"); 1002 return 0; 1003 } 1004 Lex.Lex(); // eat the ',' 1005 1006 Init *MHS = ParseValue(CurRec); 1007 if (MHS == 0) return 0; 1008 1009 if (Lex.getCode() != tgtok::comma) { 1010 TokError("expected ',' in ternary operator"); 1011 return 0; 1012 } 1013 Lex.Lex(); // eat the ',' 1014 1015 Init *RHS = ParseValue(CurRec); 1016 if (RHS == 0) return 0; 1017 1018 if (Lex.getCode() != tgtok::r_paren) { 1019 TokError("expected ')' in binary operator"); 1020 return 0; 1021 } 1022 Lex.Lex(); // eat the ')' 1023 1024 switch (LexCode) { 1025 default: llvm_unreachable("Unhandled code!"); 1026 case tgtok::XIf: { 1027 RecTy *MHSTy = 0; 1028 RecTy *RHSTy = 0; 1029 1030 if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS)) 1031 MHSTy = MHSt->getType(); 1032 if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS)) 1033 MHSTy = BitsRecTy::get(MHSbits->getNumBits()); 1034 if (isa<BitInit>(MHS)) 1035 MHSTy = BitRecTy::get(); 1036 1037 if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS)) 1038 RHSTy = RHSt->getType(); 1039 if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS)) 1040 RHSTy = BitsRecTy::get(RHSbits->getNumBits()); 1041 if (isa<BitInit>(RHS)) 1042 RHSTy = BitRecTy::get(); 1043 1044 // For UnsetInit, it's typed from the other hand. 1045 if (isa<UnsetInit>(MHS)) 1046 MHSTy = RHSTy; 1047 if (isa<UnsetInit>(RHS)) 1048 RHSTy = MHSTy; 1049 1050 if (!MHSTy || !RHSTy) { 1051 TokError("could not get type for !if"); 1052 return 0; 1053 } 1054 1055 if (MHSTy->typeIsConvertibleTo(RHSTy)) { 1056 Type = RHSTy; 1057 } else if (RHSTy->typeIsConvertibleTo(MHSTy)) { 1058 Type = MHSTy; 1059 } else { 1060 TokError("inconsistent types for !if"); 1061 return 0; 1062 } 1063 break; 1064 } 1065 case tgtok::XForEach: { 1066 TypedInit *MHSt = dyn_cast<TypedInit>(MHS); 1067 if (MHSt == 0) { 1068 TokError("could not get type for !foreach"); 1069 return 0; 1070 } 1071 Type = MHSt->getType(); 1072 break; 1073 } 1074 case tgtok::XSubst: { 1075 TypedInit *RHSt = dyn_cast<TypedInit>(RHS); 1076 if (RHSt == 0) { 1077 TokError("could not get type for !subst"); 1078 return 0; 1079 } 1080 Type = RHSt->getType(); 1081 break; 1082 } 1083 } 1084 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec, 1085 CurMultiClass); 1086 } 1087 } 1088} 1089 1090/// ParseOperatorType - Parse a type for an operator. This returns 1091/// null on error. 1092/// 1093/// OperatorType ::= '<' Type '>' 1094/// 1095RecTy *TGParser::ParseOperatorType() { 1096 RecTy *Type = 0; 1097 1098 if (Lex.getCode() != tgtok::less) { 1099 TokError("expected type name for operator"); 1100 return 0; 1101 } 1102 Lex.Lex(); // eat the < 1103 1104 Type = ParseType(); 1105 1106 if (Type == 0) { 1107 TokError("expected type name for operator"); 1108 return 0; 1109 } 1110 1111 if (Lex.getCode() != tgtok::greater) { 1112 TokError("expected type name for operator"); 1113 return 0; 1114 } 1115 Lex.Lex(); // eat the > 1116 1117 return Type; 1118} 1119 1120 1121/// ParseSimpleValue - Parse a tblgen value. This returns null on error. 1122/// 1123/// SimpleValue ::= IDValue 1124/// SimpleValue ::= INTVAL 1125/// SimpleValue ::= STRVAL+ 1126/// SimpleValue ::= CODEFRAGMENT 1127/// SimpleValue ::= '?' 1128/// SimpleValue ::= '{' ValueList '}' 1129/// SimpleValue ::= ID '<' ValueListNE '>' 1130/// SimpleValue ::= '[' ValueList ']' 1131/// SimpleValue ::= '(' IDValue DagArgList ')' 1132/// SimpleValue ::= CONCATTOK '(' Value ',' Value ')' 1133/// SimpleValue ::= ADDTOK '(' Value ',' Value ')' 1134/// SimpleValue ::= SHLTOK '(' Value ',' Value ')' 1135/// SimpleValue ::= SRATOK '(' Value ',' Value ')' 1136/// SimpleValue ::= SRLTOK '(' Value ',' Value ')' 1137/// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' 1138/// 1139Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType, 1140 IDParseMode Mode) { 1141 Init *R = 0; 1142 switch (Lex.getCode()) { 1143 default: TokError("Unknown token when parsing a value"); break; 1144 case tgtok::paste: 1145 // This is a leading paste operation. This is deprecated but 1146 // still exists in some .td files. Ignore it. 1147 Lex.Lex(); // Skip '#'. 1148 return ParseSimpleValue(CurRec, ItemType, Mode); 1149 case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break; 1150 case tgtok::StrVal: { 1151 std::string Val = Lex.getCurStrVal(); 1152 Lex.Lex(); 1153 1154 // Handle multiple consecutive concatenated strings. 1155 while (Lex.getCode() == tgtok::StrVal) { 1156 Val += Lex.getCurStrVal(); 1157 Lex.Lex(); 1158 } 1159 1160 R = StringInit::get(Val); 1161 break; 1162 } 1163 case tgtok::CodeFragment: 1164 R = StringInit::get(Lex.getCurStrVal()); 1165 Lex.Lex(); 1166 break; 1167 case tgtok::question: 1168 R = UnsetInit::get(); 1169 Lex.Lex(); 1170 break; 1171 case tgtok::Id: { 1172 SMLoc NameLoc = Lex.getLoc(); 1173 std::string Name = Lex.getCurStrVal(); 1174 if (Lex.Lex() != tgtok::less) // consume the Id. 1175 return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue 1176 1177 // Value ::= ID '<' ValueListNE '>' 1178 if (Lex.Lex() == tgtok::greater) { 1179 TokError("expected non-empty value list"); 1180 return 0; 1181 } 1182 1183 // This is a CLASS<initvalslist> expression. This is supposed to synthesize 1184 // a new anonymous definition, deriving from CLASS<initvalslist> with no 1185 // body. 1186 Record *Class = Records.getClass(Name); 1187 if (!Class) { 1188 Error(NameLoc, "Expected a class name, got '" + Name + "'"); 1189 return 0; 1190 } 1191 1192 std::vector<Init*> ValueList = ParseValueList(CurRec, Class); 1193 if (ValueList.empty()) return 0; 1194 1195 if (Lex.getCode() != tgtok::greater) { 1196 TokError("expected '>' at end of value list"); 1197 return 0; 1198 } 1199 Lex.Lex(); // eat the '>' 1200 SMLoc EndLoc = Lex.getLoc(); 1201 1202 // Create the new record, set it as CurRec temporarily. 1203 Record *NewRec = new Record(GetNewAnonymousName(), NameLoc, Records, 1204 /*IsAnonymous=*/true); 1205 SubClassReference SCRef; 1206 SCRef.RefRange = SMRange(NameLoc, EndLoc); 1207 SCRef.Rec = Class; 1208 SCRef.TemplateArgs = ValueList; 1209 // Add info about the subclass to NewRec. 1210 if (AddSubClass(NewRec, SCRef)) 1211 return 0; 1212 if (!CurMultiClass) { 1213 NewRec->resolveReferences(); 1214 Records.addDef(NewRec); 1215 } else { 1216 // Otherwise, we're inside a multiclass, add it to the multiclass. 1217 CurMultiClass->DefPrototypes.push_back(NewRec); 1218 1219 // Copy the template arguments for the multiclass into the def. 1220 const std::vector<Init *> &TArgs = 1221 CurMultiClass->Rec.getTemplateArgs(); 1222 1223 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1224 const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); 1225 assert(RV && "Template arg doesn't exist?"); 1226 NewRec->addValue(*RV); 1227 } 1228 1229 // We can't return the prototype def here, instead return: 1230 // !cast<ItemType>(!strconcat(NAME, AnonName)). 1231 const RecordVal *MCNameRV = CurMultiClass->Rec.getValue("NAME"); 1232 assert(MCNameRV && "multiclass record must have a NAME"); 1233 1234 return UnOpInit::get(UnOpInit::CAST, 1235 BinOpInit::get(BinOpInit::STRCONCAT, 1236 VarInit::get(MCNameRV->getName(), 1237 MCNameRV->getType()), 1238 NewRec->getNameInit(), 1239 StringRecTy::get()), 1240 Class->getDefInit()->getType()); 1241 } 1242 1243 // The result of the expression is a reference to the new record. 1244 return DefInit::get(NewRec); 1245 } 1246 case tgtok::l_brace: { // Value ::= '{' ValueList '}' 1247 SMLoc BraceLoc = Lex.getLoc(); 1248 Lex.Lex(); // eat the '{' 1249 std::vector<Init*> Vals; 1250 1251 if (Lex.getCode() != tgtok::r_brace) { 1252 Vals = ParseValueList(CurRec); 1253 if (Vals.empty()) return 0; 1254 } 1255 if (Lex.getCode() != tgtok::r_brace) { 1256 TokError("expected '}' at end of bit list value"); 1257 return 0; 1258 } 1259 Lex.Lex(); // eat the '}' 1260 1261 SmallVector<Init *, 16> NewBits(Vals.size()); 1262 1263 for (unsigned i = 0, e = Vals.size(); i != e; ++i) { 1264 Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); 1265 if (Bit == 0) { 1266 Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ 1267 ") is not convertable to a bit"); 1268 return 0; 1269 } 1270 NewBits[Vals.size()-i-1] = Bit; 1271 } 1272 return BitsInit::get(NewBits); 1273 } 1274 case tgtok::l_square: { // Value ::= '[' ValueList ']' 1275 Lex.Lex(); // eat the '[' 1276 std::vector<Init*> Vals; 1277 1278 RecTy *DeducedEltTy = 0; 1279 ListRecTy *GivenListTy = 0; 1280 1281 if (ItemType != 0) { 1282 ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType); 1283 if (ListType == 0) { 1284 std::string s; 1285 raw_string_ostream ss(s); 1286 ss << "Type mismatch for list, expected list type, got " 1287 << ItemType->getAsString(); 1288 TokError(ss.str()); 1289 return 0; 1290 } 1291 GivenListTy = ListType; 1292 } 1293 1294 if (Lex.getCode() != tgtok::r_square) { 1295 Vals = ParseValueList(CurRec, 0, 1296 GivenListTy ? GivenListTy->getElementType() : 0); 1297 if (Vals.empty()) return 0; 1298 } 1299 if (Lex.getCode() != tgtok::r_square) { 1300 TokError("expected ']' at end of list value"); 1301 return 0; 1302 } 1303 Lex.Lex(); // eat the ']' 1304 1305 RecTy *GivenEltTy = 0; 1306 if (Lex.getCode() == tgtok::less) { 1307 // Optional list element type 1308 Lex.Lex(); // eat the '<' 1309 1310 GivenEltTy = ParseType(); 1311 if (GivenEltTy == 0) { 1312 // Couldn't parse element type 1313 return 0; 1314 } 1315 1316 if (Lex.getCode() != tgtok::greater) { 1317 TokError("expected '>' at end of list element type"); 1318 return 0; 1319 } 1320 Lex.Lex(); // eat the '>' 1321 } 1322 1323 // Check elements 1324 RecTy *EltTy = 0; 1325 for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); 1326 i != ie; 1327 ++i) { 1328 TypedInit *TArg = dyn_cast<TypedInit>(*i); 1329 if (TArg == 0) { 1330 TokError("Untyped list element"); 1331 return 0; 1332 } 1333 if (EltTy != 0) { 1334 EltTy = resolveTypes(EltTy, TArg->getType()); 1335 if (EltTy == 0) { 1336 TokError("Incompatible types in list elements"); 1337 return 0; 1338 } 1339 } else { 1340 EltTy = TArg->getType(); 1341 } 1342 } 1343 1344 if (GivenEltTy != 0) { 1345 if (EltTy != 0) { 1346 // Verify consistency 1347 if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { 1348 TokError("Incompatible types in list elements"); 1349 return 0; 1350 } 1351 } 1352 EltTy = GivenEltTy; 1353 } 1354 1355 if (EltTy == 0) { 1356 if (ItemType == 0) { 1357 TokError("No type for list"); 1358 return 0; 1359 } 1360 DeducedEltTy = GivenListTy->getElementType(); 1361 } else { 1362 // Make sure the deduced type is compatible with the given type 1363 if (GivenListTy) { 1364 if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { 1365 TokError("Element type mismatch for list"); 1366 return 0; 1367 } 1368 } 1369 DeducedEltTy = EltTy; 1370 } 1371 1372 return ListInit::get(Vals, DeducedEltTy); 1373 } 1374 case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')' 1375 Lex.Lex(); // eat the '(' 1376 if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) { 1377 TokError("expected identifier in dag init"); 1378 return 0; 1379 } 1380 1381 Init *Operator = ParseValue(CurRec); 1382 if (Operator == 0) return 0; 1383 1384 // If the operator name is present, parse it. 1385 std::string OperatorName; 1386 if (Lex.getCode() == tgtok::colon) { 1387 if (Lex.Lex() != tgtok::VarName) { // eat the ':' 1388 TokError("expected variable name in dag operator"); 1389 return 0; 1390 } 1391 OperatorName = Lex.getCurStrVal(); 1392 Lex.Lex(); // eat the VarName. 1393 } 1394 1395 std::vector<std::pair<llvm::Init*, std::string> > DagArgs; 1396 if (Lex.getCode() != tgtok::r_paren) { 1397 DagArgs = ParseDagArgList(CurRec); 1398 if (DagArgs.empty()) return 0; 1399 } 1400 1401 if (Lex.getCode() != tgtok::r_paren) { 1402 TokError("expected ')' in dag init"); 1403 return 0; 1404 } 1405 Lex.Lex(); // eat the ')' 1406 1407 return DagInit::get(Operator, OperatorName, DagArgs); 1408 } 1409 1410 case tgtok::XHead: 1411 case tgtok::XTail: 1412 case tgtok::XEmpty: 1413 case tgtok::XCast: // Value ::= !unop '(' Value ')' 1414 case tgtok::XConcat: 1415 case tgtok::XADD: 1416 case tgtok::XSRA: 1417 case tgtok::XSRL: 1418 case tgtok::XSHL: 1419 case tgtok::XEq: 1420 case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')' 1421 case tgtok::XIf: 1422 case tgtok::XForEach: 1423 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 1424 return ParseOperation(CurRec); 1425 } 1426 } 1427 1428 return R; 1429} 1430 1431/// ParseValue - Parse a tblgen value. This returns null on error. 1432/// 1433/// Value ::= SimpleValue ValueSuffix* 1434/// ValueSuffix ::= '{' BitList '}' 1435/// ValueSuffix ::= '[' BitList ']' 1436/// ValueSuffix ::= '.' ID 1437/// 1438Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) { 1439 Init *Result = ParseSimpleValue(CurRec, ItemType, Mode); 1440 if (Result == 0) return 0; 1441 1442 // Parse the suffixes now if present. 1443 while (1) { 1444 switch (Lex.getCode()) { 1445 default: return Result; 1446 case tgtok::l_brace: { 1447 if (Mode == ParseNameMode || Mode == ParseForeachMode) 1448 // This is the beginning of the object body. 1449 return Result; 1450 1451 SMLoc CurlyLoc = Lex.getLoc(); 1452 Lex.Lex(); // eat the '{' 1453 std::vector<unsigned> Ranges = ParseRangeList(); 1454 if (Ranges.empty()) return 0; 1455 1456 // Reverse the bitlist. 1457 std::reverse(Ranges.begin(), Ranges.end()); 1458 Result = Result->convertInitializerBitRange(Ranges); 1459 if (Result == 0) { 1460 Error(CurlyLoc, "Invalid bit range for value"); 1461 return 0; 1462 } 1463 1464 // Eat the '}'. 1465 if (Lex.getCode() != tgtok::r_brace) { 1466 TokError("expected '}' at end of bit range list"); 1467 return 0; 1468 } 1469 Lex.Lex(); 1470 break; 1471 } 1472 case tgtok::l_square: { 1473 SMLoc SquareLoc = Lex.getLoc(); 1474 Lex.Lex(); // eat the '[' 1475 std::vector<unsigned> Ranges = ParseRangeList(); 1476 if (Ranges.empty()) return 0; 1477 1478 Result = Result->convertInitListSlice(Ranges); 1479 if (Result == 0) { 1480 Error(SquareLoc, "Invalid range for list slice"); 1481 return 0; 1482 } 1483 1484 // Eat the ']'. 1485 if (Lex.getCode() != tgtok::r_square) { 1486 TokError("expected ']' at end of list slice"); 1487 return 0; 1488 } 1489 Lex.Lex(); 1490 break; 1491 } 1492 case tgtok::period: 1493 if (Lex.Lex() != tgtok::Id) { // eat the . 1494 TokError("expected field identifier after '.'"); 1495 return 0; 1496 } 1497 if (!Result->getFieldType(Lex.getCurStrVal())) { 1498 TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + 1499 Result->getAsString() + "'"); 1500 return 0; 1501 } 1502 Result = FieldInit::get(Result, Lex.getCurStrVal()); 1503 Lex.Lex(); // eat field name 1504 break; 1505 1506 case tgtok::paste: 1507 SMLoc PasteLoc = Lex.getLoc(); 1508 1509 // Create a !strconcat() operation, first casting each operand to 1510 // a string if necessary. 1511 1512 TypedInit *LHS = dyn_cast<TypedInit>(Result); 1513 if (!LHS) { 1514 Error(PasteLoc, "LHS of paste is not typed!"); 1515 return 0; 1516 } 1517 1518 if (LHS->getType() != StringRecTy::get()) { 1519 LHS = UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get()); 1520 } 1521 1522 TypedInit *RHS = 0; 1523 1524 Lex.Lex(); // Eat the '#'. 1525 switch (Lex.getCode()) { 1526 case tgtok::colon: 1527 case tgtok::semi: 1528 case tgtok::l_brace: 1529 // These are all of the tokens that can begin an object body. 1530 // Some of these can also begin values but we disallow those cases 1531 // because they are unlikely to be useful. 1532 1533 // Trailing paste, concat with an empty string. 1534 RHS = StringInit::get(""); 1535 break; 1536 1537 default: 1538 Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode); 1539 RHS = dyn_cast<TypedInit>(RHSResult); 1540 if (!RHS) { 1541 Error(PasteLoc, "RHS of paste is not typed!"); 1542 return 0; 1543 } 1544 1545 if (RHS->getType() != StringRecTy::get()) { 1546 RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get()); 1547 } 1548 1549 break; 1550 } 1551 1552 Result = BinOpInit::get(BinOpInit::STRCONCAT, LHS, RHS, 1553 StringRecTy::get())->Fold(CurRec, CurMultiClass); 1554 break; 1555 } 1556 } 1557} 1558 1559/// ParseDagArgList - Parse the argument list for a dag literal expression. 1560/// 1561/// DagArg ::= Value (':' VARNAME)? 1562/// DagArg ::= VARNAME 1563/// DagArgList ::= DagArg 1564/// DagArgList ::= DagArgList ',' DagArg 1565std::vector<std::pair<llvm::Init*, std::string> > 1566TGParser::ParseDagArgList(Record *CurRec) { 1567 std::vector<std::pair<llvm::Init*, std::string> > Result; 1568 1569 while (1) { 1570 // DagArg ::= VARNAME 1571 if (Lex.getCode() == tgtok::VarName) { 1572 // A missing value is treated like '?'. 1573 Result.push_back(std::make_pair(UnsetInit::get(), Lex.getCurStrVal())); 1574 Lex.Lex(); 1575 } else { 1576 // DagArg ::= Value (':' VARNAME)? 1577 Init *Val = ParseValue(CurRec); 1578 if (Val == 0) 1579 return std::vector<std::pair<llvm::Init*, std::string> >(); 1580 1581 // If the variable name is present, add it. 1582 std::string VarName; 1583 if (Lex.getCode() == tgtok::colon) { 1584 if (Lex.Lex() != tgtok::VarName) { // eat the ':' 1585 TokError("expected variable name in dag literal"); 1586 return std::vector<std::pair<llvm::Init*, std::string> >(); 1587 } 1588 VarName = Lex.getCurStrVal(); 1589 Lex.Lex(); // eat the VarName. 1590 } 1591 1592 Result.push_back(std::make_pair(Val, VarName)); 1593 } 1594 if (Lex.getCode() != tgtok::comma) break; 1595 Lex.Lex(); // eat the ',' 1596 } 1597 1598 return Result; 1599} 1600 1601 1602/// ParseValueList - Parse a comma separated list of values, returning them as a 1603/// vector. Note that this always expects to be able to parse at least one 1604/// value. It returns an empty list if this is not possible. 1605/// 1606/// ValueList ::= Value (',' Value) 1607/// 1608std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, 1609 RecTy *EltTy) { 1610 std::vector<Init*> Result; 1611 RecTy *ItemType = EltTy; 1612 unsigned int ArgN = 0; 1613 if (ArgsRec != 0 && EltTy == 0) { 1614 const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs(); 1615 if (!TArgs.size()) { 1616 TokError("template argument provided to non-template class"); 1617 return std::vector<Init*>(); 1618 } 1619 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1620 if (!RV) { 1621 errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN] 1622 << ")\n"; 1623 } 1624 assert(RV && "Template argument record not found??"); 1625 ItemType = RV->getType(); 1626 ++ArgN; 1627 } 1628 Result.push_back(ParseValue(CurRec, ItemType)); 1629 if (Result.back() == 0) return std::vector<Init*>(); 1630 1631 while (Lex.getCode() == tgtok::comma) { 1632 Lex.Lex(); // Eat the comma 1633 1634 if (ArgsRec != 0 && EltTy == 0) { 1635 const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs(); 1636 if (ArgN >= TArgs.size()) { 1637 TokError("too many template arguments"); 1638 return std::vector<Init*>(); 1639 } 1640 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1641 assert(RV && "Template argument record not found??"); 1642 ItemType = RV->getType(); 1643 ++ArgN; 1644 } 1645 Result.push_back(ParseValue(CurRec, ItemType)); 1646 if (Result.back() == 0) return std::vector<Init*>(); 1647 } 1648 1649 return Result; 1650} 1651 1652 1653/// ParseDeclaration - Read a declaration, returning the name of field ID, or an 1654/// empty string on error. This can happen in a number of different context's, 1655/// including within a def or in the template args for a def (which which case 1656/// CurRec will be non-null) and within the template args for a multiclass (in 1657/// which case CurRec will be null, but CurMultiClass will be set). This can 1658/// also happen within a def that is within a multiclass, which will set both 1659/// CurRec and CurMultiClass. 1660/// 1661/// Declaration ::= FIELD? Type ID ('=' Value)? 1662/// 1663Init *TGParser::ParseDeclaration(Record *CurRec, 1664 bool ParsingTemplateArgs) { 1665 // Read the field prefix if present. 1666 bool HasField = Lex.getCode() == tgtok::Field; 1667 if (HasField) Lex.Lex(); 1668 1669 RecTy *Type = ParseType(); 1670 if (Type == 0) return 0; 1671 1672 if (Lex.getCode() != tgtok::Id) { 1673 TokError("Expected identifier in declaration"); 1674 return 0; 1675 } 1676 1677 SMLoc IdLoc = Lex.getLoc(); 1678 Init *DeclName = StringInit::get(Lex.getCurStrVal()); 1679 Lex.Lex(); 1680 1681 if (ParsingTemplateArgs) { 1682 if (CurRec) { 1683 DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":"); 1684 } else { 1685 assert(CurMultiClass); 1686 } 1687 if (CurMultiClass) 1688 DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName, 1689 "::"); 1690 } 1691 1692 // Add the value. 1693 if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField))) 1694 return 0; 1695 1696 // If a value is present, parse it. 1697 if (Lex.getCode() == tgtok::equal) { 1698 Lex.Lex(); 1699 SMLoc ValLoc = Lex.getLoc(); 1700 Init *Val = ParseValue(CurRec, Type); 1701 if (Val == 0 || 1702 SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val)) 1703 return 0; 1704 } 1705 1706 return DeclName; 1707} 1708 1709/// ParseForeachDeclaration - Read a foreach declaration, returning 1710/// the name of the declared object or a NULL Init on error. Return 1711/// the name of the parsed initializer list through ForeachListName. 1712/// 1713/// ForeachDeclaration ::= ID '=' '[' ValueList ']' 1714/// ForeachDeclaration ::= ID '=' '{' RangeList '}' 1715/// ForeachDeclaration ::= ID '=' RangePiece 1716/// 1717VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) { 1718 if (Lex.getCode() != tgtok::Id) { 1719 TokError("Expected identifier in foreach declaration"); 1720 return 0; 1721 } 1722 1723 Init *DeclName = StringInit::get(Lex.getCurStrVal()); 1724 Lex.Lex(); 1725 1726 // If a value is present, parse it. 1727 if (Lex.getCode() != tgtok::equal) { 1728 TokError("Expected '=' in foreach declaration"); 1729 return 0; 1730 } 1731 Lex.Lex(); // Eat the '=' 1732 1733 RecTy *IterType = 0; 1734 std::vector<unsigned> Ranges; 1735 1736 switch (Lex.getCode()) { 1737 default: TokError("Unknown token when expecting a range list"); return 0; 1738 case tgtok::l_square: { // '[' ValueList ']' 1739 Init *List = ParseSimpleValue(0, 0, ParseForeachMode); 1740 ForeachListValue = dyn_cast<ListInit>(List); 1741 if (ForeachListValue == 0) { 1742 TokError("Expected a Value list"); 1743 return 0; 1744 } 1745 RecTy *ValueType = ForeachListValue->getType(); 1746 ListRecTy *ListType = dyn_cast<ListRecTy>(ValueType); 1747 if (ListType == 0) { 1748 TokError("Value list is not of list type"); 1749 return 0; 1750 } 1751 IterType = ListType->getElementType(); 1752 break; 1753 } 1754 1755 case tgtok::IntVal: { // RangePiece. 1756 if (ParseRangePiece(Ranges)) 1757 return 0; 1758 break; 1759 } 1760 1761 case tgtok::l_brace: { // '{' RangeList '}' 1762 Lex.Lex(); // eat the '{' 1763 Ranges = ParseRangeList(); 1764 if (Lex.getCode() != tgtok::r_brace) { 1765 TokError("expected '}' at end of bit range list"); 1766 return 0; 1767 } 1768 Lex.Lex(); 1769 break; 1770 } 1771 } 1772 1773 if (!Ranges.empty()) { 1774 assert(!IterType && "Type already initialized?"); 1775 IterType = IntRecTy::get(); 1776 std::vector<Init*> Values; 1777 for (unsigned i = 0, e = Ranges.size(); i != e; ++i) 1778 Values.push_back(IntInit::get(Ranges[i])); 1779 ForeachListValue = ListInit::get(Values, IterType); 1780 } 1781 1782 if (!IterType) 1783 return 0; 1784 1785 return VarInit::get(DeclName, IterType); 1786} 1787 1788/// ParseTemplateArgList - Read a template argument list, which is a non-empty 1789/// sequence of template-declarations in <>'s. If CurRec is non-null, these are 1790/// template args for a def, which may or may not be in a multiclass. If null, 1791/// these are the template args for a multiclass. 1792/// 1793/// TemplateArgList ::= '<' Declaration (',' Declaration)* '>' 1794/// 1795bool TGParser::ParseTemplateArgList(Record *CurRec) { 1796 assert(Lex.getCode() == tgtok::less && "Not a template arg list!"); 1797 Lex.Lex(); // eat the '<' 1798 1799 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec; 1800 1801 // Read the first declaration. 1802 Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1803 if (TemplArg == 0) 1804 return true; 1805 1806 TheRecToAddTo->addTemplateArg(TemplArg); 1807 1808 while (Lex.getCode() == tgtok::comma) { 1809 Lex.Lex(); // eat the ',' 1810 1811 // Read the following declarations. 1812 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1813 if (TemplArg == 0) 1814 return true; 1815 TheRecToAddTo->addTemplateArg(TemplArg); 1816 } 1817 1818 if (Lex.getCode() != tgtok::greater) 1819 return TokError("expected '>' at end of template argument list"); 1820 Lex.Lex(); // eat the '>'. 1821 return false; 1822} 1823 1824 1825/// ParseBodyItem - Parse a single item at within the body of a def or class. 1826/// 1827/// BodyItem ::= Declaration ';' 1828/// BodyItem ::= LET ID OptionalBitList '=' Value ';' 1829bool TGParser::ParseBodyItem(Record *CurRec) { 1830 if (Lex.getCode() != tgtok::Let) { 1831 if (ParseDeclaration(CurRec, false) == 0) 1832 return true; 1833 1834 if (Lex.getCode() != tgtok::semi) 1835 return TokError("expected ';' after declaration"); 1836 Lex.Lex(); 1837 return false; 1838 } 1839 1840 // LET ID OptionalRangeList '=' Value ';' 1841 if (Lex.Lex() != tgtok::Id) 1842 return TokError("expected field identifier after let"); 1843 1844 SMLoc IdLoc = Lex.getLoc(); 1845 std::string FieldName = Lex.getCurStrVal(); 1846 Lex.Lex(); // eat the field name. 1847 1848 std::vector<unsigned> BitList; 1849 if (ParseOptionalBitList(BitList)) 1850 return true; 1851 std::reverse(BitList.begin(), BitList.end()); 1852 1853 if (Lex.getCode() != tgtok::equal) 1854 return TokError("expected '=' in let expression"); 1855 Lex.Lex(); // eat the '='. 1856 1857 RecordVal *Field = CurRec->getValue(FieldName); 1858 if (Field == 0) 1859 return TokError("Value '" + FieldName + "' unknown!"); 1860 1861 RecTy *Type = Field->getType(); 1862 1863 Init *Val = ParseValue(CurRec, Type); 1864 if (Val == 0) return true; 1865 1866 if (Lex.getCode() != tgtok::semi) 1867 return TokError("expected ';' after let expression"); 1868 Lex.Lex(); 1869 1870 return SetValue(CurRec, IdLoc, FieldName, BitList, Val); 1871} 1872 1873/// ParseBody - Read the body of a class or def. Return true on error, false on 1874/// success. 1875/// 1876/// Body ::= ';' 1877/// Body ::= '{' BodyList '}' 1878/// BodyList BodyItem* 1879/// 1880bool TGParser::ParseBody(Record *CurRec) { 1881 // If this is a null definition, just eat the semi and return. 1882 if (Lex.getCode() == tgtok::semi) { 1883 Lex.Lex(); 1884 return false; 1885 } 1886 1887 if (Lex.getCode() != tgtok::l_brace) 1888 return TokError("Expected ';' or '{' to start body"); 1889 // Eat the '{'. 1890 Lex.Lex(); 1891 1892 while (Lex.getCode() != tgtok::r_brace) 1893 if (ParseBodyItem(CurRec)) 1894 return true; 1895 1896 // Eat the '}'. 1897 Lex.Lex(); 1898 return false; 1899} 1900 1901/// \brief Apply the current let bindings to \a CurRec. 1902/// \returns true on error, false otherwise. 1903bool TGParser::ApplyLetStack(Record *CurRec) { 1904 for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 1905 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 1906 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 1907 LetStack[i][j].Bits, LetStack[i][j].Value)) 1908 return true; 1909 return false; 1910} 1911 1912/// ParseObjectBody - Parse the body of a def or class. This consists of an 1913/// optional ClassList followed by a Body. CurRec is the current def or class 1914/// that is being parsed. 1915/// 1916/// ObjectBody ::= BaseClassList Body 1917/// BaseClassList ::= /*empty*/ 1918/// BaseClassList ::= ':' BaseClassListNE 1919/// BaseClassListNE ::= SubClassRef (',' SubClassRef)* 1920/// 1921bool TGParser::ParseObjectBody(Record *CurRec) { 1922 // If there is a baseclass list, read it. 1923 if (Lex.getCode() == tgtok::colon) { 1924 Lex.Lex(); 1925 1926 // Read all of the subclasses. 1927 SubClassReference SubClass = ParseSubClassReference(CurRec, false); 1928 while (1) { 1929 // Check for error. 1930 if (SubClass.Rec == 0) return true; 1931 1932 // Add it. 1933 if (AddSubClass(CurRec, SubClass)) 1934 return true; 1935 1936 if (Lex.getCode() != tgtok::comma) break; 1937 Lex.Lex(); // eat ','. 1938 SubClass = ParseSubClassReference(CurRec, false); 1939 } 1940 } 1941 1942 if (ApplyLetStack(CurRec)) 1943 return true; 1944 1945 return ParseBody(CurRec); 1946} 1947 1948/// ParseDef - Parse and return a top level or multiclass def, return the record 1949/// corresponding to it. This returns null on error. 1950/// 1951/// DefInst ::= DEF ObjectName ObjectBody 1952/// 1953bool TGParser::ParseDef(MultiClass *CurMultiClass) { 1954 SMLoc DefLoc = Lex.getLoc(); 1955 assert(Lex.getCode() == tgtok::Def && "Unknown tok"); 1956 Lex.Lex(); // Eat the 'def' token. 1957 1958 // Parse ObjectName and make a record for it. 1959 Record *CurRec; 1960 Init *Name = ParseObjectName(CurMultiClass); 1961 if (Name) 1962 CurRec = new Record(Name, DefLoc, Records); 1963 else 1964 CurRec = new Record(GetNewAnonymousName(), DefLoc, Records, 1965 /*IsAnonymous=*/true); 1966 1967 if (!CurMultiClass && Loops.empty()) { 1968 // Top-level def definition. 1969 1970 // Ensure redefinition doesn't happen. 1971 if (Records.getDef(CurRec->getNameInitAsString())) { 1972 Error(DefLoc, "def '" + CurRec->getNameInitAsString() 1973 + "' already defined"); 1974 return true; 1975 } 1976 Records.addDef(CurRec); 1977 1978 if (ParseObjectBody(CurRec)) 1979 return true; 1980 } else if (CurMultiClass) { 1981 // Parse the body before adding this prototype to the DefPrototypes vector. 1982 // That way implicit definitions will be added to the DefPrototypes vector 1983 // before this object, instantiated prior to defs derived from this object, 1984 // and this available for indirect name resolution when defs derived from 1985 // this object are instantiated. 1986 if (ParseObjectBody(CurRec)) 1987 return true; 1988 1989 // Otherwise, a def inside a multiclass, add it to the multiclass. 1990 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i) 1991 if (CurMultiClass->DefPrototypes[i]->getNameInit() 1992 == CurRec->getNameInit()) { 1993 Error(DefLoc, "def '" + CurRec->getNameInitAsString() + 1994 "' already defined in this multiclass!"); 1995 return true; 1996 } 1997 CurMultiClass->DefPrototypes.push_back(CurRec); 1998 } else if (ParseObjectBody(CurRec)) 1999 return true; 2000 2001 if (CurMultiClass == 0) // Def's in multiclasses aren't really defs. 2002 // See Record::setName(). This resolve step will see any new name 2003 // for the def that might have been created when resolving 2004 // inheritance, values and arguments above. 2005 CurRec->resolveReferences(); 2006 2007 // If ObjectBody has template arguments, it's an error. 2008 assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?"); 2009 2010 if (CurMultiClass) { 2011 // Copy the template arguments for the multiclass into the def. 2012 const std::vector<Init *> &TArgs = 2013 CurMultiClass->Rec.getTemplateArgs(); 2014 2015 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 2016 const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); 2017 assert(RV && "Template arg doesn't exist?"); 2018 CurRec->addValue(*RV); 2019 } 2020 } 2021 2022 if (ProcessForeachDefs(CurRec, DefLoc)) { 2023 Error(DefLoc, 2024 "Could not process loops for def" + CurRec->getNameInitAsString()); 2025 return true; 2026 } 2027 2028 return false; 2029} 2030 2031/// ParseForeach - Parse a for statement. Return the record corresponding 2032/// to it. This returns true on error. 2033/// 2034/// Foreach ::= FOREACH Declaration IN '{ ObjectList '}' 2035/// Foreach ::= FOREACH Declaration IN Object 2036/// 2037bool TGParser::ParseForeach(MultiClass *CurMultiClass) { 2038 assert(Lex.getCode() == tgtok::Foreach && "Unknown tok"); 2039 Lex.Lex(); // Eat the 'for' token. 2040 2041 // Make a temporary object to record items associated with the for 2042 // loop. 2043 ListInit *ListValue = 0; 2044 VarInit *IterName = ParseForeachDeclaration(ListValue); 2045 if (IterName == 0) 2046 return TokError("expected declaration in for"); 2047 2048 if (Lex.getCode() != tgtok::In) 2049 return TokError("Unknown tok"); 2050 Lex.Lex(); // Eat the in 2051 2052 // Create a loop object and remember it. 2053 Loops.push_back(ForeachLoop(IterName, ListValue)); 2054 2055 if (Lex.getCode() != tgtok::l_brace) { 2056 // FOREACH Declaration IN Object 2057 if (ParseObject(CurMultiClass)) 2058 return true; 2059 } 2060 else { 2061 SMLoc BraceLoc = Lex.getLoc(); 2062 // Otherwise, this is a group foreach. 2063 Lex.Lex(); // eat the '{'. 2064 2065 // Parse the object list. 2066 if (ParseObjectList(CurMultiClass)) 2067 return true; 2068 2069 if (Lex.getCode() != tgtok::r_brace) { 2070 TokError("expected '}' at end of foreach command"); 2071 return Error(BraceLoc, "to match this '{'"); 2072 } 2073 Lex.Lex(); // Eat the } 2074 } 2075 2076 // We've processed everything in this loop. 2077 Loops.pop_back(); 2078 2079 return false; 2080} 2081 2082/// ParseClass - Parse a tblgen class definition. 2083/// 2084/// ClassInst ::= CLASS ID TemplateArgList? ObjectBody 2085/// 2086bool TGParser::ParseClass() { 2087 assert(Lex.getCode() == tgtok::Class && "Unexpected token!"); 2088 Lex.Lex(); 2089 2090 if (Lex.getCode() != tgtok::Id) 2091 return TokError("expected class name after 'class' keyword"); 2092 2093 Record *CurRec = Records.getClass(Lex.getCurStrVal()); 2094 if (CurRec) { 2095 // If the body was previously defined, this is an error. 2096 if (CurRec->getValues().size() > 1 || // Account for NAME. 2097 !CurRec->getSuperClasses().empty() || 2098 !CurRec->getTemplateArgs().empty()) 2099 return TokError("Class '" + CurRec->getNameInitAsString() 2100 + "' already defined"); 2101 } else { 2102 // If this is the first reference to this class, create and add it. 2103 CurRec = new Record(Lex.getCurStrVal(), Lex.getLoc(), Records); 2104 Records.addClass(CurRec); 2105 } 2106 Lex.Lex(); // eat the name. 2107 2108 // If there are template args, parse them. 2109 if (Lex.getCode() == tgtok::less) 2110 if (ParseTemplateArgList(CurRec)) 2111 return true; 2112 2113 // Finally, parse the object body. 2114 return ParseObjectBody(CurRec); 2115} 2116 2117/// ParseLetList - Parse a non-empty list of assignment expressions into a list 2118/// of LetRecords. 2119/// 2120/// LetList ::= LetItem (',' LetItem)* 2121/// LetItem ::= ID OptionalRangeList '=' Value 2122/// 2123std::vector<LetRecord> TGParser::ParseLetList() { 2124 std::vector<LetRecord> Result; 2125 2126 while (1) { 2127 if (Lex.getCode() != tgtok::Id) { 2128 TokError("expected identifier in let definition"); 2129 return std::vector<LetRecord>(); 2130 } 2131 std::string Name = Lex.getCurStrVal(); 2132 SMLoc NameLoc = Lex.getLoc(); 2133 Lex.Lex(); // Eat the identifier. 2134 2135 // Check for an optional RangeList. 2136 std::vector<unsigned> Bits; 2137 if (ParseOptionalRangeList(Bits)) 2138 return std::vector<LetRecord>(); 2139 std::reverse(Bits.begin(), Bits.end()); 2140 2141 if (Lex.getCode() != tgtok::equal) { 2142 TokError("expected '=' in let expression"); 2143 return std::vector<LetRecord>(); 2144 } 2145 Lex.Lex(); // eat the '='. 2146 2147 Init *Val = ParseValue(0); 2148 if (Val == 0) return std::vector<LetRecord>(); 2149 2150 // Now that we have everything, add the record. 2151 Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); 2152 2153 if (Lex.getCode() != tgtok::comma) 2154 return Result; 2155 Lex.Lex(); // eat the comma. 2156 } 2157} 2158 2159/// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of 2160/// different related productions. This works inside multiclasses too. 2161/// 2162/// Object ::= LET LetList IN '{' ObjectList '}' 2163/// Object ::= LET LetList IN Object 2164/// 2165bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { 2166 assert(Lex.getCode() == tgtok::Let && "Unexpected token"); 2167 Lex.Lex(); 2168 2169 // Add this entry to the let stack. 2170 std::vector<LetRecord> LetInfo = ParseLetList(); 2171 if (LetInfo.empty()) return true; 2172 LetStack.push_back(LetInfo); 2173 2174 if (Lex.getCode() != tgtok::In) 2175 return TokError("expected 'in' at end of top-level 'let'"); 2176 Lex.Lex(); 2177 2178 // If this is a scalar let, just handle it now 2179 if (Lex.getCode() != tgtok::l_brace) { 2180 // LET LetList IN Object 2181 if (ParseObject(CurMultiClass)) 2182 return true; 2183 } else { // Object ::= LETCommand '{' ObjectList '}' 2184 SMLoc BraceLoc = Lex.getLoc(); 2185 // Otherwise, this is a group let. 2186 Lex.Lex(); // eat the '{'. 2187 2188 // Parse the object list. 2189 if (ParseObjectList(CurMultiClass)) 2190 return true; 2191 2192 if (Lex.getCode() != tgtok::r_brace) { 2193 TokError("expected '}' at end of top level let command"); 2194 return Error(BraceLoc, "to match this '{'"); 2195 } 2196 Lex.Lex(); 2197 } 2198 2199 // Outside this let scope, this let block is not active. 2200 LetStack.pop_back(); 2201 return false; 2202} 2203 2204/// ParseMultiClass - Parse a multiclass definition. 2205/// 2206/// MultiClassInst ::= MULTICLASS ID TemplateArgList? 2207/// ':' BaseMultiClassList '{' MultiClassObject+ '}' 2208/// MultiClassObject ::= DefInst 2209/// MultiClassObject ::= MultiClassInst 2210/// MultiClassObject ::= DefMInst 2211/// MultiClassObject ::= LETCommand '{' ObjectList '}' 2212/// MultiClassObject ::= LETCommand Object 2213/// 2214bool TGParser::ParseMultiClass() { 2215 assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token"); 2216 Lex.Lex(); // Eat the multiclass token. 2217 2218 if (Lex.getCode() != tgtok::Id) 2219 return TokError("expected identifier after multiclass for name"); 2220 std::string Name = Lex.getCurStrVal(); 2221 2222 if (MultiClasses.count(Name)) 2223 return TokError("multiclass '" + Name + "' already defined"); 2224 2225 CurMultiClass = MultiClasses[Name] = new MultiClass(Name, 2226 Lex.getLoc(), Records); 2227 Lex.Lex(); // Eat the identifier. 2228 2229 // If there are template args, parse them. 2230 if (Lex.getCode() == tgtok::less) 2231 if (ParseTemplateArgList(0)) 2232 return true; 2233 2234 bool inherits = false; 2235 2236 // If there are submulticlasses, parse them. 2237 if (Lex.getCode() == tgtok::colon) { 2238 inherits = true; 2239 2240 Lex.Lex(); 2241 2242 // Read all of the submulticlasses. 2243 SubMultiClassReference SubMultiClass = 2244 ParseSubMultiClassReference(CurMultiClass); 2245 while (1) { 2246 // Check for error. 2247 if (SubMultiClass.MC == 0) return true; 2248 2249 // Add it. 2250 if (AddSubMultiClass(CurMultiClass, SubMultiClass)) 2251 return true; 2252 2253 if (Lex.getCode() != tgtok::comma) break; 2254 Lex.Lex(); // eat ','. 2255 SubMultiClass = ParseSubMultiClassReference(CurMultiClass); 2256 } 2257 } 2258 2259 if (Lex.getCode() != tgtok::l_brace) { 2260 if (!inherits) 2261 return TokError("expected '{' in multiclass definition"); 2262 else if (Lex.getCode() != tgtok::semi) 2263 return TokError("expected ';' in multiclass definition"); 2264 else 2265 Lex.Lex(); // eat the ';'. 2266 } else { 2267 if (Lex.Lex() == tgtok::r_brace) // eat the '{'. 2268 return TokError("multiclass must contain at least one def"); 2269 2270 while (Lex.getCode() != tgtok::r_brace) { 2271 switch (Lex.getCode()) { 2272 default: 2273 return TokError("expected 'let', 'def' or 'defm' in multiclass body"); 2274 case tgtok::Let: 2275 case tgtok::Def: 2276 case tgtok::Defm: 2277 case tgtok::Foreach: 2278 if (ParseObject(CurMultiClass)) 2279 return true; 2280 break; 2281 } 2282 } 2283 Lex.Lex(); // eat the '}'. 2284 } 2285 2286 CurMultiClass = 0; 2287 return false; 2288} 2289 2290Record *TGParser:: 2291InstantiateMulticlassDef(MultiClass &MC, 2292 Record *DefProto, 2293 Init *&DefmPrefix, 2294 SMRange DefmPrefixRange) { 2295 // We need to preserve DefProto so it can be reused for later 2296 // instantiations, so create a new Record to inherit from it. 2297 2298 // Add in the defm name. If the defm prefix is empty, give each 2299 // instantiated def a unique name. Otherwise, if "#NAME#" exists in the 2300 // name, substitute the prefix for #NAME#. Otherwise, use the defm name 2301 // as a prefix. 2302 2303 bool IsAnonymous = false; 2304 if (DefmPrefix == 0) { 2305 DefmPrefix = StringInit::get(GetNewAnonymousName()); 2306 IsAnonymous = true; 2307 } 2308 2309 Init *DefName = DefProto->getNameInit(); 2310 2311 StringInit *DefNameString = dyn_cast<StringInit>(DefName); 2312 2313 if (DefNameString != 0) { 2314 // We have a fully expanded string so there are no operators to 2315 // resolve. We should concatenate the given prefix and name. 2316 DefName = 2317 BinOpInit::get(BinOpInit::STRCONCAT, 2318 UnOpInit::get(UnOpInit::CAST, DefmPrefix, 2319 StringRecTy::get())->Fold(DefProto, &MC), 2320 DefName, StringRecTy::get())->Fold(DefProto, &MC); 2321 } 2322 2323 // Make a trail of SMLocs from the multiclass instantiations. 2324 SmallVector<SMLoc, 4> Locs(1, DefmPrefixRange.Start); 2325 Locs.append(DefProto->getLoc().begin(), DefProto->getLoc().end()); 2326 Record *CurRec = new Record(DefName, Locs, Records, IsAnonymous); 2327 2328 SubClassReference Ref; 2329 Ref.RefRange = DefmPrefixRange; 2330 Ref.Rec = DefProto; 2331 AddSubClass(CurRec, Ref); 2332 2333 // Set the value for NAME. We don't resolve references to it 'til later, 2334 // though, so that uses in nested multiclass names don't get 2335 // confused. 2336 if (SetValue(CurRec, Ref.RefRange.Start, "NAME", std::vector<unsigned>(), 2337 DefmPrefix)) { 2338 Error(DefmPrefixRange.Start, "Could not resolve " 2339 + CurRec->getNameInitAsString() + ":NAME to '" 2340 + DefmPrefix->getAsUnquotedString() + "'"); 2341 return 0; 2342 } 2343 2344 // If the DefNameString didn't resolve, we probably have a reference to 2345 // NAME and need to replace it. We need to do at least this much greedily, 2346 // otherwise nested multiclasses will end up with incorrect NAME expansions. 2347 if (DefNameString == 0) { 2348 RecordVal *DefNameRV = CurRec->getValue("NAME"); 2349 CurRec->resolveReferencesTo(DefNameRV); 2350 } 2351 2352 if (!CurMultiClass) { 2353 // Now that we're at the top level, resolve all NAME references 2354 // in the resultant defs that weren't in the def names themselves. 2355 RecordVal *DefNameRV = CurRec->getValue("NAME"); 2356 CurRec->resolveReferencesTo(DefNameRV); 2357 2358 // Now that NAME references are resolved and we're at the top level of 2359 // any multiclass expansions, add the record to the RecordKeeper. If we are 2360 // currently in a multiclass, it means this defm appears inside a 2361 // multiclass and its name won't be fully resolvable until we see 2362 // the top-level defm. Therefore, we don't add this to the 2363 // RecordKeeper at this point. If we did we could get duplicate 2364 // defs as more than one probably refers to NAME or some other 2365 // common internal placeholder. 2366 2367 // Ensure redefinition doesn't happen. 2368 if (Records.getDef(CurRec->getNameInitAsString())) { 2369 Error(DefmPrefixRange.Start, "def '" + CurRec->getNameInitAsString() + 2370 "' already defined, instantiating defm with subdef '" + 2371 DefProto->getNameInitAsString() + "'"); 2372 return 0; 2373 } 2374 2375 Records.addDef(CurRec); 2376 } 2377 2378 return CurRec; 2379} 2380 2381bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, 2382 Record *CurRec, 2383 SMLoc DefmPrefixLoc, 2384 SMLoc SubClassLoc, 2385 const std::vector<Init *> &TArgs, 2386 std::vector<Init *> &TemplateVals, 2387 bool DeleteArgs) { 2388 // Loop over all of the template arguments, setting them to the specified 2389 // value or leaving them as the default if necessary. 2390 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 2391 // Check if a value is specified for this temp-arg. 2392 if (i < TemplateVals.size()) { 2393 // Set it now. 2394 if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(), 2395 TemplateVals[i])) 2396 return true; 2397 2398 // Resolve it next. 2399 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 2400 2401 if (DeleteArgs) 2402 // Now remove it. 2403 CurRec->removeValue(TArgs[i]); 2404 2405 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 2406 return Error(SubClassLoc, "value not specified for template argument #"+ 2407 utostr(i) + " (" + TArgs[i]->getAsUnquotedString() 2408 + ") of multiclassclass '" + MC.Rec.getNameInitAsString() 2409 + "'"); 2410 } 2411 } 2412 return false; 2413} 2414 2415bool TGParser::ResolveMulticlassDef(MultiClass &MC, 2416 Record *CurRec, 2417 Record *DefProto, 2418 SMLoc DefmPrefixLoc) { 2419 // If the mdef is inside a 'let' expression, add to each def. 2420 if (ApplyLetStack(CurRec)) 2421 return Error(DefmPrefixLoc, "when instantiating this defm"); 2422 2423 // Don't create a top level definition for defm inside multiclasses, 2424 // instead, only update the prototypes and bind the template args 2425 // with the new created definition. 2426 if (!CurMultiClass) 2427 return false; 2428 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); 2429 i != e; ++i) 2430 if (CurMultiClass->DefPrototypes[i]->getNameInit() 2431 == CurRec->getNameInit()) 2432 return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() + 2433 "' already defined in this multiclass!"); 2434 CurMultiClass->DefPrototypes.push_back(CurRec); 2435 2436 // Copy the template arguments for the multiclass into the new def. 2437 const std::vector<Init *> &TA = 2438 CurMultiClass->Rec.getTemplateArgs(); 2439 2440 for (unsigned i = 0, e = TA.size(); i != e; ++i) { 2441 const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]); 2442 assert(RV && "Template arg doesn't exist?"); 2443 CurRec->addValue(*RV); 2444 } 2445 2446 return false; 2447} 2448 2449/// ParseDefm - Parse the instantiation of a multiclass. 2450/// 2451/// DefMInst ::= DEFM ID ':' DefmSubClassRef ';' 2452/// 2453bool TGParser::ParseDefm(MultiClass *CurMultiClass) { 2454 assert(Lex.getCode() == tgtok::Defm && "Unexpected token!"); 2455 SMLoc DefmLoc = Lex.getLoc(); 2456 Init *DefmPrefix = 0; 2457 2458 if (Lex.Lex() == tgtok::Id) { // eat the defm. 2459 DefmPrefix = ParseObjectName(CurMultiClass); 2460 } 2461 2462 SMLoc DefmPrefixEndLoc = Lex.getLoc(); 2463 if (Lex.getCode() != tgtok::colon) 2464 return TokError("expected ':' after defm identifier"); 2465 2466 // Keep track of the new generated record definitions. 2467 std::vector<Record*> NewRecDefs; 2468 2469 // This record also inherits from a regular class (non-multiclass)? 2470 bool InheritFromClass = false; 2471 2472 // eat the colon. 2473 Lex.Lex(); 2474 2475 SMLoc SubClassLoc = Lex.getLoc(); 2476 SubClassReference Ref = ParseSubClassReference(0, true); 2477 2478 while (1) { 2479 if (Ref.Rec == 0) return true; 2480 2481 // To instantiate a multiclass, we need to first get the multiclass, then 2482 // instantiate each def contained in the multiclass with the SubClassRef 2483 // template parameters. 2484 MultiClass *MC = MultiClasses[Ref.Rec->getName()]; 2485 assert(MC && "Didn't lookup multiclass correctly?"); 2486 std::vector<Init*> &TemplateVals = Ref.TemplateArgs; 2487 2488 // Verify that the correct number of template arguments were specified. 2489 const std::vector<Init *> &TArgs = MC->Rec.getTemplateArgs(); 2490 if (TArgs.size() < TemplateVals.size()) 2491 return Error(SubClassLoc, 2492 "more template args specified than multiclass expects"); 2493 2494 // Loop over all the def's in the multiclass, instantiating each one. 2495 for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) { 2496 Record *DefProto = MC->DefPrototypes[i]; 2497 2498 Record *CurRec = InstantiateMulticlassDef(*MC, DefProto, DefmPrefix, 2499 SMRange(DefmLoc, 2500 DefmPrefixEndLoc)); 2501 if (!CurRec) 2502 return true; 2503 2504 if (ResolveMulticlassDefArgs(*MC, CurRec, DefmLoc, SubClassLoc, 2505 TArgs, TemplateVals, true/*Delete args*/)) 2506 return Error(SubClassLoc, "could not instantiate def"); 2507 2508 if (ResolveMulticlassDef(*MC, CurRec, DefProto, DefmLoc)) 2509 return Error(SubClassLoc, "could not instantiate def"); 2510 2511 NewRecDefs.push_back(CurRec); 2512 } 2513 2514 2515 if (Lex.getCode() != tgtok::comma) break; 2516 Lex.Lex(); // eat ','. 2517 2518 if (Lex.getCode() != tgtok::Id) 2519 return TokError("expected identifier"); 2520 2521 SubClassLoc = Lex.getLoc(); 2522 2523 // A defm can inherit from regular classes (non-multiclass) as 2524 // long as they come in the end of the inheritance list. 2525 InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0); 2526 2527 if (InheritFromClass) 2528 break; 2529 2530 Ref = ParseSubClassReference(0, true); 2531 } 2532 2533 if (InheritFromClass) { 2534 // Process all the classes to inherit as if they were part of a 2535 // regular 'def' and inherit all record values. 2536 SubClassReference SubClass = ParseSubClassReference(0, false); 2537 while (1) { 2538 // Check for error. 2539 if (SubClass.Rec == 0) return true; 2540 2541 // Get the expanded definition prototypes and teach them about 2542 // the record values the current class to inherit has 2543 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) { 2544 Record *CurRec = NewRecDefs[i]; 2545 2546 // Add it. 2547 if (AddSubClass(CurRec, SubClass)) 2548 return true; 2549 2550 if (ApplyLetStack(CurRec)) 2551 return true; 2552 } 2553 2554 if (Lex.getCode() != tgtok::comma) break; 2555 Lex.Lex(); // eat ','. 2556 SubClass = ParseSubClassReference(0, false); 2557 } 2558 } 2559 2560 if (!CurMultiClass) 2561 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) 2562 // See Record::setName(). This resolve step will see any new 2563 // name for the def that might have been created when resolving 2564 // inheritance, values and arguments above. 2565 NewRecDefs[i]->resolveReferences(); 2566 2567 if (Lex.getCode() != tgtok::semi) 2568 return TokError("expected ';' at end of defm"); 2569 Lex.Lex(); 2570 2571 return false; 2572} 2573 2574/// ParseObject 2575/// Object ::= ClassInst 2576/// Object ::= DefInst 2577/// Object ::= MultiClassInst 2578/// Object ::= DefMInst 2579/// Object ::= LETCommand '{' ObjectList '}' 2580/// Object ::= LETCommand Object 2581bool TGParser::ParseObject(MultiClass *MC) { 2582 switch (Lex.getCode()) { 2583 default: 2584 return TokError("Expected class, def, defm, multiclass or let definition"); 2585 case tgtok::Let: return ParseTopLevelLet(MC); 2586 case tgtok::Def: return ParseDef(MC); 2587 case tgtok::Foreach: return ParseForeach(MC); 2588 case tgtok::Defm: return ParseDefm(MC); 2589 case tgtok::Class: return ParseClass(); 2590 case tgtok::MultiClass: return ParseMultiClass(); 2591 } 2592} 2593 2594/// ParseObjectList 2595/// ObjectList :== Object* 2596bool TGParser::ParseObjectList(MultiClass *MC) { 2597 while (isObjectStart(Lex.getCode())) { 2598 if (ParseObject(MC)) 2599 return true; 2600 } 2601 return false; 2602} 2603 2604bool TGParser::ParseFile() { 2605 Lex.Lex(); // Prime the lexer. 2606 if (ParseObjectList()) return true; 2607 2608 // If we have unread input at the end of the file, report it. 2609 if (Lex.getCode() == tgtok::Eof) 2610 return false; 2611 2612 return TokError("Unexpected input at top level"); 2613} 2614 2615