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