Record.cpp revision 3f7b7f8ce0b050fc6a0100839d9c5a84198b2aed
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" 21c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth#include "llvm/ADT/Hashing.h" 22ca7fd3de360b266783438666054dba198ff77ba2David Greene#include "llvm/ADT/SmallVector.h" 23ca7fd3de360b266783438666054dba198ff77ba2David Greene#include "llvm/ADT/STLExtras.h" 2499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner#include "llvm/ADT/StringExtras.h" 25d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene#include "llvm/ADT/StringMap.h" 266fb9a84e79212f550981b6545aa435e7ca0cd794Duraid Madina 272082ebe8b3a5db302748828ab4f79a36d239c1d9Chris Lattnerusing namespace llvm; 28e62c1185bee05facc25d1d725434f517261d308bChris Lattner 29e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 30cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene// std::string wrapper for DenseMap purposes 31cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene//===----------------------------------------------------------------------===// 32cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 33c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruthnamespace llvm { 34c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth 35cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// TableGenStringKey - This is a wrapper for std::string suitable for 36cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// using as a key to a DenseMap. Because there isn't a particularly 37cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// good way to indicate tombstone or empty keys for strings, we want 38cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// to wrap std::string to indicate that this is a "special" string 39cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// not expected to take on certain values (those of the tombstone and 40cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// empty keys). This makes things a little safer as it clarifies 41cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// that DenseMap is really not appropriate for general strings. 42cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 43cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greeneclass TableGenStringKey { 44cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greenepublic: 45cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey(const std::string &str) : data(str) {} 46cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey(const char *str) : data(str) {} 47cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 48cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene const std::string &str() const { return data; } 49c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth 50c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth friend hash_code hash_value(const TableGenStringKey &Value) { 51c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth using llvm::hash_value; 52c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth return hash_value(Value.str()); 53c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth } 54cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greeneprivate: 55cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene std::string data; 56cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene}; 57cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 58cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene/// Specialize DenseMapInfo for TableGenStringKey. 59cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greenetemplate<> struct DenseMapInfo<TableGenStringKey> { 60cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static inline TableGenStringKey getEmptyKey() { 61cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey Empty("<<<EMPTY KEY>>>"); 62cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return Empty; 63cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 64cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static inline TableGenStringKey getTombstoneKey() { 65cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene TableGenStringKey Tombstone("<<<TOMBSTONE KEY>>>"); 66cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return Tombstone; 67cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 68cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static unsigned getHashValue(const TableGenStringKey& Val) { 69c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth using llvm::hash_value; 70c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth return hash_value(Val); 71cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 72cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene static bool isEqual(const TableGenStringKey& LHS, 73cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene const TableGenStringKey& RHS) { 74cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene return LHS.str() == RHS.str(); 75cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene } 76cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene}; 77cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 78c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth} // namespace llvm 79cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene 80cd0bc905d2c100edbf2f65ac7f1d58353fb1728cDavid Greene//===----------------------------------------------------------------------===// 81e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Type implementations 82e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 83e62c1185bee05facc25d1d725434f517261d308bChris Lattner 8477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitRecTy BitRecTy::Shared; 8577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenIntRecTy IntRecTy::Shared; 8677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenStringRecTy StringRecTy::Shared; 8777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDagRecTy DagRecTy::Shared; 8877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 892d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid RecTy::anchor() { } 901a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecTy::dump() const { print(errs()); } 91e62c1185bee05facc25d1d725434f517261d308bChris Lattner 9277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenListRecTy *RecTy::getListTy() { 9377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!ListTy) 9477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen ListTy = new ListRecTy(this); 9577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return ListTy; 9677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 9777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 9805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(BitsInit *BI) { 99e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! 100e62c1185bee05facc25d1d725434f517261d308bChris Lattner return BI->getBit(0); 101e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 102e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1037cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerbool BitRecTy::baseClassOf(const BitsRecTy *RHS) const { 1047cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->getNumBits() == 1; 1057cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 1067cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 10705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(IntInit *II) { 10863f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Val = II->getValue(); 109e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! 1103da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 111dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitInit::get(Val != 0); 112e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 113e62c1185bee05facc25d1d725434f517261d308bChris Lattner 11405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(TypedInit *VI) { 115307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao RecTy *Ty = VI->getType(); 11663554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<BitRecTy>(Ty) || isa<BitsRecTy>(Ty) || isa<IntRecTy>(Ty)) 117e62c1185bee05facc25d1d725434f517261d308bChris Lattner return VI; // Accept variable if it is already of bit type! 118e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 119e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 120e62c1185bee05facc25d1d725434f517261d308bChris Lattner 12177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitsRecTy *BitsRecTy::get(unsigned Sz) { 12277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static std::vector<BitsRecTy*> Shared; 12377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (Sz >= Shared.size()) 12477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Shared.resize(Sz + 1); 12577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen BitsRecTy *&Ty = Shared[Sz]; 12677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!Ty) 12777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Ty = new BitsRecTy(Sz); 12877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return Ty; 12977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 13077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 13199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string BitsRecTy::getAsString() const { 13299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "bits<" + utostr(Size) + ">"; 13399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 13499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 13505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(UnsetInit *UI) { 13605bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 137e62c1185bee05facc25d1d725434f517261d308bChris Lattner 138e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 139dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = UnsetInit::get(); 140ca7fd3de360b266783438666054dba198ff77ba2David Greene 141dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 142e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 143e62c1185bee05facc25d1d725434f517261d308bChris Lattner 14405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitInit *UI) { 145ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (Size != 1) return 0; // Can only convert single bit. 146dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(UI); 147e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 148e62c1185bee05facc25d1d725434f517261d308bChris Lattner 149548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// canFitInBitfield - Return true if the number of bits is large enough to hold 150548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// the integer value. 151548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendlingstatic bool canFitInBitfield(int64_t Value, unsigned NumBits) { 152b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky // For example, with NumBits == 4, we permit Values from [-7 .. 15]. 153b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky return (NumBits >= sizeof(Value) * 8) || 154b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); 155548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling} 156548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 157d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// convertValue from Int initializer to bits type: Split the integer up into the 158d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// appropriate bits. 159548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// 16005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(IntInit *II) { 161294984cecbe1e5abbe37dc38bf2941f2804b13caMisha Brukman int64_t Value = II->getValue(); 162ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // Make sure this bitfield is large enough to hold the integer value. 163548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (!canFitInBitfield(Value, Size)) 164548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling return 0; 165e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16605bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 167ca7fd3de360b266783438666054dba198ff77ba2David Greene 168e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 169dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (1LL << i)); 170d19c2cf5d2ae5b263df3f4c7c9744cdf3946f89bChris Lattner 171dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 172e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 173e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitsInit *BI) { 175e62c1185bee05facc25d1d725434f517261d308bChris Lattner // If the number of bits is right, return it. Otherwise we need to expand or 176ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // truncate. 177e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() == Size) return BI; 178e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 179e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 180e62c1185bee05facc25d1d725434f517261d308bChris Lattner 18105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(TypedInit *VI) { 18263554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (Size == 1 && isa<BitRecTy>(VI->getType())) 183dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(VI); 1843da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 185307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (VI->getType()->typeIsConvertibleTo(this)) { 186307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao SmallVector<Init *, 16> NewBits(Size); 187d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 188307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0; i != Size; ++i) 189307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = VarBitInit::get(VI, i); 190307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return BitsInit::get(NewBits); 191548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 192548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 193e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 194e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 195e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitInit *BI) { 197dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(BI->getValue()); 19808ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner} 19908ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner 20005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitsInit *BI) { 20163f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result = 0; 2023da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 2036cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) { 204e62c1185bee05facc25d1d725434f517261d308bChris Lattner Result |= Bit->getValue() << i; 205e62c1185bee05facc25d1d725434f517261d308bChris Lattner } else { 206e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 207e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 208dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 209e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 210e62c1185bee05facc25d1d725434f517261d308bChris Lattner 21105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(TypedInit *TI) { 21208ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 213b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 214e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 215e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 216e62c1185bee05facc25d1d725434f517261d308bChris Lattner 21705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(UnOpInit *BO) { 218e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 21905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 220e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 221e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 222dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); 223e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 224e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 225e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 22605bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 227e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 228d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 22905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(BinOpInit *BO) { 230711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (BO->getOpcode() == BinOpInit::STRCONCAT) { 23105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 23205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 233711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L == 0 || R == 0) return 0; 234711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L != BO->getLHS() || R != BO->getRHS()) 235dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); 236711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner return BO; 237711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 238e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 23905bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 240711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 241711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 242711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 24305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(TypedInit *TI) { 24463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<StringRecTy>(TI->getType())) 245b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 246e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 247e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 248e62c1185bee05facc25d1d725434f517261d308bChris Lattner 24999ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string ListRecTy::getAsString() const { 25099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "list<" + Ty->getAsString() + ">"; 25199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 25299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 25305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(ListInit *LI) { 25405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Elements; 2557cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 256e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Verify that all of the elements of the list are subclasses of the 2577cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // appropriate class! 258e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = LI->getSize(); i != e; ++i) 25905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) 2607cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner Elements.push_back(CI); 2617cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner else 262e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 2637cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 26463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<ListRecTy>(LI->getType())) 265e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 266e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 267dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Elements, this); 268e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 269e62c1185bee05facc25d1d725434f517261d308bChris Lattner 27005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(TypedInit *TI) { 271f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with our class. 272736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType())) 2737cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) 274f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 275f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return 0; 276f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner} 277f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner 27805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(TypedInit *TI) { 27940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 28040f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return TI; 28140f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return 0; 28240f71134b9fef0ca06c516f033cc9403394a913cChris Lattner} 28340f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 28405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(UnOpInit *BO) { 285e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 28605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 287e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 288e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 289dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); 290e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 291e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 292e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 293e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 294d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 29505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(BinOpInit *BO) { 29630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (BO->getOpcode() == BinOpInit::CONCAT) { 29705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 29805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 29930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L == 0 || R == 0) return 0; 30030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L != BO->getLHS() || R != BO->getRHS()) 301dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); 30230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return BO; 30330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 30430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return 0; 30530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng} 30630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng 30777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenRecordRecTy *RecordRecTy::get(Record *R) { 308736ceace11249da645ec4ed91b8714832193ead4Sean Silva return dyn_cast<RecordRecTy>(R->getDefInit()->getType()); 30977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 31077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 31199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string RecordRecTy::getAsString() const { 31299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return Rec->getName(); 31399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 31440f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 31505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(DefInit *DI) { 316e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Ensure that DI is a subclass of Rec. 317e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!DI->getDef()->isSubClassOf(Rec)) 318e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 319e62c1185bee05facc25d1d725434f517261d308bChris Lattner return DI; 320e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 321e62c1185bee05facc25d1d725434f517261d308bChris Lattner 32205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(TypedInit *TI) { 323f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with Rec. 324736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RRT = dyn_cast<RecordRecTy>(TI->getType())) 325ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner if (RRT->getRecord()->isSubClassOf(getRecord()) || 326ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner RRT->getRecord() == getRecord()) 327f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 328ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner return 0; 329ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner} 330ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner 3317cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerbool RecordRecTy::baseClassOf(const RecordRecTy *RHS) const { 33293583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes if (Rec == RHS->getRecord() || RHS->getRecord()->isSubClassOf(Rec)) 33393583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 33493583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 33593583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes const std::vector<Record*> &SC = Rec->getSuperClasses(); 33693583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes for (unsigned i = 0, e = SC.size(); i != e; ++i) 33793583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes if (RHS->getRecord()->isSubClassOf(SC[i])) 33893583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 33993583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 34093583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return false; 3417cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 3427cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 34321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// resolveTypes - Find a common type that T1 and T2 convert to. 344e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// Return 0 if no such type exists. 345e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// 346e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid GreeneRecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { 34757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T1->typeIsConvertibleTo(T2)) 34857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T2; 34957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T2->typeIsConvertibleTo(T1)) 35057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T1; 35157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva 35257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // If one is a Record type, check superclasses 353736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) { 35457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T2 inherits from a type T1 also inherits from 35557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T1SuperClasses = 35657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy1->getRecord()->getSuperClasses(); 35757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), 35857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T1SuperClasses.end(); 35957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 36057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 36157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); 36257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); 36357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType1 != 0) { 36457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType1 != SuperRecTy1) { 36557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy1; 366e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 36757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType1; 368e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 36957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 37057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 371736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2)) { 37257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T1 inherits from a type T2 also inherits from 37357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T2SuperClasses = 37457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy2->getRecord()->getSuperClasses(); 37557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), 37657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T2SuperClasses.end(); 37757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 37857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 37957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); 38057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); 38157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType2 != 0) { 38257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType2 != SuperRecTy2) { 38357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy2; 384e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 38557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType2; 386e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 387e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 388e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 38957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return 0; 390e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 391e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 392e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 393e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 394e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Initializer implementations 395e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 396e62c1185bee05facc25d1d725434f517261d308bChris Lattner 3972d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid Init::anchor() { } 3981a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Init::dump() const { return print(errs()); } 399e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4002d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid UnsetInit::anchor() { } 4012d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 40205bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnsetInit *UnsetInit::get() { 40305bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnsetInit TheInit; 404ba1ae182876762f17201b33c0b87ca8ede156cfcDavid Greene return &TheInit; 405dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 406dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 4072d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid BitInit::anchor() { } 4082d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 40905bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitInit *BitInit::get(bool V) { 41005bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit True(true); 41105bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit False(false); 4120ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene 4130ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene return V ? &True : &False; 414dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 415dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 416726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenestatic void 41705bce0beee87512e52428d4b80f5a8e79a949576David GreeneProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { 418726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddInteger(Range.size()); 419726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 42005bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 421726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene iend = Range.end(); 422726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene i != iend; 423726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ++i) 424726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddPointer(*i); 425726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 426726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 42705bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *BitsInit::get(ArrayRef<Init *> Range) { 428726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene typedef FoldingSet<BitsInit> Pool; 429726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene static Pool ThePool; 430726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 431726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene FoldingSetNodeID ID; 432726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Range); 433726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 434726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene void *IP = 0; 43505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 436726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 437726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 438726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene BitsInit *I = new BitsInit(Range); 439726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ThePool.InsertNode(I, IP); 440726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 441726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 442726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 443726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 444726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenevoid BitsInit::Profile(FoldingSetNodeID &ID) const { 445726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Bits); 446dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 447dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 44805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 449f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneBitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 45005bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 451ca7fd3de360b266783438666054dba198ff77ba2David Greene 452e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 453ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= getNumBits()) 454e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 455ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = getBit(Bits[i]); 456e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 457dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 458e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 459e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4603aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BitsInit::getAsString() const { 4613aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "{ "; 462e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 4633aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 46405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *Bit = getBit(e-i-1)) 4653aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Bit->getAsString(); 46623ffa4a48820e58b411cf94a66b2a0d91173fbfaChris Lattner else 4673aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += "*"; 468e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 4693aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + " }"; 470e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 471e62c1185bee05facc25d1d725434f517261d308bChris Lattner 472307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// Fix bit initializer to preserve the behavior that bit reference from a unset 473307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// bits initializer will resolve into VarBitInit to keep the field name and bit 474307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// number used in targets with fixed insn length. 475307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liaostatic Init *fixBitInit(const RecordVal *RV, Init *Before, Init *After) { 476307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (RV || After != UnsetInit::get()) 477307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return After; 478307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return Before; 479307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 480307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 4819b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// resolveReferences - If there are any field references that refer to fields 4829b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// that have been filled in, we can propagate the values now. 4839b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// 48405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { 48528520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner bool Changed = false; 48605bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(getNumBits()); 48728520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 488307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CachedInit = 0; 489307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CachedBitVar = 0; 490307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao bool CachedBitVarChanged = false; 491307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 492307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 493307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBit = Bits[i]; 494307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBitVar = CurBit->getBitVar(); 495ade0de91236a5967e323a810b21bda4b0425642fChris Lattner 496ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = CurBit; 497307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 498307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CurBitVar == CachedBitVar) { 499307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 500307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CachedInit->getBit(CurBit->getBitNum()); 501307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 502307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 503307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao continue; 504307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 505307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVar = CurBitVar; 506307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged = false; 507307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 508307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *B; 509307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao do { 510307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao B = CurBitVar; 511307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CurBitVar = CurBitVar->resolveReferences(R, RV); 512307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged |= B != CurBitVar; 513307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Changed |= B != CurBitVar; 514307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } while (B != CurBitVar); 515307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedInit = CurBitVar; 516307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 517307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 518307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CurBitVar->getBit(CurBit->getBitNum()); 519307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 520307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 52128520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner } 52228520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 52328520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner if (Changed) 524dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 525ca7fd3de360b266783438666054dba198ff77ba2David Greene 52605bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BitsInit *>(this); 52728520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner} 52828520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 52905bce0beee87512e52428d4b80f5a8e79a949576David GreeneIntInit *IntInit::get(int64_t V) { 5302855b0f0730b1a31aa156ea667fee79f66be4b03David Greene typedef DenseMap<int64_t, IntInit *> Pool; 5312855b0f0730b1a31aa156ea667fee79f66be4b03David Greene static Pool ThePool; 5322855b0f0730b1a31aa156ea667fee79f66be4b03David Greene 5332855b0f0730b1a31aa156ea667fee79f66be4b03David Greene IntInit *&I = ThePool[V]; 5342855b0f0730b1a31aa156ea667fee79f66be4b03David Greene if (!I) I = new IntInit(V); 5352855b0f0730b1a31aa156ea667fee79f66be4b03David Greene return I; 536dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 537dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5383aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string IntInit::getAsString() const { 5393aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return itostr(Value); 5403aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 5413aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 54205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 543f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneIntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 54405bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 545e62c1185bee05facc25d1d725434f517261d308bChris Lattner 546e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 547ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= 64) 548e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 549ca7fd3de360b266783438666054dba198ff77ba2David Greene 550dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); 551d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene } 552dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 553dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 554dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5552d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid StringInit::anchor() { } 5562d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 557ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund OlesenStringInit *StringInit::get(StringRef V) { 558d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene typedef StringMap<StringInit *> Pool; 559d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene static Pool ThePool; 560d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene 561d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene StringInit *&I = ThePool[V]; 562d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene if (!I) I = new StringInit(V); 563d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene return I; 564dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 565dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 566aad4c9fc37b38cae21343173084c81d789535446David Greenestatic void ProfileListInit(FoldingSetNodeID &ID, 56705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> Range, 568aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy) { 569aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddInteger(Range.size()); 570aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(EltTy); 571aad4c9fc37b38cae21343173084c81d789535446David Greene 57205bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 573aad4c9fc37b38cae21343173084c81d789535446David Greene iend = Range.end(); 574aad4c9fc37b38cae21343173084c81d789535446David Greene i != iend; 575aad4c9fc37b38cae21343173084c81d789535446David Greene ++i) 576aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(*i); 577aad4c9fc37b38cae21343173084c81d789535446David Greene} 578aad4c9fc37b38cae21343173084c81d789535446David Greene 57905bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { 580aad4c9fc37b38cae21343173084c81d789535446David Greene typedef FoldingSet<ListInit> Pool; 581aad4c9fc37b38cae21343173084c81d789535446David Greene static Pool ThePool; 582aad4c9fc37b38cae21343173084c81d789535446David Greene 583aad4c9fc37b38cae21343173084c81d789535446David Greene // Just use the FoldingSetNodeID to compute a hash. Use a DenseMap 584aad4c9fc37b38cae21343173084c81d789535446David Greene // for actual storage. 585aad4c9fc37b38cae21343173084c81d789535446David Greene FoldingSetNodeID ID; 586aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Range, EltTy); 587aad4c9fc37b38cae21343173084c81d789535446David Greene 588aad4c9fc37b38cae21343173084c81d789535446David Greene void *IP = 0; 58905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 590aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 591aad4c9fc37b38cae21343173084c81d789535446David Greene 592aad4c9fc37b38cae21343173084c81d789535446David Greene ListInit *I = new ListInit(Range, EltTy); 593aad4c9fc37b38cae21343173084c81d789535446David Greene ThePool.InsertNode(I, IP); 594aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 595aad4c9fc37b38cae21343173084c81d789535446David Greene} 596aad4c9fc37b38cae21343173084c81d789535446David Greene 597aad4c9fc37b38cae21343173084c81d789535446David Greenevoid ListInit::Profile(FoldingSetNodeID &ID) const { 598736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *ListType = dyn_cast<ListRecTy>(getType()); 599aad4c9fc37b38cae21343173084c81d789535446David Greene assert(ListType && "Bad type for ListInit!"); 600aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy = ListType->getElementType(); 601aad4c9fc37b38cae21343173084c81d789535446David Greene 602aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Values, EltTy); 603d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene} 604d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene 60505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 606f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 60705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 608b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 609b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner if (Elements[i] >= getSize()) 610b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner return 0; 611b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner Vals.push_back(getElement(Elements[i])); 612b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner } 613dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Vals, getType()); 614b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner} 615b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 61650d456539dea5e61d7a1592a78f1861fb35b0063Chris LattnerRecord *ListInit::getElementAsRecord(unsigned i) const { 61750d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner assert(i < Values.size() && "List element index out of range!"); 6186cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Values[i]); 61950d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner if (DI == 0) throw "Expected record in list!"; 62050d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner return DI->getDef(); 62150d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner} 62250d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner 62305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 62405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Resolved; 6251dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.reserve(getSize()); 6261dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner bool Changed = false; 6271dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6281dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = getSize(); i != e; ++i) { 62905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E; 63005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurElt = getElement(i); 6311dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner do { 6331dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner E = CurElt; 6347dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurElt = CurElt->resolveReferences(R, RV); 6351dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Changed |= E != CurElt; 6361dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } while (E != CurElt); 6371dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.push_back(E); 6381dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 6391dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6401dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Changed) 641dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Resolved, getType()); 64205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<ListInit *>(this); 6431dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 6441dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 64505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 64605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 647e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Elt >= getSize()) 648e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; // Out of range reference. 64905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = getElement(Elt); 6502214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 6512214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 6522214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 6533f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 6542214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 655e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 656e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 657e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 6583aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string ListInit::getAsString() const { 6593aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "["; 6607cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 6613aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 6623aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Values[i]->getAsString(); 663e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 6643aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "]"; 665e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 666e62c1185bee05facc25d1d725434f517261d308bChris Lattner 66705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 66805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 669cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *Resolved = resolveReferences(R, IRV); 6706cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *OResolved = dyn_cast<OpInit>(Resolved); 671cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (OResolved) { 672cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Resolved = OResolved->Fold(&R, 0); 673cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene } 674d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 675cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (Resolved != this) { 6766cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *Typed = dyn_cast<TypedInit>(Resolved); 677cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene assert(Typed && "Expected typed init for list reference"); 678d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 679cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *New = Typed->resolveListElementReference(R, IRV, Elt); 680cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (New) 681cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return New; 682cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return VarListElementInit::get(Typed, Elt); 68321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 684d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 68521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 686d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 687d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 688d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 689307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *OpInit::getBit(unsigned Bit) const { 690307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 691307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<OpInit*>(this); 692307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<OpInit*>(this), Bit); 693307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 694307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 69505bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 69605bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 6976f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 6986f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene typedef DenseMap<Key, UnOpInit *> Pool; 6996f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene static Pool ThePool; 7006f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7016f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7026f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7036f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7046f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7056f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 706dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 707dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 70805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 709e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 710e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7112c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 7123f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) 7132c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 714e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7153f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) 716dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 717448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene 7183f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IntInit *LHSi = dyn_cast<IntInit>(LHS)) 719448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene return StringInit::get(LHSi->getAsString()); 72021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7213f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 7222c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7232c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7242c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7252c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7262c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 727c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 728c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 729dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 730e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 731e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 732e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, 733e22b321d2276b634519165b101b02d92c2fcf5c7David Greene ":"); 734e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7352c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7362c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7372c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 738e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 739c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 740c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 741e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 742dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 743e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 744e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 745e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7462c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 747e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); 748e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7492c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 7502c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 7512c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 75221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 753c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 754c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner throw "type mismatch in cast"; 75521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 756dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 7572c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 7582c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 75921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 76067db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 76177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 762e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7635d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n"); 7642c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 765e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 766e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 767e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 7681434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 7693f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7705f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 7715f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in car"); 7725f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7735f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7745f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 7755f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7765f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7775f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7781434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 7793f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7805f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 7815f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in cdr"); 7825f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7835f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 784dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 785dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 78605bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 78705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 78805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 78905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 790dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 7915f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 7925f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7935f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7945f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7951434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 7963f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7975f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 798dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 79921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 800dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8015f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8025f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8033f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 804e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 805dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 80621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 807dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 808e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 809e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 81021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8115f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8125f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 813e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 81405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 815e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 816e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 81705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 81805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 81921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 820e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 821dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 822e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Fold(&R, 0); 823e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 824e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 825e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 826e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 827e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 828e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8291434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8301434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8311434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 832e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 833e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 834e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 835d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 83605bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 83705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 83865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 83905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 84065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 84165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 84265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 84365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef DenseMap<Key, BinOpInit *> Pool; 84465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene static Pool ThePool; 84565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 84665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 84765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 84865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 84965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 85065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 85165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 852dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 853dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 85405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 855711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 85630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 8576cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *LHSs = dyn_cast<DagInit>(LHS); 8586cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *RHSs = dyn_cast<DagInit>(RHS); 85930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 8606cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator()); 8616cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator()); 8620b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 8630b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner throw "Concated Dag operators do not match!"; 86405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 86530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 86630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 86730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 86830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 86930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 87030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 87130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 87230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 87330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 874dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 87530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 87630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 87730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 878711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 8796cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 8806cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 881711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 882dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 883711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 884711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 8856786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 886e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 887e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 888307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *L = 8896cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())); 890307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *R = 8916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get())); 892e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 893e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 894dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 895e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 8966cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 8976cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 898e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 899e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9006786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 901dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9026786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9036786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9046786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 905711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 906711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 907711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 9086cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 9096cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *RHSi = dyn_cast<IntInit>(RHS); 910711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 91163f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 91263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 913711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 914858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Bad opcode!"); 915711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 916711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 91763f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 918711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 919dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 920711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 921711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 922711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 923711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 92405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 925711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 926711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 92705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 92805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 92905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 93021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 931711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 932dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 933c7cafcd815519b06318629b424abe746437e1389David Greene return Fold(&R, 0); 934711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 935711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 9363aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 9373aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 938711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 9393aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 9403aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 9413aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 9423aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 9436786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 9443aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 945711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9463aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 947711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 948711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 94905bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 95005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 951dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 952b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 953b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 95405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 95505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 956b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 95705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 958b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 959b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 960b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 961b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 962b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 963b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 964b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 965b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 966b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 967b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 968b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 969b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 970b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 971b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 972dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 973dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 97405bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 97505bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 976beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 97705bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 97805bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 97905bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 98005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 981beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 9826cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *TArg = dyn_cast<TypedInit>(Arg); 983beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 984beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 985beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 98605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 987d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 988beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 989beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 99021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 991beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 992beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 993beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 994beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 995beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 9966cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i)); 997beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 998beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 99905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1000d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1001beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1002beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 100321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1004beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1005beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 100621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1007beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 100821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1009beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1010beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1011beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1012beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1013beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1014f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 101505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1016dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewVal != NewOp) 1017beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return NewVal; 1018dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1019beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1020beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1021beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 102205bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 102305bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 10246cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *MHSd = dyn_cast<DagInit>(MHS); 10256cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *MHSl = dyn_cast<ListInit>(MHS); 1026beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10276cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSo = dyn_cast<OpInit>(RHS); 1028beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1029beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 10305d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); 1031beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1032beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10336cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *LHSt = dyn_cast<TypedInit>(LHS); 1034beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1035beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!LHSt) { 10365d754bfa320c558cbebded328454b75134f2cfeeJim Grosbach throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1037beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1038beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 103963554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if ((MHSd && isa<DagRecTy>(Type)) || (MHSl && isa<ListRecTy>(Type))) { 1040beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 104105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 104205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1043d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1044beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1045beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1046beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1047beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 104805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1049beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 105005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1051beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1052beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1053beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1054beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1055beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 105605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1057d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1058beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1059beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1060beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1061beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1063beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1064beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1066dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1067beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1068beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 106905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 107005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1071beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 107205bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1073beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1074beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1075beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 107605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1077beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1078beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1079beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1081beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 108221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1083beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1084beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1085beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1086beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1087beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1088f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 108905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1090dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1091beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1092beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1093dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1094beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1097beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1098beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 109905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11004afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 11026cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LHSd = dyn_cast<DefInit>(LHS); 11036cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *LHSv = dyn_cast<VarInit>(LHS); 11046cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 11054afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11066cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *MHSd = dyn_cast<DefInit>(MHS); 11076cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *MHSv = dyn_cast<VarInit>(MHS); 11086cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *MHSs = dyn_cast<StringInit>(MHS); 11094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11106cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *RHSd = dyn_cast<DefInit>(RHS); 11116cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *RHSv = dyn_cast<VarInit>(RHS); 11126cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 11134afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11144afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11154afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11164afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11174afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11184afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11194afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11204afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11214afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 112277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11234afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11244afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11254afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11264afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11274afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11284afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1129dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11304afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11314afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11324afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11334afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11344afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1135f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11364afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1137f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 11384afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 11394afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 11404afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1141f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 11424afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 11434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1144dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 11454afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11474afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 114821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 11494afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 115105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1152beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1153beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1154beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 11554afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 11574afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11589bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 11599bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 11606cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 116105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 11626cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva LHSi = dyn_cast<IntInit>(I); 11639bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 11649bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 11659bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 116621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 11679bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 11689bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11699bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11709bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 11719bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11724afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 117405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 11754afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 11764afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 117705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 117805bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 117905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 118077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 118177c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 11826cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *Value = dyn_cast<IntInit>(lhs); 118305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 11846cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva Value = dyn_cast<IntInit>(I); 118577c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value != 0) { 118677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 118777c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 118805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1189dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1190dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS, getType()))->Fold(&R, 0); 119121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 119205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1193dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1194dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene rhs, getType()))->Fold(&R, 0); 119577c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119777c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 119905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 120005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 120177c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12024afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1203dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1204dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()))->Fold(&R, 0); 12054afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return Fold(&R, 0); 12064afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12074afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12084afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12114afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 121221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 121321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12144afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 121521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12164afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12174afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1218e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12199703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 122063554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) 122163554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName)) 12229703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 12239703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return 0; 12249703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12259703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 122605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1227f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1228736ceace11249da645ec4ed91b8714832193ead4Sean Silva BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); 1229ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-bits variable. 1230e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1231e62c1185bee05facc25d1d725434f517261d308bChris Lattner 123205bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1233e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1234ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1235e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1236ca7fd3de360b266783438666054dba198ff77ba2David Greene 123705bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1238e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1239dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1240e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1241e62c1185bee05facc25d1d725434f517261d308bChris Lattner 124205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1243f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 1244736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *T = dyn_cast<ListRecTy>(getType()); 1245ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-list variable. 12461dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12471dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 124805bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 12491dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 125005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 12511dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 12521dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 125305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 125405bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1255dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 12561dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 12571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 125905bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1260ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *Value = StringInit::get(VN); 1261ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return VarInit::get(Value, T); 1262ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1263ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1264ee6dca17252de152720655282fb4b74b76fb2fe9David GreeneVarInit *VarInit::get(Init *VN, RecTy *T) { 1265ee6dca17252de152720655282fb4b74b76fb2fe9David Greene typedef std::pair<RecTy *, Init *> Key; 1266e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef DenseMap<Key, VarInit *> Pool; 1267e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene static Pool ThePool; 1268e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1269e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1270e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1271e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1272e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1273e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1274dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1275dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1276ee6dca17252de152720655282fb4b74b76fb2fe9David Greeneconst std::string &VarInit::getName() const { 12773f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva StringInit *NameString = dyn_cast<StringInit>(getNameInit()); 1278ee6dca17252de152720655282fb4b74b76fb2fe9David Greene assert(NameString && "VarInit name is not a string!"); 1279ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return NameString->getValue(); 1280ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1281ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1282307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarInit::getBit(unsigned Bit) const { 1283307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1284307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarInit*>(this); 1285307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarInit*>(this), Bit); 1286e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1287e62c1185bee05facc25d1d725434f517261d308bChris Lattner 128805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 128905bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 129005bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 1291ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (R.isTemplateArg(getNameInit())) return 0; 1292ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (IRV && IRV->getNameInit() != getNameInit()) return 0; 12931dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1294ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *RV = R.getValue(getNameInit()); 1295a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 12966cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *LI = dyn_cast<ListInit>(RV->getValue()); 1297ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 12986cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *VI = dyn_cast<TypedInit>(RV->getValue()); 1299ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1300dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1301ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 130221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13031dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 13041dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; // Out of range reference. 130505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13062214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13072214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13082214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 13093f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 13102214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 13111dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 13121dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13131dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13141dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1315b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1316736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType())) 1317b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1318b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1319b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1320b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1321b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 132205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 132305bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 132463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<RecordRecTy>(getType())) 1325d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 13263f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV != Val && (RV || isa<UnsetInit>(Val->getValue()))) 1327d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen return 0; 132805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1329ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 133005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1331b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1332b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 133324151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return 0; 1334ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1335b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1336b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1337b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 13389b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1339a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 13409b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 13419b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 13429b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 134305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 13449b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 13453f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV == Val || (RV == 0 && !isa<UnsetInit>(Val->getValue()))) 13469b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 134705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 13489b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 13493da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 135005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 135105bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1352aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1353aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1354aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1355aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1356aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1357aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1358aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1359aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1360aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1361dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1362dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 13633aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 13643aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 13653aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1366db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 136705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 1368307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *I = TI->resolveReferences(R, RV); 1369307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (TI != I) 1370307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return I->getBit(getBitNum()); 1371307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1372307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarBitInit*>(this); 1373db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1374db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 137505bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 137605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 137705bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 137808f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 137908f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 138108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138208f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 138308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 138508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 138608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1387dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1388dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 13893aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 13903aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 13913aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 13923aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 139305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 139405bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 139505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1396d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 13971dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 139805bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 13991dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14001dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1401307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarListElementInit::getBit(unsigned Bit) const { 1402307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1403307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarListElementInit*>(this); 1404307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit); 14051dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14061dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 140705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 140805bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 140905bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14101045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14111045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14121045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14133f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) { 1414d2b9f20b188966722bca10714c237aa036e8c808David Greene Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1415d2b9f20b188966722bca10714c237aa036e8c808David Greene if (Result2) return Result2; 1416d2b9f20b188966722bca10714c237aa036e8c808David Greene return new VarListElementInit(TInit, Elt); 14171045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14181045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14191045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14201045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14211dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14221dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14231dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 142405bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 142577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 142677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 142777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1428b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1429b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1430b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1431b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1432b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1433b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 143405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 143505bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1436b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1437b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1438b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1439b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14403aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 14413aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1442e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1443e62c1185bee05facc25d1d725434f517261d308bChris Lattner 144405bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 144505bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 144665bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 144765bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 144865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 144965bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 145065bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 145165bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 145265bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 145365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1454dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1455dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1456307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *FieldInit::getBit(unsigned Bit) const { 1457307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1458307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<FieldInit*>(this); 1459307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<FieldInit*>(this), Bit); 14601dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14611dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 146205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 146305bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 146405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 14656cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(ListVal)) { 14661dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) return 0; 146705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 14681dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 14692214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 14702214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 14712214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 14723f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV || !isa<UnsetInit>(E)) 14732214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 14741dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 14751dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 147624151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 147724151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 147805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 147905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 14807dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 148105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 148224151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 148305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 148405bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1485b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 14867dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 14877dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1488dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 14897dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 149005bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1491db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1492db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 149378621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid ProfileDagInit(FoldingSetNodeID &ID, 149405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *V, 149578621a851ae84520de7d24a6d61e1dcf25749712David Greene const std::string &VN, 149605bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 149778621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 149878621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 149978621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 150078621a851ae84520de7d24a6d61e1dcf25749712David Greene 150105bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 150278621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 150378621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 150478621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 150578621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 150678621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 150778621a851ae84520de7d24a6d61e1dcf25749712David Greene } 150878621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 150978621a851ae84520de7d24a6d61e1dcf25749712David Greene} 151078621a851ae84520de7d24a6d61e1dcf25749712David Greene 151105bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 151205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 151305bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 151478621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 151578621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 151678621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 151778621a851ae84520de7d24a6d61e1dcf25749712David Greene 151878621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 151978621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 152078621a851ae84520de7d24a6d61e1dcf25749712David Greene 152178621a851ae84520de7d24a6d61e1dcf25749712David Greene void *IP = 0; 152205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 152378621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 152478621a851ae84520de7d24a6d61e1dcf25749712David Greene 152578621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 152678621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 152778621a851ae84520de7d24a6d61e1dcf25749712David Greene 152878621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 152978621a851ae84520de7d24a6d61e1dcf25749712David Greene} 153078621a851ae84520de7d24a6d61e1dcf25749712David Greene 153105bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 153205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 153305bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 153405bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1535dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 153605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1537dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1538dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1539dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1540dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1541dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1542dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1543dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1544dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1545dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1546dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1547dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1548dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1549dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 155078621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 155178621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1552dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1553dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 155405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 155505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1556273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1557273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 155821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 155905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 156021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 15618c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1562dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 156321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 156405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1565273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1566273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1567db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 15683aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 15693aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 15707cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 15717cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 15728e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner if (Args.size()) { 15733aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 15743aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 157591290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 15763aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 15773aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 157891290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 15798e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 15803aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 15818e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 15828e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 15838e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1584e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1585e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1586e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1587e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1588011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1589e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1590dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1591e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1592e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1593e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1594011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1595011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1596011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1597011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1598011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1599011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1600011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 16016cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *NameString = dyn_cast<StringInit>(Name); 1602011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1603011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1604011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1605011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16061a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1607e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16081a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1609e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1610e681d284f96333cef7774c6cc3dd862526af2282David Greene OS << *getType() << " " << getNameInitAsString(); 16117dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16127dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1613e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16147dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1615e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1616e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1617e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16186f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16196f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 1620f7931b7040de1c829e678b4e391308bc3376f8a0David Greenevoid Record::init() { 1621f7931b7040de1c829e678b4e391308bc3376f8a0David Greene checkName(); 1622e338565757bfcfe9d762751c976684f66954fb45David Greene 1623e338565757bfcfe9d762751c976684f66954fb45David Greene // Every record potentially has a def at the top. This value is 1624e338565757bfcfe9d762751c976684f66954fb45David Greene // replaced with the top-level def name at instantiation time. 1625e338565757bfcfe9d762751c976684f66954fb45David Greene RecordVal DN("NAME", StringRecTy::get(), 0); 1626e338565757bfcfe9d762751c976684f66954fb45David Greene addValue(DN); 1627f7931b7040de1c829e678b4e391308bc3376f8a0David Greene} 1628f7931b7040de1c829e678b4e391308bc3376f8a0David Greene 16290d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16300d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16316cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva const TypedInit *TypedName = dyn_cast<const TypedInit>(Name); 16320d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16330d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 163463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<StringRecTy>(Type)) 1635e96ce46b4deabec1110fd9d58213cb884a33b61cJim Grosbach throw TGError(getLoc(), "Record name is not a string!"); 16360d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16370d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 163877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 163977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 164077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 164177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 164277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 164377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 16440d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 16453f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva const StringInit *NameString = dyn_cast<StringInit>(Name); 16460d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 16470d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 16480d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16490d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16500d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 16510d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 16520d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeDef(Name->getAsUnquotedString()); 165367db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addDef(this); 1654f628204262fb91bc095e198b5d9777bd015637e2David Greene } else if (TrackedRecords.getClass(Name->getAsUnquotedString()) == this) { 16550d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeClass(Name->getAsUnquotedString()); 165667db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addClass(this); 1657f628204262fb91bc095e198b5d9777bd015637e2David Greene } // Otherwise this isn't yet registered. 1658f628204262fb91bc095e198b5d9777bd015637e2David Greene Name = NewName; 16590d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 16600d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 16610d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 16620d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 16630d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 16640d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 16650d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 16660d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 16670d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 16680d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 16690d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 16700d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 16710d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16720d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16730d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 16740d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 167596a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 167696a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 16777dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 16787dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 16797dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 16807dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 16817dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1682a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen if (RV == &Values[i]) // Skip resolve the same field as the given one 1683a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen continue; 168405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 1685307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (Values[i].setValue(V->resolveReferences(*this, RV))) 1686307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao throw TGError(getLoc(), "Invalid value is found when setting '" 1687307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + Values[i].getNameInitAsString() 1688307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' after resolving references" 1689307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + (RV ? " against '" + RV->getNameInitAsString() 1690307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' of (" 1691307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + RV->getValue()->getAsUnquotedString() + ")" 1692307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao : "") 1693307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "\n"); 16947dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 16959c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *OldName = getNameInit(); 16969c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *NewName = Name->resolveReferences(*this, RV); 16979c42bcf2ca4844162b427d017fa419bf93f258e3David Greene if (NewName != OldName) { 16989c42bcf2ca4844162b427d017fa419bf93f258e3David Greene // Re-register with RecordKeeper. 16999c42bcf2ca4844162b427d017fa419bf93f258e3David Greene setName(NewName); 17009c42bcf2ca4844162b427d017fa419bf93f258e3David Greene } 1701e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1702e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17031a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1704e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17051a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 170641effc6c15cb65bf486887b20b1dd419ad40f4afDavid Greene OS << R.getNameInitAsString(); 1707e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1708e22b321d2276b634519165b101b02d92c2fcf5c7David Greene const std::vector<Init *> &TArgs = R.getTemplateArgs(); 1709e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1710e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1711e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1712e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1713e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1714e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1715e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1716e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1717e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1718e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1719e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1720e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1721e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1722e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1723e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1724e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1725a461c398267287d7a5d75fb3fa98d29cbfbb17f4David Greene OS << " " << SC[i]->getNameInitAsString(); 1726e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1727e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1728e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1729e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1730e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1731e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1732e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1733e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1734e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1735e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1736e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1737e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1738e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1739e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1740c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 1741c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// or throw an exception if the field does not exist. 1742c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 174305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1744c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1745c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner if (R == 0 || R->getValue() == 0) 1746cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1747c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1748c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1749c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1750c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1751c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 17525c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 17535c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// value as a string, throwing an exception if the field does not exist or if 17545c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 17555c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1756c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 17575c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 17585c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (R == 0 || R->getValue() == 0) 1759cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1760c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 17615c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17626cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *SI = dyn_cast<StringInit>(R->getValue())) 17635c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 1764c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 17655c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner "' does not have a string initializer!"; 17665c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 17675c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17686f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 17696f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// its value as a BitsInit, throwing an exception if the field does not exist 17706f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// or if the value is not the right type. 17716f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 177205bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 17736f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 17746f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner if (R == 0 || R->getValue() == 0) 1775cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1776c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 17776f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 17786cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue())) 17796f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 1780c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 17816f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner "' does not have a BitsInit initializer!"; 17826f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 17836f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 178458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 178558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// its value as a ListInit, throwing an exception if the field does not exist 178658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// or if the value is not the right type. 178758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 178805bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 178958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 179058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1791cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1792c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 179358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 17946cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(R->getValue())) 179558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 1796c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 179758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner "' does not have a list initializer!"; 179858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 17996f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1800b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 1801fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// its value as a vector of records, throwing an exception if the field does 1802fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// not exist or if the value is not the right type. 1803fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 180421870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1805c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 180605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1807fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1808fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 18096cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) { 1810fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1811fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 1812c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1813fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey "' list is not entirely DefInit!"; 1814fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1815fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1816fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1817fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1818fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 181958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 182063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman/// value as an int64_t, throwing an exception if the field does not exist or if 182158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// the value is not the right type. 182258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1823c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 182458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 182558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 1826cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1827c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 182858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18296cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(R->getValue())) 183058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 1831c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1832004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have an int initializer!"; 183358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18345c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1835af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 1836af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// its value as a vector of integers, throwing an exception if the field does 1837af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// not exist or if the value is not the right type. 1838af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 183921870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1840c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 184105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 184263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1843af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 18446cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) { 1845af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1846af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 1847c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1848af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov "' does not have a list of ints initializer!"; 1849af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1850af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1851af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1852af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1853af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1854bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 1855bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// returns its value as a vector of strings, throwing an exception if the 1856bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// field does not exist or if the value is not the right type. 1857bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1858bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1859bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 186005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1861bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1862bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 18636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) { 1864bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1865bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 1866bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson throw "Record `" + getName() + "', field `" + FieldName.str() + 1867bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson "' does not have a list of strings initializer!"; 1868bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1869bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1870bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1871bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1872bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1873dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 1874dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// value as a Record, throwing an exception if the field does not exist or if 1875dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// the value is not the right type. 1876dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1877c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1878dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1879dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner if (R == 0 || R->getValue() == 0) 1880cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1881c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1882dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 18836cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(R->getValue())) 1884dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 1885c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1886004a833ab8ce7fda673b3c5dea68cc6dfb612cd9Nate Begeman "' does not have a def initializer!"; 1887dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1888dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 18890969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 18900969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// value as a bit, throwing an exception if the field does not exist or if 18910969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// the value is not the right type. 18920969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1893c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 18940969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 18950969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner if (R == 0 || R->getValue() == 0) 1896cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1897c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 18980969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 18996cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1900784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 1901c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1902784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a bit initializer!"; 1903784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1904784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1905c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesenbool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { 1906c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen const RecordVal *R = getValue(FieldName); 1907c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R == 0 || R->getValue() == 0) 1908c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen throw "Record `" + getName() + "' does not have a field named `" + 1909c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen FieldName.str() + "'!\n"; 1910c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1911c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R->getValue() == UnsetInit::get()) { 1912c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = true; 1913c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return false; 1914c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen } 1915c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = false; 19166cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1917c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return BI->getValue(); 1918c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen throw "Record `" + getName() + "', field `" + FieldName.str() + 1919c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen "' does not have a bit initializer!"; 1920c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen} 1921c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1922784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 1923784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// value as an Dag, throwing an exception if the field does not exist or if 1924784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// the value is not the right type. 1925784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 192605bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1927784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1928784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner if (R == 0 || R->getValue() == 0) 1929cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "Record `" + getName() + "' does not have a field named `" + 1930c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner FieldName.str() + "'!\n"; 1931784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 19326cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DagInit *DI = dyn_cast<DagInit>(R->getValue())) 1933784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 1934c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner throw "Record `" + getName() + "', field `" + FieldName.str() + 1935784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner "' does not have a dag initializer!"; 19360969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19370969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1938dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1939d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19401a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1941d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 194221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19431a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1944d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 1945d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 1946d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 1947d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 1948d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 1949d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 1950d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 1951d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1952d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 19531a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 1954e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19551a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 1956e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 1957e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Classes = RK.getClasses(); 1958e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 1959ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 1960e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "class " << *I->second; 19613da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1962e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 1963e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Defs = RK.getDefs(); 1964e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 1965ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 1966e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "def " << *I->second; 1967e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 1968e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1969ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1970ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1971ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 1972ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 1973ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 19745c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 19755c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 19769d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 19775c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 1978cf4f81037203909420f47a195109115c9f83e6baMisha Brukman throw "ERROR: Couldn't find the `" + ClassName + "' class!\n"; 1979ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 19805c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 1981ab47ae3381aa2372009a9054260461c20324b555Chris Lattner for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 1982ab47ae3381aa2372009a9054260461c20324b555Chris Lattner E = getDefs().end(); I != E; ++I) 1983ab47ae3381aa2372009a9054260461c20324b555Chris Lattner if (I->second->isSubClassOf(Class)) 1984ab47ae3381aa2372009a9054260461c20324b555Chris Lattner Defs.push_back(I->second); 1985ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 19865c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 1987ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 1988d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 198930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 199030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 199130c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 199230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Init *Name, const std::string &Scoper) { 19936cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva RecTy *Type = dyn_cast<TypedInit>(Name)->getType(); 199430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 199530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit *NewName = 199630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 199730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 199830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurRec.getNameInit(), 199930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get(Scoper), 200030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 200130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Name, 200230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 200330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 200430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene if (CurMultiClass && Scoper != "::") { 200530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName = 200630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 200730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 200830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurMultiClass->Rec.getNameInit(), 200930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get("::"), 201030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 201130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName->Fold(&CurRec, CurMultiClass), 201230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 201330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene } 201430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 201530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return NewName->Fold(&CurRec, CurMultiClass); 201630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 201730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 201830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 201930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 202030c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 202130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Name, 202230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Scoper) { 202330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper); 202430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 2025