1 //===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // 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 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TABLEGEN_RECORD_H
16 #define LLVM_TABLEGEN_RECORD_H
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/FoldingSet.h"
20 #include "llvm/Support/Allocator.h"
21 #include "llvm/Support/SourceMgr.h"
22 #include "llvm/Support/DataTypes.h"
23 #include "llvm/Support/raw_ostream.h"
57 class VarListElementInit;
65 //===----------------------------------------------------------------------===//
67 //===----------------------------------------------------------------------===//
72 RecTy() : ListTy(0) {}
75 virtual std::string getAsString() const = 0;
76 void print(raw_ostream &OS) const { OS << getAsString(); }
79 /// typeIsConvertibleTo - Return true if all values of 'this' type can be
80 /// converted to the specified type.
81 virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0;
83 /// getListTy - Returns the type representing list<this>.
84 ListRecTy *getListTy();
86 public: // These methods should only be called from subclasses of Init
87 virtual Init *convertValue( UnsetInit *UI) { return 0; }
88 virtual Init *convertValue( BitInit *BI) { return 0; }
89 virtual Init *convertValue( BitsInit *BI) { return 0; }
90 virtual Init *convertValue( IntInit *II) { return 0; }
91 virtual Init *convertValue(StringInit *SI) { return 0; }
92 virtual Init *convertValue( ListInit *LI) { return 0; }
93 virtual Init *convertValue( UnOpInit *UI) {
94 return convertValue((TypedInit*)UI);
96 virtual Init *convertValue( BinOpInit *UI) {
97 return convertValue((TypedInit*)UI);
99 virtual Init *convertValue( TernOpInit *UI) {
100 return convertValue((TypedInit*)UI);
102 virtual Init *convertValue( CodeInit *CI) { return 0; }
103 virtual Init *convertValue(VarBitInit *VB) { return 0; }
104 virtual Init *convertValue( DefInit *DI) { return 0; }
105 virtual Init *convertValue( DagInit *DI) { return 0; }
106 virtual Init *convertValue( TypedInit *TI) { return 0; }
107 virtual Init *convertValue( VarInit *VI) {
108 return convertValue((TypedInit*)VI);
110 virtual Init *convertValue( FieldInit *FI) {
111 return convertValue((TypedInit*)FI);
114 public: // These methods should only be called by subclasses of RecTy.
115 // baseClassOf - These virtual methods should be overloaded to return true iff
116 // all values of type 'RHS' can be converted to the 'this' type.
117 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
118 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
119 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
120 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
121 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
122 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
123 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
124 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
127 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
133 /// BitRecTy - 'bit' - Represent a single bit
135 class BitRecTy : public RecTy {
136 static BitRecTy Shared;
139 static BitRecTy *get() { return &Shared; }
141 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
142 virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
143 virtual Init *convertValue( BitsInit *BI);
144 virtual Init *convertValue( IntInit *II);
145 virtual Init *convertValue(StringInit *SI) { return 0; }
146 virtual Init *convertValue( ListInit *LI) { return 0; }
147 virtual Init *convertValue( CodeInit *CI) { return 0; }
148 virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
149 virtual Init *convertValue( DefInit *DI) { return 0; }
150 virtual Init *convertValue( DagInit *DI) { return 0; }
151 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
152 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
153 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
154 virtual Init *convertValue( TypedInit *TI);
155 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
156 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
158 std::string getAsString() const { return "bit"; }
160 bool typeIsConvertibleTo(const RecTy *RHS) const {
161 return RHS->baseClassOf(this);
163 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
164 virtual bool baseClassOf(const BitsRecTy *RHS) const;
165 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
166 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
167 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
168 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
169 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
170 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
175 // BitsRecTy - 'bits<n>' - Represent a fixed number of bits
176 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
178 class BitsRecTy : public RecTy {
180 explicit BitsRecTy(unsigned Sz) : Size(Sz) {}
182 static BitsRecTy *get(unsigned Sz);
184 unsigned getNumBits() const { return Size; }
186 virtual Init *convertValue( UnsetInit *UI);
187 virtual Init *convertValue( BitInit *UI);
188 virtual Init *convertValue( BitsInit *BI);
189 virtual Init *convertValue( IntInit *II);
190 virtual Init *convertValue(StringInit *SI) { return 0; }
191 virtual Init *convertValue( ListInit *LI) { return 0; }
192 virtual Init *convertValue( CodeInit *CI) { return 0; }
193 virtual Init *convertValue(VarBitInit *VB) { return 0; }
194 virtual Init *convertValue( DefInit *DI) { return 0; }
195 virtual Init *convertValue( DagInit *DI) { return 0; }
196 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
197 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
198 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
199 virtual Init *convertValue( TypedInit *TI);
200 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
201 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
203 std::string getAsString() const;
205 bool typeIsConvertibleTo(const RecTy *RHS) const {
206 return RHS->baseClassOf(this);
208 virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; }
209 virtual bool baseClassOf(const BitsRecTy *RHS) const {
210 return RHS->Size == Size;
212 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
213 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
214 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
215 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
216 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
217 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
222 /// IntRecTy - 'int' - Represent an integer value of no particular size
224 class IntRecTy : public RecTy {
225 static IntRecTy Shared;
228 static IntRecTy *get() { return &Shared; }
230 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
231 virtual Init *convertValue( BitInit *BI);
232 virtual Init *convertValue( BitsInit *BI);
233 virtual Init *convertValue( IntInit *II) { return (Init*)II; }
234 virtual Init *convertValue(StringInit *SI) { return 0; }
235 virtual Init *convertValue( ListInit *LI) { return 0; }
236 virtual Init *convertValue( CodeInit *CI) { return 0; }
237 virtual Init *convertValue(VarBitInit *VB) { return 0; }
238 virtual Init *convertValue( DefInit *DI) { return 0; }
239 virtual Init *convertValue( DagInit *DI) { return 0; }
240 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
241 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
242 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
243 virtual Init *convertValue( TypedInit *TI);
244 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
245 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
247 std::string getAsString() const { return "int"; }
249 bool typeIsConvertibleTo(const RecTy *RHS) const {
250 return RHS->baseClassOf(this);
253 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
254 virtual bool baseClassOf(const BitsRecTy *RHS) const { return true; }
255 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
256 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
257 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
258 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
259 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
260 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
264 /// StringRecTy - 'string' - Represent an string value
266 class StringRecTy : public RecTy {
267 static StringRecTy Shared;
270 static StringRecTy *get() { return &Shared; }
272 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
273 virtual Init *convertValue( BitInit *BI) { return 0; }
274 virtual Init *convertValue( BitsInit *BI) { return 0; }
275 virtual Init *convertValue( IntInit *II) { return 0; }
276 virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
277 virtual Init *convertValue( ListInit *LI) { return 0; }
278 virtual Init *convertValue( UnOpInit *BO);
279 virtual Init *convertValue( BinOpInit *BO);
280 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
282 virtual Init *convertValue( CodeInit *CI) { return 0; }
283 virtual Init *convertValue(VarBitInit *VB) { return 0; }
284 virtual Init *convertValue( DefInit *DI) { return 0; }
285 virtual Init *convertValue( DagInit *DI) { return 0; }
286 virtual Init *convertValue( TypedInit *TI);
287 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
288 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
290 std::string getAsString() const { return "string"; }
292 bool typeIsConvertibleTo(const RecTy *RHS) const {
293 return RHS->baseClassOf(this);
296 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
297 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
298 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
299 virtual bool baseClassOf(const StringRecTy *RHS) const { return true; }
300 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
301 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
302 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
303 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
306 // ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of
307 // the specified type.
308 /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must
309 /// be of the specified type.
311 class ListRecTy : public RecTy {
313 explicit ListRecTy(RecTy *T) : Ty(T) {}
314 friend ListRecTy *RecTy::getListTy();
316 static ListRecTy *get(RecTy *T) { return T->getListTy(); }
317 RecTy *getElementType() const { return Ty; }
319 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
320 virtual Init *convertValue( BitInit *BI) { return 0; }
321 virtual Init *convertValue( BitsInit *BI) { return 0; }
322 virtual Init *convertValue( IntInit *II) { return 0; }
323 virtual Init *convertValue(StringInit *SI) { return 0; }
324 virtual Init *convertValue( ListInit *LI);
325 virtual Init *convertValue( CodeInit *CI) { return 0; }
326 virtual Init *convertValue(VarBitInit *VB) { return 0; }
327 virtual Init *convertValue( DefInit *DI) { return 0; }
328 virtual Init *convertValue( DagInit *DI) { return 0; }
329 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
330 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
331 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
332 virtual Init *convertValue( TypedInit *TI);
333 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
334 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
336 std::string getAsString() const;
338 bool typeIsConvertibleTo(const RecTy *RHS) const {
339 return RHS->baseClassOf(this);
342 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
343 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
344 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
345 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
346 virtual bool baseClassOf(const ListRecTy *RHS) const {
347 return RHS->getElementType()->typeIsConvertibleTo(Ty);
349 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
350 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
351 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
354 /// CodeRecTy - 'code' - Represent an code fragment, function or method.
356 class CodeRecTy : public RecTy {
357 static CodeRecTy Shared;
360 static CodeRecTy *get() { return &Shared; }
362 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
363 virtual Init *convertValue( BitInit *BI) { return 0; }
364 virtual Init *convertValue( BitsInit *BI) { return 0; }
365 virtual Init *convertValue( IntInit *II) { return 0; }
366 virtual Init *convertValue(StringInit *SI) { return 0; }
367 virtual Init *convertValue( ListInit *LI) { return 0; }
368 virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
369 virtual Init *convertValue(VarBitInit *VB) { return 0; }
370 virtual Init *convertValue( DefInit *DI) { return 0; }
371 virtual Init *convertValue( DagInit *DI) { return 0; }
372 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
373 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
374 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
375 virtual Init *convertValue( TypedInit *TI);
376 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
377 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
379 std::string getAsString() const { return "code"; }
381 bool typeIsConvertibleTo(const RecTy *RHS) const {
382 return RHS->baseClassOf(this);
384 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
385 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
386 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
387 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
388 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
389 virtual bool baseClassOf(const CodeRecTy *RHS) const { return true; }
390 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
391 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
394 /// DagRecTy - 'dag' - Represent a dag fragment
396 class DagRecTy : public RecTy {
397 static DagRecTy Shared;
400 static DagRecTy *get() { return &Shared; }
402 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
403 virtual Init *convertValue( BitInit *BI) { return 0; }
404 virtual Init *convertValue( BitsInit *BI) { return 0; }
405 virtual Init *convertValue( IntInit *II) { return 0; }
406 virtual Init *convertValue(StringInit *SI) { return 0; }
407 virtual Init *convertValue( ListInit *LI) { return 0; }
408 virtual Init *convertValue( CodeInit *CI) { return 0; }
409 virtual Init *convertValue(VarBitInit *VB) { return 0; }
410 virtual Init *convertValue( DefInit *DI) { return 0; }
411 virtual Init *convertValue( UnOpInit *BO);
412 virtual Init *convertValue( BinOpInit *BO);
413 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
414 virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
415 virtual Init *convertValue( TypedInit *TI);
416 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
417 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
419 std::string getAsString() const { return "dag"; }
421 bool typeIsConvertibleTo(const RecTy *RHS) const {
422 return RHS->baseClassOf(this);
425 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
426 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
427 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
428 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
429 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
430 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
431 virtual bool baseClassOf(const DagRecTy *RHS) const { return true; }
432 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
436 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
439 class RecordRecTy : public RecTy {
441 explicit RecordRecTy(Record *R) : Rec(R) {}
444 static RecordRecTy *get(Record *R);
446 Record *getRecord() const { return Rec; }
448 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
449 virtual Init *convertValue( BitInit *BI) { return 0; }
450 virtual Init *convertValue( BitsInit *BI) { return 0; }
451 virtual Init *convertValue( IntInit *II) { return 0; }
452 virtual Init *convertValue(StringInit *SI) { return 0; }
453 virtual Init *convertValue( ListInit *LI) { return 0; }
454 virtual Init *convertValue( CodeInit *CI) { return 0; }
455 virtual Init *convertValue(VarBitInit *VB) { return 0; }
456 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
457 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
458 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
459 virtual Init *convertValue( DefInit *DI);
460 virtual Init *convertValue( DagInit *DI) { return 0; }
461 virtual Init *convertValue( TypedInit *VI);
462 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
463 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
465 std::string getAsString() const;
467 bool typeIsConvertibleTo(const RecTy *RHS) const {
468 return RHS->baseClassOf(this);
470 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
471 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
472 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
473 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
474 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
475 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
476 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
477 virtual bool baseClassOf(const RecordRecTy *RHS) const;
480 /// resolveTypes - Find a common type that T1 and T2 convert to.
481 /// Return 0 if no such type exists.
483 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
485 //===----------------------------------------------------------------------===//
486 // Initializer Classes
487 //===----------------------------------------------------------------------===//
490 Init(const Init &); // Do not define.
491 Init &operator=(const Init &); // Do not define.
499 /// isComplete - This virtual method should be overridden by values that may
500 /// not be completely specified yet.
501 virtual bool isComplete() const { return true; }
503 /// print - Print out this value.
504 void print(raw_ostream &OS) const { OS << getAsString(); }
506 /// getAsString - Convert this value to a string form.
507 virtual std::string getAsString() const = 0;
508 /// getAsUnquotedString - Convert this value to a string form,
509 /// without adding quote markers. This primaruly affects
510 /// StringInits where we will not surround the string value with
512 virtual std::string getAsUnquotedString() const { return getAsString(); }
514 /// dump - Debugging method that may be called through a debugger, just
515 /// invokes print on stderr.
518 /// convertInitializerTo - This virtual function is a simple call-back
519 /// function that should be overridden to call the appropriate
520 /// RecTy::convertValue method.
522 virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
524 /// convertInitializerBitRange - This method is used to implement the bitrange
525 /// selection operator. Given an initializer, it selects the specified bits
526 /// out, returning them as a new init of bits type. If it is not legal to use
527 /// the bit subscript operator on this initializer, return null.
530 convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
534 /// convertInitListSlice - This method is used to implement the list slice
535 /// selection operator. Given an initializer, it selects the specified list
536 /// elements, returning them as a new init of list type. If it is not legal
537 /// to take a slice of this, return null.
540 convertInitListSlice(const std::vector<unsigned> &Elements) const {
544 /// getFieldType - This method is used to implement the FieldInit class.
545 /// Implementors of this method should return the type of the named field if
546 /// they are of record type.
548 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
550 /// getFieldInit - This method complements getFieldType to return the
551 /// initializer for the specified field. If getFieldType returns non-null
552 /// this method should return non-null, otherwise it returns null.
554 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
555 const std::string &FieldName) const {
559 /// resolveReferences - This method is used by classes that refer to other
560 /// variables which may not be defined at the time the expression is formed.
561 /// If a value is set for the variable later, this method will be called on
562 /// users of the value to allow the value to propagate out.
564 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
565 return const_cast<Init *>(this);
569 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
570 I.print(OS); return OS;
573 /// TypedInit - This is the common super-class of types that have a specific,
576 class TypedInit : public Init {
579 TypedInit(const TypedInit &Other); // Do not define.
580 TypedInit &operator=(const TypedInit &Other); // Do not define.
583 explicit TypedInit(RecTy *T) : Ty(T) {}
586 RecTy *getType() const { return Ty; }
589 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
591 convertInitListSlice(const std::vector<unsigned> &Elements) const;
593 /// getFieldType - This method is used to implement the FieldInit class.
594 /// Implementors of this method should return the type of the named field if
595 /// they are of record type.
597 virtual RecTy *getFieldType(const std::string &FieldName) const;
599 /// resolveBitReference - This method is used to implement
600 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
601 /// simply return the resolved value, otherwise we return null.
603 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
604 unsigned Bit) const = 0;
606 /// resolveListElementReference - This method is used to implement
607 /// VarListElementInit::resolveReferences. If the list element is resolvable
608 /// now, we return the resolved value, otherwise we return null.
609 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
610 unsigned Elt) const = 0;
614 /// UnsetInit - ? - Represents an uninitialized value
616 class UnsetInit : public Init {
617 UnsetInit() : Init() {}
618 UnsetInit(const UnsetInit &); // Do not define.
619 UnsetInit &operator=(const UnsetInit &Other); // Do not define.
622 static UnsetInit *get();
624 virtual Init *convertInitializerTo(RecTy *Ty) const {
625 return Ty->convertValue(const_cast<UnsetInit *>(this));
628 virtual bool isComplete() const { return false; }
629 virtual std::string getAsString() const { return "?"; }
633 /// BitInit - true/false - Represent a concrete initializer for a bit.
635 class BitInit : public Init {
638 explicit BitInit(bool V) : Value(V) {}
639 BitInit(const BitInit &Other); // Do not define.
640 BitInit &operator=(BitInit &Other); // Do not define.
643 static BitInit *get(bool V);
645 bool getValue() const { return Value; }
647 virtual Init *convertInitializerTo(RecTy *Ty) const {
648 return Ty->convertValue(const_cast<BitInit *>(this));
651 virtual std::string getAsString() const { return Value ? "1" : "0"; }
654 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
655 /// It contains a vector of bits, whose size is determined by the type.
657 class BitsInit : public Init, public FoldingSetNode {
658 std::vector<Init*> Bits;
660 BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
662 BitsInit(const BitsInit &Other); // Do not define.
663 BitsInit &operator=(const BitsInit &Other); // Do not define.
666 static BitsInit *get(ArrayRef<Init *> Range);
668 void Profile(FoldingSetNodeID &ID) const;
670 unsigned getNumBits() const { return Bits.size(); }
672 Init *getBit(unsigned Bit) const {
673 assert(Bit < Bits.size() && "Bit index out of range!");
677 virtual Init *convertInitializerTo(RecTy *Ty) const {
678 return Ty->convertValue(const_cast<BitsInit *>(this));
681 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
683 virtual bool isComplete() const {
684 for (unsigned i = 0; i != getNumBits(); ++i)
685 if (!getBit(i)->isComplete()) return false;
688 bool allInComplete() const {
689 for (unsigned i = 0; i != getNumBits(); ++i)
690 if (getBit(i)->isComplete()) return false;
693 virtual std::string getAsString() const;
695 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
699 /// IntInit - 7 - Represent an initalization by a literal integer value.
701 class IntInit : public TypedInit {
704 explicit IntInit(int64_t V) : TypedInit(IntRecTy::get()), Value(V) {}
706 IntInit(const IntInit &Other); // Do not define.
707 IntInit &operator=(const IntInit &Other); // Do note define.
710 static IntInit *get(int64_t V);
712 int64_t getValue() const { return Value; }
714 virtual Init *convertInitializerTo(RecTy *Ty) const {
715 return Ty->convertValue(const_cast<IntInit *>(this));
718 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
720 virtual std::string getAsString() const;
722 /// resolveBitReference - This method is used to implement
723 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
724 /// simply return the resolved value, otherwise we return null.
726 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
727 unsigned Bit) const {
728 assert(0 && "Illegal bit reference off int");
732 /// resolveListElementReference - This method is used to implement
733 /// VarListElementInit::resolveReferences. If the list element is resolvable
734 /// now, we return the resolved value, otherwise we return null.
735 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
736 unsigned Elt) const {
737 assert(0 && "Illegal element reference off int");
743 /// StringInit - "foo" - Represent an initialization by a string value.
745 class StringInit : public TypedInit {
748 explicit StringInit(const std::string &V)
749 : TypedInit(StringRecTy::get()), Value(V) {}
751 StringInit(const StringInit &Other); // Do not define.
752 StringInit &operator=(const StringInit &Other); // Do not define.
755 static StringInit *get(const std::string &V);
757 const std::string &getValue() const { return Value; }
759 virtual Init *convertInitializerTo(RecTy *Ty) const {
760 return Ty->convertValue(const_cast<StringInit *>(this));
763 virtual std::string getAsString() const { return "\"" + Value + "\""; }
764 virtual std::string getAsUnquotedString() const { return Value; }
766 /// resolveBitReference - This method is used to implement
767 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
768 /// simply return the resolved value, otherwise we return null.
770 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
771 unsigned Bit) const {
772 assert(0 && "Illegal bit reference off string");
776 /// resolveListElementReference - This method is used to implement
777 /// VarListElementInit::resolveReferences. If the list element is resolvable
778 /// now, we return the resolved value, otherwise we return null.
779 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
780 unsigned Elt) const {
781 assert(0 && "Illegal element reference off string");
786 /// CodeInit - "[{...}]" - Represent a code fragment.
788 class CodeInit : public Init {
791 explicit CodeInit(const std::string &V) : Value(V) {}
793 CodeInit(const CodeInit &Other); // Do not define.
794 CodeInit &operator=(const CodeInit &Other); // Do not define.
797 static CodeInit *get(const std::string &V);
799 const std::string &getValue() const { return Value; }
801 virtual Init *convertInitializerTo(RecTy *Ty) const {
802 return Ty->convertValue(const_cast<CodeInit *>(this));
805 virtual std::string getAsString() const { return "[{" + Value + "}]"; }
808 /// ListInit - [AL, AH, CL] - Represent a list of defs
810 class ListInit : public TypedInit, public FoldingSetNode {
811 std::vector<Init*> Values;
813 typedef std::vector<Init*>::const_iterator const_iterator;
816 explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
817 : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
819 ListInit(const ListInit &Other); // Do not define.
820 ListInit &operator=(const ListInit &Other); // Do not define.
823 static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
825 void Profile(FoldingSetNodeID &ID) const;
827 unsigned getSize() const { return Values.size(); }
828 Init *getElement(unsigned i) const {
829 assert(i < Values.size() && "List element index out of range!");
833 Record *getElementAsRecord(unsigned i) const;
835 Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
837 virtual Init *convertInitializerTo(RecTy *Ty) const {
838 return Ty->convertValue(const_cast<ListInit *>(this));
841 /// resolveReferences - This method is used by classes that refer to other
842 /// variables which may not be defined at the time they expression is formed.
843 /// If a value is set for the variable later, this method will be called on
844 /// users of the value to allow the value to propagate out.
846 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
848 virtual std::string getAsString() const;
850 ArrayRef<Init*> getValues() const { return Values; }
852 inline const_iterator begin() const { return Values.begin(); }
853 inline const_iterator end () const { return Values.end(); }
855 inline size_t size () const { return Values.size(); }
856 inline bool empty() const { return Values.empty(); }
858 /// resolveBitReference - This method is used to implement
859 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
860 /// simply return the resolved value, otherwise we return null.
862 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
863 unsigned Bit) const {
864 assert(0 && "Illegal bit reference off list");
868 /// resolveListElementReference - This method is used to implement
869 /// VarListElementInit::resolveReferences. If the list element is resolvable
870 /// now, we return the resolved value, otherwise we return null.
871 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
876 /// OpInit - Base class for operators
878 class OpInit : public TypedInit {
879 OpInit(const OpInit &Other); // Do not define.
880 OpInit &operator=(OpInit &Other); // Do not define.
883 explicit OpInit(RecTy *Type) : TypedInit(Type) {}
886 // Clone - Clone this operator, replacing arguments with the new list
887 virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
889 virtual int getNumOperands() const = 0;
890 virtual Init *getOperand(int i) const = 0;
892 // Fold - If possible, fold this to a simpler init. Return this if not
894 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
896 virtual Init *convertInitializerTo(RecTy *Ty) const {
897 return Ty->convertValue(const_cast<OpInit *>(this));
900 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
902 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
907 /// UnOpInit - !op (X) - Transform an init.
909 class UnOpInit : public OpInit {
911 enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
916 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
917 : OpInit(Type), Opc(opc), LHS(lhs) {}
919 UnOpInit(const UnOpInit &Other); // Do not define.
920 UnOpInit &operator=(const UnOpInit &Other); // Do not define.
923 static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
925 // Clone - Clone this operator, replacing arguments with the new list
926 virtual OpInit *clone(std::vector<Init *> &Operands) const {
927 assert(Operands.size() == 1 &&
928 "Wrong number of operands for unary operation");
929 return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
932 int getNumOperands() const { return 1; }
933 Init *getOperand(int i) const {
934 assert(i == 0 && "Invalid operand id for unary operator");
938 UnaryOp getOpcode() const { return Opc; }
939 Init *getOperand() const { return LHS; }
941 // Fold - If possible, fold this to a simpler init. Return this if not
943 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
945 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
947 virtual std::string getAsString() const;
950 /// BinOpInit - !op (X, Y) - Combine two inits.
952 class BinOpInit : public OpInit {
954 enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
959 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
960 OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {}
962 BinOpInit(const BinOpInit &Other); // Do not define.
963 BinOpInit &operator=(const BinOpInit &Other); // Do not define.
966 static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
969 // Clone - Clone this operator, replacing arguments with the new list
970 virtual OpInit *clone(std::vector<Init *> &Operands) const {
971 assert(Operands.size() == 2 &&
972 "Wrong number of operands for binary operation");
973 return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
976 int getNumOperands() const { return 2; }
977 Init *getOperand(int i) const {
978 assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
986 BinaryOp getOpcode() const { return Opc; }
987 Init *getLHS() const { return LHS; }
988 Init *getRHS() const { return RHS; }
990 // Fold - If possible, fold this to a simpler init. Return this if not
992 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
994 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
996 virtual std::string getAsString() const;
999 /// TernOpInit - !op (X, Y, Z) - Combine two inits.
1001 class TernOpInit : public OpInit {
1003 enum TernaryOp { SUBST, FOREACH, IF };
1006 Init *LHS, *MHS, *RHS;
1008 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
1010 OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
1012 TernOpInit(const TernOpInit &Other); // Do not define.
1013 TernOpInit &operator=(const TernOpInit &Other); // Do not define.
1016 static TernOpInit *get(TernaryOp opc, Init *lhs,
1017 Init *mhs, Init *rhs,
1020 // Clone - Clone this operator, replacing arguments with the new list
1021 virtual OpInit *clone(std::vector<Init *> &Operands) const {
1022 assert(Operands.size() == 3 &&
1023 "Wrong number of operands for ternary operation");
1024 return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
1028 int getNumOperands() const { return 3; }
1029 Init *getOperand(int i) const {
1030 assert((i == 0 || i == 1 || i == 2) &&
1031 "Invalid operand id for ternary operator");
1034 } else if (i == 1) {
1041 TernaryOp getOpcode() const { return Opc; }
1042 Init *getLHS() const { return LHS; }
1043 Init *getMHS() const { return MHS; }
1044 Init *getRHS() const { return RHS; }
1046 // Fold - If possible, fold this to a simpler init. Return this if not
1047 // possible to fold.
1048 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
1050 virtual bool isComplete() const { return false; }
1052 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1054 virtual std::string getAsString() const;
1058 /// VarInit - 'Opcode' - Represent a reference to an entire variable object.
1060 class VarInit : public TypedInit {
1061 std::string VarName;
1063 explicit VarInit(const std::string &VN, RecTy *T)
1064 : TypedInit(T), VarName(VN) {}
1066 VarInit(const VarInit &Other); // Do not define.
1067 VarInit &operator=(const VarInit &Other); // Do not define.
1070 static VarInit *get(const std::string &VN, RecTy *T);
1071 static VarInit *get(Init *VN, RecTy *T);
1073 virtual Init *convertInitializerTo(RecTy *Ty) const {
1074 return Ty->convertValue(const_cast<VarInit *>(this));
1077 const std::string &getName() const { return VarName; }
1079 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1080 unsigned Bit) const;
1081 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1082 unsigned Elt) const;
1084 virtual RecTy *getFieldType(const std::string &FieldName) const;
1085 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1086 const std::string &FieldName) const;
1088 /// resolveReferences - This method is used by classes that refer to other
1089 /// variables which may not be defined at the time they expression is formed.
1090 /// If a value is set for the variable later, this method will be called on
1091 /// users of the value to allow the value to propagate out.
1093 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1095 virtual std::string getAsString() const { return VarName; }
1099 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
1101 class VarBitInit : public Init {
1105 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
1106 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
1107 ((BitsRecTy*)T->getType())->getNumBits() > B &&
1108 "Illegal VarBitInit expression!");
1111 VarBitInit(const VarBitInit &Other); // Do not define.
1112 VarBitInit &operator=(const VarBitInit &Other); // Do not define.
1115 static VarBitInit *get(TypedInit *T, unsigned B);
1117 virtual Init *convertInitializerTo(RecTy *Ty) const {
1118 return Ty->convertValue(const_cast<VarBitInit *>(this));
1121 TypedInit *getVariable() const { return TI; }
1122 unsigned getBitNum() const { return Bit; }
1124 virtual std::string getAsString() const;
1125 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1128 /// VarListElementInit - List[4] - Represent access to one element of a var or
1130 class VarListElementInit : public TypedInit {
1134 VarListElementInit(TypedInit *T, unsigned E)
1135 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1137 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
1138 "Illegal VarBitInit expression!");
1141 VarListElementInit(const VarListElementInit &Other); // Do not define.
1142 VarListElementInit &operator=(const VarListElementInit &Other); // Do
1147 static VarListElementInit *get(TypedInit *T, unsigned E);
1149 virtual Init *convertInitializerTo(RecTy *Ty) const {
1150 return Ty->convertValue(const_cast<VarListElementInit *>(this));
1153 TypedInit *getVariable() const { return TI; }
1154 unsigned getElementNum() const { return Element; }
1156 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1157 unsigned Bit) const;
1159 /// resolveListElementReference - This method is used to implement
1160 /// VarListElementInit::resolveReferences. If the list element is resolvable
1161 /// now, we return the resolved value, otherwise we return null.
1162 virtual Init *resolveListElementReference(Record &R,
1163 const RecordVal *RV,
1164 unsigned Elt) const;
1166 virtual std::string getAsString() const;
1167 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1170 /// DefInit - AL - Represent a reference to a 'def' in the description
1172 class DefInit : public TypedInit {
1175 DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {}
1176 friend class Record;
1178 DefInit(const DefInit &Other); // Do not define.
1179 DefInit &operator=(const DefInit &Other); // Do not define.
1182 static DefInit *get(Record*);
1184 virtual Init *convertInitializerTo(RecTy *Ty) const {
1185 return Ty->convertValue(const_cast<DefInit *>(this));
1188 Record *getDef() const { return Def; }
1190 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
1192 virtual RecTy *getFieldType(const std::string &FieldName) const;
1193 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1194 const std::string &FieldName) const;
1196 virtual std::string getAsString() const;
1198 /// resolveBitReference - This method is used to implement
1199 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
1200 /// simply return the resolved value, otherwise we return null.
1202 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1203 unsigned Bit) const {
1204 assert(0 && "Illegal bit reference off def");
1208 /// resolveListElementReference - This method is used to implement
1209 /// VarListElementInit::resolveReferences. If the list element is resolvable
1210 /// now, we return the resolved value, otherwise we return null.
1211 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1212 unsigned Elt) const {
1213 assert(0 && "Illegal element reference off def");
1219 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
1221 class FieldInit : public TypedInit {
1222 Init *Rec; // Record we are referring to
1223 std::string FieldName; // Field we are accessing
1225 FieldInit(Init *R, const std::string &FN)
1226 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
1227 assert(getType() && "FieldInit with non-record type!");
1230 FieldInit(const FieldInit &Other); // Do not define.
1231 FieldInit &operator=(const FieldInit &Other); // Do not define.
1234 static FieldInit *get(Init *R, const std::string &FN);
1235 static FieldInit *get(Init *R, const Init *FN);
1237 virtual Init *convertInitializerTo(RecTy *Ty) const {
1238 return Ty->convertValue(const_cast<FieldInit *>(this));
1241 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1242 unsigned Bit) const;
1243 virtual Init *resolveListElementReference(Record &R,
1244 const RecordVal *RV,
1245 unsigned Elt) const;
1247 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1249 virtual std::string getAsString() const {
1250 return Rec->getAsString() + "." + FieldName;
1254 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
1255 /// to have at least one value then a (possibly empty) list of arguments. Each
1256 /// argument can have a name associated with it.
1258 class DagInit : public TypedInit, public FoldingSetNode {
1260 std::string ValName;
1261 std::vector<Init*> Args;
1262 std::vector<std::string> ArgNames;
1264 DagInit(Init *V, const std::string &VN,
1265 ArrayRef<Init *> ArgRange,
1266 ArrayRef<std::string> NameRange)
1267 : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
1268 Args(ArgRange.begin(), ArgRange.end()),
1269 ArgNames(NameRange.begin(), NameRange.end()) {}
1271 DagInit(const DagInit &Other); // Do not define.
1272 DagInit &operator=(const DagInit &Other); // Do not define.
1275 static DagInit *get(Init *V, const std::string &VN,
1276 ArrayRef<Init *> ArgRange,
1277 ArrayRef<std::string> NameRange);
1278 static DagInit *get(Init *V, const std::string &VN,
1280 std::pair<Init*, std::string> > &args);
1282 void Profile(FoldingSetNodeID &ID) const;
1284 virtual Init *convertInitializerTo(RecTy *Ty) const {
1285 return Ty->convertValue(const_cast<DagInit *>(this));
1288 Init *getOperator() const { return Val; }
1290 const std::string &getName() const { return ValName; }
1292 unsigned getNumArgs() const { return Args.size(); }
1293 Init *getArg(unsigned Num) const {
1294 assert(Num < Args.size() && "Arg number out of range!");
1297 const std::string &getArgName(unsigned Num) const {
1298 assert(Num < ArgNames.size() && "Arg number out of range!");
1299 return ArgNames[Num];
1302 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1304 virtual std::string getAsString() const;
1306 typedef std::vector<Init*>::const_iterator const_arg_iterator;
1307 typedef std::vector<std::string>::const_iterator const_name_iterator;
1309 inline const_arg_iterator arg_begin() const { return Args.begin(); }
1310 inline const_arg_iterator arg_end () const { return Args.end(); }
1312 inline size_t arg_size () const { return Args.size(); }
1313 inline bool arg_empty() const { return Args.empty(); }
1315 inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1316 inline const_name_iterator name_end () const { return ArgNames.end(); }
1318 inline size_t name_size () const { return ArgNames.size(); }
1319 inline bool name_empty() const { return ArgNames.empty(); }
1321 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1322 unsigned Bit) const {
1323 assert(0 && "Illegal bit reference off dag");
1327 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1328 unsigned Elt) const {
1329 assert(0 && "Illegal element reference off dag");
1334 //===----------------------------------------------------------------------===//
1335 // High-Level Classes
1336 //===----------------------------------------------------------------------===//
1344 RecordVal(Init *N, RecTy *T, unsigned P);
1345 RecordVal(const std::string &N, RecTy *T, unsigned P);
1347 const std::string &getName() const;
1349 unsigned getPrefix() const { return Prefix; }
1350 RecTy *getType() const { return Ty; }
1351 Init *getValue() const { return Value; }
1353 bool setValue(Init *V) {
1355 Value = V->convertInitializerTo(Ty);
1363 void print(raw_ostream &OS, bool PrintSem = true) const;
1366 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1367 RV.print(OS << " ");
1372 static unsigned LastID;
1374 // Unique record ID.
1378 std::vector<std::string> TemplateArgs;
1379 std::vector<RecordVal> Values;
1380 std::vector<Record*> SuperClasses;
1382 // Tracks Record instances. Not owned by Record.
1383 RecordKeeper &TrackedRecords;
1391 // Constructs a record.
1392 explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) :
1393 ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records), TheInit(0) {}
1397 static unsigned getNewUID() { return LastID++; }
1400 unsigned getID() const { return ID; }
1402 const std::string &getName() const;
1403 void setName(Init *Name); // Also updates RecordKeeper.
1404 void setName(const std::string &Name); // Also updates RecordKeeper.
1406 SMLoc getLoc() const { return Loc; }
1408 /// get the corresponding DefInit.
1409 DefInit *getDefInit();
1411 const std::vector<std::string> &getTemplateArgs() const {
1412 return TemplateArgs;
1414 const std::vector<RecordVal> &getValues() const { return Values; }
1415 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
1417 bool isTemplateArg(StringRef Name) const {
1418 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
1419 if (TemplateArgs[i] == Name) return true;
1423 const RecordVal *getValue(StringRef Name) const {
1424 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1425 if (Values[i].getName() == Name) return &Values[i];
1428 RecordVal *getValue(StringRef Name) {
1429 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1430 if (Values[i].getName() == Name) return &Values[i];
1434 void addTemplateArg(StringRef Name) {
1435 assert(!isTemplateArg(Name) && "Template arg already defined!");
1436 TemplateArgs.push_back(Name);
1439 void addValue(const RecordVal &RV) {
1440 assert(getValue(RV.getName()) == 0 && "Value already added!");
1441 Values.push_back(RV);
1444 void removeValue(StringRef Name) {
1445 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1446 if (Values[i].getName() == Name) {
1447 Values.erase(Values.begin()+i);
1450 assert(0 && "Cannot remove an entry that does not exist!");
1453 bool isSubClassOf(const Record *R) const {
1454 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1455 if (SuperClasses[i] == R)
1460 bool isSubClassOf(StringRef Name) const {
1461 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1462 if (SuperClasses[i]->getName() == Name)
1467 void addSuperClass(Record *R) {
1468 assert(!isSubClassOf(R) && "Already subclassing record!");
1469 SuperClasses.push_back(R);
1472 /// resolveReferences - If there are any field references that refer to fields
1473 /// that have been filled in, we can propagate the values now.
1475 void resolveReferences() { resolveReferencesTo(0); }
1477 /// resolveReferencesTo - If anything in this record refers to RV, replace the
1478 /// reference to RV with the RHS of RV. If RV is null, we resolve all
1479 /// possible references.
1480 void resolveReferencesTo(const RecordVal *RV);
1482 RecordKeeper &getRecords() const {
1483 return TrackedRecords;
1488 //===--------------------------------------------------------------------===//
1489 // High-level methods useful to tablegen back-ends
1492 /// getValueInit - Return the initializer for a value with the specified name,
1493 /// or throw an exception if the field does not exist.
1495 Init *getValueInit(StringRef FieldName) const;
1497 /// getValueAsString - This method looks up the specified field and returns
1498 /// its value as a string, throwing an exception if the field does not exist
1499 /// or if the value is not a string.
1501 std::string getValueAsString(StringRef FieldName) const;
1503 /// getValueAsBitsInit - This method looks up the specified field and returns
1504 /// its value as a BitsInit, throwing an exception if the field does not exist
1505 /// or if the value is not the right type.
1507 BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1509 /// getValueAsListInit - This method looks up the specified field and returns
1510 /// its value as a ListInit, throwing an exception if the field does not exist
1511 /// or if the value is not the right type.
1513 ListInit *getValueAsListInit(StringRef FieldName) const;
1515 /// getValueAsListOfDefs - This method looks up the specified field and
1516 /// returns its value as a vector of records, throwing an exception if the
1517 /// field does not exist or if the value is not the right type.
1519 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1521 /// getValueAsListOfInts - This method looks up the specified field and
1522 /// returns its value as a vector of integers, throwing an exception if the
1523 /// field does not exist or if the value is not the right type.
1525 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1527 /// getValueAsListOfStrings - This method looks up the specified field and
1528 /// returns its value as a vector of strings, throwing an exception if the
1529 /// field does not exist or if the value is not the right type.
1531 std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1533 /// getValueAsDef - This method looks up the specified field and returns its
1534 /// value as a Record, throwing an exception if the field does not exist or if
1535 /// the value is not the right type.
1537 Record *getValueAsDef(StringRef FieldName) const;
1539 /// getValueAsBit - This method looks up the specified field and returns its
1540 /// value as a bit, throwing an exception if the field does not exist or if
1541 /// the value is not the right type.
1543 bool getValueAsBit(StringRef FieldName) const;
1545 /// getValueAsInt - This method looks up the specified field and returns its
1546 /// value as an int64_t, throwing an exception if the field does not exist or
1547 /// if the value is not the right type.
1549 int64_t getValueAsInt(StringRef FieldName) const;
1551 /// getValueAsDag - This method looks up the specified field and returns its
1552 /// value as an Dag, throwing an exception if the field does not exist or if
1553 /// the value is not the right type.
1555 DagInit *getValueAsDag(StringRef FieldName) const;
1557 /// getValueAsCode - This method looks up the specified field and returns
1558 /// its value as the string data in a CodeInit, throwing an exception if the
1559 /// field does not exist or if the value is not a code object.
1561 std::string getValueAsCode(StringRef FieldName) const;
1564 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1567 Record Rec; // Placeholder for template args and Name.
1568 typedef std::vector<Record*> RecordVector;
1569 RecordVector DefPrototypes;
1573 MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1574 Rec(Name, Loc, Records) {}
1577 class RecordKeeper {
1578 std::map<std::string, Record*> Classes, Defs;
1581 for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1582 E = Classes.end(); I != E; ++I)
1584 for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1585 E = Defs.end(); I != E; ++I)
1589 const std::map<std::string, Record*> &getClasses() const { return Classes; }
1590 const std::map<std::string, Record*> &getDefs() const { return Defs; }
1592 Record *getClass(const std::string &Name) const {
1593 std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1594 return I == Classes.end() ? 0 : I->second;
1596 Record *getDef(const std::string &Name) const {
1597 std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1598 return I == Defs.end() ? 0 : I->second;
1600 void addClass(Record *R) {
1601 assert(getClass(R->getName()) == 0 && "Class already exists!");
1602 Classes.insert(std::make_pair(R->getName(), R));
1604 void addDef(Record *R) {
1605 assert(getDef(R->getName()) == 0 && "Def already exists!");
1606 Defs.insert(std::make_pair(R->getName(), R));
1609 /// removeClass - Remove, but do not delete, the specified record.
1611 void removeClass(const std::string &Name) {
1612 assert(Classes.count(Name) && "Class does not exist!");
1613 Classes.erase(Name);
1615 /// removeDef - Remove, but do not delete, the specified record.
1617 void removeDef(const std::string &Name) {
1618 assert(Defs.count(Name) && "Def does not exist!");
1622 //===--------------------------------------------------------------------===//
1623 // High-level helper methods, useful for tablegen backends...
1625 /// getAllDerivedDefinitions - This method returns all concrete definitions
1626 /// that derive from the specified class name. If a class with the specified
1627 /// name does not exist, an exception is thrown.
1628 std::vector<Record*>
1629 getAllDerivedDefinitions(const std::string &ClassName) const;
1634 /// LessRecord - Sorting predicate to sort record pointers by name.
1637 bool operator()(const Record *Rec1, const Record *Rec2) const {
1638 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1642 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1645 struct LessRecordFieldName {
1646 bool operator()(const Record *Rec1, const Record *Rec2) const {
1647 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1651 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1653 } // End llvm namespace