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