utils/TableGen/TGParser.cpp

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