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