Record.cpp revision d04a8d4b33ff316ca4cf961e06c9e312eff8e64f
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" 15726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene#include "llvm/ADT/DenseMap.h" 16726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene#include "llvm/ADT/FoldingSet.h" 17c78bd9ba6beaa42e2c1de14a3cc519cfdbfd593aChandler Carruth#include "llvm/ADT/Hashing.h" 18ca7fd3de360b266783438666054dba198ff77ba2David Greene#include "llvm/ADT/STLExtras.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallVector.h" 2099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner#include "llvm/ADT/StringExtras.h" 21d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene#include "llvm/ADT/StringMap.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/DataTypes.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ErrorHandling.h" 24d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Format.h" 25d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/TableGen/Error.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]); 61961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (DI == 0) 62061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Expected record in list!"); 62150d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner return DI->getDef(); 62250d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner} 62350d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner 62405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 62505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Resolved; 6261dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.reserve(getSize()); 6271dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner bool Changed = false; 6281dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6291dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = getSize(); i != e; ++i) { 63005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E; 63105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurElt = getElement(i); 6321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6331dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner do { 6341dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner E = CurElt; 6357dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurElt = CurElt->resolveReferences(R, RV); 6361dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Changed |= E != CurElt; 6371dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } while (E != CurElt); 6381dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.push_back(E); 6391dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 6401dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6411dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Changed) 642dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Resolved, getType()); 64305bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<ListInit *>(this); 6441dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 6451dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 64605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 64705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 648e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Elt >= getSize()) 649e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; // Out of range reference. 65005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = getElement(Elt); 6512214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 6522214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 6532214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 6543f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 6552214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 656e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 657e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 658e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 6593aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string ListInit::getAsString() const { 6603aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "["; 6617cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 6623aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 6633aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Values[i]->getAsString(); 664e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 6653aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "]"; 666e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 667e62c1185bee05facc25d1d725434f517261d308bChris Lattner 66805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 66905bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 670cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *Resolved = resolveReferences(R, IRV); 6716cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *OResolved = dyn_cast<OpInit>(Resolved); 672cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (OResolved) { 673cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Resolved = OResolved->Fold(&R, 0); 674cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene } 675d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 676cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (Resolved != this) { 6776cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *Typed = dyn_cast<TypedInit>(Resolved); 678cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene assert(Typed && "Expected typed init for list reference"); 679d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 680cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *New = Typed->resolveListElementReference(R, IRV, Elt); 681cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (New) 682cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return New; 683cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return VarListElementInit::get(Typed, Elt); 68421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 685d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 68621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 687d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 688d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 689d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 690307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *OpInit::getBit(unsigned Bit) const { 691307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 692307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<OpInit*>(this); 693307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<OpInit*>(this), Bit); 694307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 695307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 69605bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 69705bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 6986f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 6996f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene typedef DenseMap<Key, UnOpInit *> Pool; 7006f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene static Pool ThePool; 7016f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7026f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7036f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7046f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7056f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7066f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 707dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 708dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 70905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 710e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 711e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7122c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 7133f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) 7142c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 715e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7163f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) 717dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 718448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene 7193f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IntInit *LHSi = dyn_cast<IntInit>(LHS)) 720448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene return StringInit::get(LHSi->getAsString()); 72121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7223f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 7232c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7242c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7252c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7262c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7272c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 728c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 72961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 730dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 731e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 732e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 733e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, 734e22b321d2276b634519165b101b02d92c2fcf5c7David Greene ":"); 735e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7362c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7372c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7382c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 739e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 740c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 74161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 742e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 743dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 744e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 745e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 746e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7472c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 748e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); 749e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7502c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 7512c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 7522c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 75321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 754c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 75561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 75621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 757dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 7582c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 7592c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 76021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 76167db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 76277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 763e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 76461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), 76561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "Undefined reference:'" + Name + "'\n"); 7662c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 767e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 768e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 769e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 7701434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 7713f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7725f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 7735f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in car"); 7745f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7755f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7765f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 7775f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7785f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7795f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7801434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 7813f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7825f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 7835f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in cdr"); 7845f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 7855f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 786dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 787dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 78805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 78905bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 79005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 79105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 792dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 7935f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 7945f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7955f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 7965f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 7971434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 7983f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 7995f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 800dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 80121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 802dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8035f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8045f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8053f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 806e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 807dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 80821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 809dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 810e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 811e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 81221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8135f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8145f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 815e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 81605bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 817e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 818e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 81905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 82005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 82121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 822e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 823dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 824e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Fold(&R, 0); 825e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 826e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 827e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 828e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 829e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 830e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8311434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8321434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8331434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 834e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 835e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 836e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 837d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 83805bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 83905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 84065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 84105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 84265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 84365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 84465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 84565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef DenseMap<Key, BinOpInit *> Pool; 84665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene static Pool ThePool; 84765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 84865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 84965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 85065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 85165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 85265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 85365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 854dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 855dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 85605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 857711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 85830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 8596cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *LHSs = dyn_cast<DagInit>(LHS); 8606cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *RHSs = dyn_cast<DagInit>(RHS); 86130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 8626cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator()); 8636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator()); 8640b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 86561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Concated Dag operators do not match!"); 86605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 86730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 86830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 86930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 87030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 87130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 87230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 87330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 87430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 87530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 876dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 87730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 87830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 87930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 880711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 8816cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 8826cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 883711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 884dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 885711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 886711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 8876786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 888e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 889e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 890307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *L = 8916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())); 892307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *R = 8936cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get())); 894e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 895e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 896dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 897e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 8986cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 8996cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 900e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 901e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9026786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 903dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9046786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9056786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9066786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 907711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 908711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 909711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 9106cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 9116cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *RHSi = dyn_cast<IntInit>(RHS); 912711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 91363f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 91463f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 915711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 916858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Bad opcode!"); 917711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 918711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 91963f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 920711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 921dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 922711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 923711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 924711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 925711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 92605bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 927711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 928711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 92905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 93005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 93105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 93221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 933711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 934dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 935c7cafcd815519b06318629b424abe746437e1389David Greene return Fold(&R, 0); 936711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 937711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 9383aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 9393aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 940711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 9413aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 9423aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 9433aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 9443aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 9456786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 9463aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 947711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9483aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 949711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 950711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 95105bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 95205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 953dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 954b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 955b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 95605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 95705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 958b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 95905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 960b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 961b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 962b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 963b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 964b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 965b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 966b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 967b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 968b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 969b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 970b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 971b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 972b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 973b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 974dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 975dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 97605bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 97705bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 978beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 97905bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 98005bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 98105bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 98205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 983beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 9846cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *TArg = dyn_cast<TypedInit>(Arg); 985beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 986beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 987beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 98805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 989d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 990beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 991beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 99221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 993beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 994beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 995beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 996beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 997beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 9986cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i)); 999beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1000beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 100105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1002d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1003beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1004beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 100521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1006beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1007beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 100821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1009beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 101021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1011beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1012beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1013beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1014beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1015beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1016f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 101705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1018dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewVal != NewOp) 1019beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return NewVal; 1020dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1021beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1022beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1023beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 102405bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 102505bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 10266cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *MHSd = dyn_cast<DagInit>(MHS); 10276cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *MHSl = dyn_cast<ListInit>(MHS); 1028beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10296cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSo = dyn_cast<OpInit>(RHS); 1030beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1031beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 103261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n"); 1033beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1034beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10356cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *LHSt = dyn_cast<TypedInit>(LHS); 1036beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 103761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (!LHSt) 103861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1039beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 104063554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if ((MHSd && isa<DagRecTy>(Type)) || (MHSl && isa<ListRecTy>(Type))) { 1041beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 104205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 104305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1044d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1045beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1046beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1047beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1048beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 104905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1050beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 105105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1052beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1053beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1054beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1055beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1056beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 105705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1058d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1059beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1060beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1061beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1063beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1064beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1066beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1067dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1068beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1069beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 107005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 107105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1072beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 107305bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1074beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1075beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1076beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 107705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1078beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1079beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1081beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1082beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 108321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1084beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1085beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1086beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1087beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1088beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1089f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 109005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1091dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1092beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1093beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1094dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1097beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1098beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1099beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 110005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11024afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 11036cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LHSd = dyn_cast<DefInit>(LHS); 11046cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *LHSv = dyn_cast<VarInit>(LHS); 11056cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 11064afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11076cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *MHSd = dyn_cast<DefInit>(MHS); 11086cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *MHSv = dyn_cast<VarInit>(MHS); 11096cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *MHSs = dyn_cast<StringInit>(MHS); 11104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11116cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *RHSd = dyn_cast<DefInit>(RHS); 11126cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *RHSv = dyn_cast<VarInit>(RHS); 11136cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 11144afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11154afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11164afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11174afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11184afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11194afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11204afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11214afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11224afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 112377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11244afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11254afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11264afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11274afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11284afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11294afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1130dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11314afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11324afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11334afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11344afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11354afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1136f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11374afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1138f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 11394afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 11404afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 11414afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1142f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 11434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 11444afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1145dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 11464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11474afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11484afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 114921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 11504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11514afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 115205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1153beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1154beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1155beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 11564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11574afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 11584afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11599bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 11609bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 11616cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 116205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 11636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva LHSi = dyn_cast<IntInit>(I); 11649bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 11659bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 11669bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 116721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 11689bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 11699bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11709bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11719bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 11729bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 11734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 117505bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 11764afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 11774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 117805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 117905bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 118005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 118177c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 118277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 11836cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *Value = dyn_cast<IntInit>(lhs); 118405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 11856cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva Value = dyn_cast<IntInit>(I); 118677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value != 0) { 118777c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 118877c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 118905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1190dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1191dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS, getType()))->Fold(&R, 0); 119221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 119305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1194dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1195dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene rhs, getType()))->Fold(&R, 0); 119677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119777c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119877c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 119921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 120005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 120105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 120277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12034afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1204dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1205dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()))->Fold(&R, 0); 12064afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return Fold(&R, 0); 12074afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12084afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12114afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12124afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 121321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 121421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12154afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 121621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12174afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12184afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1219e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12209703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 122163554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) 122263554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName)) 12239703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 12249703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return 0; 12259703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12269703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 122705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1228f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1229736ceace11249da645ec4ed91b8714832193ead4Sean Silva BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); 1230ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-bits variable. 1231e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1232e62c1185bee05facc25d1d725434f517261d308bChris Lattner 123305bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1234e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1235ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1236e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1237ca7fd3de360b266783438666054dba198ff77ba2David Greene 123805bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1239e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1240dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1241e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1242e62c1185bee05facc25d1d725434f517261d308bChris Lattner 124305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1244f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 1245736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *T = dyn_cast<ListRecTy>(getType()); 1246ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-list variable. 12471dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12481dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 124905bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 12501dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 125105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 12521dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 12531dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 125405bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 125505bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1256dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 12571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 12581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12591dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 126005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1261ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *Value = StringInit::get(VN); 1262ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return VarInit::get(Value, T); 1263ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1264ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1265ee6dca17252de152720655282fb4b74b76fb2fe9David GreeneVarInit *VarInit::get(Init *VN, RecTy *T) { 1266ee6dca17252de152720655282fb4b74b76fb2fe9David Greene typedef std::pair<RecTy *, Init *> Key; 1267e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef DenseMap<Key, VarInit *> Pool; 1268e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene static Pool ThePool; 1269e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1270e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1271e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1272e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1273e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1274e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1275dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1276dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1277ee6dca17252de152720655282fb4b74b76fb2fe9David Greeneconst std::string &VarInit::getName() const { 12783f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva StringInit *NameString = dyn_cast<StringInit>(getNameInit()); 1279ee6dca17252de152720655282fb4b74b76fb2fe9David Greene assert(NameString && "VarInit name is not a string!"); 1280ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return NameString->getValue(); 1281ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1282ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1283307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarInit::getBit(unsigned Bit) const { 1284307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1285307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarInit*>(this); 1286307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarInit*>(this), Bit); 1287e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1288e62c1185bee05facc25d1d725434f517261d308bChris Lattner 128905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 129005bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 129105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 1292ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (R.isTemplateArg(getNameInit())) return 0; 1293ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (IRV && IRV->getNameInit() != getNameInit()) return 0; 12941dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1295ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *RV = R.getValue(getNameInit()); 1296a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 12976cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *LI = dyn_cast<ListInit>(RV->getValue()); 1298ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 12996cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *VI = dyn_cast<TypedInit>(RV->getValue()); 1300ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1301dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1302ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 130321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13041dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 13051dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; // Out of range reference. 130605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13072214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13082214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13092214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 13103f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 13112214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 13121dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 13131dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13141dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13151dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1316b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1317736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType())) 1318b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1319b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1320b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1321b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1322b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 132305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 132405bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 132563554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<RecordRecTy>(getType())) 1326d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 13273f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV != Val && (RV || isa<UnsetInit>(Val->getValue()))) 1328d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen return 0; 132905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1330ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 133105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1332b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1333b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 133424151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return 0; 1335ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1336b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1337b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1338b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 13399b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1340a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 13419b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 13429b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 13439b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 134405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 13459b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 13463f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV == Val || (RV == 0 && !isa<UnsetInit>(Val->getValue()))) 13479b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 134805bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 13499b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 13503da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 135105bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 135205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1353aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1354aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1355aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1356aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1357aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1358aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1359aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1360aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1361aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1362dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1363dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 13643aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 13653aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 13663aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1367db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 136805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 1369307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *I = TI->resolveReferences(R, RV); 1370307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (TI != I) 1371307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return I->getBit(getBitNum()); 1372307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1373307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarBitInit*>(this); 1374db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1375db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 137605bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 137705bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 137805bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 137908f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 138008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 138208f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 138408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 138508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 138608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 138708f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1388dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1389dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 13903aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 13913aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 13923aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 13933aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 139405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 139505bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 139605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1397d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 13981dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 139905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 14001dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14011dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1402307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarListElementInit::getBit(unsigned Bit) const { 1403307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1404307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarListElementInit*>(this); 1405307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit); 14061dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14071dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 140805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 140905bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 141005bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14111045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14121045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14131045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14143f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) { 1415d2b9f20b188966722bca10714c237aa036e8c808David Greene Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1416d2b9f20b188966722bca10714c237aa036e8c808David Greene if (Result2) return Result2; 1417d2b9f20b188966722bca10714c237aa036e8c808David Greene return new VarListElementInit(TInit, Elt); 14181045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14191045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14201045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14211045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14221dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14231dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14241dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 142505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 142677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 142777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 142877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1429b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1430b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1431b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1432b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1433b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1434b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 143505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 143605bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1437b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1438b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1439b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1440b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14413aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 14423aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1443e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1444e62c1185bee05facc25d1d725434f517261d308bChris Lattner 144505bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 144605bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 144765bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 144865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 144965bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 145065bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 145165bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 145265bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 145365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 145465bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1455dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1456dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1457307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *FieldInit::getBit(unsigned Bit) const { 1458307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1459307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<FieldInit*>(this); 1460307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<FieldInit*>(this), Bit); 14611dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14621dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 146305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 146405bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 146505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 14666cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(ListVal)) { 14671dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) return 0; 146805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 14691dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 14702214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 14712214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 14722214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 14733f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV || !isa<UnsetInit>(E)) 14742214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 14751dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 14761dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 147724151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 147824151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 147905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 148005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 14817dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 148205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 148324151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 148405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 148505bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1486b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 14877dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 14887dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1489dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 14907dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 149105bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1492db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1493db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 149478621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid ProfileDagInit(FoldingSetNodeID &ID, 149505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *V, 149678621a851ae84520de7d24a6d61e1dcf25749712David Greene const std::string &VN, 149705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 149878621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 149978621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 150078621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 150178621a851ae84520de7d24a6d61e1dcf25749712David Greene 150205bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 150378621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 150478621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 150578621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 150678621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 150778621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 150878621a851ae84520de7d24a6d61e1dcf25749712David Greene } 150978621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 151078621a851ae84520de7d24a6d61e1dcf25749712David Greene} 151178621a851ae84520de7d24a6d61e1dcf25749712David Greene 151205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 151305bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 151405bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 151578621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 151678621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 151778621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 151878621a851ae84520de7d24a6d61e1dcf25749712David Greene 151978621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 152078621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 152178621a851ae84520de7d24a6d61e1dcf25749712David Greene 152278621a851ae84520de7d24a6d61e1dcf25749712David Greene void *IP = 0; 152305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 152478621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 152578621a851ae84520de7d24a6d61e1dcf25749712David Greene 152678621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 152778621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 152878621a851ae84520de7d24a6d61e1dcf25749712David Greene 152978621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 153078621a851ae84520de7d24a6d61e1dcf25749712David Greene} 153178621a851ae84520de7d24a6d61e1dcf25749712David Greene 153205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 153305bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 153405bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 153505bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1536dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 153705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1538dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1539dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1540dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1541dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1542dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1543dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1544dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1545dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1546dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1547dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1548dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1549dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1550dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 155178621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 155278621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1553dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1554dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 155505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 155605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1557273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1558273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 155921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 156005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 156121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 15628c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1563dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 156421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 156505bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1566273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1567273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1568db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 15693aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 15703aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 15717cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 15727cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 15738e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner if (Args.size()) { 15743aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 15753aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 157691290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 15773aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 15783aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 157991290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 15808e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 15813aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 15828e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 15838e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 15848e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1585e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1586e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1587e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1588e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1589011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1590e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1591dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1592e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1593e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1594e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1595011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1596011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1597011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1598011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1599011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1600011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1601011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 16026cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *NameString = dyn_cast<StringInit>(Name); 1603011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1604011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1605011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1606011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16071a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1608e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16091a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1610e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1611e681d284f96333cef7774c6cc3dd862526af2282David Greene OS << *getType() << " " << getNameInitAsString(); 16127dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16137dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1614e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16157dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1616e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1617e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1618e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16196f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16206f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 1621f7931b7040de1c829e678b4e391308bc3376f8a0David Greenevoid Record::init() { 1622f7931b7040de1c829e678b4e391308bc3376f8a0David Greene checkName(); 1623e338565757bfcfe9d762751c976684f66954fb45David Greene 1624e338565757bfcfe9d762751c976684f66954fb45David Greene // Every record potentially has a def at the top. This value is 1625e338565757bfcfe9d762751c976684f66954fb45David Greene // replaced with the top-level def name at instantiation time. 1626e338565757bfcfe9d762751c976684f66954fb45David Greene RecordVal DN("NAME", StringRecTy::get(), 0); 1627e338565757bfcfe9d762751c976684f66954fb45David Greene addValue(DN); 1628f7931b7040de1c829e678b4e391308bc3376f8a0David Greene} 1629f7931b7040de1c829e678b4e391308bc3376f8a0David Greene 16300d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16310d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16326cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva const TypedInit *TypedName = dyn_cast<const TypedInit>(Name); 16330d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16340d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 163563554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<StringRecTy>(Type)) 163661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record name is not a string!"); 16370d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16380d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 163977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 164077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 164177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 164277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 164377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 164477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 16450d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 16463f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva const StringInit *NameString = dyn_cast<StringInit>(Name); 16470d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 16480d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 16490d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16500d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16510d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 16520d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 16530d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeDef(Name->getAsUnquotedString()); 165467db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addDef(this); 1655f628204262fb91bc095e198b5d9777bd015637e2David Greene } else if (TrackedRecords.getClass(Name->getAsUnquotedString()) == this) { 16560d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeClass(Name->getAsUnquotedString()); 165767db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addClass(this); 1658f628204262fb91bc095e198b5d9777bd015637e2David Greene } // Otherwise this isn't yet registered. 1659f628204262fb91bc095e198b5d9777bd015637e2David Greene Name = NewName; 16600d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 16610d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 16620d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 16630d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 16640d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 16650d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 16660d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 16670d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 16680d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 16690d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 16700d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 16710d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 16720d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16730d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16740d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 16750d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 167696a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 167796a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 16787dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 16797dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 16807dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 16817dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 16827dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1683a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen if (RV == &Values[i]) // Skip resolve the same field as the given one 1684a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen continue; 168505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 1686307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (Values[i].setValue(V->resolveReferences(*this, RV))) 168761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Invalid value is found when setting '" 1688307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + Values[i].getNameInitAsString() 1689307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' after resolving references" 1690307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + (RV ? " against '" + RV->getNameInitAsString() 1691307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' of (" 1692307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + RV->getValue()->getAsUnquotedString() + ")" 1693307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao : "") 1694307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "\n"); 16957dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 16969c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *OldName = getNameInit(); 16979c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *NewName = Name->resolveReferences(*this, RV); 16989c42bcf2ca4844162b427d017fa419bf93f258e3David Greene if (NewName != OldName) { 16999c42bcf2ca4844162b427d017fa419bf93f258e3David Greene // Re-register with RecordKeeper. 17009c42bcf2ca4844162b427d017fa419bf93f258e3David Greene setName(NewName); 17019c42bcf2ca4844162b427d017fa419bf93f258e3David Greene } 1702e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1703e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17041a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1705e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17061a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 170741effc6c15cb65bf486887b20b1dd419ad40f4afDavid Greene OS << R.getNameInitAsString(); 1708e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1709e22b321d2276b634519165b101b02d92c2fcf5c7David Greene const std::vector<Init *> &TArgs = R.getTemplateArgs(); 1710e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1711e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1712e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1713e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1714e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1715e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1716e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1717e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1718e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1719e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1720e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1721e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1722e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1723e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1724e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1725e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1726a461c398267287d7a5d75fb3fa98d29cbfbb17f4David Greene OS << " " << SC[i]->getNameInitAsString(); 1727e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1728e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1729e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1730e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1731e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1732e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1733e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1734e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1735e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1736e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1737e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1738e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1739e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1740e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1741c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 174261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or abort if the field does not exist. 1743c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 174405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1745c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1746c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner if (R == 0 || R->getValue() == 0) 174761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 174861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1749c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1750c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1751c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1752c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 17535c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 175461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a string, aborts if the field does not exist or if 17555c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 17565c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1757c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 17585c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 17595c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (R == 0 || R->getValue() == 0) 176061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 176161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 17625c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *SI = dyn_cast<StringInit>(R->getValue())) 17645c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 176561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 176661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a string initializer!"); 17675c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 17685c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17696f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 177061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a BitsInit, aborts if the field does not exist or if 177161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 17726f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 177305bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 17746f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 17756f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner if (R == 0 || R->getValue() == 0) 177661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 177761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 17786f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 17796cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue())) 17806f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 178161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 178261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a BitsInit initializer!"); 17836f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 17846f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 178558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 178661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a ListInit, aborting if the field does not exist or if 178761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 178858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 178905bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 179058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 179158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 179261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 179361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 179458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 17956cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(R->getValue())) 179658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 179761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 179861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list initializer!"); 179958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18006f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1801b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 180261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of records, aborting if the field does not exist 180361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or if the value is not the right type. 1804fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 180521870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1806c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 180705bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1808fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1809fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 18106cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) { 1811fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1812fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 181361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 181461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' list is not entirely DefInit!"); 1815fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1816fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1817fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1818fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1819fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 182058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 182161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an int64_t, aborting if the field does not exist or if the value 182261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 182358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1824c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 182558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 182658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 182761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 182861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 182958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18306cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(R->getValue())) 183158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 183261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 183361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have an int initializer!"); 183458c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18355c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1836af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 183761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of integers, aborting if the field does not exist or 183861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// if the value is not the right type. 1839af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 184021870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1841c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 184205bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 184363f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1844af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 18456cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) { 1846af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1847af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 184861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 184961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list of ints initializer!"); 1850af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1851af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1852af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1853af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1854af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1855bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 185661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// returns its value as a vector of strings, aborting if the field does not 185761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// exist or if the value is not the right type. 1858bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1859bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1860bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 186105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1862bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1863bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 18646cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) { 1865bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1866bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 186761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 186861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list of strings initializer!"); 1869bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1870bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1871bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1872bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1873bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1874dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 187561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a Record, aborting if the field does not exist or if the value 187661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 1877dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1878c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1879dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1880dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner if (R == 0 || R->getValue() == 0) 188161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 188261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1883dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 18846cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(R->getValue())) 1885dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 188661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 188761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a def initializer!"); 1888dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1889dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 18900969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 189161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a bit, aborting if the field does not exist or if the value is 189261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 18930969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1894c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 18950969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 18960969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner if (R == 0 || R->getValue() == 0) 189761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 189861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 18990969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 19006cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1901784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 190261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 190361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a bit initializer!"); 1904784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1905784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1906c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesenbool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { 1907c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen const RecordVal *R = getValue(FieldName); 1908c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R == 0 || R->getValue() == 0) 190961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 191061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1911c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1912c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R->getValue() == UnsetInit::get()) { 1913c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = true; 1914c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return false; 1915c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen } 1916c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = false; 19176cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1918c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return BI->getValue(); 191961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 192061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a bit initializer!"); 1921c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen} 1922c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1923784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 192461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an Dag, aborting if the field does not exist or if the value is 192561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 1926784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 192705bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1928784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1929784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner if (R == 0 || R->getValue() == 0) 193061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 193161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1932784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 19336cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DagInit *DI = dyn_cast<DagInit>(R->getValue())) 1934784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 193561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 193661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a dag initializer!"); 19370969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19380969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1939dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1940d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19411a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1942d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 194321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19441a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1945d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 1946d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 1947d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 1948d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 1949d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 1950d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 1951d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 1952d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1953d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 19541a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 1955e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19561a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 1957e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 1958e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Classes = RK.getClasses(); 1959e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 1960ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 1961e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "class " << *I->second; 19623da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1963e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 1964e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Defs = RK.getDefs(); 1965e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 1966ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 1967e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "def " << *I->second; 1968e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 1969e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1970ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1971ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1972ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 1973ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 1974ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 19755c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 19765c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 19779d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 19785c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 197961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n"); 1980ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 19815c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 1982ab47ae3381aa2372009a9054260461c20324b555Chris Lattner for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 1983ab47ae3381aa2372009a9054260461c20324b555Chris Lattner E = getDefs().end(); I != E; ++I) 1984ab47ae3381aa2372009a9054260461c20324b555Chris Lattner if (I->second->isSubClassOf(Class)) 1985ab47ae3381aa2372009a9054260461c20324b555Chris Lattner Defs.push_back(I->second); 1986ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 19875c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 1988ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 1989d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 199030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 199130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 199230c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 199330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Init *Name, const std::string &Scoper) { 19946cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva RecTy *Type = dyn_cast<TypedInit>(Name)->getType(); 199530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 199630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit *NewName = 199730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 199830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 199930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurRec.getNameInit(), 200030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get(Scoper), 200130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 200230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Name, 200330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 200430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 200530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene if (CurMultiClass && Scoper != "::") { 200630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName = 200730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 200830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 200930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurMultiClass->Rec.getNameInit(), 201030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get("::"), 201130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 201230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName->Fold(&CurRec, CurMultiClass), 201330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 201430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene } 201530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 201630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return NewName->Fold(&CurRec, CurMultiClass); 201730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 201830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 201930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 202030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 202130c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 202230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Name, 202330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Scoper) { 202430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper); 202530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 2026