TGParser.cpp revision 7c788888872233748da10a8177a9a1eb176c1bc8
1b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith//===- TGParser.cpp - Parser for TableGen Files ---------------------------===// 2b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// 3b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// The LLVM Compiler Infrastructure 4b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// 5b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// This file is distributed under the University of Illinois Open Source 6b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// License. See LICENSE.TXT for details. 7b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// 8b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith//===----------------------------------------------------------------------===// 9b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// 10b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// Implement the Parser for TableGen. 11b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// 12b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith//===----------------------------------------------------------------------===// 13b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith 14b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith#include "TGParser.h" 15b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith#include "llvm/TableGen/Record.h" 16e5658f0ab2a6f8fea258adb64edbb8485bb21deeRichard Smith#include "llvm/ADT/StringExtras.h" 17e5658f0ab2a6f8fea258adb64edbb8485bb21deeRichard Smith#include <algorithm> 18b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith#include <sstream> 19b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith#include "llvm/ADT/SmallVector.h" 20b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith#include "llvm/Support/CommandLine.h" 21b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smithusing namespace llvm; 22b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith 23b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith//===----------------------------------------------------------------------===// 24b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith// Support Code for the Semantic Actions. 25b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith//===----------------------------------------------------------------------===// 26b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith 27b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smithnamespace llvm { 28b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smithstruct SubClassReference { 29b4a7b1e587a232c95d02a8ca10eeba60164fbba1Richard Smith SMLoc RefLoc; 303a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith Record *Rec; 313a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith std::vector<Init*> TemplateArgs; 323a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith SubClassReference() : Rec(0) {} 333a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith 343a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith bool isInvalid() const { return Rec == 0; } 353a5032b89df601ab2e0c5c7e9667db2301bf10cfRichard Smith}; 36 37struct SubMultiClassReference { 38 SMLoc RefLoc; 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.getName())) { 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, const std::string &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 + "' unknown!"); 91 92 // Do not allow assignments like 'X = X'. This will just cause infinite loops 93 // in the resolution machinery. 94 if (BitList.empty()) 95 if (VarInit *VI = dynamic_cast<VarInit*>(V)) 96 if (VI->getName() == ValName) 97 return false; 98 99 // If we are assigning to a subset of the bits in the value... then we must be 100 // assigning to a field of BitsRecTy, which must have a BitsInit 101 // initializer. 102 // 103 if (!BitList.empty()) { 104 BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue()); 105 if (CurVal == 0) 106 return Error(Loc, "Value '" + ValName + "' is not a bits type"); 107 108 // Convert the incoming value to a bits type of the appropriate size... 109 Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size())); 110 if (BI == 0) { 111 V->convertInitializerTo(BitsRecTy::get(BitList.size())); 112 return Error(Loc, "Initializer is not compatible with bit range"); 113 } 114 115 // We should have a BitsInit type now. 116 BitsInit *BInit = dynamic_cast<BitsInit*>(BI); 117 assert(BInit != 0); 118 119 SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); 120 121 // Loop over bits, assigning values as appropriate. 122 for (unsigned i = 0, e = BitList.size(); i != e; ++i) { 123 unsigned Bit = BitList[i]; 124 if (NewBits[Bit]) 125 return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" + 126 ValName + "' more than once"); 127 NewBits[Bit] = BInit->getBit(i); 128 } 129 130 for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) 131 if (NewBits[i] == 0) 132 NewBits[i] = CurVal->getBit(i); 133 134 V = BitsInit::get(NewBits); 135 } 136 137 if (RV->setValue(V)) 138 return Error(Loc, "Value '" + ValName + "' of type '" + 139 RV->getType()->getAsString() + 140 "' is incompatible with initializer '" + V->getAsString() +"'"); 141 return false; 142} 143 144/// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template 145/// args as SubClass's template arguments. 146bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { 147 Record *SC = SubClass.Rec; 148 // Add all of the values in the subclass into the current class. 149 const std::vector<RecordVal> &Vals = SC->getValues(); 150 for (unsigned i = 0, e = Vals.size(); i != e; ++i) 151 if (AddValue(CurRec, SubClass.RefLoc, Vals[i])) 152 return true; 153 154 const std::vector<std::string> &TArgs = SC->getTemplateArgs(); 155 156 // Ensure that an appropriate number of template arguments are specified. 157 if (TArgs.size() < SubClass.TemplateArgs.size()) 158 return Error(SubClass.RefLoc, "More template args specified than expected"); 159 160 // Loop over all of the template arguments, setting them to the specified 161 // value or leaving them as the default if necessary. 162 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 163 if (i < SubClass.TemplateArgs.size()) { 164 // If a value is specified for this template arg, set it now. 165 if (SetValue(CurRec, SubClass.RefLoc, TArgs[i], std::vector<unsigned>(), 166 SubClass.TemplateArgs[i])) 167 return true; 168 169 // Resolve it next. 170 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 171 172 // Now remove it. 173 CurRec->removeValue(TArgs[i]); 174 175 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 176 return Error(SubClass.RefLoc,"Value not specified for template argument #" 177 + utostr(i) + " (" + TArgs[i] + ") of subclass '" + 178 SC->getName() + "'!"); 179 } 180 } 181 182 // Since everything went well, we can now set the "superclass" list for the 183 // current record. 184 const std::vector<Record*> &SCs = SC->getSuperClasses(); 185 for (unsigned i = 0, e = SCs.size(); i != e; ++i) { 186 if (CurRec->isSubClassOf(SCs[i])) 187 return Error(SubClass.RefLoc, 188 "Already subclass of '" + SCs[i]->getName() + "'!\n"); 189 CurRec->addSuperClass(SCs[i]); 190 } 191 192 if (CurRec->isSubClassOf(SC)) 193 return Error(SubClass.RefLoc, 194 "Already subclass of '" + SC->getName() + "'!\n"); 195 CurRec->addSuperClass(SC); 196 return false; 197} 198 199/// AddSubMultiClass - Add SubMultiClass as a subclass to 200/// CurMC, resolving its template args as SubMultiClass's 201/// template arguments. 202bool TGParser::AddSubMultiClass(MultiClass *CurMC, 203 SubMultiClassReference &SubMultiClass) { 204 MultiClass *SMC = SubMultiClass.MC; 205 Record *CurRec = &CurMC->Rec; 206 207 const std::vector<RecordVal> &MCVals = CurRec->getValues(); 208 209 // Add all of the values in the subclass into the current class. 210 const std::vector<RecordVal> &SMCVals = SMC->Rec.getValues(); 211 for (unsigned i = 0, e = SMCVals.size(); i != e; ++i) 212 if (AddValue(CurRec, SubMultiClass.RefLoc, SMCVals[i])) 213 return true; 214 215 int newDefStart = CurMC->DefPrototypes.size(); 216 217 // Add all of the defs in the subclass into the current multiclass. 218 for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(), 219 iend = SMC->DefPrototypes.end(); 220 i != iend; 221 ++i) { 222 // Clone the def and add it to the current multiclass 223 Record *NewDef = new Record(**i); 224 225 // Add all of the values in the superclass into the current def. 226 for (unsigned i = 0, e = MCVals.size(); i != e; ++i) 227 if (AddValue(NewDef, SubMultiClass.RefLoc, MCVals[i])) 228 return true; 229 230 CurMC->DefPrototypes.push_back(NewDef); 231 } 232 233 const std::vector<std::string> &SMCTArgs = SMC->Rec.getTemplateArgs(); 234 235 // Ensure that an appropriate number of template arguments are 236 // specified. 237 if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size()) 238 return Error(SubMultiClass.RefLoc, 239 "More template args specified than expected"); 240 241 // Loop over all of the template arguments, setting them to the specified 242 // value or leaving them as the default if necessary. 243 for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) { 244 if (i < SubMultiClass.TemplateArgs.size()) { 245 // If a value is specified for this template arg, set it in the 246 // superclass now. 247 if (SetValue(CurRec, SubMultiClass.RefLoc, SMCTArgs[i], 248 std::vector<unsigned>(), 249 SubMultiClass.TemplateArgs[i])) 250 return true; 251 252 // Resolve it next. 253 CurRec->resolveReferencesTo(CurRec->getValue(SMCTArgs[i])); 254 255 // Now remove it. 256 CurRec->removeValue(SMCTArgs[i]); 257 258 // If a value is specified for this template arg, set it in the 259 // new defs now. 260 for (MultiClass::RecordVector::iterator j = 261 CurMC->DefPrototypes.begin() + newDefStart, 262 jend = CurMC->DefPrototypes.end(); 263 j != jend; 264 ++j) { 265 Record *Def = *j; 266 267 if (SetValue(Def, SubMultiClass.RefLoc, SMCTArgs[i], 268 std::vector<unsigned>(), 269 SubMultiClass.TemplateArgs[i])) 270 return true; 271 272 // Resolve it next. 273 Def->resolveReferencesTo(Def->getValue(SMCTArgs[i])); 274 275 // Now remove it 276 Def->removeValue(SMCTArgs[i]); 277 } 278 } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) { 279 return Error(SubMultiClass.RefLoc, 280 "Value not specified for template argument #" 281 + utostr(i) + " (" + SMCTArgs[i] + ") of subclass '" + 282 SMC->Rec.getName() + "'!"); 283 } 284 } 285 286 return false; 287} 288 289//===----------------------------------------------------------------------===// 290// Parser Code 291//===----------------------------------------------------------------------===// 292 293/// isObjectStart - Return true if this is a valid first token for an Object. 294static bool isObjectStart(tgtok::TokKind K) { 295 return K == tgtok::Class || K == tgtok::Def || 296 K == tgtok::Defm || K == tgtok::Let || K == tgtok::MultiClass; 297} 298 299static std::string GetNewAnonymousName() { 300 static unsigned AnonCounter = 0; 301 return "anonymous."+utostr(AnonCounter++); 302} 303 304/// ParseObjectName - If an object name is specified, return it. Otherwise, 305/// return an anonymous name. 306/// ObjectName ::= ID 307/// ObjectName ::= /*empty*/ 308/// 309std::string TGParser::ParseObjectName() { 310 if (Lex.getCode() != tgtok::Id) 311 return GetNewAnonymousName(); 312 313 std::string Ret = Lex.getCurStrVal(); 314 Lex.Lex(); 315 return Ret; 316} 317 318 319/// ParseClassID - Parse and resolve a reference to a class name. This returns 320/// null on error. 321/// 322/// ClassID ::= ID 323/// 324Record *TGParser::ParseClassID() { 325 if (Lex.getCode() != tgtok::Id) { 326 TokError("expected name for ClassID"); 327 return 0; 328 } 329 330 Record *Result = Records.getClass(Lex.getCurStrVal()); 331 if (Result == 0) 332 TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); 333 334 Lex.Lex(); 335 return Result; 336} 337 338/// ParseMultiClassID - Parse and resolve a reference to a multiclass name. 339/// This returns null on error. 340/// 341/// MultiClassID ::= ID 342/// 343MultiClass *TGParser::ParseMultiClassID() { 344 if (Lex.getCode() != tgtok::Id) { 345 TokError("expected name for ClassID"); 346 return 0; 347 } 348 349 MultiClass *Result = MultiClasses[Lex.getCurStrVal()]; 350 if (Result == 0) 351 TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); 352 353 Lex.Lex(); 354 return Result; 355} 356 357Record *TGParser::ParseDefmID() { 358 if (Lex.getCode() != tgtok::Id) { 359 TokError("expected multiclass name"); 360 return 0; 361 } 362 363 MultiClass *MC = MultiClasses[Lex.getCurStrVal()]; 364 if (MC == 0) { 365 TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); 366 return 0; 367 } 368 369 Lex.Lex(); 370 return &MC->Rec; 371} 372 373 374/// ParseSubClassReference - Parse a reference to a subclass or to a templated 375/// subclass. This returns a SubClassRefTy with a null Record* on error. 376/// 377/// SubClassRef ::= ClassID 378/// SubClassRef ::= ClassID '<' ValueList '>' 379/// 380SubClassReference TGParser:: 381ParseSubClassReference(Record *CurRec, bool isDefm) { 382 SubClassReference Result; 383 Result.RefLoc = Lex.getLoc(); 384 385 if (isDefm) 386 Result.Rec = ParseDefmID(); 387 else 388 Result.Rec = ParseClassID(); 389 if (Result.Rec == 0) return Result; 390 391 // If there is no template arg list, we're done. 392 if (Lex.getCode() != tgtok::less) 393 return Result; 394 Lex.Lex(); // Eat the '<' 395 396 if (Lex.getCode() == tgtok::greater) { 397 TokError("subclass reference requires a non-empty list of template values"); 398 Result.Rec = 0; 399 return Result; 400 } 401 402 Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); 403 if (Result.TemplateArgs.empty()) { 404 Result.Rec = 0; // Error parsing value list. 405 return Result; 406 } 407 408 if (Lex.getCode() != tgtok::greater) { 409 TokError("expected '>' in template value list"); 410 Result.Rec = 0; 411 return Result; 412 } 413 Lex.Lex(); 414 415 return Result; 416} 417 418/// ParseSubMultiClassReference - Parse a reference to a subclass or to a 419/// templated submulticlass. This returns a SubMultiClassRefTy with a null 420/// Record* on error. 421/// 422/// SubMultiClassRef ::= MultiClassID 423/// SubMultiClassRef ::= MultiClassID '<' ValueList '>' 424/// 425SubMultiClassReference TGParser:: 426ParseSubMultiClassReference(MultiClass *CurMC) { 427 SubMultiClassReference Result; 428 Result.RefLoc = Lex.getLoc(); 429 430 Result.MC = ParseMultiClassID(); 431 if (Result.MC == 0) return Result; 432 433 // If there is no template arg list, we're done. 434 if (Lex.getCode() != tgtok::less) 435 return Result; 436 Lex.Lex(); // Eat the '<' 437 438 if (Lex.getCode() == tgtok::greater) { 439 TokError("subclass reference requires a non-empty list of template values"); 440 Result.MC = 0; 441 return Result; 442 } 443 444 Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); 445 if (Result.TemplateArgs.empty()) { 446 Result.MC = 0; // Error parsing value list. 447 return Result; 448 } 449 450 if (Lex.getCode() != tgtok::greater) { 451 TokError("expected '>' in template value list"); 452 Result.MC = 0; 453 return Result; 454 } 455 Lex.Lex(); 456 457 return Result; 458} 459 460/// ParseRangePiece - Parse a bit/value range. 461/// RangePiece ::= INTVAL 462/// RangePiece ::= INTVAL '-' INTVAL 463/// RangePiece ::= INTVAL INTVAL 464bool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) { 465 if (Lex.getCode() != tgtok::IntVal) { 466 TokError("expected integer or bitrange"); 467 return true; 468 } 469 int64_t Start = Lex.getCurIntVal(); 470 int64_t End; 471 472 if (Start < 0) 473 return TokError("invalid range, cannot be negative"); 474 475 switch (Lex.Lex()) { // eat first character. 476 default: 477 Ranges.push_back(Start); 478 return false; 479 case tgtok::minus: 480 if (Lex.Lex() != tgtok::IntVal) { 481 TokError("expected integer value as end of range"); 482 return true; 483 } 484 End = Lex.getCurIntVal(); 485 break; 486 case tgtok::IntVal: 487 End = -Lex.getCurIntVal(); 488 break; 489 } 490 if (End < 0) 491 return TokError("invalid range, cannot be negative"); 492 Lex.Lex(); 493 494 // Add to the range. 495 if (Start < End) { 496 for (; Start <= End; ++Start) 497 Ranges.push_back(Start); 498 } else { 499 for (; Start >= End; --Start) 500 Ranges.push_back(Start); 501 } 502 return false; 503} 504 505/// ParseRangeList - Parse a list of scalars and ranges into scalar values. 506/// 507/// RangeList ::= RangePiece (',' RangePiece)* 508/// 509std::vector<unsigned> TGParser::ParseRangeList() { 510 std::vector<unsigned> Result; 511 512 // Parse the first piece. 513 if (ParseRangePiece(Result)) 514 return std::vector<unsigned>(); 515 while (Lex.getCode() == tgtok::comma) { 516 Lex.Lex(); // Eat the comma. 517 518 // Parse the next range piece. 519 if (ParseRangePiece(Result)) 520 return std::vector<unsigned>(); 521 } 522 return Result; 523} 524 525/// ParseOptionalRangeList - Parse either a range list in <>'s or nothing. 526/// OptionalRangeList ::= '<' RangeList '>' 527/// OptionalRangeList ::= /*empty*/ 528bool TGParser::ParseOptionalRangeList(std::vector<unsigned> &Ranges) { 529 if (Lex.getCode() != tgtok::less) 530 return false; 531 532 SMLoc StartLoc = Lex.getLoc(); 533 Lex.Lex(); // eat the '<' 534 535 // Parse the range list. 536 Ranges = ParseRangeList(); 537 if (Ranges.empty()) return true; 538 539 if (Lex.getCode() != tgtok::greater) { 540 TokError("expected '>' at end of range list"); 541 return Error(StartLoc, "to match this '<'"); 542 } 543 Lex.Lex(); // eat the '>'. 544 return false; 545} 546 547/// ParseOptionalBitList - Parse either a bit list in {}'s or nothing. 548/// OptionalBitList ::= '{' RangeList '}' 549/// OptionalBitList ::= /*empty*/ 550bool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) { 551 if (Lex.getCode() != tgtok::l_brace) 552 return false; 553 554 SMLoc StartLoc = Lex.getLoc(); 555 Lex.Lex(); // eat the '{' 556 557 // Parse the range list. 558 Ranges = ParseRangeList(); 559 if (Ranges.empty()) return true; 560 561 if (Lex.getCode() != tgtok::r_brace) { 562 TokError("expected '}' at end of bit list"); 563 return Error(StartLoc, "to match this '{'"); 564 } 565 Lex.Lex(); // eat the '}'. 566 return false; 567} 568 569 570/// ParseType - Parse and return a tblgen type. This returns null on error. 571/// 572/// Type ::= STRING // string type 573/// Type ::= BIT // bit type 574/// Type ::= BITS '<' INTVAL '>' // bits<x> type 575/// Type ::= INT // int type 576/// Type ::= LIST '<' Type '>' // list<x> type 577/// Type ::= CODE // code type 578/// Type ::= DAG // dag type 579/// Type ::= ClassID // Record Type 580/// 581RecTy *TGParser::ParseType() { 582 switch (Lex.getCode()) { 583 default: TokError("Unknown token when expecting a type"); return 0; 584 case tgtok::String: Lex.Lex(); return StringRecTy::get(); 585 case tgtok::Bit: Lex.Lex(); return BitRecTy::get(); 586 case tgtok::Int: Lex.Lex(); return IntRecTy::get(); 587 case tgtok::Code: Lex.Lex(); return CodeRecTy::get(); 588 case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); 589 case tgtok::Id: 590 if (Record *R = ParseClassID()) return RecordRecTy::get(R); 591 return 0; 592 case tgtok::Bits: { 593 if (Lex.Lex() != tgtok::less) { // Eat 'bits' 594 TokError("expected '<' after bits type"); 595 return 0; 596 } 597 if (Lex.Lex() != tgtok::IntVal) { // Eat '<' 598 TokError("expected integer in bits<n> type"); 599 return 0; 600 } 601 uint64_t Val = Lex.getCurIntVal(); 602 if (Lex.Lex() != tgtok::greater) { // Eat count. 603 TokError("expected '>' at end of bits<n> type"); 604 return 0; 605 } 606 Lex.Lex(); // Eat '>' 607 return BitsRecTy::get(Val); 608 } 609 case tgtok::List: { 610 if (Lex.Lex() != tgtok::less) { // Eat 'bits' 611 TokError("expected '<' after list type"); 612 return 0; 613 } 614 Lex.Lex(); // Eat '<' 615 RecTy *SubType = ParseType(); 616 if (SubType == 0) return 0; 617 618 if (Lex.getCode() != tgtok::greater) { 619 TokError("expected '>' at end of list<ty> type"); 620 return 0; 621 } 622 Lex.Lex(); // Eat '>' 623 return ListRecTy::get(SubType); 624 } 625 } 626} 627 628/// ParseIDValue - Parse an ID as a value and decode what it means. 629/// 630/// IDValue ::= ID [def local value] 631/// IDValue ::= ID [def template arg] 632/// IDValue ::= ID [multiclass local value] 633/// IDValue ::= ID [multiclass template argument] 634/// IDValue ::= ID [def name] 635/// 636Init *TGParser::ParseIDValue(Record *CurRec) { 637 assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue"); 638 std::string Name = Lex.getCurStrVal(); 639 SMLoc Loc = Lex.getLoc(); 640 Lex.Lex(); 641 return ParseIDValue(CurRec, Name, Loc); 642} 643 644/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID 645/// has already been read. 646Init *TGParser::ParseIDValue(Record *CurRec, 647 const std::string &Name, SMLoc NameLoc) { 648 if (CurRec) { 649 if (const RecordVal *RV = CurRec->getValue(Name)) 650 return VarInit::get(Name, RV->getType()); 651 652 std::string TemplateArgName = CurRec->getName()+":"+Name; 653 if (CurRec->isTemplateArg(TemplateArgName)) { 654 const RecordVal *RV = CurRec->getValue(TemplateArgName); 655 assert(RV && "Template arg doesn't exist??"); 656 return VarInit::get(TemplateArgName, RV->getType()); 657 } 658 } 659 660 if (CurMultiClass) { 661 std::string MCName = CurMultiClass->Rec.getName()+"::"+Name; 662 if (CurMultiClass->Rec.isTemplateArg(MCName)) { 663 const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 664 assert(RV && "Template arg doesn't exist??"); 665 return VarInit::get(MCName, RV->getType()); 666 } 667 } 668 669 if (Record *D = Records.getDef(Name)) 670 return DefInit::get(D); 671 672 Error(NameLoc, "Variable not defined: '" + Name + "'"); 673 return 0; 674} 675 676/// ParseOperation - Parse an operator. This returns null on error. 677/// 678/// Operation ::= XOperator ['<' Type '>'] '(' Args ')' 679/// 680Init *TGParser::ParseOperation(Record *CurRec) { 681 switch (Lex.getCode()) { 682 default: 683 TokError("unknown operation"); 684 return 0; 685 break; 686 case tgtok::XHead: 687 case tgtok::XTail: 688 case tgtok::XEmpty: 689 case tgtok::XCast: { // Value ::= !unop '(' Value ')' 690 UnOpInit::UnaryOp Code; 691 RecTy *Type = 0; 692 693 switch (Lex.getCode()) { 694 default: assert(0 && "Unhandled code!"); 695 case tgtok::XCast: 696 Lex.Lex(); // eat the operation 697 Code = UnOpInit::CAST; 698 699 Type = ParseOperatorType(); 700 701 if (Type == 0) { 702 TokError("did not get type for unary operator"); 703 return 0; 704 } 705 706 break; 707 case tgtok::XHead: 708 Lex.Lex(); // eat the operation 709 Code = UnOpInit::HEAD; 710 break; 711 case tgtok::XTail: 712 Lex.Lex(); // eat the operation 713 Code = UnOpInit::TAIL; 714 break; 715 case tgtok::XEmpty: 716 Lex.Lex(); // eat the operation 717 Code = UnOpInit::EMPTY; 718 Type = IntRecTy::get(); 719 break; 720 } 721 if (Lex.getCode() != tgtok::l_paren) { 722 TokError("expected '(' after unary operator"); 723 return 0; 724 } 725 Lex.Lex(); // eat the '(' 726 727 Init *LHS = ParseValue(CurRec); 728 if (LHS == 0) return 0; 729 730 if (Code == UnOpInit::HEAD 731 || Code == UnOpInit::TAIL 732 || Code == UnOpInit::EMPTY) { 733 ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 734 StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 735 TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); 736 if (LHSl == 0 && LHSs == 0 && LHSt == 0) { 737 TokError("expected list or string type argument in unary operator"); 738 return 0; 739 } 740 if (LHSt) { 741 ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType()); 742 StringRecTy *SType = dynamic_cast<StringRecTy*>(LHSt->getType()); 743 if (LType == 0 && SType == 0) { 744 TokError("expected list or string type argumnet in unary operator"); 745 return 0; 746 } 747 } 748 749 if (Code == UnOpInit::HEAD 750 || Code == UnOpInit::TAIL) { 751 if (LHSl == 0 && LHSt == 0) { 752 TokError("expected list type argumnet in unary operator"); 753 return 0; 754 } 755 756 if (LHSl && LHSl->getSize() == 0) { 757 TokError("empty list argument in unary operator"); 758 return 0; 759 } 760 if (LHSl) { 761 Init *Item = LHSl->getElement(0); 762 TypedInit *Itemt = dynamic_cast<TypedInit*>(Item); 763 if (Itemt == 0) { 764 TokError("untyped list element in unary operator"); 765 return 0; 766 } 767 if (Code == UnOpInit::HEAD) { 768 Type = Itemt->getType(); 769 } else { 770 Type = ListRecTy::get(Itemt->getType()); 771 } 772 } else { 773 assert(LHSt && "expected list type argument in unary operator"); 774 ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType()); 775 if (LType == 0) { 776 TokError("expected list type argumnet in unary operator"); 777 return 0; 778 } 779 if (Code == UnOpInit::HEAD) { 780 Type = LType->getElementType(); 781 } else { 782 Type = LType; 783 } 784 } 785 } 786 } 787 788 if (Lex.getCode() != tgtok::r_paren) { 789 TokError("expected ')' in unary operator"); 790 return 0; 791 } 792 Lex.Lex(); // eat the ')' 793 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass); 794 } 795 796 case tgtok::XConcat: 797 case tgtok::XSRA: 798 case tgtok::XSRL: 799 case tgtok::XSHL: 800 case tgtok::XEq: 801 case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')' 802 tgtok::TokKind OpTok = Lex.getCode(); 803 SMLoc OpLoc = Lex.getLoc(); 804 Lex.Lex(); // eat the operation 805 806 BinOpInit::BinaryOp Code; 807 RecTy *Type = 0; 808 809 switch (OpTok) { 810 default: assert(0 && "Unhandled code!"); 811 case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break; 812 case tgtok::XSRA: Code = BinOpInit::SRA; Type = IntRecTy::get(); break; 813 case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break; 814 case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break; 815 case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break; 816 case tgtok::XStrConcat: 817 Code = BinOpInit::STRCONCAT; 818 Type = StringRecTy::get(); 819 break; 820 } 821 822 if (Lex.getCode() != tgtok::l_paren) { 823 TokError("expected '(' after binary operator"); 824 return 0; 825 } 826 Lex.Lex(); // eat the '(' 827 828 SmallVector<Init*, 2> InitList; 829 830 InitList.push_back(ParseValue(CurRec)); 831 if (InitList.back() == 0) return 0; 832 833 while (Lex.getCode() == tgtok::comma) { 834 Lex.Lex(); // eat the ',' 835 836 InitList.push_back(ParseValue(CurRec)); 837 if (InitList.back() == 0) return 0; 838 } 839 840 if (Lex.getCode() != tgtok::r_paren) { 841 TokError("expected ')' in operator"); 842 return 0; 843 } 844 Lex.Lex(); // eat the ')' 845 846 // We allow multiple operands to associative operators like !strconcat as 847 // shorthand for nesting them. 848 if (Code == BinOpInit::STRCONCAT) { 849 while (InitList.size() > 2) { 850 Init *RHS = InitList.pop_back_val(); 851 RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type)) 852 ->Fold(CurRec, CurMultiClass); 853 InitList.back() = RHS; 854 } 855 } 856 857 if (InitList.size() == 2) 858 return (BinOpInit::get(Code, InitList[0], InitList[1], Type)) 859 ->Fold(CurRec, CurMultiClass); 860 861 Error(OpLoc, "expected two operands to operator"); 862 return 0; 863 } 864 865 case tgtok::XIf: 866 case tgtok::XForEach: 867 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 868 TernOpInit::TernaryOp Code; 869 RecTy *Type = 0; 870 871 tgtok::TokKind LexCode = Lex.getCode(); 872 Lex.Lex(); // eat the operation 873 switch (LexCode) { 874 default: assert(0 && "Unhandled code!"); 875 case tgtok::XIf: 876 Code = TernOpInit::IF; 877 break; 878 case tgtok::XForEach: 879 Code = TernOpInit::FOREACH; 880 break; 881 case tgtok::XSubst: 882 Code = TernOpInit::SUBST; 883 break; 884 } 885 if (Lex.getCode() != tgtok::l_paren) { 886 TokError("expected '(' after ternary operator"); 887 return 0; 888 } 889 Lex.Lex(); // eat the '(' 890 891 Init *LHS = ParseValue(CurRec); 892 if (LHS == 0) return 0; 893 894 if (Lex.getCode() != tgtok::comma) { 895 TokError("expected ',' in ternary operator"); 896 return 0; 897 } 898 Lex.Lex(); // eat the ',' 899 900 Init *MHS = ParseValue(CurRec); 901 if (MHS == 0) return 0; 902 903 if (Lex.getCode() != tgtok::comma) { 904 TokError("expected ',' in ternary operator"); 905 return 0; 906 } 907 Lex.Lex(); // eat the ',' 908 909 Init *RHS = ParseValue(CurRec); 910 if (RHS == 0) return 0; 911 912 if (Lex.getCode() != tgtok::r_paren) { 913 TokError("expected ')' in binary operator"); 914 return 0; 915 } 916 Lex.Lex(); // eat the ')' 917 918 switch (LexCode) { 919 default: assert(0 && "Unhandled code!"); 920 case tgtok::XIf: { 921 // FIXME: The `!if' operator doesn't handle non-TypedInit well at 922 // all. This can be made much more robust. 923 TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS); 924 TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS); 925 926 RecTy *MHSTy = 0; 927 RecTy *RHSTy = 0; 928 929 if (MHSt == 0 && RHSt == 0) { 930 BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS); 931 BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS); 932 933 if (MHSbits && RHSbits && 934 MHSbits->getNumBits() == RHSbits->getNumBits()) { 935 Type = BitRecTy::get(); 936 break; 937 } else { 938 BitInit *MHSbit = dynamic_cast<BitInit*>(MHS); 939 BitInit *RHSbit = dynamic_cast<BitInit*>(RHS); 940 941 if (MHSbit && RHSbit) { 942 Type = BitRecTy::get(); 943 break; 944 } 945 } 946 } else if (MHSt != 0 && RHSt != 0) { 947 MHSTy = MHSt->getType(); 948 RHSTy = RHSt->getType(); 949 } 950 951 if (!MHSTy || !RHSTy) { 952 TokError("could not get type for !if"); 953 return 0; 954 } 955 956 if (MHSTy->typeIsConvertibleTo(RHSTy)) { 957 Type = RHSTy; 958 } else if (RHSTy->typeIsConvertibleTo(MHSTy)) { 959 Type = MHSTy; 960 } else { 961 TokError("inconsistent types for !if"); 962 return 0; 963 } 964 break; 965 } 966 case tgtok::XForEach: { 967 TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS); 968 if (MHSt == 0) { 969 TokError("could not get type for !foreach"); 970 return 0; 971 } 972 Type = MHSt->getType(); 973 break; 974 } 975 case tgtok::XSubst: { 976 TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS); 977 if (RHSt == 0) { 978 TokError("could not get type for !subst"); 979 return 0; 980 } 981 Type = RHSt->getType(); 982 break; 983 } 984 } 985 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec, 986 CurMultiClass); 987 } 988 } 989 TokError("could not parse operation"); 990 return 0; 991} 992 993/// ParseOperatorType - Parse a type for an operator. This returns 994/// null on error. 995/// 996/// OperatorType ::= '<' Type '>' 997/// 998RecTy *TGParser::ParseOperatorType() { 999 RecTy *Type = 0; 1000 1001 if (Lex.getCode() != tgtok::less) { 1002 TokError("expected type name for operator"); 1003 return 0; 1004 } 1005 Lex.Lex(); // eat the < 1006 1007 Type = ParseType(); 1008 1009 if (Type == 0) { 1010 TokError("expected type name for operator"); 1011 return 0; 1012 } 1013 1014 if (Lex.getCode() != tgtok::greater) { 1015 TokError("expected type name for operator"); 1016 return 0; 1017 } 1018 Lex.Lex(); // eat the > 1019 1020 return Type; 1021} 1022 1023 1024/// ParseSimpleValue - Parse a tblgen value. This returns null on error. 1025/// 1026/// SimpleValue ::= IDValue 1027/// SimpleValue ::= INTVAL 1028/// SimpleValue ::= STRVAL+ 1029/// SimpleValue ::= CODEFRAGMENT 1030/// SimpleValue ::= '?' 1031/// SimpleValue ::= '{' ValueList '}' 1032/// SimpleValue ::= ID '<' ValueListNE '>' 1033/// SimpleValue ::= '[' ValueList ']' 1034/// SimpleValue ::= '(' IDValue DagArgList ')' 1035/// SimpleValue ::= CONCATTOK '(' Value ',' Value ')' 1036/// SimpleValue ::= SHLTOK '(' Value ',' Value ')' 1037/// SimpleValue ::= SRATOK '(' Value ',' Value ')' 1038/// SimpleValue ::= SRLTOK '(' Value ',' Value ')' 1039/// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' 1040/// 1041Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { 1042 Init *R = 0; 1043 switch (Lex.getCode()) { 1044 default: TokError("Unknown token when parsing a value"); break; 1045 case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break; 1046 case tgtok::StrVal: { 1047 std::string Val = Lex.getCurStrVal(); 1048 Lex.Lex(); 1049 1050 // Handle multiple consecutive concatenated strings. 1051 while (Lex.getCode() == tgtok::StrVal) { 1052 Val += Lex.getCurStrVal(); 1053 Lex.Lex(); 1054 } 1055 1056 R = StringInit::get(Val); 1057 break; 1058 } 1059 case tgtok::CodeFragment: 1060 R = CodeInit::get(Lex.getCurStrVal()); 1061 Lex.Lex(); 1062 break; 1063 case tgtok::question: 1064 R = UnsetInit::get(); 1065 Lex.Lex(); 1066 break; 1067 case tgtok::Id: { 1068 SMLoc NameLoc = Lex.getLoc(); 1069 std::string Name = Lex.getCurStrVal(); 1070 if (Lex.Lex() != tgtok::less) // consume the Id. 1071 return ParseIDValue(CurRec, Name, NameLoc); // Value ::= IDValue 1072 1073 // Value ::= ID '<' ValueListNE '>' 1074 if (Lex.Lex() == tgtok::greater) { 1075 TokError("expected non-empty value list"); 1076 return 0; 1077 } 1078 1079 // This is a CLASS<initvalslist> expression. This is supposed to synthesize 1080 // a new anonymous definition, deriving from CLASS<initvalslist> with no 1081 // body. 1082 Record *Class = Records.getClass(Name); 1083 if (!Class) { 1084 Error(NameLoc, "Expected a class name, got '" + Name + "'"); 1085 return 0; 1086 } 1087 1088 std::vector<Init*> ValueList = ParseValueList(CurRec, Class); 1089 if (ValueList.empty()) return 0; 1090 1091 if (Lex.getCode() != tgtok::greater) { 1092 TokError("expected '>' at end of value list"); 1093 return 0; 1094 } 1095 Lex.Lex(); // eat the '>' 1096 1097 // Create the new record, set it as CurRec temporarily. 1098 static unsigned AnonCounter = 0; 1099 Record *NewRec = new Record("anonymous.val."+utostr(AnonCounter++), 1100 NameLoc, 1101 Records); 1102 SubClassReference SCRef; 1103 SCRef.RefLoc = NameLoc; 1104 SCRef.Rec = Class; 1105 SCRef.TemplateArgs = ValueList; 1106 // Add info about the subclass to NewRec. 1107 if (AddSubClass(NewRec, SCRef)) 1108 return 0; 1109 NewRec->resolveReferences(); 1110 Records.addDef(NewRec); 1111 1112 // The result of the expression is a reference to the new record. 1113 return DefInit::get(NewRec); 1114 } 1115 case tgtok::l_brace: { // Value ::= '{' ValueList '}' 1116 SMLoc BraceLoc = Lex.getLoc(); 1117 Lex.Lex(); // eat the '{' 1118 std::vector<Init*> Vals; 1119 1120 if (Lex.getCode() != tgtok::r_brace) { 1121 Vals = ParseValueList(CurRec); 1122 if (Vals.empty()) return 0; 1123 } 1124 if (Lex.getCode() != tgtok::r_brace) { 1125 TokError("expected '}' at end of bit list value"); 1126 return 0; 1127 } 1128 Lex.Lex(); // eat the '}' 1129 1130 SmallVector<Init *, 16> NewBits(Vals.size()); 1131 1132 for (unsigned i = 0, e = Vals.size(); i != e; ++i) { 1133 Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); 1134 if (Bit == 0) { 1135 Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ 1136 ") is not convertable to a bit"); 1137 return 0; 1138 } 1139 NewBits[Vals.size()-i-1] = Bit; 1140 } 1141 return BitsInit::get(NewBits); 1142 } 1143 case tgtok::l_square: { // Value ::= '[' ValueList ']' 1144 Lex.Lex(); // eat the '[' 1145 std::vector<Init*> Vals; 1146 1147 RecTy *DeducedEltTy = 0; 1148 ListRecTy *GivenListTy = 0; 1149 1150 if (ItemType != 0) { 1151 ListRecTy *ListType = dynamic_cast<ListRecTy*>(ItemType); 1152 if (ListType == 0) { 1153 std::stringstream s; 1154 s << "Type mismatch for list, expected list type, got " 1155 << ItemType->getAsString(); 1156 TokError(s.str()); 1157 return 0; 1158 } 1159 GivenListTy = ListType; 1160 } 1161 1162 if (Lex.getCode() != tgtok::r_square) { 1163 Vals = ParseValueList(CurRec, 0, 1164 GivenListTy ? GivenListTy->getElementType() : 0); 1165 if (Vals.empty()) return 0; 1166 } 1167 if (Lex.getCode() != tgtok::r_square) { 1168 TokError("expected ']' at end of list value"); 1169 return 0; 1170 } 1171 Lex.Lex(); // eat the ']' 1172 1173 RecTy *GivenEltTy = 0; 1174 if (Lex.getCode() == tgtok::less) { 1175 // Optional list element type 1176 Lex.Lex(); // eat the '<' 1177 1178 GivenEltTy = ParseType(); 1179 if (GivenEltTy == 0) { 1180 // Couldn't parse element type 1181 return 0; 1182 } 1183 1184 if (Lex.getCode() != tgtok::greater) { 1185 TokError("expected '>' at end of list element type"); 1186 return 0; 1187 } 1188 Lex.Lex(); // eat the '>' 1189 } 1190 1191 // Check elements 1192 RecTy *EltTy = 0; 1193 for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); 1194 i != ie; 1195 ++i) { 1196 TypedInit *TArg = dynamic_cast<TypedInit*>(*i); 1197 if (TArg == 0) { 1198 TokError("Untyped list element"); 1199 return 0; 1200 } 1201 if (EltTy != 0) { 1202 EltTy = resolveTypes(EltTy, TArg->getType()); 1203 if (EltTy == 0) { 1204 TokError("Incompatible types in list elements"); 1205 return 0; 1206 } 1207 } else { 1208 EltTy = TArg->getType(); 1209 } 1210 } 1211 1212 if (GivenEltTy != 0) { 1213 if (EltTy != 0) { 1214 // Verify consistency 1215 if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { 1216 TokError("Incompatible types in list elements"); 1217 return 0; 1218 } 1219 } 1220 EltTy = GivenEltTy; 1221 } 1222 1223 if (EltTy == 0) { 1224 if (ItemType == 0) { 1225 TokError("No type for list"); 1226 return 0; 1227 } 1228 DeducedEltTy = GivenListTy->getElementType(); 1229 } else { 1230 // Make sure the deduced type is compatible with the given type 1231 if (GivenListTy) { 1232 if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { 1233 TokError("Element type mismatch for list"); 1234 return 0; 1235 } 1236 } 1237 DeducedEltTy = EltTy; 1238 } 1239 1240 return ListInit::get(Vals, DeducedEltTy); 1241 } 1242 case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')' 1243 Lex.Lex(); // eat the '(' 1244 if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) { 1245 TokError("expected identifier in dag init"); 1246 return 0; 1247 } 1248 1249 Init *Operator = ParseValue(CurRec); 1250 if (Operator == 0) return 0; 1251 1252 // If the operator name is present, parse it. 1253 std::string OperatorName; 1254 if (Lex.getCode() == tgtok::colon) { 1255 if (Lex.Lex() != tgtok::VarName) { // eat the ':' 1256 TokError("expected variable name in dag operator"); 1257 return 0; 1258 } 1259 OperatorName = Lex.getCurStrVal(); 1260 Lex.Lex(); // eat the VarName. 1261 } 1262 1263 std::vector<std::pair<llvm::Init*, std::string> > DagArgs; 1264 if (Lex.getCode() != tgtok::r_paren) { 1265 DagArgs = ParseDagArgList(CurRec); 1266 if (DagArgs.empty()) return 0; 1267 } 1268 1269 if (Lex.getCode() != tgtok::r_paren) { 1270 TokError("expected ')' in dag init"); 1271 return 0; 1272 } 1273 Lex.Lex(); // eat the ')' 1274 1275 return DagInit::get(Operator, OperatorName, DagArgs); 1276 } 1277 1278 case tgtok::XHead: 1279 case tgtok::XTail: 1280 case tgtok::XEmpty: 1281 case tgtok::XCast: // Value ::= !unop '(' Value ')' 1282 case tgtok::XConcat: 1283 case tgtok::XSRA: 1284 case tgtok::XSRL: 1285 case tgtok::XSHL: 1286 case tgtok::XEq: 1287 case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')' 1288 case tgtok::XIf: 1289 case tgtok::XForEach: 1290 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 1291 return ParseOperation(CurRec); 1292 } 1293 } 1294 1295 return R; 1296} 1297 1298/// ParseValue - Parse a tblgen value. This returns null on error. 1299/// 1300/// Value ::= SimpleValue ValueSuffix* 1301/// ValueSuffix ::= '{' BitList '}' 1302/// ValueSuffix ::= '[' BitList ']' 1303/// ValueSuffix ::= '.' ID 1304/// 1305Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) { 1306 Init *Result = ParseSimpleValue(CurRec, ItemType); 1307 if (Result == 0) return 0; 1308 1309 // Parse the suffixes now if present. 1310 while (1) { 1311 switch (Lex.getCode()) { 1312 default: return Result; 1313 case tgtok::l_brace: { 1314 SMLoc CurlyLoc = Lex.getLoc(); 1315 Lex.Lex(); // eat the '{' 1316 std::vector<unsigned> Ranges = ParseRangeList(); 1317 if (Ranges.empty()) return 0; 1318 1319 // Reverse the bitlist. 1320 std::reverse(Ranges.begin(), Ranges.end()); 1321 Result = Result->convertInitializerBitRange(Ranges); 1322 if (Result == 0) { 1323 Error(CurlyLoc, "Invalid bit range for value"); 1324 return 0; 1325 } 1326 1327 // Eat the '}'. 1328 if (Lex.getCode() != tgtok::r_brace) { 1329 TokError("expected '}' at end of bit range list"); 1330 return 0; 1331 } 1332 Lex.Lex(); 1333 break; 1334 } 1335 case tgtok::l_square: { 1336 SMLoc SquareLoc = Lex.getLoc(); 1337 Lex.Lex(); // eat the '[' 1338 std::vector<unsigned> Ranges = ParseRangeList(); 1339 if (Ranges.empty()) return 0; 1340 1341 Result = Result->convertInitListSlice(Ranges); 1342 if (Result == 0) { 1343 Error(SquareLoc, "Invalid range for list slice"); 1344 return 0; 1345 } 1346 1347 // Eat the ']'. 1348 if (Lex.getCode() != tgtok::r_square) { 1349 TokError("expected ']' at end of list slice"); 1350 return 0; 1351 } 1352 Lex.Lex(); 1353 break; 1354 } 1355 case tgtok::period: 1356 if (Lex.Lex() != tgtok::Id) { // eat the . 1357 TokError("expected field identifier after '.'"); 1358 return 0; 1359 } 1360 if (!Result->getFieldType(Lex.getCurStrVal())) { 1361 TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + 1362 Result->getAsString() + "'"); 1363 return 0; 1364 } 1365 Result = FieldInit::get(Result, Lex.getCurStrVal()); 1366 Lex.Lex(); // eat field name 1367 break; 1368 } 1369 } 1370} 1371 1372/// ParseDagArgList - Parse the argument list for a dag literal expression. 1373/// 1374/// ParseDagArgList ::= Value (':' VARNAME)? 1375/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)? 1376std::vector<std::pair<llvm::Init*, std::string> > 1377TGParser::ParseDagArgList(Record *CurRec) { 1378 std::vector<std::pair<llvm::Init*, std::string> > Result; 1379 1380 while (1) { 1381 Init *Val = ParseValue(CurRec); 1382 if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >(); 1383 1384 // If the variable name is present, add it. 1385 std::string VarName; 1386 if (Lex.getCode() == tgtok::colon) { 1387 if (Lex.Lex() != tgtok::VarName) { // eat the ':' 1388 TokError("expected variable name in dag literal"); 1389 return std::vector<std::pair<llvm::Init*, std::string> >(); 1390 } 1391 VarName = Lex.getCurStrVal(); 1392 Lex.Lex(); // eat the VarName. 1393 } 1394 1395 Result.push_back(std::make_pair(Val, VarName)); 1396 1397 if (Lex.getCode() != tgtok::comma) break; 1398 Lex.Lex(); // eat the ',' 1399 } 1400 1401 return Result; 1402} 1403 1404 1405/// ParseValueList - Parse a comma separated list of values, returning them as a 1406/// vector. Note that this always expects to be able to parse at least one 1407/// value. It returns an empty list if this is not possible. 1408/// 1409/// ValueList ::= Value (',' Value) 1410/// 1411std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, 1412 RecTy *EltTy) { 1413 std::vector<Init*> Result; 1414 RecTy *ItemType = EltTy; 1415 unsigned int ArgN = 0; 1416 if (ArgsRec != 0 && EltTy == 0) { 1417 const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs(); 1418 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1419 if (!RV) { 1420 errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN] 1421 << ")\n"; 1422 } 1423 assert(RV && "Template argument record not found??"); 1424 ItemType = RV->getType(); 1425 ++ArgN; 1426 } 1427 Result.push_back(ParseValue(CurRec, ItemType)); 1428 if (Result.back() == 0) return std::vector<Init*>(); 1429 1430 while (Lex.getCode() == tgtok::comma) { 1431 Lex.Lex(); // Eat the comma 1432 1433 if (ArgsRec != 0 && EltTy == 0) { 1434 const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs(); 1435 if (ArgN >= TArgs.size()) { 1436 TokError("too many template arguments"); 1437 return std::vector<Init*>(); 1438 } 1439 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1440 assert(RV && "Template argument record not found??"); 1441 ItemType = RV->getType(); 1442 ++ArgN; 1443 } 1444 Result.push_back(ParseValue(CurRec, ItemType)); 1445 if (Result.back() == 0) return std::vector<Init*>(); 1446 } 1447 1448 return Result; 1449} 1450 1451 1452/// ParseDeclaration - Read a declaration, returning the name of field ID, or an 1453/// empty string on error. This can happen in a number of different context's, 1454/// including within a def or in the template args for a def (which which case 1455/// CurRec will be non-null) and within the template args for a multiclass (in 1456/// which case CurRec will be null, but CurMultiClass will be set). This can 1457/// also happen within a def that is within a multiclass, which will set both 1458/// CurRec and CurMultiClass. 1459/// 1460/// Declaration ::= FIELD? Type ID ('=' Value)? 1461/// 1462std::string TGParser::ParseDeclaration(Record *CurRec, 1463 bool ParsingTemplateArgs) { 1464 // Read the field prefix if present. 1465 bool HasField = Lex.getCode() == tgtok::Field; 1466 if (HasField) Lex.Lex(); 1467 1468 RecTy *Type = ParseType(); 1469 if (Type == 0) return ""; 1470 1471 if (Lex.getCode() != tgtok::Id) { 1472 TokError("Expected identifier in declaration"); 1473 return ""; 1474 } 1475 1476 SMLoc IdLoc = Lex.getLoc(); 1477 std::string DeclName = Lex.getCurStrVal(); 1478 Lex.Lex(); 1479 1480 if (ParsingTemplateArgs) { 1481 if (CurRec) { 1482 DeclName = CurRec->getName() + ":" + DeclName; 1483 } else { 1484 assert(CurMultiClass); 1485 } 1486 if (CurMultiClass) 1487 DeclName = CurMultiClass->Rec.getName() + "::" + DeclName; 1488 } 1489 1490 // Add the value. 1491 if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField))) 1492 return ""; 1493 1494 // If a value is present, parse it. 1495 if (Lex.getCode() == tgtok::equal) { 1496 Lex.Lex(); 1497 SMLoc ValLoc = Lex.getLoc(); 1498 Init *Val = ParseValue(CurRec, Type); 1499 if (Val == 0 || 1500 SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val)) 1501 return ""; 1502 } 1503 1504 return DeclName; 1505} 1506 1507/// ParseTemplateArgList - Read a template argument list, which is a non-empty 1508/// sequence of template-declarations in <>'s. If CurRec is non-null, these are 1509/// template args for a def, which may or may not be in a multiclass. If null, 1510/// these are the template args for a multiclass. 1511/// 1512/// TemplateArgList ::= '<' Declaration (',' Declaration)* '>' 1513/// 1514bool TGParser::ParseTemplateArgList(Record *CurRec) { 1515 assert(Lex.getCode() == tgtok::less && "Not a template arg list!"); 1516 Lex.Lex(); // eat the '<' 1517 1518 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec; 1519 1520 // Read the first declaration. 1521 std::string TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1522 if (TemplArg.empty()) 1523 return true; 1524 1525 TheRecToAddTo->addTemplateArg(TemplArg); 1526 1527 while (Lex.getCode() == tgtok::comma) { 1528 Lex.Lex(); // eat the ',' 1529 1530 // Read the following declarations. 1531 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1532 if (TemplArg.empty()) 1533 return true; 1534 TheRecToAddTo->addTemplateArg(TemplArg); 1535 } 1536 1537 if (Lex.getCode() != tgtok::greater) 1538 return TokError("expected '>' at end of template argument list"); 1539 Lex.Lex(); // eat the '>'. 1540 return false; 1541} 1542 1543 1544/// ParseBodyItem - Parse a single item at within the body of a def or class. 1545/// 1546/// BodyItem ::= Declaration ';' 1547/// BodyItem ::= LET ID OptionalBitList '=' Value ';' 1548bool TGParser::ParseBodyItem(Record *CurRec) { 1549 if (Lex.getCode() != tgtok::Let) { 1550 if (ParseDeclaration(CurRec, false).empty()) 1551 return true; 1552 1553 if (Lex.getCode() != tgtok::semi) 1554 return TokError("expected ';' after declaration"); 1555 Lex.Lex(); 1556 return false; 1557 } 1558 1559 // LET ID OptionalRangeList '=' Value ';' 1560 if (Lex.Lex() != tgtok::Id) 1561 return TokError("expected field identifier after let"); 1562 1563 SMLoc IdLoc = Lex.getLoc(); 1564 std::string FieldName = Lex.getCurStrVal(); 1565 Lex.Lex(); // eat the field name. 1566 1567 std::vector<unsigned> BitList; 1568 if (ParseOptionalBitList(BitList)) 1569 return true; 1570 std::reverse(BitList.begin(), BitList.end()); 1571 1572 if (Lex.getCode() != tgtok::equal) 1573 return TokError("expected '=' in let expression"); 1574 Lex.Lex(); // eat the '='. 1575 1576 RecordVal *Field = CurRec->getValue(FieldName); 1577 if (Field == 0) 1578 return TokError("Value '" + FieldName + "' unknown!"); 1579 1580 RecTy *Type = Field->getType(); 1581 1582 Init *Val = ParseValue(CurRec, Type); 1583 if (Val == 0) return true; 1584 1585 if (Lex.getCode() != tgtok::semi) 1586 return TokError("expected ';' after let expression"); 1587 Lex.Lex(); 1588 1589 return SetValue(CurRec, IdLoc, FieldName, BitList, Val); 1590} 1591 1592/// ParseBody - Read the body of a class or def. Return true on error, false on 1593/// success. 1594/// 1595/// Body ::= ';' 1596/// Body ::= '{' BodyList '}' 1597/// BodyList BodyItem* 1598/// 1599bool TGParser::ParseBody(Record *CurRec) { 1600 // If this is a null definition, just eat the semi and return. 1601 if (Lex.getCode() == tgtok::semi) { 1602 Lex.Lex(); 1603 return false; 1604 } 1605 1606 if (Lex.getCode() != tgtok::l_brace) 1607 return TokError("Expected ';' or '{' to start body"); 1608 // Eat the '{'. 1609 Lex.Lex(); 1610 1611 while (Lex.getCode() != tgtok::r_brace) 1612 if (ParseBodyItem(CurRec)) 1613 return true; 1614 1615 // Eat the '}'. 1616 Lex.Lex(); 1617 return false; 1618} 1619 1620/// ParseObjectBody - Parse the body of a def or class. This consists of an 1621/// optional ClassList followed by a Body. CurRec is the current def or class 1622/// that is being parsed. 1623/// 1624/// ObjectBody ::= BaseClassList Body 1625/// BaseClassList ::= /*empty*/ 1626/// BaseClassList ::= ':' BaseClassListNE 1627/// BaseClassListNE ::= SubClassRef (',' SubClassRef)* 1628/// 1629bool TGParser::ParseObjectBody(Record *CurRec) { 1630 // If there is a baseclass list, read it. 1631 if (Lex.getCode() == tgtok::colon) { 1632 Lex.Lex(); 1633 1634 // Read all of the subclasses. 1635 SubClassReference SubClass = ParseSubClassReference(CurRec, false); 1636 while (1) { 1637 // Check for error. 1638 if (SubClass.Rec == 0) return true; 1639 1640 // Add it. 1641 if (AddSubClass(CurRec, SubClass)) 1642 return true; 1643 1644 if (Lex.getCode() != tgtok::comma) break; 1645 Lex.Lex(); // eat ','. 1646 SubClass = ParseSubClassReference(CurRec, false); 1647 } 1648 } 1649 1650 // Process any variables on the let stack. 1651 for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 1652 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 1653 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 1654 LetStack[i][j].Bits, LetStack[i][j].Value)) 1655 return true; 1656 1657 return ParseBody(CurRec); 1658} 1659 1660/// ParseDef - Parse and return a top level or multiclass def, return the record 1661/// corresponding to it. This returns null on error. 1662/// 1663/// DefInst ::= DEF ObjectName ObjectBody 1664/// 1665bool TGParser::ParseDef(MultiClass *CurMultiClass) { 1666 SMLoc DefLoc = Lex.getLoc(); 1667 assert(Lex.getCode() == tgtok::Def && "Unknown tok"); 1668 Lex.Lex(); // Eat the 'def' token. 1669 1670 // Parse ObjectName and make a record for it. 1671 Record *CurRec = new Record(ParseObjectName(), DefLoc, Records); 1672 1673 if (!CurMultiClass) { 1674 // Top-level def definition. 1675 1676 // Ensure redefinition doesn't happen. 1677 if (Records.getDef(CurRec->getName())) { 1678 Error(DefLoc, "def '" + CurRec->getName() + "' already defined"); 1679 return true; 1680 } 1681 Records.addDef(CurRec); 1682 } else { 1683 // Otherwise, a def inside a multiclass, add it to the multiclass. 1684 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i) 1685 if (CurMultiClass->DefPrototypes[i]->getName() == CurRec->getName()) { 1686 Error(DefLoc, "def '" + CurRec->getName() + 1687 "' already defined in this multiclass!"); 1688 return true; 1689 } 1690 CurMultiClass->DefPrototypes.push_back(CurRec); 1691 } 1692 1693 if (ParseObjectBody(CurRec)) 1694 return true; 1695 1696 if (CurMultiClass == 0) // Def's in multiclasses aren't really defs. 1697 // See Record::setName(). This resolve step will see any new name 1698 // for the def that might have been created when resolving 1699 // inheritance, values and arguments above. 1700 CurRec->resolveReferences(); 1701 1702 // If ObjectBody has template arguments, it's an error. 1703 assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?"); 1704 1705 if (CurMultiClass) { 1706 // Copy the template arguments for the multiclass into the def. 1707 const std::vector<std::string> &TArgs = 1708 CurMultiClass->Rec.getTemplateArgs(); 1709 1710 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1711 const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); 1712 assert(RV && "Template arg doesn't exist?"); 1713 CurRec->addValue(*RV); 1714 } 1715 } 1716 1717 return false; 1718} 1719 1720 1721/// ParseClass - Parse a tblgen class definition. 1722/// 1723/// ClassInst ::= CLASS ID TemplateArgList? ObjectBody 1724/// 1725bool TGParser::ParseClass() { 1726 assert(Lex.getCode() == tgtok::Class && "Unexpected token!"); 1727 Lex.Lex(); 1728 1729 if (Lex.getCode() != tgtok::Id) 1730 return TokError("expected class name after 'class' keyword"); 1731 1732 Record *CurRec = Records.getClass(Lex.getCurStrVal()); 1733 if (CurRec) { 1734 // If the body was previously defined, this is an error. 1735 if (!CurRec->getValues().empty() || 1736 !CurRec->getSuperClasses().empty() || 1737 !CurRec->getTemplateArgs().empty()) 1738 return TokError("Class '" + CurRec->getName() + "' already defined"); 1739 } else { 1740 // If this is the first reference to this class, create and add it. 1741 CurRec = new Record(Lex.getCurStrVal(), Lex.getLoc(), Records); 1742 Records.addClass(CurRec); 1743 } 1744 Lex.Lex(); // eat the name. 1745 1746 // If there are template args, parse them. 1747 if (Lex.getCode() == tgtok::less) 1748 if (ParseTemplateArgList(CurRec)) 1749 return true; 1750 1751 // Finally, parse the object body. 1752 return ParseObjectBody(CurRec); 1753} 1754 1755/// ParseLetList - Parse a non-empty list of assignment expressions into a list 1756/// of LetRecords. 1757/// 1758/// LetList ::= LetItem (',' LetItem)* 1759/// LetItem ::= ID OptionalRangeList '=' Value 1760/// 1761std::vector<LetRecord> TGParser::ParseLetList() { 1762 std::vector<LetRecord> Result; 1763 1764 while (1) { 1765 if (Lex.getCode() != tgtok::Id) { 1766 TokError("expected identifier in let definition"); 1767 return std::vector<LetRecord>(); 1768 } 1769 std::string Name = Lex.getCurStrVal(); 1770 SMLoc NameLoc = Lex.getLoc(); 1771 Lex.Lex(); // Eat the identifier. 1772 1773 // Check for an optional RangeList. 1774 std::vector<unsigned> Bits; 1775 if (ParseOptionalRangeList(Bits)) 1776 return std::vector<LetRecord>(); 1777 std::reverse(Bits.begin(), Bits.end()); 1778 1779 if (Lex.getCode() != tgtok::equal) { 1780 TokError("expected '=' in let expression"); 1781 return std::vector<LetRecord>(); 1782 } 1783 Lex.Lex(); // eat the '='. 1784 1785 Init *Val = ParseValue(0); 1786 if (Val == 0) return std::vector<LetRecord>(); 1787 1788 // Now that we have everything, add the record. 1789 Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); 1790 1791 if (Lex.getCode() != tgtok::comma) 1792 return Result; 1793 Lex.Lex(); // eat the comma. 1794 } 1795} 1796 1797/// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of 1798/// different related productions. This works inside multiclasses too. 1799/// 1800/// Object ::= LET LetList IN '{' ObjectList '}' 1801/// Object ::= LET LetList IN Object 1802/// 1803bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { 1804 assert(Lex.getCode() == tgtok::Let && "Unexpected token"); 1805 Lex.Lex(); 1806 1807 // Add this entry to the let stack. 1808 std::vector<LetRecord> LetInfo = ParseLetList(); 1809 if (LetInfo.empty()) return true; 1810 LetStack.push_back(LetInfo); 1811 1812 if (Lex.getCode() != tgtok::In) 1813 return TokError("expected 'in' at end of top-level 'let'"); 1814 Lex.Lex(); 1815 1816 // If this is a scalar let, just handle it now 1817 if (Lex.getCode() != tgtok::l_brace) { 1818 // LET LetList IN Object 1819 if (ParseObject(CurMultiClass)) 1820 return true; 1821 } else { // Object ::= LETCommand '{' ObjectList '}' 1822 SMLoc BraceLoc = Lex.getLoc(); 1823 // Otherwise, this is a group let. 1824 Lex.Lex(); // eat the '{'. 1825 1826 // Parse the object list. 1827 if (ParseObjectList(CurMultiClass)) 1828 return true; 1829 1830 if (Lex.getCode() != tgtok::r_brace) { 1831 TokError("expected '}' at end of top level let command"); 1832 return Error(BraceLoc, "to match this '{'"); 1833 } 1834 Lex.Lex(); 1835 } 1836 1837 // Outside this let scope, this let block is not active. 1838 LetStack.pop_back(); 1839 return false; 1840} 1841 1842/// ParseMultiClass - Parse a multiclass definition. 1843/// 1844/// MultiClassInst ::= MULTICLASS ID TemplateArgList? 1845/// ':' BaseMultiClassList '{' MultiClassDef+ '}' 1846/// 1847bool TGParser::ParseMultiClass() { 1848 assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token"); 1849 Lex.Lex(); // Eat the multiclass token. 1850 1851 if (Lex.getCode() != tgtok::Id) 1852 return TokError("expected identifier after multiclass for name"); 1853 std::string Name = Lex.getCurStrVal(); 1854 1855 if (MultiClasses.count(Name)) 1856 return TokError("multiclass '" + Name + "' already defined"); 1857 1858 CurMultiClass = MultiClasses[Name] = new MultiClass(Name, 1859 Lex.getLoc(), Records); 1860 Lex.Lex(); // Eat the identifier. 1861 1862 // If there are template args, parse them. 1863 if (Lex.getCode() == tgtok::less) 1864 if (ParseTemplateArgList(0)) 1865 return true; 1866 1867 bool inherits = false; 1868 1869 // If there are submulticlasses, parse them. 1870 if (Lex.getCode() == tgtok::colon) { 1871 inherits = true; 1872 1873 Lex.Lex(); 1874 1875 // Read all of the submulticlasses. 1876 SubMultiClassReference SubMultiClass = 1877 ParseSubMultiClassReference(CurMultiClass); 1878 while (1) { 1879 // Check for error. 1880 if (SubMultiClass.MC == 0) return true; 1881 1882 // Add it. 1883 if (AddSubMultiClass(CurMultiClass, SubMultiClass)) 1884 return true; 1885 1886 if (Lex.getCode() != tgtok::comma) break; 1887 Lex.Lex(); // eat ','. 1888 SubMultiClass = ParseSubMultiClassReference(CurMultiClass); 1889 } 1890 } 1891 1892 if (Lex.getCode() != tgtok::l_brace) { 1893 if (!inherits) 1894 return TokError("expected '{' in multiclass definition"); 1895 else if (Lex.getCode() != tgtok::semi) 1896 return TokError("expected ';' in multiclass definition"); 1897 else 1898 Lex.Lex(); // eat the ';'. 1899 } else { 1900 if (Lex.Lex() == tgtok::r_brace) // eat the '{'. 1901 return TokError("multiclass must contain at least one def"); 1902 1903 while (Lex.getCode() != tgtok::r_brace) { 1904 switch (Lex.getCode()) { 1905 default: 1906 return TokError("expected 'let', 'def' or 'defm' in multiclass body"); 1907 case tgtok::Let: 1908 case tgtok::Def: 1909 case tgtok::Defm: 1910 if (ParseObject(CurMultiClass)) 1911 return true; 1912 break; 1913 } 1914 } 1915 Lex.Lex(); // eat the '}'. 1916 } 1917 1918 CurMultiClass = 0; 1919 return false; 1920} 1921 1922/// ParseDefm - Parse the instantiation of a multiclass. 1923/// 1924/// DefMInst ::= DEFM ID ':' DefmSubClassRef ';' 1925/// 1926bool TGParser::ParseDefm(MultiClass *CurMultiClass) { 1927 assert(Lex.getCode() == tgtok::Defm && "Unexpected token!"); 1928 1929 std::string DefmPrefix; 1930 if (Lex.Lex() == tgtok::Id) { // eat the defm. 1931 DefmPrefix = Lex.getCurStrVal(); 1932 Lex.Lex(); // Eat the defm prefix. 1933 } 1934 1935 SMLoc DefmPrefixLoc = Lex.getLoc(); 1936 if (Lex.getCode() != tgtok::colon) 1937 return TokError("expected ':' after defm identifier"); 1938 1939 // Keep track of the new generated record definitions. 1940 std::vector<Record*> NewRecDefs; 1941 1942 // This record also inherits from a regular class (non-multiclass)? 1943 bool InheritFromClass = false; 1944 1945 // eat the colon. 1946 Lex.Lex(); 1947 1948 SMLoc SubClassLoc = Lex.getLoc(); 1949 SubClassReference Ref = ParseSubClassReference(0, true); 1950 1951 while (1) { 1952 if (Ref.Rec == 0) return true; 1953 1954 // To instantiate a multiclass, we need to first get the multiclass, then 1955 // instantiate each def contained in the multiclass with the SubClassRef 1956 // template parameters. 1957 MultiClass *MC = MultiClasses[Ref.Rec->getName()]; 1958 assert(MC && "Didn't lookup multiclass correctly?"); 1959 std::vector<Init*> &TemplateVals = Ref.TemplateArgs; 1960 1961 // Verify that the correct number of template arguments were specified. 1962 const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs(); 1963 if (TArgs.size() < TemplateVals.size()) 1964 return Error(SubClassLoc, 1965 "more template args specified than multiclass expects"); 1966 1967 // Loop over all the def's in the multiclass, instantiating each one. 1968 for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) { 1969 Record *DefProto = MC->DefPrototypes[i]; 1970 1971 // Add in the defm name. If the defm prefix is empty, give each 1972 // instantiated def a unique name. Otherwise, if "#NAME#" exists in the 1973 // name, substitute the prefix for #NAME#. Otherwise, use the defm name 1974 // as a prefix. 1975 std::string DefName = DefProto->getName(); 1976 if (DefmPrefix.empty()) { 1977 DefName = GetNewAnonymousName(); 1978 } else { 1979 std::string::size_type idx = DefName.find("#NAME#"); 1980 if (idx != std::string::npos) { 1981 DefName.replace(idx, 6, DefmPrefix); 1982 } else { 1983 // Add the suffix to the defm name to get the new name. 1984 DefName = DefmPrefix + DefName; 1985 } 1986 } 1987 1988 Record *CurRec = new Record(DefName, DefmPrefixLoc, Records); 1989 1990 SubClassReference Ref; 1991 Ref.RefLoc = DefmPrefixLoc; 1992 Ref.Rec = DefProto; 1993 AddSubClass(CurRec, Ref); 1994 1995 // Loop over all of the template arguments, setting them to the specified 1996 // value or leaving them as the default if necessary. 1997 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1998 // Check if a value is specified for this temp-arg. 1999 if (i < TemplateVals.size()) { 2000 // Set it now. 2001 if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(), 2002 TemplateVals[i])) 2003 return true; 2004 2005 // Resolve it next. 2006 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 2007 2008 // Now remove it. 2009 CurRec->removeValue(TArgs[i]); 2010 2011 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 2012 return Error(SubClassLoc, 2013 "value not specified for template argument #"+ 2014 utostr(i) + " (" + TArgs[i] + ") of multiclassclass '" + 2015 MC->Rec.getName() + "'"); 2016 } 2017 } 2018 2019 // If the mdef is inside a 'let' expression, add to each def. 2020 for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 2021 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 2022 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 2023 LetStack[i][j].Bits, LetStack[i][j].Value)) { 2024 Error(DefmPrefixLoc, "when instantiating this defm"); 2025 return true; 2026 } 2027 2028 // Ensure redefinition doesn't happen. 2029 if (Records.getDef(CurRec->getName())) 2030 return Error(DefmPrefixLoc, "def '" + CurRec->getName() + 2031 "' already defined, instantiating defm with subdef '" + 2032 DefProto->getName() + "'"); 2033 2034 // Don't create a top level definition for defm inside multiclasses, 2035 // instead, only update the prototypes and bind the template args 2036 // with the new created definition. 2037 if (CurMultiClass) { 2038 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); 2039 i != e; ++i) { 2040 if (CurMultiClass->DefPrototypes[i]->getName() == CurRec->getName()) { 2041 Error(DefmPrefixLoc, "defm '" + CurRec->getName() + 2042 "' already defined in this multiclass!"); 2043 return 0; 2044 } 2045 } 2046 CurMultiClass->DefPrototypes.push_back(CurRec); 2047 2048 // Copy the template arguments for the multiclass into the new def. 2049 const std::vector<std::string> &TA = 2050 CurMultiClass->Rec.getTemplateArgs(); 2051 2052 for (unsigned i = 0, e = TA.size(); i != e; ++i) { 2053 const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]); 2054 assert(RV && "Template arg doesn't exist?"); 2055 CurRec->addValue(*RV); 2056 } 2057 } else { 2058 Records.addDef(CurRec); 2059 } 2060 2061 NewRecDefs.push_back(CurRec); 2062 } 2063 2064 if (Lex.getCode() != tgtok::comma) break; 2065 Lex.Lex(); // eat ','. 2066 2067 SubClassLoc = Lex.getLoc(); 2068 2069 // A defm can inherit from regular classes (non-multiclass) as 2070 // long as they come in the end of the inheritance list. 2071 InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0); 2072 2073 if (InheritFromClass) 2074 break; 2075 2076 Ref = ParseSubClassReference(0, true); 2077 } 2078 2079 if (InheritFromClass) { 2080 // Process all the classes to inherit as if they were part of a 2081 // regular 'def' and inherit all record values. 2082 SubClassReference SubClass = ParseSubClassReference(0, false); 2083 while (1) { 2084 // Check for error. 2085 if (SubClass.Rec == 0) return true; 2086 2087 // Get the expanded definition prototypes and teach them about 2088 // the record values the current class to inherit has 2089 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) { 2090 Record *CurRec = NewRecDefs[i]; 2091 2092 // Add it. 2093 if (AddSubClass(CurRec, SubClass)) 2094 return true; 2095 2096 // Process any variables on the let stack. 2097 for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 2098 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 2099 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 2100 LetStack[i][j].Bits, LetStack[i][j].Value)) 2101 return true; 2102 } 2103 2104 if (Lex.getCode() != tgtok::comma) break; 2105 Lex.Lex(); // eat ','. 2106 SubClass = ParseSubClassReference(0, false); 2107 } 2108 } 2109 2110 if (!CurMultiClass) 2111 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) 2112 // See Record::setName(). This resolve step will see any new 2113 // name for the def that might have been created when resolving 2114 // inheritance, values and arguments above. 2115 NewRecDefs[i]->resolveReferences(); 2116 2117 if (Lex.getCode() != tgtok::semi) 2118 return TokError("expected ';' at end of defm"); 2119 Lex.Lex(); 2120 2121 return false; 2122} 2123 2124/// ParseObject 2125/// Object ::= ClassInst 2126/// Object ::= DefInst 2127/// Object ::= MultiClassInst 2128/// Object ::= DefMInst 2129/// Object ::= LETCommand '{' ObjectList '}' 2130/// Object ::= LETCommand Object 2131bool TGParser::ParseObject(MultiClass *MC) { 2132 switch (Lex.getCode()) { 2133 default: 2134 return TokError("Expected class, def, defm, multiclass or let definition"); 2135 case tgtok::Let: return ParseTopLevelLet(MC); 2136 case tgtok::Def: return ParseDef(MC); 2137 case tgtok::Defm: return ParseDefm(MC); 2138 case tgtok::Class: return ParseClass(); 2139 case tgtok::MultiClass: return ParseMultiClass(); 2140 } 2141} 2142 2143/// ParseObjectList 2144/// ObjectList :== Object* 2145bool TGParser::ParseObjectList(MultiClass *MC) { 2146 while (isObjectStart(Lex.getCode())) { 2147 if (ParseObject(MC)) 2148 return true; 2149 } 2150 return false; 2151} 2152 2153bool TGParser::ParseFile() { 2154 Lex.Lex(); // Prime the lexer. 2155 if (ParseObjectList()) return true; 2156 2157 // If we have unread input at the end of the file, report it. 2158 if (Lex.getCode() == tgtok::Eof) 2159 return false; 2160 2161 return TokError("Unexpected input at top level"); 2162} 2163 2164