utils/TableGen/Record.h

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