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