Record.h revision ebaf92c67dac4974f98a08f8096d3eb2f4edd09d
15d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)//===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 55d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)// License. See LICENSE.TXT for details. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file defines the main TableGen data structures, including the TableGen 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// types, values, and high-level data structures. 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef LLVM_TABLEGEN_RECORD_H 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define LLVM_TABLEGEN_RECORD_H 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 185d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#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; 71 virtual void anchor(); 72public: 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 87public: // 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 115public: // 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 128inline 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/// 136class BitRecTy : public RecTy { 137 static BitRecTy Shared; 138 BitRecTy() {} 139public: 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<n>' - Represent a fixed number of bits 178/// 179class BitsRecTy : public RecTy { 180 unsigned Size; 181 explicit BitsRecTy(unsigned Sz) : Size(Sz) {} 182public: 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/// 225class IntRecTy : public RecTy { 226 static IntRecTy Shared; 227 IntRecTy() {} 228public: 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/// 267class StringRecTy : public RecTy { 268 static StringRecTy Shared; 269 StringRecTy() {} 270public: 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<Ty>' - Represent a list of values, all of which must 310/// be of the specified type. 311/// 312class ListRecTy : public RecTy { 313 RecTy *Ty; 314 explicit ListRecTy(RecTy *T) : Ty(T) {} 315 friend ListRecTy *RecTy::getListTy(); 316public: 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/// 357class CodeRecTy : public RecTy { 358 static CodeRecTy Shared; 359 CodeRecTy() {} 360public: 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/// 397class DagRecTy : public RecTy { 398 static DagRecTy Shared; 399 DagRecTy() {} 400public: 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/// 440class RecordRecTy : public RecTy { 441 Record *Rec; 442 explicit RecordRecTy(Record *R) : Rec(R) {} 443 friend class Record; 444public: 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/// 484RecTy *resolveTypes(RecTy *T1, RecTy *T2); 485 486//===----------------------------------------------------------------------===// 487// Initializer Classes 488//===----------------------------------------------------------------------===// 489 490class Init { 491 Init(const Init &); // Do not define. 492 Init &operator=(const Init &); // Do not define. 493 virtual void anchor(); 494 495protected: 496 Init(void) {} 497 498public: 499 virtual ~Init() {} 500 501 /// isComplete - This virtual method should be overridden by values that may 502 /// not be completely specified yet. 503 virtual bool isComplete() const { return true; } 504 505 /// print - Print out this value. 506 void print(raw_ostream &OS) const { OS << getAsString(); } 507 508 /// getAsString - Convert this value to a string form. 509 virtual std::string getAsString() const = 0; 510 /// getAsUnquotedString - Convert this value to a string form, 511 /// without adding quote markers. This primaruly affects 512 /// StringInits where we will not surround the string value with 513 /// quotes. 514 virtual std::string getAsUnquotedString() const { return getAsString(); } 515 516 /// dump - Debugging method that may be called through a debugger, just 517 /// invokes print on stderr. 518 void dump() const; 519 520 /// convertInitializerTo - This virtual function is a simple call-back 521 /// function that should be overridden to call the appropriate 522 /// RecTy::convertValue method. 523 /// 524 virtual Init *convertInitializerTo(RecTy *Ty) const = 0; 525 526 /// convertInitializerBitRange - This method is used to implement the bitrange 527 /// selection operator. Given an initializer, it selects the specified bits 528 /// out, returning them as a new init of bits type. If it is not legal to use 529 /// the bit subscript operator on this initializer, return null. 530 /// 531 virtual Init * 532 convertInitializerBitRange(const std::vector<unsigned> &Bits) const { 533 return 0; 534 } 535 536 /// convertInitListSlice - This method is used to implement the list slice 537 /// selection operator. Given an initializer, it selects the specified list 538 /// elements, returning them as a new init of list type. If it is not legal 539 /// to take a slice of this, return null. 540 /// 541 virtual Init * 542 convertInitListSlice(const std::vector<unsigned> &Elements) const { 543 return 0; 544 } 545 546 /// getFieldType - This method is used to implement the FieldInit class. 547 /// Implementors of this method should return the type of the named field if 548 /// they are of record type. 549 /// 550 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; } 551 552 /// getFieldInit - This method complements getFieldType to return the 553 /// initializer for the specified field. If getFieldType returns non-null 554 /// this method should return non-null, otherwise it returns null. 555 /// 556 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 557 const std::string &FieldName) const { 558 return 0; 559 } 560 561 /// resolveReferences - This method is used by classes that refer to other 562 /// variables which may not be defined at the time the expression is formed. 563 /// If a value is set for the variable later, this method will be called on 564 /// users of the value to allow the value to propagate out. 565 /// 566 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const { 567 return const_cast<Init *>(this); 568 } 569}; 570 571inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) { 572 I.print(OS); return OS; 573} 574 575/// TypedInit - This is the common super-class of types that have a specific, 576/// explicit, type. 577/// 578class TypedInit : public Init { 579 RecTy *Ty; 580 581 TypedInit(const TypedInit &Other); // Do not define. 582 TypedInit &operator=(const TypedInit &Other); // Do not define. 583 584protected: 585 explicit TypedInit(RecTy *T) : Ty(T) {} 586 587public: 588 RecTy *getType() const { return Ty; } 589 590 virtual Init * 591 convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 592 virtual Init * 593 convertInitListSlice(const std::vector<unsigned> &Elements) const; 594 595 /// getFieldType - This method is used to implement the FieldInit class. 596 /// Implementors of this method should return the type of the named field if 597 /// they are of record type. 598 /// 599 virtual RecTy *getFieldType(const std::string &FieldName) const; 600 601 /// resolveBitReference - This method is used to implement 602 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 603 /// simply return the resolved value, otherwise we return null. 604 /// 605 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 606 unsigned Bit) const = 0; 607 608 /// resolveListElementReference - This method is used to implement 609 /// VarListElementInit::resolveReferences. If the list element is resolvable 610 /// now, we return the resolved value, otherwise we return null. 611 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 612 unsigned Elt) const = 0; 613}; 614 615 616/// UnsetInit - ? - Represents an uninitialized value 617/// 618class UnsetInit : public Init { 619 UnsetInit() : Init() {} 620 UnsetInit(const UnsetInit &); // Do not define. 621 UnsetInit &operator=(const UnsetInit &Other); // Do not define. 622 virtual void anchor(); 623 624public: 625 static UnsetInit *get(); 626 627 virtual Init *convertInitializerTo(RecTy *Ty) const { 628 return Ty->convertValue(const_cast<UnsetInit *>(this)); 629 } 630 631 virtual bool isComplete() const { return false; } 632 virtual std::string getAsString() const { return "?"; } 633}; 634 635 636/// BitInit - true/false - Represent a concrete initializer for a bit. 637/// 638class BitInit : public Init { 639 bool Value; 640 641 explicit BitInit(bool V) : Value(V) {} 642 BitInit(const BitInit &Other); // Do not define. 643 BitInit &operator=(BitInit &Other); // Do not define. 644 virtual void anchor(); 645 646public: 647 static BitInit *get(bool V); 648 649 bool getValue() const { return Value; } 650 651 virtual Init *convertInitializerTo(RecTy *Ty) const { 652 return Ty->convertValue(const_cast<BitInit *>(this)); 653 } 654 655 virtual std::string getAsString() const { return Value ? "1" : "0"; } 656}; 657 658/// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value. 659/// It contains a vector of bits, whose size is determined by the type. 660/// 661class BitsInit : public Init, public FoldingSetNode { 662 std::vector<Init*> Bits; 663 664 BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {} 665 666 BitsInit(const BitsInit &Other); // Do not define. 667 BitsInit &operator=(const BitsInit &Other); // Do not define. 668 669public: 670 static BitsInit *get(ArrayRef<Init *> Range); 671 672 void Profile(FoldingSetNodeID &ID) const; 673 674 unsigned getNumBits() const { return Bits.size(); } 675 676 Init *getBit(unsigned Bit) const { 677 assert(Bit < Bits.size() && "Bit index out of range!"); 678 return Bits[Bit]; 679 } 680 681 virtual Init *convertInitializerTo(RecTy *Ty) const { 682 return Ty->convertValue(const_cast<BitsInit *>(this)); 683 } 684 virtual Init * 685 convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 686 687 virtual bool isComplete() const { 688 for (unsigned i = 0; i != getNumBits(); ++i) 689 if (!getBit(i)->isComplete()) return false; 690 return true; 691 } 692 bool allInComplete() const { 693 for (unsigned i = 0; i != getNumBits(); ++i) 694 if (getBit(i)->isComplete()) return false; 695 return true; 696 } 697 virtual std::string getAsString() const; 698 699 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 700}; 701 702 703/// IntInit - 7 - Represent an initalization by a literal integer value. 704/// 705class IntInit : public TypedInit { 706 int64_t Value; 707 708 explicit IntInit(int64_t V) : TypedInit(IntRecTy::get()), Value(V) {} 709 710 IntInit(const IntInit &Other); // Do not define. 711 IntInit &operator=(const IntInit &Other); // Do note define. 712 713public: 714 static IntInit *get(int64_t V); 715 716 int64_t getValue() const { return Value; } 717 718 virtual Init *convertInitializerTo(RecTy *Ty) const { 719 return Ty->convertValue(const_cast<IntInit *>(this)); 720 } 721 virtual Init * 722 convertInitializerBitRange(const std::vector<unsigned> &Bits) const; 723 724 virtual std::string getAsString() const; 725 726 /// resolveBitReference - This method is used to implement 727 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 728 /// simply return the resolved value, otherwise we return null. 729 /// 730 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 731 unsigned Bit) const { 732 assert(0 && "Illegal bit reference off int"); 733 return 0; 734 } 735 736 /// resolveListElementReference - This method is used to implement 737 /// VarListElementInit::resolveReferences. If the list element is resolvable 738 /// now, we return the resolved value, otherwise we return null. 739 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 740 unsigned Elt) const { 741 assert(0 && "Illegal element reference off int"); 742 return 0; 743 } 744}; 745 746 747/// StringInit - "foo" - Represent an initialization by a string value. 748/// 749class StringInit : public TypedInit { 750 std::string Value; 751 752 explicit StringInit(const std::string &V) 753 : TypedInit(StringRecTy::get()), Value(V) {} 754 755 StringInit(const StringInit &Other); // Do not define. 756 StringInit &operator=(const StringInit &Other); // Do not define. 757 virtual void anchor(); 758 759public: 760 static StringInit *get(StringRef); 761 762 const std::string &getValue() const { return Value; } 763 764 virtual Init *convertInitializerTo(RecTy *Ty) const { 765 return Ty->convertValue(const_cast<StringInit *>(this)); 766 } 767 768 virtual std::string getAsString() const { return "\"" + Value + "\""; } 769 virtual std::string getAsUnquotedString() const { return Value; } 770 771 /// resolveBitReference - This method is used to implement 772 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 773 /// simply return the resolved value, otherwise we return null. 774 /// 775 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 776 unsigned Bit) const { 777 assert(0 && "Illegal bit reference off string"); 778 return 0; 779 } 780 781 /// resolveListElementReference - This method is used to implement 782 /// VarListElementInit::resolveReferences. If the list element is resolvable 783 /// now, we return the resolved value, otherwise we return null. 784 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 785 unsigned Elt) const { 786 assert(0 && "Illegal element reference off string"); 787 return 0; 788 } 789}; 790 791/// CodeInit - "[{...}]" - Represent a code fragment. 792/// 793class CodeInit : public Init { 794 std::string Value; 795 796 explicit CodeInit(const std::string &V) : Value(V) {} 797 798 CodeInit(const CodeInit &Other); // Do not define. 799 CodeInit &operator=(const CodeInit &Other); // Do not define. 800 virtual void anchor(); 801 802public: 803 static CodeInit *get(StringRef); 804 805 const std::string &getValue() const { return Value; } 806 807 virtual Init *convertInitializerTo(RecTy *Ty) const { 808 return Ty->convertValue(const_cast<CodeInit *>(this)); 809 } 810 811 virtual std::string getAsString() const { return "[{" + Value + "}]"; } 812}; 813 814/// ListInit - [AL, AH, CL] - Represent a list of defs 815/// 816class ListInit : public TypedInit, public FoldingSetNode { 817 std::vector<Init*> Values; 818public: 819 typedef std::vector<Init*>::const_iterator const_iterator; 820 821private: 822 explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy) 823 : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {} 824 825 ListInit(const ListInit &Other); // Do not define. 826 ListInit &operator=(const ListInit &Other); // Do not define. 827 828public: 829 static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy); 830 831 void Profile(FoldingSetNodeID &ID) const; 832 833 unsigned getSize() const { return Values.size(); } 834 Init *getElement(unsigned i) const { 835 assert(i < Values.size() && "List element index out of range!"); 836 return Values[i]; 837 } 838 839 Record *getElementAsRecord(unsigned i) const; 840 841 Init *convertInitListSlice(const std::vector<unsigned> &Elements) const; 842 843 virtual Init *convertInitializerTo(RecTy *Ty) const { 844 return Ty->convertValue(const_cast<ListInit *>(this)); 845 } 846 847 /// resolveReferences - This method is used by classes that refer to other 848 /// variables which may not be defined at the time they expression is formed. 849 /// If a value is set for the variable later, this method will be called on 850 /// users of the value to allow the value to propagate out. 851 /// 852 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 853 854 virtual std::string getAsString() const; 855 856 ArrayRef<Init*> getValues() const { return Values; } 857 858 inline const_iterator begin() const { return Values.begin(); } 859 inline const_iterator end () const { return Values.end(); } 860 861 inline size_t size () const { return Values.size(); } 862 inline bool empty() const { return Values.empty(); } 863 864 /// resolveBitReference - This method is used to implement 865 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 866 /// simply return the resolved value, otherwise we return null. 867 /// 868 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 869 unsigned Bit) const { 870 assert(0 && "Illegal bit reference off list"); 871 return 0; 872 } 873 874 /// resolveListElementReference - This method is used to implement 875 /// VarListElementInit::resolveReferences. If the list element is resolvable 876 /// now, we return the resolved value, otherwise we return null. 877 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 878 unsigned Elt) const; 879}; 880 881 882/// OpInit - Base class for operators 883/// 884class OpInit : public TypedInit { 885 OpInit(const OpInit &Other); // Do not define. 886 OpInit &operator=(OpInit &Other); // Do not define. 887 888protected: 889 explicit OpInit(RecTy *Type) : TypedInit(Type) {} 890 891public: 892 // Clone - Clone this operator, replacing arguments with the new list 893 virtual OpInit *clone(std::vector<Init *> &Operands) const = 0; 894 895 virtual int getNumOperands() const = 0; 896 virtual Init *getOperand(int i) const = 0; 897 898 // Fold - If possible, fold this to a simpler init. Return this if not 899 // possible to fold. 900 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0; 901 902 virtual Init *convertInitializerTo(RecTy *Ty) const { 903 return Ty->convertValue(const_cast<OpInit *>(this)); 904 } 905 906 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 907 unsigned Bit) const; 908 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 909 unsigned Elt) const; 910}; 911 912 913/// UnOpInit - !op (X) - Transform an init. 914/// 915class UnOpInit : public OpInit { 916public: 917 enum UnaryOp { CAST, HEAD, TAIL, EMPTY }; 918private: 919 UnaryOp Opc; 920 Init *LHS; 921 922 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) 923 : OpInit(Type), Opc(opc), LHS(lhs) {} 924 925 UnOpInit(const UnOpInit &Other); // Do not define. 926 UnOpInit &operator=(const UnOpInit &Other); // Do not define. 927 928public: 929 static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type); 930 931 // Clone - Clone this operator, replacing arguments with the new list 932 virtual OpInit *clone(std::vector<Init *> &Operands) const { 933 assert(Operands.size() == 1 && 934 "Wrong number of operands for unary operation"); 935 return UnOpInit::get(getOpcode(), *Operands.begin(), getType()); 936 } 937 938 int getNumOperands() const { return 1; } 939 Init *getOperand(int i) const { 940 assert(i == 0 && "Invalid operand id for unary operator"); 941 return getOperand(); 942 } 943 944 UnaryOp getOpcode() const { return Opc; } 945 Init *getOperand() const { return LHS; } 946 947 // Fold - If possible, fold this to a simpler init. Return this if not 948 // possible to fold. 949 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 950 951 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 952 953 virtual std::string getAsString() const; 954}; 955 956/// BinOpInit - !op (X, Y) - Combine two inits. 957/// 958class BinOpInit : public OpInit { 959public: 960 enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ }; 961private: 962 BinaryOp Opc; 963 Init *LHS, *RHS; 964 965 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : 966 OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {} 967 968 BinOpInit(const BinOpInit &Other); // Do not define. 969 BinOpInit &operator=(const BinOpInit &Other); // Do not define. 970 971public: 972 static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs, 973 RecTy *Type); 974 975 // Clone - Clone this operator, replacing arguments with the new list 976 virtual OpInit *clone(std::vector<Init *> &Operands) const { 977 assert(Operands.size() == 2 && 978 "Wrong number of operands for binary operation"); 979 return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType()); 980 } 981 982 int getNumOperands() const { return 2; } 983 Init *getOperand(int i) const { 984 assert((i == 0 || i == 1) && "Invalid operand id for binary operator"); 985 if (i == 0) { 986 return getLHS(); 987 } else { 988 return getRHS(); 989 } 990 } 991 992 BinaryOp getOpcode() const { return Opc; } 993 Init *getLHS() const { return LHS; } 994 Init *getRHS() const { return RHS; } 995 996 // Fold - If possible, fold this to a simpler init. Return this if not 997 // possible to fold. 998 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 999 1000 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1001 1002 virtual std::string getAsString() const; 1003}; 1004 1005/// TernOpInit - !op (X, Y, Z) - Combine two inits. 1006/// 1007class TernOpInit : public OpInit { 1008public: 1009 enum TernaryOp { SUBST, FOREACH, IF }; 1010private: 1011 TernaryOp Opc; 1012 Init *LHS, *MHS, *RHS; 1013 1014 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, 1015 RecTy *Type) : 1016 OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {} 1017 1018 TernOpInit(const TernOpInit &Other); // Do not define. 1019 TernOpInit &operator=(const TernOpInit &Other); // Do not define. 1020 1021public: 1022 static TernOpInit *get(TernaryOp opc, Init *lhs, 1023 Init *mhs, Init *rhs, 1024 RecTy *Type); 1025 1026 // Clone - Clone this operator, replacing arguments with the new list 1027 virtual OpInit *clone(std::vector<Init *> &Operands) const { 1028 assert(Operands.size() == 3 && 1029 "Wrong number of operands for ternary operation"); 1030 return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2], 1031 getType()); 1032 } 1033 1034 int getNumOperands() const { return 3; } 1035 Init *getOperand(int i) const { 1036 assert((i == 0 || i == 1 || i == 2) && 1037 "Invalid operand id for ternary operator"); 1038 if (i == 0) { 1039 return getLHS(); 1040 } else if (i == 1) { 1041 return getMHS(); 1042 } else { 1043 return getRHS(); 1044 } 1045 } 1046 1047 TernaryOp getOpcode() const { return Opc; } 1048 Init *getLHS() const { return LHS; } 1049 Init *getMHS() const { return MHS; } 1050 Init *getRHS() const { return RHS; } 1051 1052 // Fold - If possible, fold this to a simpler init. Return this if not 1053 // possible to fold. 1054 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; 1055 1056 virtual bool isComplete() const { return false; } 1057 1058 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1059 1060 virtual std::string getAsString() const; 1061}; 1062 1063 1064/// VarInit - 'Opcode' - Represent a reference to an entire variable object. 1065/// 1066class VarInit : public TypedInit { 1067 Init *VarName; 1068 1069 explicit VarInit(const std::string &VN, RecTy *T) 1070 : TypedInit(T), VarName(StringInit::get(VN)) {} 1071 explicit VarInit(Init *VN, RecTy *T) 1072 : TypedInit(T), VarName(VN) {} 1073 1074 VarInit(const VarInit &Other); // Do not define. 1075 VarInit &operator=(const VarInit &Other); // Do not define. 1076 1077public: 1078 static VarInit *get(const std::string &VN, RecTy *T); 1079 static VarInit *get(Init *VN, RecTy *T); 1080 1081 virtual Init *convertInitializerTo(RecTy *Ty) const { 1082 return Ty->convertValue(const_cast<VarInit *>(this)); 1083 } 1084 1085 const std::string &getName() const; 1086 Init *getNameInit() const { return VarName; } 1087 std::string getNameInitAsString() const { 1088 return getNameInit()->getAsUnquotedString(); 1089 } 1090 1091 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1092 unsigned Bit) const; 1093 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1094 unsigned Elt) const; 1095 1096 virtual RecTy *getFieldType(const std::string &FieldName) const; 1097 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 1098 const std::string &FieldName) const; 1099 1100 /// resolveReferences - This method is used by classes that refer to other 1101 /// variables which may not be defined at the time they expression is formed. 1102 /// If a value is set for the variable later, this method will be called on 1103 /// users of the value to allow the value to propagate out. 1104 /// 1105 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1106 1107 virtual std::string getAsString() const { return getName(); } 1108}; 1109 1110 1111/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field. 1112/// 1113class VarBitInit : public Init { 1114 TypedInit *TI; 1115 unsigned Bit; 1116 1117 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) { 1118 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) && 1119 ((BitsRecTy*)T->getType())->getNumBits() > B && 1120 "Illegal VarBitInit expression!"); 1121 } 1122 1123 VarBitInit(const VarBitInit &Other); // Do not define. 1124 VarBitInit &operator=(const VarBitInit &Other); // Do not define. 1125 1126public: 1127 static VarBitInit *get(TypedInit *T, unsigned B); 1128 1129 virtual Init *convertInitializerTo(RecTy *Ty) const { 1130 return Ty->convertValue(const_cast<VarBitInit *>(this)); 1131 } 1132 1133 TypedInit *getVariable() const { return TI; } 1134 unsigned getBitNum() const { return Bit; } 1135 1136 virtual std::string getAsString() const; 1137 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1138}; 1139 1140/// VarListElementInit - List[4] - Represent access to one element of a var or 1141/// field. 1142class VarListElementInit : public TypedInit { 1143 TypedInit *TI; 1144 unsigned Element; 1145 1146 VarListElementInit(TypedInit *T, unsigned E) 1147 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()), 1148 TI(T), Element(E) { 1149 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) && 1150 "Illegal VarBitInit expression!"); 1151 } 1152 1153 VarListElementInit(const VarListElementInit &Other); // Do not define. 1154 VarListElementInit &operator=(const VarListElementInit &Other); // Do 1155 // not 1156 // define. 1157 1158public: 1159 static VarListElementInit *get(TypedInit *T, unsigned E); 1160 1161 virtual Init *convertInitializerTo(RecTy *Ty) const { 1162 return Ty->convertValue(const_cast<VarListElementInit *>(this)); 1163 } 1164 1165 TypedInit *getVariable() const { return TI; } 1166 unsigned getElementNum() const { return Element; } 1167 1168 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1169 unsigned Bit) const; 1170 1171 /// resolveListElementReference - This method is used to implement 1172 /// VarListElementInit::resolveReferences. If the list element is resolvable 1173 /// now, we return the resolved value, otherwise we return null. 1174 virtual Init *resolveListElementReference(Record &R, 1175 const RecordVal *RV, 1176 unsigned Elt) const; 1177 1178 virtual std::string getAsString() const; 1179 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1180}; 1181 1182/// DefInit - AL - Represent a reference to a 'def' in the description 1183/// 1184class DefInit : public TypedInit { 1185 Record *Def; 1186 1187 DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {} 1188 friend class Record; 1189 1190 DefInit(const DefInit &Other); // Do not define. 1191 DefInit &operator=(const DefInit &Other); // Do not define. 1192 1193public: 1194 static DefInit *get(Record*); 1195 1196 virtual Init *convertInitializerTo(RecTy *Ty) const { 1197 return Ty->convertValue(const_cast<DefInit *>(this)); 1198 } 1199 1200 Record *getDef() const { return Def; } 1201 1202 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); 1203 1204 virtual RecTy *getFieldType(const std::string &FieldName) const; 1205 virtual Init *getFieldInit(Record &R, const RecordVal *RV, 1206 const std::string &FieldName) const; 1207 1208 virtual std::string getAsString() const; 1209 1210 /// resolveBitReference - This method is used to implement 1211 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we 1212 /// simply return the resolved value, otherwise we return null. 1213 /// 1214 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1215 unsigned Bit) const { 1216 assert(0 && "Illegal bit reference off def"); 1217 return 0; 1218 } 1219 1220 /// resolveListElementReference - This method is used to implement 1221 /// VarListElementInit::resolveReferences. If the list element is resolvable 1222 /// now, we return the resolved value, otherwise we return null. 1223 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1224 unsigned Elt) const { 1225 assert(0 && "Illegal element reference off def"); 1226 return 0; 1227 } 1228}; 1229 1230 1231/// FieldInit - X.Y - Represent a reference to a subfield of a variable 1232/// 1233class FieldInit : public TypedInit { 1234 Init *Rec; // Record we are referring to 1235 std::string FieldName; // Field we are accessing 1236 1237 FieldInit(Init *R, const std::string &FN) 1238 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) { 1239 assert(getType() && "FieldInit with non-record type!"); 1240 } 1241 1242 FieldInit(const FieldInit &Other); // Do not define. 1243 FieldInit &operator=(const FieldInit &Other); // Do not define. 1244 1245public: 1246 static FieldInit *get(Init *R, const std::string &FN); 1247 static FieldInit *get(Init *R, const Init *FN); 1248 1249 virtual Init *convertInitializerTo(RecTy *Ty) const { 1250 return Ty->convertValue(const_cast<FieldInit *>(this)); 1251 } 1252 1253 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1254 unsigned Bit) const; 1255 virtual Init *resolveListElementReference(Record &R, 1256 const RecordVal *RV, 1257 unsigned Elt) const; 1258 1259 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1260 1261 virtual std::string getAsString() const { 1262 return Rec->getAsString() + "." + FieldName; 1263 } 1264}; 1265 1266/// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required 1267/// to have at least one value then a (possibly empty) list of arguments. Each 1268/// argument can have a name associated with it. 1269/// 1270class DagInit : public TypedInit, public FoldingSetNode { 1271 Init *Val; 1272 std::string ValName; 1273 std::vector<Init*> Args; 1274 std::vector<std::string> ArgNames; 1275 1276 DagInit(Init *V, const std::string &VN, 1277 ArrayRef<Init *> ArgRange, 1278 ArrayRef<std::string> NameRange) 1279 : TypedInit(DagRecTy::get()), Val(V), ValName(VN), 1280 Args(ArgRange.begin(), ArgRange.end()), 1281 ArgNames(NameRange.begin(), NameRange.end()) {} 1282 1283 DagInit(const DagInit &Other); // Do not define. 1284 DagInit &operator=(const DagInit &Other); // Do not define. 1285 1286public: 1287 static DagInit *get(Init *V, const std::string &VN, 1288 ArrayRef<Init *> ArgRange, 1289 ArrayRef<std::string> NameRange); 1290 static DagInit *get(Init *V, const std::string &VN, 1291 const std::vector< 1292 std::pair<Init*, std::string> > &args); 1293 1294 void Profile(FoldingSetNodeID &ID) const; 1295 1296 virtual Init *convertInitializerTo(RecTy *Ty) const { 1297 return Ty->convertValue(const_cast<DagInit *>(this)); 1298 } 1299 1300 Init *getOperator() const { return Val; } 1301 1302 const std::string &getName() const { return ValName; } 1303 1304 unsigned getNumArgs() const { return Args.size(); } 1305 Init *getArg(unsigned Num) const { 1306 assert(Num < Args.size() && "Arg number out of range!"); 1307 return Args[Num]; 1308 } 1309 const std::string &getArgName(unsigned Num) const { 1310 assert(Num < ArgNames.size() && "Arg number out of range!"); 1311 return ArgNames[Num]; 1312 } 1313 1314 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; 1315 1316 virtual std::string getAsString() const; 1317 1318 typedef std::vector<Init*>::const_iterator const_arg_iterator; 1319 typedef std::vector<std::string>::const_iterator const_name_iterator; 1320 1321 inline const_arg_iterator arg_begin() const { return Args.begin(); } 1322 inline const_arg_iterator arg_end () const { return Args.end(); } 1323 1324 inline size_t arg_size () const { return Args.size(); } 1325 inline bool arg_empty() const { return Args.empty(); } 1326 1327 inline const_name_iterator name_begin() const { return ArgNames.begin(); } 1328 inline const_name_iterator name_end () const { return ArgNames.end(); } 1329 1330 inline size_t name_size () const { return ArgNames.size(); } 1331 inline bool name_empty() const { return ArgNames.empty(); } 1332 1333 virtual Init *resolveBitReference(Record &R, const RecordVal *RV, 1334 unsigned Bit) const { 1335 assert(0 && "Illegal bit reference off dag"); 1336 return 0; 1337 } 1338 1339 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, 1340 unsigned Elt) const { 1341 assert(0 && "Illegal element reference off dag"); 1342 return 0; 1343 } 1344}; 1345 1346//===----------------------------------------------------------------------===// 1347// High-Level Classes 1348//===----------------------------------------------------------------------===// 1349 1350class RecordVal { 1351 Init *Name; 1352 RecTy *Ty; 1353 unsigned Prefix; 1354 Init *Value; 1355public: 1356 RecordVal(Init *N, RecTy *T, unsigned P); 1357 RecordVal(const std::string &N, RecTy *T, unsigned P); 1358 1359 const std::string &getName() const; 1360 const Init *getNameInit() const { return Name; } 1361 std::string getNameInitAsString() const { 1362 return getNameInit()->getAsUnquotedString(); 1363 } 1364 1365 unsigned getPrefix() const { return Prefix; } 1366 RecTy *getType() const { return Ty; } 1367 Init *getValue() const { return Value; } 1368 1369 bool setValue(Init *V) { 1370 if (V) { 1371 Value = V->convertInitializerTo(Ty); 1372 return Value == 0; 1373 } 1374 Value = 0; 1375 return false; 1376 } 1377 1378 void dump() const; 1379 void print(raw_ostream &OS, bool PrintSem = true) const; 1380}; 1381 1382inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1383 RV.print(OS << " "); 1384 return OS; 1385} 1386 1387class Record { 1388 static unsigned LastID; 1389 1390 // Unique record ID. 1391 unsigned ID; 1392 Init *Name; 1393 SMLoc Loc; 1394 std::vector<Init *> TemplateArgs; 1395 std::vector<RecordVal> Values; 1396 std::vector<Record*> SuperClasses; 1397 1398 // Tracks Record instances. Not owned by Record. 1399 RecordKeeper &TrackedRecords; 1400 1401 DefInit *TheInit; 1402 1403 void init(); 1404 void checkName(); 1405 1406public: 1407 1408 // Constructs a record. 1409 explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) : 1410 ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records), 1411 TheInit(0) { 1412 init(); 1413 } 1414 explicit Record(Init *N, SMLoc loc, RecordKeeper &records) : 1415 ID(LastID++), Name(N), Loc(loc), TrackedRecords(records), TheInit(0) { 1416 init(); 1417 } 1418 ~Record() {} 1419 1420 1421 static unsigned getNewUID() { return LastID++; } 1422 1423 1424 unsigned getID() const { return ID; } 1425 1426 const std::string &getName() const; 1427 Init *getNameInit() const { 1428 return Name; 1429 } 1430 const std::string getNameInitAsString() const { 1431 return getNameInit()->getAsUnquotedString(); 1432 } 1433 1434 void setName(Init *Name); // Also updates RecordKeeper. 1435 void setName(const std::string &Name); // Also updates RecordKeeper. 1436 1437 SMLoc getLoc() const { return Loc; } 1438 1439 /// get the corresponding DefInit. 1440 DefInit *getDefInit(); 1441 1442 const std::vector<Init *> &getTemplateArgs() const { 1443 return TemplateArgs; 1444 } 1445 const std::vector<RecordVal> &getValues() const { return Values; } 1446 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; } 1447 1448 bool isTemplateArg(Init *Name) const { 1449 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i) 1450 if (TemplateArgs[i] == Name) return true; 1451 return false; 1452 } 1453 bool isTemplateArg(StringRef Name) const { 1454 return isTemplateArg(StringInit::get(Name.str())); 1455 } 1456 1457 const RecordVal *getValue(const Init *Name) const { 1458 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1459 if (Values[i].getNameInit() == Name) return &Values[i]; 1460 return 0; 1461 } 1462 const RecordVal *getValue(StringRef Name) const { 1463 return getValue(StringInit::get(Name)); 1464 } 1465 RecordVal *getValue(const Init *Name) { 1466 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1467 if (Values[i].getNameInit() == Name) return &Values[i]; 1468 return 0; 1469 } 1470 RecordVal *getValue(StringRef Name) { 1471 return getValue(StringInit::get(Name)); 1472 } 1473 1474 void addTemplateArg(Init *Name) { 1475 assert(!isTemplateArg(Name) && "Template arg already defined!"); 1476 TemplateArgs.push_back(Name); 1477 } 1478 void addTemplateArg(StringRef Name) { 1479 addTemplateArg(StringInit::get(Name.str())); 1480 } 1481 1482 void addValue(const RecordVal &RV) { 1483 assert(getValue(RV.getNameInit()) == 0 && "Value already added!"); 1484 Values.push_back(RV); 1485 if (Values.size() > 1) 1486 // Keep NAME at the end of the list. It makes record dumps a 1487 // bit prettier and allows TableGen tests to be written more 1488 // naturally. Tests can use CHECK-NEXT to look for Record 1489 // fields they expect to see after a def. They can't do that if 1490 // NAME is the first Record field. 1491 std::swap(Values[Values.size() - 2], Values[Values.size() - 1]); 1492 } 1493 1494 void removeValue(Init *Name) { 1495 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1496 if (Values[i].getNameInit() == Name) { 1497 Values.erase(Values.begin()+i); 1498 return; 1499 } 1500 assert(0 && "Cannot remove an entry that does not exist!"); 1501 } 1502 1503 void removeValue(StringRef Name) { 1504 removeValue(StringInit::get(Name.str())); 1505 } 1506 1507 bool isSubClassOf(const Record *R) const { 1508 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 1509 if (SuperClasses[i] == R) 1510 return true; 1511 return false; 1512 } 1513 1514 bool isSubClassOf(StringRef Name) const { 1515 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) 1516 if (SuperClasses[i]->getNameInitAsString() == Name) 1517 return true; 1518 return false; 1519 } 1520 1521 void addSuperClass(Record *R) { 1522 assert(!isSubClassOf(R) && "Already subclassing record!"); 1523 SuperClasses.push_back(R); 1524 } 1525 1526 /// resolveReferences - If there are any field references that refer to fields 1527 /// that have been filled in, we can propagate the values now. 1528 /// 1529 void resolveReferences() { resolveReferencesTo(0); } 1530 1531 /// resolveReferencesTo - If anything in this record refers to RV, replace the 1532 /// reference to RV with the RHS of RV. If RV is null, we resolve all 1533 /// possible references. 1534 void resolveReferencesTo(const RecordVal *RV); 1535 1536 RecordKeeper &getRecords() const { 1537 return TrackedRecords; 1538 } 1539 1540 void dump() const; 1541 1542 //===--------------------------------------------------------------------===// 1543 // High-level methods useful to tablegen back-ends 1544 // 1545 1546 /// getValueInit - Return the initializer for a value with the specified name, 1547 /// or throw an exception if the field does not exist. 1548 /// 1549 Init *getValueInit(StringRef FieldName) const; 1550 1551 /// getValueAsString - This method looks up the specified field and returns 1552 /// its value as a string, throwing an exception if the field does not exist 1553 /// or if the value is not a string. 1554 /// 1555 std::string getValueAsString(StringRef FieldName) const; 1556 1557 /// getValueAsBitsInit - This method looks up the specified field and returns 1558 /// its value as a BitsInit, throwing an exception if the field does not exist 1559 /// or if the value is not the right type. 1560 /// 1561 BitsInit *getValueAsBitsInit(StringRef FieldName) const; 1562 1563 /// getValueAsListInit - This method looks up the specified field and returns 1564 /// its value as a ListInit, throwing an exception if the field does not exist 1565 /// or if the value is not the right type. 1566 /// 1567 ListInit *getValueAsListInit(StringRef FieldName) const; 1568 1569 /// getValueAsListOfDefs - This method looks up the specified field and 1570 /// returns its value as a vector of records, throwing an exception if the 1571 /// field does not exist or if the value is not the right type. 1572 /// 1573 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const; 1574 1575 /// getValueAsListOfInts - This method looks up the specified field and 1576 /// returns its value as a vector of integers, throwing an exception if the 1577 /// field does not exist or if the value is not the right type. 1578 /// 1579 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const; 1580 1581 /// getValueAsListOfStrings - This method looks up the specified field and 1582 /// returns its value as a vector of strings, throwing an exception if the 1583 /// field does not exist or if the value is not the right type. 1584 /// 1585 std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const; 1586 1587 /// getValueAsDef - This method looks up the specified field and returns its 1588 /// value as a Record, throwing an exception if the field does not exist or if 1589 /// the value is not the right type. 1590 /// 1591 Record *getValueAsDef(StringRef FieldName) const; 1592 1593 /// getValueAsBit - This method looks up the specified field and returns its 1594 /// value as a bit, throwing an exception if the field does not exist or if 1595 /// the value is not the right type. 1596 /// 1597 bool getValueAsBit(StringRef FieldName) const; 1598 1599 /// getValueAsInt - This method looks up the specified field and returns its 1600 /// value as an int64_t, throwing an exception if the field does not exist or 1601 /// if the value is not the right type. 1602 /// 1603 int64_t getValueAsInt(StringRef FieldName) const; 1604 1605 /// getValueAsDag - This method looks up the specified field and returns its 1606 /// value as an Dag, throwing an exception if the field does not exist or if 1607 /// the value is not the right type. 1608 /// 1609 DagInit *getValueAsDag(StringRef FieldName) const; 1610 1611 /// getValueAsCode - This method looks up the specified field and returns 1612 /// its value as the string data in a CodeInit, throwing an exception if the 1613 /// field does not exist or if the value is not a code object. 1614 /// 1615 std::string getValueAsCode(StringRef FieldName) const; 1616}; 1617 1618raw_ostream &operator<<(raw_ostream &OS, const Record &R); 1619 1620struct MultiClass { 1621 Record Rec; // Placeholder for template args and Name. 1622 typedef std::vector<Record*> RecordVector; 1623 RecordVector DefPrototypes; 1624 1625 void dump() const; 1626 1627 MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) : 1628 Rec(Name, Loc, Records) {} 1629}; 1630 1631class RecordKeeper { 1632 std::map<std::string, Record*> Classes, Defs; 1633public: 1634 ~RecordKeeper() { 1635 for (std::map<std::string, Record*>::iterator I = Classes.begin(), 1636 E = Classes.end(); I != E; ++I) 1637 delete I->second; 1638 for (std::map<std::string, Record*>::iterator I = Defs.begin(), 1639 E = Defs.end(); I != E; ++I) 1640 delete I->second; 1641 } 1642 1643 const std::map<std::string, Record*> &getClasses() const { return Classes; } 1644 const std::map<std::string, Record*> &getDefs() const { return Defs; } 1645 1646 Record *getClass(const std::string &Name) const { 1647 std::map<std::string, Record*>::const_iterator I = Classes.find(Name); 1648 return I == Classes.end() ? 0 : I->second; 1649 } 1650 Record *getDef(const std::string &Name) const { 1651 std::map<std::string, Record*>::const_iterator I = Defs.find(Name); 1652 return I == Defs.end() ? 0 : I->second; 1653 } 1654 void addClass(Record *R) { 1655 assert(getClass(R->getNameInitAsString()) == 0 && "Class already exists!"); 1656 Classes.insert(std::make_pair(R->getNameInitAsString(), R)); 1657 } 1658 void addDef(Record *R) { 1659 assert(getDef(R->getNameInitAsString()) == 0 && "Def already exists!"); 1660 Defs.insert(std::make_pair(R->getNameInitAsString(), R)); 1661 } 1662 1663 /// removeClass - Remove, but do not delete, the specified record. 1664 /// 1665 void removeClass(const std::string &Name) { 1666 assert(Classes.count(Name) && "Class does not exist!"); 1667 Classes.erase(Name); 1668 } 1669 /// removeDef - Remove, but do not delete, the specified record. 1670 /// 1671 void removeDef(const std::string &Name) { 1672 assert(Defs.count(Name) && "Def does not exist!"); 1673 Defs.erase(Name); 1674 } 1675 1676 //===--------------------------------------------------------------------===// 1677 // High-level helper methods, useful for tablegen backends... 1678 1679 /// getAllDerivedDefinitions - This method returns all concrete definitions 1680 /// that derive from the specified class name. If a class with the specified 1681 /// name does not exist, an exception is thrown. 1682 std::vector<Record*> 1683 getAllDerivedDefinitions(const std::string &ClassName) const; 1684 1685 void dump() const; 1686}; 1687 1688/// LessRecord - Sorting predicate to sort record pointers by name. 1689/// 1690struct LessRecord { 1691 bool operator()(const Record *Rec1, const Record *Rec2) const { 1692 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0; 1693 } 1694}; 1695 1696/// LessRecordFieldName - Sorting predicate to sort record pointers by their 1697/// name field. 1698/// 1699struct LessRecordFieldName { 1700 bool operator()(const Record *Rec1, const Record *Rec2) const { 1701 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1702 } 1703}; 1704 1705raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); 1706 1707/// QualifyName - Return an Init with a qualifier prefix referring 1708/// to CurRec's name. 1709Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass, 1710 Init *Name, const std::string &Scoper); 1711 1712/// QualifyName - Return an Init with a qualifier prefix referring 1713/// to CurRec's name. 1714Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass, 1715 const std::string &Name, const std::string &Scoper); 1716 1717} // End llvm namespace 1718 1719#endif 1720