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   std::string VarName;
1062
1063   explicit VarInit(const std::string &VN, RecTy *T)
1064       : TypedInit(T), VarName(VN) {}
1065
1066   VarInit(const VarInit &Other);  // Do not define.
1067   VarInit &operator=(const VarInit &Other);  // Do not define.
1068
1069 public:
1070   static VarInit *get(const std::string &VN, RecTy *T);
1071   static VarInit *get(Init *VN, RecTy *T);
1072
1073   virtual Init *convertInitializerTo(RecTy *Ty) const {
1074     return Ty->convertValue(const_cast<VarInit *>(this));
1075   }
1076
1077   const std::string &getName() const { return VarName; }
1078
1079   virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1080                                     unsigned Bit) const;
1081   virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1082                                             unsigned Elt) const;
1083
1084   virtual RecTy *getFieldType(const std::string &FieldName) const;
1085   virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1086                              const std::string &FieldName) const;
1087
1088   /// resolveReferences - This method is used by classes that refer to other
1089   /// variables which may not be defined at the time they expression is formed.
1090   /// If a value is set for the variable later, this method will be called on
1091   /// users of the value to allow the value to propagate out.
1092   ///
1093   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1094
1095   virtual std::string getAsString() const { return VarName; }
1096 };
1097
1098
1099 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
1100 ///
1101 class VarBitInit : public Init {
1102   TypedInit *TI;
1103   unsigned Bit;
1104
1105   VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
1106     assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
1107            ((BitsRecTy*)T->getType())->getNumBits() > B &&
1108            "Illegal VarBitInit expression!");
1109   }
1110
1111   VarBitInit(const VarBitInit &Other);  // Do not define.
1112   VarBitInit &operator=(const VarBitInit &Other);  // Do not define.
1113
1114 public:
1115   static VarBitInit *get(TypedInit *T, unsigned B);
1116
1117   virtual Init *convertInitializerTo(RecTy *Ty) const {
1118     return Ty->convertValue(const_cast<VarBitInit *>(this));
1119   }
1120
1121   TypedInit *getVariable() const { return TI; }
1122   unsigned getBitNum() const { return Bit; }
1123
1124   virtual std::string getAsString() const;
1125   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1126 };
1127
1128 /// VarListElementInit - List[4] - Represent access to one element of a var or
1129 /// field.
1130 class VarListElementInit : public TypedInit {
1131   TypedInit *TI;
1132   unsigned Element;
1133
1134   VarListElementInit(TypedInit *T, unsigned E)
1135       : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1136           TI(T), Element(E) {
1137     assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
1138            "Illegal VarBitInit expression!");
1139   }
1140
1141   VarListElementInit(const VarListElementInit &Other);  // Do not define.
1142   VarListElementInit &operator=(const VarListElementInit &Other);  // Do
1143                                                                    // not
1144                                                                    // define.
1145
1146 public:
1147   static VarListElementInit *get(TypedInit *T, unsigned E);
1148
1149   virtual Init *convertInitializerTo(RecTy *Ty) const {
1150     return Ty->convertValue(const_cast<VarListElementInit *>(this));
1151   }
1152
1153   TypedInit *getVariable() const { return TI; }
1154   unsigned getElementNum() const { return Element; }
1155
1156   virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1157                                     unsigned Bit) const;
1158
1159   /// resolveListElementReference - This method is used to implement
1160   /// VarListElementInit::resolveReferences.  If the list element is resolvable
1161   /// now, we return the resolved value, otherwise we return null.
1162   virtual Init *resolveListElementReference(Record &R,
1163                                             const RecordVal *RV,
1164                                             unsigned Elt) const;
1165
1166   virtual std::string getAsString() const;
1167   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1168 };
1169
1170 /// DefInit - AL - Represent a reference to a 'def' in the description
1171 ///
1172 class DefInit : public TypedInit {
1173   Record *Def;
1174
1175   DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {}
1176   friend class Record;
1177
1178   DefInit(const DefInit &Other);  // Do not define.
1179   DefInit &operator=(const DefInit &Other);  // Do not define.
1180
1181 public:
1182   static DefInit *get(Record*);
1183
1184   virtual Init *convertInitializerTo(RecTy *Ty) const {
1185     return Ty->convertValue(const_cast<DefInit *>(this));
1186   }
1187
1188   Record *getDef() const { return Def; }
1189
1190   //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
1191
1192   virtual RecTy *getFieldType(const std::string &FieldName) const;
1193   virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1194                              const std::string &FieldName) const;
1195
1196   virtual std::string getAsString() const;
1197
1198   /// resolveBitReference - This method is used to implement
1199   /// VarBitInit::resolveReferences.  If the bit is able to be resolved, we
1200   /// simply return the resolved value, otherwise we return null.
1201   ///
1202   virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1203                                     unsigned Bit) const {
1204     assert(0 && "Illegal bit reference off def");
1205     return 0;
1206   }
1207
1208   /// resolveListElementReference - This method is used to implement
1209   /// VarListElementInit::resolveReferences.  If the list element is resolvable
1210   /// now, we return the resolved value, otherwise we return null.
1211   virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1212                                             unsigned Elt) const {
1213     assert(0 && "Illegal element reference off def");
1214     return 0;
1215   }
1216 };
1217
1218
1219 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
1220 ///
1221 class FieldInit : public TypedInit {
1222   Init *Rec;                // Record we are referring to
1223   std::string FieldName;    // Field we are accessing
1224
1225   FieldInit(Init *R, const std::string &FN)
1226       : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
1227     assert(getType() && "FieldInit with non-record type!");
1228   }
1229
1230   FieldInit(const FieldInit &Other);  // Do not define.
1231   FieldInit &operator=(const FieldInit &Other);  // Do not define.
1232
1233 public:
1234   static FieldInit *get(Init *R, const std::string &FN);
1235   static FieldInit *get(Init *R, const Init *FN);
1236
1237   virtual Init *convertInitializerTo(RecTy *Ty) const {
1238     return Ty->convertValue(const_cast<FieldInit *>(this));
1239   }
1240
1241   virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1242                                     unsigned Bit) const;
1243   virtual Init *resolveListElementReference(Record &R,
1244                                             const RecordVal *RV,
1245                                             unsigned Elt) const;
1246
1247   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1248
1249   virtual std::string getAsString() const {
1250     return Rec->getAsString() + "." + FieldName;
1251   }
1252 };
1253
1254 /// DagInit - (v a, b) - Represent a DAG tree value.  DAG inits are required
1255 /// to have at least one value then a (possibly empty) list of arguments.  Each
1256 /// argument can have a name associated with it.
1257 ///
1258 class DagInit : public TypedInit, public FoldingSetNode {
1259   Init *Val;
1260   std::string ValName;
1261   std::vector<Init*> Args;
1262   std::vector<std::string> ArgNames;
1263
1264   DagInit(Init *V, const std::string &VN,
1265           ArrayRef<Init *> ArgRange,
1266           ArrayRef<std::string> NameRange)
1267       : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
1268           Args(ArgRange.begin(), ArgRange.end()),
1269           ArgNames(NameRange.begin(), NameRange.end()) {}
1270
1271   DagInit(const DagInit &Other);  // Do not define.
1272   DagInit &operator=(const DagInit &Other);  // Do not define.
1273
1274 public:
1275   static DagInit *get(Init *V, const std::string &VN,
1276                       ArrayRef<Init *> ArgRange,
1277                       ArrayRef<std::string> NameRange);
1278   static DagInit *get(Init *V, const std::string &VN,
1279                       const std::vector<
1280                         std::pair<Init*, std::string> > &args);
1281
1282   void Profile(FoldingSetNodeID &ID) const;
1283
1284   virtual Init *convertInitializerTo(RecTy *Ty) const {
1285     return Ty->convertValue(const_cast<DagInit *>(this));
1286   }
1287
1288   Init *getOperator() const { return Val; }
1289
1290   const std::string &getName() const { return ValName; }
1291
1292   unsigned getNumArgs() const { return Args.size(); }
1293   Init *getArg(unsigned Num) const {
1294     assert(Num < Args.size() && "Arg number out of range!");
1295     return Args[Num];
1296   }
1297   const std::string &getArgName(unsigned Num) const {
1298     assert(Num < ArgNames.size() && "Arg number out of range!");
1299     return ArgNames[Num];
1300   }
1301
1302   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1303
1304   virtual std::string getAsString() const;
1305
1306   typedef std::vector<Init*>::const_iterator       const_arg_iterator;
1307   typedef std::vector<std::string>::const_iterator const_name_iterator;
1308
1309   inline const_arg_iterator  arg_begin() const { return Args.begin(); }
1310   inline const_arg_iterator  arg_end  () const { return Args.end();   }
1311
1312   inline size_t              arg_size () const { return Args.size();  }
1313   inline bool                arg_empty() const { return Args.empty(); }
1314
1315   inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1316   inline const_name_iterator name_end  () const { return ArgNames.end();   }
1317
1318   inline size_t              name_size () const { return ArgNames.size();  }
1319   inline bool                name_empty() const { return ArgNames.empty(); }
1320
1321   virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1322                                     unsigned Bit) const {
1323     assert(0 && "Illegal bit reference off dag");
1324     return 0;
1325   }
1326
1327   virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1328                                             unsigned Elt) const {
1329     assert(0 && "Illegal element reference off dag");
1330     return 0;
1331   }
1332 };
1333
1334 //===----------------------------------------------------------------------===//
1335 //  High-Level Classes
1336 //===----------------------------------------------------------------------===//
1337
1338 class RecordVal {
1339   Init *Name;
1340   RecTy *Ty;
1341   unsigned Prefix;
1342   Init *Value;
1343 public:
1344   RecordVal(Init *N, RecTy *T, unsigned P);
1345   RecordVal(const std::string &N, RecTy *T, unsigned P);
1346
1347   const std::string &getName() const;
1348   const Init *getNameInit() const { return Name; }
1349   std::string getNameInitAsString() const {
1350     return getNameInit()->getAsUnquotedString();
1351   }
1352
1353   unsigned getPrefix() const { return Prefix; }
1354   RecTy *getType() const { return Ty; }
1355   Init *getValue() const { return Value; }
1356
1357   bool setValue(Init *V) {
1358     if (V) {
1359       Value = V->convertInitializerTo(Ty);
1360       return Value == 0;
1361     }
1362     Value = 0;
1363     return false;
1364   }
1365
1366   void dump() const;
1367   void print(raw_ostream &OS, bool PrintSem = true) const;
1368 };
1369
1370 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1371   RV.print(OS << "  ");
1372   return OS;
1373 }
1374
1375 class Record {
1376   static unsigned LastID;
1377
1378   // Unique record ID.
1379   unsigned ID;
1380   Init *Name;
1381   SMLoc Loc;
1382   std::vector<std::string> TemplateArgs;
1383   std::vector<RecordVal> Values;
1384   std::vector<Record*> SuperClasses;
1385
1386   // Tracks Record instances. Not owned by Record.
1387   RecordKeeper &TrackedRecords;
1388
1389   DefInit *TheInit;
1390
1391   void checkName();
1392
1393 public:
1394
1395   // Constructs a record.
1396   explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) :
1397     ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records), TheInit(0) {}
1398   ~Record() {}
1399
1400
1401   static unsigned getNewUID() { return LastID++; }
1402
1403
1404   unsigned getID() const { return ID; }
1405
1406   const std::string &getName() const;
1407   Init *getNameInit() const {
1408     return Name;
1409   }
1410   const std::string getNameInitAsString() const {
1411     return getNameInit()->getAsUnquotedString();
1412   }
1413
1414   void setName(Init *Name);               // Also updates RecordKeeper.
1415   void setName(const std::string &Name);  // Also updates RecordKeeper.
1416
1417   SMLoc getLoc() const { return Loc; }
1418
1419   /// get the corresponding DefInit.
1420   DefInit *getDefInit();
1421
1422   const std::vector<std::string> &getTemplateArgs() const {
1423     return TemplateArgs;
1424   }
1425   const std::vector<RecordVal> &getValues() const { return Values; }
1426   const std::vector<Record*>   &getSuperClasses() const { return SuperClasses; }
1427
1428   bool isTemplateArg(StringRef Name) const {
1429     for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
1430       if (TemplateArgs[i] == Name) return true;
1431     return false;
1432   }
1433
1434   const RecordVal *getValue(StringRef Name) const {
1435     for (unsigned i = 0, e = Values.size(); i != e; ++i)
1436       if (Values[i].getName() == Name) return &Values[i];
1437     return 0;
1438   }
1439   RecordVal *getValue(StringRef Name) {
1440     for (unsigned i = 0, e = Values.size(); i != e; ++i)
1441       if (Values[i].getName() == Name) return &Values[i];
1442     return 0;
1443   }
1444
1445   void addTemplateArg(StringRef Name) {
1446     assert(!isTemplateArg(Name) && "Template arg already defined!");
1447     TemplateArgs.push_back(Name);
1448   }
1449
1450   void addValue(const RecordVal &RV) {
1451     assert(getValue(RV.getName()) == 0 && "Value already added!");
1452     Values.push_back(RV);
1453   }
1454
1455   void removeValue(StringRef Name) {
1456     for (unsigned i = 0, e = Values.size(); i != e; ++i)
1457       if (Values[i].getName() == Name) {
1458         Values.erase(Values.begin()+i);
1459         return;
1460       }
1461     assert(0 && "Cannot remove an entry that does not exist!");
1462   }
1463
1464   bool isSubClassOf(const Record *R) const {
1465     for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1466       if (SuperClasses[i] == R)
1467         return true;
1468     return false;
1469   }
1470
1471   bool isSubClassOf(StringRef Name) const {
1472     for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1473       if (SuperClasses[i]->getName() == Name)
1474         return true;
1475     return false;
1476   }
1477
1478   void addSuperClass(Record *R) {
1479     assert(!isSubClassOf(R) && "Already subclassing record!");
1480     SuperClasses.push_back(R);
1481   }
1482
1483   /// resolveReferences - If there are any field references that refer to fields
1484   /// that have been filled in, we can propagate the values now.
1485   ///
1486   void resolveReferences() { resolveReferencesTo(0); }
1487
1488   /// resolveReferencesTo - If anything in this record refers to RV, replace the
1489   /// reference to RV with the RHS of RV.  If RV is null, we resolve all
1490   /// possible references.
1491   void resolveReferencesTo(const RecordVal *RV);
1492
1493   RecordKeeper &getRecords() const {
1494     return TrackedRecords;
1495   }
1496
1497   void dump() const;
1498
1499   //===--------------------------------------------------------------------===//
1500   // High-level methods useful to tablegen back-ends
1501   //
1502
1503   /// getValueInit - Return the initializer for a value with the specified name,
1504   /// or throw an exception if the field does not exist.
1505   ///
1506   Init *getValueInit(StringRef FieldName) const;
1507
1508   /// getValueAsString - This method looks up the specified field and returns
1509   /// its value as a string, throwing an exception if the field does not exist
1510   /// or if the value is not a string.
1511   ///
1512   std::string getValueAsString(StringRef FieldName) const;
1513
1514   /// getValueAsBitsInit - This method looks up the specified field and returns
1515   /// its value as a BitsInit, throwing an exception if the field does not exist
1516   /// or if the value is not the right type.
1517   ///
1518   BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1519
1520   /// getValueAsListInit - This method looks up the specified field and returns
1521   /// its value as a ListInit, throwing an exception if the field does not exist
1522   /// or if the value is not the right type.
1523   ///
1524   ListInit *getValueAsListInit(StringRef FieldName) const;
1525
1526   /// getValueAsListOfDefs - This method looks up the specified field and
1527   /// returns its value as a vector of records, throwing an exception if the
1528   /// field does not exist or if the value is not the right type.
1529   ///
1530   std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1531
1532   /// getValueAsListOfInts - This method looks up the specified field and
1533   /// returns its value as a vector of integers, throwing an exception if the
1534   /// field does not exist or if the value is not the right type.
1535   ///
1536   std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1537
1538   /// getValueAsListOfStrings - This method looks up the specified field and
1539   /// returns its value as a vector of strings, throwing an exception if the
1540   /// field does not exist or if the value is not the right type.
1541   ///
1542   std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1543
1544   /// getValueAsDef - This method looks up the specified field and returns its
1545   /// value as a Record, throwing an exception if the field does not exist or if
1546   /// the value is not the right type.
1547   ///
1548   Record *getValueAsDef(StringRef FieldName) const;
1549
1550   /// getValueAsBit - This method looks up the specified field and returns its
1551   /// value as a bit, throwing an exception if the field does not exist or if
1552   /// the value is not the right type.
1553   ///
1554   bool getValueAsBit(StringRef FieldName) const;
1555
1556   /// getValueAsInt - This method looks up the specified field and returns its
1557   /// value as an int64_t, throwing an exception if the field does not exist or
1558   /// if the value is not the right type.
1559   ///
1560   int64_t getValueAsInt(StringRef FieldName) const;
1561
1562   /// getValueAsDag - This method looks up the specified field and returns its
1563   /// value as an Dag, throwing an exception if the field does not exist or if
1564   /// the value is not the right type.
1565   ///
1566   DagInit *getValueAsDag(StringRef FieldName) const;
1567
1568   /// getValueAsCode - This method looks up the specified field and returns
1569   /// its value as the string data in a CodeInit, throwing an exception if the
1570   /// field does not exist or if the value is not a code object.
1571   ///
1572   std::string getValueAsCode(StringRef FieldName) const;
1573 };
1574
1575 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1576
1577 struct MultiClass {
1578   Record Rec;  // Placeholder for template args and Name.
1579   typedef std::vector<Record*> RecordVector;
1580   RecordVector DefPrototypes;
1581
1582   void dump() const;
1583
1584   MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1585     Rec(Name, Loc, Records) {}
1586 };
1587
1588 class RecordKeeper {
1589   std::map<std::string, Record*> Classes, Defs;
1590 public:
1591   ~RecordKeeper() {
1592     for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1593            E = Classes.end(); I != E; ++I)
1594       delete I->second;
1595     for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1596            E = Defs.end(); I != E; ++I)
1597       delete I->second;
1598   }
1599
1600   const std::map<std::string, Record*> &getClasses() const { return Classes; }
1601   const std::map<std::string, Record*> &getDefs() const { return Defs; }
1602
1603   Record *getClass(const std::string &Name) const {
1604     std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1605     return I == Classes.end() ? 0 : I->second;
1606   }
1607   Record *getDef(const std::string &Name) const {
1608     std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1609     return I == Defs.end() ? 0 : I->second;
1610   }
1611   void addClass(Record *R) {
1612     assert(getClass(R->getName()) == 0 && "Class already exists!");
1613     Classes.insert(std::make_pair(R->getName(), R));
1614   }
1615   void addDef(Record *R) {
1616     assert(getDef(R->getName()) == 0 && "Def already exists!");
1617     Defs.insert(std::make_pair(R->getName(), R));
1618   }
1619
1620   /// removeClass - Remove, but do not delete, the specified record.
1621   ///
1622   void removeClass(const std::string &Name) {
1623     assert(Classes.count(Name) && "Class does not exist!");
1624     Classes.erase(Name);
1625   }
1626   /// removeDef - Remove, but do not delete, the specified record.
1627   ///
1628   void removeDef(const std::string &Name) {
1629     assert(Defs.count(Name) && "Def does not exist!");
1630     Defs.erase(Name);
1631   }
1632
1633   //===--------------------------------------------------------------------===//
1634   // High-level helper methods, useful for tablegen backends...
1635
1636   /// getAllDerivedDefinitions - This method returns all concrete definitions
1637   /// that derive from the specified class name.  If a class with the specified
1638   /// name does not exist, an exception is thrown.
1639   std::vector<Record*>
1640   getAllDerivedDefinitions(const std::string &ClassName) const;
1641
1642   void dump() const;
1643 };
1644
1645 /// LessRecord - Sorting predicate to sort record pointers by name.
1646 ///
1647 struct LessRecord {
1648   bool operator()(const Record *Rec1, const Record *Rec2) const {
1649     return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1650   }
1651 };
1652
1653 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1654 /// name field.
1655 ///
1656 struct LessRecordFieldName {
1657   bool operator()(const Record *Rec1, const Record *Rec2) const {
1658     return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1659   }
1660 };
1661
1662 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1663
1664 } // End llvm namespace
1665
1666 #endif