LLVM  10.0.0svn
TGParser.cpp
Go to the documentation of this file.
1 //===- TGParser.cpp - Parser for TableGen Files ---------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Implement the Parser for TableGen.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "TGParser.h"
14 #include "llvm/ADT/None.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/Config/llvm-config.h"
19 #include "llvm/Support/Casting.h"
20 #include "llvm/Support/Compiler.h"
23 #include "llvm/TableGen/Record.h"
24 #include <algorithm>
25 #include <cassert>
26 #include <cstdint>
27 
28 using namespace llvm;
29 
30 //===----------------------------------------------------------------------===//
31 // Support Code for the Semantic Actions.
32 //===----------------------------------------------------------------------===//
33 
34 namespace llvm {
35 
40 
41  SubClassReference() : Rec(nullptr) {}
42 
43  bool isInvalid() const { return Rec == nullptr; }
44 };
45 
50 
51  SubMultiClassReference() : MC(nullptr) {}
52 
53  bool isInvalid() const { return MC == nullptr; }
54  void dump() const;
55 };
56 
57 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
59  errs() << "Multiclass:\n";
60 
61  MC->dump();
62 
63  errs() << "Template args:\n";
64  for (Init *TA : TemplateArgs)
65  TA->dump();
66 }
67 #endif
68 
69 } // end namespace llvm
70 
71 static bool checkBitsConcrete(Record &R, const RecordVal &RV) {
72  BitsInit *BV = cast<BitsInit>(RV.getValue());
73  for (unsigned i = 0, e = BV->getNumBits(); i != e; ++i) {
74  Init *Bit = BV->getBit(i);
75  bool IsReference = false;
76  if (auto VBI = dyn_cast<VarBitInit>(Bit)) {
77  if (auto VI = dyn_cast<VarInit>(VBI->getBitVar())) {
78  if (R.getValue(VI->getName()))
79  IsReference = true;
80  }
81  } else if (isa<VarInit>(Bit)) {
82  IsReference = true;
83  }
84  if (!(IsReference || Bit->isConcrete()))
85  return false;
86  }
87  return true;
88 }
89 
90 static void checkConcrete(Record &R) {
91  for (const RecordVal &RV : R.getValues()) {
92  // HACK: Disable this check for variables declared with 'field'. This is
93  // done merely because existing targets have legitimate cases of
94  // non-concrete variables in helper defs. Ideally, we'd introduce a
95  // 'maybe' or 'optional' modifier instead of this.
96  if (RV.getPrefix())
97  continue;
98 
99  if (Init *V = RV.getValue()) {
100  bool Ok = isa<BitsInit>(V) ? checkBitsConcrete(R, RV) : V->isConcrete();
101  if (!Ok) {
102  PrintError(R.getLoc(),
103  Twine("Initializer of '") + RV.getNameInitAsString() +
104  "' in '" + R.getNameInitAsString() +
105  "' could not be fully resolved: " +
106  RV.getValue()->getAsString());
107  }
108  }
109  }
110 }
111 
112 /// Return an Init with a qualifier prefix referring
113 /// to CurRec's name.
114 static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
115  Init *Name, StringRef Scoper) {
116  Init *NewName =
118  NewName = BinOpInit::getStrConcat(NewName, Name);
119  if (CurMultiClass && Scoper != "::") {
120  Init *Prefix = BinOpInit::getStrConcat(CurMultiClass->Rec.getNameInit(),
121  StringInit::get("::"));
122  NewName = BinOpInit::getStrConcat(Prefix, NewName);
123  }
124 
125  if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
126  NewName = BinOp->Fold(&CurRec);
127  return NewName;
128 }
129 
130 /// Return the qualified version of the implicit 'NAME' template argument.
132  MultiClass *MC = nullptr) {
133  return QualifyName(Rec, MC, StringInit::get("NAME"), MC ? "::" : ":");
134 }
135 
137  return QualifiedNameOfImplicitName(MC->Rec, MC);
138 }
139 
140 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
141  if (!CurRec)
142  CurRec = &CurMultiClass->Rec;
143 
144  if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) {
145  // The value already exists in the class, treat this as a set.
146  if (ERV->setValue(RV.getValue()))
147  return Error(Loc, "New definition of '" + RV.getName() + "' of type '" +
148  RV.getType()->getAsString() + "' is incompatible with " +
149  "previous definition of type '" +
150  ERV->getType()->getAsString() + "'");
151  } else {
152  CurRec->addValue(RV);
153  }
154  return false;
155 }
156 
157 /// SetValue -
158 /// Return true on error, false on success.
159 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
160  ArrayRef<unsigned> BitList, Init *V,
161  bool AllowSelfAssignment) {
162  if (!V) return false;
163 
164  if (!CurRec) CurRec = &CurMultiClass->Rec;
165 
166  RecordVal *RV = CurRec->getValue(ValName);
167  if (!RV)
168  return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
169  "' unknown!");
170 
171  // Do not allow assignments like 'X = X'. This will just cause infinite loops
172  // in the resolution machinery.
173  if (BitList.empty())
174  if (VarInit *VI = dyn_cast<VarInit>(V))
175  if (VI->getNameInit() == ValName && !AllowSelfAssignment)
176  return Error(Loc, "Recursion / self-assignment forbidden");
177 
178  // If we are assigning to a subset of the bits in the value... then we must be
179  // assigning to a field of BitsRecTy, which must have a BitsInit
180  // initializer.
181  //
182  if (!BitList.empty()) {
183  BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
184  if (!CurVal)
185  return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
186  "' is not a bits type");
187 
188  // Convert the incoming value to a bits type of the appropriate size...
189  Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
190  if (!BI)
191  return Error(Loc, "Initializer is not compatible with bit range");
192 
193  SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
194 
195  // Loop over bits, assigning values as appropriate.
196  for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
197  unsigned Bit = BitList[i];
198  if (NewBits[Bit])
199  return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
200  ValName->getAsUnquotedString() + "' more than once");
201  NewBits[Bit] = BI->getBit(i);
202  }
203 
204  for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
205  if (!NewBits[i])
206  NewBits[i] = CurVal->getBit(i);
207 
208  V = BitsInit::get(NewBits);
209  }
210 
211  if (RV->setValue(V)) {
212  std::string InitType;
213  if (BitsInit *BI = dyn_cast<BitsInit>(V))
214  InitType = (Twine("' of type bit initializer with length ") +
215  Twine(BI->getNumBits())).str();
216  else if (TypedInit *TI = dyn_cast<TypedInit>(V))
217  InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
218  return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
219  "' of type '" + RV->getType()->getAsString() +
220  "' is incompatible with initializer '" +
221  V->getAsString() + InitType + "'");
222  }
223  return false;
224 }
225 
226 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
227 /// args as SubClass's template arguments.
228 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
229  Record *SC = SubClass.Rec;
230  // Add all of the values in the subclass into the current class.
231  for (const RecordVal &Val : SC->getValues())
232  if (AddValue(CurRec, SubClass.RefRange.Start, Val))
233  return true;
234 
235  ArrayRef<Init *> TArgs = SC->getTemplateArgs();
236 
237  // Ensure that an appropriate number of template arguments are specified.
238  if (TArgs.size() < SubClass.TemplateArgs.size())
239  return Error(SubClass.RefRange.Start,
240  "More template args specified than expected");
241 
242  // Loop over all of the template arguments, setting them to the specified
243  // value or leaving them as the default if necessary.
244  MapResolver R(CurRec);
245 
246  for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
247  if (i < SubClass.TemplateArgs.size()) {
248  // If a value is specified for this template arg, set it now.
249  if (SetValue(CurRec, SubClass.RefRange.Start, TArgs[i],
250  None, SubClass.TemplateArgs[i]))
251  return true;
252  } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
253  return Error(SubClass.RefRange.Start,
254  "Value not specified for template argument #" +
255  Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
256  ") of subclass '" + SC->getNameInitAsString() + "'!");
257  }
258 
259  R.set(TArgs[i], CurRec->getValue(TArgs[i])->getValue());
260 
261  CurRec->removeValue(TArgs[i]);
262  }
263 
264  Init *Name;
265  if (CurRec->isClass())
266  Name =
268  else
269  Name = CurRec->getNameInit();
270  R.set(QualifiedNameOfImplicitName(*SC), Name);
271 
272  CurRec->resolveReferences(R);
273 
274  // Since everything went well, we can now set the "superclass" list for the
275  // current record.
277  for (const auto &SCPair : SCs) {
278  if (CurRec->isSubClassOf(SCPair.first))
279  return Error(SubClass.RefRange.Start,
280  "Already subclass of '" + SCPair.first->getName() + "'!\n");
281  CurRec->addSuperClass(SCPair.first, SCPair.second);
282  }
283 
284  if (CurRec->isSubClassOf(SC))
285  return Error(SubClass.RefRange.Start,
286  "Already subclass of '" + SC->getName() + "'!\n");
287  CurRec->addSuperClass(SC, SubClass.RefRange);
288  return false;
289 }
290 
291 bool TGParser::AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass) {
292  if (Entry.Rec)
293  return AddSubClass(Entry.Rec.get(), SubClass);
294 
295  for (auto &E : Entry.Loop->Entries) {
296  if (AddSubClass(E, SubClass))
297  return true;
298  }
299 
300  return false;
301 }
302 
303 /// AddSubMultiClass - Add SubMultiClass as a subclass to
304 /// CurMC, resolving its template args as SubMultiClass's
305 /// template arguments.
306 bool TGParser::AddSubMultiClass(MultiClass *CurMC,
307  SubMultiClassReference &SubMultiClass) {
308  MultiClass *SMC = SubMultiClass.MC;
309 
310  ArrayRef<Init *> SMCTArgs = SMC->Rec.getTemplateArgs();
311  if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size())
312  return Error(SubMultiClass.RefRange.Start,
313  "More template args specified than expected");
314 
315  // Prepare the mapping of template argument name to value, filling in default
316  // values if necessary.
317  SubstStack TemplateArgs;
318  for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) {
319  if (i < SubMultiClass.TemplateArgs.size()) {
320  TemplateArgs.emplace_back(SMCTArgs[i], SubMultiClass.TemplateArgs[i]);
321  } else {
322  Init *Default = SMC->Rec.getValue(SMCTArgs[i])->getValue();
323  if (!Default->isComplete()) {
324  return Error(SubMultiClass.RefRange.Start,
325  "value not specified for template argument #" + Twine(i) +
326  " (" + SMCTArgs[i]->getAsUnquotedString() +
327  ") of multiclass '" + SMC->Rec.getNameInitAsString() +
328  "'");
329  }
330  TemplateArgs.emplace_back(SMCTArgs[i], Default);
331  }
332  }
333 
334  TemplateArgs.emplace_back(
337 
338  // Add all of the defs in the subclass into the current multiclass.
339  return resolve(SMC->Entries, TemplateArgs, false, &CurMC->Entries);
340 }
341 
342 /// Add a record or foreach loop to the current context (global record keeper,
343 /// current inner-most foreach loop, or multiclass).
344 bool TGParser::addEntry(RecordsEntry E) {
345  assert(!E.Rec || !E.Loop);
346 
347  if (!Loops.empty()) {
348  Loops.back()->Entries.push_back(std::move(E));
349  return false;
350  }
351 
352  if (E.Loop) {
353  SubstStack Stack;
354  return resolve(*E.Loop, Stack, CurMultiClass == nullptr,
355  CurMultiClass ? &CurMultiClass->Entries : nullptr);
356  }
357 
358  if (CurMultiClass) {
359  CurMultiClass->Entries.push_back(std::move(E));
360  return false;
361  }
362 
363  return addDefOne(std::move(E.Rec));
364 }
365 
366 /// Resolve the entries in \p Loop, going over inner loops recursively
367 /// and making the given subsitutions of (name, value) pairs.
368 ///
369 /// The resulting records are stored in \p Dest if non-null. Otherwise, they
370 /// are added to the global record keeper.
371 bool TGParser::resolve(const ForeachLoop &Loop, SubstStack &Substs,
372  bool Final, std::vector<RecordsEntry> *Dest,
373  SMLoc *Loc) {
374  MapResolver R;
375  for (const auto &S : Substs)
376  R.set(S.first, S.second);
377  Init *List = Loop.ListValue->resolveReferences(R);
378  auto LI = dyn_cast<ListInit>(List);
379  if (!LI) {
380  if (!Final) {
381  Dest->emplace_back(std::make_unique<ForeachLoop>(Loop.Loc, Loop.IterVar,
382  List));
383  return resolve(Loop.Entries, Substs, Final, &Dest->back().Loop->Entries,
384  Loc);
385  }
386 
387  PrintError(Loop.Loc, Twine("attempting to loop over '") +
388  List->getAsString() + "', expected a list");
389  return true;
390  }
391 
392  bool Error = false;
393  for (auto Elt : *LI) {
394  Substs.emplace_back(Loop.IterVar->getNameInit(), Elt);
395  Error = resolve(Loop.Entries, Substs, Final, Dest);
396  Substs.pop_back();
397  if (Error)
398  break;
399  }
400  return Error;
401 }
402 
403 /// Resolve the entries in \p Source, going over loops recursively and
404 /// making the given substitutions of (name, value) pairs.
405 ///
406 /// The resulting records are stored in \p Dest if non-null. Otherwise, they
407 /// are added to the global record keeper.
408 bool TGParser::resolve(const std::vector<RecordsEntry> &Source,
409  SubstStack &Substs, bool Final,
410  std::vector<RecordsEntry> *Dest, SMLoc *Loc) {
411  bool Error = false;
412  for (auto &E : Source) {
413  if (E.Loop) {
414  Error = resolve(*E.Loop, Substs, Final, Dest);
415  } else {
416  auto Rec = std::make_unique<Record>(*E.Rec);
417  if (Loc)
418  Rec->appendLoc(*Loc);
419 
420  MapResolver R(Rec.get());
421  for (const auto &S : Substs)
422  R.set(S.first, S.second);
424 
425  if (Dest)
426  Dest->push_back(std::move(Rec));
427  else
428  Error = addDefOne(std::move(Rec));
429  }
430  if (Error)
431  break;
432  }
433  return Error;
434 }
435 
436 /// Resolve the record fully and add it to the record keeper.
437 bool TGParser::addDefOne(std::unique_ptr<Record> Rec) {
438  if (Record *Prev = Records.getDef(Rec->getNameInitAsString())) {
439  if (!Rec->isAnonymous()) {
440  PrintError(Rec->getLoc(),
441  "def already exists: " + Rec->getNameInitAsString());
442  PrintNote(Prev->getLoc(), "location of previous definition");
443  return true;
444  }
445  Rec->setName(Records.getNewAnonymousName());
446  }
447 
448  Rec->resolveReferences();
449  checkConcrete(*Rec);
450 
451  if (!isa<StringInit>(Rec->getNameInit())) {
452  PrintError(Rec->getLoc(), Twine("record name '") +
453  Rec->getNameInit()->getAsString() +
454  "' could not be fully resolved");
455  return true;
456  }
457 
458  // If ObjectBody has template arguments, it's an error.
459  assert(Rec->getTemplateArgs().empty() && "How'd this get template args?");
460 
461  for (DefsetRecord *Defset : Defsets) {
462  DefInit *I = Rec->getDefInit();
463  if (!I->getType()->typeIsA(Defset->EltTy)) {
464  PrintError(Rec->getLoc(), Twine("adding record of incompatible type '") +
465  I->getType()->getAsString() +
466  "' to defset");
467  PrintNote(Defset->Loc, "location of defset declaration");
468  return true;
469  }
470  Defset->Elements.push_back(I);
471  }
472 
473  Records.addDef(std::move(Rec));
474  return false;
475 }
476 
477 //===----------------------------------------------------------------------===//
478 // Parser Code
479 //===----------------------------------------------------------------------===//
480 
481 /// isObjectStart - Return true if this is a valid first token for an Object.
483  return K == tgtok::Class || K == tgtok::Def || K == tgtok::Defm ||
484  K == tgtok::Let || K == tgtok::MultiClass || K == tgtok::Foreach ||
485  K == tgtok::Defset;
486 }
487 
488 /// ParseObjectName - If a valid object name is specified, return it. If no
489 /// name is specified, return the unset initializer. Return nullptr on parse
490 /// error.
491 /// ObjectName ::= Value [ '#' Value ]*
492 /// ObjectName ::= /*empty*/
493 ///
494 Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
495  switch (Lex.getCode()) {
496  case tgtok::colon:
497  case tgtok::semi:
498  case tgtok::l_brace:
499  // These are all of the tokens that can begin an object body.
500  // Some of these can also begin values but we disallow those cases
501  // because they are unlikely to be useful.
502  return UnsetInit::get();
503  default:
504  break;
505  }
506 
507  Record *CurRec = nullptr;
508  if (CurMultiClass)
509  CurRec = &CurMultiClass->Rec;
510 
511  Init *Name = ParseValue(CurRec, StringRecTy::get(), ParseNameMode);
512  if (!Name)
513  return nullptr;
514 
515  if (CurMultiClass) {
516  Init *NameStr = QualifiedNameOfImplicitName(CurMultiClass);
517  HasReferenceResolver R(NameStr);
518  Name->resolveReferences(R);
519  if (!R.found())
521  Name);
522  }
523 
524  return Name;
525 }
526 
527 /// ParseClassID - Parse and resolve a reference to a class name. This returns
528 /// null on error.
529 ///
530 /// ClassID ::= ID
531 ///
532 Record *TGParser::ParseClassID() {
533  if (Lex.getCode() != tgtok::Id) {
534  TokError("expected name for ClassID");
535  return nullptr;
536  }
537 
538  Record *Result = Records.getClass(Lex.getCurStrVal());
539  if (!Result) {
540  std::string Msg("Couldn't find class '" + Lex.getCurStrVal() + "'");
541  if (MultiClasses[Lex.getCurStrVal()].get())
542  TokError(Msg + ". Use 'defm' if you meant to use multiclass '" +
543  Lex.getCurStrVal() + "'");
544  else
545  TokError(Msg);
546  }
547 
548  Lex.Lex();
549  return Result;
550 }
551 
552 /// ParseMultiClassID - Parse and resolve a reference to a multiclass name.
553 /// This returns null on error.
554 ///
555 /// MultiClassID ::= ID
556 ///
557 MultiClass *TGParser::ParseMultiClassID() {
558  if (Lex.getCode() != tgtok::Id) {
559  TokError("expected name for MultiClassID");
560  return nullptr;
561  }
562 
563  MultiClass *Result = MultiClasses[Lex.getCurStrVal()].get();
564  if (!Result)
565  TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");
566 
567  Lex.Lex();
568  return Result;
569 }
570 
571 /// ParseSubClassReference - Parse a reference to a subclass or to a templated
572 /// subclass. This returns a SubClassRefTy with a null Record* on error.
573 ///
574 /// SubClassRef ::= ClassID
575 /// SubClassRef ::= ClassID '<' ValueList '>'
576 ///
577 SubClassReference TGParser::
578 ParseSubClassReference(Record *CurRec, bool isDefm) {
579  SubClassReference Result;
580  Result.RefRange.Start = Lex.getLoc();
581 
582  if (isDefm) {
583  if (MultiClass *MC = ParseMultiClassID())
584  Result.Rec = &MC->Rec;
585  } else {
586  Result.Rec = ParseClassID();
587  }
588  if (!Result.Rec) return Result;
589 
590  // If there is no template arg list, we're done.
591  if (Lex.getCode() != tgtok::less) {
592  Result.RefRange.End = Lex.getLoc();
593  return Result;
594  }
595  Lex.Lex(); // Eat the '<'
596 
597  if (Lex.getCode() == tgtok::greater) {
598  TokError("subclass reference requires a non-empty list of template values");
599  Result.Rec = nullptr;
600  return Result;
601  }
602 
603  ParseValueList(Result.TemplateArgs, CurRec, Result.Rec);
604  if (Result.TemplateArgs.empty()) {
605  Result.Rec = nullptr; // Error parsing value list.
606  return Result;
607  }
608 
609  if (Lex.getCode() != tgtok::greater) {
610  TokError("expected '>' in template value list");
611  Result.Rec = nullptr;
612  return Result;
613  }
614  Lex.Lex();
615  Result.RefRange.End = Lex.getLoc();
616 
617  return Result;
618 }
619 
620 /// ParseSubMultiClassReference - Parse a reference to a subclass or to a
621 /// templated submulticlass. This returns a SubMultiClassRefTy with a null
622 /// Record* on error.
623 ///
624 /// SubMultiClassRef ::= MultiClassID
625 /// SubMultiClassRef ::= MultiClassID '<' ValueList '>'
626 ///
627 SubMultiClassReference TGParser::
628 ParseSubMultiClassReference(MultiClass *CurMC) {
629  SubMultiClassReference Result;
630  Result.RefRange.Start = Lex.getLoc();
631 
632  Result.MC = ParseMultiClassID();
633  if (!Result.MC) return Result;
634 
635  // If there is no template arg list, we're done.
636  if (Lex.getCode() != tgtok::less) {
637  Result.RefRange.End = Lex.getLoc();
638  return Result;
639  }
640  Lex.Lex(); // Eat the '<'
641 
642  if (Lex.getCode() == tgtok::greater) {
643  TokError("subclass reference requires a non-empty list of template values");
644  Result.MC = nullptr;
645  return Result;
646  }
647 
648  ParseValueList(Result.TemplateArgs, &CurMC->Rec, &Result.MC->Rec);
649  if (Result.TemplateArgs.empty()) {
650  Result.MC = nullptr; // Error parsing value list.
651  return Result;
652  }
653 
654  if (Lex.getCode() != tgtok::greater) {
655  TokError("expected '>' in template value list");
656  Result.MC = nullptr;
657  return Result;
658  }
659  Lex.Lex();
660  Result.RefRange.End = Lex.getLoc();
661 
662  return Result;
663 }
664 
665 /// ParseRangePiece - Parse a bit/value range.
666 /// RangePiece ::= INTVAL
667 /// RangePiece ::= INTVAL '-' INTVAL
668 /// RangePiece ::= INTVAL INTVAL
669 bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
670  TypedInit *FirstItem) {
671  Init *CurVal = FirstItem;
672  if (!CurVal)
673  CurVal = ParseValue(nullptr);
674 
675  IntInit *II = dyn_cast_or_null<IntInit>(CurVal);
676  if (!II)
677  return TokError("expected integer or bitrange");
678 
679  int64_t Start = II->getValue();
680  int64_t End;
681 
682  if (Start < 0)
683  return TokError("invalid range, cannot be negative");
684 
685  switch (Lex.getCode()) {
686  default:
687  Ranges.push_back(Start);
688  return false;
689  case tgtok::minus: {
690  Lex.Lex(); // eat
691 
692  Init *I_End = ParseValue(nullptr);
693  IntInit *II_End = dyn_cast_or_null<IntInit>(I_End);
694  if (!II_End) {
695  TokError("expected integer value as end of range");
696  return true;
697  }
698 
699  End = II_End->getValue();
700  break;
701  }
702  case tgtok::IntVal: {
703  End = -Lex.getCurIntVal();
704  Lex.Lex();
705  break;
706  }
707  }
708  if (End < 0)
709  return TokError("invalid range, cannot be negative");
710 
711  // Add to the range.
712  if (Start < End)
713  for (; Start <= End; ++Start)
714  Ranges.push_back(Start);
715  else
716  for (; Start >= End; --Start)
717  Ranges.push_back(Start);
718  return false;
719 }
720 
721 /// ParseRangeList - Parse a list of scalars and ranges into scalar values.
722 ///
723 /// RangeList ::= RangePiece (',' RangePiece)*
724 ///
725 void TGParser::ParseRangeList(SmallVectorImpl<unsigned> &Result) {
726  // Parse the first piece.
727  if (ParseRangePiece(Result)) {
728  Result.clear();
729  return;
730  }
731  while (Lex.getCode() == tgtok::comma) {
732  Lex.Lex(); // Eat the comma.
733 
734  // Parse the next range piece.
735  if (ParseRangePiece(Result)) {
736  Result.clear();
737  return;
738  }
739  }
740 }
741 
742 /// ParseOptionalRangeList - Parse either a range list in <>'s or nothing.
743 /// OptionalRangeList ::= '<' RangeList '>'
744 /// OptionalRangeList ::= /*empty*/
745 bool TGParser::ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges) {
746  if (Lex.getCode() != tgtok::less)
747  return false;
748 
749  SMLoc StartLoc = Lex.getLoc();
750  Lex.Lex(); // eat the '<'
751 
752  // Parse the range list.
753  ParseRangeList(Ranges);
754  if (Ranges.empty()) return true;
755 
756  if (Lex.getCode() != tgtok::greater) {
757  TokError("expected '>' at end of range list");
758  return Error(StartLoc, "to match this '<'");
759  }
760  Lex.Lex(); // eat the '>'.
761  return false;
762 }
763 
764 /// ParseOptionalBitList - Parse either a bit list in {}'s or nothing.
765 /// OptionalBitList ::= '{' RangeList '}'
766 /// OptionalBitList ::= /*empty*/
767 bool TGParser::ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges) {
768  if (Lex.getCode() != tgtok::l_brace)
769  return false;
770 
771  SMLoc StartLoc = Lex.getLoc();
772  Lex.Lex(); // eat the '{'
773 
774  // Parse the range list.
775  ParseRangeList(Ranges);
776  if (Ranges.empty()) return true;
777 
778  if (Lex.getCode() != tgtok::r_brace) {
779  TokError("expected '}' at end of bit list");
780  return Error(StartLoc, "to match this '{'");
781  }
782  Lex.Lex(); // eat the '}'.
783  return false;
784 }
785 
786 /// ParseType - Parse and return a tblgen type. This returns null on error.
787 ///
788 /// Type ::= STRING // string type
789 /// Type ::= CODE // code type
790 /// Type ::= BIT // bit type
791 /// Type ::= BITS '<' INTVAL '>' // bits<x> type
792 /// Type ::= INT // int type
793 /// Type ::= LIST '<' Type '>' // list<x> type
794 /// Type ::= DAG // dag type
795 /// Type ::= ClassID // Record Type
796 ///
797 RecTy *TGParser::ParseType() {
798  switch (Lex.getCode()) {
799  default: TokError("Unknown token when expecting a type"); return nullptr;
800  case tgtok::String: Lex.Lex(); return StringRecTy::get();
801  case tgtok::Code: Lex.Lex(); return CodeRecTy::get();
802  case tgtok::Bit: Lex.Lex(); return BitRecTy::get();
803  case tgtok::Int: Lex.Lex(); return IntRecTy::get();
804  case tgtok::Dag: Lex.Lex(); return DagRecTy::get();
805  case tgtok::Id:
806  if (Record *R = ParseClassID()) return RecordRecTy::get(R);
807  TokError("unknown class name");
808  return nullptr;
809  case tgtok::Bits: {
810  if (Lex.Lex() != tgtok::less) { // Eat 'bits'
811  TokError("expected '<' after bits type");
812  return nullptr;
813  }
814  if (Lex.Lex() != tgtok::IntVal) { // Eat '<'
815  TokError("expected integer in bits<n> type");
816  return nullptr;
817  }
818  uint64_t Val = Lex.getCurIntVal();
819  if (Lex.Lex() != tgtok::greater) { // Eat count.
820  TokError("expected '>' at end of bits<n> type");
821  return nullptr;
822  }
823  Lex.Lex(); // Eat '>'
824  return BitsRecTy::get(Val);
825  }
826  case tgtok::List: {
827  if (Lex.Lex() != tgtok::less) { // Eat 'bits'
828  TokError("expected '<' after list type");
829  return nullptr;
830  }
831  Lex.Lex(); // Eat '<'
832  RecTy *SubType = ParseType();
833  if (!SubType) return nullptr;
834 
835  if (Lex.getCode() != tgtok::greater) {
836  TokError("expected '>' at end of list<ty> type");
837  return nullptr;
838  }
839  Lex.Lex(); // Eat '>'
840  return ListRecTy::get(SubType);
841  }
842  }
843 }
844 
845 /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
846 /// has already been read.
847 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
848  IDParseMode Mode) {
849  if (CurRec) {
850  if (const RecordVal *RV = CurRec->getValue(Name))
851  return VarInit::get(Name, RV->getType());
852  }
853 
854  if ((CurRec && CurRec->isClass()) || CurMultiClass) {
855  Init *TemplateArgName;
856  if (CurMultiClass) {
857  TemplateArgName =
858  QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::");
859  } else
860  TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");
861 
862  Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
863  if (TemplateRec->isTemplateArg(TemplateArgName)) {
864  const RecordVal *RV = TemplateRec->getValue(TemplateArgName);
865  assert(RV && "Template arg doesn't exist??");
866  return VarInit::get(TemplateArgName, RV->getType());
867  } else if (Name->getValue() == "NAME") {
868  return VarInit::get(TemplateArgName, StringRecTy::get());
869  }
870  }
871 
872  // If this is in a foreach loop, make sure it's not a loop iterator
873  for (const auto &L : Loops) {
874  VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
875  if (IterVar && IterVar->getNameInit() == Name)
876  return IterVar;
877  }
878 
879  if (Mode == ParseNameMode)
880  return Name;
881 
882  if (Init *I = Records.getGlobal(Name->getValue()))
883  return I;
884 
885  // Allow self-references of concrete defs, but delay the lookup so that we
886  // get the correct type.
887  if (CurRec && !CurRec->isClass() && !CurMultiClass &&
888  CurRec->getNameInit() == Name)
889  return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
890 
891  Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
892  return nullptr;
893 }
894 
895 /// ParseOperation - Parse an operator. This returns null on error.
896 ///
897 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
898 ///
899 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
900  switch (Lex.getCode()) {
901  default:
902  TokError("unknown operation");
903  return nullptr;
904  case tgtok::XHead:
905  case tgtok::XTail:
906  case tgtok::XSize:
907  case tgtok::XEmpty:
908  case tgtok::XCast: { // Value ::= !unop '(' Value ')'
909  UnOpInit::UnaryOp Code;
910  RecTy *Type = nullptr;
911 
912  switch (Lex.getCode()) {
913  default: llvm_unreachable("Unhandled code!");
914  case tgtok::XCast:
915  Lex.Lex(); // eat the operation
916  Code = UnOpInit::CAST;
917 
918  Type = ParseOperatorType();
919 
920  if (!Type) {
921  TokError("did not get type for unary operator");
922  return nullptr;
923  }
924 
925  break;
926  case tgtok::XHead:
927  Lex.Lex(); // eat the operation
928  Code = UnOpInit::HEAD;
929  break;
930  case tgtok::XTail:
931  Lex.Lex(); // eat the operation
932  Code = UnOpInit::TAIL;
933  break;
934  case tgtok::XSize:
935  Lex.Lex();
936  Code = UnOpInit::SIZE;
937  Type = IntRecTy::get();
938  break;
939  case tgtok::XEmpty:
940  Lex.Lex(); // eat the operation
941  Code = UnOpInit::EMPTY;
942  Type = IntRecTy::get();
943  break;
944  }
945  if (Lex.getCode() != tgtok::l_paren) {
946  TokError("expected '(' after unary operator");
947  return nullptr;
948  }
949  Lex.Lex(); // eat the '('
950 
951  Init *LHS = ParseValue(CurRec);
952  if (!LHS) return nullptr;
953 
954  if (Code == UnOpInit::HEAD ||
955  Code == UnOpInit::TAIL ||
956  Code == UnOpInit::EMPTY) {
957  ListInit *LHSl = dyn_cast<ListInit>(LHS);
958  StringInit *LHSs = dyn_cast<StringInit>(LHS);
959  TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
960  if (!LHSl && !LHSs && !LHSt) {
961  TokError("expected list or string type argument in unary operator");
962  return nullptr;
963  }
964  if (LHSt) {
965  ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
966  StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType());
967  if (!LType && !SType) {
968  TokError("expected list or string type argument in unary operator");
969  return nullptr;
970  }
971  }
972 
973  if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL ||
974  Code == UnOpInit::SIZE) {
975  if (!LHSl && !LHSt) {
976  TokError("expected list type argument in unary operator");
977  return nullptr;
978  }
979  }
980 
981  if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
982  if (LHSl && LHSl->empty()) {
983  TokError("empty list argument in unary operator");
984  return nullptr;
985  }
986  if (LHSl) {
987  Init *Item = LHSl->getElement(0);
988  TypedInit *Itemt = dyn_cast<TypedInit>(Item);
989  if (!Itemt) {
990  TokError("untyped list element in unary operator");
991  return nullptr;
992  }
993  Type = (Code == UnOpInit::HEAD) ? Itemt->getType()
994  : ListRecTy::get(Itemt->getType());
995  } else {
996  assert(LHSt && "expected list type argument in unary operator");
997  ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
998  if (!LType) {
999  TokError("expected list type argument in unary operator");
1000  return nullptr;
1001  }
1002  Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType;
1003  }
1004  }
1005  }
1006 
1007  if (Lex.getCode() != tgtok::r_paren) {
1008  TokError("expected ')' in unary operator");
1009  return nullptr;
1010  }
1011  Lex.Lex(); // eat the ')'
1012  return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
1013  }
1014 
1015  case tgtok::XIsA: {
1016  // Value ::= !isa '<' Type '>' '(' Value ')'
1017  Lex.Lex(); // eat the operation
1018 
1019  RecTy *Type = ParseOperatorType();
1020  if (!Type)
1021  return nullptr;
1022 
1023  if (Lex.getCode() != tgtok::l_paren) {
1024  TokError("expected '(' after type of !isa");
1025  return nullptr;
1026  }
1027  Lex.Lex(); // eat the '('
1028 
1029  Init *LHS = ParseValue(CurRec);
1030  if (!LHS)
1031  return nullptr;
1032 
1033  if (Lex.getCode() != tgtok::r_paren) {
1034  TokError("expected ')' in !isa");
1035  return nullptr;
1036  }
1037  Lex.Lex(); // eat the ')'
1038 
1039  return (IsAOpInit::get(Type, LHS))->Fold();
1040  }
1041 
1042  case tgtok::XConcat:
1043  case tgtok::XADD:
1044  case tgtok::XMUL:
1045  case tgtok::XAND:
1046  case tgtok::XOR:
1047  case tgtok::XSRA:
1048  case tgtok::XSRL:
1049  case tgtok::XSHL:
1050  case tgtok::XEq:
1051  case tgtok::XNe:
1052  case tgtok::XLe:
1053  case tgtok::XLt:
1054  case tgtok::XGe:
1055  case tgtok::XGt:
1056  case tgtok::XListConcat:
1057  case tgtok::XListSplat:
1058  case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')'
1059  tgtok::TokKind OpTok = Lex.getCode();
1060  SMLoc OpLoc = Lex.getLoc();
1061  Lex.Lex(); // eat the operation
1062 
1063  BinOpInit::BinaryOp Code;
1064  switch (OpTok) {
1065  default: llvm_unreachable("Unhandled code!");
1066  case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
1067  case tgtok::XADD: Code = BinOpInit::ADD; break;
1068  case tgtok::XMUL: Code = BinOpInit::MUL; break;
1069  case tgtok::XAND: Code = BinOpInit::AND; break;
1070  case tgtok::XOR: Code = BinOpInit::OR; break;
1071  case tgtok::XSRA: Code = BinOpInit::SRA; break;
1072  case tgtok::XSRL: Code = BinOpInit::SRL; break;
1073  case tgtok::XSHL: Code = BinOpInit::SHL; break;
1074  case tgtok::XEq: Code = BinOpInit::EQ; break;
1075  case tgtok::XNe: Code = BinOpInit::NE; break;
1076  case tgtok::XLe: Code = BinOpInit::LE; break;
1077  case tgtok::XLt: Code = BinOpInit::LT; break;
1078  case tgtok::XGe: Code = BinOpInit::GE; break;
1079  case tgtok::XGt: Code = BinOpInit::GT; break;
1080  case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
1081  case tgtok::XListSplat: Code = BinOpInit::LISTSPLAT; break;
1082  case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
1083  }
1084 
1085  RecTy *Type = nullptr;
1086  RecTy *ArgType = nullptr;
1087  switch (OpTok) {
1088  default:
1089  llvm_unreachable("Unhandled code!");
1090  case tgtok::XConcat:
1091  Type = DagRecTy::get();
1092  ArgType = DagRecTy::get();
1093  break;
1094  case tgtok::XAND:
1095  case tgtok::XOR:
1096  case tgtok::XSRA:
1097  case tgtok::XSRL:
1098  case tgtok::XSHL:
1099  case tgtok::XADD:
1100  case tgtok::XMUL:
1101  Type = IntRecTy::get();
1102  ArgType = IntRecTy::get();
1103  break;
1104  case tgtok::XEq:
1105  case tgtok::XNe:
1106  Type = BitRecTy::get();
1107  // ArgType for Eq / Ne is not known at this point
1108  break;
1109  case tgtok::XLe:
1110  case tgtok::XLt:
1111  case tgtok::XGe:
1112  case tgtok::XGt:
1113  Type = BitRecTy::get();
1114  ArgType = IntRecTy::get();
1115  break;
1116  case tgtok::XListConcat:
1117  // We don't know the list type until we parse the first argument
1118  ArgType = ItemType;
1119  break;
1120  case tgtok::XListSplat:
1121  // Can't do any typechecking until we parse the first argument.
1122  break;
1123  case tgtok::XStrConcat:
1124  Type = StringRecTy::get();
1125  ArgType = StringRecTy::get();
1126  break;
1127  }
1128 
1129  if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
1130  Error(OpLoc, Twine("expected value of type '") +
1131  ItemType->getAsString() + "', got '" +
1132  Type->getAsString() + "'");
1133  return nullptr;
1134  }
1135 
1136  if (Lex.getCode() != tgtok::l_paren) {
1137  TokError("expected '(' after binary operator");
1138  return nullptr;
1139  }
1140  Lex.Lex(); // eat the '('
1141 
1142  SmallVector<Init*, 2> InitList;
1143 
1144  for (;;) {
1145  SMLoc InitLoc = Lex.getLoc();
1146  InitList.push_back(ParseValue(CurRec, ArgType));
1147  if (!InitList.back()) return nullptr;
1148 
1149  // All BinOps require their arguments to be of compatible types.
1150  RecTy *ListType = cast<TypedInit>(InitList.back())->getType();
1151  if (!ArgType) {
1152  ArgType = ListType;
1153 
1154  switch (Code) {
1155  case BinOpInit::LISTCONCAT:
1156  if (!isa<ListRecTy>(ArgType)) {
1157  Error(InitLoc, Twine("expected a list, got value of type '") +
1158  ArgType->getAsString() + "'");
1159  return nullptr;
1160  }
1161  break;
1162  case BinOpInit::LISTSPLAT:
1163  if (ItemType && InitList.size() == 1) {
1164  if (!isa<ListRecTy>(ItemType)) {
1165  Error(OpLoc,
1166  Twine("expected output type to be a list, got type '") +
1167  ItemType->getAsString() + "'");
1168  return nullptr;
1169  }
1170  if (!ArgType->getListTy()->typeIsConvertibleTo(ItemType)) {
1171  Error(OpLoc, Twine("expected first arg type to be '") +
1172  ArgType->getAsString() +
1173  "', got value of type '" +
1174  cast<ListRecTy>(ItemType)
1175  ->getElementType()
1176  ->getAsString() +
1177  "'");
1178  return nullptr;
1179  }
1180  }
1181  if (InitList.size() == 2 && !isa<IntRecTy>(ArgType)) {
1182  Error(InitLoc, Twine("expected second parameter to be an int, got "
1183  "value of type '") +
1184  ArgType->getAsString() + "'");
1185  return nullptr;
1186  }
1187  ArgType = nullptr; // Broken invariant: types not identical.
1188  break;
1189  case BinOpInit::EQ:
1190  case BinOpInit::NE:
1191  if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
1192  !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
1193  Error(InitLoc, Twine("expected int, bits, or string; got value of "
1194  "type '") + ArgType->getAsString() + "'");
1195  return nullptr;
1196  }
1197  break;
1198  default: llvm_unreachable("other ops have fixed argument types");
1199  }
1200  } else {
1201  RecTy *Resolved = resolveTypes(ArgType, ListType);
1202  if (!Resolved) {
1203  Error(InitLoc, Twine("expected value of type '") +
1204  ArgType->getAsString() + "', got '" +
1205  ListType->getAsString() + "'");
1206  return nullptr;
1207  }
1208  if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
1209  Code != BinOpInit::OR && Code != BinOpInit::SRA &&
1210  Code != BinOpInit::SRL && Code != BinOpInit::SHL &&
1211  Code != BinOpInit::MUL)
1212  ArgType = Resolved;
1213  }
1214 
1215  if (Lex.getCode() != tgtok::comma)
1216  break;
1217  Lex.Lex(); // eat the ','
1218  }
1219 
1220  if (Lex.getCode() != tgtok::r_paren) {
1221  TokError("expected ')' in operator");
1222  return nullptr;
1223  }
1224  Lex.Lex(); // eat the ')'
1225 
1226  // listconcat returns a list with type of the argument.
1227  if (Code == BinOpInit::LISTCONCAT)
1228  Type = ArgType;
1229  // listsplat returns a list of type of the *first* argument.
1230  if (Code == BinOpInit::LISTSPLAT)
1231  Type = cast<TypedInit>(InitList.front())->getType()->getListTy();
1232 
1233  // We allow multiple operands to associative operators like !strconcat as
1234  // shorthand for nesting them.
1235  if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
1236  Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
1237  Code == BinOpInit::AND || Code == BinOpInit::OR ||
1238  Code == BinOpInit::MUL) {
1239  while (InitList.size() > 2) {
1240  Init *RHS = InitList.pop_back_val();
1241  RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
1242  InitList.back() = RHS;
1243  }
1244  }
1245 
1246  if (InitList.size() == 2)
1247  return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
1248  ->Fold(CurRec);
1249 
1250  Error(OpLoc, "expected two operands to operator");
1251  return nullptr;
1252  }
1253 
1254  case tgtok::XForEach: { // Value ::= !foreach '(' Id ',' Value ',' Value ')'
1255  SMLoc OpLoc = Lex.getLoc();
1256  Lex.Lex(); // eat the operation
1257  if (Lex.getCode() != tgtok::l_paren) {
1258  TokError("expected '(' after !foreach");
1259  return nullptr;
1260  }
1261 
1262  if (Lex.Lex() != tgtok::Id) { // eat the '('
1263  TokError("first argument of !foreach must be an identifier");
1264  return nullptr;
1265  }
1266 
1267  Init *LHS = StringInit::get(Lex.getCurStrVal());
1268 
1269  if (CurRec && CurRec->getValue(LHS)) {
1270  TokError((Twine("iteration variable '") + LHS->getAsString() +
1271  "' already defined")
1272  .str());
1273  return nullptr;
1274  }
1275 
1276  if (Lex.Lex() != tgtok::comma) { // eat the id
1277  TokError("expected ',' in ternary operator");
1278  return nullptr;
1279  }
1280  Lex.Lex(); // eat the ','
1281 
1282  Init *MHS = ParseValue(CurRec);
1283  if (!MHS)
1284  return nullptr;
1285 
1286  if (Lex.getCode() != tgtok::comma) {
1287  TokError("expected ',' in ternary operator");
1288  return nullptr;
1289  }
1290  Lex.Lex(); // eat the ','
1291 
1292  TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
1293  if (!MHSt) {
1294  TokError("could not get type of !foreach input");
1295  return nullptr;
1296  }
1297 
1298  RecTy *InEltType = nullptr;
1299  RecTy *OutEltType = nullptr;
1300  bool IsDAG = false;
1301 
1302  if (ListRecTy *InListTy = dyn_cast<ListRecTy>(MHSt->getType())) {
1303  InEltType = InListTy->getElementType();
1304  if (ItemType) {
1305  if (ListRecTy *OutListTy = dyn_cast<ListRecTy>(ItemType)) {
1306  OutEltType = OutListTy->getElementType();
1307  } else {
1308  Error(OpLoc,
1309  "expected value of type '" + Twine(ItemType->getAsString()) +
1310  "', but got !foreach of list type");
1311  return nullptr;
1312  }
1313  }
1314  } else if (DagRecTy *InDagTy = dyn_cast<DagRecTy>(MHSt->getType())) {
1315  InEltType = InDagTy;
1316  if (ItemType && !isa<DagRecTy>(ItemType)) {
1317  Error(OpLoc,
1318  "expected value of type '" + Twine(ItemType->getAsString()) +
1319  "', but got !foreach of dag type");
1320  return nullptr;
1321  }
1322  IsDAG = true;
1323  } else {
1324  TokError("!foreach must have list or dag input");
1325  return nullptr;
1326  }
1327 
1328  // We need to create a temporary record to provide a scope for the iteration
1329  // variable while parsing top-level foreach's.
1330  std::unique_ptr<Record> ParseRecTmp;
1331  Record *ParseRec = CurRec;
1332  if (!ParseRec) {
1333  ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
1334  ParseRec = ParseRecTmp.get();
1335  }
1336 
1337  ParseRec->addValue(RecordVal(LHS, InEltType, false));
1338  Init *RHS = ParseValue(ParseRec, OutEltType);
1339  ParseRec->removeValue(LHS);
1340  if (!RHS)
1341  return nullptr;
1342 
1343  if (Lex.getCode() != tgtok::r_paren) {
1344  TokError("expected ')' in binary operator");
1345  return nullptr;
1346  }
1347  Lex.Lex(); // eat the ')'
1348 
1349  RecTy *OutType;
1350  if (IsDAG) {
1351  OutType = InEltType;
1352  } else {
1353  TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
1354  if (!RHSt) {
1355  TokError("could not get type of !foreach result");
1356  return nullptr;
1357  }
1358  OutType = RHSt->getType()->getListTy();
1359  }
1360 
1361  return (TernOpInit::get(TernOpInit::FOREACH, LHS, MHS, RHS, OutType))
1362  ->Fold(CurRec);
1363  }
1364 
1365  case tgtok::XDag:
1366  case tgtok::XIf:
1367  case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
1368  TernOpInit::TernaryOp Code;
1369  RecTy *Type = nullptr;
1370 
1371  tgtok::TokKind LexCode = Lex.getCode();
1372  Lex.Lex(); // eat the operation
1373  switch (LexCode) {
1374  default: llvm_unreachable("Unhandled code!");
1375  case tgtok::XDag:
1376  Code = TernOpInit::DAG;
1377  Type = DagRecTy::get();
1378  ItemType = nullptr;
1379  break;
1380  case tgtok::XIf:
1381  Code = TernOpInit::IF;
1382  break;
1383  case tgtok::XSubst:
1384  Code = TernOpInit::SUBST;
1385  break;
1386  }
1387  if (Lex.getCode() != tgtok::l_paren) {
1388  TokError("expected '(' after ternary operator");
1389  return nullptr;
1390  }
1391  Lex.Lex(); // eat the '('
1392 
1393  Init *LHS = ParseValue(CurRec);
1394  if (!LHS) return nullptr;
1395 
1396  if (Lex.getCode() != tgtok::comma) {
1397  TokError("expected ',' in ternary operator");
1398  return nullptr;
1399  }
1400  Lex.Lex(); // eat the ','
1401 
1402  SMLoc MHSLoc = Lex.getLoc();
1403  Init *MHS = ParseValue(CurRec, ItemType);
1404  if (!MHS)
1405  return nullptr;
1406 
1407  if (Lex.getCode() != tgtok::comma) {
1408  TokError("expected ',' in ternary operator");
1409  return nullptr;
1410  }
1411  Lex.Lex(); // eat the ','
1412 
1413  SMLoc RHSLoc = Lex.getLoc();
1414  Init *RHS = ParseValue(CurRec, ItemType);
1415  if (!RHS)
1416  return nullptr;
1417 
1418  if (Lex.getCode() != tgtok::r_paren) {
1419  TokError("expected ')' in binary operator");
1420  return nullptr;
1421  }
1422  Lex.Lex(); // eat the ')'
1423 
1424  switch (LexCode) {
1425  default: llvm_unreachable("Unhandled code!");
1426  case tgtok::XDag: {
1427  TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
1428  if (!MHSt && !isa<UnsetInit>(MHS)) {
1429  Error(MHSLoc, "could not determine type of the child list in !dag");
1430  return nullptr;
1431  }
1432  if (MHSt && !isa<ListRecTy>(MHSt->getType())) {
1433  Error(MHSLoc, Twine("expected list of children, got type '") +
1434  MHSt->getType()->getAsString() + "'");
1435  return nullptr;
1436  }
1437 
1438  TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
1439  if (!RHSt && !isa<UnsetInit>(RHS)) {
1440  Error(RHSLoc, "could not determine type of the name list in !dag");
1441  return nullptr;
1442  }
1443  if (RHSt && StringRecTy::get()->getListTy() != RHSt->getType()) {
1444  Error(RHSLoc, Twine("expected list<string>, got type '") +
1445  RHSt->getType()->getAsString() + "'");
1446  return nullptr;
1447  }
1448 
1449  if (!MHSt && !RHSt) {
1450  Error(MHSLoc,
1451  "cannot have both unset children and unset names in !dag");
1452  return nullptr;
1453  }
1454  break;
1455  }
1456  case tgtok::XIf: {
1457  RecTy *MHSTy = nullptr;
1458  RecTy *RHSTy = nullptr;
1459 
1460  if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
1461  MHSTy = MHSt->getType();
1462  if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS))
1463  MHSTy = BitsRecTy::get(MHSbits->getNumBits());
1464  if (isa<BitInit>(MHS))
1465  MHSTy = BitRecTy::get();
1466 
1467  if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS))
1468  RHSTy = RHSt->getType();
1469  if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS))
1470  RHSTy = BitsRecTy::get(RHSbits->getNumBits());
1471  if (isa<BitInit>(RHS))
1472  RHSTy = BitRecTy::get();
1473 
1474  // For UnsetInit, it's typed from the other hand.
1475  if (isa<UnsetInit>(MHS))
1476  MHSTy = RHSTy;
1477  if (isa<UnsetInit>(RHS))
1478  RHSTy = MHSTy;
1479 
1480  if (!MHSTy || !RHSTy) {
1481  TokError("could not get type for !if");
1482  return nullptr;
1483  }
1484 
1485  Type = resolveTypes(MHSTy, RHSTy);
1486  if (!Type) {
1487  TokError(Twine("inconsistent types '") + MHSTy->getAsString() +
1488  "' and '" + RHSTy->getAsString() + "' for !if");
1489  return nullptr;
1490  }
1491  break;
1492  }
1493  case tgtok::XSubst: {
1494  TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
1495  if (!RHSt) {
1496  TokError("could not get type for !subst");
1497  return nullptr;
1498  }
1499  Type = RHSt->getType();
1500  break;
1501  }
1502  }
1503  return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
1504  }
1505 
1506  case tgtok::XCond:
1507  return ParseOperationCond(CurRec, ItemType);
1508 
1509  case tgtok::XFoldl: {
1510  // Value ::= !foldl '(' Id ',' Id ',' Value ',' Value ',' Value ')'
1511  Lex.Lex(); // eat the operation
1512  if (Lex.getCode() != tgtok::l_paren) {
1513  TokError("expected '(' after !foldl");
1514  return nullptr;
1515  }
1516  Lex.Lex(); // eat the '('
1517 
1518  Init *StartUntyped = ParseValue(CurRec);
1519  if (!StartUntyped)
1520  return nullptr;
1521 
1522  TypedInit *Start = dyn_cast<TypedInit>(StartUntyped);
1523  if (!Start) {
1524  TokError(Twine("could not get type of !foldl start: '") +
1525  StartUntyped->getAsString() + "'");
1526  return nullptr;
1527  }
1528 
1529  if (Lex.getCode() != tgtok::comma) {
1530  TokError("expected ',' in !foldl");
1531  return nullptr;
1532  }
1533  Lex.Lex(); // eat the ','
1534 
1535  Init *ListUntyped = ParseValue(CurRec);
1536  if (!ListUntyped)
1537  return nullptr;
1538 
1539  TypedInit *List = dyn_cast<TypedInit>(ListUntyped);
1540  if (!List) {
1541  TokError(Twine("could not get type of !foldl list: '") +
1542  ListUntyped->getAsString() + "'");
1543  return nullptr;
1544  }
1545 
1546  ListRecTy *ListType = dyn_cast<ListRecTy>(List->getType());
1547  if (!ListType) {
1548  TokError(Twine("!foldl list must be a list, but is of type '") +
1549  List->getType()->getAsString());
1550  return nullptr;
1551  }
1552 
1553  if (Lex.getCode() != tgtok::comma) {
1554  TokError("expected ',' in !foldl");
1555  return nullptr;
1556  }
1557 
1558  if (Lex.Lex() != tgtok::Id) { // eat the ','
1559  TokError("third argument of !foldl must be an identifier");
1560  return nullptr;
1561  }
1562 
1563  Init *A = StringInit::get(Lex.getCurStrVal());
1564  if (CurRec && CurRec->getValue(A)) {
1565  TokError((Twine("left !foldl variable '") + A->getAsString() +
1566  "' already defined")
1567  .str());
1568  return nullptr;
1569  }
1570 
1571  if (Lex.Lex() != tgtok::comma) { // eat the id
1572  TokError("expected ',' in !foldl");
1573  return nullptr;
1574  }
1575 
1576  if (Lex.Lex() != tgtok::Id) { // eat the ','
1577  TokError("fourth argument of !foldl must be an identifier");
1578  return nullptr;
1579  }
1580 
1581  Init *B = StringInit::get(Lex.getCurStrVal());
1582  if (CurRec && CurRec->getValue(B)) {
1583  TokError((Twine("right !foldl variable '") + B->getAsString() +
1584  "' already defined")
1585  .str());
1586  return nullptr;
1587  }
1588 
1589  if (Lex.Lex() != tgtok::comma) { // eat the id
1590  TokError("expected ',' in !foldl");
1591  return nullptr;
1592  }
1593  Lex.Lex(); // eat the ','
1594 
1595  // We need to create a temporary record to provide a scope for the iteration
1596  // variable while parsing top-level foreach's.
1597  std::unique_ptr<Record> ParseRecTmp;
1598  Record *ParseRec = CurRec;
1599  if (!ParseRec) {
1600  ParseRecTmp = std::make_unique<Record>(".parse", ArrayRef<SMLoc>{}, Records);
1601  ParseRec = ParseRecTmp.get();
1602  }
1603 
1604  ParseRec->addValue(RecordVal(A, Start->getType(), false));
1605  ParseRec->addValue(RecordVal(B, ListType->getElementType(), false));
1606  Init *ExprUntyped = ParseValue(ParseRec);
1607  ParseRec->removeValue(A);
1608  ParseRec->removeValue(B);
1609  if (!ExprUntyped)
1610  return nullptr;
1611 
1612  TypedInit *Expr = dyn_cast<TypedInit>(ExprUntyped);
1613  if (!Expr) {
1614  TokError("could not get type of !foldl expression");
1615  return nullptr;
1616  }
1617 
1618  if (Expr->getType() != Start->getType()) {
1619  TokError(Twine("!foldl expression must be of same type as start (") +
1620  Start->getType()->getAsString() + "), but is of type " +
1621  Expr->getType()->getAsString());
1622  return nullptr;
1623  }
1624 
1625  if (Lex.getCode() != tgtok::r_paren) {
1626  TokError("expected ')' in fold operator");
1627  return nullptr;
1628  }
1629  Lex.Lex(); // eat the ')'
1630 
1631  return FoldOpInit::get(Start, List, A, B, Expr, Start->getType())
1632  ->Fold(CurRec);
1633  }
1634  }
1635 }
1636 
1637 /// ParseOperatorType - Parse a type for an operator. This returns
1638 /// null on error.
1639 ///
1640 /// OperatorType ::= '<' Type '>'
1641 ///
1642 RecTy *TGParser::ParseOperatorType() {
1643  RecTy *Type = nullptr;
1644 
1645  if (Lex.getCode() != tgtok::less) {
1646  TokError("expected type name for operator");
1647  return nullptr;
1648  }
1649  Lex.Lex(); // eat the <
1650 
1651  Type = ParseType();
1652 
1653  if (!Type) {
1654  TokError("expected type name for operator");
1655  return nullptr;
1656  }
1657 
1658  if (Lex.getCode() != tgtok::greater) {
1659  TokError("expected type name for operator");
1660  return nullptr;
1661  }
1662  Lex.Lex(); // eat the >
1663 
1664  return Type;
1665 }
1666 
1667 Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
1668  Lex.Lex(); // eat the operation 'cond'
1669 
1670  if (Lex.getCode() != tgtok::l_paren) {
1671  TokError("expected '(' after !cond operator");
1672  return nullptr;
1673  }
1674  Lex.Lex(); // eat the '('
1675 
1676  // Parse through '[Case: Val,]+'
1679  while (true) {
1680  if (Lex.getCode() == tgtok::r_paren) {
1681  Lex.Lex(); // eat the ')'
1682  break;
1683  }
1684 
1685  Init *V = ParseValue(CurRec);
1686  if (!V)
1687  return nullptr;
1688  Case.push_back(V);
1689 
1690  if (Lex.getCode() != tgtok::colon) {
1691  TokError("expected ':' following a condition in !cond operator");
1692  return nullptr;
1693  }
1694  Lex.Lex(); // eat the ':'
1695 
1696  V = ParseValue(CurRec, ItemType);
1697  if (!V)
1698  return nullptr;
1699  Val.push_back(V);
1700 
1701  if (Lex.getCode() == tgtok::r_paren) {
1702  Lex.Lex(); // eat the ')'
1703  break;
1704  }
1705 
1706  if (Lex.getCode() != tgtok::comma) {
1707  TokError("expected ',' or ')' following a value in !cond operator");
1708  return nullptr;
1709  }
1710  Lex.Lex(); // eat the ','
1711  }
1712 
1713  if (Case.size() < 1) {
1714  TokError("there should be at least 1 'condition : value' in the !cond operator");
1715  return nullptr;
1716  }
1717 
1718  // resolve type
1719  RecTy *Type = nullptr;
1720  for (Init *V : Val) {
1721  RecTy *VTy = nullptr;
1722  if (TypedInit *Vt = dyn_cast<TypedInit>(V))
1723  VTy = Vt->getType();
1724  if (BitsInit *Vbits = dyn_cast<BitsInit>(V))
1725  VTy = BitsRecTy::get(Vbits->getNumBits());
1726  if (isa<BitInit>(V))
1727  VTy = BitRecTy::get();
1728 
1729  if (Type == nullptr) {
1730  if (!isa<UnsetInit>(V))
1731  Type = VTy;
1732  } else {
1733  if (!isa<UnsetInit>(V)) {
1734  RecTy *RType = resolveTypes(Type, VTy);
1735  if (!RType) {
1736  TokError(Twine("inconsistent types '") + Type->getAsString() +
1737  "' and '" + VTy->getAsString() + "' for !cond");
1738  return nullptr;
1739  }
1740  Type = RType;
1741  }
1742  }
1743  }
1744 
1745  if (!Type) {
1746  TokError("could not determine type for !cond from its arguments");
1747  return nullptr;
1748  }
1749  return CondOpInit::get(Case, Val, Type)->Fold(CurRec);
1750 }
1751 
1752 /// ParseSimpleValue - Parse a tblgen value. This returns null on error.
1753 ///
1754 /// SimpleValue ::= IDValue
1755 /// SimpleValue ::= INTVAL
1756 /// SimpleValue ::= STRVAL+
1757 /// SimpleValue ::= CODEFRAGMENT
1758 /// SimpleValue ::= '?'
1759 /// SimpleValue ::= '{' ValueList '}'
1760 /// SimpleValue ::= ID '<' ValueListNE '>'
1761 /// SimpleValue ::= '[' ValueList ']'
1762 /// SimpleValue ::= '(' IDValue DagArgList ')'
1763 /// SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
1764 /// SimpleValue ::= ADDTOK '(' Value ',' Value ')'
1765 /// SimpleValue ::= SHLTOK '(' Value ',' Value ')'
1766 /// SimpleValue ::= SRATOK '(' Value ',' Value ')'
1767 /// SimpleValue ::= SRLTOK '(' Value ',' Value ')'
1768 /// SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
1769 /// SimpleValue ::= LISTSPLATTOK '(' Value ',' Value ')'
1770 /// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
1771 /// SimpleValue ::= COND '(' [Value ':' Value,]+ ')'
1772 ///
1773 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
1774  IDParseMode Mode) {
1775  Init *R = nullptr;
1776  switch (Lex.getCode()) {
1777  default: TokError("Unknown token when parsing a value"); break;
1778  case tgtok::paste:
1779  // This is a leading paste operation. This is deprecated but
1780  // still exists in some .td files. Ignore it.
1781  Lex.Lex(); // Skip '#'.
1782  return ParseSimpleValue(CurRec, ItemType, Mode);
1783  case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break;
1784  case tgtok::BinaryIntVal: {
1785  auto BinaryVal = Lex.getCurBinaryIntVal();
1786  SmallVector<Init*, 16> Bits(BinaryVal.second);
1787  for (unsigned i = 0, e = BinaryVal.second; i != e; ++i)
1788  Bits[i] = BitInit::get(BinaryVal.first & (1LL << i));
1789  R = BitsInit::get(Bits);
1790  Lex.Lex();
1791  break;
1792  }
1793  case tgtok::StrVal: {
1794  std::string Val = Lex.getCurStrVal();
1795  Lex.Lex();
1796 
1797  // Handle multiple consecutive concatenated strings.
1798  while (Lex.getCode() == tgtok::StrVal) {
1799  Val += Lex.getCurStrVal();
1800  Lex.Lex();
1801  }
1802 
1803  R = StringInit::get(Val);
1804  break;
1805  }
1806  case tgtok::CodeFragment:
1807  R = CodeInit::get(Lex.getCurStrVal(), Lex.getLoc());
1808  Lex.Lex();
1809  break;
1810  case tgtok::question:
1811  R = UnsetInit::get();
1812  Lex.Lex();
1813  break;
1814  case tgtok::Id: {
1815  SMLoc NameLoc = Lex.getLoc();
1816  StringInit *Name = StringInit::get(Lex.getCurStrVal());
1817  if (Lex.Lex() != tgtok::less) // consume the Id.
1818  return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue
1819 
1820  // Value ::= ID '<' ValueListNE '>'
1821  if (Lex.Lex() == tgtok::greater) {
1822  TokError("expected non-empty value list");
1823  return nullptr;
1824  }
1825 
1826  // This is a CLASS<initvalslist> expression. This is supposed to synthesize
1827  // a new anonymous definition, deriving from CLASS<initvalslist> with no
1828  // body.
1829  Record *Class = Records.getClass(Name->getValue());
1830  if (!Class) {
1831  Error(NameLoc, "Expected a class name, got '" + Name->getValue() + "'");
1832  return nullptr;
1833  }
1834 
1836  ParseValueList(Args, CurRec, Class);
1837  if (Args.empty()) return nullptr;
1838 
1839  if (Lex.getCode() != tgtok::greater) {
1840  TokError("expected '>' at end of value list");
1841  return nullptr;
1842  }
1843  Lex.Lex(); // eat the '>'
1844 
1845  // Typecheck the template arguments list
1846  ArrayRef<Init *> ExpectedArgs = Class->getTemplateArgs();
1847  if (ExpectedArgs.size() < Args.size()) {
1848  Error(NameLoc,
1849  "More template args specified than expected");
1850  return nullptr;
1851  }
1852 
1853  for (unsigned i = 0, e = ExpectedArgs.size(); i != e; ++i) {
1854  RecordVal *ExpectedArg = Class->getValue(ExpectedArgs[i]);
1855  if (i < Args.size()) {
1856  if (TypedInit *TI = dyn_cast<TypedInit>(Args[i])) {
1857  RecTy *ExpectedType = ExpectedArg->getType();
1858  if (!TI->getType()->typeIsConvertibleTo(ExpectedType)) {
1859  Error(NameLoc,
1860  "Value specified for template argument #" + Twine(i) + " (" +
1861  ExpectedArg->getNameInitAsString() + ") is of type '" +
1862  TI->getType()->getAsString() + "', expected '" +
1863  ExpectedType->getAsString() + "': " + TI->getAsString());
1864  return nullptr;
1865  }
1866  continue;
1867  }
1868  } else if (ExpectedArg->getValue()->isComplete())
1869  continue;
1870 
1871  Error(NameLoc,
1872  "Value not specified for template argument #" + Twine(i) + " (" +
1873  ExpectedArgs[i]->getAsUnquotedString() + ")");
1874  return nullptr;
1875  }
1876 
1877  return VarDefInit::get(Class, Args)->Fold();
1878  }
1879  case tgtok::l_brace: { // Value ::= '{' ValueList '}'
1880  SMLoc BraceLoc = Lex.getLoc();
1881  Lex.Lex(); // eat the '{'
1883 
1884  if (Lex.getCode() != tgtok::r_brace) {
1885  ParseValueList(Vals, CurRec);
1886  if (Vals.empty()) return nullptr;
1887  }
1888  if (Lex.getCode() != tgtok::r_brace) {
1889  TokError("expected '}' at end of bit list value");
1890  return nullptr;
1891  }
1892  Lex.Lex(); // eat the '}'
1893 
1894  SmallVector<Init *, 16> NewBits;
1895 
1896  // As we parse { a, b, ... }, 'a' is the highest bit, but we parse it
1897  // first. We'll first read everything in to a vector, then we can reverse
1898  // it to get the bits in the correct order for the BitsInit value.
1899  for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
1900  // FIXME: The following two loops would not be duplicated
1901  // if the API was a little more orthogonal.
1902 
1903  // bits<n> values are allowed to initialize n bits.
1904  if (BitsInit *BI = dyn_cast<BitsInit>(Vals[i])) {
1905  for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
1906  NewBits.push_back(BI->getBit((e - i) - 1));
1907  continue;
1908  }
1909  // bits<n> can also come from variable initializers.
1910  if (VarInit *VI = dyn_cast<VarInit>(Vals[i])) {
1911  if (BitsRecTy *BitsRec = dyn_cast<BitsRecTy>(VI->getType())) {
1912  for (unsigned i = 0, e = BitsRec->getNumBits(); i != e; ++i)
1913  NewBits.push_back(VI->getBit((e - i) - 1));
1914  continue;
1915  }
1916  // Fallthrough to try convert this to a bit.
1917  }
1918  // All other values must be convertible to just a single bit.
1919  Init *Bit = Vals[i]->getCastTo(BitRecTy::get());
1920  if (!Bit) {
1921  Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
1922  ") is not convertable to a bit");
1923  return nullptr;
1924  }
1925  NewBits.push_back(Bit);
1926  }
1927  std::reverse(NewBits.begin(), NewBits.end());
1928  return BitsInit::get(NewBits);
1929  }
1930  case tgtok::l_square: { // Value ::= '[' ValueList ']'
1931  Lex.Lex(); // eat the '['
1933 
1934  RecTy *DeducedEltTy = nullptr;
1935  ListRecTy *GivenListTy = nullptr;
1936 
1937  if (ItemType) {
1938  ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType);
1939  if (!ListType) {
1940  TokError(Twine("Type mismatch for list, expected list type, got ") +
1941  ItemType->getAsString());
1942  return nullptr;
1943  }
1944  GivenListTy = ListType;
1945  }
1946 
1947  if (Lex.getCode() != tgtok::r_square) {
1948  ParseValueList(Vals, CurRec, nullptr,
1949  GivenListTy ? GivenListTy->getElementType() : nullptr);
1950  if (Vals.empty()) return nullptr;
1951  }
1952  if (Lex.getCode() != tgtok::r_square) {
1953  TokError("expected ']' at end of list value");
1954  return nullptr;
1955  }
1956  Lex.Lex(); // eat the ']'
1957 
1958  RecTy *GivenEltTy = nullptr;
1959  if (Lex.getCode() == tgtok::less) {
1960  // Optional list element type
1961  Lex.Lex(); // eat the '<'
1962 
1963  GivenEltTy = ParseType();
1964  if (!GivenEltTy) {
1965  // Couldn't parse element type
1966  return nullptr;
1967  }
1968 
1969  if (Lex.getCode() != tgtok::greater) {
1970  TokError("expected '>' at end of list element type");
1971  return nullptr;
1972  }
1973  Lex.Lex(); // eat the '>'
1974  }
1975 
1976  // Check elements
1977  RecTy *EltTy = nullptr;
1978  for (Init *V : Vals) {
1979  TypedInit *TArg = dyn_cast<TypedInit>(V);
1980  if (TArg) {
1981  if (EltTy) {
1982  EltTy = resolveTypes(EltTy, TArg->getType());
1983  if (!EltTy) {
1984  TokError("Incompatible types in list elements");
1985  return nullptr;
1986  }
1987  } else {
1988  EltTy = TArg->getType();
1989  }
1990  }
1991  }
1992 
1993  if (GivenEltTy) {
1994  if (EltTy) {
1995  // Verify consistency
1996  if (!EltTy->typeIsConvertibleTo(GivenEltTy)) {
1997  TokError("Incompatible types in list elements");
1998  return nullptr;
1999  }
2000  }
2001  EltTy = GivenEltTy;
2002  }
2003 
2004  if (!EltTy) {
2005  if (!ItemType) {
2006  TokError("No type for list");
2007  return nullptr;
2008  }
2009  DeducedEltTy = GivenListTy->getElementType();
2010  } else {
2011  // Make sure the deduced type is compatible with the given type
2012  if (GivenListTy) {
2013  if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) {
2014  TokError(Twine("Element type mismatch for list: element type '") +
2015  EltTy->getAsString() + "' not convertible to '" +
2016  GivenListTy->getElementType()->getAsString());
2017  return nullptr;
2018  }
2019  }
2020  DeducedEltTy = EltTy;
2021  }
2022 
2023  return ListInit::get(Vals, DeducedEltTy);
2024  }
2025  case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')'
2026  Lex.Lex(); // eat the '('
2027  if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) {
2028  TokError("expected identifier in dag init");
2029  return nullptr;
2030  }
2031 
2032  Init *Operator = ParseValue(CurRec);
2033  if (!Operator) return nullptr;
2034 
2035  // If the operator name is present, parse it.
2036  StringInit *OperatorName = nullptr;
2037  if (Lex.getCode() == tgtok::colon) {
2038  if (Lex.Lex() != tgtok::VarName) { // eat the ':'
2039  TokError("expected variable name in dag operator");
2040  return nullptr;
2041  }
2042  OperatorName = StringInit::get(Lex.getCurStrVal());
2043  Lex.Lex(); // eat the VarName.
2044  }
2045 
2047  if (Lex.getCode() != tgtok::r_paren) {
2048  ParseDagArgList(DagArgs, CurRec);
2049  if (DagArgs.empty()) return nullptr;
2050  }
2051 
2052  if (Lex.getCode() != tgtok::r_paren) {
2053  TokError("expected ')' in dag init");
2054  return nullptr;
2055  }
2056  Lex.Lex(); // eat the ')'
2057 
2058  return DagInit::get(Operator, OperatorName, DagArgs);
2059  }
2060 
2061  case tgtok::XHead:
2062  case tgtok::XTail:
2063  case tgtok::XSize:
2064  case tgtok::XEmpty:
2065  case tgtok::XCast: // Value ::= !unop '(' Value ')'
2066  case tgtok::XIsA:
2067  case tgtok::XConcat:
2068  case tgtok::XDag:
2069  case tgtok::XADD:
2070  case tgtok::XMUL:
2071  case tgtok::XAND:
2072  case tgtok::XOR:
2073  case tgtok::XSRA:
2074  case tgtok::XSRL:
2075  case tgtok::XSHL:
2076  case tgtok::XEq:
2077  case tgtok::XNe:
2078  case tgtok::XLe:
2079  case tgtok::XLt:
2080  case tgtok::XGe:
2081  case tgtok::XGt:
2082  case tgtok::XListConcat:
2083  case tgtok::XListSplat:
2084  case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')'
2085  case tgtok::XIf:
2086  case tgtok::XCond:
2087  case tgtok::XFoldl:
2088  case tgtok::XForEach:
2089  case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
2090  return ParseOperation(CurRec, ItemType);
2091  }
2092  }
2093 
2094  return R;
2095 }
2096 
2097 /// ParseValue - Parse a tblgen value. This returns null on error.
2098 ///
2099 /// Value ::= SimpleValue ValueSuffix*
2100 /// ValueSuffix ::= '{' BitList '}'
2101 /// ValueSuffix ::= '[' BitList ']'
2102 /// ValueSuffix ::= '.' ID
2103 ///
2104 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
2105  Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
2106  if (!Result) return nullptr;
2107 
2108  // Parse the suffixes now if present.
2109  while (true) {
2110  switch (Lex.getCode()) {
2111  default: return Result;
2112  case tgtok::l_brace: {
2113  if (Mode == ParseNameMode)
2114  // This is the beginning of the object body.
2115  return Result;
2116 
2117  SMLoc CurlyLoc = Lex.getLoc();
2118  Lex.Lex(); // eat the '{'
2120  ParseRangeList(Ranges);
2121  if (Ranges.empty()) return nullptr;
2122 
2123  // Reverse the bitlist.
2124  std::reverse(Ranges.begin(), Ranges.end());
2125  Result = Result->convertInitializerBitRange(Ranges);
2126  if (!Result) {
2127  Error(CurlyLoc, "Invalid bit range for value");
2128  return nullptr;
2129  }
2130 
2131  // Eat the '}'.
2132  if (Lex.getCode() != tgtok::r_brace) {
2133  TokError("expected '}' at end of bit range list");
2134  return nullptr;
2135  }
2136  Lex.Lex();
2137  break;
2138  }
2139  case tgtok::l_square: {
2140  SMLoc SquareLoc = Lex.getLoc();
2141  Lex.Lex(); // eat the '['
2143  ParseRangeList(Ranges);
2144  if (Ranges.empty()) return nullptr;
2145 
2146  Result = Result->convertInitListSlice(Ranges);
2147  if (!Result) {
2148  Error(SquareLoc, "Invalid range for list slice");
2149  return nullptr;
2150  }
2151 
2152  // Eat the ']'.
2153  if (Lex.getCode() != tgtok::r_square) {
2154  TokError("expected ']' at end of list slice");
2155  return nullptr;
2156  }
2157  Lex.Lex();
2158  break;
2159  }
2160  case tgtok::period: {
2161  if (Lex.Lex() != tgtok::Id) { // eat the .
2162  TokError("expected field identifier after '.'");
2163  return nullptr;
2164  }
2165  StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
2166  if (!Result->getFieldType(FieldName)) {
2167  TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
2168  Result->getAsString() + "'");
2169  return nullptr;
2170  }
2171  Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
2172  Lex.Lex(); // eat field name
2173  break;
2174  }
2175 
2176  case tgtok::paste:
2177  SMLoc PasteLoc = Lex.getLoc();
2178  TypedInit *LHS = dyn_cast<TypedInit>(Result);
2179  if (!LHS) {
2180  Error(PasteLoc, "LHS of paste is not typed!");
2181  return nullptr;
2182  }
2183 
2184  // Check if it's a 'listA # listB'
2185  if (isa<ListRecTy>(LHS->getType())) {
2186  Lex.Lex(); // Eat the '#'.
2187 
2188  switch (Lex.getCode()) {
2189  case tgtok::colon:
2190  case tgtok::semi:
2191  case tgtok::l_brace:
2192  Result = LHS; // trailing paste, ignore.
2193  break;
2194  default:
2195  Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
2196  Result = BinOpInit::getListConcat(LHS, RHSResult);
2197  }
2198  break;
2199  }
2200 
2201  // Create a !strconcat() operation, first casting each operand to
2202  // a string if necessary.
2203  if (LHS->getType() != StringRecTy::get()) {
2204  auto CastLHS = dyn_cast<TypedInit>(
2206  ->Fold(CurRec));
2207  if (!CastLHS) {
2208  Error(PasteLoc,
2209  Twine("can't cast '") + LHS->getAsString() + "' to string");
2210  return nullptr;
2211  }
2212  LHS = CastLHS;
2213  }
2214 
2215  TypedInit *RHS = nullptr;
2216 
2217  Lex.Lex(); // Eat the '#'.
2218  switch (Lex.getCode()) {
2219  case tgtok::colon:
2220  case tgtok::semi:
2221  case tgtok::l_brace:
2222  // These are all of the tokens that can begin an object body.
2223  // Some of these can also begin values but we disallow those cases
2224  // because they are unlikely to be useful.
2225 
2226  // Trailing paste, concat with an empty string.
2227  RHS = StringInit::get("");
2228  break;
2229 
2230  default:
2231  Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
2232  RHS = dyn_cast<TypedInit>(RHSResult);
2233  if (!RHS) {
2234  Error(PasteLoc, "RHS of paste is not typed!");
2235  return nullptr;
2236  }
2237 
2238  if (RHS->getType() != StringRecTy::get()) {
2239  auto CastRHS = dyn_cast<TypedInit>(
2241  ->Fold(CurRec));
2242  if (!CastRHS) {
2243  Error(PasteLoc,
2244  Twine("can't cast '") + RHS->getAsString() + "' to string");
2245  return nullptr;
2246  }
2247  RHS = CastRHS;
2248  }
2249 
2250  break;
2251  }
2252 
2253  Result = BinOpInit::getStrConcat(LHS, RHS);
2254  break;
2255  }
2256  }
2257 }
2258 
2259 /// ParseDagArgList - Parse the argument list for a dag literal expression.
2260 ///
2261 /// DagArg ::= Value (':' VARNAME)?
2262 /// DagArg ::= VARNAME
2263 /// DagArgList ::= DagArg
2264 /// DagArgList ::= DagArgList ',' DagArg
2265 void TGParser::ParseDagArgList(
2266  SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
2267  Record *CurRec) {
2268 
2269  while (true) {
2270  // DagArg ::= VARNAME
2271  if (Lex.getCode() == tgtok::VarName) {
2272  // A missing value is treated like '?'.
2273  StringInit *VarName = StringInit::get(Lex.getCurStrVal());
2274  Result.emplace_back(UnsetInit::get(), VarName);
2275  Lex.Lex();
2276  } else {
2277  // DagArg ::= Value (':' VARNAME)?
2278  Init *Val = ParseValue(CurRec);
2279  if (!Val) {
2280  Result.clear();
2281  return;
2282  }
2283 
2284  // If the variable name is present, add it.
2285  StringInit *VarName = nullptr;
2286  if (Lex.getCode() == tgtok::colon) {
2287  if (Lex.Lex() != tgtok::VarName) { // eat the ':'
2288  TokError("expected variable name in dag literal");
2289  Result.clear();
2290  return;
2291  }
2292  VarName = StringInit::get(Lex.getCurStrVal());
2293  Lex.Lex(); // eat the VarName.
2294  }
2295 
2296  Result.push_back(std::make_pair(Val, VarName));
2297  }
2298  if (Lex.getCode() != tgtok::comma) break;
2299  Lex.Lex(); // eat the ','
2300  }
2301 }
2302 
2303 /// ParseValueList - Parse a comma separated list of values, returning them as a
2304 /// vector. Note that this always expects to be able to parse at least one
2305 /// value. It returns an empty list if this is not possible.
2306 ///
2307 /// ValueList ::= Value (',' Value)
2308 ///
2309 void TGParser::ParseValueList(SmallVectorImpl<Init*> &Result, Record *CurRec,
2310  Record *ArgsRec, RecTy *EltTy) {
2311  RecTy *ItemType = EltTy;
2312  unsigned int ArgN = 0;
2313  if (ArgsRec && !EltTy) {
2314  ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
2315  if (TArgs.empty()) {
2316  TokError("template argument provided to non-template class");
2317  Result.clear();
2318  return;
2319  }
2320  const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
2321  if (!RV) {
2322  errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN]
2323  << ")\n";
2324  }
2325  assert(RV && "Template argument record not found??");
2326  ItemType = RV->getType();
2327  ++ArgN;
2328  }
2329  Result.push_back(ParseValue(CurRec, ItemType));
2330  if (!Result.back()) {
2331  Result.clear();
2332  return;
2333  }
2334 
2335  while (Lex.getCode() == tgtok::comma) {
2336  Lex.Lex(); // Eat the comma
2337 
2338  // ignore trailing comma for lists
2339  if (Lex.getCode() == tgtok::r_square)
2340  return;
2341 
2342  if (ArgsRec && !EltTy) {
2343  ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
2344  if (ArgN >= TArgs.size()) {
2345  TokError("too many template arguments");
2346  Result.clear();
2347  return;
2348  }
2349  const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
2350  assert(RV && "Template argument record not found??");
2351  ItemType = RV->getType();
2352  ++ArgN;
2353  }
2354  Result.push_back(ParseValue(CurRec, ItemType));
2355  if (!Result.back()) {
2356  Result.clear();
2357  return;
2358  }
2359  }
2360 }
2361 
2362 /// ParseDeclaration - Read a declaration, returning the name of field ID, or an
2363 /// empty string on error. This can happen in a number of different context's,
2364 /// including within a def or in the template args for a def (which which case
2365 /// CurRec will be non-null) and within the template args for a multiclass (in
2366 /// which case CurRec will be null, but CurMultiClass will be set). This can
2367 /// also happen within a def that is within a multiclass, which will set both
2368 /// CurRec and CurMultiClass.
2369 ///
2370 /// Declaration ::= FIELD? Type ID ('=' Value)?
2371 ///
2372 Init *TGParser::ParseDeclaration(Record *CurRec,
2373  bool ParsingTemplateArgs) {
2374  // Read the field prefix if present.
2375  bool HasField = Lex.getCode() == tgtok::Field;
2376  if (HasField) Lex.Lex();
2377 
2378  RecTy *Type = ParseType();
2379  if (!Type) return nullptr;
2380 
2381  if (Lex.getCode() != tgtok::Id) {
2382  TokError("Expected identifier in declaration");
2383  return nullptr;
2384  }
2385 
2386  std::string Str = Lex.getCurStrVal();
2387  if (Str == "NAME") {
2388  TokError("'" + Str + "' is a reserved variable name");
2389  return nullptr;
2390  }
2391 
2392  SMLoc IdLoc = Lex.getLoc();
2393  Init *DeclName = StringInit::get(Str);
2394  Lex.Lex();
2395 
2396  if (ParsingTemplateArgs) {
2397  if (CurRec)
2398  DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":");
2399  else
2400  assert(CurMultiClass);
2401  if (CurMultiClass)
2402  DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName,
2403  "::");
2404  }
2405 
2406  // Add the value.
2407  if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
2408  return nullptr;
2409 
2410  // If a value is present, parse it.
2411  if (Lex.getCode() == tgtok::equal) {
2412  Lex.Lex();
2413  SMLoc ValLoc = Lex.getLoc();
2414  Init *Val = ParseValue(CurRec, Type);
2415  if (!Val ||
2416  SetValue(CurRec, ValLoc, DeclName, None, Val))
2417  // Return the name, even if an error is thrown. This is so that we can
2418  // continue to make some progress, even without the value having been
2419  // initialized.
2420  return DeclName;
2421  }
2422 
2423  return DeclName;
2424 }
2425 
2426 /// ParseForeachDeclaration - Read a foreach declaration, returning
2427 /// the name of the declared object or a NULL Init on error. Return
2428 /// the name of the parsed initializer list through ForeachListName.
2429 ///
2430 /// ForeachDeclaration ::= ID '=' '{' RangeList '}'
2431 /// ForeachDeclaration ::= ID '=' RangePiece
2432 /// ForeachDeclaration ::= ID '=' Value
2433 ///
2434 VarInit *TGParser::ParseForeachDeclaration(Init *&ForeachListValue) {
2435  if (Lex.getCode() != tgtok::Id) {
2436  TokError("Expected identifier in foreach declaration");
2437  return nullptr;
2438  }
2439 
2440  Init *DeclName = StringInit::get(Lex.getCurStrVal());
2441  Lex.Lex();
2442 
2443  // If a value is present, parse it.
2444  if (Lex.getCode() != tgtok::equal) {
2445  TokError("Expected '=' in foreach declaration");
2446  return nullptr;
2447  }
2448  Lex.Lex(); // Eat the '='
2449 
2450  RecTy *IterType = nullptr;
2452 
2453  switch (Lex.getCode()) {
2454  case tgtok::l_brace: { // '{' RangeList '}'
2455  Lex.Lex(); // eat the '{'
2456  ParseRangeList(Ranges);
2457  if (Lex.getCode() != tgtok::r_brace) {
2458  TokError("expected '}' at end of bit range list");
2459  return nullptr;
2460  }
2461  Lex.Lex();
2462  break;
2463  }
2464 
2465  default: {
2466  SMLoc ValueLoc = Lex.getLoc();
2467  Init *I = ParseValue(nullptr);
2468  if (!I)
2469  return nullptr;
2470 
2471  TypedInit *TI = dyn_cast<TypedInit>(I);
2472  if (TI && isa<ListRecTy>(TI->getType())) {
2473  ForeachListValue = I;
2474  IterType = cast<ListRecTy>(TI->getType())->getElementType();
2475  break;
2476  }
2477 
2478  if (TI) {
2479  if (ParseRangePiece(Ranges, TI))
2480  return nullptr;
2481  break;
2482  }
2483 
2484  std::string Type;
2485  if (TI)
2486  Type = (Twine("' of type '") + TI->getType()->getAsString()).str();
2487  Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
2488  if (CurMultiClass) {
2489  PrintNote({}, "references to multiclass template arguments cannot be "
2490  "resolved at this time");
2491  }
2492  return nullptr;
2493  }
2494  }
2495 
2496 
2497  if (!Ranges.empty()) {
2498  assert(!IterType && "Type already initialized?");
2499  IterType = IntRecTy::get();
2500  std::vector<Init*> Values;
2501  for (unsigned R : Ranges)
2502  Values.push_back(IntInit::get(R));
2503  ForeachListValue = ListInit::get(Values, IterType);
2504  }
2505 
2506  if (!IterType)
2507  return nullptr;
2508 
2509  return VarInit::get(DeclName, IterType);
2510 }
2511 
2512 /// ParseTemplateArgList - Read a template argument list, which is a non-empty
2513 /// sequence of template-declarations in <>'s. If CurRec is non-null, these are
2514 /// template args for a def, which may or may not be in a multiclass. If null,
2515 /// these are the template args for a multiclass.
2516 ///
2517 /// TemplateArgList ::= '<' Declaration (',' Declaration)* '>'
2518 ///
2519 bool TGParser::ParseTemplateArgList(Record *CurRec) {
2520  assert(Lex.getCode() == tgtok::less && "Not a template arg list!");
2521  Lex.Lex(); // eat the '<'
2522 
2523  Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
2524 
2525  // Read the first declaration.
2526  Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
2527  if (!TemplArg)
2528  return true;
2529 
2530  TheRecToAddTo->addTemplateArg(TemplArg);
2531 
2532  while (Lex.getCode() == tgtok::comma) {
2533  Lex.Lex(); // eat the ','
2534 
2535  // Read the following declarations.
2536  SMLoc Loc = Lex.getLoc();
2537  TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
2538  if (!TemplArg)
2539  return true;
2540 
2541  if (TheRecToAddTo->isTemplateArg(TemplArg))
2542  return Error(Loc, "template argument with the same name has already been "
2543  "defined");
2544 
2545  TheRecToAddTo->addTemplateArg(TemplArg);
2546  }
2547 
2548  if (Lex.getCode() != tgtok::greater)
2549  return TokError("expected '>' at end of template argument list");
2550  Lex.Lex(); // eat the '>'.
2551  return false;
2552 }
2553 
2554 /// ParseBodyItem - Parse a single item at within the body of a def or class.
2555 ///
2556 /// BodyItem ::= Declaration ';'
2557 /// BodyItem ::= LET ID OptionalBitList '=' Value ';'
2558 bool TGParser::ParseBodyItem(Record *CurRec) {
2559  if (Lex.getCode() != tgtok::Let) {
2560  if (!ParseDeclaration(CurRec, false))
2561  return true;
2562 
2563  if (Lex.getCode() != tgtok::semi)
2564  return TokError("expected ';' after declaration");
2565  Lex.Lex();
2566  return false;
2567  }
2568 
2569  // LET ID OptionalRangeList '=' Value ';'
2570  if (Lex.Lex() != tgtok::Id)
2571  return TokError("expected field identifier after let");
2572 
2573  SMLoc IdLoc = Lex.getLoc();
2574  StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
2575  Lex.Lex(); // eat the field name.
2576 
2577  SmallVector<unsigned, 16> BitList;
2578  if (ParseOptionalBitList(BitList))
2579  return true;
2580  std::reverse(BitList.begin(), BitList.end());
2581 
2582  if (Lex.getCode() != tgtok::equal)
2583  return TokError("expected '=' in let expression");
2584  Lex.Lex(); // eat the '='.
2585 
2586  RecordVal *Field = CurRec->getValue(FieldName);
2587  if (!Field)
2588  return TokError("Value '" + FieldName->getValue() + "' unknown!");
2589 
2590  RecTy *Type = Field->getType();
2591 
2592  Init *Val = ParseValue(CurRec, Type);
2593  if (!Val) return true;
2594 
2595  if (Lex.getCode() != tgtok::semi)
2596  return TokError("expected ';' after let expression");
2597  Lex.Lex();
2598 
2599  return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
2600 }
2601 
2602 /// ParseBody - Read the body of a class or def. Return true on error, false on
2603 /// success.
2604 ///
2605 /// Body ::= ';'
2606 /// Body ::= '{' BodyList '}'
2607 /// BodyList BodyItem*
2608 ///
2609 bool TGParser::ParseBody(Record *CurRec) {
2610  // If this is a null definition, just eat the semi and return.
2611  if (Lex.getCode() == tgtok::semi) {
2612  Lex.Lex();
2613  return false;
2614  }
2615 
2616  if (Lex.getCode() != tgtok::l_brace)
2617  return TokError("Expected ';' or '{' to start body");
2618  // Eat the '{'.
2619  Lex.Lex();
2620 
2621  while (Lex.getCode() != tgtok::r_brace)
2622  if (ParseBodyItem(CurRec))
2623  return true;
2624 
2625  // Eat the '}'.
2626  Lex.Lex();
2627  return false;
2628 }
2629 
2630 /// Apply the current let bindings to \a CurRec.
2631 /// \returns true on error, false otherwise.
2632 bool TGParser::ApplyLetStack(Record *CurRec) {
2633  for (SmallVectorImpl<LetRecord> &LetInfo : LetStack)
2634  for (LetRecord &LR : LetInfo)
2635  if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
2636  return true;
2637  return false;
2638 }
2639 
2640 bool TGParser::ApplyLetStack(RecordsEntry &Entry) {
2641  if (Entry.Rec)
2642  return ApplyLetStack(Entry.Rec.get());
2643 
2644  for (auto &E : Entry.Loop->Entries) {
2645  if (ApplyLetStack(E))
2646  return true;
2647  }
2648 
2649  return false;
2650 }
2651 
2652 /// ParseObjectBody - Parse the body of a def or class. This consists of an
2653 /// optional ClassList followed by a Body. CurRec is the current def or class
2654 /// that is being parsed.
2655 ///
2656 /// ObjectBody ::= BaseClassList Body
2657 /// BaseClassList ::= /*empty*/
2658 /// BaseClassList ::= ':' BaseClassListNE
2659 /// BaseClassListNE ::= SubClassRef (',' SubClassRef)*
2660 ///
2661 bool TGParser::ParseObjectBody(Record *CurRec) {
2662  // If there is a baseclass list, read it.
2663  if (Lex.getCode() == tgtok::colon) {
2664  Lex.Lex();
2665 
2666  // Read all of the subclasses.
2667  SubClassReference SubClass = ParseSubClassReference(CurRec, false);
2668  while (true) {
2669  // Check for error.
2670  if (!SubClass.Rec) return true;
2671 
2672  // Add it.
2673  if (AddSubClass(CurRec, SubClass))
2674  return true;
2675 
2676  if (Lex.getCode() != tgtok::comma) break;
2677  Lex.Lex(); // eat ','.
2678  SubClass = ParseSubClassReference(CurRec, false);
2679  }
2680  }
2681 
2682  if (ApplyLetStack(CurRec))
2683  return true;
2684 
2685  return ParseBody(CurRec);
2686 }
2687 
2688 /// ParseDef - Parse and return a top level or multiclass def, return the record
2689 /// corresponding to it. This returns null on error.
2690 ///
2691 /// DefInst ::= DEF ObjectName ObjectBody
2692 ///
2693 bool TGParser::ParseDef(MultiClass *CurMultiClass) {
2694  SMLoc DefLoc = Lex.getLoc();
2695  assert(Lex.getCode() == tgtok::Def && "Unknown tok");
2696  Lex.Lex(); // Eat the 'def' token.
2697 
2698  // Parse ObjectName and make a record for it.
2699  std::unique_ptr<Record> CurRec;
2700  Init *Name = ParseObjectName(CurMultiClass);
2701  if (!Name)
2702  return true;
2703 
2704  if (isa<UnsetInit>(Name))
2705  CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
2706  /*Anonymous=*/true);
2707  else
2708  CurRec = std::make_unique<Record>(Name, DefLoc, Records);
2709 
2710  if (ParseObjectBody(CurRec.get()))
2711  return true;
2712 
2713  return addEntry(std::move(CurRec));
2714 }
2715 
2716 /// ParseDefset - Parse a defset statement.
2717 ///
2718 /// Defset ::= DEFSET Type Id '=' '{' ObjectList '}'
2719 ///
2720 bool TGParser::ParseDefset() {
2721  assert(Lex.getCode() == tgtok::Defset);
2722  Lex.Lex(); // Eat the 'defset' token
2723 
2725  Defset.Loc = Lex.getLoc();
2726  RecTy *Type = ParseType();
2727  if (!Type)
2728  return true;
2729  if (!isa<ListRecTy>(Type))
2730  return Error(Defset.Loc, "expected list type");
2731  Defset.EltTy = cast<ListRecTy>(Type)->getElementType();
2732 
2733  if (Lex.getCode() != tgtok::Id)
2734  return TokError("expected identifier");
2735  StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
2736  if (Records.getGlobal(DeclName->getValue()))
2737  return TokError("def or global variable of this name already exists");
2738 
2739  if (Lex.Lex() != tgtok::equal) // Eat the identifier
2740  return TokError("expected '='");
2741  if (Lex.Lex() != tgtok::l_brace) // Eat the '='
2742  return TokError("expected '{'");
2743  SMLoc BraceLoc = Lex.getLoc();
2744  Lex.Lex(); // Eat the '{'
2745 
2746  Defsets.push_back(&Defset);
2747  bool Err = ParseObjectList(nullptr);
2748  Defsets.pop_back();
2749  if (Err)
2750  return true;
2751 
2752  if (Lex.getCode() != tgtok::r_brace) {
2753  TokError("expected '}' at end of defset");
2754  return Error(BraceLoc, "to match this '{'");
2755  }
2756  Lex.Lex(); // Eat the '}'
2757 
2758  Records.addExtraGlobal(DeclName->getValue(),
2759  ListInit::get(Defset.Elements, Defset.EltTy));
2760  return false;
2761 }
2762 
2763 /// ParseForeach - Parse a for statement. Return the record corresponding
2764 /// to it. This returns true on error.
2765 ///
2766 /// Foreach ::= FOREACH Declaration IN '{ ObjectList '}'
2767 /// Foreach ::= FOREACH Declaration IN Object
2768 ///
2769 bool TGParser::ParseForeach(MultiClass *CurMultiClass) {
2770  SMLoc Loc = Lex.getLoc();
2771  assert(Lex.getCode() == tgtok::Foreach && "Unknown tok");
2772  Lex.Lex(); // Eat the 'for' token.
2773 
2774  // Make a temporary object to record items associated with the for
2775  // loop.
2776  Init *ListValue = nullptr;
2777  VarInit *IterName = ParseForeachDeclaration(ListValue);
2778  if (!IterName)
2779  return TokError("expected declaration in for");
2780 
2781  if (Lex.getCode() != tgtok::In)
2782  return TokError("Unknown tok");
2783  Lex.Lex(); // Eat the in
2784 
2785  // Create a loop object and remember it.
2786  Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue));
2787 
2788  if (Lex.getCode() != tgtok::l_brace) {
2789  // FOREACH Declaration IN Object
2790  if (ParseObject(CurMultiClass))
2791  return true;
2792  } else {
2793  SMLoc BraceLoc = Lex.getLoc();
2794  // Otherwise, this is a group foreach.
2795  Lex.Lex(); // eat the '{'.
2796 
2797  // Parse the object list.
2798  if (ParseObjectList(CurMultiClass))
2799  return true;
2800 
2801  if (Lex.getCode() != tgtok::r_brace) {
2802  TokError("expected '}' at end of foreach command");
2803  return Error(BraceLoc, "to match this '{'");
2804  }
2805  Lex.Lex(); // Eat the }
2806  }
2807 
2808  // Resolve the loop or store it for later resolution.
2809  std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
2810  Loops.pop_back();
2811 
2812  return addEntry(std::move(Loop));
2813 }
2814 
2815 /// ParseClass - Parse a tblgen class definition.
2816 ///
2817 /// ClassInst ::= CLASS ID TemplateArgList? ObjectBody
2818 ///
2819 bool TGParser::ParseClass() {
2820  assert(Lex.getCode() == tgtok::Class && "Unexpected token!");
2821  Lex.Lex();
2822 
2823  if (Lex.getCode() != tgtok::Id)
2824  return TokError("expected class name after 'class' keyword");
2825 
2826  Record *CurRec = Records.getClass(Lex.getCurStrVal());
2827  if (CurRec) {
2828  // If the body was previously defined, this is an error.
2829  if (!CurRec->getValues().empty() ||
2830  !CurRec->getSuperClasses().empty() ||
2831  !CurRec->getTemplateArgs().empty())
2832  return TokError("Class '" + CurRec->getNameInitAsString() +
2833  "' already defined");
2834  } else {
2835  // If this is the first reference to this class, create and add it.
2836  auto NewRec =
2837  std::make_unique<Record>(Lex.getCurStrVal(), Lex.getLoc(), Records,
2838  /*Class=*/true);
2839  CurRec = NewRec.get();
2840  Records.addClass(std::move(NewRec));
2841  }
2842  Lex.Lex(); // eat the name.
2843 
2844  // If there are template args, parse them.
2845  if (Lex.getCode() == tgtok::less)
2846  if (ParseTemplateArgList(CurRec))
2847  return true;
2848 
2849  return ParseObjectBody(CurRec);
2850 }
2851 
2852 /// ParseLetList - Parse a non-empty list of assignment expressions into a list
2853 /// of LetRecords.
2854 ///
2855 /// LetList ::= LetItem (',' LetItem)*
2856 /// LetItem ::= ID OptionalRangeList '=' Value
2857 ///
2858 void TGParser::ParseLetList(SmallVectorImpl<LetRecord> &Result) {
2859  while (true) {
2860  if (Lex.getCode() != tgtok::Id) {
2861  TokError("expected identifier in let definition");
2862  Result.clear();
2863  return;
2864  }
2865 
2866  StringInit *Name = StringInit::get(Lex.getCurStrVal());
2867  SMLoc NameLoc = Lex.getLoc();
2868  Lex.Lex(); // Eat the identifier.
2869 
2870  // Check for an optional RangeList.
2872  if (ParseOptionalRangeList(Bits)) {
2873  Result.clear();
2874  return;
2875  }
2876  std::reverse(Bits.begin(), Bits.end());
2877 
2878  if (Lex.getCode() != tgtok::equal) {
2879  TokError("expected '=' in let expression");
2880  Result.clear();
2881  return;
2882  }
2883  Lex.Lex(); // eat the '='.
2884 
2885  Init *Val = ParseValue(nullptr);
2886  if (!Val) {
2887  Result.clear();
2888  return;
2889  }
2890 
2891  // Now that we have everything, add the record.
2892  Result.emplace_back(Name, Bits, Val, NameLoc);
2893 
2894  if (Lex.getCode() != tgtok::comma)
2895  return;
2896  Lex.Lex(); // eat the comma.
2897  }
2898 }
2899 
2900 /// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of
2901 /// different related productions. This works inside multiclasses too.
2902 ///
2903 /// Object ::= LET LetList IN '{' ObjectList '}'
2904 /// Object ::= LET LetList IN Object
2905 ///
2906 bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) {
2907  assert(Lex.getCode() == tgtok::Let && "Unexpected token");
2908  Lex.Lex();
2909 
2910  // Add this entry to the let stack.
2911  SmallVector<LetRecord, 8> LetInfo;
2912  ParseLetList(LetInfo);
2913  if (LetInfo.empty()) return true;
2914  LetStack.push_back(std::move(LetInfo));
2915 
2916  if (Lex.getCode() != tgtok::In)
2917  return TokError("expected 'in' at end of top-level 'let'");
2918  Lex.Lex();
2919 
2920  // If this is a scalar let, just handle it now
2921  if (Lex.getCode() != tgtok::l_brace) {
2922  // LET LetList IN Object
2923  if (ParseObject(CurMultiClass))
2924  return true;
2925  } else { // Object ::= LETCommand '{' ObjectList '}'
2926  SMLoc BraceLoc = Lex.getLoc();
2927  // Otherwise, this is a group let.
2928  Lex.Lex(); // eat the '{'.
2929 
2930  // Parse the object list.
2931  if (ParseObjectList(CurMultiClass))
2932  return true;
2933 
2934  if (Lex.getCode() != tgtok::r_brace) {
2935  TokError("expected '}' at end of top level let command");
2936  return Error(BraceLoc, "to match this '{'");
2937  }
2938  Lex.Lex();
2939  }
2940 
2941  // Outside this let scope, this let block is not active.
2942  LetStack.pop_back();
2943  return false;
2944 }
2945 
2946 /// ParseMultiClass - Parse a multiclass definition.
2947 ///
2948 /// MultiClassInst ::= MULTICLASS ID TemplateArgList?
2949 /// ':' BaseMultiClassList '{' MultiClassObject+ '}'
2950 /// MultiClassObject ::= DefInst
2951 /// MultiClassObject ::= MultiClassInst
2952 /// MultiClassObject ::= DefMInst
2953 /// MultiClassObject ::= LETCommand '{' ObjectList '}'
2954 /// MultiClassObject ::= LETCommand Object
2955 ///
2956 bool TGParser::ParseMultiClass() {
2957  assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token");
2958  Lex.Lex(); // Eat the multiclass token.
2959 
2960  if (Lex.getCode() != tgtok::Id)
2961  return TokError("expected identifier after multiclass for name");
2962  std::string Name = Lex.getCurStrVal();
2963 
2964  auto Result =
2965  MultiClasses.insert(std::make_pair(Name,
2966  std::make_unique<MultiClass>(Name, Lex.getLoc(),Records)));
2967 
2968  if (!Result.second)
2969  return TokError("multiclass '" + Name + "' already defined");
2970 
2971  CurMultiClass = Result.first->second.get();
2972  Lex.Lex(); // Eat the identifier.
2973 
2974  // If there are template args, parse them.
2975  if (Lex.getCode() == tgtok::less)
2976  if (ParseTemplateArgList(nullptr))
2977  return true;
2978 
2979  bool inherits = false;
2980 
2981  // If there are submulticlasses, parse them.
2982  if (Lex.getCode() == tgtok::colon) {
2983  inherits = true;
2984 
2985  Lex.Lex();
2986 
2987  // Read all of the submulticlasses.
2988  SubMultiClassReference SubMultiClass =
2989  ParseSubMultiClassReference(CurMultiClass);
2990  while (true) {
2991  // Check for error.
2992  if (!SubMultiClass.MC) return true;
2993 
2994  // Add it.
2995  if (AddSubMultiClass(CurMultiClass, SubMultiClass))
2996  return true;
2997 
2998  if (Lex.getCode() != tgtok::comma) break;
2999  Lex.Lex(); // eat ','.
3000  SubMultiClass = ParseSubMultiClassReference(CurMultiClass);
3001  }
3002  }
3003 
3004  if (Lex.getCode() != tgtok::l_brace) {
3005  if (!inherits)
3006  return TokError("expected '{' in multiclass definition");
3007  if (Lex.getCode() != tgtok::semi)
3008  return TokError("expected ';' in multiclass definition");
3009  Lex.Lex(); // eat the ';'.
3010  } else {
3011  if (Lex.Lex() == tgtok::r_brace) // eat the '{'.
3012  return TokError("multiclass must contain at least one def");
3013 
3014  while (Lex.getCode() != tgtok::r_brace) {
3015  switch (Lex.getCode()) {
3016  default:
3017  return TokError("expected 'let', 'def', 'defm' or 'foreach' in "
3018  "multiclass body");
3019  case tgtok::Let:
3020  case tgtok::Def:
3021  case tgtok::Defm:
3022  case tgtok::Foreach:
3023  if (ParseObject(CurMultiClass))
3024  return true;
3025  break;
3026  }
3027  }
3028  Lex.Lex(); // eat the '}'.
3029  }
3030 
3031  CurMultiClass = nullptr;
3032  return false;
3033 }
3034 
3035 /// ParseDefm - Parse the instantiation of a multiclass.
3036 ///
3037 /// DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
3038 ///
3039 bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
3040  assert(Lex.getCode() == tgtok::Defm && "Unexpected token!");
3041  Lex.Lex(); // eat the defm
3042 
3043  Init *DefmName = ParseObjectName(CurMultiClass);
3044  if (!DefmName)
3045  return true;
3046  if (isa<UnsetInit>(DefmName)) {
3047  DefmName = Records.getNewAnonymousName();
3048  if (CurMultiClass)
3049  DefmName = BinOpInit::getStrConcat(
3051  StringRecTy::get()),
3052  DefmName);
3053  }
3054 
3055  if (Lex.getCode() != tgtok::colon)
3056  return TokError("expected ':' after defm identifier");
3057 
3058  // Keep track of the new generated record definitions.
3059  std::vector<RecordsEntry> NewEntries;
3060 
3061  // This record also inherits from a regular class (non-multiclass)?
3062  bool InheritFromClass = false;
3063 
3064  // eat the colon.
3065  Lex.Lex();
3066 
3067  SMLoc SubClassLoc = Lex.getLoc();
3068  SubClassReference Ref = ParseSubClassReference(nullptr, true);
3069 
3070  while (true) {
3071  if (!Ref.Rec) return true;
3072 
3073  // To instantiate a multiclass, we need to first get the multiclass, then
3074  // instantiate each def contained in the multiclass with the SubClassRef
3075  // template parameters.
3076  MultiClass *MC = MultiClasses[Ref.Rec->getName()].get();
3077  assert(MC && "Didn't lookup multiclass correctly?");
3078  ArrayRef<Init*> TemplateVals = Ref.TemplateArgs;
3079 
3080  // Verify that the correct number of template arguments were specified.
3081  ArrayRef<Init *> TArgs = MC->Rec.getTemplateArgs();
3082  if (TArgs.size() < TemplateVals.size())
3083  return Error(SubClassLoc,
3084  "more template args specified than multiclass expects");
3085 
3086  SubstStack Substs;
3087  for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
3088  if (i < TemplateVals.size()) {
3089  Substs.emplace_back(TArgs[i], TemplateVals[i]);
3090  } else {
3091  Init *Default = MC->Rec.getValue(TArgs[i])->getValue();
3092  if (!Default->isComplete()) {
3093  return Error(SubClassLoc,
3094  "value not specified for template argument #" +
3095  Twine(i) + " (" + TArgs[i]->getAsUnquotedString() +
3096  ") of multiclass '" + MC->Rec.getNameInitAsString() +
3097  "'");
3098  }
3099  Substs.emplace_back(TArgs[i], Default);
3100  }
3101  }
3102 
3103  Substs.emplace_back(QualifiedNameOfImplicitName(MC), DefmName);
3104 
3105  if (resolve(MC->Entries, Substs, CurMultiClass == nullptr, &NewEntries,
3106  &SubClassLoc))
3107  return true;
3108 
3109  if (Lex.getCode() != tgtok::comma) break;
3110  Lex.Lex(); // eat ','.
3111 
3112  if (Lex.getCode() != tgtok::Id)
3113  return TokError("expected identifier");
3114 
3115  SubClassLoc = Lex.getLoc();
3116 
3117  // A defm can inherit from regular classes (non-multiclass) as
3118  // long as they come in the end of the inheritance list.
3119  InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != nullptr);
3120 
3121  if (InheritFromClass)
3122  break;
3123 
3124  Ref = ParseSubClassReference(nullptr, true);
3125  }
3126 
3127  if (InheritFromClass) {
3128  // Process all the classes to inherit as if they were part of a
3129  // regular 'def' and inherit all record values.
3130  SubClassReference SubClass = ParseSubClassReference(nullptr, false);
3131  while (true) {
3132  // Check for error.
3133  if (!SubClass.Rec) return true;
3134 
3135  // Get the expanded definition prototypes and teach them about
3136  // the record values the current class to inherit has
3137  for (auto &E : NewEntries) {
3138  // Add it.
3139  if (AddSubClass(E, SubClass))
3140  return true;
3141  }
3142 
3143  if (Lex.getCode() != tgtok::comma) break;
3144  Lex.Lex(); // eat ','.
3145  SubClass = ParseSubClassReference(nullptr, false);
3146  }
3147  }
3148 
3149  for (auto &E : NewEntries) {
3150  if (ApplyLetStack(E))
3151  return true;
3152 
3153  addEntry(std::move(E));
3154  }
3155 
3156  if (Lex.getCode() != tgtok::semi)
3157  return TokError("expected ';' at end of defm");
3158  Lex.Lex();
3159 
3160  return false;
3161 }
3162 
3163 /// ParseObject
3164 /// Object ::= ClassInst
3165 /// Object ::= DefInst
3166 /// Object ::= MultiClassInst
3167 /// Object ::= DefMInst
3168 /// Object ::= LETCommand '{' ObjectList '}'
3169 /// Object ::= LETCommand Object
3170 bool TGParser::ParseObject(MultiClass *MC) {
3171  switch (Lex.getCode()) {
3172  default:
3173  return TokError("Expected class, def, defm, defset, multiclass, let or "
3174  "foreach");
3175  case tgtok::Let: return ParseTopLevelLet(MC);
3176  case tgtok::Def: return ParseDef(MC);
3177  case tgtok::Foreach: return ParseForeach(MC);
3178  case tgtok::Defm: return ParseDefm(MC);
3179  case tgtok::Defset:
3180  if (MC)
3181  return TokError("defset is not allowed inside multiclass");
3182  return ParseDefset();
3183  case tgtok::Class:
3184  if (MC)
3185  return TokError("class is not allowed inside multiclass");
3186  if (!Loops.empty())
3187  return TokError("class is not allowed inside foreach loop");
3188  return ParseClass();
3189  case tgtok::MultiClass:
3190  if (!Loops.empty())
3191  return TokError("multiclass is not allowed inside foreach loop");
3192  return ParseMultiClass();
3193  }
3194 }
3195 
3196 /// ParseObjectList
3197 /// ObjectList :== Object*
3198 bool TGParser::ParseObjectList(MultiClass *MC) {
3199  while (isObjectStart(Lex.getCode())) {
3200  if (ParseObject(MC))
3201  return true;
3202  }
3203  return false;
3204 }
3205 
3206 bool TGParser::ParseFile() {
3207  Lex.Lex(); // Prime the lexer.
3208  if (ParseObjectList()) return true;
3209 
3210  // If we have unread input at the end of the file, report it.
3211  if (Lex.getCode() == tgtok::Eof)
3212  return false;
3213 
3214  return TokError("Unexpected input at top level");
3215 }
3216 
3217 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
3218 LLVM_DUMP_METHOD void RecordsEntry::dump() const {
3219  if (Loop)
3220  Loop->dump();
3221  if (Rec)
3222  Rec->dump();
3223 }
3224 
3225 LLVM_DUMP_METHOD void ForeachLoop::dump() const {
3226  errs() << "foreach " << IterVar->getAsString() << " = "
3227  << ListValue->getAsString() << " in {\n";
3228 
3229  for (const auto &E : Entries)
3230  E.dump();
3231 
3232  errs() << "}\n";
3233 }
3234 
3235 LLVM_DUMP_METHOD void MultiClass::dump() const {
3236  errs() << "Record:\n";
3237  Rec.dump();
3238 
3239  errs() << "Defs:\n";
3240  for (const auto &E : Entries)
3241  E.dump();
3242 }
3243 #endif
static BinOpInit * get(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:825
unsigned getNumBits() const
Definition: Record.h:535
Represents a range in source code.
Definition: SMLoc.h:48
StringRef getName() const
Definition: Record.cpp:1992
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:641
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Init * getValue() const
Definition: Record.h:1414
SI Whole Quad Mode
This class represents lattice values for constants.
Definition: AllocatorList.h:23
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:484
virtual std::string getAsUnquotedString() const
Convert this value to a string form, without adding quote markers.
Definition: Record.h:367
VarInit * IterVar
Definition: TGParser.h:61
static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF)
Definition: Execution.cpp:41
bool empty() const
Definition: Record.h:718
std::unique_ptr< ForeachLoop > Loop
Definition: TGParser.h:47
[AL, AH, CL] - Represent a list of defs
Definition: Record.h:661
&#39;7&#39; - Represent an initialization by a literal integer value.
Definition: Record.h:564
virtual RecTy * getFieldType(StringInit *FieldName) const
This method is used to implement the FieldInit class.
Definition: Record.h:402
&#39;list<Ty>&#39; - Represent a list of values, all of which must be of the specified type.
Definition: Record.h:195
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
!op (X, Y) - Combine two inits.
Definition: Record.h:801
void push_back(const T &Elt)
Definition: SmallVector.h:211
AL - Represent a reference to a &#39;def&#39; in the description.
Definition: Record.h:1174
static Init * getListConcat(TypedInit *lhs, Init *rhs)
Definition: Record.cpp:868
static UnOpInit * get(UnaryOp opc, Init *lhs, RecTy *Type)
Definition: Record.cpp:693
std::unique_ptr< Record > Rec
Definition: TGParser.h:46
Init * Fold(Record *CurRec, bool IsFinal=false) const
Definition: Record.cpp:712
static Init * getStrConcat(Init *lhs, Init *rhs)
Definition: Record.cpp:852
static VarInit * get(StringRef VN, RecTy *T)
Definition: Record.cpp:1466
static CodeRecTy * get()
Definition: Record.h:150
virtual Init * getCastTo(RecTy *Ty) const =0
If this initializer is convertible to Ty, return an initializer whose type is-a Ty, generating a !cast operation if required.
&#39;{ a, b, c }&#39; - Represents an initializer for a BitsRecTy value.
Definition: Record.h:513
std::string getNameInitAsString() const
Definition: Record.h:1408
Init * Fold() const
Definition: Record.cpp:1683
static BitRecTy * get()
Definition: Record.h:110
bool isInvalid() const
Definition: TGParser.cpp:43
C::iterator addEntry(C &Container, StringRef InstallName)
static IntInit * get(int64_t V)
Definition: Record.cpp:460
static BitsInit * get(ArrayRef< Init *> Range)
Definition: Record.cpp:342
SMLoc Start
Definition: SMLoc.h:50
ArrayRef< std::pair< Record *, SMRange > > getSuperClasses() const
Definition: Record.h:1509
void addSuperClass(Record *R, SMRange Range)
Definition: Record.h:1582
Hexagon Hardware Loops
static BitsRecTy * get(unsigned Sz)
Definition: Record.cpp:84
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
This is the common super-class of types that have a specific, explicit, type.
Definition: Record.h:425
RecTy * getElementType() const
Definition: Record.h:208
static StringRecTy * get()
Definition: Record.h:186
ArrayRef< Init * > getTemplateArgs() const
Definition: Record.h:1503
virtual bool isComplete() const
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:352
The access may reference the value stored in memory.
void PrintNote(const Twine &Msg)
Definition: Error.cpp:42
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:261
virtual Init * convertInitializerBitRange(ArrayRef< unsigned > Bits) const
This method is used to implement the bitrange selection operator.
Definition: Record.h:387
ArrayRef< SMLoc > getLoc() const
Definition: Record.h:1492
&#39;bits<n>&#39; - Represent a fixed number of bits
Definition: Record.h:118
bool isTemplateArg(Init *Name) const
Definition: Record.h:1516
RecTy * getType() const
Definition: Record.h:1413
bool isSubClassOf(const Record *R) const
Definition: Record.h:1563
static CodeInit * get(StringRef, const SMLoc &Loc)
Definition: Record.cpp:517
virtual Init * convertInitListSlice(ArrayRef< unsigned > Elements) const
This method is used to implement the list slice selection operator.
Definition: Record.h:395
ArrayRef< RecordVal > getValues() const
Definition: Record.h:1507
std::vector< RecordsEntry > Entries
Definition: TGParser.h:79
static Init * QualifyName(Record &CurRec, MultiClass *CurMultiClass, Init *Name, StringRef Scoper)
Return an Init with a qualifier prefix referring to CurRec&#39;s name.
Definition: TGParser.cpp:114
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
RecTy * getType() const
Definition: Record.h:441
Init * getElement(unsigned i) const
Definition: Record.h:686
Resolve arbitrary mappings.
Definition: Record.h:1892
void dump() const
Definition: Record.cpp:2122
Init * getNameInit() const
Definition: Record.h:1406
bool isClass() const
Definition: Record.h:1501
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
virtual bool isConcrete() const
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:356
void resolveReferences()
If there are any field references that refer to fields that have been filled in, we can propagate the...
Definition: Record.cpp:2110
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void set(Init *Key, Init *Value)
Definition: Record.h:1906
"foo" - Represent an initialization by a string value.
Definition: Record.h:594
RecordsEntry - Can be either a record or a foreach loop.
Definition: TGParser.h:45
const std::string getNameInitAsString() const
Definition: Record.h:1486
static DagInit * get(Init *V, StringInit *VN, ArrayRef< Init *> ArgRange, ArrayRef< StringInit *> NameRange)
Definition: Record.cpp:1894
constexpr double e
Definition: MathExtras.h:57
int64_t getValue() const
Definition: Record.h:580
&#39;string&#39; - Represent an string value
Definition: Record.h:176
static BitInit * get(bool V)
Definition: Record.cpp:311
Init * ListValue
Definition: TGParser.h:62
bool setValue(Init *V)
Definition: Record.cpp:1996
size_t size() const
Definition: SmallVector.h:52
static wasm::ValType getType(const TargetRegisterClass *RC)
static bool isObjectStart(tgtok::TokKind K)
isObjectStart - Return true if this is a valid first token for an Object.
Definition: TGParser.cpp:482
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static bool checkBitsConcrete(Record &R, const RecordVal &RV)
Definition: TGParser.cpp:71
static RecordRecTy * get(ArrayRef< Record *> Classes)
Get the record type with the given non-redundant list of superclasses.
Definition: Record.cpp:157
ForeachLoop - Record the iteration state associated with a for loop.
Definition: TGParser.h:59
static FieldInit * get(Init *R, StringInit *FN)
Definition: Record.cpp:1707
virtual Init * resolveReferences(Resolver &R) const
This method is used by classes that refer to other variables which may not be defined at the time the...
Definition: Record.h:410
void addTemplateArg(Init *Name)
Definition: Record.h:1540
virtual bool typeIsA(const RecTy *RHS) const
Return true if &#39;this&#39; type is equal to or a subtype of RHS.
Definition: Record.cpp:74
static Init * QualifiedNameOfImplicitName(Record &Rec, MultiClass *MC=nullptr)
Return the qualified version of the implicit &#39;NAME&#39; template argument.
Definition: TGParser.cpp:131
const RecordVal * getValue(const Init *Name) const
Definition: Record.h:1522
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
This is a utility class that provides an abstraction for the common functionality between Instruction...
Definition: Operator.h:30
static StringInit * get(StringRef)
Definition: Record.cpp:533
void dump() const
SmallVector< Init *, 4 > TemplateArgs
Definition: TGParser.cpp:39
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:374
CHAIN = SC CHAIN, Imm128 - System call.
SmallVector< Init *, 4 > TemplateArgs
Definition: TGParser.cpp:49
static VarDefInit * get(Record *Class, ArrayRef< Init *> Args)
Definition: Record.cpp:1593
static IsAOpInit * get(RecTy *CheckType, Init *Expr)
Definition: Record.cpp:1338
SMLoc End
Definition: SMLoc.h:50
void dump() const
RecordRecTy * getType()
Definition: Record.cpp:2042
void removeValue(Init *Name)
Definition: Record.h:1550
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:467
static FoldOpInit * get(Init *Start, Init *List, Init *A, Init *B, Init *Expr, RecTy *Type)
Definition: Record.cpp:1272
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:557
void appendLoc(SMLoc Loc)
Definition: Record.h:1493
bool typeIsConvertibleTo(const RecTy *RHS) const override
Return true if all values of &#39;this&#39; type can be converted to the specified type.
Definition: Record.cpp:134
Init * getNameInit() const
Definition: Record.h:1482
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
static UnsetInit * get()
Definition: Record.cpp:298
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:509
SmallVector< Init *, 16 > Elements
Definition: TGParser.h:74
Do not resolve anything, but keep track of whether a given variable was referenced.
Definition: Record.h:1980
static DagRecTy * get()
Definition: Record.h:228
void addValue(const RecordVal &RV)
Definition: Record.h:1545
const NodeList & List
Definition: RDFGraph.cpp:201
static TernOpInit * get(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:1054
#define I(x, y, z)
Definition: MD5.cpp:58
RecTy * resolveTypes(RecTy *T1, RecTy *T2)
Find a common type that T1 and T2 convert to.
Definition: Record.cpp:262
&#39;Opcode&#39; - Represent a reference to an entire variable object.
Definition: Record.h:1068
bool ParseFile()
ParseFile - Main entrypoint for parsing a tblgen file.
LLVM_NODISCARD 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:332
static ListRecTy * get(RecTy *T)
Definition: Record.h:207
Init * Fold(Record *CurRec) const
Definition: Record.cpp:1818
static ListInit * get(ArrayRef< Init *> Range, RecTy *EltTy)
Definition: Record.cpp:570
virtual bool typeIsConvertibleTo(const RecTy *RHS) const
Return true if all values of &#39;this&#39; type can be converted to the specified type.
Definition: Record.cpp:69
StringRef getValue() const
Definition: Record.h:610
&#39;dag&#39; - Represent a dag fragment
Definition: Record.h:218
StringRef getName() const
Definition: Record.h:1480
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
virtual std::string getAsString() const =0
Convert this value to a string form.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
std::vector< RecordsEntry > Entries
Definition: TGParser.h:63
static CondOpInit * get(ArrayRef< Init *> C, ArrayRef< Init *> V, RecTy *Type)
Definition: Record.cpp:1770
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
void dump() const
virtual std::string getAsString() const =0
Represents a location in source code.
Definition: SMLoc.h:23
ListRecTy * getListTy()
Returns the type representing list<this>.
Definition: Record.cpp:63
Init * getNameInit() const
Definition: Record.h:1086
static void checkConcrete(Record &R)
Definition: TGParser.cpp:90
Init * Fold(Record *CurRec) const
Definition: Record.cpp:1731
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:143
static IntRecTy * get()
Definition: Record.h:168
void PrintError(ArrayRef< SMLoc > ErrorLoc, const Twine &Msg)
Definition: Error.cpp:58