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