include/llvm/TableGen/Record.h

   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
  28 namespace llvm {
  29 class raw_ostream;
  30
  31 // RecTy subclasses.
  32 class BitRecTy;
  33 class BitsRecTy;
  34 class IntRecTy;
  35 class StringRecTy;
  36 class ListRecTy;
  37 class DagRecTy;
  38 class RecordRecTy;
  39
  40 // Init subclasses.
  41 class Init;
  42 class UnsetInit;
  43 class BitInit;
  44 class BitsInit;
  45 class IntInit;
  46 class StringInit;
  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 public:
  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
  82 private:
  83   RecTyKind Kind;
  84   ListRecTy *ListTy;
  85   virtual void anchor();
  86
  87 public:
  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
 105 public:   // 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
 132 public:   // 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
 144 inline 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 ///
 152 class BitRecTy : public RecTy {
 153   static BitRecTy Shared;
 154   BitRecTy() : RecTy(BitRecTyKind) {}
 155 public:
 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&lt;n&gt;' - Represent a fixed number of bits
 197 ///
 198 class BitsRecTy : public RecTy {
 199   unsigned Size;
 200   explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
 201 public:
 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 ///
 247 class IntRecTy : public RecTy {
 248   static IntRecTy Shared;
 249   IntRecTy() : RecTy(IntRecTyKind) {}
 250 public:
 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 ///
 292 class StringRecTy : public RecTy {
 293   static StringRecTy Shared;
 294   StringRecTy() : RecTy(StringRecTyKind) {}
 295 public:
 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&lt;Ty&gt;' - Represent a list of values, all of which must
 338 /// be of the specified type.
 339 ///
 340 class ListRecTy : public RecTy {
 341   RecTy *Ty;
 342   explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
 343   friend ListRecTy *RecTy::getListTy();
 344 public:
 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 ///
 388 class DagRecTy : public RecTy {
 389   static DagRecTy Shared;
 390   DagRecTy() : RecTy(DagRecTyKind) {}
 391 public:
 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 ///
 434 class RecordRecTy : public RecTy {
 435   Record *Rec;
 436   explicit RecordRecTy(Record *R) : RecTy(RecordRecTyKind), Rec(R) {}
 437   friend class Record;
 438 public:
 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 ///
 481 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
 482
 483 //===----------------------------------------------------------------------===//
 484 //  Initializer Classes
 485 //===----------------------------------------------------------------------===//
 486
 487 class Init {
 488   Init(const Init &) LLVM_DELETED_FUNCTION;
 489   Init &operator=(const Init &) LLVM_DELETED_FUNCTION;
 490   virtual void anchor();
 491
 492 protected:
 493   Init(void) {}
 494
 495 public:
 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
 580 inline 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 ///
 587 class 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
 593 protected:
 594   explicit TypedInit(RecTy *T) : Ty(T) {}
 595
 596 public:
 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 ///
 620 class 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
 626 public:
 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 ///
 644 class 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
 652 public:
 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 ///
 672 class 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
 680 public:
 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 ///
 716 class 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
 724 public:
 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 ///
 753 class 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
 763 public:
 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 ///
 790 class ListInit : public TypedInit, public FoldingSetNode {
 791   std::vector<Init*> Values;
 792 public:
 793   typedef std::vector<Init*>::const_iterator const_iterator;
 794
 795 private:
 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
 802 public:
 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 ///
 853 class OpInit : public TypedInit {
 854   OpInit(const OpInit &Other) LLVM_DELETED_FUNCTION;
 855   OpInit &operator=(OpInit &Other) LLVM_DELETED_FUNCTION;
 856
 857 protected:
 858   explicit OpInit(RecTy *Type) : TypedInit(Type) {}
 859
 860 public:
 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 ///
 884 class UnOpInit : public OpInit {
 885 public:
 886   enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
 887 private:
 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
 897 public:
 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 ///
 927 class BinOpInit : public OpInit {
 928 public:
 929   enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
 930 private:
 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
 940 public:
 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 ///
 976 class TernOpInit : public OpInit {
 977 public:
 978   enum TernaryOp { SUBST, FOREACH, IF };
 979 private:
 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
 990 public:
 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 ///
1035 class 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
1046 public:
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 ///
1082 class 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            (dynamic_cast<IntRecTy*>(T->getType()) ||
1089             (dynamic_cast<BitsRecTy*>(T->getType()) &&
1090              dynamic_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
1097 public:
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.
1118 class VarListElementInit : public TypedInit {
1119   TypedInit *TI;
1120   unsigned Element;
1121
1122   VarListElementInit(TypedInit *T, unsigned E)
1123       : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1124           TI(T), Element(E) {
1125     assert(T->getType() && dynamic_cast<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
1132 public:
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 ///
1157 class 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
1166 public:
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 ///
1199 class 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
1211 public:
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 ///
1236 class 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
1252 public:
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
1313 class RecordVal {
1314   Init *Name;
1315   RecTy *Ty;
1316   unsigned Prefix;
1317   Init *Value;
1318 public:
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
1345 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1346   RV.print(OS << "  ");
1347   return OS;
1348 }
1349
1350 class 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
1371 public:
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
1593 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1594
1595 struct 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
1606 class RecordKeeper {
1607   std::map<std::string, Record*> Classes, Defs;
1608
1609 public:
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 ///
1668 struct 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.
1678 struct 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 ///
1687 struct LessRecordFieldName {
1688   bool operator()(const Record *Rec1, const Record *Rec2) const {
1689     return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1690   }
1691 };
1692
1693 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1694
1695 /// QualifyName - Return an Init with a qualifier prefix referring
1696 /// to CurRec's name.
1697 Init *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.
1702 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1703                   const std::string &Name, const std::string &Scoper);
1704
1705 } // End llvm namespace
1706
1707 #endif