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