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