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