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 9837fda193d292d78c672b8019723c7907af312c43Sean Silvabool RecTy::baseClassOf(const RecTy *RHS) const{ 9937fda193d292d78c672b8019723c7907af312c43Sean Silva assert (RHS && "NULL pointer"); 10037fda193d292d78c672b8019723c7907af312c43Sean Silva return Kind == RHS->getRecTyKind(); 10137fda193d292d78c672b8019723c7907af312c43Sean Silva} 10237fda193d292d78c672b8019723c7907af312c43Sean Silva 10305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(BitsInit *BI) { 104e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! 105e62c1185bee05facc25d1d725434f517261d308bChris Lattner return BI->getBit(0); 106e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 107e62c1185bee05facc25d1d725434f517261d308bChris Lattner 10805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(IntInit *II) { 10963f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Val = II->getValue(); 110e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! 1113da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 112dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitInit::get(Val != 0); 113e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 114e62c1185bee05facc25d1d725434f517261d308bChris Lattner 11505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitRecTy::convertValue(TypedInit *VI) { 116307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao RecTy *Ty = VI->getType(); 11763554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<BitRecTy>(Ty) || isa<BitsRecTy>(Ty) || isa<IntRecTy>(Ty)) 118e62c1185bee05facc25d1d725434f517261d308bChris Lattner return VI; // Accept variable if it is already of bit type! 119e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 120e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 121e62c1185bee05facc25d1d725434f517261d308bChris Lattner 12237fda193d292d78c672b8019723c7907af312c43Sean Silvabool BitRecTy::baseClassOf(const RecTy *RHS) const{ 12337fda193d292d78c672b8019723c7907af312c43Sean Silva if(RecTy::baseClassOf(RHS) || getRecTyKind() == IntRecTyKind) 12437fda193d292d78c672b8019723c7907af312c43Sean Silva return true; 12537fda193d292d78c672b8019723c7907af312c43Sean Silva if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS)) 12637fda193d292d78c672b8019723c7907af312c43Sean Silva return BitsTy->getNumBits() == 1; 12737fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 12837fda193d292d78c672b8019723c7907af312c43Sean Silva} 12937fda193d292d78c672b8019723c7907af312c43Sean Silva 13077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitsRecTy *BitsRecTy::get(unsigned Sz) { 13177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static std::vector<BitsRecTy*> Shared; 13277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (Sz >= Shared.size()) 13377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Shared.resize(Sz + 1); 13477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen BitsRecTy *&Ty = Shared[Sz]; 13577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!Ty) 13677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Ty = new BitsRecTy(Sz); 13777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return Ty; 13877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 13977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 14099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string BitsRecTy::getAsString() const { 14199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "bits<" + utostr(Size) + ">"; 14299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 14399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 14405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(UnsetInit *UI) { 14505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 146e62c1185bee05facc25d1d725434f517261d308bChris Lattner 147e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 148dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = UnsetInit::get(); 149ca7fd3de360b266783438666054dba198ff77ba2David Greene 150dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 151e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 152e62c1185bee05facc25d1d725434f517261d308bChris Lattner 15305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitInit *UI) { 154ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (Size != 1) return 0; // Can only convert single bit. 155dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(UI); 156e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 157e62c1185bee05facc25d1d725434f517261d308bChris Lattner 158548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// canFitInBitfield - Return true if the number of bits is large enough to hold 159548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// the integer value. 160548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendlingstatic bool canFitInBitfield(int64_t Value, unsigned NumBits) { 161b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky // For example, with NumBits == 4, we permit Values from [-7 .. 15]. 162b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky return (NumBits >= sizeof(Value) * 8) || 163b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); 164548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling} 165548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 166d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// convertValue from Int initializer to bits type: Split the integer up into the 167d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// appropriate bits. 168548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// 16905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(IntInit *II) { 170294984cecbe1e5abbe37dc38bf2941f2804b13caMisha Brukman int64_t Value = II->getValue(); 171ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // Make sure this bitfield is large enough to hold the integer value. 172548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (!canFitInBitfield(Value, Size)) 173548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling return 0; 174e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 176ca7fd3de360b266783438666054dba198ff77ba2David Greene 177e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 178dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (1LL << i)); 179d19c2cf5d2ae5b263df3f4c7c9744cdf3946f89bChris Lattner 180dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 181e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 182e62c1185bee05facc25d1d725434f517261d308bChris Lattner 18305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitsInit *BI) { 184e62c1185bee05facc25d1d725434f517261d308bChris Lattner // If the number of bits is right, return it. Otherwise we need to expand or 185ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // truncate. 186e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() == Size) return BI; 187e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 188e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 189e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(TypedInit *VI) { 19163554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (Size == 1 && isa<BitRecTy>(VI->getType())) 192dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(VI); 1933da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 194307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (VI->getType()->typeIsConvertibleTo(this)) { 195307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao SmallVector<Init *, 16> NewBits(Size); 196d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 197307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0; i != Size; ++i) 198307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = VarBitInit::get(VI, i); 199307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return BitsInit::get(NewBits); 200548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 201548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 202e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 203e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 204e62c1185bee05facc25d1d725434f517261d308bChris Lattner 20537fda193d292d78c672b8019723c7907af312c43Sean Silvabool BitsRecTy::baseClassOf(const RecTy *RHS) const{ 20637fda193d292d78c672b8019723c7907af312c43Sean Silva if (RecTy::baseClassOf(RHS)) //argument and the receiver are the same type 20737fda193d292d78c672b8019723c7907af312c43Sean Silva return cast<BitsRecTy>(RHS)->Size == Size; 20837fda193d292d78c672b8019723c7907af312c43Sean Silva RecTyKind kind = RHS->getRecTyKind(); 20937fda193d292d78c672b8019723c7907af312c43Sean Silva return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind); 21037fda193d292d78c672b8019723c7907af312c43Sean Silva} 21137fda193d292d78c672b8019723c7907af312c43Sean Silva 21205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitInit *BI) { 213dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(BI->getValue()); 21408ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner} 21508ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner 21605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitsInit *BI) { 21763f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result = 0; 2183da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 2196cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) { 220e62c1185bee05facc25d1d725434f517261d308bChris Lattner Result |= Bit->getValue() << i; 221e62c1185bee05facc25d1d725434f517261d308bChris Lattner } else { 222e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 223e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 224dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 225e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 226e62c1185bee05facc25d1d725434f517261d308bChris Lattner 22705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(TypedInit *TI) { 22808ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 229b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 230e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 231e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 232e62c1185bee05facc25d1d725434f517261d308bChris Lattner 23337fda193d292d78c672b8019723c7907af312c43Sean Silvabool IntRecTy::baseClassOf(const RecTy *RHS) const{ 23437fda193d292d78c672b8019723c7907af312c43Sean Silva RecTyKind kind = RHS->getRecTyKind(); 23537fda193d292d78c672b8019723c7907af312c43Sean Silva return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind; 23637fda193d292d78c672b8019723c7907af312c43Sean Silva} 23737fda193d292d78c672b8019723c7907af312c43Sean Silva 23805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(UnOpInit *BO) { 239e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 24005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 241e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 242e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 243dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); 244e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 245e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 246e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 24705bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 248e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 249d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 25005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(BinOpInit *BO) { 251711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (BO->getOpcode() == BinOpInit::STRCONCAT) { 25205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 25305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 254711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L == 0 || R == 0) return 0; 255711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L != BO->getLHS() || R != BO->getRHS()) 256dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); 257711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner return BO; 258711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 259e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 26005bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 261711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 262711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 263711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 26405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(TypedInit *TI) { 26563554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<StringRecTy>(TI->getType())) 266b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 267e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 268e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 269e62c1185bee05facc25d1d725434f517261d308bChris Lattner 27099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string ListRecTy::getAsString() const { 27199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "list<" + Ty->getAsString() + ">"; 27299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 27399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 27405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(ListInit *LI) { 27505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Elements; 2767cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 277e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Verify that all of the elements of the list are subclasses of the 2787cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // appropriate class! 279e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = LI->getSize(); i != e; ++i) 28005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) 2817cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner Elements.push_back(CI); 2827cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner else 283e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 2847cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 28563554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<ListRecTy>(LI->getType())) 286e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 287e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 288dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Elements, this); 289e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 290e62c1185bee05facc25d1d725434f517261d308bChris Lattner 29105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(TypedInit *TI) { 292f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with our class. 293736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType())) 2947cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) 295f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 296f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return 0; 297f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner} 298f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner 29937fda193d292d78c672b8019723c7907af312c43Sean Silvabool ListRecTy::baseClassOf(const RecTy *RHS) const{ 30037fda193d292d78c672b8019723c7907af312c43Sean Silva if(const ListRecTy* ListTy = dyn_cast<ListRecTy>(RHS)) 30137fda193d292d78c672b8019723c7907af312c43Sean Silva return ListTy->getElementType()->typeIsConvertibleTo(Ty); 30237fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 30337fda193d292d78c672b8019723c7907af312c43Sean Silva} 30437fda193d292d78c672b8019723c7907af312c43Sean Silva 30505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(TypedInit *TI) { 30640f71134b9fef0ca06c516f033cc9403394a913cChris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 30740f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return TI; 30840f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return 0; 30940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner} 31040f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 31105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(UnOpInit *BO) { 312e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 31305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 314e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L == 0) return 0; 315e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 316dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); 317e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 318e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 319e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return 0; 320e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 321d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 32205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(BinOpInit *BO) { 32330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (BO->getOpcode() == BinOpInit::CONCAT) { 32405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 32505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 32630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L == 0 || R == 0) return 0; 32730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L != BO->getLHS() || R != BO->getRHS()) 328dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); 32930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return BO; 33030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 33130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return 0; 33230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng} 33330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng 33477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenRecordRecTy *RecordRecTy::get(Record *R) { 335736ceace11249da645ec4ed91b8714832193ead4Sean Silva return dyn_cast<RecordRecTy>(R->getDefInit()->getType()); 33677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 33777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 33899ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string RecordRecTy::getAsString() const { 33999ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return Rec->getName(); 34099ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 34140f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 34205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(DefInit *DI) { 343e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Ensure that DI is a subclass of Rec. 344e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!DI->getDef()->isSubClassOf(Rec)) 345e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 346e62c1185bee05facc25d1d725434f517261d308bChris Lattner return DI; 347e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 348e62c1185bee05facc25d1d725434f517261d308bChris Lattner 34905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(TypedInit *TI) { 350f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with Rec. 351736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RRT = dyn_cast<RecordRecTy>(TI->getType())) 352ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner if (RRT->getRecord()->isSubClassOf(getRecord()) || 353ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner RRT->getRecord() == getRecord()) 354f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 355ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner return 0; 356ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner} 357ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner 35837fda193d292d78c672b8019723c7907af312c43Sean Silvabool RecordRecTy::baseClassOf(const RecTy *RHS) const{ 35937fda193d292d78c672b8019723c7907af312c43Sean Silva const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS); 36037fda193d292d78c672b8019723c7907af312c43Sean Silva if (!RTy) 36137fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 36237fda193d292d78c672b8019723c7907af312c43Sean Silva 36337fda193d292d78c672b8019723c7907af312c43Sean Silva if (Rec == RTy->getRecord() || RTy->getRecord()->isSubClassOf(Rec)) 36493583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 36593583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 36693583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes const std::vector<Record*> &SC = Rec->getSuperClasses(); 36793583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes for (unsigned i = 0, e = SC.size(); i != e; ++i) 36837fda193d292d78c672b8019723c7907af312c43Sean Silva if (RTy->getRecord()->isSubClassOf(SC[i])) 36993583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 37093583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 37193583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return false; 3727cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 3737cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 37421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// resolveTypes - Find a common type that T1 and T2 convert to. 375e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// Return 0 if no such type exists. 376e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// 377e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid GreeneRecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { 37857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T1->typeIsConvertibleTo(T2)) 37957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T2; 38057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T2->typeIsConvertibleTo(T1)) 38157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T1; 38257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva 38357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // If one is a Record type, check superclasses 384736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) { 38557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T2 inherits from a type T1 also inherits from 38657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T1SuperClasses = 38757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy1->getRecord()->getSuperClasses(); 38857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), 38957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T1SuperClasses.end(); 39057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 39157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 39257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); 39357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); 39457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType1 != 0) { 39557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType1 != SuperRecTy1) { 39657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy1; 397e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 39857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType1; 399e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 40057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 40157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 402736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2)) { 40357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T1 inherits from a type T2 also inherits from 40457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T2SuperClasses = 40557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy2->getRecord()->getSuperClasses(); 40657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), 40757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T2SuperClasses.end(); 40857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 40957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 41057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); 41157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); 41257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType2 != 0) { 41357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType2 != SuperRecTy2) { 41457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy2; 415e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 41657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType2; 417e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 418e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 419e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 42057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return 0; 421e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 422e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 423e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 424e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 425e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Initializer implementations 426e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 427e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4282d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid Init::anchor() { } 4291a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Init::dump() const { return print(errs()); } 430e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4312d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid UnsetInit::anchor() { } 4322d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 43305bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnsetInit *UnsetInit::get() { 43405bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnsetInit TheInit; 435ba1ae182876762f17201b33c0b87ca8ede156cfcDavid Greene return &TheInit; 436dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 437dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 4382d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid BitInit::anchor() { } 4392d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 44005bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitInit *BitInit::get(bool V) { 44105bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit True(true); 44205bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit False(false); 4430ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene 4440ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene return V ? &True : &False; 445dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 446dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 447726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenestatic void 44805bce0beee87512e52428d4b80f5a8e79a949576David GreeneProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { 449726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddInteger(Range.size()); 450726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 45105bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 452726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene iend = Range.end(); 453726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene i != iend; 454726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ++i) 455726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddPointer(*i); 456726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 457726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 45805bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *BitsInit::get(ArrayRef<Init *> Range) { 459726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene typedef FoldingSet<BitsInit> Pool; 460726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene static Pool ThePool; 461726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 462726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene FoldingSetNodeID ID; 463726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Range); 464726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 465726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene void *IP = 0; 46605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 467726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 468726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 469726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene BitsInit *I = new BitsInit(Range); 470726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ThePool.InsertNode(I, IP); 471726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 472726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 473726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 474726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 475726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenevoid BitsInit::Profile(FoldingSetNodeID &ID) const { 476726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Bits); 477dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 478dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 47905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 480f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneBitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 48105bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 482ca7fd3de360b266783438666054dba198ff77ba2David Greene 483e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 484ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= getNumBits()) 485e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 486ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = getBit(Bits[i]); 487e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 488dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 489e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 490e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4913aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BitsInit::getAsString() const { 4923aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "{ "; 493e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 4943aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 49505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *Bit = getBit(e-i-1)) 4963aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Bit->getAsString(); 49723ffa4a48820e58b411cf94a66b2a0d91173fbfaChris Lattner else 4983aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += "*"; 499e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 5003aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + " }"; 501e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 502e62c1185bee05facc25d1d725434f517261d308bChris Lattner 503307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// Fix bit initializer to preserve the behavior that bit reference from a unset 504307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// bits initializer will resolve into VarBitInit to keep the field name and bit 505307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// number used in targets with fixed insn length. 506307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liaostatic Init *fixBitInit(const RecordVal *RV, Init *Before, Init *After) { 507307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (RV || After != UnsetInit::get()) 508307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return After; 509307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return Before; 510307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 511307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 5129b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// resolveReferences - If there are any field references that refer to fields 5139b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// that have been filled in, we can propagate the values now. 5149b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// 51505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { 51628520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner bool Changed = false; 51705bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(getNumBits()); 51828520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 519307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CachedInit = 0; 520307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CachedBitVar = 0; 521307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao bool CachedBitVarChanged = false; 522307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 523307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 524307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBit = Bits[i]; 525307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBitVar = CurBit->getBitVar(); 526ade0de91236a5967e323a810b21bda4b0425642fChris Lattner 527ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = CurBit; 528307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 529307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CurBitVar == CachedBitVar) { 530307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 531307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CachedInit->getBit(CurBit->getBitNum()); 532307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 533307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 534307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao continue; 535307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 536307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVar = CurBitVar; 537307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged = false; 538307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 539307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *B; 540307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao do { 541307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao B = CurBitVar; 542307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CurBitVar = CurBitVar->resolveReferences(R, RV); 543307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged |= B != CurBitVar; 544307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Changed |= B != CurBitVar; 545307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } while (B != CurBitVar); 546307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedInit = CurBitVar; 547307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 548307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 549307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CurBitVar->getBit(CurBit->getBitNum()); 550307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 551307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 55228520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner } 55328520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 55428520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner if (Changed) 555dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 556ca7fd3de360b266783438666054dba198ff77ba2David Greene 55705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BitsInit *>(this); 55828520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner} 55928520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 56005bce0beee87512e52428d4b80f5a8e79a949576David GreeneIntInit *IntInit::get(int64_t V) { 5612855b0f0730b1a31aa156ea667fee79f66be4b03David Greene typedef DenseMap<int64_t, IntInit *> Pool; 5622855b0f0730b1a31aa156ea667fee79f66be4b03David Greene static Pool ThePool; 5632855b0f0730b1a31aa156ea667fee79f66be4b03David Greene 5642855b0f0730b1a31aa156ea667fee79f66be4b03David Greene IntInit *&I = ThePool[V]; 5652855b0f0730b1a31aa156ea667fee79f66be4b03David Greene if (!I) I = new IntInit(V); 5662855b0f0730b1a31aa156ea667fee79f66be4b03David Greene return I; 567dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 568dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5693aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string IntInit::getAsString() const { 5703aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return itostr(Value); 5713aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 5723aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 57305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 574f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneIntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 57505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 576e62c1185bee05facc25d1d725434f517261d308bChris Lattner 577e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 578ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= 64) 579e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 580ca7fd3de360b266783438666054dba198ff77ba2David Greene 581dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); 582d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene } 583dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 584dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 585dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5862d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid StringInit::anchor() { } 5872d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 588ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund OlesenStringInit *StringInit::get(StringRef V) { 589d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene typedef StringMap<StringInit *> Pool; 590d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene static Pool ThePool; 591d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene 592d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene StringInit *&I = ThePool[V]; 593d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene if (!I) I = new StringInit(V); 594d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene return I; 595dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 596dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 597aad4c9fc37b38cae21343173084c81d789535446David Greenestatic void ProfileListInit(FoldingSetNodeID &ID, 59805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> Range, 599aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy) { 600aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddInteger(Range.size()); 601aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(EltTy); 602aad4c9fc37b38cae21343173084c81d789535446David Greene 60305bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 604aad4c9fc37b38cae21343173084c81d789535446David Greene iend = Range.end(); 605aad4c9fc37b38cae21343173084c81d789535446David Greene i != iend; 606aad4c9fc37b38cae21343173084c81d789535446David Greene ++i) 607aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(*i); 608aad4c9fc37b38cae21343173084c81d789535446David Greene} 609aad4c9fc37b38cae21343173084c81d789535446David Greene 61005bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { 611aad4c9fc37b38cae21343173084c81d789535446David Greene typedef FoldingSet<ListInit> Pool; 612aad4c9fc37b38cae21343173084c81d789535446David Greene static Pool ThePool; 613aad4c9fc37b38cae21343173084c81d789535446David Greene 614aad4c9fc37b38cae21343173084c81d789535446David Greene // Just use the FoldingSetNodeID to compute a hash. Use a DenseMap 615aad4c9fc37b38cae21343173084c81d789535446David Greene // for actual storage. 616aad4c9fc37b38cae21343173084c81d789535446David Greene FoldingSetNodeID ID; 617aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Range, EltTy); 618aad4c9fc37b38cae21343173084c81d789535446David Greene 619aad4c9fc37b38cae21343173084c81d789535446David Greene void *IP = 0; 62005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 621aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 622aad4c9fc37b38cae21343173084c81d789535446David Greene 623aad4c9fc37b38cae21343173084c81d789535446David Greene ListInit *I = new ListInit(Range, EltTy); 624aad4c9fc37b38cae21343173084c81d789535446David Greene ThePool.InsertNode(I, IP); 625aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 626aad4c9fc37b38cae21343173084c81d789535446David Greene} 627aad4c9fc37b38cae21343173084c81d789535446David Greene 628aad4c9fc37b38cae21343173084c81d789535446David Greenevoid ListInit::Profile(FoldingSetNodeID &ID) const { 629736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *ListType = dyn_cast<ListRecTy>(getType()); 630aad4c9fc37b38cae21343173084c81d789535446David Greene assert(ListType && "Bad type for ListInit!"); 631aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy = ListType->getElementType(); 632aad4c9fc37b38cae21343173084c81d789535446David Greene 633aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Values, EltTy); 634d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene} 635d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene 63605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 637f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 63805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 639b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 640b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner if (Elements[i] >= getSize()) 641b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner return 0; 642b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner Vals.push_back(getElement(Elements[i])); 643b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner } 644dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Vals, getType()); 645b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner} 646b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 64750d456539dea5e61d7a1592a78f1861fb35b0063Chris LattnerRecord *ListInit::getElementAsRecord(unsigned i) const { 64850d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner assert(i < Values.size() && "List element index out of range!"); 6496cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Values[i]); 65061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (DI == 0) 65161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Expected record in list!"); 65250d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner return DI->getDef(); 65350d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner} 65450d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner 65505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 65605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Resolved; 6571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.reserve(getSize()); 6581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner bool Changed = false; 6591dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6601dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = getSize(); i != e; ++i) { 66105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E; 66205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurElt = getElement(i); 6631dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6641dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner do { 6651dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner E = CurElt; 6667dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurElt = CurElt->resolveReferences(R, RV); 6671dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Changed |= E != CurElt; 6681dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } while (E != CurElt); 6691dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.push_back(E); 6701dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 6711dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6721dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Changed) 673dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Resolved, getType()); 67405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<ListInit *>(this); 6751dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 6761dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 67705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 67805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 679e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Elt >= getSize()) 680e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; // Out of range reference. 68105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = getElement(Elt); 6822214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 6832214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 6842214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 6853f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 6862214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 687e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene return 0; 688e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 689e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 6903aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string ListInit::getAsString() const { 6913aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "["; 6927cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 6933aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 6943aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Values[i]->getAsString(); 695e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 6963aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "]"; 697e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 698e62c1185bee05facc25d1d725434f517261d308bChris Lattner 69905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 70005bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 701cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *Resolved = resolveReferences(R, IRV); 7026cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *OResolved = dyn_cast<OpInit>(Resolved); 703cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (OResolved) { 704cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Resolved = OResolved->Fold(&R, 0); 705cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene } 706d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 707cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (Resolved != this) { 7086cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *Typed = dyn_cast<TypedInit>(Resolved); 709cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene assert(Typed && "Expected typed init for list reference"); 710d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 711cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *New = Typed->resolveListElementReference(R, IRV, Elt); 712cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (New) 713cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return New; 714cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return VarListElementInit::get(Typed, Elt); 71521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 716d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 71721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 718d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return 0; 719d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 720d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 721307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *OpInit::getBit(unsigned Bit) const { 722307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 723307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<OpInit*>(this); 724307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<OpInit*>(this), Bit); 725307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 726307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 72705bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 72805bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 7296f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7306f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene typedef DenseMap<Key, UnOpInit *> Pool; 7316f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene static Pool ThePool; 7326f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7336f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7346f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7356f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7366f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7376f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 738dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 739dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 74005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 741e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 742e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7432c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 7443f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) 7452c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 746e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7473f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) 748dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 749448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene 7503f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IntInit *LHSi = dyn_cast<IntInit>(LHS)) 751448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene return StringInit::get(LHSi->getAsString()); 75221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7533f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 7542c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7552c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7562c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7572c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7582c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 759c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 76061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 761dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 762e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 763e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 764e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, 765e22b321d2276b634519165b101b02d92c2fcf5c7David Greene ":"); 766e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7672c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7682c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7692c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 770e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 771c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 77261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 773e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 774dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 775e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 776e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 777e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7782c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 779e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); 780e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7812c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 7822c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 7832c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 78421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 785c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 78661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 78721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 788dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 7892c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 7902c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 79121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 79267db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 79377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 794e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 79561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), 79661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "Undefined reference:'" + Name + "'\n"); 7972c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 798e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 799e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 800e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 8011434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 8023f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 8035f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 8045f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in car"); 8055f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 8065f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8075f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 8085f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8095f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8105f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8111434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 8123f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 8135f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 8145f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene assert(0 && "Empty list in cdr"); 8155f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return 0; 8165f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 817dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 818dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 81905bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 82005bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 82105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 82205bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 823dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 8245f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 8255f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8265f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8275f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8281434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 8293f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 8305f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 831dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 83221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 833dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8345f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8355f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8363f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 837e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 838dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 83921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 840dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 841e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 842e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 84321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8445f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8455f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 846e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 84705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 848e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 849e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 85005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 85105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 85221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 853e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 854dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0); 855e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Fold(&R, 0); 856e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 857e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 858e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 859e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 860e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 861e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8621434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8631434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8641434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 865e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 866e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 867e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 868d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 86905bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 87005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 87165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 87205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 87365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 87465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 87565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef DenseMap<Key, BinOpInit *> Pool; 87765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene static Pool ThePool; 87865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 87965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 88065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 88165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 88265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 88365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 88465a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 885dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 886dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 88705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 888711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 88930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 8906cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *LHSs = dyn_cast<DagInit>(LHS); 8916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *RHSs = dyn_cast<DagInit>(RHS); 89230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 8936cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator()); 8946cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator()); 8950b6c926856fe6de3ab2180bdcfd642d9342cd163Chris Lattner if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) 89661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Concated Dag operators do not match!"); 89705bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 89830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 89930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 90030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 90130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 90230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 90330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 90430d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 90530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 90630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 907dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 90830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 90930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 91030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 911711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 9126cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 9136cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 914711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 915dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 916711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 917711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9186786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 919e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 920e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 921307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *L = 9226cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())); 923307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *R = 9246cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get())); 925e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 926e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 927dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 928e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 9296cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 9306cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 931e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 932e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9336786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 934dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9356786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9366786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9376786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 938d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: 939711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 940711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 941711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 9426cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 9436cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *RHSi = dyn_cast<IntInit>(RHS); 944711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 94563f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 94663f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 947711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 948858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Bad opcode!"); 949d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: Result = LHSv + RHSv; break; 950711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 951711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 95263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 953711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 954dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 955711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 956711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 957711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 958711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 95905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 960711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 961711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 96205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 96305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 96405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 96521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 966711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 967dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); 968c7cafcd815519b06318629b424abe746437e1389David Greene return Fold(&R, 0); 969711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 970711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 9713aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 9723aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 973711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 9743aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 975d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: Result = "!add"; break; 9763aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 9773aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 9783aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 9796786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 9803aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 981711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9823aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 983711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 984711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 98505bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 98605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 987dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 988b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 989b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 99005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 99105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 992b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 99305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 994b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 995b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 996b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 997b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 998b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 999b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 1000b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 1001b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 1002b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 1003b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 1004b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 1005b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 1006b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 1007b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 1008dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1009dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 101005bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 101105bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 1012beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 101305bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 101405bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 101505bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 101605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 1017beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10186cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *TArg = dyn_cast<TypedInit>(Arg); 1019beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1020beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 1021beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 102205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 1023d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1024beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1025beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 102621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1027beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1028beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1029beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1030beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1031beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 10326cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i)); 1033beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1034beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 103505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1036d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1037beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1038beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 103921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1040beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1041beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 104221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1043beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 104421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1045beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1046beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1047beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1048beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1049beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1050f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 105105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1052dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewVal != NewOp) 1053beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return NewVal; 1054dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1055beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1056beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1057beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 105805bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 105905bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 10606cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *MHSd = dyn_cast<DagInit>(MHS); 10616cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *MHSl = dyn_cast<ListInit>(MHS); 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSo = dyn_cast<OpInit>(RHS); 1064beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 106661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n"); 1067beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1068beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10696cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *LHSt = dyn_cast<TypedInit>(LHS); 1070beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 107161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (!LHSt) 107261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1073beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 107463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if ((MHSd && isa<DagRecTy>(Type)) || (MHSl && isa<ListRecTy>(Type))) { 1075beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 107605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 107705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1078d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1079beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1081beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1082beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 108305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1084beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 108505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1086beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1087beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1088beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1089beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1090beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 109105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1092d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1093beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1094beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1097beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1098beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1099beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1100beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1101dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1102beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1103beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 110405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 110505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1106beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 110705bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1108beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1109beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1110beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 111105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1112beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1113beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1114beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1115beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1116beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 111721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1118beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1119beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1120beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1121beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1122beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1123f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 112405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1125dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1126beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1127beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1128dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1129beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1130beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1131beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return 0; 1132beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1133beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 113405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11354afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11364afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 11376cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LHSd = dyn_cast<DefInit>(LHS); 11386cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *LHSv = dyn_cast<VarInit>(LHS); 11396cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 11404afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11416cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *MHSd = dyn_cast<DefInit>(MHS); 11426cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *MHSv = dyn_cast<VarInit>(MHS); 11436cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *MHSs = dyn_cast<StringInit>(MHS); 11444afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11456cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *RHSd = dyn_cast<DefInit>(RHS); 11466cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *RHSv = dyn_cast<VarInit>(RHS); 11476cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 11484afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11494afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11514afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11524afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11534afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11544afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11554afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 115777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11584afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11594afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11604afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11614afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11624afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11634afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1164dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11654afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11664afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11674afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11684afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11694afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1170f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11714afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1172f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 11734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 11744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 11754afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1176f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 11774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 11784afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1179dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 11804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11814afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11824afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 118321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 11844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11854afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 118605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1187beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1188beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (Result != 0) { 1189beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 11904afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11914afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 11924afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11939bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 11949bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 11956cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 119605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 11976cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva LHSi = dyn_cast<IntInit>(I); 11989bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 11999bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 12009bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 120121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 12029bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 12039bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12049bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12059bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 12069bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12074afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12084afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 120905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 12104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12114afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 121205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 121305bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 121405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 121577c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 121677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 12176cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *Value = dyn_cast<IntInit>(lhs); 121805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 12196cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva Value = dyn_cast<IntInit>(I); 122077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value != 0) { 122177c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 122277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 122305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1224dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1225dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RHS, getType()))->Fold(&R, 0); 122621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 122705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1228dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1229dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene rhs, getType()))->Fold(&R, 0); 123077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123177c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123277c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 123321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 123405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 123505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 123677c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12374afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1238dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1239dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()))->Fold(&R, 0); 12404afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return Fold(&R, 0); 12414afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12424afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12434afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12444afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12454afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12464afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 124721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 124821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12494afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 125021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12514afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12524afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1253e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12549703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 125563554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) 125663554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName)) 12579703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 12589703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return 0; 12599703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12609703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 126105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1262f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1263736ceace11249da645ec4ed91b8714832193ead4Sean Silva BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); 1264ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-bits variable. 1265e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1266e62c1185bee05facc25d1d725434f517261d308bChris Lattner 126705bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1268e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1269ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1270e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1271ca7fd3de360b266783438666054dba198ff77ba2David Greene 127205bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1273e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1274dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1275e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1276e62c1185bee05facc25d1d725434f517261d308bChris Lattner 127705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1278f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 1279736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *T = dyn_cast<ListRecTy>(getType()); 1280ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling if (T == 0) return 0; // Cannot subscript a non-list variable. 12811dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12821dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 128305bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 12841dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 128505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 12861dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 12871dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 128805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 128905bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1290dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 12911dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 12921dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12931dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 129405bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1295ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *Value = StringInit::get(VN); 1296ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return VarInit::get(Value, T); 1297ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1298ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1299ee6dca17252de152720655282fb4b74b76fb2fe9David GreeneVarInit *VarInit::get(Init *VN, RecTy *T) { 1300ee6dca17252de152720655282fb4b74b76fb2fe9David Greene typedef std::pair<RecTy *, Init *> Key; 1301e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene typedef DenseMap<Key, VarInit *> Pool; 1302e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene static Pool ThePool; 1303e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1304e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1305e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1306e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1307e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1308e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1309dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1310dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1311ee6dca17252de152720655282fb4b74b76fb2fe9David Greeneconst std::string &VarInit::getName() const { 13123f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva StringInit *NameString = dyn_cast<StringInit>(getNameInit()); 1313ee6dca17252de152720655282fb4b74b76fb2fe9David Greene assert(NameString && "VarInit name is not a string!"); 1314ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return NameString->getValue(); 1315ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1316ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1317307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarInit::getBit(unsigned Bit) const { 1318307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1319307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarInit*>(this); 1320307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarInit*>(this), Bit); 1321e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1322e62c1185bee05facc25d1d725434f517261d308bChris Lattner 132305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 132405bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 132505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 1326ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (R.isTemplateArg(getNameInit())) return 0; 1327ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (IRV && IRV->getNameInit() != getNameInit()) return 0; 13281dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1329ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *RV = R.getValue(getNameInit()); 1330a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 13316cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *LI = dyn_cast<ListInit>(RV->getValue()); 1332ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 13336cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *VI = dyn_cast<TypedInit>(RV->getValue()); 1334ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1335dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1336ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 133721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13381dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 13391dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; // Out of range reference. 134005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13412214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13422214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13432214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 13443f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 13452214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 13461dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 13471dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13481dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13491dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1350b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1351736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType())) 1352b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1353b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1354b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1355b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1356b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 135705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 135805bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 135963554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<RecordRecTy>(getType())) 1360d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 13613f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV != Val && (RV || isa<UnsetInit>(Val->getValue()))) 1362d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen return 0; 136305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1364ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 136505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1366b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1367b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 136824151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner return 0; 1369ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1370b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1371b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1372b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 13739b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1374a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 13759b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 13769b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 13779b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 137805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 13799b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 13803f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV == Val || (RV == 0 && !isa<UnsetInit>(Val->getValue()))) 13819b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 138205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 13839b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 13843da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 138505bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 138605bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1387aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1388aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1389aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1390aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1391aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1392aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1393aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1394aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1395aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1396dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1397dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 13983aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 13993aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 14003aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1401db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 140205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 1403307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *I = TI->resolveReferences(R, RV); 1404307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (TI != I) 1405307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return I->getBit(getBitNum()); 1406307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1407307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarBitInit*>(this); 1408db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1409db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 141005bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 141105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 141205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 141308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 141408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 141608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141708f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 141808f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 141908f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 142008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 142108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1422dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1423dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14243aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 14253aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 14263aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 14273aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 142805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 142905bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 143005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1431d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 14321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 143305bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 14341dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14351dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1436307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarListElementInit::getBit(unsigned Bit) const { 1437307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1438307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarListElementInit*>(this); 1439307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit); 14401dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14411dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 144205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 144305bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 144405bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14451045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14461045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14471045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14483f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) { 1449d2b9f20b188966722bca10714c237aa036e8c808David Greene Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1450d2b9f20b188966722bca10714c237aa036e8c808David Greene if (Result2) return Result2; 1451d2b9f20b188966722bca10714c237aa036e8c808David Greene return new VarListElementInit(TInit, Elt); 14521045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14531045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14541045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14551045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14561dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 14571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14581dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 145905bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 146077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 146177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 146277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1463b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1464b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1465b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1466b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 1467b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1468b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 146905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 147005bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1471b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1472b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1473b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1474b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14753aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 14763aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1477e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1478e62c1185bee05facc25d1d725434f517261d308bChris Lattner 147905bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 148005bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 148165bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 148265bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 148365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 148465bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 148565bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 148665bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 148765bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 148865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1489dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1490dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1491307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *FieldInit::getBit(unsigned Bit) const { 1492307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1493307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<FieldInit*>(this); 1494307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<FieldInit*>(this), Bit); 14951dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14961dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 149705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 149805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 149905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 15006cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(ListVal)) { 15011dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) return 0; 150205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 15031dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 15042214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 15052214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 15062214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 15073f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV || !isa<UnsetInit>(E)) 15082214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 15091dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 15101dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return 0; 151124151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 151224151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 151305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 151405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 15157dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 151605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 151724151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 151805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 151905bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1520b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 15217dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 15227dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1523dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 15247dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 152505bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1526db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1527db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 152874b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramerstatic void ProfileDagInit(FoldingSetNodeID &ID, Init *V, const std::string &VN, 152974b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramer ArrayRef<Init *> ArgRange, 153074b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramer ArrayRef<std::string> NameRange) { 153178621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 153278621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 153378621a851ae84520de7d24a6d61e1dcf25749712David Greene 153405bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 153578621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 153678621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 153778621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 153878621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 153978621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 154078621a851ae84520de7d24a6d61e1dcf25749712David Greene } 154178621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 154278621a851ae84520de7d24a6d61e1dcf25749712David Greene} 154378621a851ae84520de7d24a6d61e1dcf25749712David Greene 154405bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 154505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 154605bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 154778621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 154878621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 154978621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 155078621a851ae84520de7d24a6d61e1dcf25749712David Greene 155178621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 155278621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 155378621a851ae84520de7d24a6d61e1dcf25749712David Greene 155478621a851ae84520de7d24a6d61e1dcf25749712David Greene void *IP = 0; 155505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 155678621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 155778621a851ae84520de7d24a6d61e1dcf25749712David Greene 155878621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 155978621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 156078621a851ae84520de7d24a6d61e1dcf25749712David Greene 156178621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 156278621a851ae84520de7d24a6d61e1dcf25749712David Greene} 156378621a851ae84520de7d24a6d61e1dcf25749712David Greene 156405bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 156505bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 156605bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 156705bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1568dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 156905bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1570dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1571dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1572dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1573dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1574dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1575dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1576dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1577dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1578dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1579dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1580dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1581dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1582dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 158378621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 158478621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1585dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1586dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 158705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 158805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1589273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1590273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 159121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 159205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 159321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 15948c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1595dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 159621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 159705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1598273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1599273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1600db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 16013aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 16023aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 16037cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 16047cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 16058e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner if (Args.size()) { 16063aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 16073aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 160891290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 16093aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 16103aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 161191290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 16128e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 16133aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 16148e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 16158e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 16168e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1617e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1618e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1619e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1620e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1621011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1622e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1623dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1624e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1625e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1626e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1627011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1628011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1629011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1630011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1631011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1632011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1633011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 16346cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *NameString = dyn_cast<StringInit>(Name); 1635011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1636011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1637011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1638011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16391a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1640e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16411a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1642e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1643e681d284f96333cef7774c6cc3dd862526af2282David Greene OS << *getType() << " " << getNameInitAsString(); 16447dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16457dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1646e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16477dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1648e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1649e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1650e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16516f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16526f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 1653f7931b7040de1c829e678b4e391308bc3376f8a0David Greenevoid Record::init() { 1654f7931b7040de1c829e678b4e391308bc3376f8a0David Greene checkName(); 1655e338565757bfcfe9d762751c976684f66954fb45David Greene 1656e338565757bfcfe9d762751c976684f66954fb45David Greene // Every record potentially has a def at the top. This value is 1657e338565757bfcfe9d762751c976684f66954fb45David Greene // replaced with the top-level def name at instantiation time. 1658e338565757bfcfe9d762751c976684f66954fb45David Greene RecordVal DN("NAME", StringRecTy::get(), 0); 1659e338565757bfcfe9d762751c976684f66954fb45David Greene addValue(DN); 1660f7931b7040de1c829e678b4e391308bc3376f8a0David Greene} 1661f7931b7040de1c829e678b4e391308bc3376f8a0David Greene 16620d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16630d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16646cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva const TypedInit *TypedName = dyn_cast<const TypedInit>(Name); 16650d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16660d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 166763554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<StringRecTy>(Type)) 166861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record name is not a string!"); 16690d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16700d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 167177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 167277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 167377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 167477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 167577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 167677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 16770d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 16783f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva const StringInit *NameString = dyn_cast<StringInit>(Name); 16790d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 16800d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 16810d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16820d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 16830d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 16840d886401b3ec09b0c2d267942b07702a2f0740f4David Greene if (TrackedRecords.getDef(Name->getAsUnquotedString()) == this) { 16850d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeDef(Name->getAsUnquotedString()); 168667db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addDef(this); 1687f628204262fb91bc095e198b5d9777bd015637e2David Greene } else if (TrackedRecords.getClass(Name->getAsUnquotedString()) == this) { 16880d886401b3ec09b0c2d267942b07702a2f0740f4David Greene TrackedRecords.removeClass(Name->getAsUnquotedString()); 168967db883487fca3472fdde51e931657e22d4d0495Chris Lattner TrackedRecords.addClass(this); 1690f628204262fb91bc095e198b5d9777bd015637e2David Greene } // Otherwise this isn't yet registered. 1691f628204262fb91bc095e198b5d9777bd015637e2David Greene Name = NewName; 16920d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 16930d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 16940d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 16950d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 16960d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 16970d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 16980d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 16990d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 17000d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 17010d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 17020d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 17030d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 17040d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17050d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17060d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 17070d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 170896a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 170996a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 17107dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 17117dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 17127dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 17137dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 17147dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1715a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen if (RV == &Values[i]) // Skip resolve the same field as the given one 1716a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen continue; 171705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 1718307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (Values[i].setValue(V->resolveReferences(*this, RV))) 171961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Invalid value is found when setting '" 1720307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + Values[i].getNameInitAsString() 1721307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' after resolving references" 1722307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + (RV ? " against '" + RV->getNameInitAsString() 1723307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' of (" 1724307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + RV->getValue()->getAsUnquotedString() + ")" 1725307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao : "") 1726307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "\n"); 17277dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 17289c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *OldName = getNameInit(); 17299c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *NewName = Name->resolveReferences(*this, RV); 17309c42bcf2ca4844162b427d017fa419bf93f258e3David Greene if (NewName != OldName) { 17319c42bcf2ca4844162b427d017fa419bf93f258e3David Greene // Re-register with RecordKeeper. 17329c42bcf2ca4844162b427d017fa419bf93f258e3David Greene setName(NewName); 17339c42bcf2ca4844162b427d017fa419bf93f258e3David Greene } 1734e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1735e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17361a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1737e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17381a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 173941effc6c15cb65bf486887b20b1dd419ad40f4afDavid Greene OS << R.getNameInitAsString(); 1740e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1741e22b321d2276b634519165b101b02d92c2fcf5c7David Greene const std::vector<Init *> &TArgs = R.getTemplateArgs(); 1742e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1743e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1744e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1745e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1746e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1747e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1748e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1749e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1750e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1751e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1752e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1753e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1754e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1755e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1756e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1757e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1758a461c398267287d7a5d75fb3fa98d29cbfbb17f4David Greene OS << " " << SC[i]->getNameInitAsString(); 1759e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1760e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1761e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1762e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1763e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1764e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1765e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1766e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1767e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1768e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1769e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1770e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1771e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1772e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1773c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 177461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or abort if the field does not exist. 1775c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 177605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1777c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1778c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner if (R == 0 || R->getValue() == 0) 177961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 178061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1781c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1782c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1783c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1784c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 17855c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 178661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a string, aborts if the field does not exist or if 17875c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 17885c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1789c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 17905c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 17915c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (R == 0 || R->getValue() == 0) 179261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 179361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 17945c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 17956cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *SI = dyn_cast<StringInit>(R->getValue())) 17965c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 179761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 179861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a string initializer!"); 17995c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 18005c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 18016f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 180261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a BitsInit, aborts if the field does not exist or if 180361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 18046f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 180505bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 18066f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 18076f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner if (R == 0 || R->getValue() == 0) 180861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 180961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 18106f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 18116cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue())) 18126f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 181361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 181461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a BitsInit initializer!"); 18156f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 18166f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 181758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 181861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a ListInit, aborting if the field does not exist or if 181961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 182058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 182105bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 182258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 182358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 182461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 182561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 182658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18276cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(R->getValue())) 182858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 182961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 183061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list initializer!"); 183158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18326f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1833b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 183461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of records, aborting if the field does not exist 183561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or if the value is not the right type. 1836fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 183721870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1838c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 183905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1840fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1841fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 18426cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) { 1843fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1844fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 184561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 184661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' list is not entirely DefInit!"); 1847fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1848fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1849fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1850fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1851fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 185258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 185361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an int64_t, aborting if the field does not exist or if the value 185461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 185558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1856c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 185758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 185858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner if (R == 0 || R->getValue() == 0) 185961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 186061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 186158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18626cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(R->getValue())) 186358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 186461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 186561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have an int initializer!"); 186658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18675c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1868af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 186961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of integers, aborting if the field does not exist or 187061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// if the value is not the right type. 1871af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 187221870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1873c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 187405bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 187563f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1876af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 18776cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) { 1878af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1879af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 188061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 188161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list of ints initializer!"); 1882af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1883af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1884af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1885af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1886af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1887bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 188861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// returns its value as a vector of strings, aborting if the field does not 188961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// exist or if the value is not the right type. 1890bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1891bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1892bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 189305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1894bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1895bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 18966cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) { 1897bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1898bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 189961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 190061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a list of strings initializer!"); 1901bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1902bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1903bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1904bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1905bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1906dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 190761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a Record, aborting if the field does not exist or if the value 190861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 1909dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1910c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1911dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1912dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner if (R == 0 || R->getValue() == 0) 191361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 191461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1915dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19166cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(R->getValue())) 1917dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 191861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 191961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a def initializer!"); 1920dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1921dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19220969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 192361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a bit, aborting if the field does not exist or if the value is 192461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 19250969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1926c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 19270969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 19280969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner if (R == 0 || R->getValue() == 0) 192961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 193061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 19310969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 19326cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1933784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 193461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 193561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a bit initializer!"); 1936784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1937784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1938c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesenbool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { 1939c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen const RecordVal *R = getValue(FieldName); 1940c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R == 0 || R->getValue() == 0) 194161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 194261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1943c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1944c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R->getValue() == UnsetInit::get()) { 1945c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = true; 1946c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return false; 1947c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen } 1948c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = false; 19496cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1950c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return BI->getValue(); 195161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 195261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a bit initializer!"); 1953c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen} 1954c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1955784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 195661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an Dag, aborting if the field does not exist or if the value is 195761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 1958784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 195905bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1960784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1961784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner if (R == 0 || R->getValue() == 0) 196261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 196361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1964784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 19656cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DagInit *DI = dyn_cast<DagInit>(R->getValue())) 1966784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 196761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 196861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger FieldName.str() + "' does not have a dag initializer!"); 19690969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19700969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1971dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1972d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19731a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1974d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 197521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19761a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1977d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 1978d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 1979d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 1980d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 1981d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 1982d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 1983d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 1984d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1985d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 19861a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 1987e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19881a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 1989e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 1990e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Classes = RK.getClasses(); 1991e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Classes.begin(), 1992ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 1993e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "class " << *I->second; 19943da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1995e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 1996e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &Defs = RK.getDefs(); 1997e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::const_iterator I = Defs.begin(), 1998ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 1999e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "def " << *I->second; 2000e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 2001e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 2002ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2003ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2004ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 2005ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 2006ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 20075c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 20085c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 20099d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 20105c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 201161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n"); 2012ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20135c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 2014ab47ae3381aa2372009a9054260461c20324b555Chris Lattner for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(), 2015ab47ae3381aa2372009a9054260461c20324b555Chris Lattner E = getDefs().end(); I != E; ++I) 2016ab47ae3381aa2372009a9054260461c20324b555Chris Lattner if (I->second->isSubClassOf(Class)) 2017ab47ae3381aa2372009a9054260461c20324b555Chris Lattner Defs.push_back(I->second); 2018ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20195c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 2020ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 2021d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 202230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 202330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 202430c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 202530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Init *Name, const std::string &Scoper) { 20266cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva RecTy *Type = dyn_cast<TypedInit>(Name)->getType(); 202730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 202830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit *NewName = 202930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 203030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 203130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurRec.getNameInit(), 203230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get(Scoper), 203330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 203430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Name, 203530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 203630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 203730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene if (CurMultiClass && Scoper != "::") { 203830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName = 203930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 204030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 204130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurMultiClass->Rec.getNameInit(), 204230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get("::"), 204330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 204430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName->Fold(&CurRec, CurMultiClass), 204530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 204630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene } 204730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 204830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return NewName->Fold(&CurRec, CurMultiClass); 204930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 205030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 205130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 205230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 205330c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 205430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Name, 205530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Scoper) { 205630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper); 205730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 2058