1 //===- Record.h - Classes to represent Table Records ------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the main TableGen data structures, including the TableGen
11 // types, values, and high-level data structures.
13 //===----------------------------------------------------------------------===//
26 // RecTy subclasses...
51 class VarListElementInit;
56 //===----------------------------------------------------------------------===//
58 //===----------------------------------------------------------------------===//
63 virtual void print(std::ostream &OS) const = 0;
66 /// typeIsConvertibleTo - Return true if all values of 'this' type can be
67 /// converted to the specified type.
68 virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0;
70 public: // These methods should only be called from subclasses of Init
71 virtual Init *convertValue( UnsetInit *UI) { return 0; }
72 virtual Init *convertValue( BitInit *BI) { return 0; }
73 virtual Init *convertValue( BitsInit *BI) { return 0; }
74 virtual Init *convertValue( IntInit *II) { return 0; }
75 virtual Init *convertValue(StringInit *SI) { return 0; }
76 virtual Init *convertValue( ListInit *LI) { return 0; }
77 virtual Init *convertValue( CodeInit *CI) { return 0; }
78 virtual Init *convertValue(VarBitInit *VB) { return 0; }
79 virtual Init *convertValue( DefInit *DI) { return 0; }
80 virtual Init *convertValue( DagInit *DI) { return 0; }
81 virtual Init *convertValue( TypedInit *TI) { return 0; }
82 virtual Init *convertValue( VarInit *VI) {
83 return convertValue((TypedInit*)VI);
85 virtual Init *convertValue( FieldInit *FI) {
86 return convertValue((TypedInit*)FI);
89 public: // These methods should only be called by subclasses of RecTy.
90 // baseClassOf - These virtual methods should be overloaded to return true iff
91 // all values of type 'RHS' can be converted to the 'this' type.
92 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
93 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
94 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
95 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
96 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
97 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
98 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
99 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
102 inline std::ostream &operator<<(std::ostream &OS, const RecTy &Ty) {
108 /// BitRecTy - 'bit' - Represent a single bit
110 class BitRecTy : public RecTy {
112 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
113 virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
114 virtual Init *convertValue( BitsInit *BI);
115 virtual Init *convertValue( IntInit *II);
116 virtual Init *convertValue(StringInit *SI) { return 0; }
117 virtual Init *convertValue( ListInit *LI) { return 0; }
118 virtual Init *convertValue( CodeInit *CI) { return 0; }
119 virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
120 virtual Init *convertValue( DefInit *DI) { return 0; }
121 virtual Init *convertValue( DagInit *DI) { return 0; }
122 virtual Init *convertValue( TypedInit *TI);
123 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
124 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
126 void print(std::ostream &OS) const { OS << "bit"; }
128 bool typeIsConvertibleTo(const RecTy *RHS) const {
129 return RHS->baseClassOf(this);
131 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
132 virtual bool baseClassOf(const BitsRecTy *RHS) const;
133 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
134 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
135 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
136 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
137 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
138 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
143 // BitsRecTy - 'bits<n>' - Represent a fixed number of bits
144 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
146 class BitsRecTy : public RecTy {
149 BitsRecTy(unsigned Sz) : Size(Sz) {}
151 unsigned getNumBits() const { return Size; }
153 virtual Init *convertValue( UnsetInit *UI);
154 virtual Init *convertValue( BitInit *UI);
155 virtual Init *convertValue( BitsInit *BI);
156 virtual Init *convertValue( IntInit *II);
157 virtual Init *convertValue(StringInit *SI) { return 0; }
158 virtual Init *convertValue( ListInit *LI) { return 0; }
159 virtual Init *convertValue( CodeInit *CI) { return 0; }
160 virtual Init *convertValue(VarBitInit *VB) { return 0; }
161 virtual Init *convertValue( DefInit *DI) { return 0; }
162 virtual Init *convertValue( DagInit *DI) { return 0; }
163 virtual Init *convertValue( TypedInit *TI);
164 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
165 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
168 void print(std::ostream &OS) const { OS << "bits<" << Size << ">"; }
170 bool typeIsConvertibleTo(const RecTy *RHS) const {
171 return RHS->baseClassOf(this);
173 virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; }
174 virtual bool baseClassOf(const BitsRecTy *RHS) const {
175 return RHS->Size == Size;
177 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
178 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
179 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
180 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
181 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
182 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
187 /// IntRecTy - 'int' - Represent an integer value of no particular size
189 class IntRecTy : public RecTy {
191 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
192 virtual Init *convertValue( BitInit *BI);
193 virtual Init *convertValue( BitsInit *BI);
194 virtual Init *convertValue( IntInit *II) { return (Init*)II; }
195 virtual Init *convertValue(StringInit *SI) { return 0; }
196 virtual Init *convertValue( ListInit *LI) { return 0; }
197 virtual Init *convertValue( CodeInit *CI) { return 0; }
198 virtual Init *convertValue(VarBitInit *VB) { return 0; }
199 virtual Init *convertValue( DefInit *DI) { return 0; }
200 virtual Init *convertValue( DagInit *DI) { return 0; }
201 virtual Init *convertValue( TypedInit *TI);
202 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
203 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
206 void print(std::ostream &OS) const { OS << "int"; }
208 bool typeIsConvertibleTo(const RecTy *RHS) const {
209 return RHS->baseClassOf(this);
212 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
213 virtual bool baseClassOf(const BitsRecTy *RHS) const { return true; }
214 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
215 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
216 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
217 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
218 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
219 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
223 /// StringRecTy - 'string' - Represent an string value
225 class StringRecTy : public RecTy {
227 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
228 virtual Init *convertValue( BitInit *BI) { return 0; }
229 virtual Init *convertValue( BitsInit *BI) { return 0; }
230 virtual Init *convertValue( IntInit *II) { return 0; }
231 virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
232 virtual Init *convertValue( ListInit *LI) { return 0; }
233 virtual Init *convertValue( CodeInit *CI) { return 0; }
234 virtual Init *convertValue(VarBitInit *VB) { return 0; }
235 virtual Init *convertValue( DefInit *DI) { return 0; }
236 virtual Init *convertValue( DagInit *DI) { return 0; }
237 virtual Init *convertValue( TypedInit *TI);
238 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
239 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
241 void print(std::ostream &OS) const { OS << "string"; }
243 bool typeIsConvertibleTo(const RecTy *RHS) const {
244 return RHS->baseClassOf(this);
247 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
248 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
249 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
250 virtual bool baseClassOf(const StringRecTy *RHS) const { return true; }
251 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
252 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
253 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
254 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
257 // ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of
258 // the specified type.
259 /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must
260 /// be of the specified type.
262 class ListRecTy : public RecTy {
265 ListRecTy(RecTy *T) : Ty(T) {}
267 RecTy *getElementType() const { return Ty; }
269 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
270 virtual Init *convertValue( BitInit *BI) { return 0; }
271 virtual Init *convertValue( BitsInit *BI) { return 0; }
272 virtual Init *convertValue( IntInit *II) { return 0; }
273 virtual Init *convertValue(StringInit *SI) { return 0; }
274 virtual Init *convertValue( ListInit *LI);
275 virtual Init *convertValue( CodeInit *CI) { return 0; }
276 virtual Init *convertValue(VarBitInit *VB) { return 0; }
277 virtual Init *convertValue( DefInit *DI) { return 0; }
278 virtual Init *convertValue( DagInit *DI) { return 0; }
279 virtual Init *convertValue( TypedInit *TI);
280 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
281 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
283 void print(std::ostream &OS) const;
285 bool typeIsConvertibleTo(const RecTy *RHS) const {
286 return RHS->baseClassOf(this);
289 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
290 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
291 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
292 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
293 virtual bool baseClassOf(const ListRecTy *RHS) const {
294 return RHS->getElementType()->typeIsConvertibleTo(Ty);
296 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
297 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
298 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
301 /// CodeRecTy - 'code' - Represent an code fragment, function or method.
303 class CodeRecTy : public RecTy {
305 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
306 virtual Init *convertValue( BitInit *BI) { return 0; }
307 virtual Init *convertValue( BitsInit *BI) { return 0; }
308 virtual Init *convertValue( IntInit *II) { return 0; }
309 virtual Init *convertValue(StringInit *SI) { return 0; }
310 virtual Init *convertValue( ListInit *LI) { return 0; }
311 virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
312 virtual Init *convertValue(VarBitInit *VB) { return 0; }
313 virtual Init *convertValue( DefInit *DI) { return 0; }
314 virtual Init *convertValue( DagInit *DI) { return 0; }
315 virtual Init *convertValue( TypedInit *TI);
316 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
317 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
320 void print(std::ostream &OS) const { OS << "code"; }
322 bool typeIsConvertibleTo(const RecTy *RHS) const {
323 return RHS->baseClassOf(this);
325 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
326 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
327 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
328 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
329 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
330 virtual bool baseClassOf(const CodeRecTy *RHS) const { return true; }
331 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
332 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
335 /// DagRecTy - 'dag' - Represent a dag fragment
337 class DagRecTy : public RecTy {
339 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
340 virtual Init *convertValue( BitInit *BI) { return 0; }
341 virtual Init *convertValue( BitsInit *BI) { return 0; }
342 virtual Init *convertValue( IntInit *II) { return 0; }
343 virtual Init *convertValue(StringInit *SI) { return 0; }
344 virtual Init *convertValue( ListInit *LI) { return 0; }
345 virtual Init *convertValue( CodeInit *CI) { return 0; }
346 virtual Init *convertValue(VarBitInit *VB) { return 0; }
347 virtual Init *convertValue( DefInit *DI) { return 0; }
348 virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
349 virtual Init *convertValue( TypedInit *TI);
350 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
351 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
353 void print(std::ostream &OS) const { OS << "dag"; }
355 bool typeIsConvertibleTo(const RecTy *RHS) const {
356 return RHS->baseClassOf(this);
359 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
360 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
361 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
362 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
363 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
364 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
365 virtual bool baseClassOf(const DagRecTy *RHS) const { return true; }
366 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
370 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
373 class RecordRecTy : public RecTy {
376 RecordRecTy(Record *R) : Rec(R) {}
378 Record *getRecord() const { return Rec; }
380 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
381 virtual Init *convertValue( BitInit *BI) { return 0; }
382 virtual Init *convertValue( BitsInit *BI) { return 0; }
383 virtual Init *convertValue( IntInit *II) { return 0; }
384 virtual Init *convertValue(StringInit *SI) { return 0; }
385 virtual Init *convertValue( ListInit *LI) { return 0; }
386 virtual Init *convertValue( CodeInit *CI) { return 0; }
387 virtual Init *convertValue(VarBitInit *VB) { return 0; }
388 virtual Init *convertValue( DefInit *DI);
389 virtual Init *convertValue( DagInit *DI) { return 0; }
390 virtual Init *convertValue( TypedInit *VI);
391 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
392 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
394 void print(std::ostream &OS) const;
396 bool typeIsConvertibleTo(const RecTy *RHS) const {
397 return RHS->baseClassOf(this);
399 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
400 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
401 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
402 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
403 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
404 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
405 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
406 virtual bool baseClassOf(const RecordRecTy *RHS) const;
411 //===----------------------------------------------------------------------===//
412 // Initializer Classes
413 //===----------------------------------------------------------------------===//
418 /// isComplete - This virtual method should be overridden by values that may
419 /// not be completely specified yet.
420 virtual bool isComplete() const { return true; }
422 /// print - Print out this value.
423 virtual void print(std::ostream &OS) const = 0;
425 /// dump - Debugging method that may be called through a debugger, just
426 /// invokes print on cerr.
429 /// convertInitializerTo - This virtual function is a simple call-back
430 /// function that should be overridden to call the appropriate
431 /// RecTy::convertValue method.
433 virtual Init *convertInitializerTo(RecTy *Ty) = 0;
435 /// convertInitializerBitRange - This method is used to implement the bitrange
436 /// selection operator. Given an initializer, it selects the specified bits
437 /// out, returning them as a new init of bits type. If it is not legal to use
438 /// the bit subscript operator on this initializer, return null.
440 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) {
444 /// convertInitListSlice - This method is used to implement the list slice
445 /// selection operator. Given an initializer, it selects the specified list
446 /// elements, returning them as a new init of list type. If it is not legal
447 /// to take a slice of this, return null.
449 virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements) {
453 /// getFieldType - This method is used to implement the FieldInit class.
454 /// Implementors of this method should return the type of the named field if
455 /// they are of record type.
457 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
459 /// getFieldInit - This method complements getFieldType to return the
460 /// initializer for the specified field. If getFieldType returns non-null
461 /// this method should return non-null, otherwise it returns null.
463 virtual Init *getFieldInit(Record &R, const std::string &FieldName) const {
467 /// resolveReferences - This method is used by classes that refer to other
468 /// variables which may not be defined at the time they expression is formed.
469 /// If a value is set for the variable later, this method will be called on
470 /// users of the value to allow the value to propagate out.
472 virtual Init *resolveReferences(Record &R) { return this; }
475 inline std::ostream &operator<<(std::ostream &OS, const Init &I) {
476 I.print(OS); return OS;
480 /// UnsetInit - ? - Represents an uninitialized value
482 class UnsetInit : public Init {
484 virtual Init *convertInitializerTo(RecTy *Ty) {
485 return Ty->convertValue(this);
488 virtual bool isComplete() const { return false; }
489 virtual void print(std::ostream &OS) const { OS << "?"; }
493 /// BitInit - true/false - Represent a concrete initializer for a bit.
495 class BitInit : public Init {
498 BitInit(bool V) : Value(V) {}
500 bool getValue() const { return Value; }
502 virtual Init *convertInitializerTo(RecTy *Ty) {
503 return Ty->convertValue(this);
506 virtual void print(std::ostream &OS) const { OS << (Value ? "1" : "0"); }
509 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
510 /// It contains a vector of bits, whose size is determined by the type.
512 class BitsInit : public Init {
513 std::vector<Init*> Bits;
515 BitsInit(unsigned Size) : Bits(Size) {}
517 unsigned getNumBits() const { return Bits.size(); }
519 Init *getBit(unsigned Bit) const {
520 assert(Bit < Bits.size() && "Bit index out of range!");
523 void setBit(unsigned Bit, Init *V) {
524 assert(Bit < Bits.size() && "Bit index out of range!");
525 assert(Bits[Bit] == 0 && "Bit already set!");
529 virtual Init *convertInitializerTo(RecTy *Ty) {
530 return Ty->convertValue(this);
532 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
534 virtual bool isComplete() const {
535 for (unsigned i = 0; i != getNumBits(); ++i)
536 if (!getBit(i)->isComplete()) return false;
539 virtual void print(std::ostream &OS) const;
541 virtual Init *resolveReferences(Record &R);
543 // printXX - Print this bitstream with the specified format, returning true if
544 // it is not possible.
545 bool printInHex(std::ostream &OS) const;
546 bool printAsVariable(std::ostream &OS) const;
547 bool printAsUnset(std::ostream &OS) const;
551 /// IntInit - 7 - Represent an initalization by a literal integer value.
553 class IntInit : public Init {
556 IntInit(int V) : Value(V) {}
558 int getValue() const { return Value; }
560 virtual Init *convertInitializerTo(RecTy *Ty) {
561 return Ty->convertValue(this);
563 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
565 virtual void print(std::ostream &OS) const { OS << Value; }
569 /// StringInit - "foo" - Represent an initialization by a string value.
571 class StringInit : public Init {
574 StringInit(const std::string &V) : Value(V) {}
576 const std::string &getValue() const { return Value; }
578 virtual Init *convertInitializerTo(RecTy *Ty) {
579 return Ty->convertValue(this);
582 virtual void print(std::ostream &OS) const { OS << "\"" << Value << "\""; }
585 /// CodeInit - "[{...}]" - Represent a code fragment.
587 class CodeInit : public Init {
590 CodeInit(const std::string &V) : Value(V) {}
592 const std::string getValue() const { return Value; }
594 virtual Init *convertInitializerTo(RecTy *Ty) {
595 return Ty->convertValue(this);
598 virtual void print(std::ostream &OS) const { OS << "[{" << Value << "}]"; }
601 /// ListInit - [AL, AH, CL] - Represent a list of defs
603 class ListInit : public Init {
604 std::vector<Init*> Values;
606 ListInit(std::vector<Init*> &Vs) {
610 unsigned getSize() const { return Values.size(); }
611 Init *getElement(unsigned i) const {
612 assert(i < Values.size() && "List element index out of range!");
616 Init *convertInitListSlice(const std::vector<unsigned> &Elements);
618 virtual Init *convertInitializerTo(RecTy *Ty) {
619 return Ty->convertValue(this);
622 /// resolveReferences - This method is used by classes that refer to other
623 /// variables which may not be defined at the time they expression is formed.
624 /// If a value is set for the variable later, this method will be called on
625 /// users of the value to allow the value to propagate out.
627 virtual Init *resolveReferences(Record &R);
629 virtual void print(std::ostream &OS) const;
633 /// TypedInit - This is the common super-class of types that have a specific,
636 class TypedInit : public Init {
639 TypedInit(RecTy *T) : Ty(T) {}
641 RecTy *getType() const { return Ty; }
643 virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
644 virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements);
646 /// resolveBitReference - This method is used to implement
647 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
648 /// simply return the resolved value, otherwise we return null.
650 virtual Init *resolveBitReference(Record &R, unsigned Bit) = 0;
652 /// resolveListElementReference - This method is used to implement
653 /// VarListElementInit::resolveReferences. If the list element is resolvable
654 /// now, we return the resolved value, otherwise we return null.
655 virtual Init *resolveListElementReference(Record &R, unsigned Elt) = 0;
658 /// VarInit - 'Opcode' - Represent a reference to an entire variable object.
660 class VarInit : public TypedInit {
663 VarInit(const std::string &VN, RecTy *T) : TypedInit(T), VarName(VN) {}
665 virtual Init *convertInitializerTo(RecTy *Ty) {
666 return Ty->convertValue(this);
669 const std::string &getName() const { return VarName; }
671 virtual Init *resolveBitReference(Record &R, unsigned Bit);
672 virtual Init *resolveListElementReference(Record &R, unsigned Elt);
674 virtual RecTy *getFieldType(const std::string &FieldName) const;
675 virtual Init *getFieldInit(Record &R, const std::string &FieldName) const;
677 /// resolveReferences - This method is used by classes that refer to other
678 /// variables which may not be defined at the time they expression is formed.
679 /// If a value is set for the variable later, this method will be called on
680 /// users of the value to allow the value to propagate out.
682 virtual Init *resolveReferences(Record &R);
684 virtual void print(std::ostream &OS) const { OS << VarName; }
688 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
690 class VarBitInit : public Init {
694 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
695 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
696 ((BitsRecTy*)T->getType())->getNumBits() > B &&
697 "Illegal VarBitInit expression!");
700 virtual Init *convertInitializerTo(RecTy *Ty) {
701 return Ty->convertValue(this);
704 TypedInit *getVariable() const { return TI; }
705 unsigned getBitNum() const { return Bit; }
707 virtual void print(std::ostream &OS) const {
708 TI->print(OS); OS << "{" << Bit << "}";
710 virtual Init *resolveReferences(Record &R);
713 /// VarListElementInit - List[4] - Represent access to one element of a var or
715 class VarListElementInit : public TypedInit {
719 VarListElementInit(TypedInit *T, unsigned E)
720 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
722 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
723 "Illegal VarBitInit expression!");
726 virtual Init *convertInitializerTo(RecTy *Ty) {
727 return Ty->convertValue(this);
730 TypedInit *getVariable() const { return TI; }
731 unsigned getElementNum() const { return Element; }
733 virtual Init *resolveBitReference(Record &R, unsigned Bit);
735 /// resolveListElementReference - This method is used to implement
736 /// VarListElementInit::resolveReferences. If the list element is resolvable
737 /// now, we return the resolved value, otherwise we return null.
738 virtual Init *resolveListElementReference(Record &R, unsigned Elt);
740 virtual void print(std::ostream &OS) const {
741 TI->print(OS); OS << "[" << Element << "]";
743 virtual Init *resolveReferences(Record &R);
746 /// DefInit - AL - Represent a reference to a 'def' in the description
748 class DefInit : public Init {
751 DefInit(Record *D) : Def(D) {}
753 virtual Init *convertInitializerTo(RecTy *Ty) {
754 return Ty->convertValue(this);
757 Record *getDef() const { return Def; }
759 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
761 virtual RecTy *getFieldType(const std::string &FieldName) const;
762 virtual Init *getFieldInit(Record &R, const std::string &FieldName) const;
764 virtual void print(std::ostream &OS) const;
768 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
770 class FieldInit : public TypedInit {
771 Init *Rec; // Record we are referring to
772 std::string FieldName; // Field we are accessing
774 FieldInit(Init *R, const std::string &FN)
775 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
776 assert(getType() && "FieldInit with non-record type!");
779 virtual Init *convertInitializerTo(RecTy *Ty) {
780 return Ty->convertValue(this);
783 virtual Init *resolveBitReference(Record &R, unsigned Bit);
784 virtual Init *resolveListElementReference(Record &R, unsigned Elt);
786 virtual Init *resolveReferences(Record &R);
788 virtual void print(std::ostream &OS) const {
789 Rec->print(OS); OS << "." << FieldName;
793 /// DagInit - (def a, b) - Represent a DAG tree value. DAG inits are required
794 /// to have Records for their first value, after that, any legal Init is
797 class DagInit : public Init {
799 std::vector<Init*> Args;
800 std::vector<std::string> ArgNames;
802 DagInit(Record *D, const std::vector<std::pair<Init*, std::string> > &args)
804 Args.reserve(args.size());
805 ArgNames.reserve(args.size());
806 for (unsigned i = 0, e = args.size(); i != e; ++i) {
807 Args.push_back(args[i].first);
808 ArgNames.push_back(args[i].second);
812 virtual Init *convertInitializerTo(RecTy *Ty) {
813 return Ty->convertValue(this);
816 Record *getNodeType() const { return NodeTypeDef; }
818 unsigned getNumArgs() const { return Args.size(); }
819 Init *getArg(unsigned Num) const {
820 assert(Num < Args.size() && "Arg number out of range!");
823 const std::string &getArgName(unsigned Num) const {
824 assert(Num < ArgNames.size() && "Arg number out of range!");
825 return ArgNames[Num];
828 void setArg(unsigned Num, Init *I) {
829 assert(Num < Args.size() && "Arg number out of range!");
833 virtual void print(std::ostream &OS) const;
836 //===----------------------------------------------------------------------===//
837 // High-Level Classes
838 //===----------------------------------------------------------------------===//
846 RecordVal(const std::string &N, RecTy *T, unsigned P);
848 const std::string &getName() const { return Name; }
850 unsigned getPrefix() const { return Prefix; }
851 RecTy *getType() const { return Ty; }
852 Init *getValue() const { return Value; }
854 bool setValue(Init *V) {
856 Value = V->convertInitializerTo(Ty);
864 void print(std::ostream &OS, bool PrintSem = true) const;
867 inline std::ostream &operator<<(std::ostream &OS, const RecordVal &RV) {
873 const std::string Name;
874 std::vector<std::string> TemplateArgs;
875 std::vector<RecordVal> Values;
876 std::vector<Record*> SuperClasses;
879 Record(const std::string &N) : Name(N) {}
882 const std::string &getName() const { return Name; }
883 const std::vector<std::string> &getTemplateArgs() const {
886 const std::vector<RecordVal> &getValues() const { return Values; }
887 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
889 bool isTemplateArg(const std::string &Name) const {
890 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
891 if (TemplateArgs[i] == Name) return true;
895 const RecordVal *getValue(const std::string &Name) const {
896 for (unsigned i = 0, e = Values.size(); i != e; ++i)
897 if (Values[i].getName() == Name) return &Values[i];
900 RecordVal *getValue(const std::string &Name) {
901 for (unsigned i = 0, e = Values.size(); i != e; ++i)
902 if (Values[i].getName() == Name) return &Values[i];
906 void addTemplateArg(const std::string &Name) {
907 assert(!isTemplateArg(Name) && "Template arg already defined!");
908 TemplateArgs.push_back(Name);
911 void addValue(const RecordVal &RV) {
912 assert(getValue(RV.getName()) == 0 && "Value already added!");
913 Values.push_back(RV);
916 void removeValue(const std::string &Name) {
917 assert(getValue(Name) && "Cannot remove an entry that does not exist!");
918 for (unsigned i = 0, e = Values.size(); i != e; ++i)
919 if (Values[i].getName() == Name) {
920 Values.erase(Values.begin()+i);
923 assert(0 && "Name does not exist in record!");
926 bool isSubClassOf(Record *R) const {
927 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
928 if (SuperClasses[i] == R)
933 bool isSubClassOf(const std::string &Name) const {
934 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
935 if (SuperClasses[i]->getName() == Name)
940 void addSuperClass(Record *R) {
941 assert(!isSubClassOf(R) && "Already subclassing record!");
942 SuperClasses.push_back(R);
945 // resolveReferences - If there are any field references that refer to fields
946 // that have been filled in, we can propagate the values now.
948 void resolveReferences();
952 //===--------------------------------------------------------------------===//
953 // High-level methods useful to tablegen back-ends
956 /// getValueInit - Return the initializer for a value with the specified name,
957 /// or throw an exception if the field does not exist.
959 Init *getValueInit(const std::string &FieldName) const;
961 /// getValueAsString - This method looks up the specified field and returns
962 /// its value as a string, throwing an exception if the field does not exist
963 /// or if the value is not a string.
965 std::string getValueAsString(const std::string &FieldName) const;
967 /// getValueAsBitsInit - This method looks up the specified field and returns
968 /// its value as a BitsInit, throwing an exception if the field does not exist
969 /// or if the value is not the right type.
971 BitsInit *getValueAsBitsInit(const std::string &FieldName) const;
973 /// getValueAsListInit - This method looks up the specified field and returns
974 /// its value as a ListInit, throwing an exception if the field does not exist
975 /// or if the value is not the right type.
977 ListInit *getValueAsListInit(const std::string &FieldName) const;
979 /// getValueAsDef - This method looks up the specified field and returns its
980 /// value as a Record, throwing an exception if the field does not exist or if
981 /// the value is not the right type.
983 Record *getValueAsDef(const std::string &FieldName) const;
985 /// getValueAsBit - This method looks up the specified field and returns its
986 /// value as a bit, throwing an exception if the field does not exist or if
987 /// the value is not the right type.
989 bool getValueAsBit(const std::string &FieldName) const;
991 /// getValueAsInt - This method looks up the specified field and returns its
992 /// value as an int, throwing an exception if the field does not exist or if
993 /// the value is not the right type.
995 int getValueAsInt(const std::string &FieldName) const;
997 /// getValueAsDag - This method looks up the specified field and returns its
998 /// value as an Dag, throwing an exception if the field does not exist or if
999 /// the value is not the right type.
1001 DagInit *getValueAsDag(const std::string &FieldName) const;
1004 std::ostream &operator<<(std::ostream &OS, const Record &R);
1006 class RecordKeeper {
1007 std::map<std::string, Record*> Classes, Defs;
1010 for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1011 E = Classes.end(); I != E; ++I)
1013 for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1014 E = Defs.end(); I != E; ++I)
1018 const std::map<std::string, Record*> &getClasses() const { return Classes; }
1019 const std::map<std::string, Record*> &getDefs() const { return Defs; }
1021 Record *getClass(const std::string &Name) const {
1022 std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1023 return I == Classes.end() ? 0 : I->second;
1025 Record *getDef(const std::string &Name) const {
1026 std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1027 return I == Defs.end() ? 0 : I->second;
1029 void addClass(Record *R) {
1030 assert(getClass(R->getName()) == 0 && "Class already exists!");
1031 Classes.insert(std::make_pair(R->getName(), R));
1033 void addDef(Record *R) {
1034 assert(getDef(R->getName()) == 0 && "Def already exists!");
1035 Defs.insert(std::make_pair(R->getName(), R));
1038 //===--------------------------------------------------------------------===//
1039 // High-level helper methods, useful for tablegen backends...
1041 /// getAllDerivedDefinitions - This method returns all concrete definitions
1042 /// that derive from the specified class name. If a class with the specified
1043 /// name does not exist, an exception is thrown.
1044 std::vector<Record*>
1045 getAllDerivedDefinitions(const std::string &ClassName) const;
1051 std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK);
1053 extern RecordKeeper Records;
1055 } // End llvm namespace