1 //===- Record.h - Classes to represent Table Records ------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the main TableGen data structures, including the TableGen 11 // types, values, and high-level data structures. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef RECORD_H 16 #define RECORD_H 17 18 #include "llvm/Support/SourceMgr.h" 19 #include "llvm/System/DataTypes.h" 20 #include "llvm/Support/raw_ostream.h" 21 #include <map> 22 23 namespace llvm { 24 class raw_ostream; 25 26 // RecTy subclasses. 27 class BitRecTy; 28 class BitsRecTy; 29 class IntRecTy; 30 class StringRecTy; 31 class ListRecTy; 32 class CodeRecTy; 33 class DagRecTy; 34 class RecordRecTy; 35 36 // Init subclasses. 37 struct Init; 38 class UnsetInit; 39 class BitInit; 40 class BitsInit; 41 class IntInit; 42 class StringInit; 43 class CodeInit; 44 class ListInit; 45 class UnOpInit; 46 class BinOpInit; 47 class TernOpInit; 48 class DefInit; 49 class DagInit; 50 class TypedInit; 51 class VarInit; 52 class FieldInit; 53 class VarBitInit; 54 class VarListElementInit; 55 56 // Other classes. 57 class Record; 58 class RecordVal; 59 struct MultiClass; 60 61 //===----------------------------------------------------------------------===// 62 // Type Classes 63 //===----------------------------------------------------------------------===// 64 65 struct RecTy { ~RecTyRecTy66 virtual ~RecTy() {} 67 68 virtual std::string getAsString() const = 0; printRecTy69 void print(raw_ostream &OS) const { OS << getAsString(); } 70 void dump() const; 71 72 /// typeIsConvertibleTo - Return true if all values of 'this' type can be 73 /// converted to the specified type. 74 virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0; 75 76 public: // These methods should only be called from subclasses of Init convertValueRecTy77 virtual Init *convertValue( UnsetInit *UI) { return 0; } convertValueRecTy78 virtual Init *convertValue( BitInit *BI) { return 0; } convertValueRecTy79 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValueRecTy80 virtual Init *convertValue( IntInit *II) { return 0; } convertValueRecTy81 virtual Init *convertValue(StringInit *SI) { return 0; } convertValueRecTy82 virtual Init *convertValue( ListInit *LI) { return 0; } convertValueRecTy83 virtual Init *convertValue( UnOpInit *UI) { 84 return convertValue((TypedInit*)UI); 85 } convertValueRecTy86 virtual Init *convertValue( BinOpInit *UI) { 87 return convertValue((TypedInit*)UI); 88 } convertValueRecTy89 virtual Init *convertValue( TernOpInit *UI) { 90 return convertValue((TypedInit*)UI); 91 } convertValueRecTy92 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValueRecTy93 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValueRecTy94 virtual Init *convertValue( DefInit *DI) { return 0; } convertValueRecTy95 virtual Init *convertValue( DagInit *DI) { return 0; } convertValueRecTy96 virtual Init *convertValue( TypedInit *TI) { return 0; } convertValueRecTy97 virtual Init *convertValue( VarInit *VI) { 98 return convertValue((TypedInit*)VI); 99 } convertValueRecTy100 virtual Init *convertValue( FieldInit *FI) { 101 return convertValue((TypedInit*)FI); 102 } 103 104 public: // These methods should only be called by subclasses of RecTy. 105 // baseClassOf - These virtual methods should be overloaded to return true iff 106 // all values of type 'RHS' can be converted to the 'this' type. baseClassOfRecTy107 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOfRecTy108 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOfRecTy109 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOfRecTy110 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOfRecTy111 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOfRecTy112 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOfRecTy113 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOfRecTy114 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 115 }; 116 117 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { 118 Ty.print(OS); 119 return OS; 120 } 121 122 123 /// BitRecTy - 'bit' - Represent a single bit 124 /// 125 class BitRecTy : public RecTy { 126 public: convertValue(UnsetInit * UI)127 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)128 virtual Init *convertValue( BitInit *BI) { return (Init*)BI; } 129 virtual Init *convertValue( BitsInit *BI); 130 virtual Init *convertValue( IntInit *II); convertValue(StringInit * SI)131 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)132 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)133 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)134 virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; } convertValue(DefInit * DI)135 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)136 virtual Init *convertValue( DagInit *DI) { return 0; } convertValue(UnOpInit * UI)137 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)138 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)139 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 140 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)141 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)142 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 143 getAsString()144 std::string getAsString() const { return "bit"; } 145 typeIsConvertibleTo(const RecTy * RHS)146 bool typeIsConvertibleTo(const RecTy *RHS) const { 147 return RHS->baseClassOf(this); 148 } baseClassOf(const BitRecTy * RHS)149 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; } 150 virtual bool baseClassOf(const BitsRecTy *RHS) const; baseClassOf(const IntRecTy * RHS)151 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } baseClassOf(const StringRecTy * RHS)152 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)153 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)154 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)155 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)156 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 157 158 }; 159 160 161 // BitsRecTy - 'bits<n>' - Represent a fixed number of bits 162 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits 163 /// 164 class BitsRecTy : public RecTy { 165 unsigned Size; 166 public: BitsRecTy(unsigned Sz)167 explicit BitsRecTy(unsigned Sz) : Size(Sz) {} 168 getNumBits()169 unsigned getNumBits() const { return Size; } 170 171 virtual Init *convertValue( UnsetInit *UI); 172 virtual Init *convertValue( BitInit *UI); 173 virtual Init *convertValue( BitsInit *BI); 174 virtual Init *convertValue( IntInit *II); convertValue(StringInit * SI)175 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)176 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)177 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)178 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)179 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)180 virtual Init *convertValue( DagInit *DI) { return 0; } convertValue(UnOpInit * UI)181 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)182 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)183 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 184 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)185 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)186 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 187 188 std::string getAsString() const; 189 typeIsConvertibleTo(const RecTy * RHS)190 bool typeIsConvertibleTo(const RecTy *RHS) const { 191 return RHS->baseClassOf(this); 192 } baseClassOf(const BitRecTy * RHS)193 virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; } baseClassOf(const BitsRecTy * RHS)194 virtual bool baseClassOf(const BitsRecTy *RHS) const { 195 return RHS->Size == Size; 196 } baseClassOf(const IntRecTy * RHS)197 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } baseClassOf(const StringRecTy * RHS)198 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)199 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)200 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)201 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)202 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 203 204 }; 205 206 207 /// IntRecTy - 'int' - Represent an integer value of no particular size 208 /// 209 class IntRecTy : public RecTy { 210 public: convertValue(UnsetInit * UI)211 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } 212 virtual Init *convertValue( BitInit *BI); 213 virtual Init *convertValue( BitsInit *BI); convertValue(IntInit * II)214 virtual Init *convertValue( IntInit *II) { return (Init*)II; } convertValue(StringInit * SI)215 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)216 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)217 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)218 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)219 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)220 virtual Init *convertValue( DagInit *DI) { return 0; } convertValue(UnOpInit * UI)221 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)222 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)223 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 224 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)225 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)226 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 227 getAsString()228 std::string getAsString() const { return "int"; } 229 typeIsConvertibleTo(const RecTy * RHS)230 bool typeIsConvertibleTo(const RecTy *RHS) const { 231 return RHS->baseClassOf(this); 232 } 233 baseClassOf(const BitRecTy * RHS)234 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; } baseClassOf(const BitsRecTy * RHS)235 virtual bool baseClassOf(const BitsRecTy *RHS) const { return true; } baseClassOf(const IntRecTy * RHS)236 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; } baseClassOf(const StringRecTy * RHS)237 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)238 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)239 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)240 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)241 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 242 243 }; 244 245 /// StringRecTy - 'string' - Represent an string value 246 /// 247 class StringRecTy : public RecTy { 248 public: convertValue(UnsetInit * UI)249 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)250 virtual Init *convertValue( BitInit *BI) { return 0; } convertValue(BitsInit * BI)251 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValue(IntInit * II)252 virtual Init *convertValue( IntInit *II) { return 0; } convertValue(StringInit * SI)253 virtual Init *convertValue(StringInit *SI) { return (Init*)SI; } convertValue(ListInit * LI)254 virtual Init *convertValue( ListInit *LI) { return 0; } 255 virtual Init *convertValue( UnOpInit *BO); 256 virtual Init *convertValue( BinOpInit *BO); convertValue(TernOpInit * BO)257 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);} 258 convertValue(CodeInit * CI)259 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)260 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)261 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)262 virtual Init *convertValue( DagInit *DI) { return 0; } 263 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)264 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)265 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 266 getAsString()267 std::string getAsString() const { return "string"; } 268 typeIsConvertibleTo(const RecTy * RHS)269 bool typeIsConvertibleTo(const RecTy *RHS) const { 270 return RHS->baseClassOf(this); 271 } 272 baseClassOf(const BitRecTy * RHS)273 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOf(const BitsRecTy * RHS)274 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOf(const IntRecTy * RHS)275 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOf(const StringRecTy * RHS)276 virtual bool baseClassOf(const StringRecTy *RHS) const { return true; } baseClassOf(const ListRecTy * RHS)277 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)278 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)279 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)280 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 281 }; 282 283 // ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of 284 // the specified type. 285 /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must 286 /// be of the specified type. 287 /// 288 class ListRecTy : public RecTy { 289 RecTy *Ty; 290 public: ListRecTy(RecTy * T)291 explicit ListRecTy(RecTy *T) : Ty(T) {} 292 getElementType()293 RecTy *getElementType() const { return Ty; } 294 convertValue(UnsetInit * UI)295 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)296 virtual Init *convertValue( BitInit *BI) { return 0; } convertValue(BitsInit * BI)297 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValue(IntInit * II)298 virtual Init *convertValue( IntInit *II) { return 0; } convertValue(StringInit * SI)299 virtual Init *convertValue(StringInit *SI) { return 0; } 300 virtual Init *convertValue( ListInit *LI); convertValue(CodeInit * CI)301 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)302 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)303 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)304 virtual Init *convertValue( DagInit *DI) { return 0; } convertValue(UnOpInit * UI)305 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)306 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)307 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 308 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)309 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)310 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 311 312 std::string getAsString() const; 313 typeIsConvertibleTo(const RecTy * RHS)314 bool typeIsConvertibleTo(const RecTy *RHS) const { 315 return RHS->baseClassOf(this); 316 } 317 baseClassOf(const BitRecTy * RHS)318 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOf(const BitsRecTy * RHS)319 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOf(const IntRecTy * RHS)320 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOf(const StringRecTy * RHS)321 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)322 virtual bool baseClassOf(const ListRecTy *RHS) const { 323 return RHS->getElementType()->typeIsConvertibleTo(Ty); 324 } baseClassOf(const CodeRecTy * RHS)325 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)326 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)327 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 328 }; 329 330 /// CodeRecTy - 'code' - Represent an code fragment, function or method. 331 /// 332 class CodeRecTy : public RecTy { 333 public: convertValue(UnsetInit * UI)334 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)335 virtual Init *convertValue( BitInit *BI) { return 0; } convertValue(BitsInit * BI)336 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValue(IntInit * II)337 virtual Init *convertValue( IntInit *II) { return 0; } convertValue(StringInit * SI)338 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)339 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)340 virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; } convertValue(VarBitInit * VB)341 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)342 virtual Init *convertValue( DefInit *DI) { return 0; } convertValue(DagInit * DI)343 virtual Init *convertValue( DagInit *DI) { return 0; } convertValue(UnOpInit * UI)344 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)345 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)346 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 347 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)348 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)349 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 350 getAsString()351 std::string getAsString() const { return "code"; } 352 typeIsConvertibleTo(const RecTy * RHS)353 bool typeIsConvertibleTo(const RecTy *RHS) const { 354 return RHS->baseClassOf(this); 355 } baseClassOf(const BitRecTy * RHS)356 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOf(const BitsRecTy * RHS)357 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOf(const IntRecTy * RHS)358 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOf(const StringRecTy * RHS)359 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)360 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)361 virtual bool baseClassOf(const CodeRecTy *RHS) const { return true; } baseClassOf(const DagRecTy * RHS)362 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } baseClassOf(const RecordRecTy * RHS)363 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 364 }; 365 366 /// DagRecTy - 'dag' - Represent a dag fragment 367 /// 368 class DagRecTy : public RecTy { 369 public: convertValue(UnsetInit * UI)370 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)371 virtual Init *convertValue( BitInit *BI) { return 0; } convertValue(BitsInit * BI)372 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValue(IntInit * II)373 virtual Init *convertValue( IntInit *II) { return 0; } convertValue(StringInit * SI)374 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)375 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)376 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)377 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(DefInit * DI)378 virtual Init *convertValue( DefInit *DI) { return 0; } 379 virtual Init *convertValue( UnOpInit *BO); 380 virtual Init *convertValue( BinOpInit *BO); convertValue(TernOpInit * BO)381 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);} convertValue(DagInit * CI)382 virtual Init *convertValue( DagInit *CI) { return (Init*)CI; } 383 virtual Init *convertValue( TypedInit *TI); convertValue(VarInit * VI)384 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)385 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 386 getAsString()387 std::string getAsString() const { return "dag"; } 388 typeIsConvertibleTo(const RecTy * RHS)389 bool typeIsConvertibleTo(const RecTy *RHS) const { 390 return RHS->baseClassOf(this); 391 } 392 baseClassOf(const BitRecTy * RHS)393 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOf(const BitsRecTy * RHS)394 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOf(const IntRecTy * RHS)395 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOf(const StringRecTy * RHS)396 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)397 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)398 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)399 virtual bool baseClassOf(const DagRecTy *RHS) const { return true; } baseClassOf(const RecordRecTy * RHS)400 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; } 401 }; 402 403 404 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as: 405 /// (R32 X = EAX). 406 /// 407 class RecordRecTy : public RecTy { 408 Record *Rec; 409 public: RecordRecTy(Record * R)410 explicit RecordRecTy(Record *R) : Rec(R) {} 411 getRecord()412 Record *getRecord() const { return Rec; } 413 convertValue(UnsetInit * UI)414 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } convertValue(BitInit * BI)415 virtual Init *convertValue( BitInit *BI) { return 0; } convertValue(BitsInit * BI)416 virtual Init *convertValue( BitsInit *BI) { return 0; } convertValue(IntInit * II)417 virtual Init *convertValue( IntInit *II) { return 0; } convertValue(StringInit * SI)418 virtual Init *convertValue(StringInit *SI) { return 0; } convertValue(ListInit * LI)419 virtual Init *convertValue( ListInit *LI) { return 0; } convertValue(CodeInit * CI)420 virtual Init *convertValue( CodeInit *CI) { return 0; } convertValue(VarBitInit * VB)421 virtual Init *convertValue(VarBitInit *VB) { return 0; } convertValue(UnOpInit * UI)422 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} convertValue(BinOpInit * UI)423 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} convertValue(TernOpInit * UI)424 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} 425 virtual Init *convertValue( DefInit *DI); convertValue(DagInit * DI)426 virtual Init *convertValue( DagInit *DI) { return 0; } 427 virtual Init *convertValue( TypedInit *VI); convertValue(VarInit * VI)428 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} convertValue(FieldInit * FI)429 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} 430 431 std::string getAsString() const; 432 typeIsConvertibleTo(const RecTy * RHS)433 bool typeIsConvertibleTo(const RecTy *RHS) const { 434 return RHS->baseClassOf(this); 435 } baseClassOf(const BitRecTy * RHS)436 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; } baseClassOf(const BitsRecTy * RHS)437 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; } baseClassOf(const IntRecTy * RHS)438 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; } baseClassOf(const StringRecTy * RHS)439 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; } baseClassOf(const ListRecTy * RHS)440 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; } baseClassOf(const CodeRecTy * RHS)441 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; } baseClassOf(const DagRecTy * RHS)442 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; } 443 virtual bool baseClassOf(const RecordRecTy *RHS) const; 444 }; 445 446 /// resolveTypes - Find a common type that T1 and T2 convert to. 447 /// Return 0 if no such type exists. 448 /// 449 RecTy *resolveTypes(RecTy *T1, RecTy *T2); 450 451 //===----------------------------------------------------------------------===// 452 // Initializer Classes 453 //===----------------------------------------------------------------------===// 454 455 struct Init { ~InitInit456 virtual ~Init() {} 457 458 /// isComplete - This virtual method should be overridden by values that may 459 /// not be completely specified yet. isCompleteInit460 virtual bool isComplete() const { return true; } 461 462 /// print - Print out this value. printInit463 void print(raw_ostream &OS) const { OS << getAsString(); } 464 465 /// getAsString - Convert this value to a string form. 466 virtual std::string getAsString() const = 0; 467 468 /// dump - Debugging method that may be called through a debugger, just 469 /// invokes print on stderr. 470 void dump() const; 471 472 /// convertInitializerTo - This virtual function is a simple call-back 473 /// function that should be overridden to call the appropriate 474 /// RecTy::convertValue method. 475 /// 476 virtual Init *convertInitializerTo(RecTy *Ty) = 0; 477 478 /// convertInitializerBitRange - This method is used to implement the bitrange 479 /// selection operator. Given an initializer, it selects the specified bits 480 /// out, returning them as a new init of bits type. If it is not legal to use 481 /// the bit subscript operator on this initializer, return null. 482 /// convertInitializerBitRangeInit483 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) { 484 return 0; 485 } 486 487 /// convertInitListSlice - This method is used to implement the list slice 488 /// selection operator. Given an initializer, it selects the specified list 489 /// elements, returning them as a new init of list type. If it is not legal 490 /// to take a slice of this, return null. 491 /// convertInitListSliceInit492 virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements) { 493 return 0; 494 } 495 496 /// getFieldType - This method is used to implement the FieldInit class. 497 /// Implementors of this method should return the type of the named field if 498 /// they are of record type. 499 /// getFieldTypeInit500 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; } 501 502 /// getFieldInit - This method complements getFieldType to return the 503 /// initializer for the specified field. If getFieldType returns non-null 504 /// this method should return non-null, otherwise it returns null. 505 /// getFieldInitInit506 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 507 const std::string &FieldName) const { 508 return 0; 509 } 510 511 /// resolveReferences - This method is used by classes that refer to other 512 /// variables which may not be defined at the time the expression is formed. 513 /// If a value is set for the variable later, this method will be called on 514 /// users of the value to allow the value to propagate out. 515 /// resolveReferencesInit516 virtual Init *resolveReferences(Record &R, const RecordVal *RV) { 517 return this; 518 } 519 }; 520 521 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) { 522 I.print(OS); return OS; 523 } 524 525 /// TypedInit - This is the common super-class of types that have a specific, 526 /// explicit, type. 527 /// 528 class TypedInit : public Init { 529 RecTy *Ty; 530 public: TypedInit(RecTy * T)531 explicit TypedInit(RecTy *T) : Ty(T) {} 532 getType()533 RecTy *getType() const { return Ty; } 534 535 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 536 virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements); 537 538 /// getFieldType - This method is used to implement the FieldInit class. 539 /// Implementors of this method should return the type of the named field if 540 /// they are of record type. 541 /// 542 virtual RecTy *getFieldType(const std::string &FieldName) const; 543 544 /// resolveBitReference - This method is used to implement 545 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 546 /// simply return the resolved value, otherwise we return null. 547 /// 548 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 549 unsigned Bit) = 0; 550 551 /// resolveListElementReference - This method is used to implement 552 /// VarListElementInit::resolveReferences. If the list element is resolvable 553 /// now, we return the resolved value, otherwise we return null. 554 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 555 unsigned Elt) = 0; 556 }; 557 558 559 /// UnsetInit - ? - Represents an uninitialized value 560 /// 561 class UnsetInit : public Init { 562 public: convertInitializerTo(RecTy * Ty)563 virtual Init *convertInitializerTo(RecTy *Ty) { 564 return Ty->convertValue(this); 565 } 566 isComplete()567 virtual bool isComplete() const { return false; } getAsString()568 virtual std::string getAsString() const { return "?"; } 569 }; 570 571 572 /// BitInit - true/false - Represent a concrete initializer for a bit. 573 /// 574 class BitInit : public Init { 575 bool Value; 576 public: BitInit(bool V)577 explicit BitInit(bool V) : Value(V) {} 578 getValue()579 bool getValue() const { return Value; } 580 convertInitializerTo(RecTy * Ty)581 virtual Init *convertInitializerTo(RecTy *Ty) { 582 return Ty->convertValue(this); 583 } 584 getAsString()585 virtual std::string getAsString() const { return Value ? "1" : "0"; } 586 }; 587 588 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value. 589 /// It contains a vector of bits, whose size is determined by the type. 590 /// 591 class BitsInit : public Init { 592 std::vector<Init*> Bits; 593 public: BitsInit(unsigned Size)594 explicit BitsInit(unsigned Size) : Bits(Size) {} 595 getNumBits()596 unsigned getNumBits() const { return Bits.size(); } 597 getBit(unsigned Bit)598 Init *getBit(unsigned Bit) const { 599 assert(Bit < Bits.size() && "Bit index out of range!"); 600 return Bits[Bit]; 601 } setBit(unsigned Bit,Init * V)602 void setBit(unsigned Bit, Init *V) { 603 assert(Bit < Bits.size() && "Bit index out of range!"); 604 assert(Bits[Bit] == 0 && "Bit already set!"); 605 Bits[Bit] = V; 606 } 607 convertInitializerTo(RecTy * Ty)608 virtual Init *convertInitializerTo(RecTy *Ty) { 609 return Ty->convertValue(this); 610 } 611 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 612 isComplete()613 virtual bool isComplete() const { 614 for (unsigned i = 0; i != getNumBits(); ++i) 615 if (!getBit(i)->isComplete()) return false; 616 return true; 617 } allInComplete()618 bool allInComplete() const { 619 for (unsigned i = 0; i != getNumBits(); ++i) 620 if (getBit(i)->isComplete()) return false; 621 return true; 622 } 623 virtual std::string getAsString() const; 624 625 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 626 }; 627 628 629 /// IntInit - 7 - Represent an initalization by a literal integer value. 630 /// 631 class IntInit : public TypedInit { 632 int64_t Value; 633 public: IntInit(int64_t V)634 explicit IntInit(int64_t V) : TypedInit(new IntRecTy), Value(V) {} 635 getValue()636 int64_t getValue() const { return Value; } 637 convertInitializerTo(RecTy * Ty)638 virtual Init *convertInitializerTo(RecTy *Ty) { 639 return Ty->convertValue(this); 640 } 641 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 642 643 virtual std::string getAsString() const; 644 645 /// resolveBitReference - This method is used to implement 646 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 647 /// simply return the resolved value, otherwise we return null. 648 /// resolveBitReference(Record & R,const RecordVal * RV,unsigned Bit)649 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 650 unsigned Bit) { 651 assert(0 && "Illegal bit reference off int"); 652 return 0; 653 } 654 655 /// resolveListElementReference - This method is used to implement 656 /// VarListElementInit::resolveReferences. If the list element is resolvable 657 /// now, we return the resolved value, otherwise we return null. resolveListElementReference(Record & R,const RecordVal * RV,unsigned Elt)658 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 659 unsigned Elt) { 660 assert(0 && "Illegal element reference off int"); 661 return 0; 662 } 663 }; 664 665 666 /// StringInit - "foo" - Represent an initialization by a string value. 667 /// 668 class StringInit : public TypedInit { 669 std::string Value; 670 public: StringInit(const std::string & V)671 explicit StringInit(const std::string &V) 672 : TypedInit(new StringRecTy), Value(V) {} 673 getValue()674 const std::string &getValue() const { return Value; } 675 convertInitializerTo(RecTy * Ty)676 virtual Init *convertInitializerTo(RecTy *Ty) { 677 return Ty->convertValue(this); 678 } 679 getAsString()680 virtual std::string getAsString() const { return "\"" + Value + "\""; } 681 682 /// resolveBitReference - This method is used to implement 683 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 684 /// simply return the resolved value, otherwise we return null. 685 /// resolveBitReference(Record & R,const RecordVal * RV,unsigned Bit)686 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 687 unsigned Bit) { 688 assert(0 && "Illegal bit reference off string"); 689 return 0; 690 } 691 692 /// resolveListElementReference - This method is used to implement 693 /// VarListElementInit::resolveReferences. If the list element is resolvable 694 /// now, we return the resolved value, otherwise we return null. resolveListElementReference(Record & R,const RecordVal * RV,unsigned Elt)695 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 696 unsigned Elt) { 697 assert(0 && "Illegal element reference off string"); 698 return 0; 699 } 700 }; 701 702 /// CodeInit - "[{...}]" - Represent a code fragment. 703 /// 704 class CodeInit : public Init { 705 std::string Value; 706 public: CodeInit(const std::string & V)707 explicit CodeInit(const std::string &V) : Value(V) {} 708 getValue()709 const std::string getValue() const { return Value; } 710 convertInitializerTo(RecTy * Ty)711 virtual Init *convertInitializerTo(RecTy *Ty) { 712 return Ty->convertValue(this); 713 } 714 getAsString()715 virtual std::string getAsString() const { return "[{" + Value + "}]"; } 716 }; 717 718 /// ListInit - [AL, AH, CL] - Represent a list of defs 719 /// 720 class ListInit : public TypedInit { 721 std::vector<Init*> Values; 722 public: 723 typedef std::vector<Init*>::iterator iterator; 724 typedef std::vector<Init*>::const_iterator const_iterator; 725 ListInit(std::vector<Init * > & Vs,RecTy * EltTy)726 explicit ListInit(std::vector<Init*> &Vs, RecTy *EltTy) 727 : TypedInit(new ListRecTy(EltTy)) { 728 Values.swap(Vs); 729 } ListInit(iterator Start,iterator End,RecTy * EltTy)730 explicit ListInit(iterator Start, iterator End, RecTy *EltTy) 731 : TypedInit(new ListRecTy(EltTy)), Values(Start, End) {} 732 getSize()733 unsigned getSize() const { return Values.size(); } getElement(unsigned i)734 Init *getElement(unsigned i) const { 735 assert(i < Values.size() && "List element index out of range!"); 736 return Values[i]; 737 } 738 739 Record *getElementAsRecord(unsigned i) const; 740 741 Init *convertInitListSlice(const std::vector<unsigned> &Elements); 742 convertInitializerTo(RecTy * Ty)743 virtual Init *convertInitializerTo(RecTy *Ty) { 744 return Ty->convertValue(this); 745 } 746 747 /// resolveReferences - This method is used by classes that refer to other 748 /// variables which may not be defined at the time they expression is formed. 749 /// If a value is set for the variable later, this method will be called on 750 /// users of the value to allow the value to propagate out. 751 /// 752 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 753 754 virtual std::string getAsString() const; 755 begin()756 inline iterator begin() { return Values.begin(); } begin()757 inline const_iterator begin() const { return Values.begin(); } end()758 inline iterator end () { return Values.end(); } end()759 inline const_iterator end () const { return Values.end(); } 760 size()761 inline size_t size () const { return Values.size(); } empty()762 inline bool empty() const { return Values.empty(); } 763 764 /// resolveBitReference - This method is used to implement 765 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 766 /// simply return the resolved value, otherwise we return null. 767 /// resolveBitReference(Record & R,const RecordVal * RV,unsigned Bit)768 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 769 unsigned Bit) { 770 assert(0 && "Illegal bit reference off list"); 771 return 0; 772 } 773 774 /// resolveListElementReference - This method is used to implement 775 /// VarListElementInit::resolveReferences. If the list element is resolvable 776 /// now, we return the resolved value, otherwise we return null. 777 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 778 unsigned Elt); 779 }; 780 781 782 /// OpInit - Base class for operators 783 /// 784 class OpInit : public TypedInit { 785 public: OpInit(RecTy * Type)786 OpInit(RecTy *Type) : TypedInit(Type) {} 787 788 // Clone - Clone this operator, replacing arguments with the new list 789 virtual OpInit *clone(std::vector<Init *> &Operands) = 0; 790 791 virtual int getNumOperands() const = 0; 792 virtual Init *getOperand(int i) = 0; 793 794 // Fold - If possible, fold this to a simpler init. Return this if not 795 // possible to fold. 796 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) = 0; 797 convertInitializerTo(RecTy * Ty)798 virtual Init *convertInitializerTo(RecTy *Ty) { 799 return Ty->convertValue(this); 800 } 801 802 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 803 unsigned Bit); 804 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 805 unsigned Elt); 806 }; 807 808 809 /// UnOpInit - !op (X) - Transform an init. 810 /// 811 class UnOpInit : public OpInit { 812 public: 813 enum UnaryOp { CAST, CAR, CDR, LNULL }; 814 private: 815 UnaryOp Opc; 816 Init *LHS; 817 public: UnOpInit(UnaryOp opc,Init * lhs,RecTy * Type)818 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) : 819 OpInit(Type), Opc(opc), LHS(lhs) { 820 } 821 822 // Clone - Clone this operator, replacing arguments with the new list clone(std::vector<Init * > & Operands)823 virtual OpInit *clone(std::vector<Init *> &Operands) { 824 assert(Operands.size() == 1 && 825 "Wrong number of operands for unary operation"); 826 return new UnOpInit(getOpcode(), *Operands.begin(), getType()); 827 } 828 getNumOperands()829 int getNumOperands() const { return 1; } getOperand(int i)830 Init *getOperand(int i) { 831 assert(i == 0 && "Invalid operand id for unary operator"); 832 return getOperand(); 833 } 834 getOpcode()835 UnaryOp getOpcode() const { return Opc; } getOperand()836 Init *getOperand() const { return LHS; } 837 838 // Fold - If possible, fold this to a simpler init. Return this if not 839 // possible to fold. 840 Init *Fold(Record *CurRec, MultiClass *CurMultiClass); 841 842 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 843 844 virtual std::string getAsString() const; 845 }; 846 847 /// BinOpInit - !op (X, Y) - Combine two inits. 848 /// 849 class BinOpInit : public OpInit { 850 public: 851 enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, NAMECONCAT, EQ }; 852 private: 853 BinaryOp Opc; 854 Init *LHS, *RHS; 855 public: BinOpInit(BinaryOp opc,Init * lhs,Init * rhs,RecTy * Type)856 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : 857 OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) { 858 } 859 860 // Clone - Clone this operator, replacing arguments with the new list clone(std::vector<Init * > & Operands)861 virtual OpInit *clone(std::vector<Init *> &Operands) { 862 assert(Operands.size() == 2 && 863 "Wrong number of operands for binary operation"); 864 return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType()); 865 } 866 getNumOperands()867 int getNumOperands() const { return 2; } getOperand(int i)868 Init *getOperand(int i) { 869 assert((i == 0 || i == 1) && "Invalid operand id for binary operator"); 870 if (i == 0) { 871 return getLHS(); 872 } else { 873 return getRHS(); 874 } 875 } 876 getOpcode()877 BinaryOp getOpcode() const { return Opc; } getLHS()878 Init *getLHS() const { return LHS; } getRHS()879 Init *getRHS() const { return RHS; } 880 881 // Fold - If possible, fold this to a simpler init. Return this if not 882 // possible to fold. 883 Init *Fold(Record *CurRec, MultiClass *CurMultiClass); 884 885 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 886 887 virtual std::string getAsString() const; 888 }; 889 890 /// TernOpInit - !op (X, Y, Z) - Combine two inits. 891 /// 892 class TernOpInit : public OpInit { 893 public: 894 enum TernaryOp { SUBST, FOREACH, IF }; 895 private: 896 TernaryOp Opc; 897 Init *LHS, *MHS, *RHS; 898 public: TernOpInit(TernaryOp opc,Init * lhs,Init * mhs,Init * rhs,RecTy * Type)899 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type) : 900 OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) { 901 } 902 903 // Clone - Clone this operator, replacing arguments with the new list clone(std::vector<Init * > & Operands)904 virtual OpInit *clone(std::vector<Init *> &Operands) { 905 assert(Operands.size() == 3 && 906 "Wrong number of operands for ternary operation"); 907 return new TernOpInit(getOpcode(), Operands[0], Operands[1], Operands[2], 908 getType()); 909 } 910 getNumOperands()911 int getNumOperands() const { return 3; } getOperand(int i)912 Init *getOperand(int i) { 913 assert((i == 0 || i == 1 || i == 2) && 914 "Invalid operand id for ternary operator"); 915 if (i == 0) { 916 return getLHS(); 917 } else if (i == 1) { 918 return getMHS(); 919 } else { 920 return getRHS(); 921 } 922 } 923 getOpcode()924 TernaryOp getOpcode() const { return Opc; } getLHS()925 Init *getLHS() const { return LHS; } getMHS()926 Init *getMHS() const { return MHS; } getRHS()927 Init *getRHS() const { return RHS; } 928 929 // Fold - If possible, fold this to a simpler init. Return this if not 930 // possible to fold. 931 Init *Fold(Record *CurRec, MultiClass *CurMultiClass); 932 933 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 934 935 virtual std::string getAsString() const; 936 }; 937 938 939 /// VarInit - 'Opcode' - Represent a reference to an entire variable object. 940 /// 941 class VarInit : public TypedInit { 942 std::string VarName; 943 public: VarInit(const std::string & VN,RecTy * T)944 explicit VarInit(const std::string &VN, RecTy *T) 945 : TypedInit(T), VarName(VN) {} 946 convertInitializerTo(RecTy * Ty)947 virtual Init *convertInitializerTo(RecTy *Ty) { 948 return Ty->convertValue(this); 949 } 950 getName()951 const std::string &getName() const { return VarName; } 952 953 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 954 unsigned Bit); 955 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 956 unsigned Elt); 957 958 virtual RecTy *getFieldType(const std::string &FieldName) const; 959 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 960 const std::string &FieldName) const; 961 962 /// resolveReferences - This method is used by classes that refer to other 963 /// variables which may not be defined at the time they expression is formed. 964 /// If a value is set for the variable later, this method will be called on 965 /// users of the value to allow the value to propagate out. 966 /// 967 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 968 getAsString()969 virtual std::string getAsString() const { return VarName; } 970 }; 971 972 973 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field. 974 /// 975 class VarBitInit : public Init { 976 TypedInit *TI; 977 unsigned Bit; 978 public: VarBitInit(TypedInit * T,unsigned B)979 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) { 980 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) && 981 ((BitsRecTy*)T->getType())->getNumBits() > B && 982 "Illegal VarBitInit expression!"); 983 } 984 convertInitializerTo(RecTy * Ty)985 virtual Init *convertInitializerTo(RecTy *Ty) { 986 return Ty->convertValue(this); 987 } 988 getVariable()989 TypedInit *getVariable() const { return TI; } getBitNum()990 unsigned getBitNum() const { return Bit; } 991 992 virtual std::string getAsString() const; 993 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 994 }; 995 996 /// VarListElementInit - List[4] - Represent access to one element of a var or 997 /// field. 998 class VarListElementInit : public TypedInit { 999 TypedInit *TI; 1000 unsigned Element; 1001 public: VarListElementInit(TypedInit * T,unsigned E)1002 VarListElementInit(TypedInit *T, unsigned E) 1003 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()), 1004 TI(T), Element(E) { 1005 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) && 1006 "Illegal VarBitInit expression!"); 1007 } 1008 convertInitializerTo(RecTy * Ty)1009 virtual Init *convertInitializerTo(RecTy *Ty) { 1010 return Ty->convertValue(this); 1011 } 1012 getVariable()1013 TypedInit *getVariable() const { return TI; } getElementNum()1014 unsigned getElementNum() const { return Element; } 1015 1016 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1017 unsigned Bit); 1018 1019 /// resolveListElementReference - This method is used to implement 1020 /// VarListElementInit::resolveReferences. If the list element is resolvable 1021 /// now, we return the resolved value, otherwise we return null. 1022 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1023 unsigned Elt); 1024 1025 virtual std::string getAsString() const; 1026 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 1027 }; 1028 1029 /// DefInit - AL - Represent a reference to a 'def' in the description 1030 /// 1031 class DefInit : public TypedInit { 1032 Record *Def; 1033 public: DefInit(Record * D)1034 explicit DefInit(Record *D) : TypedInit(new RecordRecTy(D)), Def(D) {} 1035 convertInitializerTo(RecTy * Ty)1036 virtual Init *convertInitializerTo(RecTy *Ty) { 1037 return Ty->convertValue(this); 1038 } 1039 getDef()1040 Record *getDef() const { return Def; } 1041 1042 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 1043 1044 virtual RecTy *getFieldType(const std::string &FieldName) const; 1045 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 1046 const std::string &FieldName) const; 1047 1048 virtual std::string getAsString() const; 1049 1050 /// resolveBitReference - This method is used to implement 1051 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 1052 /// simply return the resolved value, otherwise we return null. 1053 /// resolveBitReference(Record & R,const RecordVal * RV,unsigned Bit)1054 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1055 unsigned Bit) { 1056 assert(0 && "Illegal bit reference off def"); 1057 return 0; 1058 } 1059 1060 /// resolveListElementReference - This method is used to implement 1061 /// VarListElementInit::resolveReferences. If the list element is resolvable 1062 /// now, we return the resolved value, otherwise we return null. resolveListElementReference(Record & R,const RecordVal * RV,unsigned Elt)1063 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1064 unsigned Elt) { 1065 assert(0 && "Illegal element reference off def"); 1066 return 0; 1067 } 1068 }; 1069 1070 1071 /// FieldInit - X.Y - Represent a reference to a subfield of a variable 1072 /// 1073 class FieldInit : public TypedInit { 1074 Init *Rec; // Record we are referring to 1075 std::string FieldName; // Field we are accessing 1076 public: FieldInit(Init * R,const std::string & FN)1077 FieldInit(Init *R, const std::string &FN) 1078 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) { 1079 assert(getType() && "FieldInit with non-record type!"); 1080 } 1081 convertInitializerTo(RecTy * Ty)1082 virtual Init *convertInitializerTo(RecTy *Ty) { 1083 return Ty->convertValue(this); 1084 } 1085 1086 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1087 unsigned Bit); 1088 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1089 unsigned Elt); 1090 1091 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 1092 getAsString()1093 virtual std::string getAsString() const { 1094 return Rec->getAsString() + "." + FieldName; 1095 } 1096 }; 1097 1098 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required 1099 /// to have at least one value then a (possibly empty) list of arguments. Each 1100 /// argument can have a name associated with it. 1101 /// 1102 class DagInit : public TypedInit { 1103 Init *Val; 1104 std::string ValName; 1105 std::vector<Init*> Args; 1106 std::vector<std::string> ArgNames; 1107 public: DagInit(Init * V,std::string VN,const std::vector<std::pair<Init *,std::string>> & args)1108 DagInit(Init *V, std::string VN, 1109 const std::vector<std::pair<Init*, std::string> > &args) 1110 : TypedInit(new DagRecTy), Val(V), ValName(VN) { 1111 Args.reserve(args.size()); 1112 ArgNames.reserve(args.size()); 1113 for (unsigned i = 0, e = args.size(); i != e; ++i) { 1114 Args.push_back(args[i].first); 1115 ArgNames.push_back(args[i].second); 1116 } 1117 } DagInit(Init * V,std::string VN,const std::vector<Init * > & args,const std::vector<std::string> & argNames)1118 DagInit(Init *V, std::string VN, const std::vector<Init*> &args, 1119 const std::vector<std::string> &argNames) 1120 : TypedInit(new DagRecTy), Val(V), ValName(VN), Args(args), 1121 ArgNames(argNames) { } 1122 convertInitializerTo(RecTy * Ty)1123 virtual Init *convertInitializerTo(RecTy *Ty) { 1124 return Ty->convertValue(this); 1125 } 1126 getOperator()1127 Init *getOperator() const { return Val; } 1128 getName()1129 const std::string &getName() const { return ValName; } 1130 getNumArgs()1131 unsigned getNumArgs() const { return Args.size(); } getArg(unsigned Num)1132 Init *getArg(unsigned Num) const { 1133 assert(Num < Args.size() && "Arg number out of range!"); 1134 return Args[Num]; 1135 } getArgName(unsigned Num)1136 const std::string &getArgName(unsigned Num) const { 1137 assert(Num < ArgNames.size() && "Arg number out of range!"); 1138 return ArgNames[Num]; 1139 } 1140 setArg(unsigned Num,Init * I)1141 void setArg(unsigned Num, Init *I) { 1142 assert(Num < Args.size() && "Arg number out of range!"); 1143 Args[Num] = I; 1144 } 1145 1146 virtual Init *resolveReferences(Record &R, const RecordVal *RV); 1147 1148 virtual std::string getAsString() const; 1149 1150 typedef std::vector<Init*>::iterator arg_iterator; 1151 typedef std::vector<Init*>::const_iterator const_arg_iterator; 1152 typedef std::vector<std::string>::iterator name_iterator; 1153 typedef std::vector<std::string>::const_iterator const_name_iterator; 1154 arg_begin()1155 inline arg_iterator arg_begin() { return Args.begin(); } arg_begin()1156 inline const_arg_iterator arg_begin() const { return Args.begin(); } arg_end()1157 inline arg_iterator arg_end () { return Args.end(); } arg_end()1158 inline const_arg_iterator arg_end () const { return Args.end(); } 1159 arg_size()1160 inline size_t arg_size () const { return Args.size(); } arg_empty()1161 inline bool arg_empty() const { return Args.empty(); } 1162 name_begin()1163 inline name_iterator name_begin() { return ArgNames.begin(); } name_begin()1164 inline const_name_iterator name_begin() const { return ArgNames.begin(); } name_end()1165 inline name_iterator name_end () { return ArgNames.end(); } name_end()1166 inline const_name_iterator name_end () const { return ArgNames.end(); } 1167 name_size()1168 inline size_t name_size () const { return ArgNames.size(); } name_empty()1169 inline bool name_empty() const { return ArgNames.empty(); } 1170 resolveBitReference(Record & R,const RecordVal * RV,unsigned Bit)1171 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1172 unsigned Bit) { 1173 assert(0 && "Illegal bit reference off dag"); 1174 return 0; 1175 } 1176 resolveListElementReference(Record & R,const RecordVal * RV,unsigned Elt)1177 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1178 unsigned Elt) { 1179 assert(0 && "Illegal element reference off dag"); 1180 return 0; 1181 } 1182 }; 1183 1184 //===----------------------------------------------------------------------===// 1185 // High-Level Classes 1186 //===----------------------------------------------------------------------===// 1187 1188 class RecordVal { 1189 std::string Name; 1190 RecTy *Ty; 1191 unsigned Prefix; 1192 Init *Value; 1193 public: 1194 RecordVal(const std::string &N, RecTy *T, unsigned P); 1195 getName()1196 const std::string &getName() const { return Name; } 1197 getPrefix()1198 unsigned getPrefix() const { return Prefix; } getType()1199 RecTy *getType() const { return Ty; } getValue()1200 Init *getValue() const { return Value; } 1201 setValue(Init * V)1202 bool setValue(Init *V) { 1203 if (V) { 1204 Value = V->convertInitializerTo(Ty); 1205 return Value == 0; 1206 } 1207 Value = 0; 1208 return false; 1209 } 1210 1211 void dump() const; 1212 void print(raw_ostream &OS, bool PrintSem = true) const; 1213 }; 1214 1215 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1216 RV.print(OS << " "); 1217 return OS; 1218 } 1219 1220 class Record { 1221 static unsigned LastID; 1222 1223 // Unique record ID. 1224 unsigned ID; 1225 std::string Name; 1226 SMLoc Loc; 1227 std::vector<std::string> TemplateArgs; 1228 std::vector<RecordVal> Values; 1229 std::vector<Record*> SuperClasses; 1230 public: 1231 Record(const std::string & N,SMLoc loc)1232 explicit Record(const std::string &N, SMLoc loc) : 1233 ID(LastID++), Name(N), Loc(loc) {} ~Record()1234 ~Record() {} 1235 1236 getNewUID()1237 static unsigned getNewUID() { return LastID++; } 1238 1239 getID()1240 unsigned getID() const { return ID; } 1241 getName()1242 const std::string &getName() const { return Name; } 1243 void setName(const std::string &Name); // Also updates RecordKeeper. 1244 getLoc()1245 SMLoc getLoc() const { return Loc; } 1246 getTemplateArgs()1247 const std::vector<std::string> &getTemplateArgs() const { 1248 return TemplateArgs; 1249 } getValues()1250 const std::vector<RecordVal> &getValues() const { return Values; } getSuperClasses()1251 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; } 1252 isTemplateArg(StringRef Name)1253 bool isTemplateArg(StringRef Name) const { 1254 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i) 1255 if (TemplateArgs[i] == Name) return true; 1256 return false; 1257 } 1258 getValue(StringRef Name)1259 const RecordVal *getValue(StringRef Name) const { 1260 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1261 if (Values[i].getName() == Name) return &Values[i]; 1262 return 0; 1263 } getValue(StringRef Name)1264 RecordVal *getValue(StringRef Name) { 1265 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1266 if (Values[i].getName() == Name) return &Values[i]; 1267 return 0; 1268 } 1269 addTemplateArg(StringRef Name)1270 void addTemplateArg(StringRef Name) { 1271 assert(!isTemplateArg(Name) && "Template arg already defined!"); 1272 TemplateArgs.push_back(Name); 1273 } 1274 addValue(const RecordVal & RV)1275 void addValue(const RecordVal &RV) { 1276 assert(getValue(RV.getName()) == 0 && "Value already added!"); 1277 Values.push_back(RV); 1278 } 1279 removeValue(StringRef Name)1280 void removeValue(StringRef Name) { 1281 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1282 if (Values[i].getName() == Name) { 1283 Values.erase(Values.begin()+i); 1284 return; 1285 } 1286 assert(0 && "Cannot remove an entry that does not exist!"); 1287 } 1288 isSubClassOf(const Record * R)1289 bool isSubClassOf(const Record *R) const { 1290 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 1291 if (SuperClasses[i] == R) 1292 return true; 1293 return false; 1294 } 1295 isSubClassOf(StringRef Name)1296 bool isSubClassOf(StringRef Name) const { 1297 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 1298 if (SuperClasses[i]->getName() == Name) 1299 return true; 1300 return false; 1301 } 1302 addSuperClass(Record * R)1303 void addSuperClass(Record *R) { 1304 assert(!isSubClassOf(R) && "Already subclassing record!"); 1305 SuperClasses.push_back(R); 1306 } 1307 1308 /// resolveReferences - If there are any field references that refer to fields 1309 /// that have been filled in, we can propagate the values now. 1310 /// resolveReferences()1311 void resolveReferences() { resolveReferencesTo(0); } 1312 1313 /// resolveReferencesTo - If anything in this record refers to RV, replace the 1314 /// reference to RV with the RHS of RV. If RV is null, we resolve all 1315 /// possible references. 1316 void resolveReferencesTo(const RecordVal *RV); 1317 1318 void dump() const; 1319 1320 //===--------------------------------------------------------------------===// 1321 // High-level methods useful to tablegen back-ends 1322 // 1323 1324 /// getValueInit - Return the initializer for a value with the specified name, 1325 /// or throw an exception if the field does not exist. 1326 /// 1327 Init *getValueInit(StringRef FieldName) const; 1328 1329 /// getValueAsString - This method looks up the specified field and returns 1330 /// its value as a string, throwing an exception if the field does not exist 1331 /// or if the value is not a string. 1332 /// 1333 std::string getValueAsString(StringRef FieldName) const; 1334 1335 /// getValueAsBitsInit - This method looks up the specified field and returns 1336 /// its value as a BitsInit, throwing an exception if the field does not exist 1337 /// or if the value is not the right type. 1338 /// 1339 BitsInit *getValueAsBitsInit(StringRef FieldName) const; 1340 1341 /// getValueAsListInit - This method looks up the specified field and returns 1342 /// its value as a ListInit, throwing an exception if the field does not exist 1343 /// or if the value is not the right type. 1344 /// 1345 ListInit *getValueAsListInit(StringRef FieldName) const; 1346 1347 /// getValueAsListOfDefs - This method looks up the specified field and 1348 /// returns its value as a vector of records, throwing an exception if the 1349 /// field does not exist or if the value is not the right type. 1350 /// 1351 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const; 1352 1353 /// getValueAsListOfInts - This method looks up the specified field and returns 1354 /// its value as a vector of integers, throwing an exception if the field does 1355 /// not exist or if the value is not the right type. 1356 /// 1357 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const; 1358 1359 /// getValueAsDef - This method looks up the specified field and returns its 1360 /// value as a Record, throwing an exception if the field does not exist or if 1361 /// the value is not the right type. 1362 /// 1363 Record *getValueAsDef(StringRef FieldName) const; 1364 1365 /// getValueAsBit - This method looks up the specified field and returns its 1366 /// value as a bit, throwing an exception if the field does not exist or if 1367 /// the value is not the right type. 1368 /// 1369 bool getValueAsBit(StringRef FieldName) const; 1370 1371 /// getValueAsInt - This method looks up the specified field and returns its 1372 /// value as an int64_t, throwing an exception if the field does not exist or 1373 /// if the value is not the right type. 1374 /// 1375 int64_t getValueAsInt(StringRef FieldName) const; 1376 1377 /// getValueAsDag - This method looks up the specified field and returns its 1378 /// value as an Dag, throwing an exception if the field does not exist or if 1379 /// the value is not the right type. 1380 /// 1381 DagInit *getValueAsDag(StringRef FieldName) const; 1382 1383 /// getValueAsCode - This method looks up the specified field and returns 1384 /// its value as the string data in a CodeInit, throwing an exception if the 1385 /// field does not exist or if the value is not a code object. 1386 /// 1387 std::string getValueAsCode(StringRef FieldName) const; 1388 }; 1389 1390 raw_ostream &operator<<(raw_ostream &OS, const Record &R); 1391 1392 struct MultiClass { 1393 Record Rec; // Placeholder for template args and Name. 1394 typedef std::vector<Record*> RecordVector; 1395 RecordVector DefPrototypes; 1396 1397 void dump() const; 1398 MultiClassMultiClass1399 MultiClass(const std::string &Name, SMLoc Loc) : Rec(Name, Loc) {} 1400 }; 1401 1402 class RecordKeeper { 1403 std::map<std::string, Record*> Classes, Defs; 1404 public: ~RecordKeeper()1405 ~RecordKeeper() { 1406 for (std::map<std::string, Record*>::iterator I = Classes.begin(), 1407 E = Classes.end(); I != E; ++I) 1408 delete I->second; 1409 for (std::map<std::string, Record*>::iterator I = Defs.begin(), 1410 E = Defs.end(); I != E; ++I) 1411 delete I->second; 1412 } 1413 getClasses()1414 const std::map<std::string, Record*> &getClasses() const { return Classes; } getDefs()1415 const std::map<std::string, Record*> &getDefs() const { return Defs; } 1416 getClass(const std::string & Name)1417 Record *getClass(const std::string &Name) const { 1418 std::map<std::string, Record*>::const_iterator I = Classes.find(Name); 1419 return I == Classes.end() ? 0 : I->second; 1420 } getDef(const std::string & Name)1421 Record *getDef(const std::string &Name) const { 1422 std::map<std::string, Record*>::const_iterator I = Defs.find(Name); 1423 return I == Defs.end() ? 0 : I->second; 1424 } addClass(Record * R)1425 void addClass(Record *R) { 1426 assert(getClass(R->getName()) == 0 && "Class already exists!"); 1427 Classes.insert(std::make_pair(R->getName(), R)); 1428 } addDef(Record * R)1429 void addDef(Record *R) { 1430 assert(getDef(R->getName()) == 0 && "Def already exists!"); 1431 Defs.insert(std::make_pair(R->getName(), R)); 1432 } 1433 1434 /// removeClass - Remove, but do not delete, the specified record. 1435 /// removeClass(const std::string & Name)1436 void removeClass(const std::string &Name) { 1437 assert(Classes.count(Name) && "Class does not exist!"); 1438 Classes.erase(Name); 1439 } 1440 /// removeDef - Remove, but do not delete, the specified record. 1441 /// removeDef(const std::string & Name)1442 void removeDef(const std::string &Name) { 1443 assert(Defs.count(Name) && "Def does not exist!"); 1444 Defs.erase(Name); 1445 } 1446 1447 //===--------------------------------------------------------------------===// 1448 // High-level helper methods, useful for tablegen backends... 1449 1450 /// getAllDerivedDefinitions - This method returns all concrete definitions 1451 /// that derive from the specified class name. If a class with the specified 1452 /// name does not exist, an exception is thrown. 1453 std::vector<Record*> 1454 getAllDerivedDefinitions(const std::string &ClassName) const; 1455 1456 1457 void dump() const; 1458 }; 1459 1460 /// LessRecord - Sorting predicate to sort record pointers by name. 1461 /// 1462 struct LessRecord { operatorLessRecord1463 bool operator()(const Record *Rec1, const Record *Rec2) const { 1464 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0; 1465 } 1466 }; 1467 1468 /// LessRecordFieldName - Sorting predicate to sort record pointers by their 1469 /// name field. 1470 /// 1471 struct LessRecordFieldName { operatorLessRecordFieldName1472 bool operator()(const Record *Rec1, const Record *Rec2) const { 1473 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1474 } 1475 }; 1476 1477 1478 class TGError { 1479 SMLoc Loc; 1480 std::string Message; 1481 public: TGError(SMLoc loc,const std::string & message)1482 TGError(SMLoc loc, const std::string &message) : Loc(loc), Message(message) {} 1483 getLoc()1484 SMLoc getLoc() const { return Loc; } getMessage()1485 const std::string &getMessage() const { return Message; } 1486 }; 1487 1488 1489 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); 1490 1491 extern RecordKeeper Records; 1492 1493 void PrintError(SMLoc ErrorLoc, const std::string &Msg); 1494 1495 } // End llvm namespace 1496 1497 #endif 1498