Record.cpp revision 0c7f116bb6950ef819323d855415b2f2b0aad987
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) { 104dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (BI->getNumBits() != 1) return nullptr; // 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(); 110dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Val != 0 && Val != 1) return nullptr; // 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(); 11737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (isa<BitRecTy>(Ty)) 118e62c1185bee05facc25d1d725434f517261d308bChris Lattner return VI; // Accept variable if it is already of bit type! 11937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *BitsTy = dyn_cast<BitsRecTy>(Ty)) 12037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Accept only bits<1> expression. 12137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return BitsTy->getNumBits() == 1 ? VI : nullptr; 12237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Ternary !if can be converted to bit, but only if both sides are 12337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // convertible to a bit. 12437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (TernOpInit *TOI = dyn_cast<TernOpInit>(VI)) { 12537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (TOI->getOpcode() != TernOpInit::TernaryOp::IF) 12637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 12737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!TOI->getMHS()->convertInitializerTo(BitRecTy::get()) || 12837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines !TOI->getRHS()->convertInitializerTo(BitRecTy::get())) 12937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 13037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return TOI; 13137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 132dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 133e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 134e62c1185bee05facc25d1d725434f517261d308bChris Lattner 13537fda193d292d78c672b8019723c7907af312c43Sean Silvabool BitRecTy::baseClassOf(const RecTy *RHS) const{ 13637fda193d292d78c672b8019723c7907af312c43Sean Silva if(RecTy::baseClassOf(RHS) || getRecTyKind() == IntRecTyKind) 13737fda193d292d78c672b8019723c7907af312c43Sean Silva return true; 13837fda193d292d78c672b8019723c7907af312c43Sean Silva if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS)) 13937fda193d292d78c672b8019723c7907af312c43Sean Silva return BitsTy->getNumBits() == 1; 14037fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 14137fda193d292d78c672b8019723c7907af312c43Sean Silva} 14237fda193d292d78c672b8019723c7907af312c43Sean Silva 14377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenBitsRecTy *BitsRecTy::get(unsigned Sz) { 14477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static std::vector<BitsRecTy*> Shared; 14577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (Sz >= Shared.size()) 14677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Shared.resize(Sz + 1); 14777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen BitsRecTy *&Ty = Shared[Sz]; 14877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!Ty) 14977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen Ty = new BitsRecTy(Sz); 15077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return Ty; 15177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 15277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 15399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string BitsRecTy::getAsString() const { 15499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "bits<" + utostr(Size) + ">"; 15599ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 15699ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 15705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(UnsetInit *UI) { 15805bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 159e62c1185bee05facc25d1d725434f517261d308bChris Lattner 160e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 161dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = UnsetInit::get(); 162ca7fd3de360b266783438666054dba198ff77ba2David Greene 163dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 164e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 165e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitInit *UI) { 167dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Size != 1) return nullptr; // Can only convert single bit. 16836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return BitsInit::get(UI); 169e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 170e62c1185bee05facc25d1d725434f517261d308bChris Lattner 171548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// canFitInBitfield - Return true if the number of bits is large enough to hold 172548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// the integer value. 173548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendlingstatic bool canFitInBitfield(int64_t Value, unsigned NumBits) { 174b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky // For example, with NumBits == 4, we permit Values from [-7 .. 15]. 175b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky return (NumBits >= sizeof(Value) * 8) || 176b2afe8759dbbed1d74da361ef0db1a4aaafefdb3Nick Lewycky (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1); 177548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling} 178548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 179d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// convertValue from Int initializer to bits type: Split the integer up into the 180d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher/// appropriate bits. 181548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling/// 18205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(IntInit *II) { 183294984cecbe1e5abbe37dc38bf2941f2804b13caMisha Brukman int64_t Value = II->getValue(); 184ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // Make sure this bitfield is large enough to hold the integer value. 185548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling if (!canFitInBitfield(Value, Size)) 186dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 187e62c1185bee05facc25d1d725434f517261d308bChris Lattner 18805bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Size); 189ca7fd3de360b266783438666054dba198ff77ba2David Greene 190e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != Size; ++i) 191dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (1LL << i)); 192d19c2cf5d2ae5b263df3f4c7c9744cdf3946f89bChris Lattner 193dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 194e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 195e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(BitsInit *BI) { 197e62c1185bee05facc25d1d725434f517261d308bChris Lattner // If the number of bits is right, return it. Otherwise we need to expand or 198ab7837c26980d260ac0e42d52d6f137e78c8231cBill Wendling // truncate. 199e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (BI->getNumBits() == Size) return BI; 200dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 201e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 202e62c1185bee05facc25d1d725434f517261d308bChris Lattner 20305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsRecTy::convertValue(TypedInit *VI) { 20463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (Size == 1 && isa<BitRecTy>(VI->getType())) 205dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(VI); 2063da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 207307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (VI->getType()->typeIsConvertibleTo(this)) { 208307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao SmallVector<Init *, 16> NewBits(Size); 209d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 210307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0; i != Size; ++i) 211307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = VarBitInit::get(VI, i); 212307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return BitsInit::get(NewBits); 213548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling } 214548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 215dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 216e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 217e62c1185bee05facc25d1d725434f517261d308bChris Lattner 21837fda193d292d78c672b8019723c7907af312c43Sean Silvabool BitsRecTy::baseClassOf(const RecTy *RHS) const{ 21937fda193d292d78c672b8019723c7907af312c43Sean Silva if (RecTy::baseClassOf(RHS)) //argument and the receiver are the same type 22037fda193d292d78c672b8019723c7907af312c43Sean Silva return cast<BitsRecTy>(RHS)->Size == Size; 22137fda193d292d78c672b8019723c7907af312c43Sean Silva RecTyKind kind = RHS->getRecTyKind(); 22237fda193d292d78c672b8019723c7907af312c43Sean Silva return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind); 22337fda193d292d78c672b8019723c7907af312c43Sean Silva} 22437fda193d292d78c672b8019723c7907af312c43Sean Silva 22505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitInit *BI) { 226dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(BI->getValue()); 22708ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner} 22808ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner 22905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(BitsInit *BI) { 23063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result = 0; 2313da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 2326cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) { 233e62c1185bee05facc25d1d725434f517261d308bChris Lattner Result |= Bit->getValue() << i; 234e62c1185bee05facc25d1d725434f517261d308bChris Lattner } else { 235dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 236e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 237dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 238e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 239e62c1185bee05facc25d1d725434f517261d308bChris Lattner 24005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *IntRecTy::convertValue(TypedInit *TI) { 24108ca97291fe309c24a29beba2f2d770aa75c7653Chris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 242b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 243dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 244e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 245e62c1185bee05facc25d1d725434f517261d308bChris Lattner 24637fda193d292d78c672b8019723c7907af312c43Sean Silvabool IntRecTy::baseClassOf(const RecTy *RHS) const{ 24737fda193d292d78c672b8019723c7907af312c43Sean Silva RecTyKind kind = RHS->getRecTyKind(); 24837fda193d292d78c672b8019723c7907af312c43Sean Silva return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind; 24937fda193d292d78c672b8019723c7907af312c43Sean Silva} 25037fda193d292d78c672b8019723c7907af312c43Sean Silva 25105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(UnOpInit *BO) { 252e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 25305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 254dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!L) return nullptr; 255e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 256dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy); 257e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 258e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 259e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 26005bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 261e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 262d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 26305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(BinOpInit *BO) { 264711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (BO->getOpcode() == BinOpInit::STRCONCAT) { 26505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 26605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 267dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!L || !R) return nullptr; 268711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (L != BO->getLHS() || R != BO->getRHS()) 269dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy); 270711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner return BO; 271711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 272e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 27305bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)BO); 274711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 275711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 276711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 27705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *StringRecTy::convertValue(TypedInit *TI) { 27863554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<StringRecTy>(TI->getType())) 279b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner return TI; // Accept variable if already of the right type! 280dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 281e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 282e62c1185bee05facc25d1d725434f517261d308bChris Lattner 28399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string ListRecTy::getAsString() const { 28499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return "list<" + Ty->getAsString() + ">"; 28599ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 28699ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner 28705bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(ListInit *LI) { 28805bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Elements; 2897cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 290e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Verify that all of the elements of the list are subclasses of the 2917cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // appropriate class! 292e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = LI->getSize(); i != e; ++i) 29305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) 2947cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner Elements.push_back(CI); 2957cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner else 296dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2977cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 29863554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<ListRecTy>(LI->getType())) 299dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 300e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 301dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Elements, this); 302e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 303e62c1185bee05facc25d1d725434f517261d308bChris Lattner 30405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListRecTy::convertValue(TypedInit *TI) { 305f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with our class. 306736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (ListRecTy *LRT = dyn_cast<ListRecTy>(TI->getType())) 3077cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) 308f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 309dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 310f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner} 311f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner 31237fda193d292d78c672b8019723c7907af312c43Sean Silvabool ListRecTy::baseClassOf(const RecTy *RHS) const{ 31337fda193d292d78c672b8019723c7907af312c43Sean Silva if(const ListRecTy* ListTy = dyn_cast<ListRecTy>(RHS)) 31437fda193d292d78c672b8019723c7907af312c43Sean Silva return ListTy->getElementType()->typeIsConvertibleTo(Ty); 31537fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 31637fda193d292d78c672b8019723c7907af312c43Sean Silva} 31737fda193d292d78c672b8019723c7907af312c43Sean Silva 31805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(TypedInit *TI) { 31940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner if (TI->getType()->typeIsConvertibleTo(this)) 32040f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return TI; 321dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 32240f71134b9fef0ca06c516f033cc9403394a913cChris Lattner} 32340f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 32405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(UnOpInit *BO) { 325e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (BO->getOpcode() == UnOpInit::CAST) { 32605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getOperand()->convertInitializerTo(this); 327dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!L) return nullptr; 328e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (L != BO->getOperand()) 329dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy); 330e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return BO; 331e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 332dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 333e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 334d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 33505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagRecTy::convertValue(BinOpInit *BO) { 33630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (BO->getOpcode() == BinOpInit::CONCAT) { 33705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *L = BO->getLHS()->convertInitializerTo(this); 33805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *R = BO->getRHS()->convertInitializerTo(this); 339dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!L || !R) return nullptr; 34030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (L != BO->getLHS() || R != BO->getRHS()) 341dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy); 34230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng return BO; 34330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 344dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 34530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng} 34630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng 34777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenRecordRecTy *RecordRecTy::get(Record *R) { 348736ceace11249da645ec4ed91b8714832193ead4Sean Silva return dyn_cast<RecordRecTy>(R->getDefInit()->getType()); 34977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 35077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 35199ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattnerstd::string RecordRecTy::getAsString() const { 35299ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner return Rec->getName(); 35399ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner} 35440f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 35505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(DefInit *DI) { 356e62c1185bee05facc25d1d725434f517261d308bChris Lattner // Ensure that DI is a subclass of Rec. 357e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!DI->getDef()->isSubClassOf(Rec)) 358dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 359e62c1185bee05facc25d1d725434f517261d308bChris Lattner return DI; 360e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 361e62c1185bee05facc25d1d725434f517261d308bChris Lattner 36205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *RecordRecTy::convertValue(TypedInit *TI) { 363f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner // Ensure that TI is compatible with Rec. 364736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RRT = dyn_cast<RecordRecTy>(TI->getType())) 365ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner if (RRT->getRecord()->isSubClassOf(getRecord()) || 366ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner RRT->getRecord() == getRecord()) 367f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner return TI; 368dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 369ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner} 370ce3d64025b32d10dbaf9c77f5b1b56a09bc88f82Chris Lattner 37137fda193d292d78c672b8019723c7907af312c43Sean Silvabool RecordRecTy::baseClassOf(const RecTy *RHS) const{ 37237fda193d292d78c672b8019723c7907af312c43Sean Silva const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS); 37337fda193d292d78c672b8019723c7907af312c43Sean Silva if (!RTy) 37437fda193d292d78c672b8019723c7907af312c43Sean Silva return false; 37537fda193d292d78c672b8019723c7907af312c43Sean Silva 37637fda193d292d78c672b8019723c7907af312c43Sean Silva if (Rec == RTy->getRecord() || RTy->getRecord()->isSubClassOf(Rec)) 37793583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 37893583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 37993583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes const std::vector<Record*> &SC = Rec->getSuperClasses(); 38093583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes for (unsigned i = 0, e = SC.size(); i != e; ++i) 38137fda193d292d78c672b8019723c7907af312c43Sean Silva if (RTy->getRecord()->isSubClassOf(SC[i])) 38293583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return true; 38393583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes 38493583c97f8d265b0e6bf8b561aae0c82dbf2bc06Bruno Cardoso Lopes return false; 3857cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner} 3867cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 38721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// resolveTypes - Find a common type that T1 and T2 convert to. 388e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// Return 0 if no such type exists. 389e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// 390e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid GreeneRecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { 39157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T1->typeIsConvertibleTo(T2)) 39257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T2; 39357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (T2->typeIsConvertibleTo(T1)) 39457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return T1; 39557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva 39657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // If one is a Record type, check superclasses 397736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) { 39857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T2 inherits from a type T1 also inherits from 39957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T1SuperClasses = 40057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy1->getRecord()->getSuperClasses(); 40157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(), 40257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T1SuperClasses.end(); 40357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 40457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 40557838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy1 = RecordRecTy::get(*i); 40657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType1 = resolveTypes(SuperRecTy1, T2); 407dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (NewType1) { 40857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType1 != SuperRecTy1) { 40957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy1; 410e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 41157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType1; 412e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 41357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 41457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva } 415736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2)) { 41657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva // See if T1 inherits from a type T2 also inherits from 41757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva const std::vector<Record *> &T2SuperClasses = 41857838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy2->getRecord()->getSuperClasses(); 41957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(), 42057838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva iend = T2SuperClasses.end(); 42157838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva i != iend; 42257838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva ++i) { 42357838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecordRecTy *SuperRecTy2 = RecordRecTy::get(*i); 42457838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva RecTy *NewType2 = resolveTypes(T1, SuperRecTy2); 425dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (NewType2) { 42657838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva if (NewType2 != SuperRecTy2) { 42757838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva delete SuperRecTy2; 428e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 42957838db0a1cfcfbb8d1df59562dccd22208cd703Sean Silva return NewType2; 430e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 431e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 432e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 433dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 434e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 435e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 436e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 437e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 438e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Initializer implementations 439e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 440e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4412d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid Init::anchor() { } 4421a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Init::dump() const { return print(errs()); } 443e62c1185bee05facc25d1d725434f517261d308bChris Lattner 4442d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid UnsetInit::anchor() { } 4452d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 44605bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnsetInit *UnsetInit::get() { 44705bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnsetInit TheInit; 448ba1ae182876762f17201b33c0b87ca8ede156cfcDavid Greene return &TheInit; 449dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 450dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 4512d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid BitInit::anchor() { } 4522d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 45305bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitInit *BitInit::get(bool V) { 45405bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit True(true); 45505bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit False(false); 4560ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene 4570ffd167a01cc44e1c3bddf4d71d772a38834a30bDavid Greene return V ? &True : &False; 458dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 459dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 460726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenestatic void 46105bce0beee87512e52428d4b80f5a8e79a949576David GreeneProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) { 462726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddInteger(Range.size()); 463726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 46405bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 465726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene iend = Range.end(); 466726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene i != iend; 467726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ++i) 468726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ID.AddPointer(*i); 469726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 470726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 47105bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *BitsInit::get(ArrayRef<Init *> Range) { 472726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene typedef FoldingSet<BitsInit> Pool; 473726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene static Pool ThePool; 474726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 475726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene FoldingSetNodeID ID; 476726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Range); 477726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 478dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void *IP = nullptr; 47905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 480726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 481726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 482726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene BitsInit *I = new BitsInit(Range); 483726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ThePool.InsertNode(I, IP); 484726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 485726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene return I; 486726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene} 487726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 488726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greenevoid BitsInit::Profile(FoldingSetNodeID &ID) const { 489726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene ProfileBitsInit(ID, Bits); 490dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 491dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 49205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 493f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneBitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 49405bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 495ca7fd3de360b266783438666054dba198ff77ba2David Greene 496e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 497ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= getNumBits()) 498dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 499ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = getBit(Bits[i]); 500e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 501dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 502e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 503e62c1185bee05facc25d1d725434f517261d308bChris Lattner 5043aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BitsInit::getAsString() const { 5053aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "{ "; 506e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 5073aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 50805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *Bit = getBit(e-i-1)) 5093aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Bit->getAsString(); 51023ffa4a48820e58b411cf94a66b2a0d91173fbfaChris Lattner else 5113aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += "*"; 512e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 5133aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + " }"; 514e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 515e62c1185bee05facc25d1d725434f517261d308bChris Lattner 516307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// Fix bit initializer to preserve the behavior that bit reference from a unset 517307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// bits initializer will resolve into VarBitInit to keep the field name and bit 518307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao// number used in targets with fixed insn length. 519307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liaostatic Init *fixBitInit(const RecordVal *RV, Init *Before, Init *After) { 520307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (RV || After != UnsetInit::get()) 521307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return After; 522307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return Before; 523307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 524307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 5259b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// resolveReferences - If there are any field references that refer to fields 5269b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// that have been filled in, we can propagate the values now. 5279b929aa7495ee0b5d389370baeb332456632b2feChris Lattner// 52805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { 52928520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner bool Changed = false; 53005bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(getNumBits()); 53128520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 532dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Init *CachedInit = nullptr; 533dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Init *CachedBitVar = nullptr; 534307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao bool CachedBitVarChanged = false; 535307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 536307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao for (unsigned i = 0, e = getNumBits(); i != e; ++i) { 537307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBit = Bits[i]; 538307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *CurBitVar = CurBit->getBitVar(); 539ade0de91236a5967e323a810b21bda4b0425642fChris Lattner 540ca7fd3de360b266783438666054dba198ff77ba2David Greene NewBits[i] = CurBit; 541307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 542307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CurBitVar == CachedBitVar) { 543307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 544307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CachedInit->getBit(CurBit->getBitNum()); 545307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 546307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 547307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao continue; 548307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 549307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVar = CurBitVar; 550307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged = false; 551307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 552307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *B; 553307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao do { 554307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao B = CurBitVar; 555307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CurBitVar = CurBitVar->resolveReferences(R, RV); 556307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedBitVarChanged |= B != CurBitVar; 557307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Changed |= B != CurBitVar; 558307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } while (B != CurBitVar); 559307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao CachedInit = CurBitVar; 560307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 561307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (CachedBitVarChanged) { 562307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *Bit = CurBitVar->getBit(CurBit->getBitNum()); 563307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao NewBits[i] = fixBitInit(RV, CurBit, Bit); 564307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 56528520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner } 56628520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 56728520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner if (Changed) 568dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 569ca7fd3de360b266783438666054dba198ff77ba2David Greene 57005bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BitsInit *>(this); 57128520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner} 57228520c4b61ed71d6c47ce3f9bfc9e2ed659d51a5Chris Lattner 5738f4397799f9eebdc149754c539619ccbed578b90Rafael Espindolanamespace { 5748f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola template<typename T> 5758f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola class Pool : public T { 5768f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola public: 5778f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola ~Pool(); 5788f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola }; 5798f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola template<typename T> 5808f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola Pool<T>::~Pool() { 5818f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola for (typename T::iterator I = this->begin(), E = this->end(); I != E; ++I) { 5828f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola typename T::value_type &Item = *I; 5838f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola delete Item.second; 5848f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola } 5858f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola } 5868f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola} 5878f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola 58805bce0beee87512e52428d4b80f5a8e79a949576David GreeneIntInit *IntInit::get(int64_t V) { 5898f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola static Pool<DenseMap<int64_t, IntInit *> > ThePool; 5902855b0f0730b1a31aa156ea667fee79f66be4b03David Greene 5912855b0f0730b1a31aa156ea667fee79f66be4b03David Greene IntInit *&I = ThePool[V]; 5922855b0f0730b1a31aa156ea667fee79f66be4b03David Greene if (!I) I = new IntInit(V); 5932855b0f0730b1a31aa156ea667fee79f66be4b03David Greene return I; 594dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 595dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 5963aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string IntInit::getAsString() const { 5973aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return itostr(Value); 5983aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 5993aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 60005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 601f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneIntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 60205bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 603e62c1185bee05facc25d1d725434f517261d308bChris Lattner 604e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 605ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= 64) 606dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 607ca7fd3de360b266783438666054dba198ff77ba2David Greene 608dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i])); 609d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene } 610dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 611dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 612dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 6132d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid StringInit::anchor() { } 6142d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 615ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund OlesenStringInit *StringInit::get(StringRef V) { 6168f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola static Pool<StringMap<StringInit *> > ThePool; 617d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene 618d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene StringInit *&I = ThePool[V]; 619d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene if (!I) I = new StringInit(V); 620d0e9d04ab04d862392cbc84543ad9d77c58eb966David Greene return I; 621dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 622dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 623aad4c9fc37b38cae21343173084c81d789535446David Greenestatic void ProfileListInit(FoldingSetNodeID &ID, 62405bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> Range, 625aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy) { 626aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddInteger(Range.size()); 627aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(EltTy); 628aad4c9fc37b38cae21343173084c81d789535446David Greene 62905bce0beee87512e52428d4b80f5a8e79a949576David Greene for (ArrayRef<Init *>::iterator i = Range.begin(), 630aad4c9fc37b38cae21343173084c81d789535446David Greene iend = Range.end(); 631aad4c9fc37b38cae21343173084c81d789535446David Greene i != iend; 632aad4c9fc37b38cae21343173084c81d789535446David Greene ++i) 633aad4c9fc37b38cae21343173084c81d789535446David Greene ID.AddPointer(*i); 634aad4c9fc37b38cae21343173084c81d789535446David Greene} 635aad4c9fc37b38cae21343173084c81d789535446David Greene 63605bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) { 637aad4c9fc37b38cae21343173084c81d789535446David Greene typedef FoldingSet<ListInit> Pool; 638aad4c9fc37b38cae21343173084c81d789535446David Greene static Pool ThePool; 639dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines static std::vector<std::unique_ptr<ListInit>> TheActualPool; 640aad4c9fc37b38cae21343173084c81d789535446David Greene 641aad4c9fc37b38cae21343173084c81d789535446David Greene FoldingSetNodeID ID; 642aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Range, EltTy); 643aad4c9fc37b38cae21343173084c81d789535446David Greene 644dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void *IP = nullptr; 64505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 646aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 647aad4c9fc37b38cae21343173084c81d789535446David Greene 648aad4c9fc37b38cae21343173084c81d789535446David Greene ListInit *I = new ListInit(Range, EltTy); 649aad4c9fc37b38cae21343173084c81d789535446David Greene ThePool.InsertNode(I, IP); 650dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines TheActualPool.push_back(std::unique_ptr<ListInit>(I)); 651aad4c9fc37b38cae21343173084c81d789535446David Greene return I; 652aad4c9fc37b38cae21343173084c81d789535446David Greene} 653aad4c9fc37b38cae21343173084c81d789535446David Greene 654aad4c9fc37b38cae21343173084c81d789535446David Greenevoid ListInit::Profile(FoldingSetNodeID &ID) const { 655736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *ListType = dyn_cast<ListRecTy>(getType()); 656aad4c9fc37b38cae21343173084c81d789535446David Greene assert(ListType && "Bad type for ListInit!"); 657aad4c9fc37b38cae21343173084c81d789535446David Greene RecTy *EltTy = ListType->getElementType(); 658aad4c9fc37b38cae21343173084c81d789535446David Greene 659aad4c9fc37b38cae21343173084c81d789535446David Greene ProfileListInit(ID, Values, EltTy); 660d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene} 661d4a9066c93da9a5aab47ca228d82e796fdec70c0David Greene 66205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 663f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 66405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Vals; 665b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 666b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner if (Elements[i] >= getSize()) 667dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 668b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner Vals.push_back(getElement(Elements[i])); 669b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner } 670dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Vals, getType()); 671b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner} 672b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 67350d456539dea5e61d7a1592a78f1861fb35b0063Chris LattnerRecord *ListInit::getElementAsRecord(unsigned i) const { 67450d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner assert(i < Values.size() && "List element index out of range!"); 6756cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Values[i]); 676dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!DI) 67761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Expected record in list!"); 67850d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner return DI->getDef(); 67950d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner} 68050d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner 68105bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { 68205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Resolved; 6831dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.reserve(getSize()); 6841dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner bool Changed = false; 6851dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6861dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = getSize(); i != e; ++i) { 68705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E; 68805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *CurElt = getElement(i); 6891dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6901dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner do { 6911dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner E = CurElt; 6927dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner CurElt = CurElt->resolveReferences(R, RV); 6931dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Changed |= E != CurElt; 6941dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } while (E != CurElt); 6951dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner Resolved.push_back(E); 6961dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 6971dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 6981dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Changed) 699dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(Resolved, getType()); 70005bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<ListInit *>(this); 7011dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 7021dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 70305bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV, 70405bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 705e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (Elt >= getSize()) 706dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // Out of range reference. 70705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = getElement(Elt); 7082214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 7092214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 7102214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 7113f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 7122214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 713dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 714e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene} 715e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 7163aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string ListInit::getAsString() const { 7173aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "["; 7187cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 7193aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (i) Result += ", "; 7203aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += Values[i]->getAsString(); 721e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 7223aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "]"; 723e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 724e62c1185bee05facc25d1d725434f517261d308bChris Lattner 72505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, 72605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 727cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *Resolved = resolveReferences(R, IRV); 7286cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *OResolved = dyn_cast<OpInit>(Resolved); 729cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (OResolved) { 730dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Resolved = OResolved->Fold(&R, nullptr); 731cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene } 732d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 733cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (Resolved != this) { 7346cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *Typed = dyn_cast<TypedInit>(Resolved); 735cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene assert(Typed && "Expected typed init for list reference"); 736d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (Typed) { 737cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene Init *New = Typed->resolveListElementReference(R, IRV, Elt); 738cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene if (New) 739cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return New; 740cedaae125e26d4d98072ed04017ddaebcfa468f8David Greene return VarListElementInit::get(Typed, Elt); 74121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 742d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 74321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 744dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 745d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene} 746d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 747307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *OpInit::getBit(unsigned Bit) const { 748307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 749307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<OpInit*>(this); 750307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<OpInit*>(this), Bit); 751307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao} 752307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 75305bce0beee87512e52428d4b80f5a8e79a949576David GreeneUnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) { 75405bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key; 7558f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola static Pool<DenseMap<Key, UnOpInit *> > ThePool; 7566f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7576f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type)); 7586f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene 7596f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene UnOpInit *&I = ThePool[TheKey]; 7606f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene if (!I) I = new UnOpInit(opc, lhs, Type); 7616f03b636d26bebad3cfcaaa02a2bbc1b3a6c81b8David Greene return I; 762dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 763dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 76405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 765e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (getOpcode()) { 766e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: { 7672c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (getType()->getAsString() == "string") { 7683f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) 7692c0266202dc10a1ff887a8829950b6548d7feee3David Greene return LHSs; 770e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 7713f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (DefInit *LHSd = dyn_cast<DefInit>(LHS)) 772dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSd->getDef()->getName()); 773448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene 7743f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IntInit *LHSi = dyn_cast<IntInit>(LHS)) 775448b73a95ca9be6409907b96402f1606cd87d80cDavid Greene return StringInit::get(LHSi->getAsString()); 77621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 7773f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 7782c0266202dc10a1ff887a8829950b6548d7feee3David Greene std::string Name = LHSs->getValue(); 7792c0266202dc10a1ff887a8829950b6548d7feee3David Greene 7802c0266202dc10a1ff887a8829950b6548d7feee3David Greene // From TGParser::ParseIDValue 7812c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec) { 7822c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (const RecordVal *RV = CurRec->getValue(Name)) { 783c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 78461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 785dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Name, RV->getType()); 786e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 787e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 788e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, 789e22b321d2276b634519165b101b02d92c2fcf5c7David Greene ":"); 790e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 7912c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurRec->isTemplateArg(TemplateArgName)) { 7922c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurRec->getValue(TemplateArgName); 7932c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 794e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 795c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 79661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 797e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 798dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(TemplateArgName, RV->getType()); 799e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 800e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 801e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 8022c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass) { 803e22b321d2276b634519165b101b02d92c2fcf5c7David Greene Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::"); 804e22b321d2276b634519165b101b02d92c2fcf5c7David Greene 8052c0266202dc10a1ff887a8829950b6548d7feee3David Greene if (CurMultiClass->Rec.isTemplateArg(MCName)) { 8062c0266202dc10a1ff887a8829950b6548d7feee3David Greene const RecordVal *RV = CurMultiClass->Rec.getValue(MCName); 8072c0266202dc10a1ff887a8829950b6548d7feee3David Greene assert(RV && "Template arg doesn't exist??"); 80821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 809c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner if (RV->getType() != getType()) 81061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("type mismatch in cast"); 81121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 812dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(MCName, RV->getType()); 8132c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 8142c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 815ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(CurRec && "NULL pointer"); 81667db883487fca3472fdde51e931657e22d4d0495Chris Lattner if (Record *D = (CurRec->getRecords()).getDef(Name)) 81777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(D); 818e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 81961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), 82061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "Undefined reference:'" + Name + "'\n"); 8212c0266202dc10a1ff887a8829950b6548d7feee3David Greene } 822e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 823e6c27de069225e1122c78385ad22a2ff656db8e6David Greene break; 824e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 8251434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: { 8263f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 827c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines assert(LHSl->getSize() != 0 && "Empty list in car"); 8285f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return LHSl->getElement(0); 8295f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8305f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8315f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8321434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: { 8333f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 834c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines assert(LHSl->getSize() != 0 && "Empty list in cdr"); 835dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // Note the +1. We can't just pass the result of getValues() 836dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene // directly. 83705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1; 83805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator end = LHSl->getValues().end(); 83905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *Result = 84005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit::get(ArrayRef<Init *>(begin, end - begin), 841dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene LHSl->getType()); 8425f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene return Result; 8435f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8445f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8455f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8461434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: { 8473f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) { 8485f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene if (LHSl->getSize() == 0) { 849dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 85021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 851dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 8525f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8535f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 8543f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) { 855e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene if (LHSs->getValue().empty()) { 856dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(1); 85721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 858dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(0); 859e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 860e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 86121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 8625f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene break; 8635f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene } 864e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 86505bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<UnOpInit *>(this); 866e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 867e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 86805bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 86905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 87021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 871e6c27de069225e1122c78385ad22a2ff656db8e6David Greene if (LHS != lhs) 872dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr); 873dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Fold(&R, nullptr); 874e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 875e6c27de069225e1122c78385ad22a2ff656db8e6David Greene 876e6c27de069225e1122c78385ad22a2ff656db8e6David Greenestd::string UnOpInit::getAsString() const { 877e6c27de069225e1122c78385ad22a2ff656db8e6David Greene std::string Result; 878e6c27de069225e1122c78385ad22a2ff656db8e6David Greene switch (Opc) { 879e6c27de069225e1122c78385ad22a2ff656db8e6David Greene case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break; 8801434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case HEAD: Result = "!head"; break; 8811434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case TAIL: Result = "!tail"; break; 8821434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene case EMPTY: Result = "!empty"; break; 883e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 884e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return Result + "(" + LHS->getAsString() + ")"; 885e6c27de069225e1122c78385ad22a2ff656db8e6David Greene} 886d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 88705bce0beee87512e52428d4b80f5a8e79a949576David GreeneBinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs, 88805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs, RecTy *Type) { 88965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene typedef std::pair< 89005bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, Init *>, Init *>, 89165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene RecTy * 89265a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene > Key; 89365a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 8948f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola static Pool<DenseMap<Key, BinOpInit *> > ThePool; 89565a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 89665a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs), 89765a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene Type)); 89865a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene 89965a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene BinOpInit *&I = ThePool[TheKey]; 90065a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene if (!I) I = new BinOpInit(opc, lhs, rhs, Type); 90165a5b8cb3b32db7681afca62d3e9d92941dbf979David Greene return I; 902dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 903dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 90405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 905711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 90630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng case CONCAT: { 9076cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *LHSs = dyn_cast<DagInit>(LHS); 9086cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *RHSs = dyn_cast<DagInit>(RHS); 90930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng if (LHSs && RHSs) { 9106cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator()); 9116cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator()); 912dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!LOp || !ROp || LOp->getDef() != ROp->getDef()) 91361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Concated Dag operators do not match!"); 91405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 91530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng std::vector<std::string> ArgNames; 91630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { 91730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(LHSs->getArg(i)); 91830d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(LHSs->getArgName(i)); 91930d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 92030d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) { 92130d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng Args.push_back(RHSs->getArg(i)); 92230d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng ArgNames.push_back(RHSs->getArgName(i)); 92330d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 924dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(LHSs->getOperator(), "", Args, ArgNames); 92530d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 92630d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng break; 92730d15757e3a203eb4b7170dfccbfd1f93476567bEvan Cheng } 928dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines case LISTCONCAT: { 929dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ListInit *LHSs = dyn_cast<ListInit>(LHS); 930dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ListInit *RHSs = dyn_cast<ListInit>(RHS); 931dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (LHSs && RHSs) { 932dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines std::vector<Init *> Args; 933dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Args.insert(Args.end(), LHSs->begin(), LHSs->end()); 934dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Args.insert(Args.end(), RHSs->begin(), RHSs->end()); 935dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ListInit::get( 936dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Args, static_cast<ListRecTy *>(LHSs->getType())->getElementType()); 937dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 938dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines break; 939dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 940711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case STRCONCAT: { 9416cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 9426cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 943711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSs && RHSs) 944dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(LHSs->getValue() + RHSs->getValue()); 945711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 946711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 9476786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: { 948e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // try to fold eq comparison for 'bit' and 'int', otherwise fallback 949e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // to string objects. 950307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *L = 9516cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())); 952307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao IntInit *R = 9536cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get())); 954e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 955e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes if (L && R) 956dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(L->getValue() == R->getValue()); 957e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 9586cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 9596cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 960e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes 961e87de41189b1591afd88e4dc12eeb17e06b77d3eBruno Cardoso Lopes // Make sure we've resolved 9626786d5e18387465d6106eaef0b7923526ef0bc10David Greene if (LHSs && RHSs) 963dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(LHSs->getValue() == RHSs->getValue()); 9646786d5e18387465d6106eaef0b7923526ef0bc10David Greene 9656786d5e18387465d6106eaef0b7923526ef0bc10David Greene break; 9666786d5e18387465d6106eaef0b7923526ef0bc10David Greene } 967d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: 96837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines case AND: 969711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: 970711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: 971711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRL: { 97237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines IntInit *LHSi = 97337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())); 97437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines IntInit *RHSi = 97537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get())); 976711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHSi && RHSi) { 97763f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); 97863f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Result; 979711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (getOpcode()) { 980858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Bad opcode!"); 981d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: Result = LHSv + RHSv; break; 98237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines case AND: Result = LHSv & RHSv; break; 983711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SHL: Result = LHSv << RHSv; break; 984711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner case SRA: Result = LHSv >> RHSv; break; 98563f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break; 986711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 987dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return IntInit::get(Result); 988711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 989711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner break; 990711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 991711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 99205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<BinOpInit *>(this); 993711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 994711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 99505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { 99605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 99705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 99821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 999711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner if (LHS != lhs || RHS != rhs) 1000dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr); 1001dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Fold(&R, nullptr); 1002711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 1003711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 10043aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string BinOpInit::getAsString() const { 10053aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result; 1006711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner switch (Opc) { 10073aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case CONCAT: Result = "!con"; break; 1008d23a41c153712b929bd84f5e713bda5db5d6e66dHal Finkel case ADD: Result = "!add"; break; 100937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines case AND: Result = "!and"; break; 10103aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SHL: Result = "!shl"; break; 10113aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRA: Result = "!sra"; break; 10123aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case SRL: Result = "!srl"; break; 10136786d5e18387465d6106eaef0b7923526ef0bc10David Greene case EQ: Result = "!eq"; break; 1014dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines case LISTCONCAT: Result = "!listconcat"; break; 10153aba4d39fd101238ac06871895c28f26736d80cbChris Lattner case STRCONCAT: Result = "!strconcat"; break; 1016711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner } 10173aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; 1018711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner} 1019711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattner 102005bce0beee87512e52428d4b80f5a8e79a949576David GreeneTernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, 102105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 1022dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene RecTy *Type) { 1023b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef std::pair< 1024b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene std::pair< 102505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<std::pair<unsigned, RecTy *>, Init *>, 102605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 1027b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene >, 102805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init * 1029b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene > Key; 1030b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 1031b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene typedef DenseMap<Key, TernOpInit *> Pool; 1032b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene static Pool ThePool; 1033b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 1034b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc, 1035b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene Type), 1036b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene lhs), 1037b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene mhs), 1038b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene rhs)); 1039b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene 1040b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene TernOpInit *&I = ThePool[TheKey]; 1041b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene if (!I) I = new TernOpInit(opc, lhs, mhs, rhs, Type); 1042b76a1e6993fa4020a6c1ef552fdf4f564b706facDavid Greene return I; 1043dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1044dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 104505bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 104605bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass); 1047beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 104805bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, 104905bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type, Record *CurRec, 105005bce0beee87512e52428d4b80f5a8e79a949576David Greene MultiClass *CurMultiClass) { 105105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 1052beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10536cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *TArg = dyn_cast<TypedInit>(Arg); 1054beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1055beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // If this is a dag, recurse 1056beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (TArg && TArg->getType()->getAsString() == "dag") { 105705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, 1058d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1059dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Result; 1060beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1061beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1062beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (int i = 0; i < RHSo->getNumOperands(); ++i) { 10636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i)); 1064beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1065beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (RHSoo) { 106605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSoo, LHS, Arg, 1067d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1068dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Result) { 1069beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Result); 107021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1071beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 1072beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 107321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1074beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Arg); 107521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1076beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1077beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1078beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1079beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1080beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new leaf 1081f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 108205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); 1083dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return (NewVal != NewOp) ? NewVal : nullptr; 1084beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1085beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 108605bce0beee87512e52428d4b80f5a8e79a949576David Greenestatic Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, 108705bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *CurRec, MultiClass *CurMultiClass) { 10886cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *MHSd = dyn_cast<DagInit>(MHS); 10896cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *MHSl = dyn_cast<ListInit>(MHS); 1090beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva OpInit *RHSo = dyn_cast<OpInit>(RHS); 1092beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1093beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (!RHSo) { 109461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n"); 1095beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1096beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 10976cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *LHSt = dyn_cast<TypedInit>(LHS); 1098beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 109961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (!LHSt) 110061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n"); 1101beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 110263554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if ((MHSd && isa<DagRecTy>(Type)) || (MHSl && isa<ListRecTy>(Type))) { 1103beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSd) { 110405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = MHSd->getOperator(); 110505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Val, 1106d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher Type, CurRec, CurMultiClass); 1107dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Result) { 1108beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Val = Result; 1109beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1110beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 111105bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init *, std::string> > args; 1112beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { 111305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg; 1114beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene std::string ArgName; 1115beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = MHSd->getArg(i); 1116beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ArgName = MHSd->getArgName(i); 1117beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1118beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Process args 111905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, 1120d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher CurRec, CurMultiClass); 1121dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Result) { 1122beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene Arg = Result; 1123beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1124beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1125beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // TODO: Process arg names 1126beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene args.push_back(std::make_pair(Arg, ArgName)); 1127beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1128beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1129dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Val, "", args); 1130beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1131beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (MHSl) { 113205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewOperands; 113305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); 1134beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 113505bce0beee87512e52428d4b80f5a8e79a949576David Greene for (std::vector<Init *>::iterator li = NewList.begin(), 1136beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene liend = NewList.end(); 1137beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene li != liend; 1138beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene ++li) { 113905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Item = *li; 1140beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.clear(); 1141beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene for(int i = 0; i < RHSo->getNumOperands(); ++i) { 1142beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // First, replace the foreach variable with the list item 1143beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) { 1144beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(Item); 114521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1146beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene NewOperands.push_back(RHSo->getOperand(i)); 1147beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1148beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1149beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1150beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene // Now run the operator and use its result as the new list item 1151f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene const OpInit *NewOp = RHSo->clone(NewOperands); 115205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); 1153dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene if (NewItem != NewOp) 1154beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene *li = NewItem; 1155beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1156dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(NewList, MHSl->getType()); 1157beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1158beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1159dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1160beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene} 1161beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 116205bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { 11634afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (getOpcode()) { 11644afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: { 11656cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *LHSd = dyn_cast<DefInit>(LHS); 11666cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *LHSv = dyn_cast<VarInit>(LHS); 11676cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *LHSs = dyn_cast<StringInit>(LHS); 11684afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11696cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *MHSd = dyn_cast<DefInit>(MHS); 11706cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *MHSv = dyn_cast<VarInit>(MHS); 11716cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *MHSs = dyn_cast<StringInit>(MHS); 11724afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11736cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *RHSd = dyn_cast<DefInit>(RHS); 11746cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva VarInit *RHSv = dyn_cast<VarInit>(RHS); 11756cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *RHSs = dyn_cast<StringInit>(RHS); 11764afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if ((LHSd && MHSd && RHSd) 11784afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSv && MHSv && RHSv) 11794afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene || (LHSs && MHSs && RHSs)) { 11804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSd) { 11814afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Record *Val = RHSd->getDef(); 11824afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSd->getAsString() == RHSd->getAsString()) { 11834afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSd->getDef(); 11844afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 118577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return DefInit::get(Val); 11864afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11874afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSv) { 11884afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSv->getName(); 11894afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHSv->getAsString() == RHSv->getAsString()) { 11904afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val = MHSv->getName(); 11914afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1192dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarInit::get(Val, getType()); 11934afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 11944afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (RHSs) { 11954afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Val = RHSs->getValue(); 11964afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11974afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string::size_type found; 1198f660802f348e4e57ef9df8d30be74b894259badbDavid Greene std::string::size_type idx = 0; 11994afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene do { 1200f660802f348e4e57ef9df8d30be74b894259badbDavid Greene found = Val.find(LHSs->getValue(), idx); 12014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (found != std::string::npos) { 12024afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene Val.replace(found, LHSs->getValue().size(), MHSs->getValue()); 12034afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 1204f660802f348e4e57ef9df8d30be74b894259badbDavid Greene idx = found + MHSs->getValue().size(); 12054afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } while (found != std::string::npos); 12064afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1207dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return StringInit::get(Val); 12084afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12104afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 121121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } 12124afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12134afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case FOREACH: { 121405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), 1215beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene CurRec, CurMultiClass); 1216dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Result) { 1217beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene return Result; 12184afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12194afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene break; 12204afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12219bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene 12229bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene case IF: { 12236cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *LHSi = dyn_cast<IntInit>(LHS); 122405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) 12256cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva LHSi = dyn_cast<IntInit>(I); 12269bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi) { 12279bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene if (LHSi->getValue()) { 12289bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return MHS; 122921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 12309bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene return RHS; 12319bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12329bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12339bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene break; 12349bea7c85d71bbb192f686a56e9b5bf32ae3389e6David Greene } 12354afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12364afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 123705bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<TernOpInit *>(this); 12384afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12394afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 124005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *TernOpInit::resolveReferences(Record &R, 124105bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV) const { 124205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *lhs = LHS->resolveReferences(R, RV); 124377c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 124477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Opc == IF && lhs != LHS) { 12456cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva IntInit *Value = dyn_cast<IntInit>(lhs); 124605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) 12476cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva Value = dyn_cast<IntInit>(I); 1248dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Value) { 124977c489dcae2d7906fae653e2d25e023004d1b9e4David Greene // Short-circuit 125077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene if (Value->getValue()) { 125105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 1252dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, 1253dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RHS, getType()))->Fold(&R, nullptr); 125421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 125505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 1256dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, MHS, 1257dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines rhs, getType()))->Fold(&R, nullptr); 125877c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 125977c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 126077c489dcae2d7906fae653e2d25e023004d1b9e4David Greene } 126121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 126205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs = MHS->resolveReferences(R, RV); 126305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *rhs = RHS->resolveReferences(R, RV); 126477c489dcae2d7906fae653e2d25e023004d1b9e4David Greene 12654afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (LHS != lhs || MHS != mhs || RHS != rhs) 1266dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, 1267dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines getType()))->Fold(&R, nullptr); 1268dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Fold(&R, nullptr); 12694afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 12704afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 12714afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenestd::string TernOpInit::getAsString() const { 12724afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene std::string Result; 12734afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene switch (Opc) { 12744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene case SUBST: Result = "!subst"; break; 127521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case FOREACH: Result = "!foreach"; break; 127621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson case IF: Result = "!if"; break; 12774afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 127821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " 12794afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene + RHS->getAsString() + ")"; 12804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene} 1281e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 12829703843dfa5640ddfc4362d7aa20b03fba485eceDavid GreeneRecTy *TypedInit::getFieldType(const std::string &FieldName) const { 128363554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) 128463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName)) 12859703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene return Field->getType(); 1286dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 12879703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene} 12889703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 128905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1290f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 1291736ceace11249da645ec4ed91b8714832193ead4Sean Silva BitsRecTy *T = dyn_cast<BitsRecTy>(getType()); 1292dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!T) return nullptr; // Cannot subscript a non-bits variable. 1293e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned NumBits = T->getNumBits(); 1294e62c1185bee05facc25d1d725434f517261d308bChris Lattner 129505bce0beee87512e52428d4b80f5a8e79a949576David Greene SmallVector<Init *, 16> NewBits(Bits.size()); 1296e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Bits.size(); i != e; ++i) { 1297ca7fd3de360b266783438666054dba198ff77ba2David Greene if (Bits[i] >= NumBits) 1298dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1299ca7fd3de360b266783438666054dba198ff77ba2David Greene 130005bce0beee87512e52428d4b80f5a8e79a949576David Greene NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]); 1301e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1302dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BitsInit::get(NewBits); 1303e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1304e62c1185bee05facc25d1d725434f517261d308bChris Lattner 130505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 1306f37dd02f7743ebd2424480361f5a7db510495c4fDavid GreeneTypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { 1307736ceace11249da645ec4ed91b8714832193ead4Sean Silva ListRecTy *T = dyn_cast<ListRecTy>(getType()); 1308dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!T) return nullptr; // Cannot subscript a non-list variable. 13091dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13101dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elements.size() == 1) 131105bce0beee87512e52428d4b80f5a8e79a949576David Greene return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]); 13121dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 131305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> ListInits; 13141dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner ListInits.reserve(Elements.size()); 13151dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 131605bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this), 131705bce0beee87512e52428d4b80f5a8e79a949576David Greene Elements[i])); 1318dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ListInit::get(ListInits, T); 13191dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13201dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13211dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 132205bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarInit *VarInit::get(const std::string &VN, RecTy *T) { 1323ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *Value = StringInit::get(VN); 1324ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return VarInit::get(Value, T); 1325ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1326ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1327ee6dca17252de152720655282fb4b74b76fb2fe9David GreeneVarInit *VarInit::get(Init *VN, RecTy *T) { 1328ee6dca17252de152720655282fb4b74b76fb2fe9David Greene typedef std::pair<RecTy *, Init *> Key; 13298f4397799f9eebdc149754c539619ccbed578b90Rafael Espindola static Pool<DenseMap<Key, VarInit *> > ThePool; 1330e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1331e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene Key TheKey(std::make_pair(T, VN)); 1332e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene 1333e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene VarInit *&I = ThePool[TheKey]; 1334e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene if (!I) I = new VarInit(VN, T); 1335e0be0e361a8306a7106ccab27dcf0140a748bfbcDavid Greene return I; 1336dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1337dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1338ee6dca17252de152720655282fb4b74b76fb2fe9David Greeneconst std::string &VarInit::getName() const { 13393f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva StringInit *NameString = dyn_cast<StringInit>(getNameInit()); 1340ee6dca17252de152720655282fb4b74b76fb2fe9David Greene assert(NameString && "VarInit name is not a string!"); 1341ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return NameString->getValue(); 1342ee6dca17252de152720655282fb4b74b76fb2fe9David Greene} 1343ee6dca17252de152720655282fb4b74b76fb2fe9David Greene 1344307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarInit::getBit(unsigned Bit) const { 1345307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1346307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarInit*>(this); 1347307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarInit*>(this), Bit); 1348e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1349e62c1185bee05facc25d1d725434f517261d308bChris Lattner 135005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveListElementReference(Record &R, 135105bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *IRV, 135205bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 1353dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (R.isTemplateArg(getNameInit())) return nullptr; 1354dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (IRV && IRV->getNameInit() != getNameInit()) return nullptr; 13551dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1356ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *RV = R.getValue(getNameInit()); 1357a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson assert(RV && "Reference to a non-existent variable?"); 13586cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva ListInit *LI = dyn_cast<ListInit>(RV->getValue()); 1359ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene if (!LI) { 13606cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva TypedInit *VI = dyn_cast<TypedInit>(RV->getValue()); 1361ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene assert(VI && "Invalid list element!"); 1362dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return VarListElementInit::get(VI, Elt); 1363ccf85ded583167cbdbc20043e698eda8a7c2ed7dDavid Greene } 136421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 13651dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner if (Elt >= LI->getSize()) 1366dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // Out of range reference. 136705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 13682214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a reference 13692214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // to a specific variable and that variable is explicitly unset, then 13702214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // replace the VarListElementInit with it. 13713f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (IRV || !isa<UnsetInit>(E)) 13722214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 1373dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 13741dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 13751dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 13761dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1377b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *VarInit::getFieldType(const std::string &FieldName) const { 1378736ceace11249da645ec4ed91b8714832193ead4Sean Silva if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType())) 1379b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName)) 1380b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1381dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1382b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1383b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 138405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::getFieldInit(Record &R, const RecordVal *RV, 138505bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 138663554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (isa<RecordRecTy>(getType())) 1387d1baa252c41322d3a38d4360ba1dbcc20c0badf9Jakob Stoklund Olesen if (const RecordVal *Val = R.getValue(VarName)) { 13883f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV != Val && (RV || isa<UnsetInit>(Val->getValue()))) 1389dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 139005bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *TheInit = Val->getValue(); 1391ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner assert(TheInit != this && "Infinite loop detected!"); 139205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) 1393b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return I; 1394b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner else 1395dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1396ff367ee1c5977299c57343f93a31c7d40b5ede5dChris Lattner } 1397dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1398b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1399b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 14009b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// resolveReferences - This method is used by classes that refer to other 1401a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson/// variables which may not be defined at the time the expression is formed. 14029b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// If a value is set for the variable later, this method will be called on 14039b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// users of the value to allow the value to propagate out. 14049b929aa7495ee0b5d389370baeb332456632b2feChris Lattner/// 140505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { 14069b929aa7495ee0b5d389370baeb332456632b2feChris Lattner if (RecordVal *Val = R.getValue(VarName)) 1407dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (RV == Val || (!RV && !isa<UnsetInit>(Val->getValue()))) 14089b929aa7495ee0b5d389370baeb332456632b2feChris Lattner return Val->getValue(); 140905bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarInit *>(this); 14109b929aa7495ee0b5d389370baeb332456632b2feChris Lattner} 14113da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 141205bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarBitInit *VarBitInit::get(TypedInit *T, unsigned B) { 141305bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 1414aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene typedef DenseMap<Key, VarBitInit *> Pool; 1415aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1416aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene static Pool ThePool; 1417aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1418aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene Key TheKey(std::make_pair(T, B)); 1419aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene 1420aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene VarBitInit *&I = ThePool[TheKey]; 1421aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene if (!I) I = new VarBitInit(T, B); 1422aa839b8fa3e4500551f23b20491c1c55e89567b5David Greene return I; 1423dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1424dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14253aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarBitInit::getAsString() const { 14263aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "{" + utostr(Bit) + "}"; 14273aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 1428db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 142905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const { 1430307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao Init *I = TI->resolveReferences(R, RV); 1431307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (TI != I) 1432307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return I->getBit(getBitNum()); 1433307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1434307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarBitInit*>(this); 1435db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1436db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 143705bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit *VarListElementInit::get(TypedInit *T, 143805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned E) { 143905bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<TypedInit *, unsigned> Key; 144008f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene typedef DenseMap<Key, VarListElementInit *> Pool; 144108f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 144208f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene static Pool ThePool; 144308f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 144408f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene Key TheKey(std::make_pair(T, E)); 144508f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene 144608f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene VarListElementInit *&I = ThePool[TheKey]; 144708f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene if (!I) I = new VarListElementInit(T, E); 144808f71e3e7437359f94fed3207bc64d8cc54ef3f3David Greene return I; 1449dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1450dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 14513aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string VarListElementInit::getAsString() const { 14523aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return TI->getAsString() + "[" + utostr(Element) + "]"; 14533aba4d39fd101238ac06871895c28f26736d80cbChris Lattner} 14543aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 145505bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit * 145605bce0beee87512e52428d4b80f5a8e79a949576David GreeneVarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const { 145705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *I = getVariable()->resolveListElementReference(R, RV, 1458d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher getElementNum())) 14591dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner return I; 146005bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<VarListElementInit *>(this); 14611dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14621dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1463307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *VarListElementInit::getBit(unsigned Bit) const { 1464307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1465307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarListElementInit*>(this); 1466307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit); 14671dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14681dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 146905bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *VarListElementInit:: resolveListElementReference(Record &R, 147005bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 147105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 14721045a594e65c65c55dfcd9585658eee85ef79e75David Greene Init *Result = TI->resolveListElementReference(R, RV, Element); 14731045a594e65c65c55dfcd9585658eee85ef79e75David Greene 14741045a594e65c65c55dfcd9585658eee85ef79e75David Greene if (Result) { 14753f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) { 1476d2b9f20b188966722bca10714c237aa036e8c808David Greene Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); 1477d2b9f20b188966722bca10714c237aa036e8c808David Greene if (Result2) return Result2; 1478d2b9f20b188966722bca10714c237aa036e8c808David Greene return new VarListElementInit(TInit, Elt); 14791045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14801045a594e65c65c55dfcd9585658eee85ef79e75David Greene return Result; 14811045a594e65c65c55dfcd9585658eee85ef79e75David Greene } 14821045a594e65c65c55dfcd9585658eee85ef79e75David Greene 1483dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 14841dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 14851dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 148605bce0beee87512e52428d4b80f5a8e79a949576David GreeneDefInit *DefInit::get(Record *R) { 148777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return R->getDefInit(); 148877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 148977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1490b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris LattnerRecTy *DefInit::getFieldType(const std::string &FieldName) const { 1491b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner if (const RecordVal *RV = Def->getValue(FieldName)) 1492b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return RV->getType(); 1493dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1494b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1495b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 149605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DefInit::getFieldInit(Record &R, const RecordVal *RV, 149705bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 1498b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return Def->getValue(FieldName)->getValue(); 1499b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner} 1500b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1501b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 15023aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DefInit::getAsString() const { 15033aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Def->getName(); 1504e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1505e62c1185bee05facc25d1d725434f517261d308bChris Lattner 150605bce0beee87512e52428d4b80f5a8e79a949576David GreeneFieldInit *FieldInit::get(Init *R, const std::string &FN) { 150705bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init *, TableGenStringKey> Key; 150865bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene typedef DenseMap<Key, FieldInit *> Pool; 150965bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene static Pool ThePool; 151065bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 151165bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene Key TheKey(std::make_pair(R, FN)); 151265bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene 151365bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene FieldInit *&I = ThePool[TheKey]; 151465bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene if (!I) I = new FieldInit(R, FN); 151565bf3ca9aa474db6c5c2a0d3ea0f4a22af514184David Greene return I; 1516dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1517dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1518307525cd24c3b9c081ddb3c34a3418f2875cd556Michael LiaoInit *FieldInit::getBit(unsigned Bit) const { 1519307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (getType() == BitRecTy::get()) 1520307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<FieldInit*>(this); 1521307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return VarBitInit::get(const_cast<FieldInit*>(this), Bit); 15221dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner} 15231dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 152405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, 152505bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 152605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) 15276cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(ListVal)) { 1528dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Elt >= LI->getSize()) return nullptr; 152905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *E = LI->getElement(Elt); 15301dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 15312214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // If the element is set to some value, or if we are resolving a 15322214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // reference to a specific variable and that variable is explicitly 15332214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson // unset, then replace the VarListElementInit with it. 15343f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (RV || !isa<UnsetInit>(E)) 15352214dc07649d36e47d11914e1ffc7c56eb40ad73Bob Wilson return E; 15361dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 1537dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 153824151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner} 153924151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 154005bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { 154105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; 15427dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 154305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); 154424151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner if (BitsVal) { 154505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *BVR = BitsVal->resolveReferences(R, RV); 154605bce0beee87512e52428d4b80f5a8e79a949576David Greene return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this); 1547b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 15487dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 15497dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (NewRec != Rec) { 1550dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return FieldInit::get(NewRec, FieldName); 15517dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 155205bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<FieldInit *>(this); 1553db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner} 1554db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 155574b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramerstatic void ProfileDagInit(FoldingSetNodeID &ID, Init *V, const std::string &VN, 155674b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramer ArrayRef<Init *> ArgRange, 155774b3c8da4800c7e8ba8f019879db29738ecc5f74Benjamin Kramer ArrayRef<std::string> NameRange) { 155878621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(V); 155978621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(VN); 156078621a851ae84520de7d24a6d61e1dcf25749712David Greene 156105bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *>::iterator Arg = ArgRange.begin(); 156278621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string>::iterator Name = NameRange.begin(); 156378621a851ae84520de7d24a6d61e1dcf25749712David Greene while (Arg != ArgRange.end()) { 156478621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name != NameRange.end() && "Arg name underflow!"); 156578621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddPointer(*Arg++); 156678621a851ae84520de7d24a6d61e1dcf25749712David Greene ID.AddString(*Name++); 156778621a851ae84520de7d24a6d61e1dcf25749712David Greene } 156878621a851ae84520de7d24a6d61e1dcf25749712David Greene assert(Name == NameRange.end() && "Arg name overflow!"); 156978621a851ae84520de7d24a6d61e1dcf25749712David Greene} 157078621a851ae84520de7d24a6d61e1dcf25749712David Greene 157105bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 157205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 157305bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 157478621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) { 157578621a851ae84520de7d24a6d61e1dcf25749712David Greene typedef FoldingSet<DagInit> Pool; 157678621a851ae84520de7d24a6d61e1dcf25749712David Greene static Pool ThePool; 157778621a851ae84520de7d24a6d61e1dcf25749712David Greene 157878621a851ae84520de7d24a6d61e1dcf25749712David Greene FoldingSetNodeID ID; 157978621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, V, VN, ArgRange, NameRange); 158078621a851ae84520de7d24a6d61e1dcf25749712David Greene 1581dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void *IP = nullptr; 158205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP)) 158378621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 158478621a851ae84520de7d24a6d61e1dcf25749712David Greene 158578621a851ae84520de7d24a6d61e1dcf25749712David Greene DagInit *I = new DagInit(V, VN, ArgRange, NameRange); 158678621a851ae84520de7d24a6d61e1dcf25749712David Greene ThePool.InsertNode(I, IP); 158778621a851ae84520de7d24a6d61e1dcf25749712David Greene 158878621a851ae84520de7d24a6d61e1dcf25749712David Greene return I; 158978621a851ae84520de7d24a6d61e1dcf25749712David Greene} 159078621a851ae84520de7d24a6d61e1dcf25749712David Greene 159105bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit * 159205bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit::get(Init *V, const std::string &VN, 159305bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector<std::pair<Init*, std::string> > &args) { 159405bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::pair<Init*, std::string> PairType; 1595dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 159605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init *> Args; 1597dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene std::vector<std::string> Names; 1598dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1599dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene for (std::vector<PairType>::const_iterator i = args.begin(), 1600dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene iend = args.end(); 1601dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene i != iend; 1602dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene ++i) { 1603dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Args.push_back(i->first); 1604dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Names.push_back(i->second); 1605dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene } 1606dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1607dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(V, VN, Args, Names); 1608dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1609dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 161078621a851ae84520de7d24a6d61e1dcf25749712David Greenevoid DagInit::Profile(FoldingSetNodeID &ID) const { 161178621a851ae84520de7d24a6d61e1dcf25749712David Greene ProfileDagInit(ID, Val, ValName, Args, ArgNames); 1612dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene} 1613dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 161405bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { 161505bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> NewArgs; 1616273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) 1617273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner NewArgs.push_back(Args[i]->resolveReferences(R, RV)); 161821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 161905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Op = Val->resolveReferences(R, RV); 162021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 16218c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner if (Args != NewArgs || Op != Val) 1622dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return DagInit::get(Op, ValName, NewArgs, ArgNames); 162321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 162405bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<DagInit *>(this); 1625273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner} 1626273d463befb26004ed5be8dc737321f65a175ad0Chris Lattner 1627db1b766fe63d22627b80346fcbf0ee95a69f791dChris Lattner 16283aba4d39fd101238ac06871895c28f26736d80cbChris Lattnerstd::string DagInit::getAsString() const { 16293aba4d39fd101238ac06871895c28f26736d80cbChris Lattner std::string Result = "(" + Val->getAsString(); 16307cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!ValName.empty()) 16317cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result += ":" + ValName; 1632ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Args.empty()) { 16333aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += " " + Args[0]->getAsString(); 16343aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0]; 163591290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) { 16363aba4d39fd101238ac06871895c28f26736d80cbChris Lattner Result += ", " + Args[i]->getAsString(); 16373aba4d39fd101238ac06871895c28f26736d80cbChris Lattner if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i]; 163891290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 16398e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 16403aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Result + ")"; 16418e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner} 16428e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 16438e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 1644e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1645e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Other implementations 1646e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1647e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1648011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(Init *N, RecTy *T, unsigned P) 1649e62c1185bee05facc25d1d725434f517261d308bChris Lattner : Name(N), Ty(T), Prefix(P) { 1650dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene Value = Ty->convertValue(UnsetInit::get()); 1651e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(Value && "Cannot create unset value for current type!"); 1652e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1653e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1654011dca7fac07100695dd3685bfaddbea58a468b9David GreeneRecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P) 1655011dca7fac07100695dd3685bfaddbea58a468b9David Greene : Name(StringInit::get(N)), Ty(T), Prefix(P) { 1656011dca7fac07100695dd3685bfaddbea58a468b9David Greene Value = Ty->convertValue(UnsetInit::get()); 1657011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(Value && "Cannot create unset value for current type!"); 1658011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1659011dca7fac07100695dd3685bfaddbea58a468b9David Greene 1660011dca7fac07100695dd3685bfaddbea58a468b9David Greeneconst std::string &RecordVal::getName() const { 16616cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva StringInit *NameString = dyn_cast<StringInit>(Name); 1662011dca7fac07100695dd3685bfaddbea58a468b9David Greene assert(NameString && "RecordVal name is not a string!"); 1663011dca7fac07100695dd3685bfaddbea58a468b9David Greene return NameString->getValue(); 1664011dca7fac07100695dd3685bfaddbea58a468b9David Greene} 1665011dca7fac07100695dd3685bfaddbea58a468b9David Greene 16661a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::dump() const { errs() << *this; } 1667e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16681a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordVal::print(raw_ostream &OS, bool PrintSem) const { 1669e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (getPrefix()) OS << "field "; 1670e681d284f96333cef7774c6cc3dd862526af2282David Greene OS << *getType() << " " << getNameInitAsString(); 16717dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16727dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner if (getValue()) 1673e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " = " << *getValue(); 16747dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 1675e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (PrintSem) OS << ";\n"; 1676e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1677e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16786f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarunsigned Record::LastID = 0; 16796f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 1680f7931b7040de1c829e678b4e391308bc3376f8a0David Greenevoid Record::init() { 1681f7931b7040de1c829e678b4e391308bc3376f8a0David Greene checkName(); 1682e338565757bfcfe9d762751c976684f66954fb45David Greene 1683e338565757bfcfe9d762751c976684f66954fb45David Greene // Every record potentially has a def at the top. This value is 1684e338565757bfcfe9d762751c976684f66954fb45David Greene // replaced with the top-level def name at instantiation time. 1685e338565757bfcfe9d762751c976684f66954fb45David Greene RecordVal DN("NAME", StringRecTy::get(), 0); 1686e338565757bfcfe9d762751c976684f66954fb45David Greene addValue(DN); 1687f7931b7040de1c829e678b4e391308bc3376f8a0David Greene} 1688f7931b7040de1c829e678b4e391308bc3376f8a0David Greene 16890d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::checkName() { 16900d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Ensure the record name has string type. 16916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva const TypedInit *TypedName = dyn_cast<const TypedInit>(Name); 16920d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(TypedName && "Record name is not typed!"); 16930d886401b3ec09b0c2d267942b07702a2f0740f4David Greene RecTy *Type = TypedName->getType(); 169463554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva if (!isa<StringRecTy>(Type)) 169561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record name is not a string!"); 16960d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 16970d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 169877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund OlesenDefInit *Record::getDefInit() { 169977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen if (!TheInit) 170077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen TheInit = new DefInit(this, new RecordRecTy(this)); 170177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen return TheInit; 170277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen} 170377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 17040d886401b3ec09b0c2d267942b07702a2f0740f4David Greeneconst std::string &Record::getName() const { 17053f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva const StringInit *NameString = dyn_cast<StringInit>(Name); 17060d886401b3ec09b0c2d267942b07702a2f0740f4David Greene assert(NameString && "Record name is not a string!"); 17070d886401b3ec09b0c2d267942b07702a2f0740f4David Greene return NameString->getValue(); 17080d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17090d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17100d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(Init *NewName) { 1711f628204262fb91bc095e198b5d9777bd015637e2David Greene Name = NewName; 17120d886401b3ec09b0c2d267942b07702a2f0740f4David Greene checkName(); 17130d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // DO NOT resolve record values to the name at this point because 17140d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // there might be default values for arguments of this def. Those 17150d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // arguments might not have been resolved yet so we don't want to 17160d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // prematurely assume values for those arguments were not passed to 17170d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this def. 17180d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // 17190d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // Nonetheless, it may be that some of this Record's values 17200d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // reference the record name. Indeed, the reason for having the 17210d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // record name be an Init is to provide this flexibility. The extra 17220d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // resolve steps after completely instantiating defs takes care of 17230d886401b3ec09b0c2d267942b07702a2f0740f4David Greene // this. See TGParser::ParseDef and TGParser::ParseDefm. 17240d886401b3ec09b0c2d267942b07702a2f0740f4David Greene} 17250d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 17260d886401b3ec09b0c2d267942b07702a2f0740f4David Greenevoid Record::setName(const std::string &Name) { 17270d886401b3ec09b0c2d267942b07702a2f0740f4David Greene setName(StringInit::get(Name)); 172896a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene} 172996a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 17307dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// resolveReferencesTo - If anything in this record refers to RV, replace the 17317dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// reference to RV with the RHS of RV. If RV is null, we resolve all possible 17327dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner/// references. 17337dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnervoid Record::resolveReferencesTo(const RecordVal *RV) { 17347dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1735a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen if (RV == &Values[i]) // Skip resolve the same field as the given one 1736a2da78852b25ef098c91e5923e8edf205c3bf0c7Jakob Stoklund Olesen continue; 173705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Init *V = Values[i].getValue()) 1738307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao if (Values[i].setValue(V->resolveReferences(*this, RV))) 173961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Invalid value is found when setting '" 1740307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + Values[i].getNameInitAsString() 1741307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' after resolving references" 1742307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + (RV ? " against '" + RV->getNameInitAsString() 1743307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "' of (" 1744307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + RV->getValue()->getAsUnquotedString() + ")" 1745307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao : "") 1746307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao + "\n"); 17477dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 17489c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *OldName = getNameInit(); 17499c42bcf2ca4844162b427d017fa419bf93f258e3David Greene Init *NewName = Name->resolveReferences(*this, RV); 17509c42bcf2ca4844162b427d017fa419bf93f258e3David Greene if (NewName != OldName) { 17519c42bcf2ca4844162b427d017fa419bf93f258e3David Greene // Re-register with RecordKeeper. 17529c42bcf2ca4844162b427d017fa419bf93f258e3David Greene setName(NewName); 17539c42bcf2ca4844162b427d017fa419bf93f258e3David Greene } 1754e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1755e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17561a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid Record::dump() const { errs() << *this; } 1757e62c1185bee05facc25d1d725434f517261d308bChris Lattner 17581a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { 175941effc6c15cb65bf486887b20b1dd419ad40f4afDavid Greene OS << R.getNameInitAsString(); 1760e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1761e22b321d2276b634519165b101b02d92c2fcf5c7David Greene const std::vector<Init *> &TArgs = R.getTemplateArgs(); 1762e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!TArgs.empty()) { 1763e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "<"; 1764e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TArgs.size(); i != e; ++i) { 1765e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (i) OS << ", "; 1766e62c1185bee05facc25d1d725434f517261d308bChris Lattner const RecordVal *RV = R.getValue(TArgs[i]); 1767e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(RV && "Template argument record not found??"); 1768e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV->print(OS, false); 1769e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1770e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << ">"; 1771e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1772e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1773e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << " {"; 1774e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &SC = R.getSuperClasses(); 1775e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!SC.empty()) { 1776e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\t//"; 1777e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SC.size(); i != e; ++i) 1778a461c398267287d7a5d75fb3fa98d29cbfbb17f4David Greene OS << " " << SC[i]->getNameInitAsString(); 1779e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1780e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "\n"; 1781e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1782e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &Vals = R.getValues(); 1783e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1784e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1785e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1786e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Vals.size(); i != e; ++i) 1787e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName())) 1788e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << Vals[i]; 1789e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1790e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS << "}\n"; 1791e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1792e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1793c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// getValueInit - Return the initializer for a value with the specified name, 179461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or abort if the field does not exist. 1795c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner/// 179605bce0beee87512e52428d4b80f5a8e79a949576David GreeneInit *Record::getValueInit(StringRef FieldName) const { 1797c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner const RecordVal *R = getValue(FieldName); 1798dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 179961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 180036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 1801c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner return R->getValue(); 1802c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner} 1803c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 1804c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 18055c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// getValueAsString - This method looks up the specified field and returns its 180661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a string, aborts if the field does not exist or if 18075c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// the value is not a string. 18085c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner/// 1809c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerstd::string Record::getValueAsString(StringRef FieldName) const { 18105c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const RecordVal *R = getValue(FieldName); 1811dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 181261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 181336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 18145c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 18156cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *SI = dyn_cast<StringInit>(R->getValue())) 18165c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return SI->getValue(); 181761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 181836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a string initializer!"); 18195c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner} 18205c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 18216f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// getValueAsBitsInit - This method looks up the specified field and returns 182261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a BitsInit, aborts if the field does not exist or if 182361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 18246f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner/// 182505bce0beee87512e52428d4b80f5a8e79a949576David GreeneBitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { 18266f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner const RecordVal *R = getValue(FieldName); 1827dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 182861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 182936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 18306f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 18316cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue())) 18326f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner return BI; 183361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 183436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a BitsInit initializer!"); 18356f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner} 18366f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 183758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsListInit - This method looks up the specified field and returns 183861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a ListInit, aborting if the field does not exist or if 183961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// the value is not the right type. 184058c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 184105bce0beee87512e52428d4b80f5a8e79a949576David GreeneListInit *Record::getValueAsListInit(StringRef FieldName) const { 184258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 1843dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 184461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 184536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 184658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18476cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (ListInit *LI = dyn_cast<ListInit>(R->getValue())) 184858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return LI; 184961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 185036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a list initializer!"); 185158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18526f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 1853b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner/// getValueAsListOfDefs - This method looks up the specified field and returns 185461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of records, aborting if the field does not exist 185561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// or if the value is not the right type. 1856fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey/// 185721870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<Record*> 1858c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfDefs(StringRef FieldName) const { 185905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1860fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey std::vector<Record*> Defs; 1861fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey for (unsigned i = 0; i < List->getSize(); i++) { 18626cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) { 1863fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey Defs.push_back(DI->getDef()); 1864fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } else { 186561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 186636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' list is not entirely DefInit!"); 1867fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1868fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey } 1869fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey return Defs; 1870fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey} 1871fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 187258c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// getValueAsInt - This method looks up the specified field and returns its 187361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an int64_t, aborting if the field does not exist or if the value 187461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 187558c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner/// 1876c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerint64_t Record::getValueAsInt(StringRef FieldName) const { 187758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner const RecordVal *R = getValue(FieldName); 1878dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 187961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 188036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 188158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 18826cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(R->getValue())) 188358c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner return II->getValue(); 188461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 188536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have an int initializer!"); 188658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner} 18875c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1888af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// getValueAsListOfInts - This method looks up the specified field and returns 188961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// its value as a vector of integers, aborting if the field does not exist or 189061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// if the value is not the right type. 1891af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov/// 189221870411d9c1807526b613d04c2ebae5a43c263bBob Wilsonstd::vector<int64_t> 1893c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord::getValueAsListOfInts(StringRef FieldName) const { 189405bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 189563f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman std::vector<int64_t> Ints; 1896af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov for (unsigned i = 0; i < List->getSize(); i++) { 18976cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) { 1898af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov Ints.push_back(II->getValue()); 1899af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } else { 190061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 190136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a list of ints initializer!"); 1902af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1903af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov } 1904af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov return Ints; 1905af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov} 1906af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov 1907bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// getValueAsListOfStrings - This method looks up the specified field and 190861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// returns its value as a vector of strings, aborting if the field does not 190961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// exist or if the value is not the right type. 1910bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson/// 1911bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstd::vector<std::string> 1912bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonRecord::getValueAsListOfStrings(StringRef FieldName) const { 191305bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *List = getValueAsListInit(FieldName); 1914bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> Strings; 1915bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson for (unsigned i = 0; i < List->getSize(); i++) { 19166cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) { 1917bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Strings.push_back(II->getValue()); 1918bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else { 191961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 192036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a list of strings initializer!"); 1921bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1922bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1923bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return Strings; 1924bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson} 1925bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1926dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// getValueAsDef - This method looks up the specified field and returns its 192761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a Record, aborting if the field does not exist or if the value 192861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// is not the right type. 1929dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner/// 1930c19418f31fa8ab09ff43c57150e5042dbe368f49Chris LattnerRecord *Record::getValueAsDef(StringRef FieldName) const { 1931dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner const RecordVal *R = getValue(FieldName); 1932dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 193361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 193436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 1935dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19366cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(R->getValue())) 1937dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner return DI->getDef(); 193861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 193936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a def initializer!"); 1940dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner} 1941dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 19420969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// getValueAsBit - This method looks up the specified field and returns its 194361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as a bit, aborting if the field does not exist or if the value is 194461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 19450969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner/// 1946c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattnerbool Record::getValueAsBit(StringRef FieldName) const { 19470969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner const RecordVal *R = getValue(FieldName); 1948dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 194961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 195036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 19510969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 19526cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1953784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return BI->getValue(); 195461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 195536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a bit initializer!"); 1956784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner} 1957784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1958c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesenbool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const { 1959c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen const RecordVal *R = getValue(FieldName); 1960dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 196161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 196261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' does not have a field named `" + FieldName.str() + "'!\n"); 1963c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1964c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen if (R->getValue() == UnsetInit::get()) { 1965c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = true; 1966c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return false; 1967c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen } 1968c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen Unset = false; 19696cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitInit *BI = dyn_cast<BitInit>(R->getValue())) 1970c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen return BI->getValue(); 197161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 197236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a bit initializer!"); 1973c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen} 1974c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 1975784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// getValueAsDag - This method looks up the specified field and returns its 197661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// value as an Dag, aborting if the field does not exist or if the value is 197761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// not the right type. 1978784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner/// 197905bce0beee87512e52428d4b80f5a8e79a949576David GreeneDagInit *Record::getValueAsDag(StringRef FieldName) const { 1980784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner const RecordVal *R = getValue(FieldName); 1981dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!R || !R->getValue()) 198261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + 198336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have a field named `" + FieldName + "'!\n"); 1984784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 19856cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DagInit *DI = dyn_cast<DagInit>(R->getValue())) 1986784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner return DI; 198761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(getLoc(), "Record `" + getName() + "', field `" + 198836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines FieldName + "' does not have a dag initializer!"); 19890969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner} 19900969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1991dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 1992d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greenevoid MultiClass::dump() const { 19931a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Record:\n"; 1994d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene Rec.dump(); 199521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 19961a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Defs:\n"; 1997d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene for (RecordVector::const_iterator r = DefPrototypes.begin(), 1998d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene rend = DefPrototypes.end(); 1999d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene r != rend; 2000d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene ++r) { 2001d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene (*r)->dump(); 2002d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene } 2003d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene} 2004d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 2005d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 20061a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid RecordKeeper::dump() const { errs() << *this; } 2007e62c1185bee05facc25d1d725434f517261d308bChris Lattner 20081a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) { 2009e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Classes -----------------\n"; 201037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const auto &Classes = RK.getClasses(); 201137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines for (const auto &C : Classes) 201237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines OS << "class " << *C.second; 20133da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 2014e62c1185bee05facc25d1d725434f517261d308bChris Lattner OS << "------------- Defs -----------------\n"; 201537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const auto &Defs = RK.getDefs(); 201637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines for (const auto &D : Defs) 201737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines OS << "def " << *D.second; 2018e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 2019e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 2020ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2021ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 2022ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// getAllDerivedDefinitions - This method returns all concrete definitions 2023ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// that derive from the specified class name. If a class with the specified 2024ab47ae3381aa2372009a9054260461c20324b555Chris Lattner/// name does not exist, an error is printed and true is returned. 20255c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattnerstd::vector<Record*> 20265c737ad4d669b835b8fb973a5c477a4dbb213830Chris LattnerRecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const { 20279d6250f52ba4ba0a34d44aa2cc9d3fa14c15a006Chris Lattner Record *Class = getClass(ClassName); 20285c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner if (!Class) 202961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n"); 2030ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20315c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> Defs; 203237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines for (const auto &D : getDefs()) 203337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (D.second->isSubClassOf(Class)) 203437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Defs.push_back(D.second.get()); 2035ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 20365c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner return Defs; 2037ab47ae3381aa2372009a9054260461c20324b555Chris Lattner} 2038d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 203930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 204030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 204130c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 204230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Init *Name, const std::string &Scoper) { 20430c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar RecTy *Type = cast<TypedInit>(Name)->getType(); 204430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 204530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit *NewName = 204630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 204730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 204830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurRec.getNameInit(), 204930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get(Scoper), 205030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 205130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Name, 205230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 205330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 205430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene if (CurMultiClass && Scoper != "::") { 205530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName = 205630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 205730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene BinOpInit::get(BinOpInit::STRCONCAT, 205830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene CurMultiClass->Rec.getNameInit(), 205930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene StringInit::get("::"), 206030c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type)->Fold(&CurRec, CurMultiClass), 206130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene NewName->Fold(&CurRec, CurMultiClass), 206230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Type); 206330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene } 206430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 206530c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return NewName->Fold(&CurRec, CurMultiClass); 206630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 206730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 206830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 206930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 207030c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, 207130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Name, 207230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Scoper) { 207330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper); 207430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene} 2075