Record.cpp revision 7c788888872233748da10a8177a9a1eb176c1bc8
1e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===- Record.cpp - Record implementation ---------------------------------===// 23da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 301d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell// The LLVM Compiler Infrastructure 401d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell// 53060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// This file is distributed under the University of Illinois Open Source 63060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// License. See LICENSE.TXT for details. 73da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 801d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell//===----------------------------------------------------------------------===// 9e62c1185bee05facc25d1d725434f517261d308bChris Lattner// 10711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner// Implement the tablegen record classes. 11e62c1185bee05facc25d1d725434f517261d308bChris Lattner// 12e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 13e62c1185bee05facc25d1d725434f517261d308bChris Lattner 147c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Record.h" 157c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Error.h" 161f6efa3996dd1929fbc129203ce5009b620e6969Michael J. Spencer#include "llvm/Support/DataTypes.h" 170d886401b3ec09b0c2d267942b07702a2f0740f4David Greene#include "llvm/Support/ErrorHandling.h" 181a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include "llvm/Support/Format.h" 19726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene#include "llvm/ADT/DenseMap.h" 20726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene#include "llvm/ADT/FoldingSet.h" 21ca7fd3de360b266783438666054dba198ff77ba2David Greene#include "llvm/ADT/SmallVector.h" 22ca7fd3de360b266783438666054dba198ff77ba2David Greene#include "llvm/ADT/STLExtras.h" 2399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner#include "llvm/ADT/StringExtras.h" 24d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene#include "llvm/ADT/StringMap.h" 256fb9a84e79212f550981b6545aa435e7ca0cd794Duraid Madina 262082ebe8b3a5db302748828ab4f79a36d239c1d9Chris Lattnerusing namespace llvm; 27e62c1185bee05facc25d1d725434f517261d308bChris Lattner 28e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 29cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene// std::string wrapper for DenseMap purposes 30cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene//===----------------------------------------------------------------------===// 31cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 32cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// TableGenStringKey - This is a wrapper for std::string suitable for 33cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// using as a key to a DenseMap. Because there isn't a particularly 34cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// good way to indicate tombstone or empty keys for strings, we want 35cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// to wrap std::string to indicate that this is a "special" string 36cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// not expected to take on certain values (those of the tombstone and 37cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// empty keys). This makes things a little safer as it clarifies 38cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// that DenseMap is really not appropriate for general strings. 39cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 40cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greeneclass TableGenStringKey { 41cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greenepublic: 42cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey(const std::string &str) : data(str) {} 43cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey(const char *str) : data(str) {} 44cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 45cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene const std::string &str() const { return data; } 46cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 47cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greeneprivate: 48cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene std::string data; 49cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene}; 50cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 51cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// Specialize DenseMapInfo for TableGenStringKey. 52cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greenenamespace llvm { 53cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 54cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greenetemplate<> struct DenseMapInfo<TableGenStringKey> { 55cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static inline TableGenStringKey getEmptyKey() { 56cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey Empty("<<<EMPTY KEY>>>"); 57cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return Empty; 58cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 59cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static inline TableGenStringKey getTombstoneKey() { 60cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey Tombstone("<<<TOMBSTONE KEY>>>"); 61cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return Tombstone; 62cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 63cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static unsigned getHashValue(const TableGenStringKey& Val) { 64cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return HashString(Val.str()); 65cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 66cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static bool isEqual(const TableGenStringKey& LHS, 67cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene const TableGenStringKey& RHS) { 68cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return LHS.str() == RHS.str(); 69cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 70cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene}; 71cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 72cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene} 73cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 74cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene//===----------------------------------------------------------------------===// 75e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Type implementations 76e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 77e62c1185bee05facc25d1d725434f517261d308bChris Lattner 7877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitRecTy BitRecTy::Shared; 7977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenIntRecTy IntRecTy::Shared; 8077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenStringRecTy StringRecTy::Shared; 8177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenCodeRecTy CodeRecTy::Shared; 8277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDagRecTy DagRecTy::Shared; 8377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 841a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecTy::dump() const { print(errs()); } 85e62c1185bee05facc25d1d725434f517261d308bChris Lattner 8677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenListRecTy *RecTy::getListTy() { 8777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!ListTy) 8877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen ListTy = new ListRecTy(this); 8977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return ListTy; 9077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 9177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 9205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(BitsInit *BI) { 93e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! 94e62c1185bee05facc25d1d725434f517261d308bChris Lattner return BI->getBit(0); 95e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 96e62c1185bee05facc25d1d725434f517261d308bChris Lattner 977cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerbool BitRecTy::baseClassOf(const BitsRecTy *RHS) const { 987cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->getNumBits() == 1; 997cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 1007cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 10105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(IntInit *II) { 10263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Val = II->getValue(); 103e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! 1043da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 105dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitInit::get(Val != 0); 106e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 107e62c1185bee05facc25d1d725434f517261d308bChris Lattner 10805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(TypedInit *VI) { 109e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (dynamic_cast<BitRecTy*>(VI->getType())) 110e62c1185bee05facc25d1d725434f517261d308bChris Lattner return VI; // Accept variable if it is already of bit type! 111e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 112e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 113e62c1185bee05facc25d1d725434f517261d308bChris Lattner 11477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitsRecTy *BitsRecTy::get(unsigned Sz) { 11577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static std::vector<BitsRecTy*> Shared; 11677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (Sz >= Shared.size()) 11777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Shared.resize(Sz + 1); 11877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen BitsRecTy *&Ty = Shared[Sz]; 11977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!Ty) 12077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Ty = new BitsRecTy(Sz); 12177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return Ty; 12277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 12377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 12499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string BitsRecTy::getAsString() const { 12599ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "bits<" + utostr(Size) + ">"; 12699ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 12799ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 12805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(UnsetInit *UI) { 12905bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 130e62c1185bee05facc25d1d725434f517261d308bChris Lattner 131e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 132dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = UnsetInit::get(); 133ca7fd3de360b266783438666054dba198ff77ba2David Greene 134dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 135e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 136e62c1185bee05facc25d1d725434f517261d308bChris Lattner 13705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitInit *UI) { 138ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (Size != 1) return 0; // Can only convert single bit. 139dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(UI); 140e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 141e62c1185bee05facc25d1d725434f517261d308bChris Lattner 142548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// canFitInBitfield - Return true if the number of bits is large enough to hold 143548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// the integer value. 144548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendlingstatic bool canFitInBitfield(int64_t Value, unsigned NumBits) { 145b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky // For example, with NumBits == 4, we permit Values from [-7 .. 15]. 146b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky return (NumBits >= sizeof(Value) * 8) || 147b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); 148548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling} 149548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 150d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// convertValue from Int initializer to bits type: Split the integer up into the 151d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// appropriate bits. 152548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// 15305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(IntInit *II) { 154294984cecbe1e5abbe37dc38bf2941f2804b13caMisha Brukman int64_t Value = II->getValue(); 155ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // Make sure this bitfield is large enough to hold the integer value. 156548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (!canFitInBitfield(Value, Size)) 157548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling return 0; 158e62c1185bee05facc25d1d725434f517261d308bChris Lattner 15905bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 160ca7fd3de360b266783438666054dba198ff77ba2David Greene 161e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 162dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (1LL << i)); 163d19c2cf5d2ae5b263df3f4c7c9744cdf3946f89bChris Lattner 164dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 165e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 166e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitsInit *BI) { 168e62c1185bee05facc25d1d725434f517261d308bChris Lattner // If the number of bits is right, return it. Otherwise we need to expand or 169ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // truncate. 170e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() == Size) return BI; 171e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 172e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 173e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(TypedInit *VI) { 175e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType())) 176e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BRT->Size == Size) { 17705bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 178ca7fd3de360b266783438666054dba198ff77ba2David Greene 179e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 180dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = VarBitInit::get(VI, i); 181dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 182e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 183548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 184ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) 185dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(VI); 1863da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 18705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) { 188548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (Tern->getOpcode() == TernOpInit::IF) { 18905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS = Tern->getLHS(); 19005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *MHS = Tern->getMHS(); 19105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *RHS = Tern->getRHS(); 192548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 19305bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *MHSi = dynamic_cast<IntInit*>(MHS); 19405bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *RHSi = dynamic_cast<IntInit*>(RHS); 195548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 196548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSi && RHSi) { 197548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling int64_t MHSVal = MHSi->getValue(); 198548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling int64_t RHSVal = RHSi->getValue(); 199548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 200548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) { 20105bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 202548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 203548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling for (unsigned i = 0; i != Size; ++i) 204ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = 205dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene TernOpInit::get(TernOpInit::IF, LHS, 206dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene IntInit::get((MHSVal & (1LL << i)) ? 1 : 0), 207dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene IntInit::get((RHSVal & (1LL << i)) ? 1 : 0), 208dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene VI->getType()); 209d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 210dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 211548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 212548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } else { 21305bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS); 21405bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS); 215548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 216548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (MHSbs && RHSbs) { 21705bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 218548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 219548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling for (unsigned i = 0; i != Size; ++i) 220dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = TernOpInit::get(TernOpInit::IF, LHS, 221dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene MHSbs->getBit(i), 222dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHSbs->getBit(i), 223dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene VI->getType()); 224548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 225dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 226548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 227548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 228548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 229548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 230548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 231e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 232e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 233e62c1185bee05facc25d1d725434f517261d308bChris Lattner 23405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitInit *BI) { 235dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(BI->getValue()); 23608ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner} 23708ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner 23805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitsInit *BI) { 23963f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result = 0; 2403da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 24105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) { 242e62c1185bee05facc25d1d725434f517261d308bChris Lattner Result |= Bit->getValue() << i; 243e62c1185bee05facc25d1d725434f517261d308bChris Lattner } else { 244e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 245e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 246dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 247e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 248e62c1185bee05facc25d1d725434f517261d308bChris Lattner 24905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(TypedInit *TI) { 25008ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 251b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 252e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 253e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 254e62c1185bee05facc25d1d725434f517261d308bChris Lattner 25505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(UnOpInit *BO) { 256e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 25705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 258e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 259e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 260dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); 261e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 262e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 263e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 26405bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 265e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 266d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 26705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(BinOpInit *BO) { 268711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (BO->getOpcode() == BinOpInit::STRCONCAT) { 26905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 27005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 271711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L == 0 || R == 0) return 0; 272711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L != BO->getLHS() || R != BO->getRHS()) 273dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); 274711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner return BO; 275711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 276e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 27705bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 278711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 279711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 280711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 28105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(TypedInit *TI) { 282b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner if (dynamic_cast<StringRecTy*>(TI->getType())) 283b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 284e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 285e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 286e62c1185bee05facc25d1d725434f517261d308bChris Lattner 28799ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string ListRecTy::getAsString() const { 28899ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "list<" + Ty->getAsString() + ">"; 28999ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 29099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 29105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(ListInit *LI) { 29205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Elements; 2937cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 294e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Verify that all of the elements of the list are subclasses of the 2957cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // appropriate class! 296e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = LI->getSize(); i != e; ++i) 29705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) 2987cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner Elements.push_back(CI); 2997cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner else 300e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 3017cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 302e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ListRecTy *LType = dynamic_cast<ListRecTy*>(LI->getType()); 303e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LType == 0) { 304e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 305e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 306e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 307dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Elements, this); 308e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 309e62c1185bee05facc25d1d725434f517261d308bChris Lattner 31005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(TypedInit *TI) { 311f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with our class. 312f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType())) 3137cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) 314f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 315f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return 0; 316f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner} 317f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner 31805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *CodeRecTy::convertValue(TypedInit *TI) { 319e9d019c364398dd030af3dcefd135d6c557a8cc3Chris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 320e9d019c364398dd030af3dcefd135d6c557a8cc3Chris Lattner return TI; 321e9d019c364398dd030af3dcefd135d6c557a8cc3Chris Lattner return 0; 322e9d019c364398dd030af3dcefd135d6c557a8cc3Chris Lattner} 323e9d019c364398dd030af3dcefd135d6c557a8cc3Chris Lattner 32405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(TypedInit *TI) { 32540f71134b9fef0ca06c516f033cc9403394a913cChris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 32640f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return TI; 32740f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return 0; 32840f71134b9fef0ca06c516f033cc9403394a913cChris Lattner} 32940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 33005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(UnOpInit *BO) { 331e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 33205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 333e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 334e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 335dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); 336e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 337e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 338e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 339e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 340d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 34105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(BinOpInit *BO) { 34230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (BO->getOpcode() == BinOpInit::CONCAT) { 34305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 34405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 34530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L == 0 || R == 0) return 0; 34630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L != BO->getLHS() || R != BO->getRHS()) 347dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); 34830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return BO; 34930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 35030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return 0; 35130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng} 35230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng 35377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenRecordRecTy *RecordRecTy::get(Record *R) { 35477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return &dynamic_cast<RecordRecTy&>(*R->getDefInit()->getType()); 35577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 35677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 35799ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string RecordRecTy::getAsString() const { 35899ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return Rec->getName(); 35999ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 36040f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 36105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(DefInit *DI) { 362e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Ensure that DI is a subclass of Rec. 363e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!DI->getDef()->isSubClassOf(Rec)) 364e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 365e62c1185bee05facc25d1d725434f517261d308bChris Lattner return DI; 366e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 367e62c1185bee05facc25d1d725434f517261d308bChris Lattner 36805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(TypedInit *TI) { 369f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with Rec. 370f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType())) 371ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner if (RRT->getRecord()->isSubClassOf(getRecord()) || 372ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner RRT->getRecord() == getRecord()) 373f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 374ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner return 0; 375ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner} 376ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner 3777cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerbool RecordRecTy::baseClassOf(const RecordRecTy *RHS) const { 37893583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes if (Rec == RHS->getRecord() || RHS->getRecord()->isSubClassOf(Rec)) 37993583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 38093583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 38193583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes const std::vector<Record*> &SC = Rec->getSuperClasses(); 38293583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes for (unsigned i = 0, e = SC.size(); i != e; ++i) 38393583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes if (RHS->getRecord()->isSubClassOf(SC[i])) 38493583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 38593583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 38693583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return false; 3877cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 3887cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 3897cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 39021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// resolveTypes - Find a common type that T1 and T2 convert to. 391e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// Return 0 if no such type exists. 392e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// 393e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid GreeneRecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { 394e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (!T1->typeIsConvertibleTo(T2)) { 395e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (!T2->typeIsConvertibleTo(T1)) { 396e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // If one is a Record type, check superclasses 397e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecordRecTy *RecTy1 = dynamic_cast<RecordRecTy*>(T1); 398e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (RecTy1) { 399e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // See if T2 inherits from a type T1 also inherits from 40021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson const std::vector<Record *> &T1SuperClasses = 40121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson RecTy1->getRecord()->getSuperClasses(); 402e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), 403e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene iend = T1SuperClasses.end(); 404e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene i != iend; 405e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ++i) { 40677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); 407e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); 408e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (NewType1 != 0) { 409e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (NewType1 != SuperRecTy1) { 410e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene delete SuperRecTy1; 411e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 412e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return NewType1; 413e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 414e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 415e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 416e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecordRecTy *RecTy2 = dynamic_cast<RecordRecTy*>(T2); 417e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (RecTy2) { 418e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene // See if T1 inherits from a type T2 also inherits from 41921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson const std::vector<Record *> &T2SuperClasses = 42021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson RecTy2->getRecord()->getSuperClasses(); 42121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), 422e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene iend = T2SuperClasses.end(); 423e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene i != iend; 424e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene ++i) { 42577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); 426e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); 427e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (NewType2 != 0) { 428e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (NewType2 != SuperRecTy2) { 429e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene delete SuperRecTy2; 430e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 431e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return NewType2; 432e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 433e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 434e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 435e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 436e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 437e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return T2; 438e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 439e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return T1; 440e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 441e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 442e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 443e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 444e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Initializer implementations 445e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 446e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4471a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Init::dump() const { return print(errs()); } 448e62c1185bee05facc25d1d725434f517261d308bChris Lattner 44905bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnsetInit *UnsetInit::get() { 45005bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnsetInit TheInit; 451ba1ae182876762f17201b33c0b87ca8ede156cfcDavid Greene return &TheInit; 452dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 453dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 45405bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitInit *BitInit::get(bool V) { 45505bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit True(true); 45605bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit False(false); 4570ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene 4580ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene return V ? &True : &False; 459dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 460dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 461726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenestatic void 46205bce0beee87512e52428d4b80f5a8e79a949576David GreeneProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { 463726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddInteger(Range.size()); 464726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 46505bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 466726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene iend = Range.end(); 467726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene i != iend; 468726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ++i) 469726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddPointer(*i); 470726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 471726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 47205bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *BitsInit::get(ArrayRef<Init *> Range) { 473726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene typedef FoldingSet<BitsInit> Pool; 474726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene static Pool ThePool; 475726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 476726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene FoldingSetNodeID ID; 477726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Range); 478726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 479726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene void *IP = 0; 48005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 481726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 482726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 483726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene BitsInit *I = new BitsInit(Range); 484726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ThePool.InsertNode(I, IP); 485726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 486726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 487726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 488726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 489726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenevoid BitsInit::Profile(FoldingSetNodeID &ID) const { 490726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Bits); 491dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 492dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 49305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 494f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneBitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 49505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 496ca7fd3de360b266783438666054dba198ff77ba2David Greene 497e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 498ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= getNumBits()) 499e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 500ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = getBit(Bits[i]); 501e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 502dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 503e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 504e62c1185bee05facc25d1d725434f517261d308bChris Lattner 5053aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BitsInit::getAsString() const { 5063aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "{ "; 507e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 5083aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 50905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *Bit = getBit(e-i-1)) 5103aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Bit->getAsString(); 51123ffa4a48820e58b411cf94a66b2a0d91173fbfaChris Lattner else 5123aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += "*"; 513e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 5143aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + " }"; 515e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 516e62c1185bee05facc25d1d725434f517261d308bChris Lattner 5179b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// resolveReferences - If there are any field references that refer to fields 5189b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// that have been filled in, we can propagate the values now. 5199b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// 52005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { 52128520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner bool Changed = false; 52205bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(getNumBits()); 52328520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 524d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 52505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *B; 52605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurBit = getBit(i); 527ade0de91236a5967e323a810b21bda4b0425642fChris Lattner 52828520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner do { 529ade0de91236a5967e323a810b21bda4b0425642fChris Lattner B = CurBit; 5307dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurBit = CurBit->resolveReferences(R, RV); 531ade0de91236a5967e323a810b21bda4b0425642fChris Lattner Changed |= B != CurBit; 532ade0de91236a5967e323a810b21bda4b0425642fChris Lattner } while (B != CurBit); 533ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = CurBit; 53428520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner } 53528520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 53628520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner if (Changed) 537dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 538ca7fd3de360b266783438666054dba198ff77ba2David Greene 53905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BitsInit *>(this); 54028520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner} 54128520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 54205bce0beee87512e52428d4b80f5a8e79a949576David GreeneIntInit *IntInit::get(int64_t V) { 5432855b0f0730b1a31aa156ea667fee79f66be4b03David Greene typedef DenseMap<int64_t, IntInit *> Pool; 5442855b0f0730b1a31aa156ea667fee79f66be4b03David Greene static Pool ThePool; 5452855b0f0730b1a31aa156ea667fee79f66be4b03David Greene 5462855b0f0730b1a31aa156ea667fee79f66be4b03David Greene IntInit *&I = ThePool[V]; 5472855b0f0730b1a31aa156ea667fee79f66be4b03David Greene if (!I) I = new IntInit(V); 5482855b0f0730b1a31aa156ea667fee79f66be4b03David Greene return I; 549dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 550dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5513aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string IntInit::getAsString() const { 5523aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return itostr(Value); 5533aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 5543aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 55505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 556f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneIntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 55705bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 558e62c1185bee05facc25d1d725434f517261d308bChris Lattner 559e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 560ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= 64) 561e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 562ca7fd3de360b266783438666054dba198ff77ba2David Greene 563dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); 564d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene } 565dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 566dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 567dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 56805bce0beee87512e52428d4b80f5a8e79a949576David GreeneStringInit *StringInit::get(const std::string &V) { 569d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene typedef StringMap<StringInit *> Pool; 570d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene static Pool ThePool; 571d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene 572d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene StringInit *&I = ThePool[V]; 573d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene if (!I) I = new StringInit(V); 574d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene return I; 575dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 576dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 57705bce0beee87512e52428d4b80f5a8e79a949576David GreeneCodeInit *CodeInit::get(const std::string &V) { 578637b4ffa01f42a6df598d4fc367d645a600128e1David Greene typedef StringMap<CodeInit *> Pool; 579637b4ffa01f42a6df598d4fc367d645a600128e1David Greene static Pool ThePool; 580637b4ffa01f42a6df598d4fc367d645a600128e1David Greene 581637b4ffa01f42a6df598d4fc367d645a600128e1David Greene CodeInit *&I = ThePool[V]; 582637b4ffa01f42a6df598d4fc367d645a600128e1David Greene if (!I) I = new CodeInit(V); 583637b4ffa01f42a6df598d4fc367d645a600128e1David Greene return I; 584dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 585dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 586aad4c9fc37b38cae21343173084c81d789535446David Greenestatic void ProfileListInit(FoldingSetNodeID &ID, 58705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> Range, 588aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy) { 589aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddInteger(Range.size()); 590aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(EltTy); 591aad4c9fc37b38cae21343173084c81d789535446David Greene 59205bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 593aad4c9fc37b38cae21343173084c81d789535446David Greene iend = Range.end(); 594aad4c9fc37b38cae21343173084c81d789535446David Greene i != iend; 595aad4c9fc37b38cae21343173084c81d789535446David Greene ++i) 596aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(*i); 597aad4c9fc37b38cae21343173084c81d789535446David Greene} 598aad4c9fc37b38cae21343173084c81d789535446David Greene 59905bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { 600aad4c9fc37b38cae21343173084c81d789535446David Greene typedef FoldingSet<ListInit> Pool; 601aad4c9fc37b38cae21343173084c81d789535446David Greene static Pool ThePool; 602aad4c9fc37b38cae21343173084c81d789535446David Greene 603aad4c9fc37b38cae21343173084c81d789535446David Greene // Just use the FoldingSetNodeID to compute a hash. Use a DenseMap 604aad4c9fc37b38cae21343173084c81d789535446David Greene // for actual storage. 605aad4c9fc37b38cae21343173084c81d789535446David Greene FoldingSetNodeID ID; 606aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Range, EltTy); 607aad4c9fc37b38cae21343173084c81d789535446David Greene 608aad4c9fc37b38cae21343173084c81d789535446David Greene void *IP = 0; 60905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 610aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 611aad4c9fc37b38cae21343173084c81d789535446David Greene 612aad4c9fc37b38cae21343173084c81d789535446David Greene ListInit *I = new ListInit(Range, EltTy); 613aad4c9fc37b38cae21343173084c81d789535446David Greene ThePool.InsertNode(I, IP); 614aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 615aad4c9fc37b38cae21343173084c81d789535446David Greene} 616aad4c9fc37b38cae21343173084c81d789535446David Greene 617aad4c9fc37b38cae21343173084c81d789535446David Greenevoid ListInit::Profile(FoldingSetNodeID &ID) const { 618aad4c9fc37b38cae21343173084c81d789535446David Greene ListRecTy *ListType = dynamic_cast<ListRecTy *>(getType()); 619aad4c9fc37b38cae21343173084c81d789535446David Greene assert(ListType && "Bad type for ListInit!"); 620aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy = ListType->getElementType(); 621aad4c9fc37b38cae21343173084c81d789535446David Greene 622aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Values, EltTy); 623d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene} 624d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene 62505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 626f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 62705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 628b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 629b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner if (Elements[i] >= getSize()) 630b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner return 0; 631b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner Vals.push_back(getElement(Elements[i])); 632b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner } 633dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Vals, getType()); 634b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner} 635b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 63650d456539dea5e61d7a1592a78f1861fb35b0063Chris LattnerRecord *ListInit::getElementAsRecord(unsigned i) const { 63750d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner assert(i < Values.size() && "List element index out of range!"); 63805bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(Values[i]); 63950d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner if (DI == 0) throw "Expected record in list!"; 64050d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner return DI->getDef(); 64150d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner} 64250d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner 64305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 64405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Resolved; 6451dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.reserve(getSize()); 6461dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner bool Changed = false; 6471dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6481dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = getSize(); i != e; ++i) { 64905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E; 65005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurElt = getElement(i); 6511dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6521dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner do { 6531dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner E = CurElt; 6547dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurElt = CurElt->resolveReferences(R, RV); 6551dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Changed |= E != CurElt; 6561dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } while (E != CurElt); 6571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.push_back(E); 6581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 6591dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6601dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Changed) 661dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Resolved, getType()); 66205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<ListInit *>(this); 6631dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 6641dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 66505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 66605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 667e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Elt >= getSize()) 668e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; // Out of range reference. 66905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = getElement(Elt); 6702214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 6712214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 6722214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 67305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IRV || !dynamic_cast<UnsetInit*>(E)) 6742214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 675e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 676e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 677e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 6783aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string ListInit::getAsString() const { 6793aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "["; 6807cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 6813aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 6823aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Values[i]->getAsString(); 683e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 6843aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "]"; 685e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 686e62c1185bee05facc25d1d725434f517261d308bChris Lattner 68705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveBitReference(Record &R, const RecordVal *IRV, 68805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 68905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Folded = Fold(&R, 0); 690d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 691d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Folded != this) { 69205bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *Typed = dynamic_cast<TypedInit *>(Folded); 693d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 694d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return Typed->resolveBitReference(R, IRV, Bit); 69521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 696d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 69721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 698d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 699d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 700d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 70105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 70205bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 70305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Folded = Fold(&R, 0); 704d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 705d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Folded != this) { 70605bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *Typed = dynamic_cast<TypedInit *>(Folded); 707d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 708d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return Typed->resolveListElementReference(R, IRV, Elt); 70921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 710d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 71121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 712d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 713d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 714d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 71505bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 71605bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 7176f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7186f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene typedef DenseMap<Key, UnOpInit *> Pool; 7196f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene static Pool ThePool; 7206f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7216f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7226f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7236f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7246f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7256f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 726dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 727dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 72805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 729e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 730e6c27de069225e1122c78385ad22a2ff656db8e6David Greene default: assert(0 && "Unknown unop"); 731e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7322c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 73305bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 7342c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSs) { 7352c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 7362c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 737e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 73805bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 7392c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSd) { 740dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 7412c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 74221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 74305bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 7442c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSs) { 7452c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7462c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7472c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7482c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7492c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 750c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 751c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 752dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 753e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 754e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7552c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string TemplateArgName = CurRec->getName()+":"+Name; 7562c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7572c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7582c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 759e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 760c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 761c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 762e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 763dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 764e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 765e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 766e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7672c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 7682c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string MCName = CurMultiClass->Rec.getName()+"::"+Name; 7692c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 7702c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 7712c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 77221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 773c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 774c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 77521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 776dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 7772c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 7782c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 77921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 78067db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 78177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 782e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7835d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n"); 7842c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 785e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 786e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 787e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 7881434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 78905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 7905f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 7915f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 7925f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in car"); 7935f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7945f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7955f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 7965f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7975f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7985f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7991434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 80005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 8015f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 8025f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 8035f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in cdr"); 8045f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 8055f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 806dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 807dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 80805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 80905bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 81005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 81105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 812dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 8135f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 8145f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8155f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8165f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8171434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 81805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 8195f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 8205f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 821dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 82221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 823dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8245f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8255f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 82605bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 827e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs) { 828e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 829dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 83021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 831dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 832e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 833e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 83421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8355f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8365f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 837e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 83805bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 839e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 840e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 84105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 84205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 84321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 844e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 845dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 846e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Fold(&R, 0); 847e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 848e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 849e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 850e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 851e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 852e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8531434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8541434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8551434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 856e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 857e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 858e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 859d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 86005bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 86105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 86265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 86305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 86465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 86565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 86665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 86765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef DenseMap<Key, BinOpInit *> Pool; 86865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene static Pool ThePool; 86965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 87165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 87265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 87465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 87565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 876dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 877dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 87805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 879711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 880711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner default: assert(0 && "Unknown binop"); 88130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 88205bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *LHSs = dynamic_cast<DagInit*>(LHS); 88305bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *RHSs = dynamic_cast<DagInit*>(RHS); 88430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 88505bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator()); 88605bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator()); 8870b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 8880b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner throw "Concated Dag operators do not match!"; 88905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 89030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 89130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 89230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 89330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 89430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 89530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 89630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 89730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 89830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 899dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 90030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 90130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 90230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 903711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 90405bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 90505bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 906711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 907dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 908711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 909711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9106786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 911e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 912e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 91305bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit* L = 91405bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); 91505bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit* R = 91605bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); 917e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 918e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 919dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 920e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 92105bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 92205bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 923e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 924e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9256786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 926dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9276786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9286786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9296786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 930711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 931711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 932711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 93305bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 93405bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *RHSi = dynamic_cast<IntInit*>(RHS); 935711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 93663f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 93763f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 938711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 939711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner default: assert(0 && "Bad opcode!"); 940711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 941711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 94263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 943711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 944dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 945711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 946711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 947711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 948711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 94905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 950711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 951711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 95205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 95305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 95405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 95521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 956711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 957dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 958c7cafcd815519b06318629b424abe746437e1389David Greene return Fold(&R, 0); 959711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 960711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 9613aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 9623aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 963711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 9643aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 9653aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 9663aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 9673aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 9686786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 9693aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 970711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9713aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 972711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 973711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 97405bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 97505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 976dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 977b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 978b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 97905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 98005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 981b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 98205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 983b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 984b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 985b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 986b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 987b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 988b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 989b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 990b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 991b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 992b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 993b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 994b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 995b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 996b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 997dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 998dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 99905bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 100005bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 1001beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 100205bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 100305bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 100405bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 100505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 1006beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 100705bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *TArg = dynamic_cast<TypedInit*>(Arg); 1008beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1009beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 1010beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 101105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 1012d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1013beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1014beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 101521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1016beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1017beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1018beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1019beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1020beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 102105bce0beee87512e52428d4b80f5a8e79a949576David Greene OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); 1022beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1023beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 102405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1025d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1026beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1027beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 102821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1029beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1030beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 103121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1032beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 103321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1034beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1035beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1036beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1037beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1038beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1039f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 104005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1041dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewVal != NewOp) 1042beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return NewVal; 1043dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1044beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1045beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1046beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 104705bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 104805bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 104905bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MHSd = dynamic_cast<DagInit*>(MHS); 105005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *MHSl = dynamic_cast<ListInit*>(MHS); 1051beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1052beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type); 1053beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type); 1054beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 105505bce0beee87512e52428d4b80f5a8e79a949576David Greene OpInit *RHSo = dynamic_cast<OpInit*>(RHS); 1056beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1057beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 10585d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); 1059beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1060beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 106105bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1063beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!LHSt) { 10645d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1066beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1067c98a77d078ab5ec443576facb1402025c093f64aNick Lewycky if ((MHSd && DagType) || (MHSl && ListType)) { 1068beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 106905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 107005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1071d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1072beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1073beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1074beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1075beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 107605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1077beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 107805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1079beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1081beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1082beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1083beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 108405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1085d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1086beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1087beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1088beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1089beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1090beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1091beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1092beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1093beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1094dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 109705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 109805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1099beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 110005bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1101beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1102beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1103beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 110405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1105beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1106beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1107beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1108beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1109beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 111021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1111beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1112beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1113beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1114beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1115beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1116f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 111705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1118dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1119beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1120beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1121dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1122beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1123beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1124beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1125beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1126beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 112705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11284afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11294afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene default: assert(0 && "Unknown binop"); 11304afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 113105bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 113205bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *LHSv = dynamic_cast<VarInit*>(LHS); 113305bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 11344afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 113505bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *MHSd = dynamic_cast<DefInit*>(MHS); 113605bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *MHSv = dynamic_cast<VarInit*>(MHS); 113705bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *MHSs = dynamic_cast<StringInit*>(MHS); 11384afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 113905bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *RHSd = dynamic_cast<DefInit*>(RHS); 114005bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *RHSv = dynamic_cast<VarInit*>(RHS); 114105bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 11424afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11444afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11454afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11474afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11484afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11494afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 115177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11524afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11534afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11544afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11554afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11574afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1158dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11594afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11604afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11614afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11624afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11634afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1164f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11654afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1166f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 11674afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 11684afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 11694afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1170f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 11714afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 11724afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1173dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 11744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11754afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11764afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 117721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 11784afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11794afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 118005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1181beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1182beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1183beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 11844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11854afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 11864afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11879bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 11889bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 118905bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 119005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 119105bce0beee87512e52428d4b80f5a8e79a949576David Greene LHSi = dynamic_cast<IntInit*>(I); 11929bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 11939bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 11949bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 119521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 11969bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 11979bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11989bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11999bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 12009bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12024afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 120305bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 12044afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12054afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 120605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 120705bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 120805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 120977c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 121077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 121105bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *Value = dynamic_cast<IntInit*>(lhs); 121205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 121305bce0beee87512e52428d4b80f5a8e79a949576David Greene Value = dynamic_cast<IntInit*>(I); 121477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value != 0) { 121577c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 121677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 121705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1218dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1219dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS, getType()))->Fold(&R, 0); 122021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 122105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1222dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1223dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene rhs, getType()))->Fold(&R, 0); 122477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 122577c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 122677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 122721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 122805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 122905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 123077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12314afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1232dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1233dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()))->Fold(&R, 0); 12344afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return Fold(&R, 0); 12354afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12364afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12374afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12384afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12394afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12404afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 124121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 124221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 124421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12454afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1247e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12489703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 12499703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene RecordRecTy *RecordType = dynamic_cast<RecordRecTy *>(getType()); 12509703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene if (RecordType) { 12519703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene RecordVal *Field = RecordType->getRecord()->getValue(FieldName); 12529703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene if (Field) { 12539703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 12549703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene } 12559703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene } 12569703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return 0; 12579703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12589703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 125905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1260f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1261db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType()); 1262ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-bits variable. 1263e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1264e62c1185bee05facc25d1d725434f517261d308bChris Lattner 126505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1266e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1267ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1268e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1269ca7fd3de360b266783438666054dba198ff77ba2David Greene 127005bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1271e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1272dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1273e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1274e62c1185bee05facc25d1d725434f517261d308bChris Lattner 127505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1276f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 12771dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListRecTy *T = dynamic_cast<ListRecTy*>(getType()); 1278ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-list variable. 12791dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12801dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 128105bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 12821dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 128305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 12841dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 12851dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 128605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 128705bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1288dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 12891dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 12901dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12911dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 129205bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1293e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef std::pair<RecTy *, TableGenStringKey> Key; 1294e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef DenseMap<Key, VarInit *> Pool; 1295e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene static Pool ThePool; 1296e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1297e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1298e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1299e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1300e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1301e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1302dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1303dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 130405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, 130505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 13067dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (R.isTemplateArg(getName())) return 0; 13077dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (IRV && IRV->getName() != getName()) return 0; 1308e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1309db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner RecordVal *RV = R.getValue(getName()); 1310a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 131105bce0beee87512e52428d4b80f5a8e79a949576David Greene assert(dynamic_cast<BitsInit*>(RV->getValue())); 131205bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *BI = (BitsInit*)RV->getValue(); 13133da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1314db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 131505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *B = BI->getBit(Bit); 1316e62c1185bee05facc25d1d725434f517261d308bChris Lattner 13172214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the bit is set to some value, or if we are resolving a reference to a 13182214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // specific variable and that variable is explicitly unset, then replace the 13192214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // VarBitInit with it. 132005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IRV || !dynamic_cast<UnsetInit*>(B)) 13212214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return B; 13221dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 1323e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1324e62c1185bee05facc25d1d725434f517261d308bChris Lattner 132505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 132605bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 132705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 13287dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (R.isTemplateArg(getName())) return 0; 13297dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (IRV && IRV->getName() != getName()) return 0; 13301dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13311dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner RecordVal *RV = R.getValue(getName()); 1332a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 133305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); 1334ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 133505bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *VI = dynamic_cast<VarInit*>(RV->getValue()); 1336ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1337dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1338ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 133921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13401dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 13411dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; // Out of range reference. 134205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13432214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13442214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13452214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 134605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IRV || !dynamic_cast<UnsetInit*>(E)) 13472214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 13481dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 13491dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13501dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13511dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1352b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1353b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType())) 1354b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1355b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1356b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1357b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1358b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 135905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 136005bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 13619ec4849ff6cd771f53a1340aa6383702b7a6bb98Reid Spencer if (dynamic_cast<RecordRecTy*>(getType())) 1362d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 136305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue()))) 1364d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen return 0; 136505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1366ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 136705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1368b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1369b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 137024151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return 0; 1371ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1372b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1373b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1374b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 13759b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1376a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 13779b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 13789b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 13799b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 138005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 13819b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 138205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue()))) 13839b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 138405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 13859b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 13863da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 138705bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 138805bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1389aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1390aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1391aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1392aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1393aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1394aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1395aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1396aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1397aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1398dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1399dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14003aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 14013aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 14023aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1403db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 140405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 140505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) 1406db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner return I; 140705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarBitInit *>(this); 1408db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1409db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 141005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 141105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 141205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 141308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 141408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 141608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141708f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 141808f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141908f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 142008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 142108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1422dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1423dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14243aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 14253aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 14263aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 14273aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 142805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 142905bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 143005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1431d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 14321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 143305bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 14341dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14351dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 143605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV, 143705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 14381dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner // FIXME: This should be implemented, to support references like: 14391dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner // bit B = AA[0]{1}; 14401dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14411dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14421dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 144305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 144405bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 144505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14461045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14471045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14481045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14491045a594e65c65c55dfcd9585658eee85ef79e75David Greene TypedInit *TInit = dynamic_cast<TypedInit *>(Result); 14501045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (TInit) { 14511045a594e65c65c55dfcd9585658eee85ef79e75David Greene return TInit->resolveListElementReference(R, RV, Elt); 14521045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14531045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14541045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14551045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14561dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 145905bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 146077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 146177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 146277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1463b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1464b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1465b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1466b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1467b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1468b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 146905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 147005bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1471b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1472b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1473b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1474b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14753aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 14763aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1477e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1478e62c1185bee05facc25d1d725434f517261d308bChris Lattner 147905bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 148005bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 148165bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 148265bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 148365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 148465bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 148565bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 148665bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 148765bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 148865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1489dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1490dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 149105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveBitReference(Record &R, const RecordVal *RV, 149205bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 149305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName)) 149405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) { 149524151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 149605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *B = BI->getBit(Bit); 14973da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 149805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<BitInit*>(B)) // If the bit is set. 149924151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return B; // Replace the VarBitInit with it. 150024151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner } 15011dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 15021dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 15031dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 150405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 150505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 150605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 150705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) { 15081dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) return 0; 150905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 15101dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 15112214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 15122214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 15132214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 151405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV || !dynamic_cast<UnsetInit*>(E)) 15152214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 15161dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 15171dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 151824151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 151924151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 152005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 152105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 15227dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 152305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 152424151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 152505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 152605bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1527b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 15287dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 15297dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1530dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 15317dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 153205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1533db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1534db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 153578621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid ProfileDagInit(FoldingSetNodeID &ID, 153605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *V, 153778621a851ae84520de7d24a6d61e1dcf25749712David Greene const std::string &VN, 153805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 153978621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 154078621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 154178621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 154278621a851ae84520de7d24a6d61e1dcf25749712David Greene 154305bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 154478621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 154578621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 154678621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 154778621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 154878621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 154978621a851ae84520de7d24a6d61e1dcf25749712David Greene } 155078621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 155178621a851ae84520de7d24a6d61e1dcf25749712David Greene} 155278621a851ae84520de7d24a6d61e1dcf25749712David Greene 155305bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 155405bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 155505bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 155678621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 155778621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 155878621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 155978621a851ae84520de7d24a6d61e1dcf25749712David Greene 156078621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 156178621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 156278621a851ae84520de7d24a6d61e1dcf25749712David Greene 156378621a851ae84520de7d24a6d61e1dcf25749712David Greene void *IP = 0; 156405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 156578621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 156678621a851ae84520de7d24a6d61e1dcf25749712David Greene 156778621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 156878621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 156978621a851ae84520de7d24a6d61e1dcf25749712David Greene 157078621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 157178621a851ae84520de7d24a6d61e1dcf25749712David Greene} 157278621a851ae84520de7d24a6d61e1dcf25749712David Greene 157305bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 157405bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 157505bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 157605bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1577dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 157805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1579dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1580dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1581dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1582dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1583dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1584dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1585dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1586dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1587dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1588dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1589dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1590dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1591dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 159278621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 159378621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1594dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1595dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 159605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 159705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1598273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1599273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 160021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 160105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 160221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 16038c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1604dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 160521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 160605bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1607273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1608273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1609db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 16103aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 16113aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 16127cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 16137cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 16148e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner if (Args.size()) { 16153aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 16163aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 161791290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 16183aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 16193aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 162091290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 16218e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 16223aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 16238e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 16248e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 16258e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1626e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1627e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1628e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1629e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1630011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1631e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1632dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1633e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1634e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1635e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1636011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1637011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1638011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1639011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1640011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1641011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1642011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 1643011dca7fac07100695dd3685bfaddbea58a468b9David Greene StringInit *NameString = dynamic_cast<StringInit *>(Name); 1644011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1645011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1646011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1647011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16481a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1649e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16501a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1651e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1652e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << *getType() << " " << getName(); 16537dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16547dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1655e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16567dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1657e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1658e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1659e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16606f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16616f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 16620d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16630d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16640d886401b3ec09b0c2d267942b07702a2f0740f4David Greene const TypedInit *TypedName = dynamic_cast<const TypedInit *>(Name); 16650d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16660d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 16670d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (dynamic_cast<StringRecTy *>(Type) == 0) { 16680d886401b3ec09b0c2d267942b07702a2f0740f4David Greene llvm_unreachable("Record name is not a string!"); 16690d886401b3ec09b0c2d267942b07702a2f0740f4David Greene } 16700d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16710d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 167277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 167377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 167477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 167577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 167677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 167777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 16780d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 16790d886401b3ec09b0c2d267942b07702a2f0740f4David Greene const StringInit *NameString = 16800d886401b3ec09b0c2d267942b07702a2f0740f4David Greene dynamic_cast<const StringInit *>(Name); 16810d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 16820d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 16830d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16840d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16850d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 16860d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 16870d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeDef(Name->getAsUnquotedString()); 16880d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Name = NewName; 168967db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addDef(this); 1690936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } else { 16910d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeClass(Name->getAsUnquotedString()); 16920d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Name = NewName; 169367db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addClass(this); 1694936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } 16950d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 16960d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Since the Init for the name was changed, see if we can resolve 16970d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // any of it using members of the Record. 16980d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Init *ComputedName = Name->resolveReferences(*this, 0); 16990d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (ComputedName != Name) { 17000d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(ComputedName); 17010d886401b3ec09b0c2d267942b07702a2f0740f4David Greene } 17020d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 17030d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 17040d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 17050d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 17060d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 17070d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 17080d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 17090d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 17100d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 17110d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 17120d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 17130d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17140d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17150d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 17160d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 1717936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner} 1718936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner 17197dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 17207dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 17217dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 17227dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 17237dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 172405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 17257dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner Values[i].setValue(V->resolveReferences(*this, RV)); 17267dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 1727e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1728e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17291a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1730e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17311a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 1732e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << R.getName(); 1733e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1734e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<std::string> &TArgs = R.getTemplateArgs(); 1735e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1736e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1737e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1738e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1739e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1740e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1741e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1742e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1743e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1744e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1745e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1746e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1747e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1748e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1749e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1750e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1751e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " " << SC[i]->getName(); 1752e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1753e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1754e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1755e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1756e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1757e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1758e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1759e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1760e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1761e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1762e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1763e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1764e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1765e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1766c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 1767c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// or throw an exception if the field does not exist. 1768c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 176905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1770c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1771c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner if (R == 0 || R->getValue() == 0) 1772cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1773c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1774c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1775c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1776c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1777c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 17785c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 17795c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// value as a string, throwing an exception if the field does not exist or if 17805c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 17815c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1782c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 17835c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 17845c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (R == 0 || R->getValue() == 0) 1785cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1786c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 17875c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 178805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (StringInit *SI = dynamic_cast<StringInit*>(R->getValue())) 17895c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 1790c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 17915c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner "' does not have a string initializer!"; 17925c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 17935c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17946f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 17956f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// its value as a BitsInit, throwing an exception if the field does not exist 17966f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// or if the value is not the right type. 17976f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 179805bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 17996f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 18006f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner if (R == 0 || R->getValue() == 0) 1801cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1802c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 18036f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 180405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) 18056f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 1806c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 18076f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner "' does not have a BitsInit initializer!"; 18086f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 18096f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 181058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 181158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// its value as a ListInit, throwing an exception if the field does not exist 181258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// or if the value is not the right type. 181358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 181405bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 181558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 181658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1817cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1818c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 181958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 182005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) 182158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 1822c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 182358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner "' does not have a list initializer!"; 182458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18256f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1826b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 1827fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// its value as a vector of records, throwing an exception if the field does 1828fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// not exist or if the value is not the right type. 1829fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 183021870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1831c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 183205bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1833fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1834fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 183505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { 1836fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1837fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 1838c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1839fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey "' list is not entirely DefInit!"; 1840fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1841fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1842fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1843fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1844fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 184558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 184663f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman/// value as an int64_t, throwing an exception if the field does not exist or if 184758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// the value is not the right type. 184858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1849c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 185058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 185158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1852cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1853c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 185458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 185505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) 185658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 1857c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1858004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have an int initializer!"; 185958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18605c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1861af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 1862af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// its value as a vector of integers, throwing an exception if the field does 1863af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// not exist or if the value is not the right type. 1864af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 186521870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1866c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 186705bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 186863f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1869af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 187005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { 1871af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1872af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 1873c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1874af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov "' does not have a list of ints initializer!"; 1875af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1876af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1877af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1878af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1879af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1880bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 1881bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// returns its value as a vector of strings, throwing an exception if the 1882bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// field does not exist or if the value is not the right type. 1883bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1884bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1885bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 188605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1887bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1888bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 188905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { 1890bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1891bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 1892bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson throw "Record `" + getName() + "', field `" + FieldName.str() + 1893bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson "' does not have a list of strings initializer!"; 1894bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1895bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1896bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1897bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1898bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1899dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 1900dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// value as a Record, throwing an exception if the field does not exist or if 1901dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// the value is not the right type. 1902dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1903c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1904dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1905dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner if (R == 0 || R->getValue() == 0) 1906cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1907c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1908dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 190905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) 1910dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 1911c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1912004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have a def initializer!"; 1913dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1914dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19150969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 19160969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// value as a bit, throwing an exception if the field does not exist or if 19170969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// the value is not the right type. 19180969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1919c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 19200969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 19210969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner if (R == 0 || R->getValue() == 0) 1922cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1923c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 19240969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 192505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) 1926784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 1927c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1928784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a bit initializer!"; 1929784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1930784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1931784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 1932784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// value as an Dag, throwing an exception if the field does not exist or if 1933784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// the value is not the right type. 1934784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 193505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1936784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1937784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner if (R == 0 || R->getValue() == 0) 1938cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1939c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1940784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 194105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) 1942784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 1943c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1944784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a dag initializer!"; 19450969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19460969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1947c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsCode(StringRef FieldName) const { 19488f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner const RecordVal *R = getValue(FieldName); 19498f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner if (R == 0 || R->getValue() == 0) 19508f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner throw "Record `" + getName() + "' does not have a field named `" + 1951c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 195221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 195305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (CodeInit *CI = dynamic_cast<CodeInit*>(R->getValue())) 19548f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner return CI->getValue(); 1955c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 19568f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner "' does not have a code initializer!"; 19578f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner} 19588f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner 1959dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1960d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19611a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1962d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 196321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19641a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1965d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 1966d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 1967d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 1968d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 1969d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 1970d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 1971d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 1972d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1973d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 19741a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 1975e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19761a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 1977e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 1978e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Classes = RK.getClasses(); 1979e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 1980ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 1981e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "class " << *I->second; 19823da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1983e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 1984e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Defs = RK.getDefs(); 1985e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 1986ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 1987e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "def " << *I->second; 1988e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 1989e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1990ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1991ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1992ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 1993ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 1994ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 19955c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 19965c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 19979d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 19985c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 1999cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "ERROR: Couldn't find the `" + ClassName + "' class!\n"; 2000ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20015c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 2002ab47ae3381aa2372009a9054260461c20324b555Chris Lattner for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 2003ab47ae3381aa2372009a9054260461c20324b555Chris Lattner E = getDefs().end(); I != E; ++I) 2004ab47ae3381aa2372009a9054260461c20324b555Chris Lattner if (I->second->isSubClassOf(Class)) 2005ab47ae3381aa2372009a9054260461c20324b555Chris Lattner Defs.push_back(I->second); 2006ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20075c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 2008ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 2009d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 2010