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 {
1063 explicit VarInit(const std::string &VN, RecTy *T)
1064 : TypedInit(T), VarName(StringInit::get(VN)) {}
1065 explicit VarInit(Init *VN, RecTy *T)
1066 : TypedInit(T), VarName(VN) {}
1068 VarInit(const VarInit &Other); // Do not define.
1069 VarInit &operator=(const VarInit &Other); // Do not define.
1072 static VarInit *get(const std::string &VN, RecTy *T);
1073 static VarInit *get(Init *VN, RecTy *T);
1075 virtual Init *convertInitializerTo(RecTy *Ty) const {
1076 return Ty->convertValue(const_cast<VarInit *>(this));
1079 const std::string &getName() const;
1080 Init *getNameInit() const { return VarName; }
1081 std::string getNameInitAsString() const {
1082 return getNameInit()->getAsUnquotedString();
1085 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1086 unsigned Bit) const;
1087 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1088 unsigned Elt) const;
1090 virtual RecTy *getFieldType(const std::string &FieldName) const;
1091 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1092 const std::string &FieldName) const;
1094 /// resolveReferences - This method is used by classes that refer to other
1095 /// variables which may not be defined at the time they expression is formed.
1096 /// If a value is set for the variable later, this method will be called on
1097 /// users of the value to allow the value to propagate out.
1099 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1101 virtual std::string getAsString() const { return getName(); }
1105 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
1107 class VarBitInit : public Init {
1111 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
1112 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
1113 ((BitsRecTy*)T->getType())->getNumBits() > B &&
1114 "Illegal VarBitInit expression!");
1117 VarBitInit(const VarBitInit &Other); // Do not define.
1118 VarBitInit &operator=(const VarBitInit &Other); // Do not define.
1121 static VarBitInit *get(TypedInit *T, unsigned B);
1123 virtual Init *convertInitializerTo(RecTy *Ty) const {
1124 return Ty->convertValue(const_cast<VarBitInit *>(this));
1127 TypedInit *getVariable() const { return TI; }
1128 unsigned getBitNum() const { return Bit; }
1130 virtual std::string getAsString() const;
1131 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1134 /// VarListElementInit - List[4] - Represent access to one element of a var or
1136 class VarListElementInit : public TypedInit {
1140 VarListElementInit(TypedInit *T, unsigned E)
1141 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1143 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
1144 "Illegal VarBitInit expression!");
1147 VarListElementInit(const VarListElementInit &Other); // Do not define.
1148 VarListElementInit &operator=(const VarListElementInit &Other); // Do
1153 static VarListElementInit *get(TypedInit *T, unsigned E);
1155 virtual Init *convertInitializerTo(RecTy *Ty) const {
1156 return Ty->convertValue(const_cast<VarListElementInit *>(this));
1159 TypedInit *getVariable() const { return TI; }
1160 unsigned getElementNum() const { return Element; }
1162 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1163 unsigned Bit) const;
1165 /// resolveListElementReference - This method is used to implement
1166 /// VarListElementInit::resolveReferences. If the list element is resolvable
1167 /// now, we return the resolved value, otherwise we return null.
1168 virtual Init *resolveListElementReference(Record &R,
1169 const RecordVal *RV,
1170 unsigned Elt) const;
1172 virtual std::string getAsString() const;
1173 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1176 /// DefInit - AL - Represent a reference to a 'def' in the description
1178 class DefInit : public TypedInit {
1181 DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {}
1182 friend class Record;
1184 DefInit(const DefInit &Other); // Do not define.
1185 DefInit &operator=(const DefInit &Other); // Do not define.
1188 static DefInit *get(Record*);
1190 virtual Init *convertInitializerTo(RecTy *Ty) const {
1191 return Ty->convertValue(const_cast<DefInit *>(this));
1194 Record *getDef() const { return Def; }
1196 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
1198 virtual RecTy *getFieldType(const std::string &FieldName) const;
1199 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1200 const std::string &FieldName) const;
1202 virtual std::string getAsString() const;
1204 /// resolveBitReference - This method is used to implement
1205 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
1206 /// simply return the resolved value, otherwise we return null.
1208 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1209 unsigned Bit) const {
1210 assert(0 && "Illegal bit reference off def");
1214 /// resolveListElementReference - This method is used to implement
1215 /// VarListElementInit::resolveReferences. If the list element is resolvable
1216 /// now, we return the resolved value, otherwise we return null.
1217 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1218 unsigned Elt) const {
1219 assert(0 && "Illegal element reference off def");
1225 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
1227 class FieldInit : public TypedInit {
1228 Init *Rec; // Record we are referring to
1229 std::string FieldName; // Field we are accessing
1231 FieldInit(Init *R, const std::string &FN)
1232 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
1233 assert(getType() && "FieldInit with non-record type!");
1236 FieldInit(const FieldInit &Other); // Do not define.
1237 FieldInit &operator=(const FieldInit &Other); // Do not define.
1240 static FieldInit *get(Init *R, const std::string &FN);
1241 static FieldInit *get(Init *R, const Init *FN);
1243 virtual Init *convertInitializerTo(RecTy *Ty) const {
1244 return Ty->convertValue(const_cast<FieldInit *>(this));
1247 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1248 unsigned Bit) const;
1249 virtual Init *resolveListElementReference(Record &R,
1250 const RecordVal *RV,
1251 unsigned Elt) const;
1253 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1255 virtual std::string getAsString() const {
1256 return Rec->getAsString() + "." + FieldName;
1260 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
1261 /// to have at least one value then a (possibly empty) list of arguments. Each
1262 /// argument can have a name associated with it.
1264 class DagInit : public TypedInit, public FoldingSetNode {
1266 std::string ValName;
1267 std::vector<Init*> Args;
1268 std::vector<std::string> ArgNames;
1270 DagInit(Init *V, const std::string &VN,
1271 ArrayRef<Init *> ArgRange,
1272 ArrayRef<std::string> NameRange)
1273 : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
1274 Args(ArgRange.begin(), ArgRange.end()),
1275 ArgNames(NameRange.begin(), NameRange.end()) {}
1277 DagInit(const DagInit &Other); // Do not define.
1278 DagInit &operator=(const DagInit &Other); // Do not define.
1281 static DagInit *get(Init *V, const std::string &VN,
1282 ArrayRef<Init *> ArgRange,
1283 ArrayRef<std::string> NameRange);
1284 static DagInit *get(Init *V, const std::string &VN,
1286 std::pair<Init*, std::string> > &args);
1288 void Profile(FoldingSetNodeID &ID) const;
1290 virtual Init *convertInitializerTo(RecTy *Ty) const {
1291 return Ty->convertValue(const_cast<DagInit *>(this));
1294 Init *getOperator() const { return Val; }
1296 const std::string &getName() const { return ValName; }
1298 unsigned getNumArgs() const { return Args.size(); }
1299 Init *getArg(unsigned Num) const {
1300 assert(Num < Args.size() && "Arg number out of range!");
1303 const std::string &getArgName(unsigned Num) const {
1304 assert(Num < ArgNames.size() && "Arg number out of range!");
1305 return ArgNames[Num];
1308 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1310 virtual std::string getAsString() const;
1312 typedef std::vector<Init*>::const_iterator const_arg_iterator;
1313 typedef std::vector<std::string>::const_iterator const_name_iterator;
1315 inline const_arg_iterator arg_begin() const { return Args.begin(); }
1316 inline const_arg_iterator arg_end () const { return Args.end(); }
1318 inline size_t arg_size () const { return Args.size(); }
1319 inline bool arg_empty() const { return Args.empty(); }
1321 inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1322 inline const_name_iterator name_end () const { return ArgNames.end(); }
1324 inline size_t name_size () const { return ArgNames.size(); }
1325 inline bool name_empty() const { return ArgNames.empty(); }
1327 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1328 unsigned Bit) const {
1329 assert(0 && "Illegal bit reference off dag");
1333 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1334 unsigned Elt) const {
1335 assert(0 && "Illegal element reference off dag");
1340 //===----------------------------------------------------------------------===//
1341 // High-Level Classes
1342 //===----------------------------------------------------------------------===//
1350 RecordVal(Init *N, RecTy *T, unsigned P);
1351 RecordVal(const std::string &N, RecTy *T, unsigned P);
1353 const std::string &getName() const;
1354 const Init *getNameInit() const { return Name; }
1355 std::string getNameInitAsString() const {
1356 return getNameInit()->getAsUnquotedString();
1359 unsigned getPrefix() const { return Prefix; }
1360 RecTy *getType() const { return Ty; }
1361 Init *getValue() const { return Value; }
1363 bool setValue(Init *V) {
1365 Value = V->convertInitializerTo(Ty);
1373 void print(raw_ostream &OS, bool PrintSem = true) const;
1376 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1377 RV.print(OS << " ");
1382 static unsigned LastID;
1384 // Unique record ID.
1388 std::vector<Init *> TemplateArgs;
1389 std::vector<RecordVal> Values;
1390 std::vector<Record*> SuperClasses;
1392 // Tracks Record instances. Not owned by Record.
1393 RecordKeeper &TrackedRecords;
1402 // Constructs a record.
1403 explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) :
1404 ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records), TheInit(0) {}
1408 static unsigned getNewUID() { return LastID++; }
1411 unsigned getID() const { return ID; }
1413 const std::string &getName() const;
1414 Init *getNameInit() const {
1417 const std::string getNameInitAsString() const {
1418 return getNameInit()->getAsUnquotedString();
1421 void setName(Init *Name); // Also updates RecordKeeper.
1422 void setName(const std::string &Name); // Also updates RecordKeeper.
1424 SMLoc getLoc() const { return Loc; }
1426 /// get the corresponding DefInit.
1427 DefInit *getDefInit();
1429 const std::vector<Init *> &getTemplateArgs() const {
1430 return TemplateArgs;
1432 const std::vector<RecordVal> &getValues() const { return Values; }
1433 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
1435 bool isTemplateArg(Init *Name) const {
1436 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
1437 if (TemplateArgs[i] == Name) return true;
1440 bool isTemplateArg(StringRef Name) const {
1441 return isTemplateArg(StringInit::get(Name.str()));
1444 const RecordVal *getValue(StringRef Name) const {
1445 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1446 if (Values[i].getName() == Name) return &Values[i];
1449 RecordVal *getValue(StringRef Name) {
1450 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1451 if (Values[i].getName() == Name) return &Values[i];
1455 const RecordVal *getValue(Init *Name) const;
1456 RecordVal *getValue(Init *Name);
1458 void addTemplateArg(Init *Name) {
1459 assert(!isTemplateArg(Name) && "Template arg already defined!");
1460 TemplateArgs.push_back(Name);
1462 void addTemplateArg(StringRef Name) {
1463 addTemplateArg(StringInit::get(Name.str()));
1466 void addValue(const RecordVal &RV) {
1467 assert(getValue(RV.getName()) == 0 && "Value already added!");
1468 Values.push_back(RV);
1471 void removeValue(Init *Name) {
1472 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1473 if (Values[i].getNameInit() == Name) {
1474 Values.erase(Values.begin()+i);
1477 assert(0 && "Cannot remove an entry that does not exist!");
1480 void removeValue(StringRef Name) {
1481 removeValue(StringInit::get(Name.str()));
1484 bool isSubClassOf(const Record *R) const {
1485 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1486 if (SuperClasses[i] == R)
1491 bool isSubClassOf(StringRef Name) const {
1492 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1493 if (SuperClasses[i]->getNameInitAsString() == Name)
1498 void addSuperClass(Record *R) {
1499 assert(!isSubClassOf(R) && "Already subclassing record!");
1500 SuperClasses.push_back(R);
1503 /// resolveReferences - If there are any field references that refer to fields
1504 /// that have been filled in, we can propagate the values now.
1506 void resolveReferences() { resolveReferencesTo(0); }
1508 /// resolveReferencesTo - If anything in this record refers to RV, replace the
1509 /// reference to RV with the RHS of RV. If RV is null, we resolve all
1510 /// possible references.
1511 void resolveReferencesTo(const RecordVal *RV);
1513 RecordKeeper &getRecords() const {
1514 return TrackedRecords;
1519 //===--------------------------------------------------------------------===//
1520 // High-level methods useful to tablegen back-ends
1523 /// getValueInit - Return the initializer for a value with the specified name,
1524 /// or throw an exception if the field does not exist.
1526 Init *getValueInit(StringRef FieldName) const;
1528 /// getValueAsString - This method looks up the specified field and returns
1529 /// its value as a string, throwing an exception if the field does not exist
1530 /// or if the value is not a string.
1532 std::string getValueAsString(StringRef FieldName) const;
1534 /// getValueAsBitsInit - This method looks up the specified field and returns
1535 /// its value as a BitsInit, throwing an exception if the field does not exist
1536 /// or if the value is not the right type.
1538 BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1540 /// getValueAsListInit - This method looks up the specified field and returns
1541 /// its value as a ListInit, throwing an exception if the field does not exist
1542 /// or if the value is not the right type.
1544 ListInit *getValueAsListInit(StringRef FieldName) const;
1546 /// getValueAsListOfDefs - This method looks up the specified field and
1547 /// returns its value as a vector of records, throwing an exception if the
1548 /// field does not exist or if the value is not the right type.
1550 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1552 /// getValueAsListOfInts - This method looks up the specified field and
1553 /// returns its value as a vector of integers, throwing an exception if the
1554 /// field does not exist or if the value is not the right type.
1556 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1558 /// getValueAsListOfStrings - This method looks up the specified field and
1559 /// returns its value as a vector of strings, throwing an exception if the
1560 /// field does not exist or if the value is not the right type.
1562 std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1564 /// getValueAsDef - This method looks up the specified field and returns its
1565 /// value as a Record, throwing an exception if the field does not exist or if
1566 /// the value is not the right type.
1568 Record *getValueAsDef(StringRef FieldName) const;
1570 /// getValueAsBit - This method looks up the specified field and returns its
1571 /// value as a bit, throwing an exception if the field does not exist or if
1572 /// the value is not the right type.
1574 bool getValueAsBit(StringRef FieldName) const;
1576 /// getValueAsInt - This method looks up the specified field and returns its
1577 /// value as an int64_t, throwing an exception if the field does not exist or
1578 /// if the value is not the right type.
1580 int64_t getValueAsInt(StringRef FieldName) const;
1582 /// getValueAsDag - This method looks up the specified field and returns its
1583 /// value as an Dag, throwing an exception if the field does not exist or if
1584 /// the value is not the right type.
1586 DagInit *getValueAsDag(StringRef FieldName) const;
1588 /// getValueAsCode - This method looks up the specified field and returns
1589 /// its value as the string data in a CodeInit, throwing an exception if the
1590 /// field does not exist or if the value is not a code object.
1592 std::string getValueAsCode(StringRef FieldName) const;
1595 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1598 Record Rec; // Placeholder for template args and Name.
1599 typedef std::vector<Record*> RecordVector;
1600 RecordVector DefPrototypes;
1604 MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1605 Rec(Name, Loc, Records) {}
1608 class RecordKeeper {
1609 std::map<std::string, Record*> Classes, Defs;
1612 for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1613 E = Classes.end(); I != E; ++I)
1615 for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1616 E = Defs.end(); I != E; ++I)
1620 const std::map<std::string, Record*> &getClasses() const { return Classes; }
1621 const std::map<std::string, Record*> &getDefs() const { return Defs; }
1623 Record *getClass(const std::string &Name) const {
1624 std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1625 return I == Classes.end() ? 0 : I->second;
1627 Record *getDef(const std::string &Name) const {
1628 std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1629 return I == Defs.end() ? 0 : I->second;
1631 void addClass(Record *R) {
1632 assert(getClass(R->getNameInitAsString()) == 0 && "Class already exists!");
1633 Classes.insert(std::make_pair(R->getNameInitAsString(), R));
1635 void addDef(Record *R) {
1636 assert(getDef(R->getNameInitAsString()) == 0 && "Def already exists!");
1637 Defs.insert(std::make_pair(R->getNameInitAsString(), R));
1640 /// removeClass - Remove, but do not delete, the specified record.
1642 void removeClass(const std::string &Name) {
1643 assert(Classes.count(Name) && "Class does not exist!");
1644 Classes.erase(Name);
1646 /// removeDef - Remove, but do not delete, the specified record.
1648 void removeDef(const std::string &Name) {
1649 assert(Defs.count(Name) && "Def does not exist!");
1653 //===--------------------------------------------------------------------===//
1654 // High-level helper methods, useful for tablegen backends...
1656 /// getAllDerivedDefinitions - This method returns all concrete definitions
1657 /// that derive from the specified class name. If a class with the specified
1658 /// name does not exist, an exception is thrown.
1659 std::vector<Record*>
1660 getAllDerivedDefinitions(const std::string &ClassName) const;
1665 /// LessRecord - Sorting predicate to sort record pointers by name.
1668 bool operator()(const Record *Rec1, const Record *Rec2) const {
1669 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1673 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1676 struct LessRecordFieldName {
1677 bool operator()(const Record *Rec1, const Record *Rec2) const {
1678 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1682 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1684 /// QualifyName - Return an Init with a qualifier prefix referring
1685 /// to CurRec's name.
1686 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1687 Init *Name, const std::string &Scoper);
1689 /// QualifyName - Return an Init with a qualifier prefix referring
1690 /// to CurRec's name.
1691 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1692 const std::string &Name, const std::string &Scoper);
1694 } // End llvm namespace