2 //===- Record.h - Classes to represent Table Records ------------*- C++ -*-===//
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 // This file defines the main TableGen data structures, including the TableGen
12 // types, values, and high-level data structures.
14 //===----------------------------------------------------------------------===//
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/FoldingSet.h"
21 #include "llvm/Support/Allocator.h"
22 #include "llvm/Support/SourceMgr.h"
23 #include "llvm/Support/DataTypes.h"
24 #include "llvm/Support/raw_ostream.h"
58 class VarListElementInit;
66 //===----------------------------------------------------------------------===//
68 //===----------------------------------------------------------------------===//
73 RecTy() : ListTy(0) {}
76 virtual std::string getAsString() const = 0;
77 void print(raw_ostream &OS) const { OS << getAsString(); }
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;
84 /// getListTy - Returns the type representing list<this>.
85 ListRecTy *getListTy();
87 public: // These methods should only be called from subclasses of Init
88 virtual Init *convertValue( UnsetInit *UI) { return 0; }
89 virtual Init *convertValue( BitInit *BI) { return 0; }
90 virtual Init *convertValue( BitsInit *BI) { return 0; }
91 virtual Init *convertValue( IntInit *II) { return 0; }
92 virtual Init *convertValue(StringInit *SI) { return 0; }
93 virtual Init *convertValue( ListInit *LI) { return 0; }
94 virtual Init *convertValue( UnOpInit *UI) {
95 return convertValue((TypedInit*)UI);
97 virtual Init *convertValue( BinOpInit *UI) {
98 return convertValue((TypedInit*)UI);
100 virtual Init *convertValue( TernOpInit *UI) {
101 return convertValue((TypedInit*)UI);
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);
111 virtual Init *convertValue( FieldInit *FI) {
112 return convertValue((TypedInit*)FI);
115 public: // These methods should only be called by subclasses of RecTy.
116 // baseClassOf - These virtual methods should be overloaded to return true iff
117 // all values of type 'RHS' can be converted to the 'this' type.
118 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
119 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
120 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
121 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
122 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
123 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
124 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
125 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
128 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
134 /// BitRecTy - 'bit' - Represent a single bit
136 class BitRecTy : public RecTy {
137 static BitRecTy Shared;
140 static BitRecTy *get() { return &Shared; }
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);}
159 std::string getAsString() const { return "bit"; }
161 bool typeIsConvertibleTo(const RecTy *RHS) const {
162 return RHS->baseClassOf(this);
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; }
176 // BitsRecTy - 'bits<n>' - Represent a fixed number of bits
177 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
179 class BitsRecTy : public RecTy {
181 explicit BitsRecTy(unsigned Sz) : Size(Sz) {}
183 static BitsRecTy *get(unsigned Sz);
185 unsigned getNumBits() const { return Size; }
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);}
204 std::string getAsString() const;
206 bool typeIsConvertibleTo(const RecTy *RHS) const {
207 return RHS->baseClassOf(this);
209 virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; }
210 virtual bool baseClassOf(const BitsRecTy *RHS) const {
211 return RHS->Size == Size;
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; }
223 /// IntRecTy - 'int' - Represent an integer value of no particular size
225 class IntRecTy : public RecTy {
226 static IntRecTy Shared;
229 static IntRecTy *get() { return &Shared; }
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);}
248 std::string getAsString() const { return "int"; }
250 bool typeIsConvertibleTo(const RecTy *RHS) const {
251 return RHS->baseClassOf(this);
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; }
265 /// StringRecTy - 'string' - Represent an string value
267 class StringRecTy : public RecTy {
268 static StringRecTy Shared;
271 static StringRecTy *get() { return &Shared; }
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);}
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);}
291 std::string getAsString() const { return "string"; }
293 bool typeIsConvertibleTo(const RecTy *RHS) const {
294 return RHS->baseClassOf(this);
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; }
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.
312 class ListRecTy : public RecTy {
314 explicit ListRecTy(RecTy *T) : Ty(T) {}
315 friend ListRecTy *RecTy::getListTy();
317 static ListRecTy *get(RecTy *T) { return T->getListTy(); }
318 RecTy *getElementType() const { return Ty; }
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);}
337 std::string getAsString() const;
339 bool typeIsConvertibleTo(const RecTy *RHS) const {
340 return RHS->baseClassOf(this);
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);
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; }
355 /// CodeRecTy - 'code' - Represent an code fragment, function or method.
357 class CodeRecTy : public RecTy {
358 static CodeRecTy Shared;
361 static CodeRecTy *get() { return &Shared; }
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);}
380 std::string getAsString() const { return "code"; }
382 bool typeIsConvertibleTo(const RecTy *RHS) const {
383 return RHS->baseClassOf(this);
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; }
395 /// DagRecTy - 'dag' - Represent a dag fragment
397 class DagRecTy : public RecTy {
398 static DagRecTy Shared;
401 static DagRecTy *get() { return &Shared; }
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);}
420 std::string getAsString() const { return "dag"; }
422 bool typeIsConvertibleTo(const RecTy *RHS) const {
423 return RHS->baseClassOf(this);
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; }
437 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
440 class RecordRecTy : public RecTy {
442 explicit RecordRecTy(Record *R) : Rec(R) {}
445 static RecordRecTy *get(Record *R);
447 Record *getRecord() const { return Rec; }
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);}
466 std::string getAsString() const;
468 bool typeIsConvertibleTo(const RecTy *RHS) const {
469 return RHS->baseClassOf(this);
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;
481 /// resolveTypes - Find a common type that T1 and T2 convert to.
482 /// Return 0 if no such type exists.
484 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
486 //===----------------------------------------------------------------------===//
487 // Initializer Classes
488 //===----------------------------------------------------------------------===//
491 Init(const Init &); // Do not define.
492 Init &operator=(const Init &); // Do not define.
500 /// isComplete - This virtual method should be overridden by values that may
501 /// not be completely specified yet.
502 virtual bool isComplete() const { return true; }
504 /// print - Print out this value.
505 void print(raw_ostream &OS) const { OS << getAsString(); }
507 /// getAsString - Convert this value to a string form.
508 virtual std::string getAsString() const = 0;
509 /// getAsUnquotedString - Convert this value to a string form,
510 /// without adding quote markers. This primaruly affects
511 /// StringInits where we will not surround the string value with
513 virtual std::string getAsUnquotedString() const { return getAsString(); }
515 /// dump - Debugging method that may be called through a debugger, just
516 /// invokes print on stderr.
519 /// convertInitializerTo - This virtual function is a simple call-back
520 /// function that should be overridden to call the appropriate
521 /// RecTy::convertValue method.
523 virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
525 /// convertInitializerBitRange - This method is used to implement the bitrange
526 /// selection operator. Given an initializer, it selects the specified bits
527 /// out, returning them as a new init of bits type. If it is not legal to use
528 /// the bit subscript operator on this initializer, return null.
531 convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
535 /// convertInitListSlice - This method is used to implement the list slice
536 /// selection operator. Given an initializer, it selects the specified list
537 /// elements, returning them as a new init of list type. If it is not legal
538 /// to take a slice of this, return null.
541 convertInitListSlice(const std::vector<unsigned> &Elements) const {
545 /// getFieldType - This method is used to implement the FieldInit class.
546 /// Implementors of this method should return the type of the named field if
547 /// they are of record type.
549 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
551 /// getFieldInit - This method complements getFieldType to return the
552 /// initializer for the specified field. If getFieldType returns non-null
553 /// this method should return non-null, otherwise it returns null.
555 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
556 const std::string &FieldName) const {
560 /// resolveReferences - This method is used by classes that refer to other
561 /// variables which may not be defined at the time the expression is formed.
562 /// If a value is set for the variable later, this method will be called on
563 /// users of the value to allow the value to propagate out.
565 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
566 return const_cast<Init *>(this);
570 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
571 I.print(OS); return OS;
574 /// TypedInit - This is the common super-class of types that have a specific,
577 class TypedInit : public Init {
580 TypedInit(const TypedInit &Other); // Do not define.
581 TypedInit &operator=(const TypedInit &Other); // Do not define.
584 explicit TypedInit(RecTy *T) : Ty(T) {}
587 RecTy *getType() const { return Ty; }
590 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
592 convertInitListSlice(const std::vector<unsigned> &Elements) const;
594 /// getFieldType - This method is used to implement the FieldInit class.
595 /// Implementors of this method should return the type of the named field if
596 /// they are of record type.
598 virtual RecTy *getFieldType(const std::string &FieldName) const;
600 /// resolveBitReference - This method is used to implement
601 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
602 /// simply return the resolved value, otherwise we return null.
604 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
605 unsigned Bit) const = 0;
607 /// resolveListElementReference - This method is used to implement
608 /// VarListElementInit::resolveReferences. If the list element is resolvable
609 /// now, we return the resolved value, otherwise we return null.
610 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
611 unsigned Elt) const = 0;
615 /// UnsetInit - ? - Represents an uninitialized value
617 class UnsetInit : public Init {
618 UnsetInit() : Init() {}
619 UnsetInit(const UnsetInit &); // Do not define.
620 UnsetInit &operator=(const UnsetInit &Other); // Do not define.
623 static UnsetInit *get();
625 virtual Init *convertInitializerTo(RecTy *Ty) const {
626 return Ty->convertValue(const_cast<UnsetInit *>(this));
629 virtual bool isComplete() const { return false; }
630 virtual std::string getAsString() const { return "?"; }
634 /// BitInit - true/false - Represent a concrete initializer for a bit.
636 class BitInit : public Init {
639 explicit BitInit(bool V) : Value(V) {}
640 BitInit(const BitInit &Other); // Do not define.
641 BitInit &operator=(BitInit &Other); // Do not define.
644 static BitInit *get(bool V);
646 bool getValue() const { return Value; }
648 virtual Init *convertInitializerTo(RecTy *Ty) const {
649 return Ty->convertValue(const_cast<BitInit *>(this));
652 virtual std::string getAsString() const { return Value ? "1" : "0"; }
655 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
656 /// It contains a vector of bits, whose size is determined by the type.
658 class BitsInit : public Init, public FoldingSetNode {
659 std::vector<Init*> Bits;
661 BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
663 BitsInit(const BitsInit &Other); // Do not define.
664 BitsInit &operator=(const BitsInit &Other); // Do not define.
667 static BitsInit *get(ArrayRef<Init *> Range);
669 void Profile(FoldingSetNodeID &ID) const;
671 unsigned getNumBits() const { return Bits.size(); }
673 Init *getBit(unsigned Bit) const {
674 assert(Bit < Bits.size() && "Bit index out of range!");
678 virtual Init *convertInitializerTo(RecTy *Ty) const {
679 return Ty->convertValue(const_cast<BitsInit *>(this));
682 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
684 virtual bool isComplete() const {
685 for (unsigned i = 0; i != getNumBits(); ++i)
686 if (!getBit(i)->isComplete()) return false;
689 bool allInComplete() const {
690 for (unsigned i = 0; i != getNumBits(); ++i)
691 if (getBit(i)->isComplete()) return false;
694 virtual std::string getAsString() const;
696 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
700 /// IntInit - 7 - Represent an initalization by a literal integer value.
702 class IntInit : public TypedInit {
705 explicit IntInit(int64_t V) : TypedInit(IntRecTy::get()), Value(V) {}
707 IntInit(const IntInit &Other); // Do not define.
708 IntInit &operator=(const IntInit &Other); // Do note define.
711 static IntInit *get(int64_t V);
713 int64_t getValue() const { return Value; }
715 virtual Init *convertInitializerTo(RecTy *Ty) const {
716 return Ty->convertValue(const_cast<IntInit *>(this));
719 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
721 virtual std::string getAsString() const;
723 /// resolveBitReference - This method is used to implement
724 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
725 /// simply return the resolved value, otherwise we return null.
727 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
728 unsigned Bit) const {
729 assert(0 && "Illegal bit reference off int");
733 /// resolveListElementReference - This method is used to implement
734 /// VarListElementInit::resolveReferences. If the list element is resolvable
735 /// now, we return the resolved value, otherwise we return null.
736 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
737 unsigned Elt) const {
738 assert(0 && "Illegal element reference off int");
744 /// StringInit - "foo" - Represent an initialization by a string value.
746 class StringInit : public TypedInit {
749 explicit StringInit(const std::string &V)
750 : TypedInit(StringRecTy::get()), Value(V) {}
752 StringInit(const StringInit &Other); // Do not define.
753 StringInit &operator=(const StringInit &Other); // Do not define.
756 static StringInit *get(const std::string &V);
758 const std::string &getValue() const { return Value; }
760 virtual Init *convertInitializerTo(RecTy *Ty) const {
761 return Ty->convertValue(const_cast<StringInit *>(this));
764 virtual std::string getAsString() const { return "\"" + Value + "\""; }
765 virtual std::string getAsUnquotedString() const { return Value; }
767 /// resolveBitReference - This method is used to implement
768 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
769 /// simply return the resolved value, otherwise we return null.
771 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
772 unsigned Bit) const {
773 assert(0 && "Illegal bit reference off string");
777 /// resolveListElementReference - This method is used to implement
778 /// VarListElementInit::resolveReferences. If the list element is resolvable
779 /// now, we return the resolved value, otherwise we return null.
780 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
781 unsigned Elt) const {
782 assert(0 && "Illegal element reference off string");
787 /// CodeInit - "[{...}]" - Represent a code fragment.
789 class CodeInit : public Init {
792 explicit CodeInit(const std::string &V) : Value(V) {}
794 CodeInit(const CodeInit &Other); // Do not define.
795 CodeInit &operator=(const CodeInit &Other); // Do not define.
798 static CodeInit *get(const std::string &V);
800 const std::string &getValue() const { return Value; }
802 virtual Init *convertInitializerTo(RecTy *Ty) const {
803 return Ty->convertValue(const_cast<CodeInit *>(this));
806 virtual std::string getAsString() const { return "[{" + Value + "}]"; }
809 /// ListInit - [AL, AH, CL] - Represent a list of defs
811 class ListInit : public TypedInit, public FoldingSetNode {
812 std::vector<Init*> Values;
814 typedef std::vector<Init*>::const_iterator const_iterator;
817 explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
818 : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
820 ListInit(const ListInit &Other); // Do not define.
821 ListInit &operator=(const ListInit &Other); // Do not define.
824 static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
826 void Profile(FoldingSetNodeID &ID) const;
828 unsigned getSize() const { return Values.size(); }
829 Init *getElement(unsigned i) const {
830 assert(i < Values.size() && "List element index out of range!");
834 Record *getElementAsRecord(unsigned i) const;
836 Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
838 virtual Init *convertInitializerTo(RecTy *Ty) const {
839 return Ty->convertValue(const_cast<ListInit *>(this));
842 /// resolveReferences - This method is used by classes that refer to other
843 /// variables which may not be defined at the time they expression is formed.
844 /// If a value is set for the variable later, this method will be called on
845 /// users of the value to allow the value to propagate out.
847 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
849 virtual std::string getAsString() const;
851 ArrayRef<Init*> getValues() const { return Values; }
853 inline const_iterator begin() const { return Values.begin(); }
854 inline const_iterator end () const { return Values.end(); }
856 inline size_t size () const { return Values.size(); }
857 inline bool empty() const { return Values.empty(); }
859 /// resolveBitReference - This method is used to implement
860 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
861 /// simply return the resolved value, otherwise we return null.
863 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
864 unsigned Bit) const {
865 assert(0 && "Illegal bit reference off list");
869 /// resolveListElementReference - This method is used to implement
870 /// VarListElementInit::resolveReferences. If the list element is resolvable
871 /// now, we return the resolved value, otherwise we return null.
872 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
877 /// OpInit - Base class for operators
879 class OpInit : public TypedInit {
880 OpInit(const OpInit &Other); // Do not define.
881 OpInit &operator=(OpInit &Other); // Do not define.
884 explicit OpInit(RecTy *Type) : TypedInit(Type) {}
887 // Clone - Clone this operator, replacing arguments with the new list
888 virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
890 virtual int getNumOperands() const = 0;
891 virtual Init *getOperand(int i) const = 0;
893 // Fold - If possible, fold this to a simpler init. Return this if not
895 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
897 virtual Init *convertInitializerTo(RecTy *Ty) const {
898 return Ty->convertValue(const_cast<OpInit *>(this));
901 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
903 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
908 /// UnOpInit - !op (X) - Transform an init.
910 class UnOpInit : public OpInit {
912 enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
917 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
918 : OpInit(Type), Opc(opc), LHS(lhs) {}
920 UnOpInit(const UnOpInit &Other); // Do not define.
921 UnOpInit &operator=(const UnOpInit &Other); // Do not define.
924 static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
926 // Clone - Clone this operator, replacing arguments with the new list
927 virtual OpInit *clone(std::vector<Init *> &Operands) const {
928 assert(Operands.size() == 1 &&
929 "Wrong number of operands for unary operation");
930 return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
933 int getNumOperands() const { return 1; }
934 Init *getOperand(int i) const {
935 assert(i == 0 && "Invalid operand id for unary operator");
939 UnaryOp getOpcode() const { return Opc; }
940 Init *getOperand() const { return LHS; }
942 // Fold - If possible, fold this to a simpler init. Return this if not
944 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
946 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
948 virtual std::string getAsString() const;
951 /// BinOpInit - !op (X, Y) - Combine two inits.
953 class BinOpInit : public OpInit {
955 enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
960 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
961 OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {}
963 BinOpInit(const BinOpInit &Other); // Do not define.
964 BinOpInit &operator=(const BinOpInit &Other); // Do not define.
967 static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
970 // Clone - Clone this operator, replacing arguments with the new list
971 virtual OpInit *clone(std::vector<Init *> &Operands) const {
972 assert(Operands.size() == 2 &&
973 "Wrong number of operands for binary operation");
974 return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
977 int getNumOperands() const { return 2; }
978 Init *getOperand(int i) const {
979 assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
987 BinaryOp getOpcode() const { return Opc; }
988 Init *getLHS() const { return LHS; }
989 Init *getRHS() const { return RHS; }
991 // Fold - If possible, fold this to a simpler init. Return this if not
993 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
995 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
997 virtual std::string getAsString() const;
1000 /// TernOpInit - !op (X, Y, Z) - Combine two inits.
1002 class TernOpInit : public OpInit {
1004 enum TernaryOp { SUBST, FOREACH, IF };
1007 Init *LHS, *MHS, *RHS;
1009 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
1011 OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
1013 TernOpInit(const TernOpInit &Other); // Do not define.
1014 TernOpInit &operator=(const TernOpInit &Other); // Do not define.
1017 static TernOpInit *get(TernaryOp opc, Init *lhs,
1018 Init *mhs, Init *rhs,
1021 // Clone - Clone this operator, replacing arguments with the new list
1022 virtual OpInit *clone(std::vector<Init *> &Operands) const {
1023 assert(Operands.size() == 3 &&
1024 "Wrong number of operands for ternary operation");
1025 return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
1029 int getNumOperands() const { return 3; }
1030 Init *getOperand(int i) const {
1031 assert((i == 0 || i == 1 || i == 2) &&
1032 "Invalid operand id for ternary operator");
1035 } else if (i == 1) {
1042 TernaryOp getOpcode() const { return Opc; }
1043 Init *getLHS() const { return LHS; }
1044 Init *getMHS() const { return MHS; }
1045 Init *getRHS() const { return RHS; }
1047 // Fold - If possible, fold this to a simpler init. Return this if not
1048 // possible to fold.
1049 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
1051 virtual bool isComplete() const { return false; }
1053 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1055 virtual std::string getAsString() const;
1059 /// VarInit - 'Opcode' - Represent a reference to an entire variable object.
1061 class VarInit : public TypedInit {
1062 std::string VarName;
1064 explicit VarInit(const std::string &VN, RecTy *T)
1065 : TypedInit(T), VarName(VN) {}
1067 VarInit(const VarInit &Other); // Do not define.
1068 VarInit &operator=(const VarInit &Other); // Do not define.
1071 static VarInit *get(const std::string &VN, RecTy *T);
1072 static VarInit *get(Init *VN, RecTy *T);
1074 virtual Init *convertInitializerTo(RecTy *Ty) const {
1075 return Ty->convertValue(const_cast<VarInit *>(this));
1078 const std::string &getName() const { return VarName; }
1080 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1081 unsigned Bit) const;
1082 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1083 unsigned Elt) const;
1085 virtual RecTy *getFieldType(const std::string &FieldName) const;
1086 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1087 const std::string &FieldName) const;
1089 /// resolveReferences - This method is used by classes that refer to other
1090 /// variables which may not be defined at the time they expression is formed.
1091 /// If a value is set for the variable later, this method will be called on
1092 /// users of the value to allow the value to propagate out.
1094 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1096 virtual std::string getAsString() const { return VarName; }
1100 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
1102 class VarBitInit : public Init {
1106 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
1107 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
1108 ((BitsRecTy*)T->getType())->getNumBits() > B &&
1109 "Illegal VarBitInit expression!");
1112 VarBitInit(const VarBitInit &Other); // Do not define.
1113 VarBitInit &operator=(const VarBitInit &Other); // Do not define.
1116 static VarBitInit *get(TypedInit *T, unsigned B);
1118 virtual Init *convertInitializerTo(RecTy *Ty) const {
1119 return Ty->convertValue(const_cast<VarBitInit *>(this));
1122 TypedInit *getVariable() const { return TI; }
1123 unsigned getBitNum() const { return Bit; }
1125 virtual std::string getAsString() const;
1126 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1129 /// VarListElementInit - List[4] - Represent access to one element of a var or
1131 class VarListElementInit : public TypedInit {
1135 VarListElementInit(TypedInit *T, unsigned E)
1136 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1138 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
1139 "Illegal VarBitInit expression!");
1142 VarListElementInit(const VarListElementInit &Other); // Do not define.
1143 VarListElementInit &operator=(const VarListElementInit &Other); // Do
1148 static VarListElementInit *get(TypedInit *T, unsigned E);
1150 virtual Init *convertInitializerTo(RecTy *Ty) const {
1151 return Ty->convertValue(const_cast<VarListElementInit *>(this));
1154 TypedInit *getVariable() const { return TI; }
1155 unsigned getElementNum() const { return Element; }
1157 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1158 unsigned Bit) const;
1160 /// resolveListElementReference - This method is used to implement
1161 /// VarListElementInit::resolveReferences. If the list element is resolvable
1162 /// now, we return the resolved value, otherwise we return null.
1163 virtual Init *resolveListElementReference(Record &R,
1164 const RecordVal *RV,
1165 unsigned Elt) const;
1167 virtual std::string getAsString() const;
1168 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1171 /// DefInit - AL - Represent a reference to a 'def' in the description
1173 class DefInit : public TypedInit {
1176 DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {}
1177 friend class Record;
1179 DefInit(const DefInit &Other); // Do not define.
1180 DefInit &operator=(const DefInit &Other); // Do not define.
1183 static DefInit *get(Record*);
1185 virtual Init *convertInitializerTo(RecTy *Ty) const {
1186 return Ty->convertValue(const_cast<DefInit *>(this));
1189 Record *getDef() const { return Def; }
1191 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
1193 virtual RecTy *getFieldType(const std::string &FieldName) const;
1194 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1195 const std::string &FieldName) const;
1197 virtual std::string getAsString() const;
1199 /// resolveBitReference - This method is used to implement
1200 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
1201 /// simply return the resolved value, otherwise we return null.
1203 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1204 unsigned Bit) const {
1205 assert(0 && "Illegal bit reference off def");
1209 /// resolveListElementReference - This method is used to implement
1210 /// VarListElementInit::resolveReferences. If the list element is resolvable
1211 /// now, we return the resolved value, otherwise we return null.
1212 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1213 unsigned Elt) const {
1214 assert(0 && "Illegal element reference off def");
1220 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
1222 class FieldInit : public TypedInit {
1223 Init *Rec; // Record we are referring to
1224 std::string FieldName; // Field we are accessing
1226 FieldInit(Init *R, const std::string &FN)
1227 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
1228 assert(getType() && "FieldInit with non-record type!");
1231 FieldInit(const FieldInit &Other); // Do not define.
1232 FieldInit &operator=(const FieldInit &Other); // Do not define.
1235 static FieldInit *get(Init *R, const std::string &FN);
1236 static FieldInit *get(Init *R, const Init *FN);
1238 virtual Init *convertInitializerTo(RecTy *Ty) const {
1239 return Ty->convertValue(const_cast<FieldInit *>(this));
1242 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1243 unsigned Bit) const;
1244 virtual Init *resolveListElementReference(Record &R,
1245 const RecordVal *RV,
1246 unsigned Elt) const;
1248 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1250 virtual std::string getAsString() const {
1251 return Rec->getAsString() + "." + FieldName;
1255 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
1256 /// to have at least one value then a (possibly empty) list of arguments. Each
1257 /// argument can have a name associated with it.
1259 class DagInit : public TypedInit, public FoldingSetNode {
1261 std::string ValName;
1262 std::vector<Init*> Args;
1263 std::vector<std::string> ArgNames;
1265 DagInit(Init *V, const std::string &VN,
1266 ArrayRef<Init *> ArgRange,
1267 ArrayRef<std::string> NameRange)
1268 : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
1269 Args(ArgRange.begin(), ArgRange.end()),
1270 ArgNames(NameRange.begin(), NameRange.end()) {}
1272 DagInit(const DagInit &Other); // Do not define.
1273 DagInit &operator=(const DagInit &Other); // Do not define.
1276 static DagInit *get(Init *V, const std::string &VN,
1277 ArrayRef<Init *> ArgRange,
1278 ArrayRef<std::string> NameRange);
1279 static DagInit *get(Init *V, const std::string &VN,
1281 std::pair<Init*, std::string> > &args);
1283 void Profile(FoldingSetNodeID &ID) const;
1285 virtual Init *convertInitializerTo(RecTy *Ty) const {
1286 return Ty->convertValue(const_cast<DagInit *>(this));
1289 Init *getOperator() const { return Val; }
1291 const std::string &getName() const { return ValName; }
1293 unsigned getNumArgs() const { return Args.size(); }
1294 Init *getArg(unsigned Num) const {
1295 assert(Num < Args.size() && "Arg number out of range!");
1298 const std::string &getArgName(unsigned Num) const {
1299 assert(Num < ArgNames.size() && "Arg number out of range!");
1300 return ArgNames[Num];
1303 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1305 virtual std::string getAsString() const;
1307 typedef std::vector<Init*>::const_iterator const_arg_iterator;
1308 typedef std::vector<std::string>::const_iterator const_name_iterator;
1310 inline const_arg_iterator arg_begin() const { return Args.begin(); }
1311 inline const_arg_iterator arg_end () const { return Args.end(); }
1313 inline size_t arg_size () const { return Args.size(); }
1314 inline bool arg_empty() const { return Args.empty(); }
1316 inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1317 inline const_name_iterator name_end () const { return ArgNames.end(); }
1319 inline size_t name_size () const { return ArgNames.size(); }
1320 inline bool name_empty() const { return ArgNames.empty(); }
1322 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1323 unsigned Bit) const {
1324 assert(0 && "Illegal bit reference off dag");
1328 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1329 unsigned Elt) const {
1330 assert(0 && "Illegal element reference off dag");
1335 //===----------------------------------------------------------------------===//
1336 // High-Level Classes
1337 //===----------------------------------------------------------------------===//
1345 RecordVal(Init *N, RecTy *T, unsigned P);
1346 RecordVal(const std::string &N, RecTy *T, unsigned P);
1348 const std::string &getName() const;
1350 unsigned getPrefix() const { return Prefix; }
1351 RecTy *getType() const { return Ty; }
1352 Init *getValue() const { return Value; }
1354 bool setValue(Init *V) {
1356 Value = V->convertInitializerTo(Ty);
1364 void print(raw_ostream &OS, bool PrintSem = true) const;
1367 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1368 RV.print(OS << " ");
1373 static unsigned LastID;
1375 // Unique record ID.
1379 std::vector<std::string> TemplateArgs;
1380 std::vector<RecordVal> Values;
1381 std::vector<Record*> SuperClasses;
1383 // Tracks Record instances. Not owned by Record.
1384 RecordKeeper &TrackedRecords;
1392 // Constructs a record.
1393 explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) :
1394 ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records), TheInit(0) {}
1398 static unsigned getNewUID() { return LastID++; }
1401 unsigned getID() const { return ID; }
1403 const std::string &getName() const;
1404 void setName(Init *Name); // Also updates RecordKeeper.
1405 void setName(const std::string &Name); // Also updates RecordKeeper.
1407 SMLoc getLoc() const { return Loc; }
1409 /// get the corresponding DefInit.
1410 DefInit *getDefInit();
1412 const std::vector<std::string> &getTemplateArgs() const {
1413 return TemplateArgs;
1415 const std::vector<RecordVal> &getValues() const { return Values; }
1416 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
1418 bool isTemplateArg(StringRef Name) const {
1419 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
1420 if (TemplateArgs[i] == Name) return true;
1424 const RecordVal *getValue(StringRef Name) const {
1425 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1426 if (Values[i].getName() == Name) return &Values[i];
1429 RecordVal *getValue(StringRef Name) {
1430 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1431 if (Values[i].getName() == Name) return &Values[i];
1435 void addTemplateArg(StringRef Name) {
1436 assert(!isTemplateArg(Name) && "Template arg already defined!");
1437 TemplateArgs.push_back(Name);
1440 void addValue(const RecordVal &RV) {
1441 assert(getValue(RV.getName()) == 0 && "Value already added!");
1442 Values.push_back(RV);
1445 void removeValue(StringRef Name) {
1446 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1447 if (Values[i].getName() == Name) {
1448 Values.erase(Values.begin()+i);
1451 assert(0 && "Cannot remove an entry that does not exist!");
1454 bool isSubClassOf(const Record *R) const {
1455 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1456 if (SuperClasses[i] == R)
1461 bool isSubClassOf(StringRef Name) const {
1462 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1463 if (SuperClasses[i]->getName() == Name)
1468 void addSuperClass(Record *R) {
1469 assert(!isSubClassOf(R) && "Already subclassing record!");
1470 SuperClasses.push_back(R);
1473 /// resolveReferences - If there are any field references that refer to fields
1474 /// that have been filled in, we can propagate the values now.
1476 void resolveReferences() { resolveReferencesTo(0); }
1478 /// resolveReferencesTo - If anything in this record refers to RV, replace the
1479 /// reference to RV with the RHS of RV. If RV is null, we resolve all
1480 /// possible references.
1481 void resolveReferencesTo(const RecordVal *RV);
1483 RecordKeeper &getRecords() const {
1484 return TrackedRecords;
1489 //===--------------------------------------------------------------------===//
1490 // High-level methods useful to tablegen back-ends
1493 /// getValueInit - Return the initializer for a value with the specified name,
1494 /// or throw an exception if the field does not exist.
1496 Init *getValueInit(StringRef FieldName) const;
1498 /// getValueAsString - This method looks up the specified field and returns
1499 /// its value as a string, throwing an exception if the field does not exist
1500 /// or if the value is not a string.
1502 std::string getValueAsString(StringRef FieldName) const;
1504 /// getValueAsBitsInit - This method looks up the specified field and returns
1505 /// its value as a BitsInit, throwing an exception if the field does not exist
1506 /// or if the value is not the right type.
1508 BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1510 /// getValueAsListInit - This method looks up the specified field and returns
1511 /// its value as a ListInit, throwing an exception if the field does not exist
1512 /// or if the value is not the right type.
1514 ListInit *getValueAsListInit(StringRef FieldName) const;
1516 /// getValueAsListOfDefs - This method looks up the specified field and
1517 /// returns its value as a vector of records, throwing an exception if the
1518 /// field does not exist or if the value is not the right type.
1520 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1522 /// getValueAsListOfInts - This method looks up the specified field and
1523 /// returns its value as a vector of integers, throwing an exception if the
1524 /// field does not exist or if the value is not the right type.
1526 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1528 /// getValueAsListOfStrings - This method looks up the specified field and
1529 /// returns its value as a vector of strings, throwing an exception if the
1530 /// field does not exist or if the value is not the right type.
1532 std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1534 /// getValueAsDef - This method looks up the specified field and returns its
1535 /// value as a Record, throwing an exception if the field does not exist or if
1536 /// the value is not the right type.
1538 Record *getValueAsDef(StringRef FieldName) const;
1540 /// getValueAsBit - This method looks up the specified field and returns its
1541 /// value as a bit, throwing an exception if the field does not exist or if
1542 /// the value is not the right type.
1544 bool getValueAsBit(StringRef FieldName) const;
1546 /// getValueAsInt - This method looks up the specified field and returns its
1547 /// value as an int64_t, throwing an exception if the field does not exist or
1548 /// if the value is not the right type.
1550 int64_t getValueAsInt(StringRef FieldName) const;
1552 /// getValueAsDag - This method looks up the specified field and returns its
1553 /// value as an Dag, throwing an exception if the field does not exist or if
1554 /// the value is not the right type.
1556 DagInit *getValueAsDag(StringRef FieldName) const;
1558 /// getValueAsCode - This method looks up the specified field and returns
1559 /// its value as the string data in a CodeInit, throwing an exception if the
1560 /// field does not exist or if the value is not a code object.
1562 std::string getValueAsCode(StringRef FieldName) const;
1565 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1568 Record Rec; // Placeholder for template args and Name.
1569 typedef std::vector<Record*> RecordVector;
1570 RecordVector DefPrototypes;
1574 MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1575 Rec(Name, Loc, Records) {}
1578 class RecordKeeper {
1579 std::map<std::string, Record*> Classes, Defs;
1582 for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1583 E = Classes.end(); I != E; ++I)
1585 for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1586 E = Defs.end(); I != E; ++I)
1590 const std::map<std::string, Record*> &getClasses() const { return Classes; }
1591 const std::map<std::string, Record*> &getDefs() const { return Defs; }
1593 Record *getClass(const std::string &Name) const {
1594 std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1595 return I == Classes.end() ? 0 : I->second;
1597 Record *getDef(const std::string &Name) const {
1598 std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1599 return I == Defs.end() ? 0 : I->second;
1601 void addClass(Record *R) {
1602 assert(getClass(R->getName()) == 0 && "Class already exists!");
1603 Classes.insert(std::make_pair(R->getName(), R));
1605 void addDef(Record *R) {
1606 assert(getDef(R->getName()) == 0 && "Def already exists!");
1607 Defs.insert(std::make_pair(R->getName(), R));
1610 /// removeClass - Remove, but do not delete, the specified record.
1612 void removeClass(const std::string &Name) {
1613 assert(Classes.count(Name) && "Class does not exist!");
1614 Classes.erase(Name);
1616 /// removeDef - Remove, but do not delete, the specified record.
1618 void removeDef(const std::string &Name) {
1619 assert(Defs.count(Name) && "Def does not exist!");
1623 //===--------------------------------------------------------------------===//
1624 // High-level helper methods, useful for tablegen backends...
1626 /// getAllDerivedDefinitions - This method returns all concrete definitions
1627 /// that derive from the specified class name. If a class with the specified
1628 /// name does not exist, an exception is thrown.
1629 std::vector<Record*>
1630 getAllDerivedDefinitions(const std::string &ClassName) const;
1635 /// LessRecord - Sorting predicate to sort record pointers by name.
1638 bool operator()(const Record *Rec1, const Record *Rec2) const {
1639 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1643 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1646 struct LessRecordFieldName {
1647 bool operator()(const Record *Rec1, const Record *Rec2) const {
1648 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1652 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1654 } // End llvm namespace