TGParser.cpp revision 6da674cda1587c9b09e01f65219cec54f54d90b8
1f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===- TGParser.cpp - Parser for TableGen Files ---------------------------===// 2f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// 3f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// The LLVM Compiler Infrastructure 4f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// 53060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// This file is distributed under the University of Illinois Open Source 63060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// License. See LICENSE.TXT for details. 7f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// 8f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 9f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// 10f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// Implement the Parser for TableGen. 11f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// 12f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 13f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 14f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner#include "TGParser.h" 157c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Record.h" 16f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner#include "llvm/ADT/StringExtras.h" 171a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include <algorithm> 181a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include <sstream> 198d978a75b477c0e4861d937096518eebba639e72Chris Lattner#include "llvm/ADT/SmallVector.h" 2046f55527d848bcc7cff1210137caff29bbf1b010Chris Lattner#include "llvm/Support/CommandLine.h" 21f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerusing namespace llvm; 22f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 23f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 24f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// Support Code for the Semantic Actions. 25f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 26f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 27f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnernamespace llvm { 28f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerstruct SubClassReference { 291e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc RefLoc; 30f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *Rec; 3105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> TemplateArgs; 321c8ae59dfdc85d917db0333ae0b93e2be4ca6c36Chris Lattner SubClassReference() : Rec(0) {} 33d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 34f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner bool isInvalid() const { return Rec == 0; } 35f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner}; 36de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 37de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greenestruct SubMultiClassReference { 381e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc RefLoc; 39de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene MultiClass *MC; 4005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> TemplateArgs; 41de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SubMultiClassReference() : MC(0) {} 4232558650ae09247b31aa89cdee64e8c849771024Bob Wilson 43de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene bool isInvalid() const { return MC == 0; } 44d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene void dump() const; 45de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene}; 46d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 47d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid SubMultiClassReference::dump() const { 481a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Multiclass:\n"; 4921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 50d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene MC->dump(); 5121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 521a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Template args:\n"; 5305bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(), 54d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene iend = TemplateArgs.end(); 55d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene i != iend; 56d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++i) { 57d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*i)->dump(); 58d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 59d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 60d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 61f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} // end namespace llvm 62f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 631e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattnerbool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { 64f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec == 0) 65f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec = &CurMultiClass->Rec; 6621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 67f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (RecordVal *ERV = CurRec->getValue(RV.getName())) { 68f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // The value already exists in the class, treat this as a set. 69f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ERV->setValue(RV.getValue())) 70f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(Loc, "New definition of '" + RV.getName() + "' of type '" + 71f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner RV.getType()->getAsString() + "' is incompatible with " + 7221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson "previous definition of type '" + 73f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner ERV->getType()->getAsString() + "'"); 74f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { 75f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->addValue(RV); 76f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 77f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 78f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 79f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 80f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SetValue - 81f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Return true on error, false on success. 8221870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonbool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName, 8305bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<unsigned> &BitList, Init *V) { 84f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!V) return false; 85f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 86f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec == 0) CurRec = &CurMultiClass->Rec; 87f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 88f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner RecordVal *RV = CurRec->getValue(ValName); 89f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (RV == 0) 90f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(Loc, "Value '" + ValName + "' unknown!"); 91f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 92f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Do not allow assignments like 'X = X'. This will just cause infinite loops 93f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // in the resolution machinery. 94f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (BitList.empty()) 9505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (VarInit *VI = dynamic_cast<VarInit*>(V)) 96f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (VI->getName() == ValName) 97f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 9821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 99f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If we are assigning to a subset of the bits in the value... then we must be 100f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // assigning to a field of BitsRecTy, which must have a BitsInit 101f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // initializer. 102f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // 103f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!BitList.empty()) { 10405bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue()); 105f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurVal == 0) 106f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(Loc, "Value '" + ValName + "' is not a bits type"); 107f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 108f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Convert the incoming value to a bits type of the appropriate size... 10905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size())); 110f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (BI == 0) { 11177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen V->convertInitializerTo(BitsRecTy::get(BitList.size())); 112f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(Loc, "Initializer is not compatible with bit range"); 113f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 11421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 115f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // We should have a BitsInit type now. 11605bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *BInit = dynamic_cast<BitsInit*>(BI); 117f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(BInit != 0); 118f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 11905bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); 120f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 121f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Loop over bits, assigning values as appropriate. 122f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = BitList.size(); i != e; ++i) { 123f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner unsigned Bit = BitList[i]; 124ca7fd3de360b266783438666054dba198ff77ba2David Greene if (NewBits[Bit]) 125f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" + 126f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner ValName + "' more than once"); 127ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[Bit] = BInit->getBit(i); 128f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 129f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 130f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i) 131ca7fd3de360b266783438666054dba198ff77ba2David Greene if (NewBits[i] == 0) 132ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = CurVal->getBit(i); 133f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 134dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene V = BitsInit::get(NewBits); 135f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 136f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 137f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (RV->setValue(V)) 13821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Error(Loc, "Value '" + ValName + "' of type '" + 13921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson RV->getType()->getAsString() + 1405d814864133fd3be4414a043341508bcc2caa7b5Chris Lattner "' is incompatible with initializer '" + V->getAsString() +"'"); 141f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 142f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 143f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 144f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template 145f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// args as SubClass's template arguments. 146aff9c270de8de7d1a0bc138d391bc67136bad58eCedric Venetbool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { 147f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *SC = SubClass.Rec; 148f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add all of the values in the subclass into the current class. 149f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner const std::vector<RecordVal> &Vals = SC->getValues(); 150f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 151f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (AddValue(CurRec, SubClass.RefLoc, Vals[i])) 152f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 153f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 154f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner const std::vector<std::string> &TArgs = SC->getTemplateArgs(); 155f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 156f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Ensure that an appropriate number of template arguments are specified. 157f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (TArgs.size() < SubClass.TemplateArgs.size()) 158f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(SubClass.RefLoc, "More template args specified than expected"); 15921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 160f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Loop over all of the template arguments, setting them to the specified 161f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // value or leaving them as the default if necessary. 162f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 163f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (i < SubClass.TemplateArgs.size()) { 164f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If a value is specified for this template arg, set it now. 16521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson if (SetValue(CurRec, SubClass.RefLoc, TArgs[i], std::vector<unsigned>(), 166f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClass.TemplateArgs[i])) 167f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 16821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 169f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Resolve it next. 170f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 17121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 172f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Now remove it. 173f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->removeValue(TArgs[i]); 174f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 175f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 176f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(SubClass.RefLoc,"Value not specified for template argument #" 17721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson + utostr(i) + " (" + TArgs[i] + ") of subclass '" + 178f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SC->getName() + "'!"); 179f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 180f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 181f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 182f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Since everything went well, we can now set the "superclass" list for the 183f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // current record. 184f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner const std::vector<Record*> &SCs = SC->getSuperClasses(); 185f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = SCs.size(); i != e; ++i) { 186f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec->isSubClassOf(SCs[i])) 187f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(SubClass.RefLoc, 188f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner "Already subclass of '" + SCs[i]->getName() + "'!\n"); 189f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->addSuperClass(SCs[i]); 190f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 19121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 192f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec->isSubClassOf(SC)) 193f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(SubClass.RefLoc, 194f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner "Already subclass of '" + SC->getName() + "'!\n"); 195f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->addSuperClass(SC); 196f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 197f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 198f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 199de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// AddSubMultiClass - Add SubMultiClass as a subclass to 200440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson/// CurMC, resolving its template args as SubMultiClass's 201de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// template arguments. 202440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilsonbool TGParser::AddSubMultiClass(MultiClass *CurMC, 2031d512df4a9e249ceb6d6b69e89527c75d872ecd1Bob Wilson SubMultiClassReference &SubMultiClass) { 204de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene MultiClass *SMC = SubMultiClass.MC; 205440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson Record *CurRec = &CurMC->Rec; 206de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 207440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson const std::vector<RecordVal> &MCVals = CurRec->getValues(); 208de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 209de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Add all of the values in the subclass into the current class. 210de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene const std::vector<RecordVal> &SMCVals = SMC->Rec.getValues(); 211de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene for (unsigned i = 0, e = SMCVals.size(); i != e; ++i) 212de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (AddValue(CurRec, SubMultiClass.RefLoc, SMCVals[i])) 213de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return true; 214de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 215440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson int newDefStart = CurMC->DefPrototypes.size(); 216d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 217de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Add all of the defs in the subclass into the current multiclass. 218de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene for (MultiClass::RecordVector::const_iterator i = SMC->DefPrototypes.begin(), 219de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene iend = SMC->DefPrototypes.end(); 220de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene i != iend; 221de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene ++i) { 222de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Clone the def and add it to the current multiclass 223de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Record *NewDef = new Record(**i); 224de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 225de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Add all of the values in the superclass into the current def. 226de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene for (unsigned i = 0, e = MCVals.size(); i != e; ++i) 227de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (AddValue(NewDef, SubMultiClass.RefLoc, MCVals[i])) 228de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return true; 229de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 230440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson CurMC->DefPrototypes.push_back(NewDef); 231de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 23232558650ae09247b31aa89cdee64e8c849771024Bob Wilson 233de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene const std::vector<std::string> &SMCTArgs = SMC->Rec.getTemplateArgs(); 234de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 235d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // Ensure that an appropriate number of template arguments are 236d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // specified. 237de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size()) 238d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene return Error(SubMultiClass.RefLoc, 239d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene "More template args specified than expected"); 24032558650ae09247b31aa89cdee64e8c849771024Bob Wilson 241de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Loop over all of the template arguments, setting them to the specified 242de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // value or leaving them as the default if necessary. 243de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) { 244de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (i < SubMultiClass.TemplateArgs.size()) { 245d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // If a value is specified for this template arg, set it in the 246d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // superclass now. 247d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene if (SetValue(CurRec, SubMultiClass.RefLoc, SMCTArgs[i], 24832558650ae09247b31aa89cdee64e8c849771024Bob Wilson std::vector<unsigned>(), 249de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SubMultiClass.TemplateArgs[i])) 250de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return true; 251de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 252de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Resolve it next. 253de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene CurRec->resolveReferencesTo(CurRec->getValue(SMCTArgs[i])); 25432558650ae09247b31aa89cdee64e8c849771024Bob Wilson 255de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Now remove it. 256de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene CurRec->removeValue(SMCTArgs[i]); 257de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 258d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // If a value is specified for this template arg, set it in the 259d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene // new defs now. 260d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (MultiClass::RecordVector::iterator j = 261440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson CurMC->DefPrototypes.begin() + newDefStart, 262440548dd1f78682e372a38cacccf7c5ac1781b2cBob Wilson jend = CurMC->DefPrototypes.end(); 263de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene j != jend; 264de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene ++j) { 265de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Record *Def = *j; 266de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 267d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene if (SetValue(Def, SubMultiClass.RefLoc, SMCTArgs[i], 26832558650ae09247b31aa89cdee64e8c849771024Bob Wilson std::vector<unsigned>(), 269de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SubMultiClass.TemplateArgs[i])) 270de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return true; 271de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 272de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Resolve it next. 273de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Def->resolveReferencesTo(Def->getValue(SMCTArgs[i])); 274de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 275de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Now remove it 276de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Def->removeValue(SMCTArgs[i]); 277de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 278de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } else if (!CurRec->getValue(SMCTArgs[i])->getValue()->isComplete()) { 279d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene return Error(SubMultiClass.RefLoc, 280d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene "Value not specified for template argument #" 28132558650ae09247b31aa89cdee64e8c849771024Bob Wilson + utostr(i) + " (" + SMCTArgs[i] + ") of subclass '" + 282de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SMC->Rec.getName() + "'!"); 283de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 284de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 285de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 286de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return false; 287de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene} 288de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 289f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 290f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner// Parser Code 291f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner//===----------------------------------------------------------------------===// 292f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 293f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// isObjectStart - Return true if this is a valid first token for an Object. 294f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerstatic bool isObjectStart(tgtok::TokKind K) { 295f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return K == tgtok::Class || K == tgtok::Def || 29621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson K == tgtok::Defm || K == tgtok::Let || K == tgtok::MultiClass; 297f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 298f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 299df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattnerstatic std::string GetNewAnonymousName() { 300df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner static unsigned AnonCounter = 0; 301df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner return "anonymous."+utostr(AnonCounter++); 302df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner} 303df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner 304f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseObjectName - If an object name is specified, return it. Otherwise, 305f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// return an anonymous name. 306f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ObjectName ::= ID 307f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ObjectName ::= /*empty*/ 308f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 309f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerstd::string TGParser::ParseObjectName() { 310df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner if (Lex.getCode() != tgtok::Id) 311df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner return GetNewAnonymousName(); 312c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 313df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner std::string Ret = Lex.getCurStrVal(); 314df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner Lex.Lex(); 315df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner return Ret; 316f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 317f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 318f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 319f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseClassID - Parse and resolve a reference to a class name. This returns 320f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// null on error. 321f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 322f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ClassID ::= ID 323f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 324f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerRecord *TGParser::ParseClassID() { 325f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) { 326f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected name for ClassID"); 327f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 328f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 32921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 330f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *Result = Records.getClass(Lex.getCurStrVal()); 331f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result == 0) 332f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); 33321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 334f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 335f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 336f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 337f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 33832558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// ParseMultiClassID - Parse and resolve a reference to a multiclass name. 33932558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// This returns null on error. 340de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// 341de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// MultiClassID ::= ID 342de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// 343de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid GreeneMultiClass *TGParser::ParseMultiClassID() { 344de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() != tgtok::Id) { 345de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene TokError("expected name for ClassID"); 346de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return 0; 347de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 34832558650ae09247b31aa89cdee64e8c849771024Bob Wilson 349de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene MultiClass *Result = MultiClasses[Lex.getCurStrVal()]; 350de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Result == 0) 351de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene TokError("Couldn't find class '" + Lex.getCurStrVal() + "'"); 35232558650ae09247b31aa89cdee64e8c849771024Bob Wilson 353de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Lex.Lex(); 354de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 355de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene} 356de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 357f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerRecord *TGParser::ParseDefmID() { 358f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) { 359f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected multiclass name"); 360f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 361f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 36221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 363f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner MultiClass *MC = MultiClasses[Lex.getCurStrVal()]; 364f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (MC == 0) { 365f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'"); 366f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 367f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 36821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 369f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 370f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return &MC->Rec; 37121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson} 372f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 373f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 374f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseSubClassReference - Parse a reference to a subclass or to a templated 375f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// subclass. This returns a SubClassRefTy with a null Record* on error. 376f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 377f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SubClassRef ::= ClassID 378f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SubClassRef ::= ClassID '<' ValueList '>' 379f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 380f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerSubClassReference TGParser:: 381f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerParseSubClassReference(Record *CurRec, bool isDefm) { 382f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClassReference Result; 383f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.RefLoc = Lex.getLoc(); 38421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 385f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (isDefm) 386f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.Rec = ParseDefmID(); 387f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner else 388f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.Rec = ParseClassID(); 389f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result.Rec == 0) return Result; 39021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 391f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If there is no template arg list, we're done. 392f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::less) 393f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 394f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat the '<' 39521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 396f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::greater) { 397f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("subclass reference requires a non-empty list of template values"); 398f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.Rec = 0; 399f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 400f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 40121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 402e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Result.TemplateArgs = ParseValueList(CurRec, Result.Rec); 403f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result.TemplateArgs.empty()) { 404f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.Rec = 0; // Error parsing value list. 405f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 406f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 40721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 408f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::greater) { 409f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '>' in template value list"); 410f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.Rec = 0; 411f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 412f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 413f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 41421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 415f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 416f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 417f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 41832558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// ParseSubMultiClassReference - Parse a reference to a subclass or to a 41932558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// templated submulticlass. This returns a SubMultiClassRefTy with a null 42032558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// Record* on error. 421de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// 422de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// SubMultiClassRef ::= MultiClassID 423de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// SubMultiClassRef ::= MultiClassID '<' ValueList '>' 424de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene/// 425de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid GreeneSubMultiClassReference TGParser:: 426de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid GreeneParseSubMultiClassReference(MultiClass *CurMC) { 427de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SubMultiClassReference Result; 428de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Result.RefLoc = Lex.getLoc(); 42932558650ae09247b31aa89cdee64e8c849771024Bob Wilson 430de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Result.MC = ParseMultiClassID(); 431de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Result.MC == 0) return Result; 43232558650ae09247b31aa89cdee64e8c849771024Bob Wilson 433de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // If there is no template arg list, we're done. 434de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() != tgtok::less) 435de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 436de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Lex.Lex(); // Eat the '<' 43732558650ae09247b31aa89cdee64e8c849771024Bob Wilson 438de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() == tgtok::greater) { 439de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene TokError("subclass reference requires a non-empty list of template values"); 440de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Result.MC = 0; 441de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 442de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 44332558650ae09247b31aa89cdee64e8c849771024Bob Wilson 444e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Result.TemplateArgs = ParseValueList(&CurMC->Rec, &Result.MC->Rec); 445de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Result.TemplateArgs.empty()) { 446de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Result.MC = 0; // Error parsing value list. 447de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 448de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 44932558650ae09247b31aa89cdee64e8c849771024Bob Wilson 450de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() != tgtok::greater) { 451de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene TokError("expected '>' in template value list"); 452de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Result.MC = 0; 453de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 454de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 455de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Lex.Lex(); 456de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 457de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return Result; 458de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene} 459de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 460f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseRangePiece - Parse a bit/value range. 461f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// RangePiece ::= INTVAL 462f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// RangePiece ::= INTVAL '-' INTVAL 463f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// RangePiece ::= INTVAL INTVAL 464f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseRangePiece(std::vector<unsigned> &Ranges) { 465811281e788432d3136de13f72d05790eced52d92Chris Lattner if (Lex.getCode() != tgtok::IntVal) { 466811281e788432d3136de13f72d05790eced52d92Chris Lattner TokError("expected integer or bitrange"); 467811281e788432d3136de13f72d05790eced52d92Chris Lattner return true; 468811281e788432d3136de13f72d05790eced52d92Chris Lattner } 46963f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Start = Lex.getCurIntVal(); 47063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t End; 47121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 472f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Start < 0) 473f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("invalid range, cannot be negative"); 47421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 475f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner switch (Lex.Lex()) { // eat first character. 47621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson default: 477f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Ranges.push_back(Start); 478f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 479f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::minus: 480f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::IntVal) { 481f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected integer value as end of range"); 482f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 483f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 484f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner End = Lex.getCurIntVal(); 485f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner break; 486f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::IntVal: 487f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner End = -Lex.getCurIntVal(); 488f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner break; 489f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 49021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson if (End < 0) 491f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("invalid range, cannot be negative"); 492f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 49321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 494f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add to the range. 495f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Start < End) { 496f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (; Start <= End; ++Start) 497f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Ranges.push_back(Start); 498f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { 499f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (; Start >= End; --Start) 500f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Ranges.push_back(Start); 501f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 502f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 503f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 504f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 505f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseRangeList - Parse a list of scalars and ranges into scalar values. 506f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 507f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// RangeList ::= RangePiece (',' RangePiece)* 508f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 509f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerstd::vector<unsigned> TGParser::ParseRangeList() { 510f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<unsigned> Result; 51121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 512f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the first piece. 513f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseRangePiece(Result)) 514f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return std::vector<unsigned>(); 515f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (Lex.getCode() == tgtok::comma) { 516f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat the comma. 517f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 518f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the next range piece. 519f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseRangePiece(Result)) 520f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return std::vector<unsigned>(); 521f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 522f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 523f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 524f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 525f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseOptionalRangeList - Parse either a range list in <>'s or nothing. 526f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// OptionalRangeList ::= '<' RangeList '>' 527f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// OptionalRangeList ::= /*empty*/ 528f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseOptionalRangeList(std::vector<unsigned> &Ranges) { 529f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::less) 530f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 53121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 5321e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc StartLoc = Lex.getLoc(); 533f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '<' 53421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 535f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the range list. 536f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Ranges = ParseRangeList(); 537f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Ranges.empty()) return true; 53821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 539f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::greater) { 540f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '>' at end of range list"); 541f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(StartLoc, "to match this '<'"); 542f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 543f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '>'. 544f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 545f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 546f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 547f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseOptionalBitList - Parse either a bit list in {}'s or nothing. 548f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// OptionalBitList ::= '{' RangeList '}' 549f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// OptionalBitList ::= /*empty*/ 550f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseOptionalBitList(std::vector<unsigned> &Ranges) { 551f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::l_brace) 552f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 55321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 5541e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc StartLoc = Lex.getLoc(); 555f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '{' 55621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 557f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the range list. 558f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Ranges = ParseRangeList(); 559f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Ranges.empty()) return true; 56021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 561f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_brace) { 562f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '}' at end of bit list"); 563f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(StartLoc, "to match this '{'"); 564f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 565f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '}'. 566f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 567f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 568f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 569f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 570f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseType - Parse and return a tblgen type. This returns null on error. 571f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 572f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= STRING // string type 573f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= BIT // bit type 574f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= BITS '<' INTVAL '>' // bits<x> type 575f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= INT // int type 576f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= LIST '<' Type '>' // list<x> type 577f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= CODE // code type 578f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= DAG // dag type 579f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Type ::= ClassID // Record Type 580f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 581f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerRecTy *TGParser::ParseType() { 582f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner switch (Lex.getCode()) { 583f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner default: TokError("Unknown token when expecting a type"); return 0; 58477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::String: Lex.Lex(); return StringRecTy::get(); 58577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::Bit: Lex.Lex(); return BitRecTy::get(); 58677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::Int: Lex.Lex(); return IntRecTy::get(); 58777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::Code: Lex.Lex(); return CodeRecTy::get(); 58877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::Dag: Lex.Lex(); return DagRecTy::get(); 589f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::Id: 59077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (Record *R = ParseClassID()) return RecordRecTy::get(R); 591f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 592f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::Bits: { 593f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::less) { // Eat 'bits' 594f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '<' after bits type"); 595f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 596f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 597f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::IntVal) { // Eat '<' 598f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected integer in bits<n> type"); 599f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 600f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 60163f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman uint64_t Val = Lex.getCurIntVal(); 602f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::greater) { // Eat count. 603f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '>' at end of bits<n> type"); 604f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 605f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 606f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat '>' 60777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return BitsRecTy::get(Val); 608f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 609f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::List: { 610f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::less) { // Eat 'bits' 611f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '<' after list type"); 612f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 613f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 614f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat '<' 615f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner RecTy *SubType = ParseType(); 616f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (SubType == 0) return 0; 61721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 618f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::greater) { 619f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '>' at end of list<ty> type"); 620f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 621f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 622f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat '>' 62377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return ListRecTy::get(SubType); 624f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 62521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 626f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 627f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 628f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseIDValue - Parse an ID as a value and decode what it means. 629f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 630f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// IDValue ::= ID [def local value] 631f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// IDValue ::= ID [def template arg] 632f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// IDValue ::= ID [multiclass local value] 633f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// IDValue ::= ID [multiclass template argument] 634f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// IDValue ::= ID [def name] 635f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 63605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TGParser::ParseIDValue(Record *CurRec) { 637f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue"); 638f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string Name = Lex.getCurStrVal(); 6391e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc Loc = Lex.getLoc(); 640f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 641f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ParseIDValue(CurRec, Name, Loc); 642f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 643f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 644f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID 645f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// has already been read. 64605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TGParser::ParseIDValue(Record *CurRec, 6471e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner const std::string &Name, SMLoc NameLoc) { 648f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec) { 649f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (const RecordVal *RV = CurRec->getValue(Name)) 650dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 65121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 652f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string TemplateArgName = CurRec->getName()+":"+Name; 653f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec->isTemplateArg(TemplateArgName)) { 654f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner const RecordVal *RV = CurRec->getValue(TemplateArgName); 655f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(RV && "Template arg doesn't exist??"); 656dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 657f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 658f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 65921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 660f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurMultiClass) { 661f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string MCName = CurMultiClass->Rec.getName()+"::"+Name; 662f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurMultiClass->Rec.isTemplateArg(MCName)) { 663f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 664f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(RV && "Template arg doesn't exist??"); 665dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 666f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 667f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 66821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 669f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Record *D = Records.getDef(Name)) 67077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 671f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 672f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(NameLoc, "Variable not defined: '" + Name + "'"); 673f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 674f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 675f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 676d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// ParseOperation - Parse an operator. This returns null on error. 677d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 678d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// Operation ::= XOperator ['<' Type '>'] '(' Args ')' 679d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 68005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TGParser::ParseOperation(Record *CurRec) { 681d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene switch (Lex.getCode()) { 682d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene default: 683d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("unknown operation"); 684d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 685d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene break; 6861434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XHead: 6871434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XTail: 6881434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XEmpty: 689e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case tgtok::XCast: { // Value ::= !unop '(' Value ')' 690e6c27de069225e1122c78385ad22a2ff656db8e6David Greene UnOpInit::UnaryOp Code; 691e6c27de069225e1122c78385ad22a2ff656db8e6David Greene RecTy *Type = 0; 692d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 693e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Lex.getCode()) { 694e6c27de069225e1122c78385ad22a2ff656db8e6David Greene default: assert(0 && "Unhandled code!"); 695e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case tgtok::XCast: 696e6c27de069225e1122c78385ad22a2ff656db8e6David Greene Lex.Lex(); // eat the operation 697e6c27de069225e1122c78385ad22a2ff656db8e6David Greene Code = UnOpInit::CAST; 698d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 699e6c27de069225e1122c78385ad22a2ff656db8e6David Greene Type = ParseOperatorType(); 700d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 701e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (Type == 0) { 7025f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene TokError("did not get type for unary operator"); 703e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 704e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 705d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 706e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 7071434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XHead: 7085f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Lex.Lex(); // eat the operation 7091434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene Code = UnOpInit::HEAD; 7105f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7111434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XTail: 7125f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Lex.Lex(); // eat the operation 7131434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene Code = UnOpInit::TAIL; 7145f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7151434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XEmpty: 7165f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Lex.Lex(); // eat the operation 7171434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene Code = UnOpInit::EMPTY; 71877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Type = IntRecTy::get(); 7195f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 720e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 721e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (Lex.getCode() != tgtok::l_paren) { 722e6c27de069225e1122c78385ad22a2ff656db8e6David Greene TokError("expected '(' after unary operator"); 723e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 724e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 725e6c27de069225e1122c78385ad22a2ff656db8e6David Greene Lex.Lex(); // eat the '(' 726d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 72705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS = ParseValue(CurRec); 728e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS == 0) return 0; 729d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 7301434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene if (Code == UnOpInit::HEAD 7311434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene || Code == UnOpInit::TAIL 7321434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene || Code == UnOpInit::EMPTY) { 73305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 73405bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 73505bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); 736e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSl == 0 && LHSs == 0 && LHSt == 0) { 737e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("expected list or string type argument in unary operator"); 7385f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7395f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7405f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSt) { 7415f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType()); 742e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene StringRecTy *SType = dynamic_cast<StringRecTy*>(LHSt->getType()); 743e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LType == 0 && SType == 0) { 744e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("expected list or string type argumnet in unary operator"); 7455f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7465f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7475f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7485f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene 7491434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene if (Code == UnOpInit::HEAD 7501434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene || Code == UnOpInit::TAIL) { 751e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSl == 0 && LHSt == 0) { 752e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("expected list type argumnet in unary operator"); 753e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 754e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 75521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 7565f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl && LHSl->getSize() == 0) { 7575f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene TokError("empty list argument in unary operator"); 7585f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7595f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7605f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 76105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = LHSl->getElement(0); 76205bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *Itemt = dynamic_cast<TypedInit*>(Item); 7635f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (Itemt == 0) { 7645f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene TokError("untyped list element in unary operator"); 7655f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7665f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7671434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene if (Code == UnOpInit::HEAD) { 7685f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Type = Itemt->getType(); 76921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 77077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Type = ListRecTy::get(Itemt->getType()); 7715f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 77221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7735f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(LHSt && "expected list type argument in unary operator"); 7745f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene ListRecTy *LType = dynamic_cast<ListRecTy*>(LHSt->getType()); 7755f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LType == 0) { 7765f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene TokError("expected list type argumnet in unary operator"); 7775f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7785f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7791434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene if (Code == UnOpInit::HEAD) { 7805f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Type = LType->getElementType(); 78121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7825f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene Type = LType; 7835f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7845f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7855f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7865f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7875f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene 788e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (Lex.getCode() != tgtok::r_paren) { 789e6c27de069225e1122c78385ad22a2ff656db8e6David Greene TokError("expected ')' in unary operator"); 790e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 791e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 792e6c27de069225e1122c78385ad22a2ff656db8e6David Greene Lex.Lex(); // eat the ')' 793dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass); 794e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 795d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 796d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene case tgtok::XConcat: 79721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case tgtok::XSRA: 798d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene case tgtok::XSRL: 799d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene case tgtok::XSHL: 8006786d5e18387465d6106eaef0b7923526ef0bc10David Greene case tgtok::XEq: 801c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner case tgtok::XStrConcat: { // Value ::= !binop '(' Value ',' Value ')' 8028d978a75b477c0e4861d937096518eebba639e72Chris Lattner tgtok::TokKind OpTok = Lex.getCode(); 8038d978a75b477c0e4861d937096518eebba639e72Chris Lattner SMLoc OpLoc = Lex.getLoc(); 8048d978a75b477c0e4861d937096518eebba639e72Chris Lattner Lex.Lex(); // eat the operation 8058d978a75b477c0e4861d937096518eebba639e72Chris Lattner 806d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene BinOpInit::BinaryOp Code; 807d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene RecTy *Type = 0; 808d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 8098d978a75b477c0e4861d937096518eebba639e72Chris Lattner switch (OpTok) { 810d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene default: assert(0 && "Unhandled code!"); 81177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break; 81277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::XSRA: Code = BinOpInit::SRA; Type = IntRecTy::get(); break; 81377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::XSRL: Code = BinOpInit::SRL; Type = IntRecTy::get(); break; 81477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::XSHL: Code = BinOpInit::SHL; Type = IntRecTy::get(); break; 81577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen case tgtok::XEq: Code = BinOpInit::EQ; Type = BitRecTy::get(); break; 81621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case tgtok::XStrConcat: 817d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Code = BinOpInit::STRCONCAT; 81877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Type = StringRecTy::get(); 819d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene break; 820d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 821c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 822d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Lex.getCode() != tgtok::l_paren) { 823d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("expected '(' after binary operator"); 824d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 825d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 826d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Lex.Lex(); // eat the '(' 827d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 82805bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init*, 2> InitList; 829c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 8308d978a75b477c0e4861d937096518eebba639e72Chris Lattner InitList.push_back(ParseValue(CurRec)); 8318d978a75b477c0e4861d937096518eebba639e72Chris Lattner if (InitList.back() == 0) return 0; 832d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 8338d978a75b477c0e4861d937096518eebba639e72Chris Lattner while (Lex.getCode() == tgtok::comma) { 8348d978a75b477c0e4861d937096518eebba639e72Chris Lattner Lex.Lex(); // eat the ',' 83521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8368d978a75b477c0e4861d937096518eebba639e72Chris Lattner InitList.push_back(ParseValue(CurRec)); 8378d978a75b477c0e4861d937096518eebba639e72Chris Lattner if (InitList.back() == 0) return 0; 8388d978a75b477c0e4861d937096518eebba639e72Chris Lattner } 839d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 840d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Lex.getCode() != tgtok::r_paren) { 8418d978a75b477c0e4861d937096518eebba639e72Chris Lattner TokError("expected ')' in operator"); 842d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 843d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 844d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Lex.Lex(); // eat the ')' 8458d978a75b477c0e4861d937096518eebba639e72Chris Lattner 8468d978a75b477c0e4861d937096518eebba639e72Chris Lattner // We allow multiple operands to associative operators like !strconcat as 8478d978a75b477c0e4861d937096518eebba639e72Chris Lattner // shorthand for nesting them. 8488d978a75b477c0e4861d937096518eebba639e72Chris Lattner if (Code == BinOpInit::STRCONCAT) { 8498d978a75b477c0e4861d937096518eebba639e72Chris Lattner while (InitList.size() > 2) { 85005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *RHS = InitList.pop_back_val(); 851dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type)) 852dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ->Fold(CurRec, CurMultiClass); 8538d978a75b477c0e4861d937096518eebba639e72Chris Lattner InitList.back() = RHS; 8548d978a75b477c0e4861d937096518eebba639e72Chris Lattner } 8558d978a75b477c0e4861d937096518eebba639e72Chris Lattner } 856c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 8578d978a75b477c0e4861d937096518eebba639e72Chris Lattner if (InitList.size() == 2) 858dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(Code, InitList[0], InitList[1], Type)) 8598d978a75b477c0e4861d937096518eebba639e72Chris Lattner ->Fold(CurRec, CurMultiClass); 860c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 8618d978a75b477c0e4861d937096518eebba639e72Chris Lattner Error(OpLoc, "expected two operands to operator"); 8628d978a75b477c0e4861d937096518eebba639e72Chris Lattner return 0; 863d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 864d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 8659bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case tgtok::XIf: 866beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene case tgtok::XForEach: 8674afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 8684afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TernOpInit::TernaryOp Code; 8694afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene RecTy *Type = 0; 8704afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 8714afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene tgtok::TokKind LexCode = Lex.getCode(); 8724afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Lex.Lex(); // eat the operation 8734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (LexCode) { 8744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene default: assert(0 && "Unhandled code!"); 8759bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case tgtok::XIf: 8769bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene Code = TernOpInit::IF; 8779bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 878beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene case tgtok::XForEach: 879beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Code = TernOpInit::FOREACH; 880beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene break; 8814afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case tgtok::XSubst: 8824afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Code = TernOpInit::SUBST; 8834afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 8844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 8854afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (Lex.getCode() != tgtok::l_paren) { 8864afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TokError("expected '(' after ternary operator"); 8874afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return 0; 8884afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 8894afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Lex.Lex(); // eat the '(' 8904afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 89105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS = ParseValue(CurRec); 8924afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS == 0) return 0; 8934afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 8944afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (Lex.getCode() != tgtok::comma) { 8954afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TokError("expected ',' in ternary operator"); 8964afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return 0; 8974afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 8984afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Lex.Lex(); // eat the ',' 89921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 90005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *MHS = ParseValue(CurRec); 9014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (MHS == 0) return 0; 9024afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 9034afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (Lex.getCode() != tgtok::comma) { 9044afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TokError("expected ',' in ternary operator"); 9054afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return 0; 9064afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 9074afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Lex.Lex(); // eat the ',' 90821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 90905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *RHS = ParseValue(CurRec); 9104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHS == 0) return 0; 9114afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 9124afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (Lex.getCode() != tgtok::r_paren) { 9134afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TokError("expected ')' in binary operator"); 9144afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return 0; 9154afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 9164afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Lex.Lex(); // eat the ')' 9174afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 9184afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (LexCode) { 9194afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene default: assert(0 && "Unhandled code!"); 9209bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case tgtok::XIf: { 921548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling // FIXME: The `!if' operator doesn't handle non-TypedInit well at 922548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling // all. This can be made much more robust. 92305bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS); 92405bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS); 925548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 926548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling RecTy *MHSTy = 0; 927548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling RecTy *RHSTy = 0; 928548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 929548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSt == 0 && RHSt == 0) { 93005bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS); 93105bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS); 932548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 933548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSbits && RHSbits && 934548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling MHSbits->getNumBits() == RHSbits->getNumBits()) { 93577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Type = BitRecTy::get(); 936548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling break; 937548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } else { 93805bce0beee87512e52428d4b80f5a8e79a949576David Greene BitInit *MHSbit = dynamic_cast<BitInit*>(MHS); 93905bce0beee87512e52428d4b80f5a8e79a949576David Greene BitInit *RHSbit = dynamic_cast<BitInit*>(RHS); 940548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 941548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSbit && RHSbit) { 94277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Type = BitRecTy::get(); 943548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling break; 944548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 945548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 946548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } else if (MHSt != 0 && RHSt != 0) { 947548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling MHSTy = MHSt->getType(); 948548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling RHSTy = RHSt->getType(); 949548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 950548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 951548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (!MHSTy || !RHSTy) { 9529bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene TokError("could not get type for !if"); 9539bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return 0; 9549bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 955548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 956548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSTy->typeIsConvertibleTo(RHSTy)) { 957548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling Type = RHSTy; 958548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } else if (RHSTy->typeIsConvertibleTo(MHSTy)) { 959548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling Type = MHSTy; 96021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 9619bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene TokError("inconsistent types for !if"); 9629bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return 0; 9639bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 9649bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 9659bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 966beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene case tgtok::XForEach: { 96705bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS); 968beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSt == 0) { 969beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene TokError("could not get type for !foreach"); 970beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 971beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 972beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Type = MHSt->getType(); 973beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene break; 974beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 9754afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case tgtok::XSubst: { 97605bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS); 9774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSt == 0) { 9784afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TokError("could not get type for !subst"); 9794afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return 0; 9804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 9814afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Type = RHSt->getType(); 9824afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 9834afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 9844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 985dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec, 98621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson CurMultiClass); 9874afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 988d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 989d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("could not parse operation"); 990d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 991d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 992d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 993d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// ParseOperatorType - Parse a type for an operator. This returns 994d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// null on error. 995d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 996d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// OperatorType ::= '<' Type '>' 997d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 998a9ad04191cb56c42944b17980b8b2bb2afe11ab2Dan GohmanRecTy *TGParser::ParseOperatorType() { 999d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene RecTy *Type = 0; 1000d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1001d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Lex.getCode() != tgtok::less) { 1002d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("expected type name for operator"); 1003d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 1004d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1005d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Lex.Lex(); // eat the < 1006d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1007d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Type = ParseType(); 1008d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1009d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Type == 0) { 1010d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("expected type name for operator"); 1011d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 1012d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1013d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1014d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Lex.getCode() != tgtok::greater) { 1015d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene TokError("expected type name for operator"); 1016d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 1017d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1018d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene Lex.Lex(); // eat the > 1019d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1020d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return Type; 1021d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 1022d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1023d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1024f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseSimpleValue - Parse a tblgen value. This returns null on error. 1025f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1026f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= IDValue 1027f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= INTVAL 1028d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner/// SimpleValue ::= STRVAL+ 1029f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= CODEFRAGMENT 1030f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= '?' 1031f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= '{' ValueList '}' 1032f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= ID '<' ValueListNE '>' 1033f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= '[' ValueList ']' 1034f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= '(' IDValue DagArgList ')' 1035f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= CONCATTOK '(' Value ',' Value ')' 1036f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= SHLTOK '(' Value ',' Value ')' 1037f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= SRATOK '(' Value ',' Value ')' 1038f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= SRLTOK '(' Value ',' Value ')' 1039f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' 1040f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 104105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { 104205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = 0; 1043f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner switch (Lex.getCode()) { 1044f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner default: TokError("Unknown token when parsing a value"); break; 1045dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break; 1046d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner case tgtok::StrVal: { 1047d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner std::string Val = Lex.getCurStrVal(); 1048d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner Lex.Lex(); 104921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1050da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Handle multiple consecutive concatenated strings. 1051d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner while (Lex.getCode() == tgtok::StrVal) { 1052d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner Val += Lex.getCurStrVal(); 1053d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner Lex.Lex(); 1054d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner } 105521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1056dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene R = StringInit::get(Val); 1057d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner break; 1058d7a50cf28c48d44cee0aa4c5abe2dce359a10727Chris Lattner } 1059f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::CodeFragment: 1060dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene R = CodeInit::get(Lex.getCurStrVal()); 1061578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner Lex.Lex(); 1062578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner break; 1063578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner case tgtok::question: 1064dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene R = UnsetInit::get(); 1065578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner Lex.Lex(); 1066578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner break; 1067f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::Id: { 10681e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc NameLoc = Lex.getLoc(); 1069f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string Name = Lex.getCurStrVal(); 1070f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::less) // consume the Id. 1071f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ParseIDValue(CurRec, Name, NameLoc); // Value ::= IDValue 107221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1073f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Value ::= ID '<' ValueListNE '>' 1074f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() == tgtok::greater) { 1075f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected non-empty value list"); 1076f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1077f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1078e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1079f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // This is a CLASS<initvalslist> expression. This is supposed to synthesize 1080f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // a new anonymous definition, deriving from CLASS<initvalslist> with no 1081f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // body. 1082f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *Class = Records.getClass(Name); 1083f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!Class) { 1084f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(NameLoc, "Expected a class name, got '" + Name + "'"); 1085f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1086f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1087e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 108805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ValueList = ParseValueList(CurRec, Class); 1089e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ValueList.empty()) return 0; 109021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1091e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Lex.getCode() != tgtok::greater) { 1092e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("expected '>' at end of value list"); 1093e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1094e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1095e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Lex.Lex(); // eat the '>' 109621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1097f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Create the new record, set it as CurRec temporarily. 1098f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner static unsigned AnonCounter = 0; 10999c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner Record *NewRec = new Record("anonymous.val."+utostr(AnonCounter++), 11009c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner NameLoc, 11019c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner Records); 1102f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClassReference SCRef; 1103f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SCRef.RefLoc = NameLoc; 1104f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SCRef.Rec = Class; 1105f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SCRef.TemplateArgs = ValueList; 1106f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add info about the subclass to NewRec. 1107f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (AddSubClass(NewRec, SCRef)) 1108f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1109f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner NewRec->resolveReferences(); 1110f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Records.addDef(NewRec); 111121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1112f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // The result of the expression is a reference to the new record. 111377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(NewRec); 111421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 1115f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::l_brace: { // Value ::= '{' ValueList '}' 11161e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc BraceLoc = Lex.getLoc(); 1117f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '{' 111805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 111921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1120f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_brace) { 1121f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Vals = ParseValueList(CurRec); 1122f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Vals.empty()) return 0; 1123f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1124f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_brace) { 1125f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '}' at end of bit list value"); 1126f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1127f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1128f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '}' 112921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 113005bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Vals.size()); 1131ca7fd3de360b266783438666054dba198ff77ba2David Greene 1132f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) { 113305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); 1134f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Bit == 0) { 11355d814864133fd3be4414a043341508bcc2caa7b5Chris Lattner Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ 11365d814864133fd3be4414a043341508bcc2caa7b5Chris Lattner ") is not convertable to a bit"); 1137f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1138f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1139ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[Vals.size()-i-1] = Bit; 1140f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1141dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1142f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1143f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::l_square: { // Value ::= '[' ValueList ']' 1144f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '[' 114505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 114621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1147e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *DeducedEltTy = 0; 1148e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ListRecTy *GivenListTy = 0; 114921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1150e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ItemType != 0) { 1151e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ListRecTy *ListType = dynamic_cast<ListRecTy*>(ItemType); 1152e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ListType == 0) { 1153e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene std::stringstream s; 115421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson s << "Type mismatch for list, expected list type, got " 1155e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene << ItemType->getAsString(); 1156e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError(s.str()); 11576a44adade20bdea80c76b68833ec5eff5baaba98Jim Grosbach return 0; 1158e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1159e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene GivenListTy = ListType; 116021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 1161e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1162f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_square) { 116321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Vals = ParseValueList(CurRec, 0, 116421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson GivenListTy ? GivenListTy->getElementType() : 0); 1165f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Vals.empty()) return 0; 1166f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1167f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_square) { 1168f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected ']' at end of list value"); 1169f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1170f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1171f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the ']' 1172e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1173e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *GivenEltTy = 0; 1174e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Lex.getCode() == tgtok::less) { 1175e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // Optional list element type 1176e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Lex.Lex(); // eat the '<' 1177e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1178e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene GivenEltTy = ParseType(); 1179e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (GivenEltTy == 0) { 1180e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // Couldn't parse element type 1181e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1182e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1183e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1184e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Lex.getCode() != tgtok::greater) { 1185e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("expected '>' at end of list element type"); 1186e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1187e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1188e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Lex.Lex(); // eat the '>' 1189e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1190e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1191e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // Check elements 1192e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *EltTy = 0; 119305bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); 1194e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene i != ie; 1195e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ++i) { 119605bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *TArg = dynamic_cast<TypedInit*>(*i); 1197e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (TArg == 0) { 1198e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("Untyped list element"); 1199e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1200e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1201e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (EltTy != 0) { 1202e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene EltTy = resolveTypes(EltTy, TArg->getType()); 1203e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (EltTy == 0) { 1204e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("Incompatible types in list elements"); 1205e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1206e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 120721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1208e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene EltTy = TArg->getType(); 1209e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1210e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1211e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1212e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (GivenEltTy != 0) { 1213e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (EltTy != 0) { 1214e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // Verify consistency 1215e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (!EltTy->typeIsConvertibleTo(GivenEltTy)) { 1216e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("Incompatible types in list elements"); 1217e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1218e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1219e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1220e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene EltTy = GivenEltTy; 1221e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1222e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1223e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (EltTy == 0) { 1224e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ItemType == 0) { 1225e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("No type for list"); 1226e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1227e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1228e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene DeducedEltTy = GivenListTy->getElementType(); 122921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1230e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // Make sure the deduced type is compatible with the given type 1231e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (GivenListTy) { 1232e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (!EltTy->typeIsConvertibleTo(GivenListTy->getElementType())) { 1233e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene TokError("Element type mismatch for list"); 1234e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 1235e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1236e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1237e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene DeducedEltTy = EltTy; 1238e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 123921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1240dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Vals, DeducedEltTy); 1241f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1242f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')' 1243f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '(' 1244c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) { 12453dc2e96eec566f8c4e88a34296d6f10b840d7d1eChris Lattner TokError("expected identifier in dag init"); 12463dc2e96eec566f8c4e88a34296d6f10b840d7d1eChris Lattner return 0; 12473dc2e96eec566f8c4e88a34296d6f10b840d7d1eChris Lattner } 124821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 124905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Operator = ParseValue(CurRec); 1250578bcf0e48ab5858eeb8870839fa2946b6edd4b4Chris Lattner if (Operator == 0) return 0; 1251c7cafcd815519b06318629b424abe746437e1389David Greene 12527cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman // If the operator name is present, parse it. 12537cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman std::string OperatorName; 12547cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (Lex.getCode() == tgtok::colon) { 12557cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (Lex.Lex() != tgtok::VarName) { // eat the ':' 12567cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman TokError("expected variable name in dag operator"); 12577cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman return 0; 12587cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman } 12597cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman OperatorName = Lex.getCurStrVal(); 12607cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Lex.Lex(); // eat the VarName. 12617cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman } 126221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 126305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<llvm::Init*, std::string> > DagArgs; 1264f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_paren) { 1265f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner DagArgs = ParseDagArgList(CurRec); 1266f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (DagArgs.empty()) return 0; 1267f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 126821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1269f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_paren) { 1270f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected ')' in dag init"); 1271f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1272f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1273f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the ')' 127421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1275dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Operator, OperatorName, DagArgs); 1276f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 127721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 12781434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XHead: 12791434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XTail: 12801434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case tgtok::XEmpty: 1281e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case tgtok::XCast: // Value ::= !unop '(' Value ')' 1282f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::XConcat: 128321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case tgtok::XSRA: 1284f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::XSRL: 1285f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::XSHL: 12866786d5e18387465d6106eaef0b7923526ef0bc10David Greene case tgtok::XEq: 1287c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner case tgtok::XStrConcat: // Value ::= !binop '(' Value ',' Value ')' 12889bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case tgtok::XIf: 1289beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene case tgtok::XForEach: 12904afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')' 1291d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return ParseOperation(CurRec); 1292f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1293f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 129421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1295f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return R; 1296f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1297f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1298f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseValue - Parse a tblgen value. This returns null on error. 1299f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1300f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Value ::= SimpleValue ValueSuffix* 1301f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ValueSuffix ::= '{' BitList '}' 1302f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ValueSuffix ::= '[' BitList ']' 1303f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ValueSuffix ::= '.' ID 1304f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 130505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) { 130605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ParseSimpleValue(CurRec, ItemType); 1307f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result == 0) return 0; 130821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1309f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the suffixes now if present. 1310f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (1) { 1311f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner switch (Lex.getCode()) { 1312f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner default: return Result; 1313f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::l_brace: { 13141e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc CurlyLoc = Lex.getLoc(); 1315f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '{' 1316f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<unsigned> Ranges = ParseRangeList(); 1317f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Ranges.empty()) return 0; 131821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1319f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Reverse the bitlist. 1320f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::reverse(Ranges.begin(), Ranges.end()); 1321f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result = Result->convertInitializerBitRange(Ranges); 1322f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result == 0) { 1323f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(CurlyLoc, "Invalid bit range for value"); 1324f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1325f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 132621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1327f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Eat the '}'. 1328f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_brace) { 1329f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '}' at end of bit range list"); 1330f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1331f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1332f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1333f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner break; 1334f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1335f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::l_square: { 13361e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc SquareLoc = Lex.getLoc(); 1337f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '[' 1338f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<unsigned> Ranges = ParseRangeList(); 1339f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Ranges.empty()) return 0; 134021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1341f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result = Result->convertInitListSlice(Ranges); 1342f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Result == 0) { 1343f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(SquareLoc, "Invalid range for list slice"); 1344f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1345f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 134621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1347f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Eat the ']'. 1348f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_square) { 1349f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected ']' at end of list slice"); 1350f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1351f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1352f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1353f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner break; 1354f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1355f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::period: 1356f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::Id) { // eat the . 1357f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected field identifier after '.'"); 1358f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1359f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1360f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!Result->getFieldType(Lex.getCurStrVal())) { 1361f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" + 13625d814864133fd3be4414a043341508bcc2caa7b5Chris Lattner Result->getAsString() + "'"); 1363f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return 0; 1364f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1365dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Result = FieldInit::get(Result, Lex.getCurStrVal()); 1366f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat field name 1367f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner break; 1368f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1369f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1370f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1371f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1372f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDagArgList - Parse the argument list for a dag literal expression. 1373f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1374f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDagArgList ::= Value (':' VARNAME)? 1375f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)? 137605bce0beee87512e52428d4b80f5a8e79a949576David Greenestd::vector<std::pair<llvm::Init*, std::string> > 1377f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris LattnerTGParser::ParseDagArgList(Record *CurRec) { 137805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<llvm::Init*, std::string> > Result; 137921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1380f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (1) { 138105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = ParseValue(CurRec); 138205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >(); 138321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1384f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If the variable name is present, add it. 1385f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string VarName; 1386f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::colon) { 1387f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::VarName) { // eat the ':' 1388f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected variable name in dag literal"); 138905bce0beee87512e52428d4b80f5a8e79a949576David Greene return std::vector<std::pair<llvm::Init*, std::string> >(); 1390f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1391f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner VarName = Lex.getCurStrVal(); 1392f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the VarName. 1393f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 139421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1395f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.push_back(std::make_pair(Val, VarName)); 139621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1397f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::comma) break; 139821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Lex.Lex(); // eat the ',' 1399f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 140021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1401f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 1402f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1403f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1404f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1405f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseValueList - Parse a comma separated list of values, returning them as a 1406f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// vector. Note that this always expects to be able to parse at least one 1407f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// value. It returns an empty list if this is not possible. 1408f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1409f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ValueList ::= Value (',' Value) 1410f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 141105bce0beee87512e52428d4b80f5a8e79a949576David Greenestd::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, 1412d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher RecTy *EltTy) { 141305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Result; 1414e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *ItemType = EltTy; 141567acdf2977595a1d9755bf919d678f80ee65364fDavid Greene unsigned int ArgN = 0; 1416e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ArgsRec != 0 && EltTy == 0) { 1417e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs(); 1418e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1419d9746fe58ace4a8625983da1ecf68c0564883616David Greene if (!RV) { 1420d9746fe58ace4a8625983da1ecf68c0564883616David Greene errs() << "Cannot find template arg " << ArgN << " (" << TArgs[ArgN] 1421d9746fe58ace4a8625983da1ecf68c0564883616David Greene << ")\n"; 1422d9746fe58ace4a8625983da1ecf68c0564883616David Greene } 1423e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene assert(RV && "Template argument record not found??"); 1424e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ItemType = RV->getType(); 1425e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ++ArgN; 1426e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1427e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Result.push_back(ParseValue(CurRec, ItemType)); 142805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Result.back() == 0) return std::vector<Init*>(); 142921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1430f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (Lex.getCode() == tgtok::comma) { 1431f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat the comma 143221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1433e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (ArgsRec != 0 && EltTy == 0) { 1434e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs(); 143567acdf2977595a1d9755bf919d678f80ee65364fDavid Greene if (ArgN >= TArgs.size()) { 143667acdf2977595a1d9755bf919d678f80ee65364fDavid Greene TokError("too many template arguments"); 143705bce0beee87512e52428d4b80f5a8e79a949576David Greene return std::vector<Init*>(); 143821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 1439e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); 1440e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene assert(RV && "Template argument record not found??"); 1441e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ItemType = RV->getType(); 1442e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ++ArgN; 1443e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 1444e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene Result.push_back(ParseValue(CurRec, ItemType)); 144505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Result.back() == 0) return std::vector<Init*>(); 1446f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 144721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1448f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 1449f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1450f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1451f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1452f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDeclaration - Read a declaration, returning the name of field ID, or an 1453f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// empty string on error. This can happen in a number of different context's, 1454f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// including within a def or in the template args for a def (which which case 1455f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// CurRec will be non-null) and within the template args for a multiclass (in 1456f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// which case CurRec will be null, but CurMultiClass will be set). This can 1457f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// also happen within a def that is within a multiclass, which will set both 1458f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// CurRec and CurMultiClass. 1459f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1460f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Declaration ::= FIELD? Type ID ('=' Value)? 1461f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 146221870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::string TGParser::ParseDeclaration(Record *CurRec, 1463f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner bool ParsingTemplateArgs) { 1464f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Read the field prefix if present. 1465f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner bool HasField = Lex.getCode() == tgtok::Field; 1466f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (HasField) Lex.Lex(); 146721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1468f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner RecTy *Type = ParseType(); 1469f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Type == 0) return ""; 147021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1471f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) { 1472f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("Expected identifier in declaration"); 1473f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ""; 1474f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 147521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 14761e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc IdLoc = Lex.getLoc(); 1477f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string DeclName = Lex.getCurStrVal(); 1478f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 147921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1480f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParsingTemplateArgs) { 1481f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec) { 1482f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner DeclName = CurRec->getName() + ":" + DeclName; 1483f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { 1484f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(CurMultiClass); 1485f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1486f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurMultiClass) 1487f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner DeclName = CurMultiClass->Rec.getName() + "::" + DeclName; 1488f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 148921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1490f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add the value. 1491f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (AddValue(CurRec, IdLoc, RecordVal(DeclName, Type, HasField))) 1492f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ""; 149321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1494f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If a value is present, parse it. 1495f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::equal) { 1496f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 14971e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc ValLoc = Lex.getLoc(); 149805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = ParseValue(CurRec, Type); 1499f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Val == 0 || 1500f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val)) 1501f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ""; 1502f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 150321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1504f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return DeclName; 1505f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1506f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1507f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseTemplateArgList - Read a template argument list, which is a non-empty 1508f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// sequence of template-declarations in <>'s. If CurRec is non-null, these are 1509f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// template args for a def, which may or may not be in a multiclass. If null, 1510f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// these are the template args for a multiclass. 1511f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1512f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// TemplateArgList ::= '<' Declaration (',' Declaration)* '>' 151321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// 1514f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseTemplateArgList(Record *CurRec) { 1515f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::less && "Not a template arg list!"); 1516f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '<' 151721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1518f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec; 151921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1520f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Read the first declaration. 1521f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1522f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (TemplArg.empty()) 1523f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 152421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1525f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TheRecToAddTo->addTemplateArg(TemplArg); 152621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1527f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (Lex.getCode() == tgtok::comma) { 1528f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the ',' 152921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1530f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Read the following declarations. 1531f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TemplArg = ParseDeclaration(CurRec, true/*templateargs*/); 1532f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (TemplArg.empty()) 1533f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1534f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TheRecToAddTo->addTemplateArg(TemplArg); 1535f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 153621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1537f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::greater) 1538f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected '>' at end of template argument list"); 1539f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '>'. 1540f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 1541f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1542f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1543f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1544f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseBodyItem - Parse a single item at within the body of a def or class. 1545f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1546f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BodyItem ::= Declaration ';' 1547f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BodyItem ::= LET ID OptionalBitList '=' Value ';' 1548f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseBodyItem(Record *CurRec) { 1549f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Let) { 155021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson if (ParseDeclaration(CurRec, false).empty()) 1551f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 155221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1553f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::semi) 1554f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected ';' after declaration"); 1555f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1556f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 1557f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1558f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1559f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // LET ID OptionalRangeList '=' Value ';' 1560f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.Lex() != tgtok::Id) 1561f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected field identifier after let"); 156221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 15631e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc IdLoc = Lex.getLoc(); 1564f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string FieldName = Lex.getCurStrVal(); 1565f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the field name. 156621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1567f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<unsigned> BitList; 156821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson if (ParseOptionalBitList(BitList)) 1569f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1570f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::reverse(BitList.begin(), BitList.end()); 157121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1572f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::equal) 1573f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected '=' in let expression"); 1574f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '='. 157521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1576e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecordVal *Field = CurRec->getValue(FieldName); 1577e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Field == 0) 1578e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return TokError("Value '" + FieldName + "' unknown!"); 1579e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 1580e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *Type = Field->getType(); 158121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 158205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = ParseValue(CurRec, Type); 1583f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Val == 0) return true; 158421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1585f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::semi) 1586f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected ';' after let expression"); 1587f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 158821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1589f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return SetValue(CurRec, IdLoc, FieldName, BitList, Val); 1590f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1591f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1592f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseBody - Read the body of a class or def. Return true on error, false on 1593f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// success. 1594f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1595f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Body ::= ';' 1596f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Body ::= '{' BodyList '}' 1597f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BodyList BodyItem* 1598f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1599f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseBody(Record *CurRec) { 1600f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If this is a null definition, just eat the semi and return. 1601f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::semi) { 1602f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1603f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 1604f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 160521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1606f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::l_brace) 1607f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("Expected ';' or '{' to start body"); 1608f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Eat the '{'. 1609f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 161021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1611f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (Lex.getCode() != tgtok::r_brace) 1612f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseBodyItem(CurRec)) 1613f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1614f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1615f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Eat the '}'. 1616f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1617f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 1618f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1619f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1620f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseObjectBody - Parse the body of a def or class. This consists of an 1621f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// optional ClassList followed by a Body. CurRec is the current def or class 1622f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// that is being parsed. 1623f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1624f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ObjectBody ::= BaseClassList Body 1625f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BaseClassList ::= /*empty*/ 1626f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BaseClassList ::= ':' BaseClassListNE 1627f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// BaseClassListNE ::= SubClassRef (',' SubClassRef)* 1628f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1629f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseObjectBody(Record *CurRec) { 1630f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If there is a baseclass list, read it. 1631f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::colon) { 1632f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 163321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1634f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Read all of the subclasses. 1635f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClassReference SubClass = ParseSubClassReference(CurRec, false); 1636f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (1) { 1637f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Check for error. 1638f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (SubClass.Rec == 0) return true; 163921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1640f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add it. 1641f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (AddSubClass(CurRec, SubClass)) 1642f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 164321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1644f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::comma) break; 1645f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat ','. 1646f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClass = ParseSubClassReference(CurRec, false); 1647f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1648f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1649f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1650f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Process any variables on the let stack. 1651f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 1652f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 1653f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 1654f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner LetStack[i][j].Bits, LetStack[i][j].Value)) 1655f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 165621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1657f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ParseBody(CurRec); 1658f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1659f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1660f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDef - Parse and return a top level or multiclass def, return the record 1661f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// corresponding to it. This returns null on error. 1662f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1663f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// DefInst ::= DEF ObjectName ObjectBody 1664f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1665ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopesbool TGParser::ParseDef(MultiClass *CurMultiClass) { 16661e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc DefLoc = Lex.getLoc(); 1667f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::Def && "Unknown tok"); 166821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Lex.Lex(); // Eat the 'def' token. 1669f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1670f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse ObjectName and make a record for it. 16719c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner Record *CurRec = new Record(ParseObjectName(), DefLoc, Records); 167221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1673f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!CurMultiClass) { 1674f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Top-level def definition. 167521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1676f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Ensure redefinition doesn't happen. 1677f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Records.getDef(CurRec->getName())) { 1678f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(DefLoc, "def '" + CurRec->getName() + "' already defined"); 1679ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes return true; 1680f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1681f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Records.addDef(CurRec); 1682f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { 1683f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Otherwise, a def inside a multiclass, add it to the multiclass. 1684f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); i != e; ++i) 1685f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurMultiClass->DefPrototypes[i]->getName() == CurRec->getName()) { 1686f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Error(DefLoc, "def '" + CurRec->getName() + 1687f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner "' already defined in this multiclass!"); 1688ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes return true; 1689f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1690f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurMultiClass->DefPrototypes.push_back(CurRec); 1691f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 169221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1693f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseObjectBody(CurRec)) 1694ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes return true; 169521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1696f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurMultiClass == 0) // Def's in multiclasses aren't really defs. 16970d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // See Record::setName(). This resolve step will see any new name 16980d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // for the def that might have been created when resolving 16990d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // inheritance, values and arguments above. 1700f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurRec->resolveReferences(); 170121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1702f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If ObjectBody has template arguments, it's an error. 1703f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?"); 1704ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes 1705ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes if (CurMultiClass) { 1706ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes // Copy the template arguments for the multiclass into the def. 1707ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes const std::vector<std::string> &TArgs = 1708ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes CurMultiClass->Rec.getTemplateArgs(); 1709ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes 1710ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1711ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); 1712ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes assert(RV && "Template arg doesn't exist?"); 1713ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes CurRec->addValue(*RV); 1714ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes } 1715ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes } 1716ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes 1717ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes return false; 1718f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1719f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1720f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 17216da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// ParseMultiDef - Parse and return a multiclass multidef, return the record 17226da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// corresponding to it. This returns null on error. 17236da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// 17246da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// MultiDefInst ::= MULTIDEF ObjectName '<' Value ',' Declaration ',' 17256da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// Value '>' ObjectBody 17266da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// 17276da674cda1587c9b09e01f65219cec54f54d90b8David Greenebool TGParser::ParseMultiDef(MultiClass *CurMultiClass) { 17286da674cda1587c9b09e01f65219cec54f54d90b8David Greene assert(CurMultiClass && "No multiclass for multidef!"); 17296da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17306da674cda1587c9b09e01f65219cec54f54d90b8David Greene SMLoc DefLoc = Lex.getLoc(); 17316da674cda1587c9b09e01f65219cec54f54d90b8David Greene assert(Lex.getCode() == tgtok::MultiDef && "Unknown tok"); 17326da674cda1587c9b09e01f65219cec54f54d90b8David Greene Lex.Lex(); // Eat the 'multidef' token. 17336da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17346da674cda1587c9b09e01f65219cec54f54d90b8David Greene // Parse ObjectName and make a record for it. 17356da674cda1587c9b09e01f65219cec54f54d90b8David Greene Record *CurRec = new Record(ParseObjectName(), DefLoc, Records); 17366da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17376da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (Lex.getCode() != tgtok::less) 17386da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("multidef init requires a non-empty list of values"); 17396da674cda1587c9b09e01f65219cec54f54d90b8David Greene Lex.Lex(); // Eat the '<' 17406da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17416da674cda1587c9b09e01f65219cec54f54d90b8David Greene Init *ListI = ParseValue(CurRec, 0); 17426da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (ListI == 0) 17436da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("First multidef init must be of list type"); 17446da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17456da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (Lex.getCode() != tgtok::comma) 17466da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("expected comma in multidef"); 17476da674cda1587c9b09e01f65219cec54f54d90b8David Greene Lex.Lex(); // Eat the comma 17486da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17496da674cda1587c9b09e01f65219cec54f54d90b8David Greene std::string ItemName = ParseDeclaration(CurRec, false/*Not a template arg*/); 17506da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (ItemName.empty()) 17516da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("expected declaration in multidef"); 17526da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17536da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (Lex.getCode() != tgtok::comma) 17546da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("expected comma in multidef"); 17556da674cda1587c9b09e01f65219cec54f54d90b8David Greene Lex.Lex(); // Eat the comma 17566da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17576da674cda1587c9b09e01f65219cec54f54d90b8David Greene Init *IntI = ParseValue(CurRec, 0); 17586da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (IntI == 0) 17596da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("expected integer value in multidef"); 17606da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17616da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (Lex.getCode() != tgtok::greater) 17626da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("multidef init requires a non-empty list of values"); 17636da674cda1587c9b09e01f65219cec54f54d90b8David Greene Lex.Lex(); // Eat the '>' 17646da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17656da674cda1587c9b09e01f65219cec54f54d90b8David Greene TypedInit *List = dynamic_cast<TypedInit *>(ListI); 17666da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (dynamic_cast<ListRecTy *>(List->getType()) == 0) 17676da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("First multidef init must be of list type"); 17686da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17696da674cda1587c9b09e01f65219cec54f54d90b8David Greene IntInit *Int = dynamic_cast<IntInit *>(IntI); 17706da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (Int == 0) 17716da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("Second multidef init must be a constant integer"); 17726da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17736da674cda1587c9b09e01f65219cec54f54d90b8David Greene // Add it to the multiclass. 17746da674cda1587c9b09e01f65219cec54f54d90b8David Greene for (unsigned i = 0, e = CurMultiClass->MultiDefPrototypes.size(); 17756da674cda1587c9b09e01f65219cec54f54d90b8David Greene i != e; ++i) 17766da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (CurMultiClass->MultiDefPrototypes[i].Rec->getName() 17776da674cda1587c9b09e01f65219cec54f54d90b8David Greene == CurRec->getName()) 17786da674cda1587c9b09e01f65219cec54f54d90b8David Greene return Error(DefLoc, "multidef '" + CurRec->getName() + 17796da674cda1587c9b09e01f65219cec54f54d90b8David Greene "' already defined in this multiclass!"); 17806da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17816da674cda1587c9b09e01f65219cec54f54d90b8David Greene CurMultiClass->MultiDefPrototypes.push_back( 17826da674cda1587c9b09e01f65219cec54f54d90b8David Greene MultiClass::MultiDef(CurRec, List, Int, ItemName)); 17836da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17846da674cda1587c9b09e01f65219cec54f54d90b8David Greene if (ParseObjectBody(CurRec)) 17856da674cda1587c9b09e01f65219cec54f54d90b8David Greene return true; 17866da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17876da674cda1587c9b09e01f65219cec54f54d90b8David Greene // If ObjectBody has template arguments, it's an error. 17886da674cda1587c9b09e01f65219cec54f54d90b8David Greene assert(CurRec->getTemplateArgs().empty() && "How'd this get template args?"); 17896da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17906da674cda1587c9b09e01f65219cec54f54d90b8David Greene // Copy the template arguments for the multiclass into the 17916da674cda1587c9b09e01f65219cec54f54d90b8David Greene // multidef. 17926da674cda1587c9b09e01f65219cec54f54d90b8David Greene const std::vector<std::string> &TArgs = CurMultiClass->Rec.getTemplateArgs(); 17936da674cda1587c9b09e01f65219cec54f54d90b8David Greene 17946da674cda1587c9b09e01f65219cec54f54d90b8David Greene for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 17956da674cda1587c9b09e01f65219cec54f54d90b8David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(TArgs[i]); 17966da674cda1587c9b09e01f65219cec54f54d90b8David Greene assert(RV && "Template arg doesn't exist?"); 17976da674cda1587c9b09e01f65219cec54f54d90b8David Greene CurRec->addValue(*RV); 17986da674cda1587c9b09e01f65219cec54f54d90b8David Greene } 17996da674cda1587c9b09e01f65219cec54f54d90b8David Greene 18006da674cda1587c9b09e01f65219cec54f54d90b8David Greene return false; 18016da674cda1587c9b09e01f65219cec54f54d90b8David Greene} 18026da674cda1587c9b09e01f65219cec54f54d90b8David Greene 18036da674cda1587c9b09e01f65219cec54f54d90b8David Greene 1804f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseClass - Parse a tblgen class definition. 1805f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1806f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ClassInst ::= CLASS ID TemplateArgList? ObjectBody 1807f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1808f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseClass() { 1809f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::Class && "Unexpected token!"); 1810f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 181121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1812f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) 1813f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected class name after 'class' keyword"); 181421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1815f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Record *CurRec = Records.getClass(Lex.getCurStrVal()); 1816f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (CurRec) { 1817f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If the body was previously defined, this is an error. 1818f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (!CurRec->getValues().empty() || 1819f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner !CurRec->getSuperClasses().empty() || 1820f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner !CurRec->getTemplateArgs().empty()) 1821f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("Class '" + CurRec->getName() + "' already defined"); 1822f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { 1823f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If this is the first reference to this class, create and add it. 18249c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner CurRec = new Record(Lex.getCurStrVal(), Lex.getLoc(), Records); 1825f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Records.addClass(CurRec); 1826f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1827f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the name. 182821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1829f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If there are template args, parse them. 1830f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::less) 1831f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseTemplateArgList(CurRec)) 1832f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1833f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1834f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Finally, parse the object body. 1835f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return ParseObjectBody(CurRec); 1836f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1837f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1838f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseLetList - Parse a non-empty list of assignment expressions into a list 1839f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// of LetRecords. 1840f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1841f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// LetList ::= LetItem (',' LetItem)* 1842f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// LetItem ::= ID OptionalRangeList '=' Value 1843f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1844f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerstd::vector<LetRecord> TGParser::ParseLetList() { 1845f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<LetRecord> Result; 184621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1847f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (1) { 1848f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) { 1849f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected identifier in let definition"); 1850f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return std::vector<LetRecord>(); 1851f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1852f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string Name = Lex.getCurStrVal(); 18531e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc NameLoc = Lex.getLoc(); 185421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Lex.Lex(); // Eat the identifier. 1855f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1856f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Check for an optional RangeList. 1857f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<unsigned> Bits; 185821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson if (ParseOptionalRangeList(Bits)) 1859f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return std::vector<LetRecord>(); 1860f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::reverse(Bits.begin(), Bits.end()); 186121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1862f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::equal) { 1863f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '=' in let expression"); 1864f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return std::vector<LetRecord>(); 1865f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1866f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '='. 186721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 186805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = ParseValue(0); 1869f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Val == 0) return std::vector<LetRecord>(); 187021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1871f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Now that we have everything, add the record. 1872f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Result.push_back(LetRecord(Name, Bits, Val, NameLoc)); 187321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1874f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::comma) 1875f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Result; 187621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Lex.Lex(); // eat the comma. 1877f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1878f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1879f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1880f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseTopLevelLet - Parse a 'let' at top level. This can be a couple of 1881ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes/// different related productions. This works inside multiclasses too. 1882f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1883f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= LET LetList IN '{' ObjectList '}' 1884f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= LET LetList IN Object 1885f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1886ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopesbool TGParser::ParseTopLevelLet(MultiClass *CurMultiClass) { 1887f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::Let && "Unexpected token"); 1888f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 188921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1890f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Add this entry to the let stack. 1891f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::vector<LetRecord> LetInfo = ParseLetList(); 1892f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (LetInfo.empty()) return true; 1893f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner LetStack.push_back(LetInfo); 1894f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1895f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::In) 1896f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected 'in' at end of top-level 'let'"); 1897f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 189821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1899f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If this is a scalar let, just handle it now 1900f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::l_brace) { 1901f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // LET LetList IN Object 1902ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes if (ParseObject(CurMultiClass)) 1903f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1904f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } else { // Object ::= LETCommand '{' ObjectList '}' 19051e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc BraceLoc = Lex.getLoc(); 1906f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Otherwise, this is a group let. 1907f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // eat the '{'. 190821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1909f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Parse the object list. 1910ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes if (ParseObjectList(CurMultiClass)) 1911f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 191221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1913f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::r_brace) { 1914f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner TokError("expected '}' at end of top level let command"); 1915f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return Error(BraceLoc, "to match this '{'"); 1916f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 1917f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 1918f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 191921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1920f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // Outside this let scope, this let block is not active. 1921f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner LetStack.pop_back(); 1922f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 1923f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 1924f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1925f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseMultiClass - Parse a multiclass definition. 1926f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 192732558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// MultiClassInst ::= MULTICLASS ID TemplateArgList? 192832558650ae09247b31aa89cdee64e8c849771024Bob Wilson/// ':' BaseMultiClassList '{' MultiClassDef+ '}' 1929f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 1930f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseMultiClass() { 1931f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::MultiClass && "Unexpected token"); 1932f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat the multiclass token. 1933f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1934f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() != tgtok::Id) 1935f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected identifier after multiclass for name"); 1936f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner std::string Name = Lex.getCurStrVal(); 193721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1938f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (MultiClasses.count(Name)) 1939f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("multiclass '" + Name + "' already defined"); 194021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 194167db883487fca3472fdde51e931657e22d4d0495Chris Lattner CurMultiClass = MultiClasses[Name] = new MultiClass(Name, 194267db883487fca3472fdde51e931657e22d4d0495Chris Lattner Lex.getLoc(), Records); 1943f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Eat the identifier. 194421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1945f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If there are template args, parse them. 1946f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::less) 1947f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseTemplateArgList(0)) 1948f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 1949f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 1950d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene bool inherits = false; 1951d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1952de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // If there are submulticlasses, parse them. 1953de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() == tgtok::colon) { 1954d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene inherits = true; 1955d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1956de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Lex.Lex(); 195732558650ae09247b31aa89cdee64e8c849771024Bob Wilson 1958de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Read all of the submulticlasses. 195932558650ae09247b31aa89cdee64e8c849771024Bob Wilson SubMultiClassReference SubMultiClass = 196032558650ae09247b31aa89cdee64e8c849771024Bob Wilson ParseSubMultiClassReference(CurMultiClass); 1961de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene while (1) { 1962de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Check for error. 1963de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (SubMultiClass.MC == 0) return true; 196432558650ae09247b31aa89cdee64e8c849771024Bob Wilson 1965de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene // Add it. 1966de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (AddSubMultiClass(CurMultiClass, SubMultiClass)) 1967de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene return true; 196832558650ae09247b31aa89cdee64e8c849771024Bob Wilson 1969de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene if (Lex.getCode() != tgtok::comma) break; 1970de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene Lex.Lex(); // eat ','. 1971de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene SubMultiClass = ParseSubMultiClassReference(CurMultiClass); 1972de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 1973de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene } 1974de444af6bb9a8a7bb95e2a274d8fa8697e8f4e3fDavid Greene 1975d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene if (Lex.getCode() != tgtok::l_brace) { 1976d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene if (!inherits) 1977d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene return TokError("expected '{' in multiclass definition"); 197821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson else if (Lex.getCode() != tgtok::semi) 197921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return TokError("expected ';' in multiclass definition"); 1980d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene else 198121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson Lex.Lex(); // eat the ';'. 198221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1983d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene if (Lex.Lex() == tgtok::r_brace) // eat the '{'. 1984d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene return TokError("multiclass must contain at least one def"); 198521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1986270562b3d4c61ae1381cb1b0026bb703b46ff88fBruno Cardoso Lopes while (Lex.getCode() != tgtok::r_brace) { 1987ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes switch (Lex.getCode()) { 1988ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes default: 19896da674cda1587c9b09e01f65219cec54f54d90b8David Greene return TokError("expected 'let', 'def', 'defm' or 'multidef'" 19906da674cda1587c9b09e01f65219cec54f54d90b8David Greene "in multiclass body"); 1991ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Let: 1992ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Def: 1993ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Defm: 19946da674cda1587c9b09e01f65219cec54f54d90b8David Greene case tgtok::MultiDef: 1995ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes if (ParseObject(CurMultiClass)) 1996ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes return true; 1997ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes break; 1998ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes } 1999270562b3d4c61ae1381cb1b0026bb703b46ff88fBruno Cardoso Lopes } 2000d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Lex.Lex(); // eat the '}'. 2001d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 200221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 2003f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner CurMultiClass = 0; 2004f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 2005f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 2006f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 2007e499a2df4492dab21a50d74f3f687b989f910a2fDavid GreeneRecord *TGParser:: 2008e499a2df4492dab21a50d74f3f687b989f910a2fDavid GreeneInstantiateMulticlassDef(MultiClass &MC, 2009e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *DefProto, 2010e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene const std::string &DefmPrefix, 2011e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene SMLoc DefmPrefixLoc) { 2012e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Add in the defm name. If the defm prefix is empty, give each 2013e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // instantiated def a unique name. Otherwise, if "#NAME#" exists in the 2014e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // name, substitute the prefix for #NAME#. Otherwise, use the defm name 2015e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // as a prefix. 2016e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene std::string DefName = DefProto->getName(); 2017e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (DefmPrefix.empty()) { 2018e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene DefName = GetNewAnonymousName(); 2019e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } else { 2020e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene std::string::size_type idx = DefName.find("#NAME#"); 2021e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (idx != std::string::npos) { 2022e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene DefName.replace(idx, 6, DefmPrefix); 2023e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } else { 2024e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Add the suffix to the defm name to get the new name. 2025e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene DefName = DefmPrefix + DefName; 2026e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2027e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2028e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2029e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *CurRec = new Record(DefName, DefmPrefixLoc, Records); 2030e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2031e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene SubClassReference Ref; 2032e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Ref.RefLoc = DefmPrefixLoc; 2033e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Ref.Rec = DefProto; 2034e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene AddSubClass(CurRec, Ref); 2035e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2036e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return CurRec; 2037e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene} 2038e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2039e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greenebool TGParser::ResolveMulticlassDefArgs(MultiClass &MC, 2040e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *CurRec, 2041e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene SMLoc DefmPrefixLoc, 2042e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene SMLoc SubClassLoc, 2043e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene const std::vector<std::string> &TArgs, 2044e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene std::vector<Init *> &TemplateVals, 2045e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene bool DeleteArgs) { 2046e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Loop over all of the template arguments, setting them to the specified 2047e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // value or leaving them as the default if necessary. 2048e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 2049e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Check if a value is specified for this temp-arg. 2050e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (i < TemplateVals.size()) { 2051e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Set it now. 2052e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (SetValue(CurRec, DefmPrefixLoc, TArgs[i], std::vector<unsigned>(), 2053e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene TemplateVals[i])) 2054e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return true; 2055e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2056e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Resolve it next. 2057e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene CurRec->resolveReferencesTo(CurRec->getValue(TArgs[i])); 2058e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2059e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (DeleteArgs) 2060e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Now remove it. 2061e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene CurRec->removeValue(TArgs[i]); 2062e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2063e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) { 2064e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(SubClassLoc, "value not specified for template argument #"+ 2065e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene utostr(i) + " (" + TArgs[i] + ") of multiclassclass '" + 2066e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene MC.Rec.getName() + "'"); 2067e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2068e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2069e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return false; 2070e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene} 2071e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2072e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greenebool TGParser::ResolveMulticlassDef(MultiClass &MC, 2073e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *CurRec, 2074e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *DefProto, 2075e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene SMLoc DefmPrefixLoc) { 2076e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // If the mdef is inside a 'let' expression, add to each def. 2077e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 2078e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 2079e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 2080e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene LetStack[i][j].Bits, LetStack[i][j].Value)) 2081e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(DefmPrefixLoc, "when instantiating this defm"); 2082e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2083e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Ensure redefinition doesn't happen. 2084e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (Records.getDef(CurRec->getName())) 2085e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(DefmPrefixLoc, "def '" + CurRec->getName() + 2086e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene "' already defined, instantiating defm with subdef '" + 2087e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene DefProto->getName() + "'"); 2088e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2089e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Don't create a top level definition for defm inside multiclasses, 2090e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // instead, only update the prototypes and bind the template args 2091e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // with the new created definition. 2092e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (CurMultiClass) { 2093e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene for (unsigned i = 0, e = CurMultiClass->DefPrototypes.size(); 2094e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene i != e; ++i) 2095e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (CurMultiClass->DefPrototypes[i]->getName() == CurRec->getName()) 2096e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(DefmPrefixLoc, "defm '" + CurRec->getName() + 2097e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene "' already defined in this multiclass!"); 2098e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene CurMultiClass->DefPrototypes.push_back(CurRec); 2099e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2100e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene // Copy the template arguments for the multiclass into the new def. 2101e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene const std::vector<std::string> &TA = 2102e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene CurMultiClass->Rec.getTemplateArgs(); 2103e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2104e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene for (unsigned i = 0, e = TA.size(); i != e; ++i) { 2105e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene const RecordVal *RV = CurMultiClass->Rec.getValue(TA[i]); 2106e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene assert(RV && "Template arg doesn't exist?"); 2107e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene CurRec->addValue(*RV); 2108e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2109e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } else { 2110e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Records.addDef(CurRec); 2111e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene } 2112e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2113e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return false; 2114e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene} 2115e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 2116f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseDefm - Parse the instantiation of a multiclass. 2117f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 2118f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// DefMInst ::= DEFM ID ':' DefmSubClassRef ';' 2119f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// 2120270562b3d4c61ae1381cb1b0026bb703b46ff88fBruno Cardoso Lopesbool TGParser::ParseDefm(MultiClass *CurMultiClass) { 2121f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner assert(Lex.getCode() == tgtok::Defm && "Unexpected token!"); 212221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 2123df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner std::string DefmPrefix; 2124df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner if (Lex.Lex() == tgtok::Id) { // eat the defm. 2125df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner DefmPrefix = Lex.getCurStrVal(); 2126df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner Lex.Lex(); // Eat the defm prefix. 2127df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner } 2128c761f7dca2134d4d500ce7f7db4422356725ee8cMikhail Glushenkov 21291e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc DefmPrefixLoc = Lex.getLoc(); 2130df72eaef3d863be99fd45f59c59919a8c1261d05Chris Lattner if (Lex.getCode() != tgtok::colon) 2131f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("expected ':' after defm identifier"); 213221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 21336e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Keep track of the new generated record definitions. 21346e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes std::vector<Record*> NewRecDefs; 21356e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 21366e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // This record also inherits from a regular class (non-multiclass)? 21376e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes bool InheritFromClass = false; 21386e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 2139f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // eat the colon. 2140f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); 2141f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 21421e3a8a492471f5dc3f50452af9eb9a2dfb1aeb39Chris Lattner SMLoc SubClassLoc = Lex.getLoc(); 2143f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner SubClassReference Ref = ParseSubClassReference(0, true); 21445654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21455654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene while (1) { 21465654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene if (Ref.Rec == 0) return true; 21475654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21485654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene // To instantiate a multiclass, we need to first get the multiclass, then 21495654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene // instantiate each def contained in the multiclass with the SubClassRef 21505654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene // template parameters. 21515654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene MultiClass *MC = MultiClasses[Ref.Rec->getName()]; 21525654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene assert(MC && "Didn't lookup multiclass correctly?"); 215305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> &TemplateVals = Ref.TemplateArgs; 21545654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21555654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene // Verify that the correct number of template arguments were specified. 21565654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs(); 21575654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene if (TArgs.size() < TemplateVals.size()) 21585654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene return Error(SubClassLoc, 21595654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene "more template args specified than multiclass expects"); 21605654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21615654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene // Loop over all the def's in the multiclass, instantiating each one. 21625654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene for (unsigned i = 0, e = MC->DefPrototypes.size(); i != e; ++i) { 21635654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene Record *DefProto = MC->DefPrototypes[i]; 21645654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 2165e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene Record *CurRec = InstantiateMulticlassDef(*MC, DefProto, DefmPrefix, DefmPrefixLoc); 2166270562b3d4c61ae1381cb1b0026bb703b46ff88fBruno Cardoso Lopes 2167e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (ResolveMulticlassDefArgs(*MC, CurRec, DefmPrefixLoc, SubClassLoc, 2168e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene TArgs, TemplateVals, true/*Delete args*/)) 2169e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(SubClassLoc, "could not instantiate def"); 2170270562b3d4c61ae1381cb1b0026bb703b46ff88fBruno Cardoso Lopes 2171e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene if (ResolveMulticlassDef(*MC, CurRec, DefProto, DefmPrefixLoc)) 2172e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene return Error(SubClassLoc, "could not instantiate def"); 21736e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 21746e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes NewRecDefs.push_back(CurRec); 2175f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 21765654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 2177e499a2df4492dab21a50d74f3f687b989f910a2fDavid Greene 21785654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene if (Lex.getCode() != tgtok::comma) break; 21795654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene Lex.Lex(); // eat ','. 21805654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21815654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene SubClassLoc = Lex.getLoc(); 21826e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 21836e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // A defm can inherit from regular classes (non-multiclass) as 21846e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // long as they come in the end of the inheritance list. 21856e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes InheritFromClass = (Records.getClass(Lex.getCurStrVal()) != 0); 21866e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 21876e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (InheritFromClass) 21886e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes break; 21896e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 21905654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene Ref = ParseSubClassReference(0, true); 2191f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 21925654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene 21936e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (InheritFromClass) { 21946e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Process all the classes to inherit as if they were part of a 21956e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // regular 'def' and inherit all record values. 21966e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes SubClassReference SubClass = ParseSubClassReference(0, false); 21976e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes while (1) { 21986e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Check for error. 21996e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (SubClass.Rec == 0) return true; 22006e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 22016e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Get the expanded definition prototypes and teach them about 22026e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // the record values the current class to inherit has 22036e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) { 22046e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes Record *CurRec = NewRecDefs[i]; 22056e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 22066e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Add it. 22076e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (AddSubClass(CurRec, SubClass)) 22086e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes return true; 22096e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 22106e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes // Process any variables on the let stack. 22116e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes for (unsigned i = 0, e = LetStack.size(); i != e; ++i) 22126e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes for (unsigned j = 0, e = LetStack[i].size(); j != e; ++j) 22136e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (SetValue(CurRec, LetStack[i][j].Loc, LetStack[i][j].Name, 22146e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes LetStack[i][j].Bits, LetStack[i][j].Value)) 22156e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes return true; 22166e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes } 22176e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 22186e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes if (Lex.getCode() != tgtok::comma) break; 22196e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes Lex.Lex(); // eat ','. 22206e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes SubClass = ParseSubClassReference(0, false); 22216e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes } 22226e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes } 22236e0a99a7ab6d6fd0099946c4859466f2a9cdd1e1Bruno Cardoso Lopes 2224e5104ac99aae21fb8ee514f3b65eac9856399dc0Bruno Cardoso Lopes if (!CurMultiClass) 2225e5104ac99aae21fb8ee514f3b65eac9856399dc0Bruno Cardoso Lopes for (unsigned i = 0, e = NewRecDefs.size(); i != e; ++i) 22260d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // See Record::setName(). This resolve step will see any new 22270d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // name for the def that might have been created when resolving 22280d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // inheritance, values and arguments above. 2229e5104ac99aae21fb8ee514f3b65eac9856399dc0Bruno Cardoso Lopes NewRecDefs[i]->resolveReferences(); 2230e5104ac99aae21fb8ee514f3b65eac9856399dc0Bruno Cardoso Lopes 22315654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene if (Lex.getCode() != tgtok::semi) 22325654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene return TokError("expected ';' at end of defm"); 22335654613a013b94a92f9ed65e1a2f34e0a8d9cfdfDavid Greene Lex.Lex(); 223421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 2235f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 2236f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 2237f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 2238f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseObject 2239f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= ClassInst 2240f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= DefInst 22416da674cda1587c9b09e01f65219cec54f54d90b8David Greene/// Object ::= MultiDefInst 2242f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= MultiClassInst 2243f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= DefMInst 2244f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= LETCommand '{' ObjectList '}' 2245f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// Object ::= LETCommand Object 2246ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopesbool TGParser::ParseObject(MultiClass *MC) { 2247f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner switch (Lex.getCode()) { 2248d6d9dd9f5e950383b7040a864bd8e004f95bcc91Chris Lattner default: 2249d6d9dd9f5e950383b7040a864bd8e004f95bcc91Chris Lattner return TokError("Expected class, def, defm, multiclass or let definition"); 2250ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Let: return ParseTopLevelLet(MC); 2251ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Def: return ParseDef(MC); 22526da674cda1587c9b09e01f65219cec54f54d90b8David Greene case tgtok::MultiDef: return ParseMultiDef(MC); 2253ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes case tgtok::Defm: return ParseDefm(MC); 2254f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::Class: return ParseClass(); 2255f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner case tgtok::MultiClass: return ParseMultiClass(); 2256f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 2257f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 2258f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 2259f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ParseObjectList 2260f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner/// ObjectList :== Object* 2261ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopesbool TGParser::ParseObjectList(MultiClass *MC) { 2262f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner while (isObjectStart(Lex.getCode())) { 2263ee65db3add855bfbc4ddc7e45926d1b9bafca8a4Bruno Cardoso Lopes if (ParseObject(MC)) 2264f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return true; 2265f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner } 2266f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 2267f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 2268f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 2269f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattnerbool TGParser::ParseFile() { 2270f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner Lex.Lex(); // Prime the lexer. 2271f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (ParseObjectList()) return true; 227221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 2273f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner // If we have unread input at the end of the file, report it. 2274f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner if (Lex.getCode() == tgtok::Eof) 2275f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return false; 227621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 2277f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner return TokError("Unexpected input at top level"); 2278f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner} 2279f460165a4c1bf4bc762f9b3f12b9ed284b89cc99Chris Lattner 2280