Record.h revision b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169
17c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne//===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===// 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// 1014d7c59491347a2f8f29e120fd75a4cad42f68e7Chris Lattner// This file defines the main TableGen data structures, including the TableGen 1114d7c59491347a2f8f29e120fd75a4cad42f68e7Chris Lattner// types, values, and high-level data structures. 12e62c1185bee05facc25d1d725434f517261d308bChris Lattner// 13e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 14e62c1185bee05facc25d1d725434f517261d308bChris Lattner 157c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#ifndef LLVM_TABLEGEN_RECORD_H 167c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#define LLVM_TABLEGEN_RECORD_H 17e62c1185bee05facc25d1d725434f517261d308bChris Lattner 18c45a2cacd09f88b8b715fd89f5bf6c2347b2cce9David Greene#include "llvm/ADT/ArrayRef.h" 19726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene#include "llvm/ADT/FoldingSet.h" 20dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene#include "llvm/Support/Allocator.h" 2189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva#include "llvm/Support/Casting.h" 22099e198ae84c1a6cfe2a7c79ee9f47fa67caac8fChris Lattner#include "llvm/Support/SourceMgr.h" 233cc52ea33c0b96d1682f14fc45c45b57df0f39b6Michael J. Spencer#include "llvm/Support/DataTypes.h" 2450bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper#include "llvm/Support/ErrorHandling.h" 251a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include "llvm/Support/raw_ostream.h" 26e62c1185bee05facc25d1d725434f517261d308bChris Lattner#include <map> 27028936ada14335bb04f377d46a6261dc4c66dafdJohn Criswell 28d0fde30ce850b78371fd1386338350591f9ff494Brian Gaekenamespace llvm { 291a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarclass raw_ostream; 3021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 317dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner// RecTy subclasses. 327cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass BitRecTy; 337cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass BitsRecTy; 347cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass IntRecTy; 357cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass StringRecTy; 367cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass ListRecTy; 3740f71134b9fef0ca06c516f033cc9403394a913cChris Lattnerclass DagRecTy; 387cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerclass RecordRecTy; 397cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 407dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner// Init subclasses. 41afd54269ab9951c0dcdea076c4d6f48a345e9d27David Greeneclass Init; 42e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass UnsetInit; 43e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass BitInit; 44e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass BitsInit; 45e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass IntInit; 46e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass StringInit; 47e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass ListInit; 48e6c27de069225e1122c78385ad22a2ff656db8e6David Greeneclass UnOpInit; 49711e5d96aa648ebe96b09483d0775f3b16283e3dChris Lattnerclass BinOpInit; 504afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greeneclass TernOpInit; 51e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass DefInit; 528e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattnerclass DagInit; 53b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattnerclass TypedInit; 54b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattnerclass VarInit; 55a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattnerclass FieldInit; 56b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattnerclass VarBitInit; 571dba7abdd77e19c230f0426825a5ae4879471dccChris Lattnerclass VarListElementInit; 587cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 597dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner// Other classes. 60e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass Record; 617dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattnerclass RecordVal; 62293b13350c2fbae8a64b0b0beb440cb859968c8cBob Wilsonstruct MultiClass; 6367db883487fca3472fdde51e931657e22d4d0495Chris Lattnerclass RecordKeeper; 64e62c1185bee05facc25d1d725434f517261d308bChris Lattner 65e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 66e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Type Classes 67e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 68e62c1185bee05facc25d1d725434f517261d308bChris Lattner 6977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesenclass RecTy { 7089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silvapublic: 7189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva /// \brief Subclass discriminator (for dyn_cast<> et al.) 7289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva enum RecTyKind { 7389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva BitRecTyKind, 7489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva BitsRecTyKind, 7589adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva IntRecTyKind, 7689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva StringRecTyKind, 7789adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva ListRecTyKind, 7889adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva DagRecTyKind, 7989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva RecordRecTyKind 8089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva }; 8189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 8289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silvaprivate: 8389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva RecTyKind Kind; 8477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen ListRecTy *ListTy; 852d24e2a396a1d211baaeedf32148a3b657240170David Blaikie virtual void anchor(); 8689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 8777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesenpublic: 8889adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *) { return true; } 8989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva RecTyKind getRecTyKind() const { return Kind; } 9089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 9189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva RecTy(RecTyKind K) : Kind(K), ListTy(0) {} 92e62c1185bee05facc25d1d725434f517261d308bChris Lattner virtual ~RecTy() {} 93e62c1185bee05facc25d1d725434f517261d308bChris Lattner 9499ba1f7b8deaf2a296c98600dbf593754cbd43a2Chris Lattner virtual std::string getAsString() const = 0; 951a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar void print(raw_ostream &OS) const { OS << getAsString(); } 967cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner void dump() const; 977cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 987cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner /// typeIsConvertibleTo - Return true if all values of 'this' type can be 997cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner /// converted to the specified type. 1007cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0; 1017cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 10277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen /// getListTy - Returns the type representing list<this>. 10377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen ListRecTy *getListTy(); 10477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1057cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerpublic: // These methods should only be called from subclasses of Init 10605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return 0; } 10705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return 0; } 10805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI) { return 0; } 10905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return 0; } 11005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 11105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 11205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { 11305bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)UI); 114e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 11505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { 11605bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)UI); 117e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene } 11805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { 11905bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)UI); 1204afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 12105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 12205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 12305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 12405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI) { return 0; } 12505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { 12605bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)VI); 127b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner } 12805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { 12905bce0beee87512e52428d4b80f5a8e79a949576David Greene return convertValue((TypedInit*)FI); 130b45b3b3cd14faaf5a3ea5226af7e1e3cd653e6cbChris Lattner } 131e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1327cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattnerpublic: // These methods should only be called by subclasses of RecTy. 1337cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // baseClassOf - These virtual methods should be overloaded to return true iff 1347cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner // all values of type 'RHS' can be converted to the 'this' type. 1357cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } 1367cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } 1377cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } 1387cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 1397cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 14040f71134b9fef0ca06c516f033cc9403394a913cChris Lattner virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 1417cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 142e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 143e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1441a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarinline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { 145e62c1185bee05facc25d1d725434f517261d308bChris Lattner Ty.print(OS); 146e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 147e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 148e62c1185bee05facc25d1d725434f517261d308bChris Lattner 14907278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 15007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// BitRecTy - 'bit' - Represent a single bit 15107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 1521fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerclass BitRecTy : public RecTy { 15377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static BitRecTy Shared; 15489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva BitRecTy() : RecTy(BitRecTyKind) {} 1551fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerpublic: 15689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const BitRecTy *) { return true; } 15789adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 15889adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == BitRecTyKind; 15989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 16089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 16177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static BitRecTy *get() { return &Shared; } 16277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 16305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 16405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return (Init*)BI; } 16505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI); 16605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II); 16705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 16805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 16905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; } 17005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 17105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 17205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} 17305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} 17405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 17505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 17605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 17705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 178e62c1185bee05facc25d1d725434f517261d308bChris Lattner 179ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const { return "bit"; } 1807cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 181ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 1827cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 1837cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 184ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return true; } 185ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const; 186ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } 187ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 188ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 189ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 190ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 191ead87b671278379f92890fddd859a301bb68f462Reid Spencer 192e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 193e62c1185bee05facc25d1d725434f517261d308bChris Lattner 19407278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 195234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman// BitsRecTy - 'bits<n>' - Represent a fixed number of bits 196234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman/// BitsRecTy - 'bits<n>' - Represent a fixed number of bits 19707278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 198e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass BitsRecTy : public RecTy { 199e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned Size; 20089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {} 20177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesenpublic: 20289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const BitsRecTy *) { return true; } 20389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 20489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == BitsRecTyKind; 20589adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 20689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 20777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static BitsRecTy *get(unsigned Sz); 208e62c1185bee05facc25d1d725434f517261d308bChris Lattner 209e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned getNumBits() const { return Size; } 210e62c1185bee05facc25d1d725434f517261d308bChris Lattner 21105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI); 21205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *UI); 21305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI); 21405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II); 21505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 21605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 21705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 21805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 21905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 22005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} 22105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} 22205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 22305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 22405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 22505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 226ead87b671278379f92890fddd859a301bb68f462Reid Spencer 227ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const; 2287cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 229ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 2307cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 2317cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 232ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; } 233ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { 2347cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->Size == Size; 2357cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 236ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } 237ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 238ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 239ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 240ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 241ead87b671278379f92890fddd859a301bb68f462Reid Spencer 242e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 243e62c1185bee05facc25d1d725434f517261d308bChris Lattner 24407278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 24507278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// IntRecTy - 'int' - Represent an integer value of no particular size 24607278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 2471fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerclass IntRecTy : public RecTy { 24877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static IntRecTy Shared; 24989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva IntRecTy() : RecTy(IntRecTyKind) {} 2501fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerpublic: 25189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const IntRecTy *) { return true; } 25289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 25389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == IntRecTyKind; 25489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 25589adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 25677f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static IntRecTy *get() { return &Shared; } 25777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 25805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 25905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI); 26005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI); 26105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return (Init*)II; } 26205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 26305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 26405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 26505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 26605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 26705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} 26805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} 26905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 27005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 27105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 27205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 273ead87b671278379f92890fddd859a301bb68f462Reid Spencer 274ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const { return "int"; } 2757cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 276ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 2777cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 2787cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 2797cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 280ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return true; } 281ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { return true; } 282ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } 283ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 284ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 285ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 286ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 287ead87b671278379f92890fddd859a301bb68f462Reid Spencer 288e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 289e62c1185bee05facc25d1d725434f517261d308bChris Lattner 29007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// StringRecTy - 'string' - Represent an string value 29107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 2921fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerclass StringRecTy : public RecTy { 29377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static StringRecTy Shared; 29489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva StringRecTy() : RecTy(StringRecTyKind) {} 2951fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerpublic: 29689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const StringRecTy *) { return true; } 29789adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 29889adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == StringRecTyKind; 29989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 30089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 30177f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static StringRecTy *get() { return &Shared; } 30277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 30305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 30405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return 0; } 30505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI) { return 0; } 30605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return 0; } 30705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return (Init*)SI; } 30805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 30905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *BO); 31005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *BO); 31105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);} 31205bce0beee87512e52428d4b80f5a8e79a949576David Greene 31305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 31405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 31505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 31605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 31705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 31805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 319ead87b671278379f92890fddd859a301bb68f462Reid Spencer 320ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const { return "string"; } 3217cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 322ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 3237cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 3247cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 3257cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 326ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } 327ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } 328ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } 3297cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const StringRecTy *RHS) const { return true; } 330ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 331ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 332ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 333e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 334e62c1185bee05facc25d1d725434f517261d308bChris Lattner 335234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of 336234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman// the specified type. 337234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman/// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must 338234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman/// be of the specified type. 33907278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 340e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass ListRecTy : public RecTy { 3417cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner RecTy *Ty; 34289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {} 34377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen friend ListRecTy *RecTy::getListTy(); 34477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesenpublic: 34589adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const ListRecTy *) { return true; } 34689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 34789adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == ListRecTyKind; 34889adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 34989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 35077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static ListRecTy *get(RecTy *T) { return T->getListTy(); } 3517cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner RecTy *getElementType() const { return Ty; } 352f1b36f9a71eb267f04b7bd3a32aca9bc69f71e97Chris Lattner 35305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 35405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return 0; } 35505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI) { return 0; } 35605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return 0; } 35705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 35805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI); 35905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 36005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 36105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 36205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} 36305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} 36405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 36505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 36605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 36705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 3683da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 369ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const; 3707cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 371ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 3727cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 3737cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 3747cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 375ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } 376ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } 377ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } 378ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 379ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { 3803da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman return RHS->getElementType()->typeIsConvertibleTo(Ty); 3817cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 382ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 383ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 384f05760de76b4ec26474da18c97770ca369972cfdChris Lattner}; 385f05760de76b4ec26474da18c97770ca369972cfdChris Lattner 38640f71134b9fef0ca06c516f033cc9403394a913cChris Lattner/// DagRecTy - 'dag' - Represent a dag fragment 38740f71134b9fef0ca06c516f033cc9403394a913cChris Lattner/// 3881fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerclass DagRecTy : public RecTy { 38977f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static DagRecTy Shared; 39089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva DagRecTy() : RecTy(DagRecTyKind) {} 3911fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerpublic: 39289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const DagRecTy *) { return true; } 39389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 39489adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == DagRecTyKind; 39589adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 39689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 39777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static DagRecTy *get() { return &Shared; } 39877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 39905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 40005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return 0; } 40105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI) { return 0; } 40205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return 0; } 40305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 40405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 40505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 40605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI) { return 0; } 40705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *BO); 40805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *BO); 40905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);} 41005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *CI) { return (Init*)CI; } 41105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *TI); 41205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 41305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 41440f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 415ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const { return "dag"; } 41640f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 417ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 41840f71134b9fef0ca06c516f033cc9403394a913cChris Lattner return RHS->baseClassOf(this); 41940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner } 420ead87b671278379f92890fddd859a301bb68f462Reid Spencer 421ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } 422ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } 423ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } 424ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 425ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 426ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return true; } 427ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 42840f71134b9fef0ca06c516f033cc9403394a913cChris Lattner}; 42940f71134b9fef0ca06c516f033cc9403394a913cChris Lattner 430f05760de76b4ec26474da18c97770ca369972cfdChris Lattner 431234b3ec8795e0661af56aa1d1a978a41d80686c5Misha Brukman/// RecordRecTy - '[classname]' - Represent an instance of a class, such as: 43207278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// (R32 X = EAX). 43307278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 434e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass RecordRecTy : public RecTy { 435e62c1185bee05facc25d1d725434f517261d308bChris Lattner Record *Rec; 43689adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva explicit RecordRecTy(Record *R) : RecTy(RecordRecTyKind), Rec(R) {} 43777f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen friend class Record; 43877f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesenpublic: 43989adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecordRecTy *) { return true; } 44089adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva static bool classof(const RecTy *RT) { 44189adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva return RT->getRecTyKind() == RecordRecTyKind; 44289adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva } 44389adeb225db4cd4d5c671d2ac5e2e6a6e755b5bcSean Silva 44477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen static RecordRecTy *get(Record *R); 445e62c1185bee05facc25d1d725434f517261d308bChris Lattner 446a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner Record *getRecord() const { return Rec; } 447a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner 44805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 44905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitInit *BI) { return 0; } 45005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BitsInit *BI) { return 0; } 45105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( IntInit *II) { return 0; } 45205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(StringInit *SI) { return 0; } 45305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( ListInit *LI) { return 0; } 45405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue(VarBitInit *VB) { return 0; } 45505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} 45605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} 45705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 45805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DefInit *DI); 45905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( DagInit *DI) { return 0; } 46005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( TypedInit *VI); 46105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} 46205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 463e62c1185bee05facc25d1d725434f517261d308bChris Lattner 464ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual std::string getAsString() const; 4657cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner 466ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual bool typeIsConvertibleTo(const RecTy *RHS) const { 4677cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return RHS->baseClassOf(this); 4687cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner } 469ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } 470ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } 471ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } 472ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } 473ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } 474ead87b671278379f92890fddd859a301bb68f462Reid Spencer virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 4757cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner virtual bool baseClassOf(const RecordRecTy *RHS) const; 476e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 477e62c1185bee05facc25d1d725434f517261d308bChris Lattner 47821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// resolveTypes - Find a common type that T1 and T2 convert to. 479e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// Return 0 if no such type exists. 480e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene/// 481e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid GreeneRecTy *resolveTypes(RecTy *T1, RecTy *T2); 48207278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 483e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 484e62c1185bee05facc25d1d725434f517261d308bChris Lattner// Initializer Classes 485e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 486e62c1185bee05facc25d1d725434f517261d308bChris Lattner 487afd54269ab9951c0dcdea076c4d6f48a345e9d27David Greeneclass Init { 488b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silvaprotected: 489b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// \brief Discriminator enum (for isa<>, dyn_cast<>, et al.) 490b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// 491b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// This enum is laid out by a preorder traversal of the inheritance 492b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// hierarchy, and does not contain an entry for abstract classes, as per 493b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// the recommendation in docs/HowToSetUpLLVMStyleRTTI.rst. 494b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// 495b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// We also explicitly include "first" and "last" values for each 496b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// interior node of the inheritance tree, to make it easier to read the 497b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// corresponding classof(). 498b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// 499b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// We could pack these a bit tighter by not having the IK_FirstXXXInit 500b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// and IK_LastXXXInit be their own values, but that would degrade 501b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva /// readability for really no benefit. 502b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva enum InitKind { 503b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_BitInit, 504b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_BitsInit, 505b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_FirstTypedInit, 506b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_DagInit, 507b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_DefInit, 508b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_FieldInit, 509b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_IntInit, 510b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_ListInit, 511b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_FirstOpInit, 512b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_BinOpInit, 513b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_TernOpInit, 514b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_UnOpInit, 515b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_LastOpInit, 516b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_StringInit, 517b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_VarInit, 518b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_VarListElementInit, 519b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_LastTypedInit, 520b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_UnsetInit, 521b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva IK_VarBitInit 522b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva }; 523b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva 524b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silvaprivate: 525b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva const InitKind Kind; 526a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper Init(const Init &) LLVM_DELETED_FUNCTION; 527a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper Init &operator=(const Init &) LLVM_DELETED_FUNCTION; 5282d24e2a396a1d211baaeedf32148a3b657240170David Blaikie virtual void anchor(); 529dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 530b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silvapublic: 531b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva InitKind getKind() const { return Kind; } 532b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva 533dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greeneprotected: 534b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva explicit Init(InitKind K) : Kind(K) {} 535dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 536afd54269ab9951c0dcdea076c4d6f48a345e9d27David Greenepublic: 537e62c1185bee05facc25d1d725434f517261d308bChris Lattner virtual ~Init() {} 538e62c1185bee05facc25d1d725434f517261d308bChris Lattner 539f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// isComplete - This virtual method should be overridden by values that may 540f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// not be completely specified yet. 541f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner virtual bool isComplete() const { return true; } 542f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner 543f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// print - Print out this value. 5441a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar void print(raw_ostream &OS) const { OS << getAsString(); } 5453aba4d39fd101238ac06871895c28f26736d80cbChris Lattner 5463aba4d39fd101238ac06871895c28f26736d80cbChris Lattner /// getAsString - Convert this value to a string form. 5473aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const = 0; 5480b18d59435a7c01a433ac69845e6d8e1ad66ce8bDavid Greene /// getAsUnquotedString - Convert this value to a string form, 5490b18d59435a7c01a433ac69845e6d8e1ad66ce8bDavid Greene /// without adding quote markers. This primaruly affects 5500b18d59435a7c01a433ac69845e6d8e1ad66ce8bDavid Greene /// StringInits where we will not surround the string value with 5510b18d59435a7c01a433ac69845e6d8e1ad66ce8bDavid Greene /// quotes. 5524b18691c3580674691875ec37c84a1c4edf2d586Jim Grosbach virtual std::string getAsUnquotedString() const { return getAsString(); } 553f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner 554f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// dump - Debugging method that may be called through a debugger, just 5551a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar /// invokes print on stderr. 556e62c1185bee05facc25d1d725434f517261d308bChris Lattner void dump() const; 557e62c1185bee05facc25d1d725434f517261d308bChris Lattner 558f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// convertInitializerTo - This virtual function is a simple call-back 559f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// function that should be overridden to call the appropriate 560f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// RecTy::convertValue method. 561f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// 56205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const = 0; 563f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner 564f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// convertInitializerBitRange - This method is used to implement the bitrange 565f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// selection operator. Given an initializer, it selects the specified bits 5667331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner /// out, returning them as a new init of bits type. If it is not legal to use 5677331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner /// the bit subscript operator on this initializer, return null. 568f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// 56905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 570f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 571e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 572e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 573e62c1185bee05facc25d1d725434f517261d308bChris Lattner 574b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner /// convertInitListSlice - This method is used to implement the list slice 575b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner /// selection operator. Given an initializer, it selects the specified list 576b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner /// elements, returning them as a new init of list type. If it is not legal 577b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner /// to take a slice of this, return null. 578b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner /// 57905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 580f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitListSlice(const std::vector<unsigned> &Elements) const { 581b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner return 0; 582b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner } 583b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 584a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner /// getFieldType - This method is used to implement the FieldInit class. 585a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner /// Implementors of this method should return the type of the named field if 586a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner /// they are of record type. 587a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner /// 588a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; } 589a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner 590b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner /// getFieldInit - This method complements getFieldType to return the 591b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner /// initializer for the specified field. If getFieldType returns non-null 592b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner /// this method should return non-null, otherwise it returns null. 593b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner /// 59405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *getFieldInit(Record &R, const RecordVal *RV, 59505bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const { 596b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner return 0; 597b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner } 5983da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 599f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// resolveReferences - This method is used by classes that refer to other 600a8449e6aaa6f494d85e75d4755f9c47abf1e06ceBob Wilson /// variables which may not be defined at the time the expression is formed. 601f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// If a value is set for the variable later, this method will be called on 602f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// users of the value to allow the value to propagate out. 603f1e37d9d037bb5f7beb688822beddd2340cd871eChris Lattner /// 60405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const { 60505bce0beee87512e52428d4b80f5a8e79a949576David Greene return const_cast<Init *>(this); 6067dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner } 607307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 608307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// getBit - This method is used to return the initializer for the specified 609307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// bit. 610307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const = 0; 611307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 612307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// getBitVar - This method is used to retrieve the initializer for bit 613307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// reference. For non-VarBitInit, it simply returns itself. 614307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBitVar() const { return const_cast<Init*>(this); } 615307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 616307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// getBitNum - This method is used to retrieve the bit number of a bit 617307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao /// reference. For non-VarBitInit, it simply returns 0. 618307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual unsigned getBitNum() const { return 0; } 619e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 620e62c1185bee05facc25d1d725434f517261d308bChris Lattner 6211a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarinline raw_ostream &operator<<(raw_ostream &OS, const Init &I) { 622e62c1185bee05facc25d1d725434f517261d308bChris Lattner I.print(OS); return OS; 623e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 624e62c1185bee05facc25d1d725434f517261d308bChris Lattner 625beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene/// TypedInit - This is the common super-class of types that have a specific, 626beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene/// explicit, type. 627beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene/// 628beb31a51f67f651c5fa3c5094a78266d04a697a5David Greeneclass TypedInit : public Init { 629beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene RecTy *Ty; 630dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 631a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper TypedInit(const TypedInit &Other) LLVM_DELETED_FUNCTION; 632a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper TypedInit &operator=(const TypedInit &Other) LLVM_DELETED_FUNCTION; 633dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 634dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greeneprotected: 635b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva explicit TypedInit(InitKind K, RecTy *T) : Init(K), Ty(T) {} 636d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 637dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 638b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 639b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() >= IK_FirstTypedInit && 640b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva I->getKind() <= IK_LastTypedInit; 641b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 642beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene RecTy *getType() const { return Ty; } 643beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 64405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 645f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 64605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 647f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitListSlice(const std::vector<unsigned> &Elements) const; 648beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 6499703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene /// getFieldType - This method is used to implement the FieldInit class. 6509703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene /// Implementors of this method should return the type of the named field if 6519703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene /// they are of record type. 6529703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene /// 6539703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene virtual RecTy *getFieldType(const std::string &FieldName) const; 6549703843dfa5640ddfc4362d7aa20b03fba485eceDavid Greene 655beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// resolveListElementReference - This method is used to implement 656beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// VarListElementInit::resolveReferences. If the list element is resolvable 657beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// now, we return the resolved value, otherwise we return null. 65805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 65905bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const = 0; 660beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene}; 661beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 66207278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 66307278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// UnsetInit - ? - Represents an uninitialized value 66407278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 6651fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerclass UnsetInit : public Init { 666b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva UnsetInit() : Init(IK_UnsetInit) {} 667a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper UnsetInit(const UnsetInit &) LLVM_DELETED_FUNCTION; 668a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper UnsetInit &operator=(const UnsetInit &Other) LLVM_DELETED_FUNCTION; 6692d24e2a396a1d211baaeedf32148a3b657240170David Blaikie virtual void anchor(); 670dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 6711fca5ff62bb2ecb5bfc8974f4dbfc56e9d3ca721Chris Lattnerpublic: 672b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 673b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_UnsetInit; 674b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 67505bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnsetInit *get(); 676dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 67705bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 67805bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<UnsetInit *>(this)); 679e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 680e62c1185bee05facc25d1d725434f517261d308bChris Lattner 681307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 682307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<UnsetInit*>(this); 683307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 684307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 685e62c1185bee05facc25d1d725434f517261d308bChris Lattner virtual bool isComplete() const { return false; } 6863aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const { return "?"; } 687e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 688e62c1185bee05facc25d1d725434f517261d308bChris Lattner 68907278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 69007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// BitInit - true/false - Represent a concrete initializer for a bit. 69107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 692e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass BitInit : public Init { 693e62c1185bee05facc25d1d725434f517261d308bChris Lattner bool Value; 694dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 695b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva explicit BitInit(bool V) : Init(IK_BitInit), Value(V) {} 696a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BitInit(const BitInit &Other) LLVM_DELETED_FUNCTION; 697a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BitInit &operator=(BitInit &Other) LLVM_DELETED_FUNCTION; 6982d24e2a396a1d211baaeedf32148a3b657240170David Blaikie virtual void anchor(); 699dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 700dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 701b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 702b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_BitInit; 703b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 70405bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitInit *get(bool V); 705e62c1185bee05facc25d1d725434f517261d308bChris Lattner 706e62c1185bee05facc25d1d725434f517261d308bChris Lattner bool getValue() const { return Value; } 707e62c1185bee05facc25d1d725434f517261d308bChris Lattner 70805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 70905bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<BitInit *>(this)); 710e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 711e62c1185bee05facc25d1d725434f517261d308bChris Lattner 712307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 713307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao assert(Bit < 1 && "Bit index out of range!"); 714307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<BitInit*>(this); 715307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 716307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 7173aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const { return Value ? "1" : "0"; } 718e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 719e62c1185bee05facc25d1d725434f517261d308bChris Lattner 72007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value. 72107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// It contains a vector of bits, whose size is determined by the type. 72207278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 723726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greeneclass BitsInit : public Init, public FoldingSetNode { 72405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Bits; 725dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 726b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva BitsInit(ArrayRef<Init *> Range) 727b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : Init(IK_BitsInit), Bits(Range.begin(), Range.end()) {} 728e62c1185bee05facc25d1d725434f517261d308bChris Lattner 729a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BitsInit(const BitsInit &Other) LLVM_DELETED_FUNCTION; 730a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BitsInit &operator=(const BitsInit &Other) LLVM_DELETED_FUNCTION; 731dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 732dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 733b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 734b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_BitsInit; 735b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 73605bce0beee87512e52428d4b80f5a8e79a949576David Greene static BitsInit *get(ArrayRef<Init *> Range); 737dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 738726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene void Profile(FoldingSetNodeID &ID) const; 739726bbde3c4ac5a279c86d1632b7b94498b01854aDavid Greene 740e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned getNumBits() const { return Bits.size(); } 741e62c1185bee05facc25d1d725434f517261d308bChris Lattner 74205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 74305bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<BitsInit *>(this)); 744e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 74505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 746f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 747e62c1185bee05facc25d1d725434f517261d308bChris Lattner 748e62c1185bee05facc25d1d725434f517261d308bChris Lattner virtual bool isComplete() const { 749e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0; i != getNumBits(); ++i) 750e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (!getBit(i)->isComplete()) return false; 751e62c1185bee05facc25d1d725434f517261d308bChris Lattner return true; 752e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 7531808e4d251005b122b1d3f7a08a01a55c328da1cJohnny Chen bool allInComplete() const { 7541808e4d251005b122b1d3f7a08a01a55c328da1cJohnny Chen for (unsigned i = 0; i != getNumBits(); ++i) 7551808e4d251005b122b1d3f7a08a01a55c328da1cJohnny Chen if (getBit(i)->isComplete()) return false; 7561808e4d251005b122b1d3f7a08a01a55c328da1cJohnny Chen return true; 7571808e4d251005b122b1d3f7a08a01a55c328da1cJohnny Chen } 7583aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 759e62c1185bee05facc25d1d725434f517261d308bChris Lattner 76005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 761307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 762307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 763307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao assert(Bit < Bits.size() && "Bit index out of range!"); 764307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return Bits[Bit]; 765307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 766e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 767e62c1185bee05facc25d1d725434f517261d308bChris Lattner 76807278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 76907278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// IntInit - 7 - Represent an initalization by a literal integer value. 77007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 771e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greeneclass IntInit : public TypedInit { 77263f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t Value; 773dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 774b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva explicit IntInit(int64_t V) 775b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {} 776e62c1185bee05facc25d1d725434f517261d308bChris Lattner 777a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper IntInit(const IntInit &Other) LLVM_DELETED_FUNCTION; 778a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper IntInit &operator=(const IntInit &Other) LLVM_DELETED_FUNCTION; 779dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 780dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 781b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 782b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_IntInit; 783b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 78405bce0beee87512e52428d4b80f5a8e79a949576David Greene static IntInit *get(int64_t V); 785dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 78663f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman int64_t getValue() const { return Value; } 787e62c1185bee05facc25d1d725434f517261d308bChris Lattner 78805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 78905bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<IntInit *>(this)); 790e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 79105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init * 792f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 793e62c1185bee05facc25d1d725434f517261d308bChris Lattner 7943aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 795e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 796e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// resolveListElementReference - This method is used to implement 797e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// VarListElementInit::resolveReferences. If the list element is resolvable 798e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// now, we return the resolved value, otherwise we return null. 79905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 80005bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 80150bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal element reference off int"); 802e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene } 803307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 804307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 805236bcf1fcd6164d624956c0858593c1a780b9a0bAaron Ballman return BitInit::get((Value & (1ULL << Bit)) != 0); 806307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 807e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 808e62c1185bee05facc25d1d725434f517261d308bChris Lattner 80907278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 81007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// StringInit - "foo" - Represent an initialization by a string value. 81107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 812beb31a51f67f651c5fa3c5094a78266d04a697a5David Greeneclass StringInit : public TypedInit { 813e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::string Value; 814dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 815d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher explicit StringInit(const std::string &V) 816b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {} 817e62c1185bee05facc25d1d725434f517261d308bChris Lattner 818a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper StringInit(const StringInit &Other) LLVM_DELETED_FUNCTION; 819a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper StringInit &operator=(const StringInit &Other) LLVM_DELETED_FUNCTION; 8202d24e2a396a1d211baaeedf32148a3b657240170David Blaikie virtual void anchor(); 821dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 822dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 823b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 824b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_StringInit; 825b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 826ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen static StringInit *get(StringRef); 827dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 8285c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner const std::string &getValue() const { return Value; } 8295c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 83005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 83105bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<StringInit *>(this)); 832e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 833e62c1185bee05facc25d1d725434f517261d308bChris Lattner 8343aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const { return "\"" + Value + "\""; } 8350b18d59435a7c01a433ac69845e6d8e1ad66ce8bDavid Greene virtual std::string getAsUnquotedString() const { return Value; } 836beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 837beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// resolveListElementReference - This method is used to implement 838beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// VarListElementInit::resolveReferences. If the list element is resolvable 839beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// now, we return the resolved value, otherwise we return null. 84005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 84105bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 84250bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal element reference off string"); 843beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 844307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 845307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 846307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao llvm_unreachable("Illegal bit reference off string"); 847307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 848e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 849e62c1185bee05facc25d1d725434f517261d308bChris Lattner 85007278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// ListInit - [AL, AH, CL] - Represent a list of defs 85107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 852aad4c9fc37b38cae21343173084c81d789535446David Greeneclass ListInit : public TypedInit, public FoldingSetNode { 85305bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Values; 854e62c1185bee05facc25d1d725434f517261d308bChris Lattnerpublic: 85505bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::vector<Init*>::const_iterator const_iterator; 8565f9f9ba00b85eb19da2618f393e43a6a11b5d892David Greene 857aad4c9fc37b38cae21343173084c81d789535446David Greeneprivate: 85805bce0beee87512e52428d4b80f5a8e79a949576David Greene explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy) 859b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), 860b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva Values(Range.begin(), Range.end()) {} 861e62c1185bee05facc25d1d725434f517261d308bChris Lattner 862a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper ListInit(const ListInit &Other) LLVM_DELETED_FUNCTION; 863a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper ListInit &operator=(const ListInit &Other) LLVM_DELETED_FUNCTION; 864dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 865dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 866b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 867b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_ListInit; 868b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 86905bce0beee87512e52428d4b80f5a8e79a949576David Greene static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy); 870dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 871aad4c9fc37b38cae21343173084c81d789535446David Greene void Profile(FoldingSetNodeID &ID) const; 872aad4c9fc37b38cae21343173084c81d789535446David Greene 8737cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner unsigned getSize() const { return Values.size(); } 87405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getElement(unsigned i) const { 8757cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner assert(i < Values.size() && "List element index out of range!"); 8767cf0ce4b8d122575c3348b5fa4947014c3d8432dChris Lattner return Values[i]; 877e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 878e62c1185bee05facc25d1d725434f517261d308bChris Lattner 87950d456539dea5e61d7a1592a78f1861fb35b0063Chris Lattner Record *getElementAsRecord(unsigned i) const; 88021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 881ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init * 882ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper convertInitListSlice(const std::vector<unsigned> &Elements) const; 883b0fef64dc98d32b90782360aa9480417b7ca34fdChris Lattner 88405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 88505bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<ListInit *>(this)); 886e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 887e62c1185bee05facc25d1d725434f517261d308bChris Lattner 8881dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// resolveReferences - This method is used by classes that refer to other 8891dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// variables which may not be defined at the time they expression is formed. 8901dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// If a value is set for the variable later, this method will be called on 8911dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// users of the value to allow the value to propagate out. 8921dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// 89305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 8941dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 8953aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 89682137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov 89705bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init*> getValues() const { return Values; } 898c45a2cacd09f88b8b715fd89f5bf6c2347b2cce9David Greene 89982137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov inline const_iterator begin() const { return Values.begin(); } 90082137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov inline const_iterator end () const { return Values.end(); } 90182137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov 90282137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov inline size_t size () const { return Values.size(); } 90382137bd061440070839f2b94c8b7c16da4f41a6dAnton Korobeynikov inline bool empty() const { return Values.empty(); } 904e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene 905e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// resolveListElementReference - This method is used to implement 906e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// VarListElementInit::resolveReferences. If the list element is resolvable 907e1b469170bb3ab259fd488fb95c29efe802cdd6aDavid Greene /// now, we return the resolved value, otherwise we return null. 90805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 90905bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const; 910307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 911307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 912307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao llvm_unreachable("Illegal bit reference off list"); 913307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 914e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 915e62c1185bee05facc25d1d725434f517261d308bChris Lattner 9167331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner 917d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// OpInit - Base class for operators 918d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 919d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greeneclass OpInit : public TypedInit { 920a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper OpInit(const OpInit &Other) LLVM_DELETED_FUNCTION; 921a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper OpInit &operator=(OpInit &Other) LLVM_DELETED_FUNCTION; 922d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher 923dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greeneprotected: 924b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva explicit OpInit(InitKind K, RecTy *Type) : TypedInit(K, Type) {} 925dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 926dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 927b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 928b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() >= IK_FirstOpInit && 929b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva I->getKind() <= IK_LastOpInit; 930b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 931d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene // Clone - Clone this operator, replacing arguments with the new list 93205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual OpInit *clone(std::vector<Init *> &Operands) const = 0; 933d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 934a9ad04191cb56c42944b17980b8b2bb2afe11ab2Dan Gohman virtual int getNumOperands() const = 0; 93505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *getOperand(int i) const = 0; 936d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 937d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene // Fold - If possible, fold this to a simpler init. Return this if not 938d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene // possible to fold. 93905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0; 940d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 94105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 94205bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<OpInit *>(this)); 943d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 94421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 94505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 94605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const; 947307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 948307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const; 949d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene}; 950d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 951d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 952d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// UnOpInit - !op (X) - Transform an init. 953d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 954e6c27de069225e1122c78385ad22a2ff656db8e6David Greeneclass UnOpInit : public OpInit { 955e6c27de069225e1122c78385ad22a2ff656db8e6David Greenepublic: 9561434f66b2e132a707e2c8ccb3350ea13fb5aa051David Greene enum UnaryOp { CAST, HEAD, TAIL, EMPTY }; 957e6c27de069225e1122c78385ad22a2ff656db8e6David Greeneprivate: 958e6c27de069225e1122c78385ad22a2ff656db8e6David Greene UnaryOp Opc; 95905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS; 960dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 96105bce0beee87512e52428d4b80f5a8e79a949576David Greene UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) 962b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : OpInit(IK_UnOpInit, Type), Opc(opc), LHS(lhs) {} 963dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 964a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper UnOpInit(const UnOpInit &Other) LLVM_DELETED_FUNCTION; 965a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper UnOpInit &operator=(const UnOpInit &Other) LLVM_DELETED_FUNCTION; 966dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 967e6c27de069225e1122c78385ad22a2ff656db8e6David Greenepublic: 968b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 969b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_UnOpInit; 970b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 97105bce0beee87512e52428d4b80f5a8e79a949576David Greene static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type); 972d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 973e6c27de069225e1122c78385ad22a2ff656db8e6David Greene // Clone - Clone this operator, replacing arguments with the new list 97405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual OpInit *clone(std::vector<Init *> &Operands) const { 975aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky assert(Operands.size() == 1 && 976aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky "Wrong number of operands for unary operation"); 977dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return UnOpInit::get(getOpcode(), *Operands.begin(), getType()); 978e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 979d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 980ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual int getNumOperands() const { return 1; } 981ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *getOperand(int i) const { 982e6c27de069225e1122c78385ad22a2ff656db8e6David Greene assert(i == 0 && "Invalid operand id for unary operator"); 983e6c27de069225e1122c78385ad22a2ff656db8e6David Greene return getOperand(); 984e6c27de069225e1122c78385ad22a2ff656db8e6David Greene } 98521870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 986e6c27de069225e1122c78385ad22a2ff656db8e6David Greene UnaryOp getOpcode() const { return Opc; } 98705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getOperand() const { return LHS; } 988d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 989e6c27de069225e1122c78385ad22a2ff656db8e6David Greene // Fold - If possible, fold this to a simpler init. Return this if not 990e6c27de069225e1122c78385ad22a2ff656db8e6David Greene // possible to fold. 991ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 992d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 99305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 99421870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 995e6c27de069225e1122c78385ad22a2ff656db8e6David Greene virtual std::string getAsString() const; 996e6c27de069225e1122c78385ad22a2ff656db8e6David Greene}; 997e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 998e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene/// BinOpInit - !op (X, Y) - Combine two inits. 999e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene/// 1000d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greeneclass BinOpInit : public OpInit { 1001e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greenepublic: 1002c7252ce74324e44efa7ec2506035a8e2d2e93d2fChris Lattner enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ }; 1003e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greeneprivate: 1004e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene BinaryOp Opc; 100505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS, *RHS; 1006dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 100705bce0beee87512e52428d4b80f5a8e79a949576David Greene BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : 1008b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva OpInit(IK_BinOpInit, Type), Opc(opc), LHS(lhs), RHS(rhs) {} 1009dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1010a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BinOpInit(const BinOpInit &Other) LLVM_DELETED_FUNCTION; 1011a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper BinOpInit &operator=(const BinOpInit &Other) LLVM_DELETED_FUNCTION; 1012dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1013dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1014b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1015b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_BinOpInit; 1016b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 101705bce0beee87512e52428d4b80f5a8e79a949576David Greene static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs, 101805bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type); 101921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1020d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene // Clone - Clone this operator, replacing arguments with the new list 102105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual OpInit *clone(std::vector<Init *> &Operands) const { 1022aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky assert(Operands.size() == 2 && 1023aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky "Wrong number of operands for binary operation"); 1024dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType()); 1025d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1026d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1027ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual int getNumOperands() const { return 2; } 1028ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *getOperand(int i) const { 1029aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky assert((i == 0 || i == 1) && "Invalid operand id for binary operator"); 1030d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene if (i == 0) { 1031d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return getLHS(); 103221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 1033d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene return getRHS(); 1034d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1035d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene } 1036d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1037e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene BinaryOp getOpcode() const { return Opc; } 103805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getLHS() const { return LHS; } 103905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getRHS() const { return RHS; } 1040e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 1041e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene // Fold - If possible, fold this to a simpler init. Return this if not 1042e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene // possible to fold. 1043ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 1044e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 104505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 104621870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1047e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene virtual std::string getAsString() const; 1048e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene}; 1049e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 1050d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// TernOpInit - !op (X, Y, Z) - Combine two inits. 1051d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene/// 10524afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greeneclass TernOpInit : public OpInit { 10534afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greenepublic: 1054ffc0ab6037aa45bc22f57433148e5f586843b3a7David Greene enum TernaryOp { SUBST, FOREACH, IF }; 10554afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greeneprivate: 10564afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TernaryOp Opc; 105705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *LHS, *MHS, *RHS; 1058dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 105905bce0beee87512e52428d4b80f5a8e79a949576David Greene TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, 1060f37dd02f7743ebd2424480361f5a7db510495c4fDavid Greene RecTy *Type) : 1061b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva OpInit(IK_TernOpInit, Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {} 1062dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1063a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper TernOpInit(const TernOpInit &Other) LLVM_DELETED_FUNCTION; 1064a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper TernOpInit &operator=(const TernOpInit &Other) LLVM_DELETED_FUNCTION; 1065dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1066dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1067b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1068b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_TernOpInit; 1069b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 107005bce0beee87512e52428d4b80f5a8e79a949576David Greene static TernOpInit *get(TernaryOp opc, Init *lhs, 107105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *mhs, Init *rhs, 107205bce0beee87512e52428d4b80f5a8e79a949576David Greene RecTy *Type); 107321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 10744afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene // Clone - Clone this operator, replacing arguments with the new list 107505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual OpInit *clone(std::vector<Init *> &Operands) const { 1076aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky assert(Operands.size() == 3 && 1077aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky "Wrong number of operands for ternary operation"); 1078dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2], 1079dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene getType()); 10804afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 10814afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 1082ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual int getNumOperands() const { return 3; } 1083ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *getOperand(int i) const { 1084aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky assert((i == 0 || i == 1 || i == 2) && 1085aa0b3df5a03304cf6fbc27d95a0d95717a3a61d0Nick Lewycky "Invalid operand id for ternary operator"); 10864afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene if (i == 0) { 10874afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return getLHS(); 108821870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else if (i == 1) { 10894afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return getMHS(); 109021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson } else { 10914afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene return getRHS(); 10924afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 10934afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene } 10944afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 10954afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene TernaryOp getOpcode() const { return Opc; } 109605bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getLHS() const { return LHS; } 109705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getMHS() const { return MHS; } 109805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getRHS() const { return RHS; } 10994afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene 11004afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene // Fold - If possible, fold this to a simpler init. Return this if not 11014afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene // possible to fold. 1102ef072c33150af8035024e6ac3d52b4861f4d6928Craig Topper virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 110321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1104548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling virtual bool isComplete() const { return false; } 1105548f5a0b751aafba88473e4863c2baf7741b56a5Bill Wendling 110605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 110721870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 11084afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene virtual std::string getAsString() const; 11094afc509b7ffe2c4ea234dfd7af5105feb21685d9David Greene}; 1110d418c1b768b5ff26afe05a5ce84d920bbbc99583David Greene 1111e8cf21e8e3db64dd49777d6bf6c867d47e9f5407David Greene 111207278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// VarInit - 'Opcode' - Represent a reference to an entire variable object. 111307278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 11147331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattnerclass VarInit : public TypedInit { 1115ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *VarName; 1116dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1117d568b3f55294917d1cc701da14a8a7daeb6563e6Eric Christopher explicit VarInit(const std::string &VN, RecTy *T) 1118b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_VarInit, T), VarName(StringInit::get(VN)) {} 1119ee6dca17252de152720655282fb4b74b76fb2fe9David Greene explicit VarInit(Init *VN, RecTy *T) 1120b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_VarInit, T), VarName(VN) {} 1121dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1122a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper VarInit(const VarInit &Other) LLVM_DELETED_FUNCTION; 1123a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper VarInit &operator=(const VarInit &Other) LLVM_DELETED_FUNCTION; 1124dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1125dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1126b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1127b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_VarInit; 1128b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 112905bce0beee87512e52428d4b80f5a8e79a949576David Greene static VarInit *get(const std::string &VN, RecTy *T); 113005bce0beee87512e52428d4b80f5a8e79a949576David Greene static VarInit *get(Init *VN, RecTy *T); 11313da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 113205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 113305bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<VarInit *>(this)); 1134e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1135e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1136ee6dca17252de152720655282fb4b74b76fb2fe9David Greene const std::string &getName() const; 1137ee6dca17252de152720655282fb4b74b76fb2fe9David Greene Init *getNameInit() const { return VarName; } 1138ee6dca17252de152720655282fb4b74b76fb2fe9David Greene std::string getNameInitAsString() const { 1139ee6dca17252de152720655282fb4b74b76fb2fe9David Greene return getNameInit()->getAsUnquotedString(); 1140ee6dca17252de152720655282fb4b74b76fb2fe9David Greene } 1141e62c1185bee05facc25d1d725434f517261d308bChris Lattner 114205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 114305bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const; 11447331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner 1145a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner virtual RecTy *getFieldType(const std::string &FieldName) const; 114605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *getFieldInit(Record &R, const RecordVal *RV, 114705bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const; 11489b929aa7495ee0b5d389370baeb332456632b2feChris Lattner 11499b929aa7495ee0b5d389370baeb332456632b2feChris Lattner /// resolveReferences - This method is used by classes that refer to other 11509b929aa7495ee0b5d389370baeb332456632b2feChris Lattner /// variables which may not be defined at the time they expression is formed. 11519b929aa7495ee0b5d389370baeb332456632b2feChris Lattner /// If a value is set for the variable later, this method will be called on 11529b929aa7495ee0b5d389370baeb332456632b2feChris Lattner /// users of the value to allow the value to propagate out. 11539b929aa7495ee0b5d389370baeb332456632b2feChris Lattner /// 115405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 11553da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1156307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const; 1157307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1158ee6dca17252de152720655282fb4b74b76fb2fe9David Greene virtual std::string getAsString() const { return getName(); } 1159e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1160e62c1185bee05facc25d1d725434f517261d308bChris Lattner 116107278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 11627331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field. 116307278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 1164e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass VarBitInit : public Init { 116505bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *TI; 1166e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned Bit; 1167dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1168b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva VarBitInit(TypedInit *T, unsigned B) : Init(IK_VarBitInit), TI(T), Bit(B) { 1169307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao assert(T->getType() && 117063554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva (isa<IntRecTy>(T->getType()) || 117163554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva (isa<BitsRecTy>(T->getType()) && 117263554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva cast<BitsRecTy>(T->getType())->getNumBits() > B)) && 11737331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner "Illegal VarBitInit expression!"); 11747331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner } 1175e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1176a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper VarBitInit(const VarBitInit &Other) LLVM_DELETED_FUNCTION; 1177a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper VarBitInit &operator=(const VarBitInit &Other) LLVM_DELETED_FUNCTION; 1178dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1179dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1180b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1181b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_VarBitInit; 1182b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 118305bce0beee87512e52428d4b80f5a8e79a949576David Greene static VarBitInit *get(TypedInit *T, unsigned B); 1184dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 118505bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 118605bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<VarBitInit *>(this)); 1187e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1188e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1189307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBitVar() const { return TI; } 1190307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual unsigned getBitNum() const { return Bit; } 11913da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 11923aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 119305bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1194307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1195307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned B) const { 1196307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao assert(B < 1 && "Bit index out of range!"); 1197307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao return const_cast<VarBitInit*>(this); 1198307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao } 1199e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1200e62c1185bee05facc25d1d725434f517261d308bChris Lattner 12013da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman/// VarListElementInit - List[4] - Represent access to one element of a var or 12021dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner/// field. 12031dba7abdd77e19c230f0426825a5ae4879471dccChris Lattnerclass VarListElementInit : public TypedInit { 120405bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *TI; 12051dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner unsigned Element; 1206dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 120705bce0beee87512e52428d4b80f5a8e79a949576David Greene VarListElementInit(TypedInit *T, unsigned E) 1208b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_VarListElementInit, 1209b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva cast<ListRecTy>(T->getType())->getElementType()), 1210b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva TI(T), Element(E) { 121163554988a94b8a4bcf3de77659a0b27c07a0975dSean Silva assert(T->getType() && isa<ListRecTy>(T->getType()) && 12121dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner "Illegal VarBitInit expression!"); 12131dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 12141dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 1215a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper VarListElementInit(const VarListElementInit &Other) LLVM_DELETED_FUNCTION; 1216a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper void operator=(const VarListElementInit &Other) LLVM_DELETED_FUNCTION; 1217dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1218dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1219b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1220b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_VarListElementInit; 1221b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 122205bce0beee87512e52428d4b80f5a8e79a949576David Greene static VarListElementInit *get(TypedInit *T, unsigned E); 1223dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 122405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 122505bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<VarListElementInit *>(this)); 12261dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner } 12271dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 122805bce0beee87512e52428d4b80f5a8e79a949576David Greene TypedInit *getVariable() const { return TI; } 12291dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner unsigned getElementNum() const { return Element; } 12301dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12311dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// resolveListElementReference - This method is used to implement 12321dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// VarListElementInit::resolveReferences. If the list element is resolvable 12331dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner /// now, we return the resolved value, otherwise we return null. 123405bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, 123505bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 123605bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const; 12371dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner 12383aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 123905bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1240307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 1241307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const; 12421dba7abdd77e19c230f0426825a5ae4879471dccChris Lattner}; 124307278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner 124407278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// DefInit - AL - Represent a reference to a 'def' in the description 124507278e48dc27d8ac64b5ff7ed6361536c2f38ea1Chris Lattner/// 1246beb31a51f67f651c5fa3c5094a78266d04a697a5David Greeneclass DefInit : public TypedInit { 1247e62c1185bee05facc25d1d725434f517261d308bChris Lattner Record *Def; 1248dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1249b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva DefInit(Record *D, RecordRecTy *T) : TypedInit(IK_DefInit, T), Def(D) {} 125077f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen friend class Record; 1251dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1252a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper DefInit(const DefInit &Other) LLVM_DELETED_FUNCTION; 1253a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper DefInit &operator=(const DefInit &Other) LLVM_DELETED_FUNCTION; 1254dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1255e62c1185bee05facc25d1d725434f517261d308bChris Lattnerpublic: 1256b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1257b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_DefInit; 1258b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 125905bce0beee87512e52428d4b80f5a8e79a949576David Greene static DefInit *get(Record*); 12603da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 126105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 126205bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<DefInit *>(this)); 1263e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1264e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1265e62c1185bee05facc25d1d725434f517261d308bChris Lattner Record *getDef() const { return Def; } 1266e62c1185bee05facc25d1d725434f517261d308bChris Lattner 126705bce0beee87512e52428d4b80f5a8e79a949576David Greene //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 1268b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner 1269b1ed0fc6308885c5887ed0474e8a4fbf63a39b45Chris Lattner virtual RecTy *getFieldType(const std::string &FieldName) const; 127005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *getFieldInit(Record &R, const RecordVal *RV, 127105bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::string &FieldName) const; 12723da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 12733aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 1274beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1275307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 127650bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal bit reference off def"); 1277beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1278beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene 1279beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// resolveListElementReference - This method is used to implement 1280beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// VarListElementInit::resolveReferences. If the list element is resolvable 1281beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene /// now, we return the resolved value, otherwise we return null. 128205bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 128305bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 128450bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal element reference off def"); 1285beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 1286e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1287e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1288e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1289a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner/// FieldInit - X.Y - Represent a reference to a subfield of a variable 1290a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner/// 12917331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattnerclass FieldInit : public TypedInit { 129205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Rec; // Record we are referring to 1293a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner std::string FieldName; // Field we are accessing 1294dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 129505bce0beee87512e52428d4b80f5a8e79a949576David Greene FieldInit(Init *R, const std::string &FN) 1296b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) { 12977331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner assert(getType() && "FieldInit with non-record type!"); 1298a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner } 1299a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner 1300a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper FieldInit(const FieldInit &Other) LLVM_DELETED_FUNCTION; 1301a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper FieldInit &operator=(const FieldInit &Other) LLVM_DELETED_FUNCTION; 1302dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1303dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1304b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1305b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_FieldInit; 1306b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 130705bce0beee87512e52428d4b80f5a8e79a949576David Greene static FieldInit *get(Init *R, const std::string &FN); 130805bce0beee87512e52428d4b80f5a8e79a949576David Greene static FieldInit *get(Init *R, const Init *FN); 1309dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 131005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 131105bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<FieldInit *>(this)); 1312a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner } 1313a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner 1314307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const; 1315307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao 131605bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, 131705bce0beee87512e52428d4b80f5a8e79a949576David Greene const RecordVal *RV, 131805bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const; 13197331ab9d56cb7007b1f5c92c90cd0d18a0af1fe3Chris Lattner 132005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 132124151a6888c752ff1d7fc80b500f5a836c9ac528Chris Lattner 13223aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const { 13233aba4d39fd101238ac06871895c28f26736d80cbChris Lattner return Rec->getAsString() + "." + FieldName; 1324a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner } 1325a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner}; 1326a1651900e1772b05afd2280308e9acc5a58cefb8Chris Lattner 13278c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner/// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required 13288c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner/// to have at least one value then a (possibly empty) list of arguments. Each 13298c06318821e4febb3a7f1afbab72dae362f1bf5fChris Lattner/// argument can have a name associated with it. 13308e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner/// 133178621a851ae84520de7d24a6d61e1dcf25749712David Greeneclass DagInit : public TypedInit, public FoldingSetNode { 133205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val; 13337cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman std::string ValName; 133405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<Init*> Args; 133591290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner std::vector<std::string> ArgNames; 1336dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 133705bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit(Init *V, const std::string &VN, 133805bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 133978621a851ae84520de7d24a6d61e1dcf25749712David Greene ArrayRef<std::string> NameRange) 1340b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN), 134178621a851ae84520de7d24a6d61e1dcf25749712David Greene Args(ArgRange.begin(), ArgRange.end()), 134278621a851ae84520de7d24a6d61e1dcf25749712David Greene ArgNames(NameRange.begin(), NameRange.end()) {} 134321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1344a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper DagInit(const DagInit &Other) LLVM_DELETED_FUNCTION; 1345a558d91cedd4fd5c2d3327a8a18e12c35530efa8Craig Topper DagInit &operator=(const DagInit &Other) LLVM_DELETED_FUNCTION; 1346dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 1347dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greenepublic: 1348b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva static bool classof(const Init *I) { 1349b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva return I->getKind() == IK_DagInit; 1350b0c6fa3b4b74d9cd03beb5a4cb9702abc85ac169Sean Silva } 135105bce0beee87512e52428d4b80f5a8e79a949576David Greene static DagInit *get(Init *V, const std::string &VN, 135205bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<Init *> ArgRange, 135305bce0beee87512e52428d4b80f5a8e79a949576David Greene ArrayRef<std::string> NameRange); 135405bce0beee87512e52428d4b80f5a8e79a949576David Greene static DagInit *get(Init *V, const std::string &VN, 135505bce0beee87512e52428d4b80f5a8e79a949576David Greene const std::vector< 135605bce0beee87512e52428d4b80f5a8e79a949576David Greene std::pair<Init*, std::string> > &args); 1357dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 135878621a851ae84520de7d24a6d61e1dcf25749712David Greene void Profile(FoldingSetNodeID &ID) const; 1359dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene 136005bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *convertInitializerTo(RecTy *Ty) const { 136105bce0beee87512e52428d4b80f5a8e79a949576David Greene return Ty->convertValue(const_cast<DagInit *>(this)); 13628e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner } 13638e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 136405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getOperator() const { return Val; } 136591290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner 13667cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman const std::string &getName() const { return ValName; } 13677cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman 136891290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner unsigned getNumArgs() const { return Args.size(); } 136905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getArg(unsigned Num) const { 137091290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner assert(Num < Args.size() && "Arg number out of range!"); 137191290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner return Args[Num]; 137291290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 137391290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner const std::string &getArgName(unsigned Num) const { 137491290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner assert(Num < ArgNames.size() && "Arg number out of range!"); 137591290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner return ArgNames[Num]; 137691290d7e9a743de363049e705a8303ae1f3a6e68Chris Lattner } 13778e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner 137805bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1379990db46e9ae7faa742a152ca4126d0bee9f1df9cChris Lattner 13803aba4d39fd101238ac06871895c28f26736d80cbChris Lattner virtual std::string getAsString() const; 13817674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 138205bce0beee87512e52428d4b80f5a8e79a949576David Greene typedef std::vector<Init*>::const_iterator const_arg_iterator; 13837674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov typedef std::vector<std::string>::const_iterator const_name_iterator; 13847674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 13857674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline const_arg_iterator arg_begin() const { return Args.begin(); } 13867674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline const_arg_iterator arg_end () const { return Args.end(); } 13877674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 13887674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline size_t arg_size () const { return Args.size(); } 13897674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline bool arg_empty() const { return Args.empty(); } 13907674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 13917674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline const_name_iterator name_begin() const { return ArgNames.begin(); } 13927674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline const_name_iterator name_end () const { return ArgNames.end(); } 13937674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 13947674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline size_t name_size () const { return ArgNames.size(); } 13957674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov inline bool name_empty() const { return ArgNames.empty(); } 13967674b9d2970fc38358c5666fce57d84c5700c69eAnton Korobeynikov 1397307525cd24c3b9c081ddb3c34a3418f2875cd556Michael Liao virtual Init *getBit(unsigned Bit) const { 139850bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal bit reference off dag"); 1399beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 140021870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 140105bce0beee87512e52428d4b80f5a8e79a949576David Greene virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 140205bce0beee87512e52428d4b80f5a8e79a949576David Greene unsigned Elt) const { 140350bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Illegal element reference off dag"); 1404beb31a51f67f651c5fa3c5094a78266d04a697a5David Greene } 14058e9a9774eb12b5242f74b8ac5b20e0a938ec9c53Chris Lattner}; 1406e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1407e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1408e62c1185bee05facc25d1d725434f517261d308bChris Lattner// High-Level Classes 1409e62c1185bee05facc25d1d725434f517261d308bChris Lattner//===----------------------------------------------------------------------===// 1410e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1411e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass RecordVal { 1412011dca7fac07100695dd3685bfaddbea58a468b9David Greene Init *Name; 1413e62c1185bee05facc25d1d725434f517261d308bChris Lattner RecTy *Ty; 1414e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned Prefix; 141505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Value; 1416e62c1185bee05facc25d1d725434f517261d308bChris Lattnerpublic: 1417011dca7fac07100695dd3685bfaddbea58a468b9David Greene RecordVal(Init *N, RecTy *T, unsigned P); 1418e62c1185bee05facc25d1d725434f517261d308bChris Lattner RecordVal(const std::string &N, RecTy *T, unsigned P); 1419e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1420011dca7fac07100695dd3685bfaddbea58a468b9David Greene const std::string &getName() const; 1421de703e25fe98f7c0dfab1750cf337a013b5c9603David Greene const Init *getNameInit() const { return Name; } 1422de703e25fe98f7c0dfab1750cf337a013b5c9603David Greene std::string getNameInitAsString() const { 1423de703e25fe98f7c0dfab1750cf337a013b5c9603David Greene return getNameInit()->getAsUnquotedString(); 1424de703e25fe98f7c0dfab1750cf337a013b5c9603David Greene } 1425e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1426e62c1185bee05facc25d1d725434f517261d308bChris Lattner unsigned getPrefix() const { return Prefix; } 1427e62c1185bee05facc25d1d725434f517261d308bChris Lattner RecTy *getType() const { return Ty; } 142805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getValue() const { return Value; } 1429e62c1185bee05facc25d1d725434f517261d308bChris Lattner 143005bce0beee87512e52428d4b80f5a8e79a949576David Greene bool setValue(Init *V) { 1431e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (V) { 1432e62c1185bee05facc25d1d725434f517261d308bChris Lattner Value = V->convertInitializerTo(Ty); 1433e62c1185bee05facc25d1d725434f517261d308bChris Lattner return Value == 0; 1434e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1435e62c1185bee05facc25d1d725434f517261d308bChris Lattner Value = 0; 1436e62c1185bee05facc25d1d725434f517261d308bChris Lattner return false; 1437e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1438e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1439e62c1185bee05facc25d1d725434f517261d308bChris Lattner void dump() const; 14401a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar void print(raw_ostream &OS, bool PrintSem = true) const; 1441e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1442e62c1185bee05facc25d1d725434f517261d308bChris Lattner 14431a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarinline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1444e62c1185bee05facc25d1d725434f517261d308bChris Lattner RV.print(OS << " "); 1445e62c1185bee05facc25d1d725434f517261d308bChris Lattner return OS; 1446e62c1185bee05facc25d1d725434f517261d308bChris Lattner} 1447e62c1185bee05facc25d1d725434f517261d308bChris Lattner 144889e0f74094a6a86170c2c70fe8c6c19cb99c97a0Chris Lattnerclass Record { 14496f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar static unsigned LastID; 14506f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 14516f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar // Unique record ID. 14526f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar unsigned ID; 14530d886401b3ec09b0c2d267942b07702a2f0740f4David Greene Init *Name; 1454376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen // Location where record was instantiated, followed by the location of 1455376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen // multiclass prototypes used. 1456376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen SmallVector<SMLoc, 4> Locs; 1457e22b321d2276b634519165b101b02d92c2fcf5c7David Greene std::vector<Init *> TemplateArgs; 1458e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::vector<RecordVal> Values; 1459e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::vector<Record*> SuperClasses; 146067db883487fca3472fdde51e931657e22d4d0495Chris Lattner 146167db883487fca3472fdde51e931657e22d4d0495Chris Lattner // Tracks Record instances. Not owned by Record. 146267db883487fca3472fdde51e931657e22d4d0495Chris Lattner RecordKeeper &TrackedRecords; 146367db883487fca3472fdde51e931657e22d4d0495Chris Lattner 146477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen DefInit *TheInit; 146577f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1466f7931b7040de1c829e678b4e391308bc3376f8a0David Greene void init(); 14670d886401b3ec09b0c2d267942b07702a2f0740f4David Greene void checkName(); 14680d886401b3ec09b0c2d267942b07702a2f0740f4David Greene 1469e62c1185bee05facc25d1d725434f517261d308bChris Lattnerpublic: 1470e62c1185bee05facc25d1d725434f517261d308bChris Lattner 14719c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner // Constructs a record. 1472376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen explicit Record(const std::string &N, ArrayRef<SMLoc> locs, 1473376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen RecordKeeper &records) : 1474376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen ID(LastID++), Name(StringInit::get(N)), Locs(locs.begin(), locs.end()), 1475376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen TrackedRecords(records), TheInit(0) { 1476004adaf3452a355ada2a54bcb61dc8925a718651David Greene init(); 14770abdadbce7e04af76145154d75ca41dab749b8d6David Greene } 1478376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records) : 1479376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen ID(LastID++), Name(N), Locs(locs.begin(), locs.end()), 1480376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen TrackedRecords(records), TheInit(0) { 1481004adaf3452a355ada2a54bcb61dc8925a718651David Greene init(); 1482675f85d0f240930d571f4e557bb92237ee48124eDavid Greene } 1483cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson 1484cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson // When copy-constructing a Record, we must still guarantee a globally unique 1485cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson // ID number. All other fields can be copied normally. 1486cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson Record(const Record &O) : 1487cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson ID(LastID++), Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs), 1488cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson Values(O.Values), SuperClasses(O.SuperClasses), 1489cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson TrackedRecords(O.TrackedRecords), TheInit(O.TheInit) { } 1490cdac1be34a0b329f1bd2232a3f4995432f633c3cOwen Anderson 1491e62c1185bee05facc25d1d725434f517261d308bChris Lattner ~Record() {} 149221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1493f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov 1494117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner static unsigned getNewUID() { return LastID++; } 1495f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov 1496f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov 14976f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar unsigned getID() const { return ID; } 14986f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar 14990d886401b3ec09b0c2d267942b07702a2f0740f4David Greene const std::string &getName() const; 1500d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene Init *getNameInit() const { 1501d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene return Name; 1502d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene } 1503d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene const std::string getNameInitAsString() const { 1504d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene return getNameInit()->getAsUnquotedString(); 1505d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene } 1506d7f8941e77fef20dc147fe102a2024cc5ccef366David Greene 15070d886401b3ec09b0c2d267942b07702a2f0740f4David Greene void setName(Init *Name); // Also updates RecordKeeper. 1508936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner void setName(const std::string &Name); // Also updates RecordKeeper. 150921870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1510376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen ArrayRef<SMLoc> getLoc() const { return Locs; } 151121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 151277f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen /// get the corresponding DefInit. 151377f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen DefInit *getDefInit(); 151477f8274c7d4bfb5e2a449eb49dc78dcae37e5457Jakob Stoklund Olesen 1515e22b321d2276b634519165b101b02d92c2fcf5c7David Greene const std::vector<Init *> &getTemplateArgs() const { 1516e62c1185bee05facc25d1d725434f517261d308bChris Lattner return TemplateArgs; 1517e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1518e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<RecordVal> &getValues() const { return Values; } 1519e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::vector<Record*> &getSuperClasses() const { return SuperClasses; } 1520e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1521e22b321d2276b634519165b101b02d92c2fcf5c7David Greene bool isTemplateArg(Init *Name) const { 1522e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i) 1523e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (TemplateArgs[i] == Name) return true; 1524e62c1185bee05facc25d1d725434f517261d308bChris Lattner return false; 1525e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1526e22b321d2276b634519165b101b02d92c2fcf5c7David Greene bool isTemplateArg(StringRef Name) const { 1527e22b321d2276b634519165b101b02d92c2fcf5c7David Greene return isTemplateArg(StringInit::get(Name.str())); 1528e22b321d2276b634519165b101b02d92c2fcf5c7David Greene } 1529e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1530ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen const RecordVal *getValue(const Init *Name) const { 1531e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) 1532ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (Values[i].getNameInit() == Name) return &Values[i]; 1533e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1534e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1535ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen const RecordVal *getValue(StringRef Name) const { 1536ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen return getValue(StringInit::get(Name)); 1537ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen } 1538ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *getValue(const Init *Name) { 1539e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) 1540ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen if (Values[i].getNameInit() == Name) return &Values[i]; 1541e62c1185bee05facc25d1d725434f517261d308bChris Lattner return 0; 1542e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1543ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen RecordVal *getValue(StringRef Name) { 1544ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen return getValue(StringInit::get(Name)); 1545ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen } 154696a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 1547e22b321d2276b634519165b101b02d92c2fcf5c7David Greene void addTemplateArg(Init *Name) { 1548e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(!isTemplateArg(Name) && "Template arg already defined!"); 1549e62c1185bee05facc25d1d725434f517261d308bChris Lattner TemplateArgs.push_back(Name); 1550e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1551e22b321d2276b634519165b101b02d92c2fcf5c7David Greene void addTemplateArg(StringRef Name) { 1552e22b321d2276b634519165b101b02d92c2fcf5c7David Greene addTemplateArg(StringInit::get(Name.str())); 1553e22b321d2276b634519165b101b02d92c2fcf5c7David Greene } 1554e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1555e62c1185bee05facc25d1d725434f517261d308bChris Lattner void addValue(const RecordVal &RV) { 1556ebaf92c67dac4974f98a08f8096d3eb2f4edd09dJakob Stoklund Olesen assert(getValue(RV.getNameInit()) == 0 && "Value already added!"); 1557e62c1185bee05facc25d1d725434f517261d308bChris Lattner Values.push_back(RV); 1558e338565757bfcfe9d762751c976684f66954fb45David Greene if (Values.size() > 1) 1559e338565757bfcfe9d762751c976684f66954fb45David Greene // Keep NAME at the end of the list. It makes record dumps a 1560e338565757bfcfe9d762751c976684f66954fb45David Greene // bit prettier and allows TableGen tests to be written more 1561e338565757bfcfe9d762751c976684f66954fb45David Greene // naturally. Tests can use CHECK-NEXT to look for Record 1562e338565757bfcfe9d762751c976684f66954fb45David Greene // fields they expect to see after a def. They can't do that if 1563e338565757bfcfe9d762751c976684f66954fb45David Greene // NAME is the first Record field. 1564e338565757bfcfe9d762751c976684f66954fb45David Greene std::swap(Values[Values.size() - 2], Values[Values.size() - 1]); 1565e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1566e62c1185bee05facc25d1d725434f517261d308bChris Lattner 156796a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene void removeValue(Init *Name) { 1568bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner for (unsigned i = 0, e = Values.size(); i != e; ++i) 156996a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene if (Values[i].getNameInit() == Name) { 1570bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner Values.erase(Values.begin()+i); 1571bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner return; 1572bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner } 157350bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Cannot remove an entry that does not exist!"); 1574bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner } 1575bfce056ea89f4a243c429c12e47ec78168bb1d2cChris Lattner 157696a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene void removeValue(StringRef Name) { 157796a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene removeValue(StringInit::get(Name.str())); 157896a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene } 157996a9f78c4aa1bc188f3f7ee869bed44cb7a6ff0eDavid Greene 158002475f1fd502fa1729d1fc447417087acf9e96c8Ted Kremenek bool isSubClassOf(const Record *R) const { 1581e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 1582e62c1185bee05facc25d1d725434f517261d308bChris Lattner if (SuperClasses[i] == R) 1583ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen return true; 1584e62c1185bee05facc25d1d725434f517261d308bChris Lattner return false; 1585e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1586e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1587c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner bool isSubClassOf(StringRef Name) const { 1588a40e5ad69f5ab5da1671a5e84e75a60202ad03d5Chris Lattner for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 15897474c29d903d479e7f99eb0d1d097f75289c5f48David Greene if (SuperClasses[i]->getNameInitAsString() == Name) 1590a40e5ad69f5ab5da1671a5e84e75a60202ad03d5Chris Lattner return true; 1591a40e5ad69f5ab5da1671a5e84e75a60202ad03d5Chris Lattner return false; 1592a40e5ad69f5ab5da1671a5e84e75a60202ad03d5Chris Lattner } 1593a40e5ad69f5ab5da1671a5e84e75a60202ad03d5Chris Lattner 1594e62c1185bee05facc25d1d725434f517261d308bChris Lattner void addSuperClass(Record *R) { 1595e62c1185bee05facc25d1d725434f517261d308bChris Lattner assert(!isSubClassOf(R) && "Already subclassing record!"); 1596e62c1185bee05facc25d1d725434f517261d308bChris Lattner SuperClasses.push_back(R); 1597e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1598e62c1185bee05facc25d1d725434f517261d308bChris Lattner 15997dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// resolveReferences - If there are any field references that refer to fields 16007dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// that have been filled in, we can propagate the values now. 16017dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// 16027dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner void resolveReferences() { resolveReferencesTo(0); } 16037dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner 16047dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// resolveReferencesTo - If anything in this record refers to RV, replace the 16057dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// reference to RV with the RHS of RV. If RV is null, we resolve all 16067dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner /// possible references. 16077dda395004eb962cef1c1554b1e8b2ad069760e0Chris Lattner void resolveReferencesTo(const RecordVal *RV); 1608e62c1185bee05facc25d1d725434f517261d308bChris Lattner 160967db883487fca3472fdde51e931657e22d4d0495Chris Lattner RecordKeeper &getRecords() const { 16109c6b60eb28d2717008f8d6ff52f7666ebc81113dChris Lattner return TrackedRecords; 161167db883487fca3472fdde51e931657e22d4d0495Chris Lattner } 161267db883487fca3472fdde51e931657e22d4d0495Chris Lattner 1613e62c1185bee05facc25d1d725434f517261d308bChris Lattner void dump() const; 16145c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 16155c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner //===--------------------------------------------------------------------===// 16165c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner // High-level methods useful to tablegen back-ends 16175c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner // 16185c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 1619c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner /// getValueInit - Return the initializer for a value with the specified name, 1620c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner /// or throw an exception if the field does not exist. 1621c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner /// 162205bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *getValueInit(StringRef FieldName) const; 1623c7d58024f8bed33e0b3e795e51a62ec30248aff3Chris Lattner 16245c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner /// getValueAsString - This method looks up the specified field and returns 16255c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner /// its value as a string, throwing an exception if the field does not exist 16265c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner /// or if the value is not a string. 16275c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner /// 1628c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner std::string getValueAsString(StringRef FieldName) const; 16295c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner 16306f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner /// getValueAsBitsInit - This method looks up the specified field and returns 16316f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner /// its value as a BitsInit, throwing an exception if the field does not exist 16326f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner /// or if the value is not the right type. 16336f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner /// 163405bce0beee87512e52428d4b80f5a8e79a949576David Greene BitsInit *getValueAsBitsInit(StringRef FieldName) const; 16356f334ad8f5c9319b334e2ba68b89d0dd46156788Chris Lattner 163658c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// getValueAsListInit - This method looks up the specified field and returns 163758c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// its value as a ListInit, throwing an exception if the field does not exist 163858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// or if the value is not the right type. 163958c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// 164005bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *getValueAsListInit(StringRef FieldName) const; 164158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner 1642b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner /// getValueAsListOfDefs - This method looks up the specified field and 1643af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov /// returns its value as a vector of records, throwing an exception if the 1644b0e103d46bf8799ac5523157a6ed4a78d1751a89Chris Lattner /// field does not exist or if the value is not the right type. 1645fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey /// 1646c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const; 1647fd306bfdd294772560b3a1cf762bc1081f66e6baJim Laskey 1648f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov /// getValueAsListOfInts - This method looks up the specified field and 1649f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov /// returns its value as a vector of integers, throwing an exception if the 1650f41b75d85be5d53f7c4ef0f60d55bf7df33a881cMikhail Glushenkov /// field does not exist or if the value is not the right type. 1651af1b61debd9cb6570ed815a27cd94897f0dca3cfAnton Korobeynikov /// 1652c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const; 165321870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1654bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson /// getValueAsListOfStrings - This method looks up the specified field and 1655bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson /// returns its value as a vector of strings, throwing an exception if the 1656bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson /// field does not exist or if the value is not the right type. 1657bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson /// 1658bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const; 1659bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 1660dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner /// getValueAsDef - This method looks up the specified field and returns its 1661dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner /// value as a Record, throwing an exception if the field does not exist or if 1662dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner /// the value is not the right type. 1663dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner /// 1664c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner Record *getValueAsDef(StringRef FieldName) const; 1665dbb295bd0d0e084ffbaae314026f389d83453619Chris Lattner 16660969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner /// getValueAsBit - This method looks up the specified field and returns its 16670969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner /// value as a bit, throwing an exception if the field does not exist or if 16680969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner /// the value is not the right type. 16690969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner /// 1670c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner bool getValueAsBit(StringRef FieldName) const; 16710969c5bdf2de91fc03480dba86bcb6ce76612d8bChris Lattner 1672c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen /// getValueAsBitOrUnset - This method looks up the specified field and 1673c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen /// returns its value as a bit. If the field is unset, sets Unset to true and 1674c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen /// retunrs false. 1675c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen /// 1676c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const; 1677c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 167858c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// getValueAsInt - This method looks up the specified field and returns its 167963f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman /// value as an int64_t, throwing an exception if the field does not exist or 168063f97201dc9dcebbe84d1b73113166c64212b4b8Dan Gohman /// if the value is not the right type. 168158c5de16927ea5ba1b454a69ce7ee4fdc371b9f7Chris Lattner /// 1682c19418f31fa8ab09ff43c57150e5042dbe368f49Chris Lattner int64_t getValueAsInt(StringRef FieldName) const; 1683784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner 1684784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner /// getValueAsDag - This method looks up the specified field and returns its 1685784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner /// value as an Dag, throwing an exception if the field does not exist or if 1686784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner /// the value is not the right type. 1687784a793636b7e766e868822c213ca96b0755b5c1Chris Lattner /// 168805bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *getValueAsDag(StringRef FieldName) const; 1689e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1690e62c1185bee05facc25d1d725434f517261d308bChris Lattner 16911a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &operator<<(raw_ostream &OS, const Record &R); 1692e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1693c7cafcd815519b06318629b424abe746437e1389David Greenestruct MultiClass { 1694c7cafcd815519b06318629b424abe746437e1389David Greene Record Rec; // Placeholder for template args and Name. 1695c7cafcd815519b06318629b424abe746437e1389David Greene typedef std::vector<Record*> RecordVector; 1696c7cafcd815519b06318629b424abe746437e1389David Greene RecordVector DefPrototypes; 1697d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 1698d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene void dump() const; 1699d34a73b3b709001c56db68a4d9a84e5d2002b1f0David Greene 17004b18691c3580674691875ec37c84a1c4edf2d586Jim Grosbach MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) : 170167db883487fca3472fdde51e931657e22d4d0495Chris Lattner Rec(Name, Loc, Records) {} 1702c7cafcd815519b06318629b424abe746437e1389David Greene}; 1703c7cafcd815519b06318629b424abe746437e1389David Greene 1704e62c1185bee05facc25d1d725434f517261d308bChris Lattnerclass RecordKeeper { 1705e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::map<std::string, Record*> Classes, Defs; 1706cebb4ee93a0064e4a2cb1fd1da7455b01e5655cbDavid Greene 1707e62c1185bee05facc25d1d725434f517261d308bChris Lattnerpublic: 1708e62c1185bee05facc25d1d725434f517261d308bChris Lattner ~RecordKeeper() { 1709e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::iterator I = Classes.begin(), 1710ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Classes.end(); I != E; ++I) 1711e62c1185bee05facc25d1d725434f517261d308bChris Lattner delete I->second; 1712e62c1185bee05facc25d1d725434f517261d308bChris Lattner for (std::map<std::string, Record*>::iterator I = Defs.begin(), 1713ea3e5e56fdc56e5c2ddafb36eab26676e137dfa0Jeff Cohen E = Defs.end(); I != E; ++I) 1714e62c1185bee05facc25d1d725434f517261d308bChris Lattner delete I->second; 1715e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 17163da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 1717e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &getClasses() const { return Classes; } 1718e62c1185bee05facc25d1d725434f517261d308bChris Lattner const std::map<std::string, Record*> &getDefs() const { return Defs; } 1719e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1720e62c1185bee05facc25d1d725434f517261d308bChris Lattner Record *getClass(const std::string &Name) const { 1721e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::map<std::string, Record*>::const_iterator I = Classes.find(Name); 1722e62c1185bee05facc25d1d725434f517261d308bChris Lattner return I == Classes.end() ? 0 : I->second; 1723e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1724e62c1185bee05facc25d1d725434f517261d308bChris Lattner Record *getDef(const std::string &Name) const { 1725e62c1185bee05facc25d1d725434f517261d308bChris Lattner std::map<std::string, Record*>::const_iterator I = Defs.find(Name); 1726e62c1185bee05facc25d1d725434f517261d308bChris Lattner return I == Defs.end() ? 0 : I->second; 1727e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1728e62c1185bee05facc25d1d725434f517261d308bChris Lattner void addClass(Record *R) { 172972cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen bool Ins = Classes.insert(std::make_pair(R->getName(), R)).second; 173072cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen (void)Ins; 173172cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen assert(Ins && "Class already exists"); 1732e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1733e62c1185bee05facc25d1d725434f517261d308bChris Lattner void addDef(Record *R) { 173472cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen bool Ins = Defs.insert(std::make_pair(R->getName(), R)).second; 173572cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen (void)Ins; 173672cba6cdf640411e2fb6207858a0abd87c4286fcJakob Stoklund Olesen assert(Ins && "Record already exists"); 1737e62c1185bee05facc25d1d725434f517261d308bChris Lattner } 1738e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1739936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner /// removeClass - Remove, but do not delete, the specified record. 1740936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner /// 1741936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner void removeClass(const std::string &Name) { 1742936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner assert(Classes.count(Name) && "Class does not exist!"); 1743936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner Classes.erase(Name); 1744936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } 1745936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner /// removeDef - Remove, but do not delete, the specified record. 1746936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner /// 1747936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner void removeDef(const std::string &Name) { 1748936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner assert(Defs.count(Name) && "Def does not exist!"); 1749936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner Defs.erase(Name); 1750936dd9274aca2f2ccd0e10dafe83a22767475fa6Chris Lattner } 175121870411d9c1807526b613d04c2ebae5a43c263bBob Wilson 1752ab47ae3381aa2372009a9054260461c20324b555Chris Lattner //===--------------------------------------------------------------------===// 1753ab47ae3381aa2372009a9054260461c20324b555Chris Lattner // High-level helper methods, useful for tablegen backends... 1754ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1755ab47ae3381aa2372009a9054260461c20324b555Chris Lattner /// getAllDerivedDefinitions - This method returns all concrete definitions 1756ab47ae3381aa2372009a9054260461c20324b555Chris Lattner /// that derive from the specified class name. If a class with the specified 17575c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner /// name does not exist, an exception is thrown. 17585c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner std::vector<Record*> 17595c737ad4d669b835b8fb973a5c477a4dbb213830Chris Lattner getAllDerivedDefinitions(const std::string &ClassName) const; 1760ab47ae3381aa2372009a9054260461c20324b555Chris Lattner 1761e62c1185bee05facc25d1d725434f517261d308bChris Lattner void dump() const; 1762e62c1185bee05facc25d1d725434f517261d308bChris Lattner}; 1763e62c1185bee05facc25d1d725434f517261d308bChris Lattner 1764690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner/// LessRecord - Sorting predicate to sort record pointers by name. 1765690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner/// 1766690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattnerstruct LessRecord { 1767690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner bool operator()(const Record *Rec1, const Record *Rec2) const { 1768160a3bf74d1a2b048f65e2162d038ed96eddde01Jakob Stoklund Olesen return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0; 1769690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner } 1770690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner}; 1771690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner 177290fee07298bec2e5160a599db850b9553d02377bSean Silva/// LessRecordByID - Sorting predicate to sort record pointers by their 177390fee07298bec2e5160a599db850b9553d02377bSean Silva/// unique ID. If you just need a deterministic order, use this, since it 177490fee07298bec2e5160a599db850b9553d02377bSean Silva/// just compares two `unsigned`; the other sorting predicates require 177590fee07298bec2e5160a599db850b9553d02377bSean Silva/// string manipulation. 177690fee07298bec2e5160a599db850b9553d02377bSean Silvastruct LessRecordByID { 177790fee07298bec2e5160a599db850b9553d02377bSean Silva bool operator()(const Record *LHS, const Record *RHS) const { 177890fee07298bec2e5160a599db850b9553d02377bSean Silva return LHS->getID() < RHS->getID(); 177990fee07298bec2e5160a599db850b9553d02377bSean Silva } 178090fee07298bec2e5160a599db850b9553d02377bSean Silva}; 178190fee07298bec2e5160a599db850b9553d02377bSean Silva 178221870411d9c1807526b613d04c2ebae5a43c263bBob Wilson/// LessRecordFieldName - Sorting predicate to sort record pointers by their 17837c9a7728d9dd248ebee8f2dd969d303711d487a9Jim Grosbach/// name field. 1784690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner/// 1785690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattnerstruct LessRecordFieldName { 1786690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner bool operator()(const Record *Rec1, const Record *Rec2) const { 1787690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1788690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner } 1789690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner}; 1790690d80eefeb522c8697ef39d9e6d19b0be276f0eChris Lattner 17911a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarraw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); 1792e62c1185bee05facc25d1d725434f517261d308bChris Lattner 179330c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 179430c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 179530c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *QualifyName(Record &CurRec, MultiClass *CurMultiClass, 179630c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene Init *Name, const std::string &Scoper); 179730c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 179830c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// QualifyName - Return an Init with a qualifier prefix referring 179930c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene/// to CurRec's name. 180030c2225b3c4a89b527ee38542ab8990ca0a682f1David GreeneInit *QualifyName(Record &CurRec, MultiClass *CurMultiClass, 180130c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene const std::string &Name, const std::string &Scoper); 180230c2225b3c4a89b527ee38542ab8990ca0a682f1David Greene 1803d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke} // End llvm namespace 1804d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 1805e62c1185bee05facc25d1d725434f517261d308bChris Lattner#endif 1806