1 //===- TGParser.cpp - Parser for TableGen Files ---------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Implement the Parser for TableGen.
12 //===----------------------------------------------------------------------===//
15 #include "llvm/TableGen/Record.h"
16 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/Support/CommandLine.h"
23 //===----------------------------------------------------------------------===//
24 // Support Code for the Semantic Actions.
25 //===----------------------------------------------------------------------===//
28 struct SubClassReference {
31 std::vector<Init*> TemplateArgs;
32 SubClassReference() : Rec(0) {}
34 bool isInvalid() const { return Rec == 0; }
37 struct SubMultiClassReference {
40 std::vector<Init*> TemplateArgs;
41 SubMultiClassReference() : MC(0) {}
43 bool isInvalid() const { return MC == 0; }
47 void SubMultiClassReference::dump() const {
48 errs() << "Multiclass:\n";
52 errs() << "Template args:\n";
53 for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(),
54 iend = TemplateArgs.end();
61 } // end namespace llvm
63 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
65 CurRec = &CurMultiClass->Rec;
67 if (RecordVal *ERV = CurRec->getValue(RV.getName())) {
68 // The value already exists in the class, treat this as a set.
69 if (ERV->setValue(RV.getValue()))
70 return Error(Loc, "New definition of '" + RV.getName() + "' of type '" +
71 RV.getType()->getAsString() + "' is incompatible with " +
72 "previous definition of type '" +
73 ERV->getType()->getAsString() + "'");
81 /// Return true on error, false on success.
82 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
83 const std::vector<unsigned> &BitList, Init *V) {
86 if (CurRec == 0) CurRec = &CurMultiClass->Rec;
88 RecordVal *RV = CurRec->getValue(ValName);
90 return Error(Loc, "Value '" + ValName->getAsUnquotedString()
93 // Do not allow assignments like 'X = X'. This will just cause infinite loops
94 // in the resolution machinery.
96 if (VarInit *VI = dynamic_cast<VarInit*>(V))
97 if (VI->getNameInit() == ValName)
100 // If we are assigning to a subset of the bits in the value... then we must be
101 // assigning to a field of BitsRecTy, which must have a BitsInit
104 if (!BitList.empty()) {
105 BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
107 return Error(Loc, "Value '" + ValName->getAsUnquotedString()
108 + "' is not a bits type");
110 // Convert the incoming value to a bits type of the appropriate size...
111 Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
113 V->convertInitializerTo(BitsRecTy::get(BitList.size()));
114 return Error(Loc, "Initializer is not compatible with bit range");
117 // We should have a BitsInit type now.
118 BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
121 SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
123 // Loop over bits, assigning values as appropriate.
124 for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
125 unsigned Bit = BitList[i];
127 return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
128 ValName->getAsUnquotedString() + "' more than once");
129 NewBits[Bit] = BInit->getBit(i);
132 for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
134 NewBits[i] = CurVal->getBit(i);
136 V = BitsInit::get(NewBits);
140 return Error(Loc, "Value '" + ValName->getAsUnquotedString() + "' of type '"
141 + RV->getType()->getAsString() +
142 "' is incompatible with initializer '" + V->getAsString()
147 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
148 /// args as SubClass's template arguments.
149 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
150 Record *SC = SubClass.Rec;
151 // Add all of the values in the subclass into the current class.
152 const std::vector<RecordVal> &Vals = SC->getValues();
153 for (unsigned i = 0, e = Vals.size(); i != e; ++i)
154 if (AddValue(CurRec, SubClass.RefLoc, Vals[i]))
157 const std::vector<Init *> &TArgs = SC->getTemplateArgs();
159 // Ensure that an appropriate number of template arguments are specified.
160 if (TArgs.size() < SubClass.TemplateArgs.size())
161 return Error(SubClass.RefLoc, "More template args specified than expected");
163 // Loop over all of the template arguments, setting them to the specified
164 // value or leaving them as the default if necessary.
165 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
166 if (i < SubClass.TemplateArgs.size()) {
167 // If a value is specified for this template arg, set it now.
168 if (SetValue(CurRec, SubClass.RefLoc, TArgs[i], std::vector<unsigned>(),
169 SubClass.TemplateArgs[i]))
173 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
176 CurRec->removeValue(TArgs[i]);
178 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
179 return Error(SubClass.RefLoc,"Value not specified for template argument #"
180 + utostr(i) + " (" + TArgs[i]->getAsUnquotedString()
181 + ") of subclass '" + SC->getNameInitAsString() + "'!");
185 // Since everything went well, we can now set the "superclass" list for the
187 const std::vector<Record*> &SCs = SC->getSuperClasses();
188 for (unsigned i = 0, e = SCs.size(); i != e; ++i) {
189 if (CurRec->isSubClassOf(SCs[i]))
190 return Error(SubClass.RefLoc,
191 "Already subclass of '" + SCs[i]->getName() + "'!\n");
192 CurRec->addSuperClass(SCs[i]);
195 if (CurRec->isSubClassOf(SC))
196 return Error(SubClass.RefLoc,
197 "Already subclass of '" + SC->getName() + "'!\n");
198 CurRec->addSuperClass(SC);
202 /// AddSubMultiClass - Add SubMultiClass as a subclass to
203 /// CurMC, resolving its template args as SubMultiClass's
204 /// template arguments.
205 bool TGParser::AddSubMultiClass(MultiClass *CurMC,
206 SubMultiClassReference &SubMultiClass) {
207 MultiClass *SMC = SubMultiClass.MC;
208 Record *CurRec = &CurMC->Rec;
210 const std::vector<RecordVal> &MCVals = CurRec->getValues();
212 // Add all of the values in the subclass into the current class.
213 const std::vector<RecordVal> &SMCVals = SMC->Rec.getValues();
214 for (unsigned i = 0, e = SMCVals.size(); i != e; ++i)
215 if (AddValue(CurRec, SubMultiClass.RefLoc, SMCVals[i]))
218 int newDefStart = CurMC->DefPrototypes.size();
220 // Add all of the defs in the subclass into the current multiclass.
221 for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(),
222 iend = SMC->DefPrototypes.end();
225 // Clone the def and add it to the current multiclass
226 Record *NewDef = new Record(**i);
228 // Add all of the values in the superclass into the current def.
229 for (unsigned i = 0, e = MCVals.size(); i != e; ++i)
230 if (AddValue(NewDef, SubMultiClass.RefLoc, MCVals[i]))
233 CurMC->DefPrototypes.push_back(NewDef);
236 const std::vector<Init *> &SMCTArgs = SMC->Rec.getTemplateArgs();
238 // Ensure that an appropriate number of template arguments are
240 if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size())
241 return Error(SubMultiClass.RefLoc,
242 "More template args specified than expected");
244 // Loop over all of the template arguments, setting them to the specified
245 // value or leaving them as the default if necessary.
246 for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) {
247 if (i < SubMultiClass.TemplateArgs.size()) {
248 // If a value is specified for this template arg, set it in the
250 if (SetValue(CurRec, SubMultiClass.RefLoc, SMCTArgs[i],
251 std::vector<unsigned>(),
252 SubMultiClass.TemplateArgs[i]))
256 CurRec->resolveReferencesTo(CurRec->getValue(SMCTArgs[i]));
259 CurRec->removeValue(SMCTArgs[i]);
261 // If a value is specified for this template arg, set it in the
263 for (MultiClass::RecordVector::iterator j =
264 CurMC->DefPrototypes.begin() + newDefStart,
265 jend = CurMC->DefPrototypes.end();
270 if (SetValue(Def, SubMultiClass.RefLoc, SMCTArgs[i],
271 std::vector<unsigned>(),
272 SubMultiClass.TemplateArgs[i]))
276 Def->resolveReferencesTo(Def->getValue(SMCTArgs[i]));
279 Def->removeValue(SMCTArgs[i]);
281 } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) {
282 return Error(SubMultiClass.RefLoc,
283 "Value not specified for template argument #"
284 + utostr(i) + " (" + SMCTArgs[i]->getAsUnquotedString()
285 + ") of subclass '" + SMC->Rec.getNameInitAsString() + "'!");
292 //===----------------------------------------------------------------------===//
294 //===----------------------------------------------------------------------===//
296 /// isObjectStart - Return true if this is a valid first token for an Object.
297 static bool isObjectStart(tgtok::TokKind K) {
298 return K == tgtok::Class || K == tgtok::Def ||
299 K == tgtok::Defm || K == tgtok::Let || K == tgtok::MultiClass;
302 static std::string GetNewAnonymousName() {
303 static unsigned AnonCounter = 0;
304 return "anonymous."+utostr(AnonCounter++);
307 /// ParseObjectName - If an object name is specified, return it. Otherwise,
308 /// return an anonymous name.
309 /// ObjectName ::= Value [ '#' Value ]*
310 /// ObjectName ::= /*empty*/
312 Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
313 switch (Lex.getCode()) {
317 // These are all of the tokens that can begin an object body.
318 // Some of these can also begin values but we disallow those cases
319 // because they are unlikely to be useful.
320 return StringInit::get(GetNewAnonymousName());
328 CurRec = &CurMultiClass->Rec;
332 const TypedInit *CurRecName =
333 dynamic_cast<const TypedInit *>(CurRec->getNameInit());
335 TokError("Record name is not typed!");
338 Type = CurRecName->getType();
341 return ParseValue(CurRec, Type, ParseNameMode);
344 /// ParseClassID - Parse and resolve a reference to a class name. This returns
349 Record *TGParser::ParseClassID() {
350 if (Lex.getCode() != tgtok::Id) {
351 TokError("expected name for ClassID");
355 Record *Result = Records.getClass(Lex.getCurStrVal());
357 TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");
363 /// ParseMultiClassID - Parse and resolve a reference to a multiclass name.
364 /// This returns null on error.
366 /// MultiClassID ::= ID
368 MultiClass *TGParser::ParseMultiClassID() {
369 if (Lex.getCode() != tgtok::Id) {
370 TokError("expected name for ClassID");
374 MultiClass *Result = MultiClasses[Lex.getCurStrVal()];
376 TokError("Couldn't find class '" + Lex.getCurStrVal() + "'");
382 Record *TGParser::ParseDefmID() {
383 if (Lex.getCode() != tgtok::Id) {
384 TokError("expected multiclass name");
388 MultiClass *MC = MultiClasses[Lex.getCurStrVal()];
390 TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");
399 /// ParseSubClassReference - Parse a reference to a subclass or to a templated
400 /// subclass. This returns a SubClassRefTy with a null Record* on error.
402 /// SubClassRef ::= ClassID
403 /// SubClassRef ::= ClassID '<' ValueList '>'
405 SubClassReference TGParser::
406 ParseSubClassReference(Record *CurRec, bool isDefm) {
407 SubClassReference Result;
408 Result.RefLoc = Lex.getLoc();
411 Result.Rec = ParseDefmID();
413 Result.Rec = ParseClassID();
414 if (Result.Rec == 0) return Result;
416 // If there is no template arg list, we're done.
417 if (Lex.getCode() != tgtok::less)
419 Lex.Lex(); // Eat the '<'
421 if (Lex.getCode() == tgtok::greater) {
422 TokError("subclass reference requires a non-empty list of template values");
427 Result.TemplateArgs = ParseValueList(CurRec, Result.Rec);
428 if (Result.TemplateArgs.empty()) {
429 Result.Rec = 0; // Error parsing value list.
433 if (Lex.getCode() != tgtok::greater) {
434 TokError("expected '>' in template value list");
443 /// ParseSubMultiClassReference - Parse a reference to a subclass or to a
444 /// templated submulticlass. This returns a SubMultiClassRefTy with a null
445 /// Record* on error.
447 /// SubMultiClassRef ::= MultiClassID
448 /// SubMultiClassRef ::= MultiClassID '<' ValueList '>'
450 SubMultiClassReference TGParser::
451 ParseSubMultiClassReference(MultiClass *CurMC) {
452 SubMultiClassReference Result;
453 Result.RefLoc = Lex.getLoc();
455 Result.MC = ParseMultiClassID();
456 if (Result.MC == 0) return Result;
458 // If there is no template arg list, we're done.
459 if (Lex.getCode() != tgtok::less)
461 Lex.Lex(); // Eat the '<'
463 if (Lex.getCode() == tgtok::greater) {
464 TokError("subclass reference requires a non-empty list of template values");
469 Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec);
470 if (Result.TemplateArgs.empty()) {
471 Result.MC = 0; // Error parsing value list.
475 if (Lex.getCode() != tgtok::greater) {
476 TokError("expected '>' in template value list");
485 /// ParseRangePiece - Parse a bit/value range.
486 /// RangePiece ::= INTVAL
487 /// RangePiece ::= INTVAL '-' INTVAL
488 /// RangePiece ::= INTVAL INTVAL
489 bool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) {
490 if (Lex.getCode() != tgtok::IntVal) {
491 TokError("expected integer or bitrange");
494 int64_t Start = Lex.getCurIntVal();
498 return TokError("invalid range, cannot be negative");
500 switch (Lex.Lex()) { // eat first character.
502 Ranges.push_back(Start);
505 if (Lex.Lex() != tgtok::IntVal) {
506 TokError("expected integer value as end of range");
509 End = Lex.getCurIntVal();
512 End = -Lex.getCurIntVal();
516 return TokError("invalid range, cannot be negative");
521 for (; Start <= End; ++Start)
522 Ranges.push_back(Start);
524 for (; Start >= End; --Start)
525 Ranges.push_back(Start);
530 /// ParseRangeList - Parse a list of scalars and ranges into scalar values.
532 /// RangeList ::= RangePiece (',' RangePiece)*
534 std::vector<unsigned> TGParser::ParseRangeList() {
535 std::vector<unsigned> Result;
537 // Parse the first piece.
538 if (ParseRangePiece(Result))
539 return std::vector<unsigned>();
540 while (Lex.getCode() == tgtok::comma) {
541 Lex.Lex(); // Eat the comma.
543 // Parse the next range piece.
544 if (ParseRangePiece(Result))
545 return std::vector<unsigned>();
550 /// ParseOptionalRangeList - Parse either a range list in <>'s or nothing.
551 /// OptionalRangeList ::= '<' RangeList '>'
552 /// OptionalRangeList ::= /*empty*/
553 bool TGParser::ParseOptionalRangeList(std::vector<unsigned> &Ranges) {
554 if (Lex.getCode() != tgtok::less)
557 SMLoc StartLoc = Lex.getLoc();
558 Lex.Lex(); // eat the '<'
560 // Parse the range list.
561 Ranges = ParseRangeList();
562 if (Ranges.empty()) return true;
564 if (Lex.getCode() != tgtok::greater) {
565 TokError("expected '>' at end of range list");
566 return Error(StartLoc, "to match this '<'");
568 Lex.Lex(); // eat the '>'.
572 /// ParseOptionalBitList - Parse either a bit list in {}'s or nothing.
573 /// OptionalBitList ::= '{' RangeList '}'
574 /// OptionalBitList ::= /*empty*/
575 bool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) {
576 if (Lex.getCode() != tgtok::l_brace)
579 SMLoc StartLoc = Lex.getLoc();
580 Lex.Lex(); // eat the '{'
582 // Parse the range list.
583 Ranges = ParseRangeList();
584 if (Ranges.empty()) return true;
586 if (Lex.getCode() != tgtok::r_brace) {
587 TokError("expected '}' at end of bit list");
588 return Error(StartLoc, "to match this '{'");
590 Lex.Lex(); // eat the '}'.
595 /// ParseType - Parse and return a tblgen type. This returns null on error.
597 /// Type ::= STRING // string type
598 /// Type ::= BIT // bit type
599 /// Type ::= BITS '<' INTVAL '>' // bits<x> type
600 /// Type ::= INT // int type
601 /// Type ::= LIST '<' Type '>' // list<x> type
602 /// Type ::= CODE // code type
603 /// Type ::= DAG // dag type
604 /// Type ::= ClassID // Record Type
606 RecTy *TGParser::ParseType() {
607 switch (Lex.getCode()) {
608 default: TokError("Unknown token when expecting a type"); return 0;
609 case tgtok::String: Lex.Lex(); return StringRecTy::get();
610 case tgtok::Bit: Lex.Lex(); return BitRecTy::get();
611 case tgtok::Int: Lex.Lex(); return IntRecTy::get();
612 case tgtok::Code: Lex.Lex(); return CodeRecTy::get();
613 case tgtok::Dag: Lex.Lex(); return DagRecTy::get();
615 if (Record *R = ParseClassID()) return RecordRecTy::get(R);
618 if (Lex.Lex() != tgtok::less) { // Eat 'bits'
619 TokError("expected '<' after bits type");
622 if (Lex.Lex() != tgtok::IntVal) { // Eat '<'
623 TokError("expected integer in bits<n> type");
626 uint64_t Val = Lex.getCurIntVal();
627 if (Lex.Lex() != tgtok::greater) { // Eat count.
628 TokError("expected '>' at end of bits<n> type");
631 Lex.Lex(); // Eat '>'
632 return BitsRecTy::get(Val);
635 if (Lex.Lex() != tgtok::less) { // Eat 'bits'
636 TokError("expected '<' after list type");
639 Lex.Lex(); // Eat '<'
640 RecTy *SubType = ParseType();
641 if (SubType == 0) return 0;
643 if (Lex.getCode() != tgtok::greater) {
644 TokError("expected '>' at end of list<ty> type");
647 Lex.Lex(); // Eat '>'
648 return ListRecTy::get(SubType);
653 /// ParseIDValue - Parse an ID as a value and decode what it means.
655 /// IDValue ::= ID [def local value]
656 /// IDValue ::= ID [def template arg]
657 /// IDValue ::= ID [multiclass local value]
658 /// IDValue ::= ID [multiclass template argument]
659 /// IDValue ::= ID [def name]
661 Init *TGParser::ParseIDValue(Record *CurRec, IDParseMode Mode) {
662 assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
663 std::string Name = Lex.getCurStrVal();
664 SMLoc Loc = Lex.getLoc();
666 return ParseIDValue(CurRec, Name, Loc);
669 /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
670 /// has already been read.
671 Init *TGParser::ParseIDValue(Record *CurRec,
672 const std::string &Name, SMLoc NameLoc,
675 if (const RecordVal *RV = CurRec->getValue(Name))
676 return VarInit::get(Name, RV->getType());
678 Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");
681 TemplateArgName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name,
684 if (CurRec->isTemplateArg(TemplateArgName)) {
685 const RecordVal *RV = CurRec->getValue(TemplateArgName);
686 assert(RV && "Template arg doesn't exist??");
687 return VarInit::get(TemplateArgName, RV->getType());
692 Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name,
695 if (CurMultiClass->Rec.isTemplateArg(MCName)) {
696 const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
697 assert(RV && "Template arg doesn't exist??");
698 return VarInit::get(MCName, RV->getType());
702 if (Mode == ParseNameMode)
703 return StringInit::get(Name);
705 if (Record *D = Records.getDef(Name))
706 return DefInit::get(D);
708 if (Mode == ParseValueMode) {
709 Error(NameLoc, "Variable not defined: '" + Name + "'");
713 return StringInit::get(Name);
716 /// ParseOperation - Parse an operator. This returns null on error.
718 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
720 Init *TGParser::ParseOperation(Record *CurRec) {
721 switch (Lex.getCode()) {
723 TokError("unknown operation");
729 case tgtok::XCast: { // Value ::= !unop '(' Value ')'
730 UnOpInit::UnaryOp Code;
733 switch (Lex.getCode()) {
734 default: assert(0 && "Unhandled code!");
736 Lex.Lex(); // eat the operation
737 Code = UnOpInit::CAST;
739 Type = ParseOperatorType();
742 TokError("did not get type for unary operator");
748 Lex.Lex(); // eat the operation
749 Code = UnOpInit::HEAD;
752 Lex.Lex(); // eat the operation
753 Code = UnOpInit::TAIL;
756 Lex.Lex(); // eat the operation
757 Code = UnOpInit::EMPTY;
758 Type = IntRecTy::get();
761 if (Lex.getCode() != tgtok::l_paren) {
762 TokError("expected '(' after unary operator");
765 Lex.Lex(); // eat the '('
767 Init *LHS = ParseValue(CurRec);
768 if (LHS == 0) return 0;
770 if (Code == UnOpInit::HEAD
771 || Code == UnOpInit::TAIL
772 || Code == UnOpInit::EMPTY) {
773 ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
774 StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
775 TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
776 if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
777 TokError("expected list or string type argument in unary operator");
781 ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType());
782 StringRecTy *SType = dynamic_cast<StringRecTy*>(LHSt->getType());
783 if (LType == 0 && SType == 0) {
784 TokError("expected list or string type argumnet in unary operator");
789 if (Code == UnOpInit::HEAD
790 || Code == UnOpInit::TAIL) {
791 if (LHSl == 0 && LHSt == 0) {
792 TokError("expected list type argumnet in unary operator");
796 if (LHSl && LHSl->getSize() == 0) {
797 TokError("empty list argument in unary operator");
801 Init *Item = LHSl->getElement(0);
802 TypedInit *Itemt = dynamic_cast<TypedInit*>(Item);
804 TokError("untyped list element in unary operator");
807 if (Code == UnOpInit::HEAD) {
808 Type = Itemt->getType();
810 Type = ListRecTy::get(Itemt->getType());
813 assert(LHSt && "expected list type argument in unary operator");
814 ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType());
816 TokError("expected list type argumnet in unary operator");
819 if (Code == UnOpInit::HEAD) {
820 Type = LType->getElementType();
828 if (Lex.getCode() != tgtok::r_paren) {
829 TokError("expected ')' in unary operator");
832 Lex.Lex(); // eat the ')'
833 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
841 case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')'
842 tgtok::TokKind OpTok = Lex.getCode();
843 SMLoc OpLoc = Lex.getLoc();
844 Lex.Lex(); // eat the operation
846 BinOpInit::BinaryOp Code;
850 default: assert(0 && "Unhandled code!");
851 case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break;
852 case tgtok::XSRA: Code = BinOpInit::SRA; Type = IntRecTy::get(); break;
853 case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break;
854 case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break;
855 case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break;
856 case tgtok::XStrConcat:
857 Code = BinOpInit::STRCONCAT;
858 Type = StringRecTy::get();
862 if (Lex.getCode() != tgtok::l_paren) {
863 TokError("expected '(' after binary operator");
866 Lex.Lex(); // eat the '('
868 SmallVector<Init*, 2> InitList;
870 InitList.push_back(ParseValue(CurRec));
871 if (InitList.back() == 0) return 0;
873 while (Lex.getCode() == tgtok::comma) {
874 Lex.Lex(); // eat the ','
876 InitList.push_back(ParseValue(CurRec));
877 if (InitList.back() == 0) return 0;
880 if (Lex.getCode() != tgtok::r_paren) {
881 TokError("expected ')' in operator");
884 Lex.Lex(); // eat the ')'
886 // We allow multiple operands to associative operators like !strconcat as
887 // shorthand for nesting them.
888 if (Code == BinOpInit::STRCONCAT) {
889 while (InitList.size() > 2) {
890 Init *RHS = InitList.pop_back_val();
891 RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
892 ->Fold(CurRec, CurMultiClass);
893 InitList.back() = RHS;
897 if (InitList.size() == 2)
898 return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
899 ->Fold(CurRec, CurMultiClass);
901 Error(OpLoc, "expected two operands to operator");
906 case tgtok::XForEach:
907 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
908 TernOpInit::TernaryOp Code;
911 tgtok::TokKind LexCode = Lex.getCode();
912 Lex.Lex(); // eat the operation
914 default: assert(0 && "Unhandled code!");
916 Code = TernOpInit::IF;
918 case tgtok::XForEach:
919 Code = TernOpInit::FOREACH;
922 Code = TernOpInit::SUBST;
925 if (Lex.getCode() != tgtok::l_paren) {
926 TokError("expected '(' after ternary operator");
929 Lex.Lex(); // eat the '('
931 Init *LHS = ParseValue(CurRec);
932 if (LHS == 0) return 0;
934 if (Lex.getCode() != tgtok::comma) {
935 TokError("expected ',' in ternary operator");
938 Lex.Lex(); // eat the ','
940 Init *MHS = ParseValue(CurRec);
941 if (MHS == 0) return 0;
943 if (Lex.getCode() != tgtok::comma) {
944 TokError("expected ',' in ternary operator");
947 Lex.Lex(); // eat the ','
949 Init *RHS = ParseValue(CurRec);
950 if (RHS == 0) return 0;
952 if (Lex.getCode() != tgtok::r_paren) {
953 TokError("expected ')' in binary operator");
956 Lex.Lex(); // eat the ')'
959 default: assert(0 && "Unhandled code!");
961 // FIXME: The `!if' operator doesn't handle non-TypedInit well at
962 // all. This can be made much more robust.
963 TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS);
964 TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS);
969 if (MHSt == 0 && RHSt == 0) {
970 BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS);
971 BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS);
973 if (MHSbits && RHSbits &&
974 MHSbits->getNumBits() == RHSbits->getNumBits()) {
975 Type = BitRecTy::get();
978 BitInit *MHSbit = dynamic_cast<BitInit*>(MHS);
979 BitInit *RHSbit = dynamic_cast<BitInit*>(RHS);
981 if (MHSbit && RHSbit) {
982 Type = BitRecTy::get();
986 } else if (MHSt != 0 && RHSt != 0) {
987 MHSTy = MHSt->getType();
988 RHSTy = RHSt->getType();
991 if (!MHSTy || !RHSTy) {
992 TokError("could not get type for !if");
996 if (MHSTy->typeIsConvertibleTo(RHSTy)) {
998 } else if (RHSTy->typeIsConvertibleTo(MHSTy)) {
1001 TokError("inconsistent types for !if");
1006 case tgtok::XForEach: {
1007 TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS);
1009 TokError("could not get type for !foreach");
1012 Type = MHSt->getType();
1015 case tgtok::XSubst: {
1016 TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS);
1018 TokError("could not get type for !subst");
1021 Type = RHSt->getType();
1025 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
1029 TokError("could not parse operation");
1033 /// ParseOperatorType - Parse a type for an operator. This returns
1036 /// OperatorType ::= '<' Type '>'
1038 RecTy *TGParser::ParseOperatorType() {
1041 if (Lex.getCode() != tgtok::less) {
1042 TokError("expected type name for operator");
1045 Lex.Lex(); // eat the <
1050 TokError("expected type name for operator");
1054 if (Lex.getCode() != tgtok::greater) {
1055 TokError("expected type name for operator");
1058 Lex.Lex(); // eat the >
1064 /// ParseSimpleValue - Parse a tblgen value. This returns null on error.
1066 /// SimpleValue ::= IDValue
1067 /// SimpleValue ::= INTVAL
1068 /// SimpleValue ::= STRVAL+
1069 /// SimpleValue ::= CODEFRAGMENT
1070 /// SimpleValue ::= '?'
1071 /// SimpleValue ::= '{' ValueList '}'
1072 /// SimpleValue ::= ID '<' ValueListNE '>'
1073 /// SimpleValue ::= '[' ValueList ']'
1074 /// SimpleValue ::= '(' IDValue DagArgList ')'
1075 /// SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
1076 /// SimpleValue ::= SHLTOK '(' Value ',' Value ')'
1077 /// SimpleValue ::= SRATOK '(' Value ',' Value ')'
1078 /// SimpleValue ::= SRLTOK '(' Value ',' Value ')'
1079 /// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
1081 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
1084 switch (Lex.getCode()) {
1085 default: TokError("Unknown token when parsing a value"); break;
1086 case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break;
1087 case tgtok::StrVal: {
1088 std::string Val = Lex.getCurStrVal();
1091 // Handle multiple consecutive concatenated strings.
1092 while (Lex.getCode() == tgtok::StrVal) {
1093 Val += Lex.getCurStrVal();
1097 R = StringInit::get(Val);
1100 case tgtok::CodeFragment:
1101 R = CodeInit::get(Lex.getCurStrVal());
1104 case tgtok::question:
1105 R = UnsetInit::get();
1109 SMLoc NameLoc = Lex.getLoc();
1110 std::string Name = Lex.getCurStrVal();
1111 if (Lex.Lex() != tgtok::less) // consume the Id.
1112 return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue
1114 // Value ::= ID '<' ValueListNE '>'
1115 if (Lex.Lex() == tgtok::greater) {
1116 TokError("expected non-empty value list");
1120 // This is a CLASS<initvalslist> expression. This is supposed to synthesize
1121 // a new anonymous definition, deriving from CLASS<initvalslist> with no
1123 Record *Class = Records.getClass(Name);
1125 Error(NameLoc, "Expected a class name, got '" + Name + "'");
1129 std::vector<Init*> ValueList = ParseValueList(CurRec, Class);
1130 if (ValueList.empty()) return 0;
1132 if (Lex.getCode() != tgtok::greater) {
1133 TokError("expected '>' at end of value list");
1136 Lex.Lex(); // eat the '>'
1138 // Create the new record, set it as CurRec temporarily.
1139 static unsigned AnonCounter = 0;
1140 Record *NewRec = new Record("anonymous.val."+utostr(AnonCounter++),
1143 SubClassReference SCRef;
1144 SCRef.RefLoc = NameLoc;
1146 SCRef.TemplateArgs = ValueList;
1147 // Add info about the subclass to NewRec.
1148 if (AddSubClass(NewRec, SCRef))
1150 NewRec->resolveReferences();
1151 Records.addDef(NewRec);
1153 // The result of the expression is a reference to the new record.
1154 return DefInit::get(NewRec);
1156 case tgtok::l_brace: { // Value ::= '{' ValueList '}'
1157 SMLoc BraceLoc = Lex.getLoc();
1158 Lex.Lex(); // eat the '{'
1159 std::vector<Init*> Vals;
1161 if (Lex.getCode() != tgtok::r_brace) {
1162 Vals = ParseValueList(CurRec);
1163 if (Vals.empty()) return 0;
1165 if (Lex.getCode() != tgtok::r_brace) {
1166 TokError("expected '}' at end of bit list value");
1169 Lex.Lex(); // eat the '}'
1171 SmallVector<Init *, 16> NewBits(Vals.size());
1173 for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
1174 Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
1176 Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
1177 ") is not convertable to a bit");
1180 NewBits[Vals.size()-i-1] = Bit;
1182 return BitsInit::get(NewBits);
1184 case tgtok::l_square: { // Value ::= '[' ValueList ']'
1185 Lex.Lex(); // eat the '['
1186 std::vector<Init*> Vals;
1188 RecTy *DeducedEltTy = 0;
1189 ListRecTy *GivenListTy = 0;
1191 if (ItemType != 0) {
1192 ListRecTy *ListType = dynamic_cast<ListRecTy*>(ItemType);
1193 if (ListType == 0) {
1194 std::stringstream s;
1195 s << "Type mismatch for list, expected list type, got "
1196 << ItemType->getAsString();
1200 GivenListTy = ListType;
1203 if (Lex.getCode() != tgtok::r_square) {
1204 Vals = ParseValueList(CurRec, 0,
1205 GivenListTy ? GivenListTy->getElementType() : 0);
1206 if (Vals.empty()) return 0;
1208 if (Lex.getCode() != tgtok::r_square) {
1209 TokError("expected ']' at end of list value");
1212 Lex.Lex(); // eat the ']'
1214 RecTy *GivenEltTy = 0;
1215 if (Lex.getCode() == tgtok::less) {
1216 // Optional list element type
1217 Lex.Lex(); // eat the '<'
1219 GivenEltTy = ParseType();
1220 if (GivenEltTy == 0) {
1221 // Couldn't parse element type
1225 if (Lex.getCode() != tgtok::greater) {
1226 TokError("expected '>' at end of list element type");
1229 Lex.Lex(); // eat the '>'
1234 for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
1237 TypedInit *TArg = dynamic_cast<TypedInit*>(*i);
1239 TokError("Untyped list element");
1243 EltTy = resolveTypes(EltTy, TArg->getType());
1245 TokError("Incompatible types in list elements");
1249 EltTy = TArg->getType();
1253 if (GivenEltTy != 0) {
1255 // Verify consistency
1256 if (!EltTy->typeIsConvertibleTo(GivenEltTy)) {
1257 TokError("Incompatible types in list elements");
1265 if (ItemType == 0) {
1266 TokError("No type for list");
1269 DeducedEltTy = GivenListTy->getElementType();
1271 // Make sure the deduced type is compatible with the given type
1273 if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) {
1274 TokError("Element type mismatch for list");
1278 DeducedEltTy = EltTy;
1281 return ListInit::get(Vals, DeducedEltTy);
1283 case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')'
1284 Lex.Lex(); // eat the '('
1285 if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) {
1286 TokError("expected identifier in dag init");
1290 Init *Operator = ParseValue(CurRec);
1291 if (Operator == 0) return 0;
1293 // If the operator name is present, parse it.
1294 std::string OperatorName;
1295 if (Lex.getCode() == tgtok::colon) {
1296 if (Lex.Lex() != tgtok::VarName) { // eat the ':'
1297 TokError("expected variable name in dag operator");
1300 OperatorName = Lex.getCurStrVal();
1301 Lex.Lex(); // eat the VarName.
1304 std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
1305 if (Lex.getCode() != tgtok::r_paren) {
1306 DagArgs = ParseDagArgList(CurRec);
1307 if (DagArgs.empty()) return 0;
1310 if (Lex.getCode() != tgtok::r_paren) {
1311 TokError("expected ')' in dag init");
1314 Lex.Lex(); // eat the ')'
1316 return DagInit::get(Operator, OperatorName, DagArgs);
1322 case tgtok::XCast: // Value ::= !unop '(' Value ')'
1323 case tgtok::XConcat:
1328 case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')'
1330 case tgtok::XForEach:
1331 case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
1332 return ParseOperation(CurRec);
1339 /// ParseValue - Parse a tblgen value. This returns null on error.
1341 /// Value ::= SimpleValue ValueSuffix*
1342 /// ValueSuffix ::= '{' BitList '}'
1343 /// ValueSuffix ::= '[' BitList ']'
1344 /// ValueSuffix ::= '.' ID
1346 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
1347 Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
1348 if (Result == 0) return 0;
1350 // Parse the suffixes now if present.
1352 switch (Lex.getCode()) {
1353 default: return Result;
1354 case tgtok::l_brace: {
1355 if (Mode == ParseNameMode)
1356 // This is the beginning of the object body.
1359 SMLoc CurlyLoc = Lex.getLoc();
1360 Lex.Lex(); // eat the '{'
1361 std::vector<unsigned> Ranges = ParseRangeList();
1362 if (Ranges.empty()) return 0;
1364 // Reverse the bitlist.
1365 std::reverse(Ranges.begin(), Ranges.end());
1366 Result = Result->convertInitializerBitRange(Ranges);
1368 Error(CurlyLoc, "Invalid bit range for value");
1373 if (Lex.getCode() != tgtok::r_brace) {
1374 TokError("expected '}' at end of bit range list");
1380 case tgtok::l_square: {
1381 SMLoc SquareLoc = Lex.getLoc();
1382 Lex.Lex(); // eat the '['
1383 std::vector<unsigned> Ranges = ParseRangeList();
1384 if (Ranges.empty()) return 0;
1386 Result = Result->convertInitListSlice(Ranges);
1388 Error(SquareLoc, "Invalid range for list slice");
1393 if (Lex.getCode() != tgtok::r_square) {
1394 TokError("expected ']' at end of list slice");
1401 if (Lex.Lex() != tgtok::Id) { // eat the .
1402 TokError("expected field identifier after '.'");
1405 if (!Result->getFieldType(Lex.getCurStrVal())) {
1406 TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
1407 Result->getAsString() + "'");
1410 Result = FieldInit::get(Result, Lex.getCurStrVal());
1411 Lex.Lex(); // eat field name
1417 /// ParseDagArgList - Parse the argument list for a dag literal expression.
1419 /// ParseDagArgList ::= Value (':' VARNAME)?
1420 /// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
1421 std::vector<std::pair<llvm::Init*, std::string> >
1422 TGParser::ParseDagArgList(Record *CurRec) {
1423 std::vector<std::pair<llvm::Init*, std::string> > Result;
1426 Init *Val = ParseValue(CurRec);
1427 if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
1429 // If the variable name is present, add it.
1430 std::string VarName;
1431 if (Lex.getCode() == tgtok::colon) {
1432 if (Lex.Lex() != tgtok::VarName) { // eat the ':'
1433 TokError("expected variable name in dag literal");
1434 return std::vector<std::pair<llvm::Init*, std::string> >();
1436 VarName = Lex.getCurStrVal();
1437 Lex.Lex(); // eat the VarName.
1440 Result.push_back(std::make_pair(Val, VarName));
1442 if (Lex.getCode() != tgtok::comma) break;
1443 Lex.Lex(); // eat the ','
1450 /// ParseValueList - Parse a comma separated list of values, returning them as a
1451 /// vector. Note that this always expects to be able to parse at least one
1452 /// value. It returns an empty list if this is not possible.
1454 /// ValueList ::= Value (',' Value)
1456 std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
1458 std::vector<Init*> Result;
1459 RecTy *ItemType = EltTy;
1460 unsigned int ArgN = 0;
1461 if (ArgsRec != 0 && EltTy == 0) {
1462 const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
1463 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
1465 errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN]
1468 assert(RV && "Template argument record not found??");
1469 ItemType = RV->getType();
1472 Result.push_back(ParseValue(CurRec, ItemType));
1473 if (Result.back() == 0) return std::vector<Init*>();
1475 while (Lex.getCode() == tgtok::comma) {
1476 Lex.Lex(); // Eat the comma
1478 if (ArgsRec != 0 && EltTy == 0) {
1479 const std::vector<Init *> &TArgs = ArgsRec->getTemplateArgs();
1480 if (ArgN >= TArgs.size()) {
1481 TokError("too many template arguments");
1482 return std::vector<Init*>();
1484 const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
1485 assert(RV && "Template argument record not found??");
1486 ItemType = RV->getType();
1489 Result.push_back(ParseValue(CurRec, ItemType));
1490 if (Result.back() == 0) return std::vector<Init*>();
1497 /// ParseDeclaration - Read a declaration, returning the name of field ID, or an
1498 /// empty string on error. This can happen in a number of different context's,
1499 /// including within a def or in the template args for a def (which which case
1500 /// CurRec will be non-null) and within the template args for a multiclass (in
1501 /// which case CurRec will be null, but CurMultiClass will be set). This can
1502 /// also happen within a def that is within a multiclass, which will set both
1503 /// CurRec and CurMultiClass.
1505 /// Declaration ::= FIELD? Type ID ('=' Value)?
1507 Init *TGParser::ParseDeclaration(Record *CurRec,
1508 bool ParsingTemplateArgs) {
1509 // Read the field prefix if present.
1510 bool HasField = Lex.getCode() == tgtok::Field;
1511 if (HasField) Lex.Lex();
1513 RecTy *Type = ParseType();
1514 if (Type == 0) return 0;
1516 if (Lex.getCode() != tgtok::Id) {
1517 TokError("Expected identifier in declaration");
1521 SMLoc IdLoc = Lex.getLoc();
1522 Init *DeclName = StringInit::get(Lex.getCurStrVal());
1525 if (ParsingTemplateArgs) {
1527 DeclName = QualifyName(*CurRec, CurMultiClass, DeclName, ":");
1529 assert(CurMultiClass);
1532 DeclName = QualifyName(CurMultiClass->Rec, CurMultiClass, DeclName,
1537 if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField)))
1540 // If a value is present, parse it.
1541 if (Lex.getCode() == tgtok::equal) {
1543 SMLoc ValLoc = Lex.getLoc();
1544 Init *Val = ParseValue(CurRec, Type);
1546 SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
1553 /// ParseTemplateArgList - Read a template argument list, which is a non-empty
1554 /// sequence of template-declarations in <>'s. If CurRec is non-null, these are
1555 /// template args for a def, which may or may not be in a multiclass. If null,
1556 /// these are the template args for a multiclass.
1558 /// TemplateArgList ::= '<' Declaration (',' Declaration)* '>'
1560 bool TGParser::ParseTemplateArgList(Record *CurRec) {
1561 assert(Lex.getCode() == tgtok::less && "Not a template arg list!");
1562 Lex.Lex(); // eat the '<'
1564 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
1566 // Read the first declaration.
1567 Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
1571 TheRecToAddTo->addTemplateArg(TemplArg);
1573 while (Lex.getCode() == tgtok::comma) {
1574 Lex.Lex(); // eat the ','
1576 // Read the following declarations.
1577 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
1580 TheRecToAddTo->addTemplateArg(TemplArg);
1583 if (Lex.getCode() != tgtok::greater)
1584 return TokError("expected '>' at end of template argument list");
1585 Lex.Lex(); // eat the '>'.
1590 /// ParseBodyItem - Parse a single item at within the body of a def or class.
1592 /// BodyItem ::= Declaration ';'
1593 /// BodyItem ::= LET ID OptionalBitList '=' Value ';'
1594 bool TGParser::ParseBodyItem(Record *CurRec) {
1595 if (Lex.getCode() != tgtok::Let) {
1596 if (ParseDeclaration(CurRec, false) == 0)
1599 if (Lex.getCode() != tgtok::semi)
1600 return TokError("expected ';' after declaration");
1605 // LET ID OptionalRangeList '=' Value ';'
1606 if (Lex.Lex() != tgtok::Id)
1607 return TokError("expected field identifier after let");
1609 SMLoc IdLoc = Lex.getLoc();
1610 std::string FieldName = Lex.getCurStrVal();
1611 Lex.Lex(); // eat the field name.
1613 std::vector<unsigned> BitList;
1614 if (ParseOptionalBitList(BitList))
1616 std::reverse(BitList.begin(), BitList.end());
1618 if (Lex.getCode() != tgtok::equal)
1619 return TokError("expected '=' in let expression");
1620 Lex.Lex(); // eat the '='.
1622 RecordVal *Field = CurRec->getValue(FieldName);
1624 return TokError("Value '" + FieldName + "' unknown!");
1626 RecTy *Type = Field->getType();
1628 Init *Val = ParseValue(CurRec, Type);
1629 if (Val == 0) return true;
1631 if (Lex.getCode() != tgtok::semi)
1632 return TokError("expected ';' after let expression");
1635 return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
1638 /// ParseBody - Read the body of a class or def. Return true on error, false on
1642 /// Body ::= '{' BodyList '}'
1643 /// BodyList BodyItem*
1645 bool TGParser::ParseBody(Record *CurRec) {
1646 // If this is a null definition, just eat the semi and return.
1647 if (Lex.getCode() == tgtok::semi) {
1652 if (Lex.getCode() != tgtok::l_brace)
1653 return TokError("Expected ';' or '{' to start body");
1657 while (Lex.getCode() != tgtok::r_brace)
1658 if (ParseBodyItem(CurRec))
1666 /// ParseObjectBody - Parse the body of a def or class. This consists of an
1667 /// optional ClassList followed by a Body. CurRec is the current def or class
1668 /// that is being parsed.
1670 /// ObjectBody ::= BaseClassList Body
1671 /// BaseClassList ::= /*empty*/
1672 /// BaseClassList ::= ':' BaseClassListNE
1673 /// BaseClassListNE ::= SubClassRef (',' SubClassRef)*
1675 bool TGParser::ParseObjectBody(Record *CurRec) {
1676 // If there is a baseclass list, read it.
1677 if (Lex.getCode() == tgtok::colon) {
1680 // Read all of the subclasses.
1681 SubClassReference SubClass = ParseSubClassReference(CurRec, false);
1684 if (SubClass.Rec == 0) return true;
1687 if (AddSubClass(CurRec, SubClass))
1690 if (Lex.getCode() != tgtok::comma) break;
1691 Lex.Lex(); // eat ','.
1692 SubClass = ParseSubClassReference(CurRec, false);
1696 // Process any variables on the let stack.
1697 for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
1698 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
1699 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
1700 LetStack[i][j].Bits, LetStack[i][j].Value))
1703 return ParseBody(CurRec);
1706 /// ParseDef - Parse and return a top level or multiclass def, return the record
1707 /// corresponding to it. This returns null on error.
1709 /// DefInst ::= DEF ObjectName ObjectBody
1711 bool TGParser::ParseDef(MultiClass *CurMultiClass) {
1712 SMLoc DefLoc = Lex.getLoc();
1713 assert(Lex.getCode() == tgtok::Def && "Unknown tok");
1714 Lex.Lex(); // Eat the 'def' token.
1716 // Parse ObjectName and make a record for it.
1717 Record *CurRec = new Record(ParseObjectName(CurMultiClass), DefLoc, Records);
1719 if (!CurMultiClass) {
1720 // Top-level def definition.
1722 // Ensure redefinition doesn't happen.
1723 if (Records.getDef(CurRec->getName())) {
1724 Error(DefLoc, "def '" + CurRec->getNameInitAsString()
1725 + "' already defined");
1728 Records.addDef(CurRec);
1730 // Otherwise, a def inside a multiclass, add it to the multiclass.
1731 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i)
1732 if (CurMultiClass->DefPrototypes[i]->getNameInit()
1733 == CurRec->getNameInit()) {
1734 Error(DefLoc, "def '" + CurRec->getNameInitAsString() +
1735 "' already defined in this multiclass!");
1738 CurMultiClass->DefPrototypes.push_back(CurRec);
1741 if (ParseObjectBody(CurRec))
1744 if (CurMultiClass == 0) // Def's in multiclasses aren't really defs.
1745 // See Record::setName(). This resolve step will see any new name
1746 // for the def that might have been created when resolving
1747 // inheritance, values and arguments above.
1748 CurRec->resolveReferences();
1750 // If ObjectBody has template arguments, it's an error.
1751 assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?");
1753 if (CurMultiClass) {
1754 // Copy the template arguments for the multiclass into the def.
1755 const std::vector<Init *> &TArgs =
1756 CurMultiClass->Rec.getTemplateArgs();
1758 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
1759 const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]);
1760 assert(RV && "Template arg doesn't exist?");
1761 CurRec->addValue(*RV);
1768 /// ParseClass - Parse a tblgen class definition.
1770 /// ClassInst ::= CLASS ID TemplateArgList? ObjectBody
1772 bool TGParser::ParseClass() {
1773 assert(Lex.getCode() == tgtok::Class && "Unexpected token!");
1776 if (Lex.getCode() != tgtok::Id)
1777 return TokError("expected class name after 'class' keyword");
1779 Record *CurRec = Records.getClass(Lex.getCurStrVal());
1781 // If the body was previously defined, this is an error.
1782 if (CurRec->getValues().size() > 1 || // Account for NAME.
1783 !CurRec->getSuperClasses().empty() ||
1784 !CurRec->getTemplateArgs().empty())
1785 return TokError("Class '" + CurRec->getNameInitAsString()
1786 + "' already defined");
1788 // If this is the first reference to this class, create and add it.
1789 CurRec = new Record(Lex.getCurStrVal(), Lex.getLoc(), Records);
1790 Records.addClass(CurRec);
1792 Lex.Lex(); // eat the name.
1794 // If there are template args, parse them.
1795 if (Lex.getCode() == tgtok::less)
1796 if (ParseTemplateArgList(CurRec))
1799 // Finally, parse the object body.
1800 return ParseObjectBody(CurRec);
1803 /// ParseLetList - Parse a non-empty list of assignment expressions into a list
1806 /// LetList ::= LetItem (',' LetItem)*
1807 /// LetItem ::= ID OptionalRangeList '=' Value
1809 std::vector<LetRecord> TGParser::ParseLetList() {
1810 std::vector<LetRecord> Result;
1813 if (Lex.getCode() != tgtok::Id) {
1814 TokError("expected identifier in let definition");
1815 return std::vector<LetRecord>();
1817 std::string Name = Lex.getCurStrVal();
1818 SMLoc NameLoc = Lex.getLoc();
1819 Lex.Lex(); // Eat the identifier.
1821 // Check for an optional RangeList.
1822 std::vector<unsigned> Bits;
1823 if (ParseOptionalRangeList(Bits))
1824 return std::vector<LetRecord>();
1825 std::reverse(Bits.begin(), Bits.end());
1827 if (Lex.getCode() != tgtok::equal) {
1828 TokError("expected '=' in let expression");
1829 return std::vector<LetRecord>();
1831 Lex.Lex(); // eat the '='.
1833 Init *Val = ParseValue(0);
1834 if (Val == 0) return std::vector<LetRecord>();
1836 // Now that we have everything, add the record.
1837 Result.push_back(LetRecord(Name, Bits, Val, NameLoc));
1839 if (Lex.getCode() != tgtok::comma)
1841 Lex.Lex(); // eat the comma.
1845 /// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of
1846 /// different related productions. This works inside multiclasses too.
1848 /// Object ::= LET LetList IN '{' ObjectList '}'
1849 /// Object ::= LET LetList IN Object
1851 bool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) {
1852 assert(Lex.getCode() == tgtok::Let && "Unexpected token");
1855 // Add this entry to the let stack.
1856 std::vector<LetRecord> LetInfo = ParseLetList();
1857 if (LetInfo.empty()) return true;
1858 LetStack.push_back(LetInfo);
1860 if (Lex.getCode() != tgtok::In)
1861 return TokError("expected 'in' at end of top-level 'let'");
1864 // If this is a scalar let, just handle it now
1865 if (Lex.getCode() != tgtok::l_brace) {
1866 // LET LetList IN Object
1867 if (ParseObject(CurMultiClass))
1869 } else { // Object ::= LETCommand '{' ObjectList '}'
1870 SMLoc BraceLoc = Lex.getLoc();
1871 // Otherwise, this is a group let.
1872 Lex.Lex(); // eat the '{'.
1874 // Parse the object list.
1875 if (ParseObjectList(CurMultiClass))
1878 if (Lex.getCode() != tgtok::r_brace) {
1879 TokError("expected '}' at end of top level let command");
1880 return Error(BraceLoc, "to match this '{'");
1885 // Outside this let scope, this let block is not active.
1886 LetStack.pop_back();
1890 /// ParseMultiClass - Parse a multiclass definition.
1892 /// MultiClassInst ::= MULTICLASS ID TemplateArgList?
1893 /// ':' BaseMultiClassList '{' MultiClassDef+ '}'
1895 bool TGParser::ParseMultiClass() {
1896 assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token");
1897 Lex.Lex(); // Eat the multiclass token.
1899 if (Lex.getCode() != tgtok::Id)
1900 return TokError("expected identifier after multiclass for name");
1901 std::string Name = Lex.getCurStrVal();
1903 if (MultiClasses.count(Name))
1904 return TokError("multiclass '" + Name + "' already defined");
1906 CurMultiClass = MultiClasses[Name] = new MultiClass(Name,
1907 Lex.getLoc(), Records);
1908 Lex.Lex(); // Eat the identifier.
1910 // If there are template args, parse them.
1911 if (Lex.getCode() == tgtok::less)
1912 if (ParseTemplateArgList(0))
1915 bool inherits = false;
1917 // If there are submulticlasses, parse them.
1918 if (Lex.getCode() == tgtok::colon) {
1923 // Read all of the submulticlasses.
1924 SubMultiClassReference SubMultiClass =
1925 ParseSubMultiClassReference(CurMultiClass);
1928 if (SubMultiClass.MC == 0) return true;
1931 if (AddSubMultiClass(CurMultiClass, SubMultiClass))
1934 if (Lex.getCode() != tgtok::comma) break;
1935 Lex.Lex(); // eat ','.
1936 SubMultiClass = ParseSubMultiClassReference(CurMultiClass);
1940 if (Lex.getCode() != tgtok::l_brace) {
1942 return TokError("expected '{' in multiclass definition");
1943 else if (Lex.getCode() != tgtok::semi)
1944 return TokError("expected ';' in multiclass definition");
1946 Lex.Lex(); // eat the ';'.
1948 if (Lex.Lex() == tgtok::r_brace) // eat the '{'.
1949 return TokError("multiclass must contain at least one def");
1951 while (Lex.getCode() != tgtok::r_brace) {
1952 switch (Lex.getCode()) {
1954 return TokError("expected 'let', 'def' or 'defm' in multiclass body");
1958 if (ParseObject(CurMultiClass))
1963 Lex.Lex(); // eat the '}'.
1971 InstantiateMulticlassDef(MultiClass &MC,
1974 SMLoc DefmPrefixLoc) {
1975 // We need to preserve DefProto so it can be reused for later
1976 // instantiations, so create a new Record to inherit from it.
1978 // Add in the defm name. If the defm prefix is empty, give each
1979 // instantiated def a unique name. Otherwise, if "#NAME#" exists in the
1980 // name, substitute the prefix for #NAME#. Otherwise, use the defm name
1982 StringInit *DefNameString =
1983 dynamic_cast<StringInit *>(DefProto->getNameInit());
1985 if (DefNameString == 0) {
1986 Error(DefmPrefixLoc, "Def name is not a string");
1990 if (DefmPrefix == 0)
1991 DefmPrefix = StringInit::get(GetNewAnonymousName());
1993 Init *DefName = DefProto->getNameInit();
1995 // See if we can substitute #NAME#.
1997 TernOpInit::get(TernOpInit::SUBST,
1998 StringInit::get("#NAME#"),
2001 StringRecTy::get())->Fold(DefProto, &MC);
2003 if (NewDefName == DefName) {
2004 // We did't do any substitution. We should concatenate the given
2006 if (DefmPrefix == 0)
2007 DefmPrefix = StringInit::get(GetNewAnonymousName());
2010 BinOpInit::get(BinOpInit::STRCONCAT,
2011 UnOpInit::get(UnOpInit::CAST, DefmPrefix,
2012 StringRecTy::get())->Fold(DefProto, &MC),
2013 DefName, StringRecTy::get())->Fold(DefProto, &MC);
2016 DefName = NewDefName;
2018 Record *CurRec = new Record(DefName, DefmPrefixLoc, Records);
2020 SubClassReference Ref;
2021 Ref.RefLoc = DefmPrefixLoc;
2023 AddSubClass(CurRec, Ref);
2025 if (DefNameString == 0) {
2026 // We must resolve references to NAME.
2027 if (SetValue(CurRec, Ref.RefLoc, "NAME", std::vector<unsigned>(),
2029 Error(DefmPrefixLoc, "Could not resolve "
2030 + CurRec->getNameInitAsString() + ":NAME to '"
2031 + DefmPrefix->getAsUnquotedString() + "'");
2035 RecordVal *DefNameRV = CurRec->getValue("NAME");
2036 CurRec->resolveReferencesTo(DefNameRV);
2039 if (!CurMultiClass) {
2040 // We do this after resolving NAME because before resolution, many
2041 // multiclass defs will have the same name expression. If we are
2042 // currently in a multiclass, it means this defm appears inside a
2043 // multiclass and its name won't be fully resolvable until we see
2044 // the top-level defm. Therefore, we don't add this to the
2045 // RecordKeeper at this point. If we did we could get duplicate
2046 // defs as more than one probably refers to NAME or some other
2047 // common internal placeholder.
2049 // Ensure redefinition doesn't happen.
2050 if (Records.getDef(CurRec->getNameInitAsString())) {
2051 Error(DefmPrefixLoc, "def '" + CurRec->getNameInitAsString() +
2052 "' already defined, instantiating defm with subdef '" +
2053 DefProto->getNameInitAsString() + "'");
2057 Records.addDef(CurRec);
2063 bool TGParser::ResolveMulticlassDefArgs(MultiClass &MC,
2065 SMLoc DefmPrefixLoc,
2067 const std::vector<Init *> &TArgs,
2068 std::vector<Init *> &TemplateVals,
2070 // Loop over all of the template arguments, setting them to the specified
2071 // value or leaving them as the default if necessary.
2072 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
2073 // Check if a value is specified for this temp-arg.
2074 if (i < TemplateVals.size()) {
2076 if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(),
2081 CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i]));
2085 CurRec->removeValue(TArgs[i]);
2087 } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
2088 return Error(SubClassLoc, "value not specified for template argument #"+
2089 utostr(i) + " (" + TArgs[i]->getAsUnquotedString()
2090 + ") of multiclassclass '" + MC.Rec.getNameInitAsString()
2097 bool TGParser::ResolveMulticlassDef(MultiClass &MC,
2100 SMLoc DefmPrefixLoc) {
2101 // If the mdef is inside a 'let' expression, add to each def.
2102 for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
2103 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
2104 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
2105 LetStack[i][j].Bits, LetStack[i][j].Value))
2106 return Error(DefmPrefixLoc, "when instantiating this defm");
2108 // Don't create a top level definition for defm inside multiclasses,
2109 // instead, only update the prototypes and bind the template args
2110 // with the new created definition.
2111 if (CurMultiClass) {
2112 for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size();
2114 if (CurMultiClass->DefPrototypes[i]->getNameInit()
2115 == CurRec->getNameInit())
2116 return Error(DefmPrefixLoc, "defm '" + CurRec->getNameInitAsString() +
2117 "' already defined in this multiclass!");
2118 CurMultiClass->DefPrototypes.push_back(CurRec);
2120 // Copy the template arguments for the multiclass into the new def.
2121 const std::vector<Init *> &TA =
2122 CurMultiClass->Rec.getTemplateArgs();
2124 for (unsigned i = 0, e = TA.size(); i != e; ++i) {
2125 const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]);
2126 assert(RV && "Template arg doesn't exist?");
2127 CurRec->addValue(*RV);
2134 /// ParseDefm - Parse the instantiation of a multiclass.
2136 /// DefMInst ::= DEFM ID ':' DefmSubClassRef ';'
2138 bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
2139 assert(Lex.getCode() == tgtok::Defm && "Unexpected token!");
2141 Init *DefmPrefix = 0;
2143 if (Lex.Lex() == tgtok::Id) { // eat the defm.
2144 DefmPrefix = ParseObjectName(CurMultiClass);
2147 SMLoc DefmPrefixLoc = Lex.getLoc();
2148 if (Lex.getCode() != tgtok::colon)
2149 return TokError("expected ':' after defm identifier");
2151 // Keep track of the new generated record definitions.
2152 std::vector<Record*> NewRecDefs;
2154 // This record also inherits from a regular class (non-multiclass)?
2155 bool InheritFromClass = false;
2160 SMLoc SubClassLoc = Lex.getLoc();
2161 SubClassReference Ref = ParseSubClassReference(0, true);
2164 if (Ref.Rec == 0) return true;
2166 // To instantiate a multiclass, we need to first get the multiclass, then
2167 // instantiate each def contained in the multiclass with the SubClassRef
2168 // template parameters.
2169 MultiClass *MC = MultiClasses[Ref.Rec->getName()];
2170 assert(MC && "Didn't lookup multiclass correctly?");
2171 std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
2173 // Verify that the correct number of template arguments were specified.
2174 const std::vector<Init *> &TArgs = MC->Rec.getTemplateArgs();
2175 if (TArgs.size() < TemplateVals.size())
2176 return Error(SubClassLoc,
2177 "more template args specified than multiclass expects");
2179 // Loop over all the def's in the multiclass, instantiating each one.
2180 for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) {
2181 Record *DefProto = MC->DefPrototypes[i];
2183 Record *CurRec = InstantiateMulticlassDef(*MC, DefProto, DefmPrefix, DefmPrefixLoc);
2185 if (ResolveMulticlassDefArgs(*MC, CurRec, DefmPrefixLoc, SubClassLoc,
2186 TArgs, TemplateVals, true/*Delete args*/))
2187 return Error(SubClassLoc, "could not instantiate def");
2189 if (ResolveMulticlassDef(*MC, CurRec, DefProto, DefmPrefixLoc))
2190 return Error(SubClassLoc, "could not instantiate def");
2192 NewRecDefs.push_back(CurRec);
2196 if (Lex.getCode() != tgtok::comma) break;
2197 Lex.Lex(); // eat ','.
2199 SubClassLoc = Lex.getLoc();
2201 // A defm can inherit from regular classes (non-multiclass) as
2202 // long as they come in the end of the inheritance list.
2203 InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0);
2205 if (InheritFromClass)
2208 Ref = ParseSubClassReference(0, true);
2211 if (InheritFromClass) {
2212 // Process all the classes to inherit as if they were part of a
2213 // regular 'def' and inherit all record values.
2214 SubClassReference SubClass = ParseSubClassReference(0, false);
2217 if (SubClass.Rec == 0) return true;
2219 // Get the expanded definition prototypes and teach them about
2220 // the record values the current class to inherit has
2221 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) {
2222 Record *CurRec = NewRecDefs[i];
2225 if (AddSubClass(CurRec, SubClass))
2228 // Process any variables on the let stack.
2229 for (unsigned i = 0, e = LetStack.size(); i != e; ++i)
2230 for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j)
2231 if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name,
2232 LetStack[i][j].Bits, LetStack[i][j].Value))
2236 if (Lex.getCode() != tgtok::comma) break;
2237 Lex.Lex(); // eat ','.
2238 SubClass = ParseSubClassReference(0, false);
2243 for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i)
2244 // See Record::setName(). This resolve step will see any new
2245 // name for the def that might have been created when resolving
2246 // inheritance, values and arguments above.
2247 NewRecDefs[i]->resolveReferences();
2249 if (Lex.getCode() != tgtok::semi)
2250 return TokError("expected ';' at end of defm");
2257 /// Object ::= ClassInst
2258 /// Object ::= DefInst
2259 /// Object ::= MultiClassInst
2260 /// Object ::= DefMInst
2261 /// Object ::= LETCommand '{' ObjectList '}'
2262 /// Object ::= LETCommand Object
2263 bool TGParser::ParseObject(MultiClass *MC) {
2264 switch (Lex.getCode()) {
2266 return TokError("Expected class, def, defm, multiclass or let definition");
2267 case tgtok::Let: return ParseTopLevelLet(MC);
2268 case tgtok::Def: return ParseDef(MC);
2269 case tgtok::Defm: return ParseDefm(MC);
2270 case tgtok::Class: return ParseClass();
2271 case tgtok::MultiClass: return ParseMultiClass();
2276 /// ObjectList :== Object*
2277 bool TGParser::ParseObjectList(MultiClass *MC) {
2278 while (isObjectStart(Lex.getCode())) {
2279 if (ParseObject(MC))
2285 bool TGParser::ParseFile() {
2286 Lex.Lex(); // Prime the lexer.
2287 if (ParseObjectList()) return true;
2289 // If we have unread input at the end of the file, report it.
2290 if (Lex.getCode() == tgtok::Eof)
2293 return TokError("Unexpected input at top level");