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 <algorithm>
  15
  16 #include "TGParser.h"
  17 #include "Record.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 using namespace llvm;
  20
  21 //===----------------------------------------------------------------------===//
  22 // Support Code for the Semantic Actions.
  23 //===----------------------------------------------------------------------===//
  24
  25 namespace llvm {
  26 struct MultiClass {
  27   Record Rec;  // Placeholder for template args and Name.
  28   std::vector<Record*> DefPrototypes;
  29
  30   MultiClass(const std::string &Name) : Rec(Name) {}
  31 };
  32
  33 struct SubClassReference {
  34   TGParser::LocTy RefLoc;
  35   Record *Rec;
  36   std::vector<Init*> TemplateArgs;
  37   SubClassReference() : RefLoc(0), Rec(0) {}
  38
  39   bool isInvalid() const { return Rec == 0; }
  40 };
  41
  42 } // end namespace llvm
  43
  44 bool TGParser::AddValue(Record *CurRec, LocTy Loc, const RecordVal &RV) {
  45   if (CurRec == 0)
  46     CurRec = &CurMultiClass->Rec;
  47
  48   if (RecordVal *ERV = CurRec->getValue(RV.getName())) {
  49     // The value already exists in the class, treat this as a set.
  50     if (ERV->setValue(RV.getValue()))
  51       return Error(Loc, "New definition of '" + RV.getName() + "' of type '" +
  52                    RV.getType()->getAsString() + "' is incompatible with " +
  53                    "previous definition of type '" +
  54                    ERV->getType()->getAsString() + "'");
  55   } else {
  56     CurRec->addValue(RV);
  57   }
  58   return false;
  59 }
  60
  61 /// SetValue -
  62 /// Return true on error, false on success.
  63 bool TGParser::SetValue(Record *CurRec, LocTy Loc, const std::string &ValName,
  64                         const std::vector<unsigned> &BitList, Init *V) {
  65   if (!V) return false;
  66
  67   if (CurRec == 0) CurRec = &CurMultiClass->Rec;
  68
  69   RecordVal *RV = CurRec->getValue(ValName);
  70   if (RV == 0)
  71     return Error(Loc, "Value '" + ValName + "' unknown!");
  72
  73   // Do not allow assignments like 'X = X'.  This will just cause infinite loops
  74   // in the resolution machinery.
  75   if (BitList.empty())
  76     if (VarInit *VI = dynamic_cast<VarInit*>(V))
  77       if (VI->getName() == ValName)
  78         return false;
  79
  80   // If we are assigning to a subset of the bits in the value... then we must be
  81   // assigning to a field of BitsRecTy, which must have a BitsInit
  82   // initializer.
  83   //
  84   if (!BitList.empty()) {
  85     BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
  86     if (CurVal == 0)
  87       return Error(Loc, "Value '" + ValName + "' is not a bits type");
  88
  89     // Convert the incoming value to a bits type of the appropriate size...
  90     Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
  91     if (BI == 0) {
  92       V->convertInitializerTo(new BitsRecTy(BitList.size()));
  93       return Error(Loc, "Initializer is not compatible with bit range");
  94     }
  95
  96     // We should have a BitsInit type now.
  97     BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
  98     assert(BInit != 0);
  99
 100     BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
 101
 102     // Loop over bits, assigning values as appropriate.
 103     for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
 104       unsigned Bit = BitList[i];
 105       if (NewVal->getBit(Bit))
 106         return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
 107                      ValName + "' more than once");
 108       NewVal->setBit(Bit, BInit->getBit(i));
 109     }
 110
 111     for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
 112       if (NewVal->getBit(i) == 0)
 113         NewVal->setBit(i, CurVal->getBit(i));
 114
 115     V = NewVal;
 116   }
 117
 118   if (RV->setValue(V))
 119    return Error(Loc, "Value '" + ValName + "' of type '" +
 120                 RV->getType()->getAsString() +
 121                 "' is incompatible with initializer '" + V->getAsString() +"'");
 122   return false;
 123 }
 124
 125 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
 126 /// args as SubClass's template arguments.
 127 bool TGParser::AddSubClass(Record *CurRec, class SubClassReference &SubClass) {
 128   Record *SC = SubClass.Rec;
 129   // Add all of the values in the subclass into the current class.
 130   const std::vector<RecordVal> &Vals = SC->getValues();
 131   for (unsigned i = 0, e = Vals.size(); i != e; ++i)
 132     if (AddValue(CurRec, SubClass.RefLoc, Vals[i]))
 133       return true;
 134
 135   const std::vector<std::string> &TArgs = SC->getTemplateArgs();
 136
 137   // Ensure that an appropriate number of template arguments are specified.
 138   if (TArgs.size() < SubClass.TemplateArgs.size())
 139     return Error(SubClass.RefLoc, "More template args specified than expected");
 140
 141   // Loop over all of the template arguments, setting them to the specified
 142   // value or leaving them as the default if necessary.
 143   for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
 144     if (i < SubClass.TemplateArgs.size()) {
 145       // If a value is specified for this template arg, set it now.
 146       if (SetValue(CurRec, SubClass.RefLoc, TArgs[i], std::vector<unsigned>(),
 147                    SubClass.TemplateArgs[i]))
 148         return true;
 149
 150       // Resolve it next.
 151       CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
 152
 153       // Now remove it.
 154       CurRec->removeValue(TArgs[i]);
 155
 156     } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
 157       return Error(SubClass.RefLoc,"Value not specified for template argument #"
 158                    + utostr(i) + " (" + TArgs[i] + ") of subclass '" +
 159                    SC->getName() + "'!");
 160     }
 161   }
 162
 163   // Since everything went well, we can now set the "superclass" list for the
 164   // current record.
 165   const std::vector<Record*> &SCs = SC->getSuperClasses();
 166   for (unsigned i = 0, e = SCs.size(); i != e; ++i) {
 167     if (CurRec->isSubClassOf(SCs[i]))
 168       return Error(SubClass.RefLoc,
 169                    "Already subclass of '" + SCs[i]->getName() + "'!\n");
 170     CurRec->addSuperClass(SCs[i]);
 171   }
 172
 173   if (CurRec->isSubClassOf(SC))
 174     return Error(SubClass.RefLoc,
 175                  "Already subclass of '" + SC->getName() + "'!\n");
 176   CurRec->addSuperClass(SC);
 177   return false;
 178 }
 179
 180 //===----------------------------------------------------------------------===//
 181 // Parser Code
 182 //===----------------------------------------------------------------------===//
 183
 184 /// isObjectStart - Return true if this is a valid first token for an Object.
 185 static bool isObjectStart(tgtok::TokKind K) {
 186   return K == tgtok::Class || K == tgtok::Def ||
 187          K == tgtok::Defm || K == tgtok::Let || K == tgtok::MultiClass;
 188 }
 189
 190 /// ParseObjectName - If an object name is specified, return it.  Otherwise,
 191 /// return an anonymous name.
 192 ///   ObjectName ::= ID
 193 ///   ObjectName ::= /*empty*/
 194 ///
 195 std::string TGParser::ParseObjectName() {
 196   if (Lex.getCode() == tgtok::Id) {
 197     std::string Ret = Lex.getCurStrVal();
 198     Lex.Lex();
 199     return Ret;
 200   }
 201
 202   static unsigned AnonCounter = 0;
 203   return "anonymous."+utostr(AnonCounter++);
 204 }
 205
 206
 207 /// ParseClassID - Parse and resolve a reference to a class name.  This returns
 208 /// null on error.
 209 ///
 210 ///    ClassID ::= ID
 211 ///
 212 Record *TGParser::ParseClassID() {
 213   if (Lex.getCode() != tgtok::Id) {
 214     TokError("expected name for ClassID");
 215     return 0;
 216   }
 217
 218   Record *Result = Records.getClass(Lex.getCurStrVal());
 219   if (Result == 0)
 220     TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");
 221
 222   Lex.Lex();
 223   return Result;
 224 }
 225
 226 Record *TGParser::ParseDefmID() {
 227   if (Lex.getCode() != tgtok::Id) {
 228     TokError("expected multiclass name");
 229     return 0;
 230   }
 231
 232   MultiClass *MC = MultiClasses[Lex.getCurStrVal()];
 233   if (MC == 0) {
 234     TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");
 235     return 0;
 236   }
 237
 238   Lex.Lex();
 239   return &MC->Rec;
 240 }
 241
 242
 243
 244 /// ParseSubClassReference - Parse a reference to a subclass or to a templated
 245 /// subclass.  This returns a SubClassRefTy with a null Record* on error.
 246 ///
 247 ///  SubClassRef ::= ClassID
 248 ///  SubClassRef ::= ClassID '<' ValueList '>'
 249 ///
 250 SubClassReference TGParser::
 251 ParseSubClassReference(Record *CurRec, bool isDefm) {
 252   SubClassReference Result;
 253   Result.RefLoc = Lex.getLoc();
 254
 255   if (isDefm)
 256     Result.Rec = ParseDefmID();
 257   else
 258     Result.Rec = ParseClassID();
 259   if (Result.Rec == 0) return Result;
 260
 261   // If there is no template arg list, we're done.
 262   if (Lex.getCode() != tgtok::less)
 263     return Result;
 264   Lex.Lex();  // Eat the '<'
 265
 266   if (Lex.getCode() == tgtok::greater) {
 267     TokError("subclass reference requires a non-empty list of template values");
 268     Result.Rec = 0;
 269     return Result;
 270   }
 271
 272   Result.TemplateArgs = ParseValueList(CurRec);
 273   if (Result.TemplateArgs.empty()) {
 274     Result.Rec = 0;   // Error parsing value list.
 275     return Result;
 276   }
 277
 278   if (Lex.getCode() != tgtok::greater) {
 279     TokError("expected '>' in template value list");
 280     Result.Rec = 0;
 281     return Result;
 282   }
 283   Lex.Lex();
 284
 285   return Result;
 286 }
 287
 288 /// ParseRangePiece - Parse a bit/value range.
 289 ///   RangePiece ::= INTVAL
 290 ///   RangePiece ::= INTVAL '-' INTVAL
 291 ///   RangePiece ::= INTVAL INTVAL
 292 bool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) {
 293   if (Lex.getCode() != tgtok::IntVal) {
 294     TokError("expected integer or bitrange");
 295     return true;
 296   }
 297   int Start = Lex.getCurIntVal();
 298   int End;
 299
 300   if (Start < 0)
 301     return TokError("invalid range, cannot be negative");
 302
 303   switch (Lex.Lex()) {  // eat first character.
 304   default:
 305     Ranges.push_back(Start);
 306     return false;
 307   case tgtok::minus:
 308     if (Lex.Lex() != tgtok::IntVal) {
 309       TokError("expected integer value as end of range");
 310       return true;
 311     }
 312     End = Lex.getCurIntVal();
 313     break;
 314   case tgtok::IntVal:
 315     End = -Lex.getCurIntVal();
 316     break;
 317   }
 318   if (End < 0)
 319     return TokError("invalid range, cannot be negative");
 320   Lex.Lex();
 321
 322   // Add to the range.
 323   if (Start < End) {
 324     for (; Start <= End; ++Start)
 325       Ranges.push_back(Start);
 326   } else {
 327     for (; Start >= End; --Start)
 328       Ranges.push_back(Start);
 329   }
 330   return false;
 331 }
 332
 333 /// ParseRangeList - Parse a list of scalars and ranges into scalar values.
 334 ///
 335 ///   RangeList ::= RangePiece (',' RangePiece)*
 336 ///
 337 std::vector<unsigned> TGParser::ParseRangeList() {
 338   std::vector<unsigned> Result;
 339
 340   // Parse the first piece.
 341   if (ParseRangePiece(Result))
 342     return std::vector<unsigned>();
 343   while (Lex.getCode() == tgtok::comma) {
 344     Lex.Lex();  // Eat the comma.
 345
 346     // Parse the next range piece.
 347     if (ParseRangePiece(Result))
 348       return std::vector<unsigned>();
 349   }
 350   return Result;
 351 }
 352
 353 /// ParseOptionalRangeList - Parse either a range list in <>'s or nothing.
 354 ///   OptionalRangeList ::= '<' RangeList '>'
 355 ///   OptionalRangeList ::= /*empty*/
 356 bool TGParser::ParseOptionalRangeList(std::vector<unsigned> &Ranges) {
 357   if (Lex.getCode() != tgtok::less)
 358     return false;
 359
 360   LocTy StartLoc = Lex.getLoc();
 361   Lex.Lex(); // eat the '<'
 362
 363   // Parse the range list.
 364   Ranges = ParseRangeList();
 365   if (Ranges.empty()) return true;
 366
 367   if (Lex.getCode() != tgtok::greater) {
 368     TokError("expected '>' at end of range list");
 369     return Error(StartLoc, "to match this '<'");
 370   }
 371   Lex.Lex();   // eat the '>'.
 372   return false;
 373 }
 374
 375 /// ParseOptionalBitList - Parse either a bit list in {}'s or nothing.
 376 ///   OptionalBitList ::= '{' RangeList '}'
 377 ///   OptionalBitList ::= /*empty*/
 378 bool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) {
 379   if (Lex.getCode() != tgtok::l_brace)
 380     return false;
 381
 382   LocTy StartLoc = Lex.getLoc();
 383   Lex.Lex(); // eat the '{'
 384
 385   // Parse the range list.
 386   Ranges = ParseRangeList();
 387   if (Ranges.empty()) return true;
 388
 389   if (Lex.getCode() != tgtok::r_brace) {
 390     TokError("expected '}' at end of bit list");
 391     return Error(StartLoc, "to match this '{'");
 392   }
 393   Lex.Lex();   // eat the '}'.
 394   return false;
 395 }
 396
 397
 398 /// ParseType - Parse and return a tblgen type.  This returns null on error.
 399 ///
 400 ///   Type ::= STRING                       // string type
 401 ///   Type ::= BIT                          // bit type
 402 ///   Type ::= BITS '<' INTVAL '>'          // bits<x> type
 403 ///   Type ::= INT                          // int type
 404 ///   Type ::= LIST '<' Type '>'            // list<x> type
 405 ///   Type ::= CODE                         // code type
 406 ///   Type ::= DAG                          // dag type
 407 ///   Type ::= ClassID                      // Record Type
 408 ///
 409 RecTy *TGParser::ParseType() {
 410   switch (Lex.getCode()) {
 411   default: TokError("Unknown token when expecting a type"); return 0;
 412   case tgtok::String: Lex.Lex(); return new StringRecTy();
 413   case tgtok::Bit:    Lex.Lex(); return new BitRecTy();
 414   case tgtok::Int:    Lex.Lex(); return new IntRecTy();
 415   case tgtok::Code:   Lex.Lex(); return new CodeRecTy();
 416   case tgtok::Dag:    Lex.Lex(); return new DagRecTy();
 417   case tgtok::Id:
 418     if (Record *R = ParseClassID()) return new RecordRecTy(R);
 419     return 0;
 420   case tgtok::Bits: {
 421     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
 422       TokError("expected '<' after bits type");
 423       return 0;
 424     }
 425     if (Lex.Lex() != tgtok::IntVal) {  // Eat '<'
 426       TokError("expected integer in bits<n> type");
 427       return 0;
 428     }
 429     unsigned Val = Lex.getCurIntVal();
 430     if (Lex.Lex() != tgtok::greater) {  // Eat count.
 431       TokError("expected '>' at end of bits<n> type");
 432       return 0;
 433     }
 434     Lex.Lex();  // Eat '>'
 435     return new BitsRecTy(Val);
 436   }
 437   case tgtok::List: {
 438     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
 439       TokError("expected '<' after list type");
 440       return 0;
 441     }
 442     Lex.Lex();  // Eat '<'
 443     RecTy *SubType = ParseType();
 444     if (SubType == 0) return 0;
 445
 446     if (Lex.getCode() != tgtok::greater) {
 447       TokError("expected '>' at end of list<ty> type");
 448       return 0;
 449     }
 450     Lex.Lex();  // Eat '>'
 451     return new ListRecTy(SubType);
 452   }
 453   }
 454 }
 455
 456 /// ParseIDValue - Parse an ID as a value and decode what it means.
 457 ///
 458 ///  IDValue ::= ID [def local value]
 459 ///  IDValue ::= ID [def template arg]
 460 ///  IDValue ::= ID [multiclass local value]
 461 ///  IDValue ::= ID [multiclass template argument]
 462 ///  IDValue ::= ID [def name]
 463 ///
 464 Init *TGParser::ParseIDValue(Record *CurRec) {
 465   assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
 466   std::string Name = Lex.getCurStrVal();
 467   LocTy Loc = Lex.getLoc();
 468   Lex.Lex();
 469   return ParseIDValue(CurRec, Name, Loc);
 470 }
 471
 472 /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
 473 /// has already been read.
 474 Init *TGParser::ParseIDValue(Record *CurRec,
 475                              const std::string &Name, LocTy NameLoc) {
 476   if (CurRec) {
 477     if (const RecordVal *RV = CurRec->getValue(Name))
 478       return new VarInit(Name, RV->getType());
 479
 480     std::string TemplateArgName = CurRec->getName()+":"+Name;
 481     if (CurRec->isTemplateArg(TemplateArgName)) {
 482       const RecordVal *RV = CurRec->getValue(TemplateArgName);
 483       assert(RV && "Template arg doesn't exist??");
 484       return new VarInit(TemplateArgName, RV->getType());
 485     }
 486   }
 487
 488   if (CurMultiClass) {
 489     std::string MCName = CurMultiClass->Rec.getName()+"::"+Name;
 490     if (CurMultiClass->Rec.isTemplateArg(MCName)) {
 491       const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
 492       assert(RV && "Template arg doesn't exist??");
 493       return new VarInit(MCName, RV->getType());
 494     }
 495   }
 496
 497   if (Record *D = Records.getDef(Name))
 498     return new DefInit(D);
 499
 500   Error(NameLoc, "Variable not defined: '" + Name + "'");
 501   return 0;
 502 }
 503
 504 /// ParseSimpleValue - Parse a tblgen value.  This returns null on error.
 505 ///
 506 ///   SimpleValue ::= IDValue
 507 ///   SimpleValue ::= INTVAL
 508 ///   SimpleValue ::= STRVAL
 509 ///   SimpleValue ::= CODEFRAGMENT
 510 ///   SimpleValue ::= '?'
 511 ///   SimpleValue ::= '{' ValueList '}'
 512 ///   SimpleValue ::= ID '<' ValueListNE '>'
 513 ///   SimpleValue ::= '[' ValueList ']'
 514 ///   SimpleValue ::= '(' IDValue DagArgList ')'
 515 ///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
 516 ///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
 517 ///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
 518 ///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
 519 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
 520 ///
 521 Init *TGParser::ParseSimpleValue(Record *CurRec) {
 522   Init *R = 0;
 523   switch (Lex.getCode()) {
 524   default: TokError("Unknown token when parsing a value"); break;
 525   case tgtok::IntVal: R = new IntInit(Lex.getCurIntVal()); Lex.Lex(); break;
 526   case tgtok::StrVal: R = new StringInit(Lex.getCurStrVal()); Lex.Lex(); break;
 527   case tgtok::CodeFragment:
 528       R = new CodeInit(Lex.getCurStrVal()); Lex.Lex(); break;
 529   case tgtok::question: R = new UnsetInit(); Lex.Lex(); break;
 530   case tgtok::Id: {
 531     LocTy NameLoc = Lex.getLoc();
 532     std::string Name = Lex.getCurStrVal();
 533     if (Lex.Lex() != tgtok::less)  // consume the Id.
 534       return ParseIDValue(CurRec, Name, NameLoc);    // Value ::= IDValue
 535
 536     // Value ::= ID '<' ValueListNE '>'
 537     if (Lex.Lex() == tgtok::greater) {
 538       TokError("expected non-empty value list");
 539       return 0;
 540     }
 541     std::vector<Init*> ValueList = ParseValueList(CurRec);
 542     if (ValueList.empty()) return 0;
 543
 544     if (Lex.getCode() != tgtok::greater) {
 545       TokError("expected '>' at end of value list");
 546       return 0;
 547     }
 548     Lex.Lex();  // eat the '>'
 549
 550     // This is a CLASS<initvalslist> expression.  This is supposed to synthesize
 551     // a new anonymous definition, deriving from CLASS<initvalslist> with no
 552     // body.
 553     Record *Class = Records.getClass(Name);
 554     if (!Class) {
 555       Error(NameLoc, "Expected a class name, got '" + Name + "'");
 556       return 0;
 557     }
 558
 559     // Create the new record, set it as CurRec temporarily.
 560     static unsigned AnonCounter = 0;
 561     Record *NewRec = new Record("anonymous.val."+utostr(AnonCounter++));
 562     SubClassReference SCRef;
 563     SCRef.RefLoc = NameLoc;
 564     SCRef.Rec = Class;
 565     SCRef.TemplateArgs = ValueList;
 566     // Add info about the subclass to NewRec.
 567     if (AddSubClass(NewRec, SCRef))
 568       return 0;
 569     NewRec->resolveReferences();
 570     Records.addDef(NewRec);
 571
 572     // The result of the expression is a reference to the new record.
 573     return new DefInit(NewRec);
 574   }
 575   case tgtok::l_brace: {           // Value ::= '{' ValueList '}'
 576     LocTy BraceLoc = Lex.getLoc();
 577     Lex.Lex(); // eat the '{'
 578     std::vector<Init*> Vals;
 579
 580     if (Lex.getCode() != tgtok::r_brace) {
 581       Vals = ParseValueList(CurRec);
 582       if (Vals.empty()) return 0;
 583     }
 584     if (Lex.getCode() != tgtok::r_brace) {
 585       TokError("expected '}' at end of bit list value");
 586       return 0;
 587     }
 588     Lex.Lex();  // eat the '}'
 589
 590     BitsInit *Result = new BitsInit(Vals.size());
 591     for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
 592       Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
 593       if (Bit == 0) {
 594         Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
 595               ") is not convertable to a bit");
 596         return 0;
 597       }
 598       Result->setBit(Vals.size()-i-1, Bit);
 599     }
 600     return Result;
 601   }
 602   case tgtok::l_square: {          // Value ::= '[' ValueList ']'
 603     Lex.Lex(); // eat the '['
 604     std::vector<Init*> Vals;
 605
 606     if (Lex.getCode() != tgtok::r_square) {
 607       Vals = ParseValueList(CurRec);
 608       if (Vals.empty()) return 0;
 609     }
 610     if (Lex.getCode() != tgtok::r_square) {
 611       TokError("expected ']' at end of list value");
 612       return 0;
 613     }
 614     Lex.Lex();  // eat the ']'
 615     return new ListInit(Vals);
 616   }
 617   case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
 618     Lex.Lex();   // eat the '('
 619     Init *Operator = ParseIDValue(CurRec);
 620     if (Operator == 0) return 0;
 621
 622     std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
 623     if (Lex.getCode() != tgtok::r_paren) {
 624       DagArgs = ParseDagArgList(CurRec);
 625       if (DagArgs.empty()) return 0;
 626     }
 627
 628     if (Lex.getCode() != tgtok::r_paren) {
 629       TokError("expected ')' in dag init");
 630       return 0;
 631     }
 632     Lex.Lex();  // eat the ')'
 633
 634     return new DagInit(Operator, DagArgs);
 635   }
 636   case tgtok::XConcat:
 637   case tgtok::XSRA:
 638   case tgtok::XSRL:
 639   case tgtok::XSHL:
 640   case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
 641     BinOpInit::BinaryOp Code;
 642     switch (Lex.getCode()) {
 643     default: assert(0 && "Unhandled code!");
 644     case tgtok::XConcat:    Code = BinOpInit::CONCAT; break;
 645     case tgtok::XSRA:       Code = BinOpInit::SRA; break;
 646     case tgtok::XSRL:       Code = BinOpInit::SRL; break;
 647     case tgtok::XSHL:       Code = BinOpInit::SHL; break;
 648     case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
 649     }
 650     Lex.Lex();  // eat the operation
 651     if (Lex.getCode() != tgtok::l_paren) {
 652       TokError("expected '(' after binary operator");
 653       return 0;
 654     }
 655     Lex.Lex();  // eat the '('
 656
 657     Init *LHS = ParseValue(CurRec);
 658     if (LHS == 0) return 0;
 659
 660     if (Lex.getCode() != tgtok::comma) {
 661       TokError("expected ',' in binary operator");
 662       return 0;
 663     }
 664     Lex.Lex();  // eat the ','
 665
 666     Init *RHS = ParseValue(CurRec);
 667     if (RHS == 0) return 0;
 668
 669     if (Lex.getCode() != tgtok::r_paren) {
 670       TokError("expected ')' in binary operator");
 671       return 0;
 672     }
 673     Lex.Lex();  // eat the ')'
 674     return (new BinOpInit(Code, LHS, RHS))->Fold();
 675   }
 676   }
 677
 678   return R;
 679 }
 680
 681 /// ParseValue - Parse a tblgen value.  This returns null on error.
 682 ///
 683 ///   Value       ::= SimpleValue ValueSuffix*
 684 ///   ValueSuffix ::= '{' BitList '}'
 685 ///   ValueSuffix ::= '[' BitList ']'
 686 ///   ValueSuffix ::= '.' ID
 687 ///
 688 Init *TGParser::ParseValue(Record *CurRec) {
 689   Init *Result = ParseSimpleValue(CurRec);
 690   if (Result == 0) return 0;
 691
 692   // Parse the suffixes now if present.
 693   while (1) {
 694     switch (Lex.getCode()) {
 695     default: return Result;
 696     case tgtok::l_brace: {
 697       LocTy CurlyLoc = Lex.getLoc();
 698       Lex.Lex(); // eat the '{'
 699       std::vector<unsigned> Ranges = ParseRangeList();
 700       if (Ranges.empty()) return 0;
 701
 702       // Reverse the bitlist.
 703       std::reverse(Ranges.begin(), Ranges.end());
 704       Result = Result->convertInitializerBitRange(Ranges);
 705       if (Result == 0) {
 706         Error(CurlyLoc, "Invalid bit range for value");
 707         return 0;
 708       }
 709
 710       // Eat the '}'.
 711       if (Lex.getCode() != tgtok::r_brace) {
 712         TokError("expected '}' at end of bit range list");
 713         return 0;
 714       }
 715       Lex.Lex();
 716       break;
 717     }
 718     case tgtok::l_square: {
 719       LocTy SquareLoc = Lex.getLoc();
 720       Lex.Lex(); // eat the '['
 721       std::vector<unsigned> Ranges = ParseRangeList();
 722       if (Ranges.empty()) return 0;
 723
 724       Result = Result->convertInitListSlice(Ranges);
 725       if (Result == 0) {
 726         Error(SquareLoc, "Invalid range for list slice");
 727         return 0;
 728       }
 729
 730       // Eat the ']'.
 731       if (Lex.getCode() != tgtok::r_square) {
 732         TokError("expected ']' at end of list slice");
 733         return 0;
 734       }
 735       Lex.Lex();
 736       break;
 737     }
 738     case tgtok::period:
 739       if (Lex.Lex() != tgtok::Id) {  // eat the .
 740         TokError("expected field identifier after '.'");
 741         return 0;
 742       }
 743       if (!Result->getFieldType(Lex.getCurStrVal())) {
 744         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
 745                  Result->getAsString() + "'");
 746         return 0;
 747       }
 748       Result = new FieldInit(Result, Lex.getCurStrVal());
 749       Lex.Lex();  // eat field name
 750       break;
 751     }
 752   }
 753 }
 754
 755 /// ParseDagArgList - Parse the argument list for a dag literal expression.
 756 ///
 757 ///    ParseDagArgList ::= Value (':' VARNAME)?
 758 ///    ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
 759 std::vector<std::pair<llvm::Init*, std::string> >
 760 TGParser::ParseDagArgList(Record *CurRec) {
 761   std::vector<std::pair<llvm::Init*, std::string> > Result;
 762
 763   while (1) {
 764     Init *Val = ParseValue(CurRec);
 765     if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
 766
 767     // If the variable name is present, add it.
 768     std::string VarName;
 769     if (Lex.getCode() == tgtok::colon) {
 770       if (Lex.Lex() != tgtok::VarName) { // eat the ':'
 771         TokError("expected variable name in dag literal");
 772         return std::vector<std::pair<llvm::Init*, std::string> >();
 773       }
 774       VarName = Lex.getCurStrVal();
 775       Lex.Lex();  // eat the VarName.
 776     }
 777
 778     Result.push_back(std::make_pair(Val, VarName));
 779
 780     if (Lex.getCode() != tgtok::comma) break;
 781     Lex.Lex(); // eat the ','
 782   }
 783
 784   return Result;
 785 }
 786
 787
 788 /// ParseValueList - Parse a comma separated list of values, returning them as a
 789 /// vector.  Note that this always expects to be able to parse at least one
 790 /// value.  It returns an empty list if this is not possible.
 791 ///
 792 ///   ValueList ::= Value (',' Value)
 793 ///
 794 std::vector<Init*> TGParser::ParseValueList(Record *CurRec) {
 795   std::vector<Init*> Result;
 796   Result.push_back(ParseValue(CurRec));
 797   if (Result.back() == 0) return std::vector<Init*>();
 798
 799   while (Lex.getCode() == tgtok::comma) {
 800     Lex.Lex();  // Eat the comma
 801
 802     Result.push_back(ParseValue(CurRec));
 803     if (Result.back() == 0) return std::vector<Init*>();
 804   }
 805
 806   return Result;
 807 }
 808
 809
 810
 811 /// ParseDeclaration - Read a declaration, returning the name of field ID, or an
 812 /// empty string on error.  This can happen in a number of different context's,
 813 /// including within a def or in the template args for a def (which which case
 814 /// CurRec will be non-null) and within the template args for a multiclass (in
 815 /// which case CurRec will be null, but CurMultiClass will be set).  This can
 816 /// also happen within a def that is within a multiclass, which will set both
 817 /// CurRec and CurMultiClass.
 818 ///
 819 ///  Declaration ::= FIELD? Type ID ('=' Value)?
 820 ///
 821 std::string TGParser::ParseDeclaration(Record *CurRec,
 822                                        bool ParsingTemplateArgs) {
 823   // Read the field prefix if present.
 824   bool HasField = Lex.getCode() == tgtok::Field;
 825   if (HasField) Lex.Lex();
 826
 827   RecTy *Type = ParseType();
 828   if (Type == 0) return "";
 829
 830   if (Lex.getCode() != tgtok::Id) {
 831     TokError("Expected identifier in declaration");
 832     return "";
 833   }
 834
 835   LocTy IdLoc = Lex.getLoc();
 836   std::string DeclName = Lex.getCurStrVal();
 837   Lex.Lex();
 838
 839   if (ParsingTemplateArgs) {
 840     if (CurRec) {
 841       DeclName = CurRec->getName() + ":" + DeclName;
 842     } else {
 843       assert(CurMultiClass);
 844     }
 845     if (CurMultiClass)
 846       DeclName = CurMultiClass->Rec.getName() + "::" + DeclName;
 847   }
 848
 849   // Add the value.
 850   if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
 851     return "";
 852
 853   // If a value is present, parse it.
 854   if (Lex.getCode() == tgtok::equal) {
 855     Lex.Lex();
 856     LocTy ValLoc = Lex.getLoc();
 857     Init *Val = ParseValue(CurRec);
 858     if (Val == 0 ||
 859         SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
 860       return "";
 861   }
 862
 863   return DeclName;
 864 }
 865
 866 /// ParseTemplateArgList - Read a template argument list, which is a non-empty
 867 /// sequence of template-declarations in <>'s.  If CurRec is non-null, these are
 868 /// template args for a def, which may or may not be in a multiclass.  If null,
 869 /// these are the template args for a multiclass.
 870 ///
 871 ///    TemplateArgList ::= '<' Declaration (',' Declaration)* '>'
 872 ///
 873 bool TGParser::ParseTemplateArgList(Record *CurRec) {
 874   assert(Lex.getCode() == tgtok::less && "Not a template arg list!");
 875   Lex.Lex(); // eat the '<'
 876
 877   Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
 878
 879   // Read the first declaration.
 880   std::string TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
 881   if (TemplArg.empty())
 882     return true;
 883
 884   TheRecToAddTo->addTemplateArg(TemplArg);
 885
 886   while (Lex.getCode() == tgtok::comma) {
 887     Lex.Lex(); // eat the ','
 888
 889     // Read the following declarations.
 890     TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
 891     if (TemplArg.empty())
 892       return true;
 893     TheRecToAddTo->addTemplateArg(TemplArg);
 894   }
 895
 896   if (Lex.getCode() != tgtok::greater)
 897     return TokError("expected '>' at end of template argument list");
 898   Lex.Lex(); // eat the '>'.
 899   return false;
 900 }
 901
 902
 903 /// ParseBodyItem - Parse a single item at within the body of a def or class.
 904 ///
 905 ///   BodyItem ::= Declaration ';'
 906 ///   BodyItem ::= LET ID OptionalBitList '=' Value ';'
 907 bool TGParser::ParseBodyItem(Record *CurRec) {
 908   if (Lex.getCode() != tgtok::Let) {
 909     if (ParseDeclaration(CurRec, false).empty())
 910       return true;
 911
 912     if (Lex.getCode() != tgtok::semi)
 913       return TokError("expected ';' after declaration");
 914     Lex.Lex();
 915     return false;
 916   }
 917
 918   // LET ID OptionalRangeList '=' Value ';'
 919   if (Lex.Lex() != tgtok::Id)
 920     return TokError("expected field identifier after let");
 921
 922   LocTy IdLoc = Lex.getLoc();
 923   std::string FieldName = Lex.getCurStrVal();
 924   Lex.Lex();  // eat the field name.
 925
 926   std::vector<unsigned> BitList;
 927   if (ParseOptionalBitList(BitList))
 928     return true;
 929   std::reverse(BitList.begin(), BitList.end());
 930
 931   if (Lex.getCode() != tgtok::equal)
 932     return TokError("expected '=' in let expression");
 933   Lex.Lex();  // eat the '='.
 934
 935   Init *Val = ParseValue(CurRec);
 936   if (Val == 0) return true;
 937
 938   if (Lex.getCode() != tgtok::semi)
 939     return TokError("expected ';' after let expression");
 940   Lex.Lex();
 941
 942   return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
 943 }
 944
 945 /// ParseBody - Read the body of a class or def.  Return true on error, false on
 946 /// success.
 947 ///
 948 ///   Body     ::= ';'
 949 ///   Body     ::= '{' BodyList '}'
 950 ///   BodyList BodyItem*
 951 ///
 952 bool TGParser::ParseBody(Record *CurRec) {
 953   // If this is a null definition, just eat the semi and return.
 954   if (Lex.getCode() == tgtok::semi) {
 955     Lex.Lex();
 956     return false;
 957   }
 958
 959   if (Lex.getCode() != tgtok::l_brace)
 960     return TokError("Expected ';' or '{' to start body");
 961   // Eat the '{'.
 962   Lex.Lex();
 963
 964   while (Lex.getCode() != tgtok::r_brace)
 965     if (ParseBodyItem(CurRec))
 966       return true;
 967
 968   // Eat the '}'.
 969   Lex.Lex();
 970   return false;
 971 }
 972
 973 /// ParseObjectBody - Parse the body of a def or class.  This consists of an
 974 /// optional ClassList followed by a Body.  CurRec is the current def or class
 975 /// that is being parsed.
 976 ///
 977 ///   ObjectBody      ::= BaseClassList Body
 978 ///   BaseClassList   ::= /*empty*/
 979 ///   BaseClassList   ::= ':' BaseClassListNE
 980 ///   BaseClassListNE ::= SubClassRef (',' SubClassRef)*
 981 ///
 982 bool TGParser::ParseObjectBody(Record *CurRec) {
 983   // If there is a baseclass list, read it.
 984   if (Lex.getCode() == tgtok::colon) {
 985     Lex.Lex();
 986
 987     // Read all of the subclasses.
 988     SubClassReference SubClass = ParseSubClassReference(CurRec, false);
 989     while (1) {
 990       // Check for error.
 991       if (SubClass.Rec == 0) return true;
 992
 993       // Add it.
 994       if (AddSubClass(CurRec, SubClass))
 995         return true;
 996
 997       if (Lex.getCode() != tgtok::comma) break;
 998       Lex.Lex(); // eat ','.
 999       SubClass = ParseSubClassReference(CurRec, false);
1000     }
1001   }
1002
1003   // Process any variables on the let stack.
1004   for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
1005     for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
1006       if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
1007                    LetStack[i][j].Bits, LetStack[i][j].Value))
1008         return true;
1009
1010   return ParseBody(CurRec);
1011 }
1012
1013
1014 /// ParseDef - Parse and return a top level or multiclass def, return the record
1015 /// corresponding to it.  This returns null on error.
1016 ///
1017 ///   DefInst ::= DEF ObjectName ObjectBody
1018 ///
1019 llvm::Record *TGParser::ParseDef(MultiClass *CurMultiClass) {
1020   LocTy DefLoc = Lex.getLoc();
1021   assert(Lex.getCode() == tgtok::Def && "Unknown tok");
1022   Lex.Lex();  // Eat the 'def' token.
1023
1024   // Parse ObjectName and make a record for it.
1025   Record *CurRec = new Record(ParseObjectName());
1026
1027   if (!CurMultiClass) {
1028     // Top-level def definition.
1029
1030     // Ensure redefinition doesn't happen.
1031     if (Records.getDef(CurRec->getName())) {
1032       Error(DefLoc, "def '" + CurRec->getName() + "' already defined");
1033       return 0;
1034     }
1035     Records.addDef(CurRec);
1036   } else {
1037     // Otherwise, a def inside a multiclass, add it to the multiclass.
1038     for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i)
1039       if (CurMultiClass->DefPrototypes[i]->getName() == CurRec->getName()) {
1040         Error(DefLoc, "def '" + CurRec->getName() +
1041               "' already defined in this multiclass!");
1042         return 0;
1043       }
1044     CurMultiClass->DefPrototypes.push_back(CurRec);
1045   }
1046
1047   if (ParseObjectBody(CurRec))
1048     return 0;
1049
1050   if (CurMultiClass == 0)  // Def's in multiclasses aren't really defs.
1051     CurRec->resolveReferences();
1052
1053   // If ObjectBody has template arguments, it's an error.
1054   assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?");
1055   return CurRec;
1056 }
1057
1058
1059 /// ParseClass - Parse a tblgen class definition.
1060 ///
1061 ///   ClassInst ::= CLASS ID TemplateArgList? ObjectBody
1062 ///
1063 bool TGParser::ParseClass() {
1064   assert(Lex.getCode() == tgtok::Class && "Unexpected token!");
1065   Lex.Lex();
1066
1067   if (Lex.getCode() != tgtok::Id)
1068     return TokError("expected class name after 'class' keyword");
1069
1070   Record *CurRec = Records.getClass(Lex.getCurStrVal());
1071   if (CurRec) {
1072     // If the body was previously defined, this is an error.
1073     if (!CurRec->getValues().empty() ||
1074         !CurRec->getSuperClasses().empty() ||
1075         !CurRec->getTemplateArgs().empty())
1076       return TokError("Class '" + CurRec->getName() + "' already defined");
1077   } else {
1078     // If this is the first reference to this class, create and add it.
1079     CurRec = new Record(Lex.getCurStrVal());
1080     Records.addClass(CurRec);
1081   }
1082   Lex.Lex(); // eat the name.
1083
1084   // If there are template args, parse them.
1085   if (Lex.getCode() == tgtok::less)
1086     if (ParseTemplateArgList(CurRec))
1087       return true;
1088
1089   // Finally, parse the object body.
1090   return ParseObjectBody(CurRec);
1091 }
1092
1093 /// ParseLetList - Parse a non-empty list of assignment expressions into a list
1094 /// of LetRecords.
1095 ///
1096 ///   LetList ::= LetItem (',' LetItem)*
1097 ///   LetItem ::= ID OptionalRangeList '=' Value
1098 ///
1099 std::vector<LetRecord> TGParser::ParseLetList() {
1100   std::vector<LetRecord> Result;
1101
1102   while (1) {
1103     if (Lex.getCode() != tgtok::Id) {
1104       TokError("expected identifier in let definition");
1105       return std::vector<LetRecord>();
1106     }
1107     std::string Name = Lex.getCurStrVal();
1108     LocTy NameLoc = Lex.getLoc();
1109     Lex.Lex();  // Eat the identifier.
1110
1111     // Check for an optional RangeList.
1112     std::vector<unsigned> Bits;
1113     if (ParseOptionalRangeList(Bits))
1114       return std::vector<LetRecord>();
1115     std::reverse(Bits.begin(), Bits.end());
1116
1117     if (Lex.getCode() != tgtok::equal) {
1118       TokError("expected '=' in let expression");
1119       return std::vector<LetRecord>();
1120     }
1121     Lex.Lex();  // eat the '='.
1122
1123     Init *Val = ParseValue(0);
1124     if (Val == 0) return std::vector<LetRecord>();
1125
1126     // Now that we have everything, add the record.
1127     Result.push_back(LetRecord(Name, Bits, Val, NameLoc));
1128
1129     if (Lex.getCode() != tgtok::comma)
1130       return Result;
1131     Lex.Lex();  // eat the comma.
1132   }
1133 }
1134
1135 /// ParseTopLevelLet - Parse a 'let' at top level.  This can be a couple of
1136 /// different related productions.
1137 ///
1138 ///   Object ::= LET LetList IN '{' ObjectList '}'
1139 ///   Object ::= LET LetList IN Object
1140 ///
1141 bool TGParser::ParseTopLevelLet() {
1142   assert(Lex.getCode() == tgtok::Let && "Unexpected token");
1143   Lex.Lex();
1144
1145   // Add this entry to the let stack.
1146   std::vector<LetRecord> LetInfo = ParseLetList();
1147   if (LetInfo.empty()) return true;
1148   LetStack.push_back(LetInfo);
1149
1150   if (Lex.getCode() != tgtok::In)
1151     return TokError("expected 'in' at end of top-level 'let'");
1152   Lex.Lex();
1153
1154   // If this is a scalar let, just handle it now
1155   if (Lex.getCode() != tgtok::l_brace) {
1156     // LET LetList IN Object
1157     if (ParseObject())
1158       return true;
1159   } else {   // Object ::= LETCommand '{' ObjectList '}'
1160     LocTy BraceLoc = Lex.getLoc();
1161     // Otherwise, this is a group let.
1162     Lex.Lex();  // eat the '{'.
1163
1164     // Parse the object list.
1165     if (ParseObjectList())
1166       return true;
1167
1168     if (Lex.getCode() != tgtok::r_brace) {
1169       TokError("expected '}' at end of top level let command");
1170       return Error(BraceLoc, "to match this '{'");
1171     }
1172     Lex.Lex();
1173   }
1174
1175   // Outside this let scope, this let block is not active.
1176   LetStack.pop_back();
1177   return false;
1178 }
1179
1180 /// ParseMultiClassDef - Parse a def in a multiclass context.
1181 ///
1182 ///  MultiClassDef ::= DefInst
1183 ///
1184 bool TGParser::ParseMultiClassDef(MultiClass *CurMC) {
1185   if (Lex.getCode() != tgtok::Def)
1186     return TokError("expected 'def' in multiclass body");
1187
1188   Record *D = ParseDef(CurMC);
1189   if (D == 0) return true;
1190
1191   // Copy the template arguments for the multiclass into the def.
1192   const std::vector<std::string> &TArgs = CurMC->Rec.getTemplateArgs();
1193
1194   for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
1195     const RecordVal *RV = CurMC->Rec.getValue(TArgs[i]);
1196     assert(RV && "Template arg doesn't exist?");
1197     D->addValue(*RV);
1198   }
1199
1200   return false;
1201 }
1202
1203 /// ParseMultiClass - Parse a multiclass definition.
1204 ///
1205 ///  MultiClassInst ::= MULTICLASS ID TemplateArgList? '{' MultiClassDef+ '}'
1206 ///
1207 bool TGParser::ParseMultiClass() {
1208   assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token");
1209   Lex.Lex();  // Eat the multiclass token.
1210
1211   if (Lex.getCode() != tgtok::Id)
1212     return TokError("expected identifier after multiclass for name");
1213   std::string Name = Lex.getCurStrVal();
1214
1215   if (MultiClasses.count(Name))
1216     return TokError("multiclass '" + Name + "' already defined");
1217
1218   CurMultiClass  = MultiClasses[Name] = new MultiClass(Name);
1219   Lex.Lex();  // Eat the identifier.
1220
1221   // If there are template args, parse them.
1222   if (Lex.getCode() == tgtok::less)
1223     if (ParseTemplateArgList(0))
1224       return true;
1225
1226   if (Lex.getCode() != tgtok::l_brace)
1227     return TokError("expected '{' in multiclass definition");
1228
1229   if (Lex.Lex() == tgtok::r_brace)  // eat the '{'.
1230     return TokError("multiclass must contain at least one def");
1231
1232   while (Lex.getCode() != tgtok::r_brace)
1233     if (ParseMultiClassDef(CurMultiClass))
1234       return true;
1235
1236   Lex.Lex();  // eat the '}'.
1237
1238   CurMultiClass = 0;
1239   return false;
1240 }
1241
1242 /// ParseDefm - Parse the instantiation of a multiclass.
1243 ///
1244 ///   DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
1245 ///
1246 bool TGParser::ParseDefm() {
1247   assert(Lex.getCode() == tgtok::Defm && "Unexpected token!");
1248   if (Lex.Lex() != tgtok::Id)  // eat the defm.
1249     return TokError("expected identifier after defm");
1250
1251   LocTy DefmPrefixLoc = Lex.getLoc();
1252   std::string DefmPrefix = Lex.getCurStrVal();
1253   if (Lex.Lex() != tgtok::colon)
1254     return TokError("expected ':' after defm identifier");
1255
1256   // eat the colon.
1257   Lex.Lex();
1258
1259   LocTy SubClassLoc = Lex.getLoc();
1260   SubClassReference Ref = ParseSubClassReference(0, true);
1261   if (Ref.Rec == 0) return true;
1262
1263   if (Lex.getCode() != tgtok::semi)
1264     return TokError("expected ';' at end of defm");
1265   Lex.Lex();
1266
1267   // To instantiate a multiclass, we need to first get the multiclass, then
1268   // instantiate each def contained in the multiclass with the SubClassRef
1269   // template parameters.
1270   MultiClass *MC = MultiClasses[Ref.Rec->getName()];
1271   assert(MC && "Didn't lookup multiclass correctly?");
1272   std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
1273
1274   // Verify that the correct number of template arguments were specified.
1275   const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs();
1276   if (TArgs.size() < TemplateVals.size())
1277     return Error(SubClassLoc,
1278                  "more template args specified than multiclass expects");
1279
1280   // Loop over all the def's in the multiclass, instantiating each one.
1281   for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) {
1282     Record *DefProto = MC->DefPrototypes[i];
1283
1284     // Add the suffix to the defm name to get the new name.
1285     Record *CurRec = new Record(DefmPrefix + DefProto->getName());
1286
1287     SubClassReference Ref;
1288     Ref.RefLoc = DefmPrefixLoc;
1289     Ref.Rec = DefProto;
1290     AddSubClass(CurRec, Ref);
1291
1292     // Loop over all of the template arguments, setting them to the specified
1293     // value or leaving them as the default if necessary.
1294     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
1295       if (i < TemplateVals.size()) { // A value is specified for this temp-arg?
1296         // Set it now.
1297         if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(),
1298                      TemplateVals[i]))
1299           return true;
1300
1301         // Resolve it next.
1302         CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
1303
1304         // Now remove it.
1305         CurRec->removeValue(TArgs[i]);
1306
1307       } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
1308         return Error(SubClassLoc, "value not specified for template argument #"+
1309                      utostr(i) + " (" + TArgs[i] + ") of multiclassclass '" +
1310                      MC->Rec.getName() + "'");
1311       }
1312     }
1313
1314     // If the mdef is inside a 'let' expression, add to each def.
1315     for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
1316       for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
1317         if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
1318                      LetStack[i][j].Bits, LetStack[i][j].Value)) {
1319           Error(DefmPrefixLoc, "when instantiating this defm");
1320           return true;
1321         }
1322
1323
1324     // Ensure redefinition doesn't happen.
1325     if (Records.getDef(CurRec->getName()))
1326       return Error(DefmPrefixLoc, "def '" + CurRec->getName() +
1327                    "' already defined, instantiating defm with subdef '" +
1328                    DefProto->getName() + "'");
1329     Records.addDef(CurRec);
1330     CurRec->resolveReferences();
1331   }
1332
1333   return false;
1334 }
1335
1336 /// ParseObject
1337 ///   Object ::= ClassInst
1338 ///   Object ::= DefInst
1339 ///   Object ::= MultiClassInst
1340 ///   Object ::= DefMInst
1341 ///   Object ::= LETCommand '{' ObjectList '}'
1342 ///   Object ::= LETCommand Object
1343 bool TGParser::ParseObject() {
1344   switch (Lex.getCode()) {
1345   default: assert(0 && "This is not an object");
1346   case tgtok::Let:   return ParseTopLevelLet();
1347   case tgtok::Def:   return ParseDef(0) == 0;
1348   case tgtok::Defm:  return ParseDefm();
1349   case tgtok::Class: return ParseClass();
1350   case tgtok::MultiClass: return ParseMultiClass();
1351   }
1352 }
1353
1354 /// ParseObjectList
1355 ///   ObjectList :== Object*
1356 bool TGParser::ParseObjectList() {
1357   while (isObjectStart(Lex.getCode())) {
1358     if (ParseObject())
1359       return true;
1360   }
1361   return false;
1362 }
1363
1364
1365 bool TGParser::ParseFile() {
1366   Lex.Lex(); // Prime the lexer.
1367   if (ParseObjectList()) return true;
1368
1369   // If we have unread input at the end of the file, report it.
1370   if (Lex.getCode() == tgtok::Eof)
1371     return false;
1372
1373   return TokError("Unexpected input at top level");
1374 }
1375