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