Record.cpp revision ee6dca17252de152720655282fb4b74b76fb2fe9
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 { 703cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *Resolved = resolveReferences(R, IRV); 704cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene OpInit *OResolved = dynamic_cast<OpInit *>(Resolved); 705cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (OResolved) { 706cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Resolved = OResolved->Fold(&R, 0); 707cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene } 708d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 709cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (Resolved != this) { 710cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene TypedInit *Typed = dynamic_cast<TypedInit *>(Resolved); 711cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene assert(Typed && "Expected typed init for list reference"); 712d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 713cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *New = Typed->resolveListElementReference(R, IRV, Elt); 714cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (New) 715cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return New; 716cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return VarListElementInit::get(Typed, Elt); 71721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 718d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 71921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 720d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 721d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 722d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 72305bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 72405bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 7256f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7266f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene typedef DenseMap<Key, UnOpInit *> Pool; 7276f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene static Pool ThePool; 7286f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7296f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7306f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7316f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7326f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7336f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 734dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 735dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 73605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 737e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 738e6c27de069225e1122c78385ad22a2ff656db8e6David Greene default: assert(0 && "Unknown unop"); 739e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7402c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 74105bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 7422c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSs) { 7432c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 7442c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 745e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 74605bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 7472c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSd) { 748dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 7492c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 75021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 75105bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 7522c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (LHSs) { 7532c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7542c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7552c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7562c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7572c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 758c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 759c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 760dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 761e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 762e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7632c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string TemplateArgName = CurRec->getName()+":"+Name; 7642c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7652c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7662c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 767e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 768c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 769c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 770e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 771dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 772e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 773e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 774e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7752c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 7762c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string MCName = CurMultiClass->Rec.getName()+"::"+Name; 7772c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 7782c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 7792c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 78021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 781c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 782c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 78321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 784dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 7852c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 7862c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 78721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 78867db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 78977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 790e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7915d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n"); 7922c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 793e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 794e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 795e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 7961434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 79705bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 7985f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 7995f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 8005f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in car"); 8015f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 8025f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8035f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 8045f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8055f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8065f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8071434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 80805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 8095f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 8105f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 8115f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in cdr"); 8125f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 8135f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 814dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 815dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 81605bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 81705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 81805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 81905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 820dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 8215f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 8225f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8235f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8245f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8251434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 82605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LHSl = dynamic_cast<ListInit*>(LHS); 8275f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl) { 8285f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 829dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 83021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 831dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8325f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8335f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 83405bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 835e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs) { 836e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 837dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 83821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 839dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 840e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 841e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 84221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8435f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8445f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 845e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 84605bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 847e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 848e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 84905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 85005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 85121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 852e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 853dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 854e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Fold(&R, 0); 855e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 856e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 857e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 858e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 859e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 860e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8611434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8621434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8631434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 864e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 865e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 866e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 867d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 86805bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 86905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 87065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 87105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 87265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 87365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 87465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef DenseMap<Key, BinOpInit *> Pool; 87665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene static Pool ThePool; 87765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 87965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 88065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 88165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 88265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 88365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 884dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 885dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 88605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 887711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 888711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner default: assert(0 && "Unknown binop"); 88930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 89005bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *LHSs = dynamic_cast<DagInit*>(LHS); 89105bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *RHSs = dynamic_cast<DagInit*>(RHS); 89230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 89305bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator()); 89405bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator()); 8950b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 8960b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner throw "Concated Dag operators do not match!"; 89705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 89830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 89930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 90030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 90130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 90230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 90330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 90430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 90530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 90630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 907dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 90830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 90930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 91030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 911711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 91205bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 91305bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 914711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 915dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 916711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 917711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9186786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 919e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 920e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 92105bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit* L = 92205bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); 92305bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit* R = 92405bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); 925e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 926e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 927dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 928e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 92905bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 93005bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 931e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 932e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9336786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 934dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9356786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9366786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9376786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 938711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 939711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 940711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 94105bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 94205bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *RHSi = dynamic_cast<IntInit*>(RHS); 943711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 94463f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 94563f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 946711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 947711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner default: assert(0 && "Bad opcode!"); 948711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 949711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 95063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 951711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 952dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 953711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 954711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 955711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 956711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 95705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 958711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 959711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 96005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 96105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 96205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 96321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 964711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 965dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 966c7cafcd815519b06318629b424abe746437e1389David Greene return Fold(&R, 0); 967711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 968711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 9693aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 9703aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 971711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 9723aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 9733aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 9743aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 9753aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 9766786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 9773aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 978711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9793aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 980711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 981711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 98205bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 98305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 984dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 985b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 986b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 98705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 98805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 989b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 99005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 991b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 992b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 993b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 994b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 995b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 996b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 997b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 998b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 999b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 1000b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 1001b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 1002b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 1003b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 1004b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 1005dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1006dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 100705bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 100805bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 1009beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 101005bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 101105bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 101205bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 101305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 1014beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 101505bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *TArg = dynamic_cast<TypedInit*>(Arg); 1016beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1017beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 1018beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 101905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 1020d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1021beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1022beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 102321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1024beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1025beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1026beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1027beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1028beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 102905bce0beee87512e52428d4b80f5a8e79a949576David Greene OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); 1030beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1031beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 103205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1033d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1034beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1035beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 103621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1037beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1038beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 103921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1040beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 104121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1042beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1043beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1044beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1045beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1046beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1047f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 104805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1049dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewVal != NewOp) 1050beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return NewVal; 1051dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1052beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1053beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1054beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 105505bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 105605bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 105705bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MHSd = dynamic_cast<DagInit*>(MHS); 105805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *MHSl = dynamic_cast<ListInit*>(MHS); 1059beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1060beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type); 1061beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type); 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 106305bce0beee87512e52428d4b80f5a8e79a949576David Greene OpInit *RHSo = dynamic_cast<OpInit*>(RHS); 1064beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 10665d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); 1067beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1068beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 106905bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); 1070beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1071beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!LHSt) { 10725d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1073beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1074beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1075c98a77d078ab5ec443576facb1402025c093f64aNick Lewycky if ((MHSd && DagType) || (MHSl && ListType)) { 1076beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 107705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 107805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1079d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1081beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1082beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1083beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 108405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1085beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 108605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1087beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1088beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1089beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1090beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1091beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 109205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1093d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1094beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1097beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1098beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1099beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1100beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1101beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1102dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1103beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1104beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 110505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 110605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1107beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 110805bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1109beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1110beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1111beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 111205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1113beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1114beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1115beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1116beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1117beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 111821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1119beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1120beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1121beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1122beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1123beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1124f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 112505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1126dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1127beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1128beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1129dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1130beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1131beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1132beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1133beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1134beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 113505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11364afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11374afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene default: assert(0 && "Unknown binop"); 11384afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 113905bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *LHSd = dynamic_cast<DefInit*>(LHS); 114005bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *LHSv = dynamic_cast<VarInit*>(LHS); 114105bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *LHSs = dynamic_cast<StringInit*>(LHS); 11424afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 114305bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *MHSd = dynamic_cast<DefInit*>(MHS); 114405bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *MHSv = dynamic_cast<VarInit*>(MHS); 114505bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *MHSs = dynamic_cast<StringInit*>(MHS); 11464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 114705bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *RHSd = dynamic_cast<DefInit*>(RHS); 114805bce0beee87512e52428d4b80f5a8e79a949576David Greene VarInit *RHSv = dynamic_cast<VarInit*>(RHS); 114905bce0beee87512e52428d4b80f5a8e79a949576David Greene StringInit *RHSs = dynamic_cast<StringInit*>(RHS); 11504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11514afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11524afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11534afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11544afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11554afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11574afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11584afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 115977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11604afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11614afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11624afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11634afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11644afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11654afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1166dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11674afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11684afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11694afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11704afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11714afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1172f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1174f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 11754afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 11764afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 11774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1178f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 11794afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 11804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1181dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 11824afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11834afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 118521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 11864afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11874afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 118805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1189beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1190beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1191beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 11924afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11934afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 11944afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11959bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 11969bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 119705bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *LHSi = dynamic_cast<IntInit*>(LHS); 119805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 119905bce0beee87512e52428d4b80f5a8e79a949576David Greene LHSi = dynamic_cast<IntInit*>(I); 12009bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 12019bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 12029bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 120321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 12049bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 12059bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12069bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12079bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 12089bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 121105bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 12124afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12134afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 121405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 121505bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 121605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 121777c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 121877c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 121905bce0beee87512e52428d4b80f5a8e79a949576David Greene IntInit *Value = dynamic_cast<IntInit*>(lhs); 122005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 122105bce0beee87512e52428d4b80f5a8e79a949576David Greene Value = dynamic_cast<IntInit*>(I); 122277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value != 0) { 122377c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 122477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 122505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1226dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1227dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS, getType()))->Fold(&R, 0); 122821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 122905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1230dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1231dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene rhs, getType()))->Fold(&R, 0); 123277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123377c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 123605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 123705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 123877c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12394afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1240dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1241dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()))->Fold(&R, 0); 12424afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return Fold(&R, 0); 12434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12444afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12454afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12474afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12484afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 124921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 125021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12514afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 125221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12534afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12544afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1255e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12569703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 12579703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene RecordRecTy *RecordType = dynamic_cast<RecordRecTy *>(getType()); 12589703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene if (RecordType) { 12599703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene RecordVal *Field = RecordType->getRecord()->getValue(FieldName); 12609703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene if (Field) { 12619703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 12629703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene } 12639703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene } 12649703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return 0; 12659703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12669703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 126705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1268f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1269db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType()); 1270ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-bits variable. 1271e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1272e62c1185bee05facc25d1d725434f517261d308bChris Lattner 127305bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1274e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1275ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1276e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1277ca7fd3de360b266783438666054dba198ff77ba2David Greene 127805bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1279e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1280dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1281e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1282e62c1185bee05facc25d1d725434f517261d308bChris Lattner 128305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1284f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 12851dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListRecTy *T = dynamic_cast<ListRecTy*>(getType()); 1286ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-list variable. 12871dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12881dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 128905bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 12901dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 129105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 12921dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 12931dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 129405bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 129505bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1296dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 12971dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 12981dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12991dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 130005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1301ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *Value = StringInit::get(VN); 1302ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return VarInit::get(Value, T); 1303ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1304ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1305ee6dca17252de152720655282fb4b74b76fb2fe9David GreeneVarInit *VarInit::get(Init *VN, RecTy *T) { 1306ee6dca17252de152720655282fb4b74b76fb2fe9David Greene typedef std::pair<RecTy *, Init *> Key; 1307e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef DenseMap<Key, VarInit *> Pool; 1308e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene static Pool ThePool; 1309e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1310e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1311e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1312e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1313e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1314e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1315dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1316dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1317ee6dca17252de152720655282fb4b74b76fb2fe9David Greeneconst std::string &VarInit::getName() const { 1318ee6dca17252de152720655282fb4b74b76fb2fe9David Greene StringInit *NameString = 1319ee6dca17252de152720655282fb4b74b76fb2fe9David Greene dynamic_cast<StringInit *>(getNameInit()); 1320ee6dca17252de152720655282fb4b74b76fb2fe9David Greene assert(NameString && "VarInit name is not a string!"); 1321ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return NameString->getValue(); 1322ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1323ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 132405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveBitReference(Record &R, const RecordVal *IRV, 132505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 13267dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (R.isTemplateArg(getName())) return 0; 13277dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (IRV && IRV->getName() != getName()) return 0; 1328e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1329db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner RecordVal *RV = R.getValue(getName()); 1330a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 133105bce0beee87512e52428d4b80f5a8e79a949576David Greene assert(dynamic_cast<BitsInit*>(RV->getValue())); 133205bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *BI = (BitsInit*)RV->getValue(); 13333da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1334db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 133505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *B = BI->getBit(Bit); 1336e62c1185bee05facc25d1d725434f517261d308bChris Lattner 13372214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the bit is set to some value, or if we are resolving a reference to a 13382214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // specific variable and that variable is explicitly unset, then replace the 13392214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // VarBitInit with it. 134005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IRV || !dynamic_cast<UnsetInit*>(B)) 13412214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return B; 13421dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 1343e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1344e62c1185bee05facc25d1d725434f517261d308bChris Lattner 134505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 134605bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 134705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 13487dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (R.isTemplateArg(getName())) return 0; 13497dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (IRV && IRV->getName() != getName()) return 0; 13501dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13511dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner RecordVal *RV = R.getValue(getName()); 1352a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 135305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); 1354ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 1355cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene TypedInit *VI = dynamic_cast<TypedInit*>(RV->getValue()); 1356ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1357dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1358ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 135921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13601dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 13611dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; // Out of range reference. 136205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13632214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13642214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13652214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 136605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IRV || !dynamic_cast<UnsetInit*>(E)) 13672214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 13681dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 13691dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13701dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13711dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1372b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1373b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType())) 1374b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1375b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1376b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1377b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1378b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 137905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 138005bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 13819ec4849ff6cd771f53a1340aa6383702b7a6bb98Reid Spencer if (dynamic_cast<RecordRecTy*>(getType())) 1382d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 138305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue()))) 1384d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen return 0; 138505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1386ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 138705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1388b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1389b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 139024151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return 0; 1391ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1392b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1393b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1394b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 13959b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1396a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 13979b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 13989b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 13999b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 140005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 14019b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 140205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue()))) 14039b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 140405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 14059b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 14063da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 140705bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 140805bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1409aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1410aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1411aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1412aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1413aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1414aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1415aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1416aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1417aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1418dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1419dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14203aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 14213aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 14223aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1423db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 142405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 142505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) 1426db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner return I; 142705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarBitInit *>(this); 1428db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1429db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 143005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 143105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 143205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 143308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 143408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 143508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 143608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 143708f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 143808f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 143908f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 144008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 144108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1442dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1443dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14443aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 14453aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 14463aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 14473aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 144805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 144905bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 145005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1451d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 14521dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 145305bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 14541dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14551dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 145605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV, 145705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 14581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner // FIXME: This should be implemented, to support references like: 14591dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner // bit B = AA[0]{1}; 14601dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14611dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14621dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 146305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 146405bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 146505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14661045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14671045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14681045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14691045a594e65c65c55dfcd9585658eee85ef79e75David Greene TypedInit *TInit = dynamic_cast<TypedInit *>(Result); 14701045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (TInit) { 1471d2b9f20b188966722bca10714c237aa036e8c808David Greene Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1472d2b9f20b188966722bca10714c237aa036e8c808David Greene if (Result2) return Result2; 1473d2b9f20b188966722bca10714c237aa036e8c808David Greene return new VarListElementInit(TInit, Elt); 14741045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14751045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14761045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14771045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14781dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14791dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14801dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 148105bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 148277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 148377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 148477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1485b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1486b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1487b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1488b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1489b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1490b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 149105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 149205bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1493b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1494b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1495b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1496b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14973aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 14983aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1499e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1500e62c1185bee05facc25d1d725434f517261d308bChris Lattner 150105bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 150205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 150365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 150465bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 150565bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 150665bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 150765bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 150865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 150965bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 151065bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1511dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1512dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 151305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveBitReference(Record &R, const RecordVal *RV, 151405bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Bit) const { 151505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName)) 151605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) { 151724151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner assert(Bit < BI->getNumBits() && "Bit reference out of range!"); 151805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *B = BI->getBit(Bit); 15193da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 152005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<BitInit*>(B)) // If the bit is set. 152124151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return B; // Replace the VarBitInit with it. 152224151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner } 15231dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 15241dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 15251dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 152605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 152705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 152805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 152905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) { 15301dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) return 0; 153105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 15321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 15332214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 15342214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 15352214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 153605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (RV || !dynamic_cast<UnsetInit*>(E)) 15372214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 15381dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 15391dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 154024151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 154124151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 154205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 154305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 15447dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 154505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 154624151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 154705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 154805bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1549b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 15507dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 15517dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1552dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 15537dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 155405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1555db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1556db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 155778621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid ProfileDagInit(FoldingSetNodeID &ID, 155805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *V, 155978621a851ae84520de7d24a6d61e1dcf25749712David Greene const std::string &VN, 156005bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 156178621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 156278621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 156378621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 156478621a851ae84520de7d24a6d61e1dcf25749712David Greene 156505bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 156678621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 156778621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 156878621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 156978621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 157078621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 157178621a851ae84520de7d24a6d61e1dcf25749712David Greene } 157278621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 157378621a851ae84520de7d24a6d61e1dcf25749712David Greene} 157478621a851ae84520de7d24a6d61e1dcf25749712David Greene 157505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 157605bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 157705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 157878621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 157978621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 158078621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 158178621a851ae84520de7d24a6d61e1dcf25749712David Greene 158278621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 158378621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 158478621a851ae84520de7d24a6d61e1dcf25749712David Greene 158578621a851ae84520de7d24a6d61e1dcf25749712David Greene void *IP = 0; 158605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 158778621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 158878621a851ae84520de7d24a6d61e1dcf25749712David Greene 158978621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 159078621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 159178621a851ae84520de7d24a6d61e1dcf25749712David Greene 159278621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 159378621a851ae84520de7d24a6d61e1dcf25749712David Greene} 159478621a851ae84520de7d24a6d61e1dcf25749712David Greene 159505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 159605bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 159705bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 159805bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1599dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 160005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1601dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1602dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1603dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1604dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1605dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1606dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1607dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1608dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1609dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1610dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1611dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1612dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1613dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 161478621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 161578621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1616dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1617dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 161805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 161905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1620273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1621273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 162221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 162305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 162421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 16258c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1626dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 162721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 162805bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1629273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1630273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1631db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 16323aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 16333aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 16347cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 16357cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 16368e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner if (Args.size()) { 16373aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 16383aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 163991290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 16403aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 16413aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 164291290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 16438e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 16443aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 16458e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 16468e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 16478e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1648e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1649e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1650e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1651e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1652011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1653e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1654dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1655e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1656e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1657e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1658011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1659011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1660011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1661011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1662011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1663011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1664011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 1665011dca7fac07100695dd3685bfaddbea58a468b9David Greene StringInit *NameString = dynamic_cast<StringInit *>(Name); 1666011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1667011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1668011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1669011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16701a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1671e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16721a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1673e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1674e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << *getType() << " " << getName(); 16757dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16767dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1677e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16787dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1679e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1680e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1681e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16826f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16836f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 16840d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16850d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16860d886401b3ec09b0c2d267942b07702a2f0740f4David Greene const TypedInit *TypedName = dynamic_cast<const TypedInit *>(Name); 16870d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16880d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 16890d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (dynamic_cast<StringRecTy *>(Type) == 0) { 16900d886401b3ec09b0c2d267942b07702a2f0740f4David Greene llvm_unreachable("Record name is not a string!"); 16910d886401b3ec09b0c2d267942b07702a2f0740f4David Greene } 16920d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16930d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 169477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 169577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 169677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 169777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 169877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 169977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 17000d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 17010d886401b3ec09b0c2d267942b07702a2f0740f4David Greene const StringInit *NameString = 17020d886401b3ec09b0c2d267942b07702a2f0740f4David Greene dynamic_cast<const StringInit *>(Name); 17030d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 17040d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 17050d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17060d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17070d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 17080d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 17090d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeDef(Name->getAsUnquotedString()); 17100d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Name = NewName; 171167db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addDef(this); 1712936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } else { 17130d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeClass(Name->getAsUnquotedString()); 17140d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Name = NewName; 171567db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addClass(this); 1716936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } 17170d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 17180d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Since the Init for the name was changed, see if we can resolve 17190d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // any of it using members of the Record. 17200d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Init *ComputedName = Name->resolveReferences(*this, 0); 17210d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (ComputedName != Name) { 17220d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(ComputedName); 17230d886401b3ec09b0c2d267942b07702a2f0740f4David Greene } 17240d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 17250d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 17260d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 17270d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 17280d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 17290d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 17300d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 17310d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 17320d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 17330d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 17340d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 17350d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17360d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17370d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 17380d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 1739936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner} 1740936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner 174196a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greeneconst RecordVal *Record::getValue(Init *Name) const { 174296a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene for (unsigned i = 0, e = Values.size(); i != e; ++i) 174396a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene if (Values[i].getNameInit() == Name) return &Values[i]; 174496a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene return 0; 174596a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 174696a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 174796a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid GreeneRecordVal *Record::getValue(Init *Name) { 174896a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene for (unsigned i = 0, e = Values.size(); i != e; ++i) 174996a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene if (Values[i].getNameInit() == Name) return &Values[i]; 175096a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene return 0; 175196a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 175296a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 17537dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 17547dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 17557dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 17567dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 17577dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 175805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 17597dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner Values[i].setValue(V->resolveReferences(*this, RV)); 17607dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 1761e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1762e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17631a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1764e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17651a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 1766e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << R.getName(); 1767e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1768e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<std::string> &TArgs = R.getTemplateArgs(); 1769e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1770e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1771e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1772e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1773e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1774e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1775e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1776e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1777e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1778e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1779e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1780e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1781e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1782e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1783e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1784e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1785e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " " << SC[i]->getName(); 1786e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1787e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1788e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1789e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1790e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1791e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1792e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1793e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1794e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1795e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1796e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1797e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1798e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1799e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1800c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 1801c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// or throw an exception if the field does not exist. 1802c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 180305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1804c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1805c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner if (R == 0 || R->getValue() == 0) 1806cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1807c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1808c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1809c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1810c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1811c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 18125c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 18135c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// value as a string, throwing an exception if the field does not exist or if 18145c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 18155c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1816c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 18175c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 18185c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (R == 0 || R->getValue() == 0) 1819cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1820c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 18215c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 182205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (StringInit *SI = dynamic_cast<StringInit*>(R->getValue())) 18235c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 1824c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 18255c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner "' does not have a string initializer!"; 18265c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 18275c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 18286f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 18296f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// its value as a BitsInit, throwing an exception if the field does not exist 18306f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// or if the value is not the right type. 18316f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 183205bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 18336f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 18346f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner if (R == 0 || R->getValue() == 0) 1835cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1836c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 18376f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 183805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) 18396f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 1840c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 18416f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner "' does not have a BitsInit initializer!"; 18426f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 18436f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 184458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 184558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// its value as a ListInit, throwing an exception if the field does not exist 184658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// or if the value is not the right type. 184758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 184805bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 184958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 185058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1851cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1852c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 185358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 185405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) 185558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 1856c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 185758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner "' does not have a list initializer!"; 185858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18596f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1860b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 1861fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// its value as a vector of records, throwing an exception if the field does 1862fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// not exist or if the value is not the right type. 1863fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 186421870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1865c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 186605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1867fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1868fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 186905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { 1870fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1871fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 1872c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1873fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey "' list is not entirely DefInit!"; 1874fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1875fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1876fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1877fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1878fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 187958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 188063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman/// value as an int64_t, throwing an exception if the field does not exist or if 188158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// the value is not the right type. 188258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1883c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 188458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 188558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1886cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1887c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 188858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 188905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) 189058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 1891c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1892004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have an int initializer!"; 189358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18945c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1895af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 1896af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// its value as a vector of integers, throwing an exception if the field does 1897af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// not exist or if the value is not the right type. 1898af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 189921870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1900c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 190105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 190263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1903af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 190405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { 1905af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1906af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 1907c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1908af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov "' does not have a list of ints initializer!"; 1909af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1910af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1911af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1912af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1913af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1914bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 1915bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// returns its value as a vector of strings, throwing an exception if the 1916bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// field does not exist or if the value is not the right type. 1917bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1918bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1919bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 192005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1921bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1922bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 192305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { 1924bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1925bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 1926bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson throw "Record `" + getName() + "', field `" + FieldName.str() + 1927bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson "' does not have a list of strings initializer!"; 1928bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1929bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1930bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1931bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1932bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1933dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 1934dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// value as a Record, throwing an exception if the field does not exist or if 1935dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// the value is not the right type. 1936dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1937c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1938dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1939dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner if (R == 0 || R->getValue() == 0) 1940cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1941c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1942dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 194305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) 1944dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 1945c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1946004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have a def initializer!"; 1947dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1948dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19490969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 19500969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// value as a bit, throwing an exception if the field does not exist or if 19510969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// the value is not the right type. 19520969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1953c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 19540969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 19550969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner if (R == 0 || R->getValue() == 0) 1956cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1957c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 19580969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 195905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) 1960784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 1961c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1962784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a bit initializer!"; 1963784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1964784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1965784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 1966784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// value as an Dag, throwing an exception if the field does not exist or if 1967784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// the value is not the right type. 1968784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 196905bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1970784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1971784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner if (R == 0 || R->getValue() == 0) 1972cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1973c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1974784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 197505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) 1976784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 1977c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1978784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a dag initializer!"; 19790969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19800969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1981c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsCode(StringRef FieldName) const { 19828f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner const RecordVal *R = getValue(FieldName); 19838f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner if (R == 0 || R->getValue() == 0) 19848f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner throw "Record `" + getName() + "' does not have a field named `" + 1985c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 198621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 198705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (CodeInit *CI = dynamic_cast<CodeInit*>(R->getValue())) 19888f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner return CI->getValue(); 1989c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 19908f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner "' does not have a code initializer!"; 19918f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner} 19928f493130bb51dea34c49e08aeab161e6a32dfdc6Chris Lattner 1993dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1994d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19951a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1996d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 199721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19981a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1999d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 2000d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 2001d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 2002d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 2003d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 2004d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 2005d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 2006d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 2007d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 20081a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 2009e62c1185bee05facc25d1d725434f517261d308bChris Lattner 20101a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 2011e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 2012e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Classes = RK.getClasses(); 2013e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 2014ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 2015e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "class " << *I->second; 20163da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 2017e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 2018e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Defs = RK.getDefs(); 2019e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 2020ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 2021e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "def " << *I->second; 2022e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 2023e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 2024ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2025ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2026ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 2027ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 2028ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 20295c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 20305c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 20319d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 20325c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 2033cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "ERROR: Couldn't find the `" + ClassName + "' class!\n"; 2034ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20355c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 2036ab47ae3381aa2372009a9054260461c20324b555Chris Lattner for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 2037ab47ae3381aa2372009a9054260461c20324b555Chris Lattner E = getDefs().end(); I != E; ++I) 2038ab47ae3381aa2372009a9054260461c20324b555Chris Lattner if (I->second->isSubClassOf(Class)) 2039ab47ae3381aa2372009a9054260461c20324b555Chris Lattner Defs.push_back(I->second); 2040ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20415c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 2042ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 2043d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 2044