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 //===----------------------------------------------------------------------===//
71 virtual void anchor();
73 RecTy() : ListTy(0) {}
76 virtual std::string getAsString() const = 0;
77 void print(raw_ostream &OS) const { OS << getAsString(); }
80 /// typeIsConvertibleTo - Return true if all values of 'this' type can be
81 /// converted to the specified type.
82 virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0;
84 /// getListTy - Returns the type representing list<this>.
85 ListRecTy *getListTy();
87 public: // These methods should only be called from subclasses of Init
88 virtual Init *convertValue( UnsetInit *UI) { return 0; }
89 virtual Init *convertValue( BitInit *BI) { return 0; }
90 virtual Init *convertValue( BitsInit *BI) { return 0; }
91 virtual Init *convertValue( IntInit *II) { return 0; }
92 virtual Init *convertValue(StringInit *SI) { return 0; }
93 virtual Init *convertValue( ListInit *LI) { return 0; }
94 virtual Init *convertValue( UnOpInit *UI) {
95 return convertValue((TypedInit*)UI);
97 virtual Init *convertValue( BinOpInit *UI) {
98 return convertValue((TypedInit*)UI);
100 virtual Init *convertValue( TernOpInit *UI) {
101 return convertValue((TypedInit*)UI);
103 virtual Init *convertValue( CodeInit *CI) { return 0; }
104 virtual Init *convertValue(VarBitInit *VB) { return 0; }
105 virtual Init *convertValue( DefInit *DI) { return 0; }
106 virtual Init *convertValue( DagInit *DI) { return 0; }
107 virtual Init *convertValue( TypedInit *TI) { return 0; }
108 virtual Init *convertValue( VarInit *VI) {
109 return convertValue((TypedInit*)VI);
111 virtual Init *convertValue( FieldInit *FI) {
112 return convertValue((TypedInit*)FI);
115 public: // These methods should only be called by subclasses of RecTy.
116 // baseClassOf - These virtual methods should be overloaded to return true iff
117 // all values of type 'RHS' can be converted to the 'this' type.
118 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
119 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
120 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
121 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
122 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
123 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
124 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
125 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
128 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
134 /// BitRecTy - 'bit' - Represent a single bit
136 class BitRecTy : public RecTy {
137 static BitRecTy Shared;
140 static BitRecTy *get() { return &Shared; }
142 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
143 virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
144 virtual Init *convertValue( BitsInit *BI);
145 virtual Init *convertValue( IntInit *II);
146 virtual Init *convertValue(StringInit *SI) { return 0; }
147 virtual Init *convertValue( ListInit *LI) { return 0; }
148 virtual Init *convertValue( CodeInit *CI) { return 0; }
149 virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
150 virtual Init *convertValue( DefInit *DI) { return 0; }
151 virtual Init *convertValue( DagInit *DI) { return 0; }
152 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
153 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
154 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
155 virtual Init *convertValue( TypedInit *TI);
156 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
157 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
159 std::string getAsString() const { return "bit"; }
161 bool typeIsConvertibleTo(const RecTy *RHS) const {
162 return RHS->baseClassOf(this);
164 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
165 virtual bool baseClassOf(const BitsRecTy *RHS) const;
166 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
167 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
168 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
169 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
170 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
171 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
176 // BitsRecTy - 'bits<n>' - Represent a fixed number of bits
177 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
179 class BitsRecTy : public RecTy {
181 explicit BitsRecTy(unsigned Sz) : Size(Sz) {}
183 static BitsRecTy *get(unsigned Sz);
185 unsigned getNumBits() const { return Size; }
187 virtual Init *convertValue( UnsetInit *UI);
188 virtual Init *convertValue( BitInit *UI);
189 virtual Init *convertValue( BitsInit *BI);
190 virtual Init *convertValue( IntInit *II);
191 virtual Init *convertValue(StringInit *SI) { return 0; }
192 virtual Init *convertValue( ListInit *LI) { return 0; }
193 virtual Init *convertValue( CodeInit *CI) { return 0; }
194 virtual Init *convertValue(VarBitInit *VB) { return 0; }
195 virtual Init *convertValue( DefInit *DI) { return 0; }
196 virtual Init *convertValue( DagInit *DI) { return 0; }
197 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
198 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
199 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
200 virtual Init *convertValue( TypedInit *TI);
201 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
202 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
204 std::string getAsString() const;
206 bool typeIsConvertibleTo(const RecTy *RHS) const {
207 return RHS->baseClassOf(this);
209 virtual bool baseClassOf(const BitRecTy *RHS) const { return Size == 1; }
210 virtual bool baseClassOf(const BitsRecTy *RHS) const {
211 return RHS->Size == Size;
213 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
214 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
215 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
216 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
217 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
218 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
223 /// IntRecTy - 'int' - Represent an integer value of no particular size
225 class IntRecTy : public RecTy {
226 static IntRecTy Shared;
229 static IntRecTy *get() { return &Shared; }
231 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
232 virtual Init *convertValue( BitInit *BI);
233 virtual Init *convertValue( BitsInit *BI);
234 virtual Init *convertValue( IntInit *II) { return (Init*)II; }
235 virtual Init *convertValue(StringInit *SI) { return 0; }
236 virtual Init *convertValue( ListInit *LI) { return 0; }
237 virtual Init *convertValue( CodeInit *CI) { return 0; }
238 virtual Init *convertValue(VarBitInit *VB) { return 0; }
239 virtual Init *convertValue( DefInit *DI) { return 0; }
240 virtual Init *convertValue( DagInit *DI) { return 0; }
241 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
242 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
243 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
244 virtual Init *convertValue( TypedInit *TI);
245 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
246 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
248 std::string getAsString() const { return "int"; }
250 bool typeIsConvertibleTo(const RecTy *RHS) const {
251 return RHS->baseClassOf(this);
254 virtual bool baseClassOf(const BitRecTy *RHS) const { return true; }
255 virtual bool baseClassOf(const BitsRecTy *RHS) const { return true; }
256 virtual bool baseClassOf(const IntRecTy *RHS) const { return true; }
257 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
258 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
259 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
260 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
261 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
265 /// StringRecTy - 'string' - Represent an string value
267 class StringRecTy : public RecTy {
268 static StringRecTy Shared;
271 static StringRecTy *get() { return &Shared; }
273 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
274 virtual Init *convertValue( BitInit *BI) { return 0; }
275 virtual Init *convertValue( BitsInit *BI) { return 0; }
276 virtual Init *convertValue( IntInit *II) { return 0; }
277 virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
278 virtual Init *convertValue( ListInit *LI) { return 0; }
279 virtual Init *convertValue( UnOpInit *BO);
280 virtual Init *convertValue( BinOpInit *BO);
281 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
283 virtual Init *convertValue( CodeInit *CI) { return 0; }
284 virtual Init *convertValue(VarBitInit *VB) { return 0; }
285 virtual Init *convertValue( DefInit *DI) { return 0; }
286 virtual Init *convertValue( DagInit *DI) { return 0; }
287 virtual Init *convertValue( TypedInit *TI);
288 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
289 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
291 std::string getAsString() const { return "string"; }
293 bool typeIsConvertibleTo(const RecTy *RHS) const {
294 return RHS->baseClassOf(this);
297 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
298 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
299 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
300 virtual bool baseClassOf(const StringRecTy *RHS) const { return true; }
301 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
302 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
303 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
304 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
307 // ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of
308 // the specified type.
309 /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must
310 /// be of the specified type.
312 class ListRecTy : public RecTy {
314 explicit ListRecTy(RecTy *T) : Ty(T) {}
315 friend ListRecTy *RecTy::getListTy();
317 static ListRecTy *get(RecTy *T) { return T->getListTy(); }
318 RecTy *getElementType() const { return Ty; }
320 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
321 virtual Init *convertValue( BitInit *BI) { return 0; }
322 virtual Init *convertValue( BitsInit *BI) { return 0; }
323 virtual Init *convertValue( IntInit *II) { return 0; }
324 virtual Init *convertValue(StringInit *SI) { return 0; }
325 virtual Init *convertValue( ListInit *LI);
326 virtual Init *convertValue( CodeInit *CI) { return 0; }
327 virtual Init *convertValue(VarBitInit *VB) { return 0; }
328 virtual Init *convertValue( DefInit *DI) { return 0; }
329 virtual Init *convertValue( DagInit *DI) { return 0; }
330 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
331 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
332 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
333 virtual Init *convertValue( TypedInit *TI);
334 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
335 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
337 std::string getAsString() const;
339 bool typeIsConvertibleTo(const RecTy *RHS) const {
340 return RHS->baseClassOf(this);
343 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
344 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
345 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
346 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
347 virtual bool baseClassOf(const ListRecTy *RHS) const {
348 return RHS->getElementType()->typeIsConvertibleTo(Ty);
350 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
351 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
352 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
355 /// CodeRecTy - 'code' - Represent an code fragment, function or method.
357 class CodeRecTy : public RecTy {
358 static CodeRecTy Shared;
361 static CodeRecTy *get() { return &Shared; }
363 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
364 virtual Init *convertValue( BitInit *BI) { return 0; }
365 virtual Init *convertValue( BitsInit *BI) { return 0; }
366 virtual Init *convertValue( IntInit *II) { return 0; }
367 virtual Init *convertValue(StringInit *SI) { return 0; }
368 virtual Init *convertValue( ListInit *LI) { return 0; }
369 virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
370 virtual Init *convertValue(VarBitInit *VB) { return 0; }
371 virtual Init *convertValue( DefInit *DI) { return 0; }
372 virtual Init *convertValue( DagInit *DI) { return 0; }
373 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
374 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
375 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
376 virtual Init *convertValue( TypedInit *TI);
377 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
378 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
380 std::string getAsString() const { return "code"; }
382 bool typeIsConvertibleTo(const RecTy *RHS) const {
383 return RHS->baseClassOf(this);
385 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
386 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
387 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
388 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
389 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
390 virtual bool baseClassOf(const CodeRecTy *RHS) const { return true; }
391 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
392 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
395 /// DagRecTy - 'dag' - Represent a dag fragment
397 class DagRecTy : public RecTy {
398 static DagRecTy Shared;
401 static DagRecTy *get() { return &Shared; }
403 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
404 virtual Init *convertValue( BitInit *BI) { return 0; }
405 virtual Init *convertValue( BitsInit *BI) { return 0; }
406 virtual Init *convertValue( IntInit *II) { return 0; }
407 virtual Init *convertValue(StringInit *SI) { return 0; }
408 virtual Init *convertValue( ListInit *LI) { return 0; }
409 virtual Init *convertValue( CodeInit *CI) { return 0; }
410 virtual Init *convertValue(VarBitInit *VB) { return 0; }
411 virtual Init *convertValue( DefInit *DI) { return 0; }
412 virtual Init *convertValue( UnOpInit *BO);
413 virtual Init *convertValue( BinOpInit *BO);
414 virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
415 virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
416 virtual Init *convertValue( TypedInit *TI);
417 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
418 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
420 std::string getAsString() const { return "dag"; }
422 bool typeIsConvertibleTo(const RecTy *RHS) const {
423 return RHS->baseClassOf(this);
426 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
427 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
428 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
429 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
430 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
431 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
432 virtual bool baseClassOf(const DagRecTy *RHS) const { return true; }
433 virtual bool baseClassOf(const RecordRecTy *RHS) const { return false; }
437 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
440 class RecordRecTy : public RecTy {
442 explicit RecordRecTy(Record *R) : Rec(R) {}
445 static RecordRecTy *get(Record *R);
447 Record *getRecord() const { return Rec; }
449 virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
450 virtual Init *convertValue( BitInit *BI) { return 0; }
451 virtual Init *convertValue( BitsInit *BI) { return 0; }
452 virtual Init *convertValue( IntInit *II) { return 0; }
453 virtual Init *convertValue(StringInit *SI) { return 0; }
454 virtual Init *convertValue( ListInit *LI) { return 0; }
455 virtual Init *convertValue( CodeInit *CI) { return 0; }
456 virtual Init *convertValue(VarBitInit *VB) { return 0; }
457 virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
458 virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
459 virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
460 virtual Init *convertValue( DefInit *DI);
461 virtual Init *convertValue( DagInit *DI) { return 0; }
462 virtual Init *convertValue( TypedInit *VI);
463 virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
464 virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
466 std::string getAsString() const;
468 bool typeIsConvertibleTo(const RecTy *RHS) const {
469 return RHS->baseClassOf(this);
471 virtual bool baseClassOf(const BitRecTy *RHS) const { return false; }
472 virtual bool baseClassOf(const BitsRecTy *RHS) const { return false; }
473 virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
474 virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
475 virtual bool baseClassOf(const ListRecTy *RHS) const { return false; }
476 virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
477 virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
478 virtual bool baseClassOf(const RecordRecTy *RHS) const;
481 /// resolveTypes - Find a common type that T1 and T2 convert to.
482 /// Return 0 if no such type exists.
484 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
486 //===----------------------------------------------------------------------===//
487 // Initializer Classes
488 //===----------------------------------------------------------------------===//
491 Init(const Init &); // Do not define.
492 Init &operator=(const Init &); // Do not define.
493 virtual void anchor();
501 /// isComplete - This virtual method should be overridden by values that may
502 /// not be completely specified yet.
503 virtual bool isComplete() const { return true; }
505 /// print - Print out this value.
506 void print(raw_ostream &OS) const { OS << getAsString(); }
508 /// getAsString - Convert this value to a string form.
509 virtual std::string getAsString() const = 0;
510 /// getAsUnquotedString - Convert this value to a string form,
511 /// without adding quote markers. This primaruly affects
512 /// StringInits where we will not surround the string value with
514 virtual std::string getAsUnquotedString() const { return getAsString(); }
516 /// dump - Debugging method that may be called through a debugger, just
517 /// invokes print on stderr.
520 /// convertInitializerTo - This virtual function is a simple call-back
521 /// function that should be overridden to call the appropriate
522 /// RecTy::convertValue method.
524 virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
526 /// convertInitializerBitRange - This method is used to implement the bitrange
527 /// selection operator. Given an initializer, it selects the specified bits
528 /// out, returning them as a new init of bits type. If it is not legal to use
529 /// the bit subscript operator on this initializer, return null.
532 convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
536 /// convertInitListSlice - This method is used to implement the list slice
537 /// selection operator. Given an initializer, it selects the specified list
538 /// elements, returning them as a new init of list type. If it is not legal
539 /// to take a slice of this, return null.
542 convertInitListSlice(const std::vector<unsigned> &Elements) const {
546 /// getFieldType - This method is used to implement the FieldInit class.
547 /// Implementors of this method should return the type of the named field if
548 /// they are of record type.
550 virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
552 /// getFieldInit - This method complements getFieldType to return the
553 /// initializer for the specified field. If getFieldType returns non-null
554 /// this method should return non-null, otherwise it returns null.
556 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
557 const std::string &FieldName) const {
561 /// resolveReferences - This method is used by classes that refer to other
562 /// variables which may not be defined at the time the expression is formed.
563 /// If a value is set for the variable later, this method will be called on
564 /// users of the value to allow the value to propagate out.
566 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
567 return const_cast<Init *>(this);
571 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
572 I.print(OS); return OS;
575 /// TypedInit - This is the common super-class of types that have a specific,
578 class TypedInit : public Init {
581 TypedInit(const TypedInit &Other); // Do not define.
582 TypedInit &operator=(const TypedInit &Other); // Do not define.
585 explicit TypedInit(RecTy *T) : Ty(T) {}
588 RecTy *getType() const { return Ty; }
591 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
593 convertInitListSlice(const std::vector<unsigned> &Elements) const;
595 /// getFieldType - This method is used to implement the FieldInit class.
596 /// Implementors of this method should return the type of the named field if
597 /// they are of record type.
599 virtual RecTy *getFieldType(const std::string &FieldName) const;
601 /// resolveBitReference - This method is used to implement
602 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
603 /// simply return the resolved value, otherwise we return null.
605 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
606 unsigned Bit) const = 0;
608 /// resolveListElementReference - This method is used to implement
609 /// VarListElementInit::resolveReferences. If the list element is resolvable
610 /// now, we return the resolved value, otherwise we return null.
611 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
612 unsigned Elt) const = 0;
616 /// UnsetInit - ? - Represents an uninitialized value
618 class UnsetInit : public Init {
619 UnsetInit() : Init() {}
620 UnsetInit(const UnsetInit &); // Do not define.
621 UnsetInit &operator=(const UnsetInit &Other); // Do not define.
622 virtual void anchor();
625 static UnsetInit *get();
627 virtual Init *convertInitializerTo(RecTy *Ty) const {
628 return Ty->convertValue(const_cast<UnsetInit *>(this));
631 virtual bool isComplete() const { return false; }
632 virtual std::string getAsString() const { return "?"; }
636 /// BitInit - true/false - Represent a concrete initializer for a bit.
638 class BitInit : public Init {
641 explicit BitInit(bool V) : Value(V) {}
642 BitInit(const BitInit &Other); // Do not define.
643 BitInit &operator=(BitInit &Other); // Do not define.
644 virtual void anchor();
647 static BitInit *get(bool V);
649 bool getValue() const { return Value; }
651 virtual Init *convertInitializerTo(RecTy *Ty) const {
652 return Ty->convertValue(const_cast<BitInit *>(this));
655 virtual std::string getAsString() const { return Value ? "1" : "0"; }
658 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
659 /// It contains a vector of bits, whose size is determined by the type.
661 class BitsInit : public Init, public FoldingSetNode {
662 std::vector<Init*> Bits;
664 BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
666 BitsInit(const BitsInit &Other); // Do not define.
667 BitsInit &operator=(const BitsInit &Other); // Do not define.
670 static BitsInit *get(ArrayRef<Init *> Range);
672 void Profile(FoldingSetNodeID &ID) const;
674 unsigned getNumBits() const { return Bits.size(); }
676 Init *getBit(unsigned Bit) const {
677 assert(Bit < Bits.size() && "Bit index out of range!");
681 virtual Init *convertInitializerTo(RecTy *Ty) const {
682 return Ty->convertValue(const_cast<BitsInit *>(this));
685 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
687 virtual bool isComplete() const {
688 for (unsigned i = 0; i != getNumBits(); ++i)
689 if (!getBit(i)->isComplete()) return false;
692 bool allInComplete() const {
693 for (unsigned i = 0; i != getNumBits(); ++i)
694 if (getBit(i)->isComplete()) return false;
697 virtual std::string getAsString() const;
699 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
703 /// IntInit - 7 - Represent an initalization by a literal integer value.
705 class IntInit : public TypedInit {
708 explicit IntInit(int64_t V) : TypedInit(IntRecTy::get()), Value(V) {}
710 IntInit(const IntInit &Other); // Do not define.
711 IntInit &operator=(const IntInit &Other); // Do note define.
714 static IntInit *get(int64_t V);
716 int64_t getValue() const { return Value; }
718 virtual Init *convertInitializerTo(RecTy *Ty) const {
719 return Ty->convertValue(const_cast<IntInit *>(this));
722 convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
724 virtual std::string getAsString() const;
726 /// resolveBitReference - This method is used to implement
727 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
728 /// simply return the resolved value, otherwise we return null.
730 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
731 unsigned Bit) const {
732 assert(0 && "Illegal bit reference off int");
736 /// resolveListElementReference - This method is used to implement
737 /// VarListElementInit::resolveReferences. If the list element is resolvable
738 /// now, we return the resolved value, otherwise we return null.
739 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
740 unsigned Elt) const {
741 assert(0 && "Illegal element reference off int");
747 /// StringInit - "foo" - Represent an initialization by a string value.
749 class StringInit : public TypedInit {
752 explicit StringInit(const std::string &V)
753 : TypedInit(StringRecTy::get()), Value(V) {}
755 StringInit(const StringInit &Other); // Do not define.
756 StringInit &operator=(const StringInit &Other); // Do not define.
757 virtual void anchor();
760 static StringInit *get(const std::string &V);
762 const std::string &getValue() const { return Value; }
764 virtual Init *convertInitializerTo(RecTy *Ty) const {
765 return Ty->convertValue(const_cast<StringInit *>(this));
768 virtual std::string getAsString() const { return "\"" + Value + "\""; }
769 virtual std::string getAsUnquotedString() const { return Value; }
771 /// resolveBitReference - This method is used to implement
772 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
773 /// simply return the resolved value, otherwise we return null.
775 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
776 unsigned Bit) const {
777 assert(0 && "Illegal bit reference off string");
781 /// resolveListElementReference - This method is used to implement
782 /// VarListElementInit::resolveReferences. If the list element is resolvable
783 /// now, we return the resolved value, otherwise we return null.
784 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
785 unsigned Elt) const {
786 assert(0 && "Illegal element reference off string");
791 /// CodeInit - "[{...}]" - Represent a code fragment.
793 class CodeInit : public Init {
796 explicit CodeInit(const std::string &V) : Value(V) {}
798 CodeInit(const CodeInit &Other); // Do not define.
799 CodeInit &operator=(const CodeInit &Other); // Do not define.
800 virtual void anchor();
803 static CodeInit *get(const std::string &V);
805 const std::string &getValue() const { return Value; }
807 virtual Init *convertInitializerTo(RecTy *Ty) const {
808 return Ty->convertValue(const_cast<CodeInit *>(this));
811 virtual std::string getAsString() const { return "[{" + Value + "}]"; }
814 /// ListInit - [AL, AH, CL] - Represent a list of defs
816 class ListInit : public TypedInit, public FoldingSetNode {
817 std::vector<Init*> Values;
819 typedef std::vector<Init*>::const_iterator const_iterator;
822 explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
823 : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
825 ListInit(const ListInit &Other); // Do not define.
826 ListInit &operator=(const ListInit &Other); // Do not define.
829 static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
831 void Profile(FoldingSetNodeID &ID) const;
833 unsigned getSize() const { return Values.size(); }
834 Init *getElement(unsigned i) const {
835 assert(i < Values.size() && "List element index out of range!");
839 Record *getElementAsRecord(unsigned i) const;
841 Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
843 virtual Init *convertInitializerTo(RecTy *Ty) const {
844 return Ty->convertValue(const_cast<ListInit *>(this));
847 /// resolveReferences - This method is used by classes that refer to other
848 /// variables which may not be defined at the time they expression is formed.
849 /// If a value is set for the variable later, this method will be called on
850 /// users of the value to allow the value to propagate out.
852 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
854 virtual std::string getAsString() const;
856 ArrayRef<Init*> getValues() const { return Values; }
858 inline const_iterator begin() const { return Values.begin(); }
859 inline const_iterator end () const { return Values.end(); }
861 inline size_t size () const { return Values.size(); }
862 inline bool empty() const { return Values.empty(); }
864 /// resolveBitReference - This method is used to implement
865 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
866 /// simply return the resolved value, otherwise we return null.
868 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
869 unsigned Bit) const {
870 assert(0 && "Illegal bit reference off list");
874 /// resolveListElementReference - This method is used to implement
875 /// VarListElementInit::resolveReferences. If the list element is resolvable
876 /// now, we return the resolved value, otherwise we return null.
877 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
882 /// OpInit - Base class for operators
884 class OpInit : public TypedInit {
885 OpInit(const OpInit &Other); // Do not define.
886 OpInit &operator=(OpInit &Other); // Do not define.
889 explicit OpInit(RecTy *Type) : TypedInit(Type) {}
892 // Clone - Clone this operator, replacing arguments with the new list
893 virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
895 virtual int getNumOperands() const = 0;
896 virtual Init *getOperand(int i) const = 0;
898 // Fold - If possible, fold this to a simpler init. Return this if not
900 virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
902 virtual Init *convertInitializerTo(RecTy *Ty) const {
903 return Ty->convertValue(const_cast<OpInit *>(this));
906 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
908 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
913 /// UnOpInit - !op (X) - Transform an init.
915 class UnOpInit : public OpInit {
917 enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
922 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
923 : OpInit(Type), Opc(opc), LHS(lhs) {}
925 UnOpInit(const UnOpInit &Other); // Do not define.
926 UnOpInit &operator=(const UnOpInit &Other); // Do not define.
929 static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
931 // Clone - Clone this operator, replacing arguments with the new list
932 virtual OpInit *clone(std::vector<Init *> &Operands) const {
933 assert(Operands.size() == 1 &&
934 "Wrong number of operands for unary operation");
935 return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
938 int getNumOperands() const { return 1; }
939 Init *getOperand(int i) const {
940 assert(i == 0 && "Invalid operand id for unary operator");
944 UnaryOp getOpcode() const { return Opc; }
945 Init *getOperand() const { return LHS; }
947 // Fold - If possible, fold this to a simpler init. Return this if not
949 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
951 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
953 virtual std::string getAsString() const;
956 /// BinOpInit - !op (X, Y) - Combine two inits.
958 class BinOpInit : public OpInit {
960 enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
965 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
966 OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {}
968 BinOpInit(const BinOpInit &Other); // Do not define.
969 BinOpInit &operator=(const BinOpInit &Other); // Do not define.
972 static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
975 // Clone - Clone this operator, replacing arguments with the new list
976 virtual OpInit *clone(std::vector<Init *> &Operands) const {
977 assert(Operands.size() == 2 &&
978 "Wrong number of operands for binary operation");
979 return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
982 int getNumOperands() const { return 2; }
983 Init *getOperand(int i) const {
984 assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
992 BinaryOp getOpcode() const { return Opc; }
993 Init *getLHS() const { return LHS; }
994 Init *getRHS() const { return RHS; }
996 // Fold - If possible, fold this to a simpler init. Return this if not
998 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
1000 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1002 virtual std::string getAsString() const;
1005 /// TernOpInit - !op (X, Y, Z) - Combine two inits.
1007 class TernOpInit : public OpInit {
1009 enum TernaryOp { SUBST, FOREACH, IF };
1012 Init *LHS, *MHS, *RHS;
1014 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
1016 OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
1018 TernOpInit(const TernOpInit &Other); // Do not define.
1019 TernOpInit &operator=(const TernOpInit &Other); // Do not define.
1022 static TernOpInit *get(TernaryOp opc, Init *lhs,
1023 Init *mhs, Init *rhs,
1026 // Clone - Clone this operator, replacing arguments with the new list
1027 virtual OpInit *clone(std::vector<Init *> &Operands) const {
1028 assert(Operands.size() == 3 &&
1029 "Wrong number of operands for ternary operation");
1030 return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
1034 int getNumOperands() const { return 3; }
1035 Init *getOperand(int i) const {
1036 assert((i == 0 || i == 1 || i == 2) &&
1037 "Invalid operand id for ternary operator");
1040 } else if (i == 1) {
1047 TernaryOp getOpcode() const { return Opc; }
1048 Init *getLHS() const { return LHS; }
1049 Init *getMHS() const { return MHS; }
1050 Init *getRHS() const { return RHS; }
1052 // Fold - If possible, fold this to a simpler init. Return this if not
1053 // possible to fold.
1054 Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
1056 virtual bool isComplete() const { return false; }
1058 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1060 virtual std::string getAsString() const;
1064 /// VarInit - 'Opcode' - Represent a reference to an entire variable object.
1066 class VarInit : public TypedInit {
1069 explicit VarInit(const std::string &VN, RecTy *T)
1070 : TypedInit(T), VarName(StringInit::get(VN)) {}
1071 explicit VarInit(Init *VN, RecTy *T)
1072 : TypedInit(T), VarName(VN) {}
1074 VarInit(const VarInit &Other); // Do not define.
1075 VarInit &operator=(const VarInit &Other); // Do not define.
1078 static VarInit *get(const std::string &VN, RecTy *T);
1079 static VarInit *get(Init *VN, RecTy *T);
1081 virtual Init *convertInitializerTo(RecTy *Ty) const {
1082 return Ty->convertValue(const_cast<VarInit *>(this));
1085 const std::string &getName() const;
1086 Init *getNameInit() const { return VarName; }
1087 std::string getNameInitAsString() const {
1088 return getNameInit()->getAsUnquotedString();
1091 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1092 unsigned Bit) const;
1093 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1094 unsigned Elt) const;
1096 virtual RecTy *getFieldType(const std::string &FieldName) const;
1097 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1098 const std::string &FieldName) const;
1100 /// resolveReferences - This method is used by classes that refer to other
1101 /// variables which may not be defined at the time they expression is formed.
1102 /// If a value is set for the variable later, this method will be called on
1103 /// users of the value to allow the value to propagate out.
1105 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1107 virtual std::string getAsString() const { return getName(); }
1111 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
1113 class VarBitInit : public Init {
1117 VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
1118 assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
1119 ((BitsRecTy*)T->getType())->getNumBits() > B &&
1120 "Illegal VarBitInit expression!");
1123 VarBitInit(const VarBitInit &Other); // Do not define.
1124 VarBitInit &operator=(const VarBitInit &Other); // Do not define.
1127 static VarBitInit *get(TypedInit *T, unsigned B);
1129 virtual Init *convertInitializerTo(RecTy *Ty) const {
1130 return Ty->convertValue(const_cast<VarBitInit *>(this));
1133 TypedInit *getVariable() const { return TI; }
1134 unsigned getBitNum() const { return Bit; }
1136 virtual std::string getAsString() const;
1137 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1140 /// VarListElementInit - List[4] - Represent access to one element of a var or
1142 class VarListElementInit : public TypedInit {
1146 VarListElementInit(TypedInit *T, unsigned E)
1147 : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
1149 assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
1150 "Illegal VarBitInit expression!");
1153 VarListElementInit(const VarListElementInit &Other); // Do not define.
1154 VarListElementInit &operator=(const VarListElementInit &Other); // Do
1159 static VarListElementInit *get(TypedInit *T, unsigned E);
1161 virtual Init *convertInitializerTo(RecTy *Ty) const {
1162 return Ty->convertValue(const_cast<VarListElementInit *>(this));
1165 TypedInit *getVariable() const { return TI; }
1166 unsigned getElementNum() const { return Element; }
1168 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1169 unsigned Bit) const;
1171 /// resolveListElementReference - This method is used to implement
1172 /// VarListElementInit::resolveReferences. If the list element is resolvable
1173 /// now, we return the resolved value, otherwise we return null.
1174 virtual Init *resolveListElementReference(Record &R,
1175 const RecordVal *RV,
1176 unsigned Elt) const;
1178 virtual std::string getAsString() const;
1179 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1182 /// DefInit - AL - Represent a reference to a 'def' in the description
1184 class DefInit : public TypedInit {
1187 DefInit(Record *D, RecordRecTy *T) : TypedInit(T), Def(D) {}
1188 friend class Record;
1190 DefInit(const DefInit &Other); // Do not define.
1191 DefInit &operator=(const DefInit &Other); // Do not define.
1194 static DefInit *get(Record*);
1196 virtual Init *convertInitializerTo(RecTy *Ty) const {
1197 return Ty->convertValue(const_cast<DefInit *>(this));
1200 Record *getDef() const { return Def; }
1202 //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
1204 virtual RecTy *getFieldType(const std::string &FieldName) const;
1205 virtual Init *getFieldInit(Record &R, const RecordVal *RV,
1206 const std::string &FieldName) const;
1208 virtual std::string getAsString() const;
1210 /// resolveBitReference - This method is used to implement
1211 /// VarBitInit::resolveReferences. If the bit is able to be resolved, we
1212 /// simply return the resolved value, otherwise we return null.
1214 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1215 unsigned Bit) const {
1216 assert(0 && "Illegal bit reference off def");
1220 /// resolveListElementReference - This method is used to implement
1221 /// VarListElementInit::resolveReferences. If the list element is resolvable
1222 /// now, we return the resolved value, otherwise we return null.
1223 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1224 unsigned Elt) const {
1225 assert(0 && "Illegal element reference off def");
1231 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
1233 class FieldInit : public TypedInit {
1234 Init *Rec; // Record we are referring to
1235 std::string FieldName; // Field we are accessing
1237 FieldInit(Init *R, const std::string &FN)
1238 : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
1239 assert(getType() && "FieldInit with non-record type!");
1242 FieldInit(const FieldInit &Other); // Do not define.
1243 FieldInit &operator=(const FieldInit &Other); // Do not define.
1246 static FieldInit *get(Init *R, const std::string &FN);
1247 static FieldInit *get(Init *R, const Init *FN);
1249 virtual Init *convertInitializerTo(RecTy *Ty) const {
1250 return Ty->convertValue(const_cast<FieldInit *>(this));
1253 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1254 unsigned Bit) const;
1255 virtual Init *resolveListElementReference(Record &R,
1256 const RecordVal *RV,
1257 unsigned Elt) const;
1259 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1261 virtual std::string getAsString() const {
1262 return Rec->getAsString() + "." + FieldName;
1266 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
1267 /// to have at least one value then a (possibly empty) list of arguments. Each
1268 /// argument can have a name associated with it.
1270 class DagInit : public TypedInit, public FoldingSetNode {
1272 std::string ValName;
1273 std::vector<Init*> Args;
1274 std::vector<std::string> ArgNames;
1276 DagInit(Init *V, const std::string &VN,
1277 ArrayRef<Init *> ArgRange,
1278 ArrayRef<std::string> NameRange)
1279 : TypedInit(DagRecTy::get()), Val(V), ValName(VN),
1280 Args(ArgRange.begin(), ArgRange.end()),
1281 ArgNames(NameRange.begin(), NameRange.end()) {}
1283 DagInit(const DagInit &Other); // Do not define.
1284 DagInit &operator=(const DagInit &Other); // Do not define.
1287 static DagInit *get(Init *V, const std::string &VN,
1288 ArrayRef<Init *> ArgRange,
1289 ArrayRef<std::string> NameRange);
1290 static DagInit *get(Init *V, const std::string &VN,
1292 std::pair<Init*, std::string> > &args);
1294 void Profile(FoldingSetNodeID &ID) const;
1296 virtual Init *convertInitializerTo(RecTy *Ty) const {
1297 return Ty->convertValue(const_cast<DagInit *>(this));
1300 Init *getOperator() const { return Val; }
1302 const std::string &getName() const { return ValName; }
1304 unsigned getNumArgs() const { return Args.size(); }
1305 Init *getArg(unsigned Num) const {
1306 assert(Num < Args.size() && "Arg number out of range!");
1309 const std::string &getArgName(unsigned Num) const {
1310 assert(Num < ArgNames.size() && "Arg number out of range!");
1311 return ArgNames[Num];
1314 virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
1316 virtual std::string getAsString() const;
1318 typedef std::vector<Init*>::const_iterator const_arg_iterator;
1319 typedef std::vector<std::string>::const_iterator const_name_iterator;
1321 inline const_arg_iterator arg_begin() const { return Args.begin(); }
1322 inline const_arg_iterator arg_end () const { return Args.end(); }
1324 inline size_t arg_size () const { return Args.size(); }
1325 inline bool arg_empty() const { return Args.empty(); }
1327 inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1328 inline const_name_iterator name_end () const { return ArgNames.end(); }
1330 inline size_t name_size () const { return ArgNames.size(); }
1331 inline bool name_empty() const { return ArgNames.empty(); }
1333 virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
1334 unsigned Bit) const {
1335 assert(0 && "Illegal bit reference off dag");
1339 virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
1340 unsigned Elt) const {
1341 assert(0 && "Illegal element reference off dag");
1346 //===----------------------------------------------------------------------===//
1347 // High-Level Classes
1348 //===----------------------------------------------------------------------===//
1356 RecordVal(Init *N, RecTy *T, unsigned P);
1357 RecordVal(const std::string &N, RecTy *T, unsigned P);
1359 const std::string &getName() const;
1360 const Init *getNameInit() const { return Name; }
1361 std::string getNameInitAsString() const {
1362 return getNameInit()->getAsUnquotedString();
1365 unsigned getPrefix() const { return Prefix; }
1366 RecTy *getType() const { return Ty; }
1367 Init *getValue() const { return Value; }
1369 bool setValue(Init *V) {
1371 Value = V->convertInitializerTo(Ty);
1379 void print(raw_ostream &OS, bool PrintSem = true) const;
1382 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1383 RV.print(OS << " ");
1388 static unsigned LastID;
1390 // Unique record ID.
1394 std::vector<Init *> TemplateArgs;
1395 std::vector<RecordVal> Values;
1396 std::vector<Record*> SuperClasses;
1398 // Tracks Record instances. Not owned by Record.
1399 RecordKeeper &TrackedRecords;
1408 // Constructs a record.
1409 explicit Record(const std::string &N, SMLoc loc, RecordKeeper &records) :
1410 ID(LastID++), Name(StringInit::get(N)), Loc(loc), TrackedRecords(records),
1414 explicit Record(Init *N, SMLoc loc, RecordKeeper &records) :
1415 ID(LastID++), Name(N), Loc(loc), TrackedRecords(records), TheInit(0) {
1421 static unsigned getNewUID() { return LastID++; }
1424 unsigned getID() const { return ID; }
1426 const std::string &getName() const;
1427 Init *getNameInit() const {
1430 const std::string getNameInitAsString() const {
1431 return getNameInit()->getAsUnquotedString();
1434 void setName(Init *Name); // Also updates RecordKeeper.
1435 void setName(const std::string &Name); // Also updates RecordKeeper.
1437 SMLoc getLoc() const { return Loc; }
1439 /// get the corresponding DefInit.
1440 DefInit *getDefInit();
1442 const std::vector<Init *> &getTemplateArgs() const {
1443 return TemplateArgs;
1445 const std::vector<RecordVal> &getValues() const { return Values; }
1446 const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
1448 bool isTemplateArg(Init *Name) const {
1449 for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
1450 if (TemplateArgs[i] == Name) return true;
1453 bool isTemplateArg(StringRef Name) const {
1454 return isTemplateArg(StringInit::get(Name.str()));
1457 const RecordVal *getValue(StringRef Name) const {
1458 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1459 if (Values[i].getName() == Name) return &Values[i];
1462 RecordVal *getValue(StringRef Name) {
1463 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1464 if (Values[i].getName() == Name) return &Values[i];
1468 const RecordVal *getValue(Init *Name) const;
1469 RecordVal *getValue(Init *Name);
1471 void addTemplateArg(Init *Name) {
1472 assert(!isTemplateArg(Name) && "Template arg already defined!");
1473 TemplateArgs.push_back(Name);
1475 void addTemplateArg(StringRef Name) {
1476 addTemplateArg(StringInit::get(Name.str()));
1479 void addValue(const RecordVal &RV) {
1480 assert(getValue(RV.getName()) == 0 && "Value already added!");
1481 Values.push_back(RV);
1482 if (Values.size() > 1)
1483 // Keep NAME at the end of the list. It makes record dumps a
1484 // bit prettier and allows TableGen tests to be written more
1485 // naturally. Tests can use CHECK-NEXT to look for Record
1486 // fields they expect to see after a def. They can't do that if
1487 // NAME is the first Record field.
1488 std::swap(Values[Values.size() - 2], Values[Values.size() - 1]);
1491 void removeValue(Init *Name) {
1492 for (unsigned i = 0, e = Values.size(); i != e; ++i)
1493 if (Values[i].getNameInit() == Name) {
1494 Values.erase(Values.begin()+i);
1497 assert(0 && "Cannot remove an entry that does not exist!");
1500 void removeValue(StringRef Name) {
1501 removeValue(StringInit::get(Name.str()));
1504 bool isSubClassOf(const Record *R) const {
1505 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1506 if (SuperClasses[i] == R)
1511 bool isSubClassOf(StringRef Name) const {
1512 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
1513 if (SuperClasses[i]->getNameInitAsString() == Name)
1518 void addSuperClass(Record *R) {
1519 assert(!isSubClassOf(R) && "Already subclassing record!");
1520 SuperClasses.push_back(R);
1523 /// resolveReferences - If there are any field references that refer to fields
1524 /// that have been filled in, we can propagate the values now.
1526 void resolveReferences() { resolveReferencesTo(0); }
1528 /// resolveReferencesTo - If anything in this record refers to RV, replace the
1529 /// reference to RV with the RHS of RV. If RV is null, we resolve all
1530 /// possible references.
1531 void resolveReferencesTo(const RecordVal *RV);
1533 RecordKeeper &getRecords() const {
1534 return TrackedRecords;
1539 //===--------------------------------------------------------------------===//
1540 // High-level methods useful to tablegen back-ends
1543 /// getValueInit - Return the initializer for a value with the specified name,
1544 /// or throw an exception if the field does not exist.
1546 Init *getValueInit(StringRef FieldName) const;
1548 /// getValueAsString - This method looks up the specified field and returns
1549 /// its value as a string, throwing an exception if the field does not exist
1550 /// or if the value is not a string.
1552 std::string getValueAsString(StringRef FieldName) const;
1554 /// getValueAsBitsInit - This method looks up the specified field and returns
1555 /// its value as a BitsInit, throwing an exception if the field does not exist
1556 /// or if the value is not the right type.
1558 BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1560 /// getValueAsListInit - This method looks up the specified field and returns
1561 /// its value as a ListInit, throwing an exception if the field does not exist
1562 /// or if the value is not the right type.
1564 ListInit *getValueAsListInit(StringRef FieldName) const;
1566 /// getValueAsListOfDefs - This method looks up the specified field and
1567 /// returns its value as a vector of records, throwing an exception if the
1568 /// field does not exist or if the value is not the right type.
1570 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1572 /// getValueAsListOfInts - This method looks up the specified field and
1573 /// returns its value as a vector of integers, throwing an exception if the
1574 /// field does not exist or if the value is not the right type.
1576 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1578 /// getValueAsListOfStrings - This method looks up the specified field and
1579 /// returns its value as a vector of strings, throwing an exception if the
1580 /// field does not exist or if the value is not the right type.
1582 std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1584 /// getValueAsDef - This method looks up the specified field and returns its
1585 /// value as a Record, throwing an exception if the field does not exist or if
1586 /// the value is not the right type.
1588 Record *getValueAsDef(StringRef FieldName) const;
1590 /// getValueAsBit - This method looks up the specified field and returns its
1591 /// value as a bit, throwing an exception if the field does not exist or if
1592 /// the value is not the right type.
1594 bool getValueAsBit(StringRef FieldName) const;
1596 /// getValueAsInt - This method looks up the specified field and returns its
1597 /// value as an int64_t, throwing an exception if the field does not exist or
1598 /// if the value is not the right type.
1600 int64_t getValueAsInt(StringRef FieldName) const;
1602 /// getValueAsDag - This method looks up the specified field and returns its
1603 /// value as an Dag, throwing an exception if the field does not exist or if
1604 /// the value is not the right type.
1606 DagInit *getValueAsDag(StringRef FieldName) const;
1608 /// getValueAsCode - This method looks up the specified field and returns
1609 /// its value as the string data in a CodeInit, throwing an exception if the
1610 /// field does not exist or if the value is not a code object.
1612 std::string getValueAsCode(StringRef FieldName) const;
1615 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1618 Record Rec; // Placeholder for template args and Name.
1619 typedef std::vector<Record*> RecordVector;
1620 RecordVector DefPrototypes;
1624 MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1625 Rec(Name, Loc, Records) {}
1628 class RecordKeeper {
1629 std::map<std::string, Record*> Classes, Defs;
1632 for (std::map<std::string, Record*>::iterator I = Classes.begin(),
1633 E = Classes.end(); I != E; ++I)
1635 for (std::map<std::string, Record*>::iterator I = Defs.begin(),
1636 E = Defs.end(); I != E; ++I)
1640 const std::map<std::string, Record*> &getClasses() const { return Classes; }
1641 const std::map<std::string, Record*> &getDefs() const { return Defs; }
1643 Record *getClass(const std::string &Name) const {
1644 std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
1645 return I == Classes.end() ? 0 : I->second;
1647 Record *getDef(const std::string &Name) const {
1648 std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
1649 return I == Defs.end() ? 0 : I->second;
1651 void addClass(Record *R) {
1652 assert(getClass(R->getNameInitAsString()) == 0 && "Class already exists!");
1653 Classes.insert(std::make_pair(R->getNameInitAsString(), R));
1655 void addDef(Record *R) {
1656 assert(getDef(R->getNameInitAsString()) == 0 && "Def already exists!");
1657 Defs.insert(std::make_pair(R->getNameInitAsString(), R));
1660 /// removeClass - Remove, but do not delete, the specified record.
1662 void removeClass(const std::string &Name) {
1663 assert(Classes.count(Name) && "Class does not exist!");
1664 Classes.erase(Name);
1666 /// removeDef - Remove, but do not delete, the specified record.
1668 void removeDef(const std::string &Name) {
1669 assert(Defs.count(Name) && "Def does not exist!");
1673 //===--------------------------------------------------------------------===//
1674 // High-level helper methods, useful for tablegen backends...
1676 /// getAllDerivedDefinitions - This method returns all concrete definitions
1677 /// that derive from the specified class name. If a class with the specified
1678 /// name does not exist, an exception is thrown.
1679 std::vector<Record*>
1680 getAllDerivedDefinitions(const std::string &ClassName) const;
1685 /// LessRecord - Sorting predicate to sort record pointers by name.
1688 bool operator()(const Record *Rec1, const Record *Rec2) const {
1689 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1693 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1696 struct LessRecordFieldName {
1697 bool operator()(const Record *Rec1, const Record *Rec2) const {
1698 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1702 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1704 /// QualifyName - Return an Init with a qualifier prefix referring
1705 /// to CurRec's name.
1706 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1707 Init *Name, const std::string &Scoper);
1709 /// QualifyName - Return an Init with a qualifier prefix referring
1710 /// to CurRec's name.
1711 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1712 const std::string &Name, const std::string &Scoper);
1714 } // End llvm namespace