LLVM  3.7.0
Record.h
Go to the documentation of this file.
1 //===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the main TableGen data structures, including the TableGen
11 // types, values, and high-level data structures.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TABLEGEN_RECORD_H
16 #define LLVM_TABLEGEN_RECORD_H
17 
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/FoldingSet.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/DataTypes.h"
24 #include "llvm/Support/SMLoc.h"
26 #include <map>
27 
28 namespace llvm {
29 
30 class ListRecTy;
31 struct MultiClass;
32 class Record;
33 class RecordVal;
34 class RecordKeeper;
35 
36 //===----------------------------------------------------------------------===//
37 // Type Classes
38 //===----------------------------------------------------------------------===//
39 
40 class RecTy {
41 public:
42  /// \brief Subclass discriminator (for dyn_cast<> et al.)
43  enum RecTyKind {
51  };
52 
53 private:
54  RecTyKind Kind;
55  std::unique_ptr<ListRecTy> ListTy;
56 
57 public:
58  RecTyKind getRecTyKind() const { return Kind; }
59 
60  RecTy(RecTyKind K) : Kind(K) {}
61  virtual ~RecTy() {}
62 
63  virtual std::string getAsString() const = 0;
64  void print(raw_ostream &OS) const { OS << getAsString(); }
65  void dump() const;
66 
67  /// typeIsConvertibleTo - Return true if all values of 'this' type can be
68  /// converted to the specified type.
69  virtual bool typeIsConvertibleTo(const RecTy *RHS) const;
70 
71  /// getListTy - Returns the type representing list<this>.
73 };
74 
75 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
76  Ty.print(OS);
77  return OS;
78 }
79 
80 /// BitRecTy - 'bit' - Represent a single bit
81 ///
82 class BitRecTy : public RecTy {
83  static BitRecTy Shared;
85 
86 public:
87  static bool classof(const RecTy *RT) {
88  return RT->getRecTyKind() == BitRecTyKind;
89  }
90 
91  static BitRecTy *get() { return &Shared; }
92 
93  std::string getAsString() const override { return "bit"; }
94 
95  bool typeIsConvertibleTo(const RecTy *RHS) const override;
96 };
97 
98 /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
99 ///
100 class BitsRecTy : public RecTy {
101  unsigned Size;
102  explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
103 
104 public:
105  static bool classof(const RecTy *RT) {
106  return RT->getRecTyKind() == BitsRecTyKind;
107  }
108 
109  static BitsRecTy *get(unsigned Sz);
110 
111  unsigned getNumBits() const { return Size; }
112 
113  std::string getAsString() const override;
114 
115  bool typeIsConvertibleTo(const RecTy *RHS) const override;
116 };
117 
118 /// IntRecTy - 'int' - Represent an integer value of no particular size
119 ///
120 class IntRecTy : public RecTy {
121  static IntRecTy Shared;
122  IntRecTy() : RecTy(IntRecTyKind) {}
123 
124 public:
125  static bool classof(const RecTy *RT) {
126  return RT->getRecTyKind() == IntRecTyKind;
127  }
128 
129  static IntRecTy *get() { return &Shared; }
130 
131  std::string getAsString() const override { return "int"; }
132 
133  bool typeIsConvertibleTo(const RecTy *RHS) const override;
134 };
135 
136 /// StringRecTy - 'string' - Represent an string value
137 ///
138 class StringRecTy : public RecTy {
139  static StringRecTy Shared;
141 
142 public:
143  static bool classof(const RecTy *RT) {
144  return RT->getRecTyKind() == StringRecTyKind;
145  }
146 
147  static StringRecTy *get() { return &Shared; }
148 
149  std::string getAsString() const override;
150 };
151 
152 /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of
153 /// the specified type.
154 ///
155 class ListRecTy : public RecTy {
156  RecTy *Ty;
157  explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
158  friend ListRecTy *RecTy::getListTy();
159 
160 public:
161  static bool classof(const RecTy *RT) {
162  return RT->getRecTyKind() == ListRecTyKind;
163  }
164 
165  static ListRecTy *get(RecTy *T) { return T->getListTy(); }
166  RecTy *getElementType() const { return Ty; }
167 
168  std::string getAsString() const override;
169 
170  bool typeIsConvertibleTo(const RecTy *RHS) const override;
171 };
172 
173 /// DagRecTy - 'dag' - Represent a dag fragment
174 ///
175 class DagRecTy : public RecTy {
176  static DagRecTy Shared;
177  DagRecTy() : RecTy(DagRecTyKind) {}
178 
179 public:
180  static bool classof(const RecTy *RT) {
181  return RT->getRecTyKind() == DagRecTyKind;
182  }
183 
184  static DagRecTy *get() { return &Shared; }
185 
186  std::string getAsString() const override;
187 };
188 
189 /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
190 /// (R32 X = EAX).
191 ///
192 class RecordRecTy : public RecTy {
193  Record *Rec;
194  explicit RecordRecTy(Record *R) : RecTy(RecordRecTyKind), Rec(R) {}
195  friend class Record;
196 
197 public:
198  static bool classof(const RecTy *RT) {
199  return RT->getRecTyKind() == RecordRecTyKind;
200  }
201 
202  static RecordRecTy *get(Record *R);
203 
204  Record *getRecord() const { return Rec; }
205 
206  std::string getAsString() const override;
207 
208  bool typeIsConvertibleTo(const RecTy *RHS) const override;
209 };
210 
211 /// resolveTypes - Find a common type that T1 and T2 convert to.
212 /// Return 0 if no such type exists.
213 ///
214 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
215 
216 //===----------------------------------------------------------------------===//
217 // Initializer Classes
218 //===----------------------------------------------------------------------===//
219 
220 class Init {
221 protected:
222  /// \brief Discriminator enum (for isa<>, dyn_cast<>, et al.)
223  ///
224  /// This enum is laid out by a preorder traversal of the inheritance
225  /// hierarchy, and does not contain an entry for abstract classes, as per
226  /// the recommendation in docs/HowToSetUpLLVMStyleRTTI.rst.
227  ///
228  /// We also explicitly include "first" and "last" values for each
229  /// interior node of the inheritance tree, to make it easier to read the
230  /// corresponding classof().
231  ///
232  /// We could pack these a bit tighter by not having the IK_FirstXXXInit
233  /// and IK_LastXXXInit be their own values, but that would degrade
234  /// readability for really no benefit.
235  enum InitKind {
255  };
256 
257 private:
258  const InitKind Kind;
259  Init(const Init &) = delete;
260  Init &operator=(const Init &) = delete;
261  virtual void anchor();
262 
263 public:
264  InitKind getKind() const { return Kind; }
265 
266 protected:
267  explicit Init(InitKind K) : Kind(K) {}
268 
269 public:
270  virtual ~Init() {}
271 
272  /// isComplete - This virtual method should be overridden by values that may
273  /// not be completely specified yet.
274  virtual bool isComplete() const { return true; }
275 
276  /// print - Print out this value.
277  void print(raw_ostream &OS) const { OS << getAsString(); }
278 
279  /// getAsString - Convert this value to a string form.
280  virtual std::string getAsString() const = 0;
281  /// getAsUnquotedString - Convert this value to a string form,
282  /// without adding quote markers. This primaruly affects
283  /// StringInits where we will not surround the string value with
284  /// quotes.
285  virtual std::string getAsUnquotedString() const { return getAsString(); }
286 
287  /// dump - Debugging method that may be called through a debugger, just
288  /// invokes print on stderr.
289  void dump() const;
290 
291  /// convertInitializerTo - This virtual function converts to the appropriate
292  /// Init based on the passed in type.
293  virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
294 
295  /// convertInitializerBitRange - This method is used to implement the bitrange
296  /// selection operator. Given an initializer, it selects the specified bits
297  /// out, returning them as a new init of bits type. If it is not legal to use
298  /// the bit subscript operator on this initializer, return null.
299  ///
300  virtual Init *
301  convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
302  return nullptr;
303  }
304 
305  /// convertInitListSlice - This method is used to implement the list slice
306  /// selection operator. Given an initializer, it selects the specified list
307  /// elements, returning them as a new init of list type. If it is not legal
308  /// to take a slice of this, return null.
309  ///
310  virtual Init *
311  convertInitListSlice(const std::vector<unsigned> &Elements) const {
312  return nullptr;
313  }
314 
315  /// getFieldType - This method is used to implement the FieldInit class.
316  /// Implementors of this method should return the type of the named field if
317  /// they are of record type.
318  ///
319  virtual RecTy *getFieldType(const std::string &FieldName) const {
320  return nullptr;
321  }
322 
323  /// getFieldInit - This method complements getFieldType to return the
324  /// initializer for the specified field. If getFieldType returns non-null
325  /// this method should return non-null, otherwise it returns null.
326  ///
327  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
328  const std::string &FieldName) const {
329  return nullptr;
330  }
331 
332  /// resolveReferences - This method is used by classes that refer to other
333  /// variables which may not be defined at the time the expression is formed.
334  /// If a value is set for the variable later, this method will be called on
335  /// users of the value to allow the value to propagate out.
336  ///
337  virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
338  return const_cast<Init *>(this);
339  }
340 
341  /// getBit - This method is used to return the initializer for the specified
342  /// bit.
343  virtual Init *getBit(unsigned Bit) const = 0;
344 
345  /// getBitVar - This method is used to retrieve the initializer for bit
346  /// reference. For non-VarBitInit, it simply returns itself.
347  virtual Init *getBitVar() const { return const_cast<Init*>(this); }
348 
349  /// getBitNum - This method is used to retrieve the bit number of a bit
350  /// reference. For non-VarBitInit, it simply returns 0.
351  virtual unsigned getBitNum() const { return 0; }
352 };
353 
354 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
355  I.print(OS); return OS;
356 }
357 
358 /// TypedInit - This is the common super-class of types that have a specific,
359 /// explicit, type.
360 ///
361 class TypedInit : public Init {
362  RecTy *Ty;
363 
364  TypedInit(const TypedInit &Other) = delete;
365  TypedInit &operator=(const TypedInit &Other) = delete;
366 
367 protected:
368  explicit TypedInit(InitKind K, RecTy *T) : Init(K), Ty(T) {}
370  // If this is a DefInit we need to delete the RecordRecTy.
371  if (getKind() == IK_DefInit)
372  delete Ty;
373  }
374 
375 public:
376  static bool classof(const Init *I) {
377  return I->getKind() >= IK_FirstTypedInit &&
378  I->getKind() <= IK_LastTypedInit;
379  }
380  RecTy *getType() const { return Ty; }
381 
382  Init *convertInitializerTo(RecTy *Ty) const override;
383 
384  Init *
385  convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
386  Init *
387  convertInitListSlice(const std::vector<unsigned> &Elements) const override;
388 
389  /// getFieldType - This method is used to implement the FieldInit class.
390  /// Implementors of this method should return the type of the named field if
391  /// they are of record type.
392  ///
393  RecTy *getFieldType(const std::string &FieldName) const override;
394 
395  /// resolveListElementReference - This method is used to implement
396  /// VarListElementInit::resolveReferences. If the list element is resolvable
397  /// now, we return the resolved value, otherwise we return null.
398  virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
399  unsigned Elt) const = 0;
400 };
401 
402 /// UnsetInit - ? - Represents an uninitialized value
403 ///
404 class UnsetInit : public Init {
405  UnsetInit() : Init(IK_UnsetInit) {}
406  UnsetInit(const UnsetInit &) = delete;
407  UnsetInit &operator=(const UnsetInit &Other) = delete;
408 
409 public:
410  static bool classof(const Init *I) {
411  return I->getKind() == IK_UnsetInit;
412  }
413  static UnsetInit *get();
414 
415  Init *convertInitializerTo(RecTy *Ty) const override;
416 
417  Init *getBit(unsigned Bit) const override {
418  return const_cast<UnsetInit*>(this);
419  }
420 
421  bool isComplete() const override { return false; }
422  std::string getAsString() const override { return "?"; }
423 };
424 
425 /// BitInit - true/false - Represent a concrete initializer for a bit.
426 ///
427 class BitInit : public Init {
428  bool Value;
429 
430  explicit BitInit(bool V) : Init(IK_BitInit), Value(V) {}
431  BitInit(const BitInit &Other) = delete;
432  BitInit &operator=(BitInit &Other) = delete;
433 
434 public:
435  static bool classof(const Init *I) {
436  return I->getKind() == IK_BitInit;
437  }
438  static BitInit *get(bool V);
439 
440  bool getValue() const { return Value; }
441 
442  Init *convertInitializerTo(RecTy *Ty) const override;
443 
444  Init *getBit(unsigned Bit) const override {
445  assert(Bit < 1 && "Bit index out of range!");
446  return const_cast<BitInit*>(this);
447  }
448 
449  std::string getAsString() const override { return Value ? "1" : "0"; }
450 };
451 
452 /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
453 /// It contains a vector of bits, whose size is determined by the type.
454 ///
455 class BitsInit : public TypedInit, public FoldingSetNode {
456  std::vector<Init*> Bits;
457 
460  Bits(Range.begin(), Range.end()) {}
461 
462  BitsInit(const BitsInit &Other) = delete;
463  BitsInit &operator=(const BitsInit &Other) = delete;
464 
465 public:
466  static bool classof(const Init *I) {
467  return I->getKind() == IK_BitsInit;
468  }
469  static BitsInit *get(ArrayRef<Init *> Range);
470 
471  void Profile(FoldingSetNodeID &ID) const;
472 
473  unsigned getNumBits() const { return Bits.size(); }
474 
475  Init *convertInitializerTo(RecTy *Ty) const override;
476  Init *
477  convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
478 
479  bool isComplete() const override {
480  for (unsigned i = 0; i != getNumBits(); ++i)
481  if (!getBit(i)->isComplete()) return false;
482  return true;
483  }
484  bool allInComplete() const {
485  for (unsigned i = 0; i != getNumBits(); ++i)
486  if (getBit(i)->isComplete()) return false;
487  return true;
488  }
489  std::string getAsString() const override;
490 
491  /// resolveListElementReference - This method is used to implement
492  /// VarListElementInit::resolveReferences. If the list element is resolvable
493  /// now, we return the resolved value, otherwise we return null.
495  unsigned Elt) const override {
496  llvm_unreachable("Illegal element reference off bits<n>");
497  }
498 
499  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
500 
501  Init *getBit(unsigned Bit) const override {
502  assert(Bit < Bits.size() && "Bit index out of range!");
503  return Bits[Bit];
504  }
505 };
506 
507 /// IntInit - 7 - Represent an initialization by a literal integer value.
508 ///
509 class IntInit : public TypedInit {
510  int64_t Value;
511 
512  explicit IntInit(int64_t V)
514 
515  IntInit(const IntInit &Other) = delete;
516  IntInit &operator=(const IntInit &Other) = delete;
517 
518 public:
519  static bool classof(const Init *I) {
520  return I->getKind() == IK_IntInit;
521  }
522  static IntInit *get(int64_t V);
523 
524  int64_t getValue() const { return Value; }
525 
526  Init *convertInitializerTo(RecTy *Ty) const override;
527  Init *
528  convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
529 
530  std::string getAsString() const override;
531 
532  /// resolveListElementReference - This method is used to implement
533  /// VarListElementInit::resolveReferences. If the list element is resolvable
534  /// now, we return the resolved value, otherwise we return null.
536  unsigned Elt) const override {
537  llvm_unreachable("Illegal element reference off int");
538  }
539 
540  Init *getBit(unsigned Bit) const override {
541  return BitInit::get((Value & (1ULL << Bit)) != 0);
542  }
543 };
544 
545 /// StringInit - "foo" - Represent an initialization by a string value.
546 ///
547 class StringInit : public TypedInit {
548  std::string Value;
549 
550  explicit StringInit(const std::string &V)
552 
553  StringInit(const StringInit &Other) = delete;
554  StringInit &operator=(const StringInit &Other) = delete;
555 
556 public:
557  static bool classof(const Init *I) {
558  return I->getKind() == IK_StringInit;
559  }
560  static StringInit *get(StringRef);
561 
562  const std::string &getValue() const { return Value; }
563 
564  Init *convertInitializerTo(RecTy *Ty) const override;
565 
566  std::string getAsString() const override { return "\"" + Value + "\""; }
567  std::string getAsUnquotedString() const override { return Value; }
568 
569  /// resolveListElementReference - This method is used to implement
570  /// VarListElementInit::resolveReferences. If the list element is resolvable
571  /// now, we return the resolved value, otherwise we return null.
573  unsigned Elt) const override {
574  llvm_unreachable("Illegal element reference off string");
575  }
576 
577  Init *getBit(unsigned Bit) const override {
578  llvm_unreachable("Illegal bit reference off string");
579  }
580 };
581 
582 /// ListInit - [AL, AH, CL] - Represent a list of defs
583 ///
584 class ListInit : public TypedInit, public FoldingSetNode {
585  std::vector<Init*> Values;
586 
587 public:
588  typedef std::vector<Init*>::const_iterator const_iterator;
589 
590 private:
591  explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
592  : TypedInit(IK_ListInit, ListRecTy::get(EltTy)),
593  Values(Range.begin(), Range.end()) {}
594 
595  ListInit(const ListInit &Other) = delete;
596  ListInit &operator=(const ListInit &Other) = delete;
597 
598 public:
599  static bool classof(const Init *I) {
600  return I->getKind() == IK_ListInit;
601  }
602  static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
603 
604  void Profile(FoldingSetNodeID &ID) const;
605 
606  Init *getElement(unsigned i) const {
607  assert(i < Values.size() && "List element index out of range!");
608  return Values[i];
609  }
610 
611  Record *getElementAsRecord(unsigned i) const;
612 
613  Init *
614  convertInitListSlice(const std::vector<unsigned> &Elements) const override;
615 
616  Init *convertInitializerTo(RecTy *Ty) const override;
617 
618  /// resolveReferences - This method is used by classes that refer to other
619  /// variables which may not be defined at the time they expression is formed.
620  /// If a value is set for the variable later, this method will be called on
621  /// users of the value to allow the value to propagate out.
622  ///
623  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
624 
625  std::string getAsString() const override;
626 
627  ArrayRef<Init*> getValues() const { return Values; }
628 
629  const_iterator begin() const { return Values.begin(); }
630  const_iterator end () const { return Values.end(); }
631 
632  size_t size () const { return Values.size(); }
633  bool empty() const { return Values.empty(); }
634 
635  /// resolveListElementReference - This method is used to implement
636  /// VarListElementInit::resolveReferences. If the list element is resolvable
637  /// now, we return the resolved value, otherwise we return null.
639  unsigned Elt) const override;
640 
641  Init *getBit(unsigned Bit) const override {
642  llvm_unreachable("Illegal bit reference off list");
643  }
644 };
645 
646 /// OpInit - Base class for operators
647 ///
648 class OpInit : public TypedInit {
649  OpInit(const OpInit &Other) = delete;
650  OpInit &operator=(OpInit &Other) = delete;
651 
652 protected:
653  explicit OpInit(InitKind K, RecTy *Type) : TypedInit(K, Type) {}
654 
655 public:
656  static bool classof(const Init *I) {
657  return I->getKind() >= IK_FirstOpInit &&
658  I->getKind() <= IK_LastOpInit;
659  }
660  // Clone - Clone this operator, replacing arguments with the new list
661  virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
662 
663  virtual unsigned getNumOperands() const = 0;
664  virtual Init *getOperand(unsigned i) const = 0;
665 
666  // Fold - If possible, fold this to a simpler init. Return this if not
667  // possible to fold.
668  virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
669 
671  unsigned Elt) const override;
672 
673  Init *getBit(unsigned Bit) const override;
674 };
675 
676 /// UnOpInit - !op (X) - Transform an init.
677 ///
678 class UnOpInit : public OpInit {
679 public:
680  enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
681 
682 private:
683  UnaryOp Opc;
684  Init *LHS;
685 
686  UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
687  : OpInit(IK_UnOpInit, Type), Opc(opc), LHS(lhs) {}
688 
689  UnOpInit(const UnOpInit &Other) = delete;
690  UnOpInit &operator=(const UnOpInit &Other) = delete;
691 
692 public:
693  static bool classof(const Init *I) {
694  return I->getKind() == IK_UnOpInit;
695  }
696  static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
697 
698  // Clone - Clone this operator, replacing arguments with the new list
699  OpInit *clone(std::vector<Init *> &Operands) const override {
700  assert(Operands.size() == 1 &&
701  "Wrong number of operands for unary operation");
702  return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
703  }
704 
705  unsigned getNumOperands() const override { return 1; }
706  Init *getOperand(unsigned i) const override {
707  assert(i == 0 && "Invalid operand id for unary operator");
708  return getOperand();
709  }
710 
711  UnaryOp getOpcode() const { return Opc; }
712  Init *getOperand() const { return LHS; }
713 
714  // Fold - If possible, fold this to a simpler init. Return this if not
715  // possible to fold.
716  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
717 
718  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
719 
720  std::string getAsString() const override;
721 };
722 
723 /// BinOpInit - !op (X, Y) - Combine two inits.
724 ///
725 class BinOpInit : public OpInit {
726 public:
728 
729 private:
730  BinaryOp Opc;
731  Init *LHS, *RHS;
732 
733  BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
734  OpInit(IK_BinOpInit, Type), Opc(opc), LHS(lhs), RHS(rhs) {}
735 
736  BinOpInit(const BinOpInit &Other) = delete;
737  BinOpInit &operator=(const BinOpInit &Other) = delete;
738 
739 public:
740  static bool classof(const Init *I) {
741  return I->getKind() == IK_BinOpInit;
742  }
743  static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
744  RecTy *Type);
745 
746  // Clone - Clone this operator, replacing arguments with the new list
747  OpInit *clone(std::vector<Init *> &Operands) const override {
748  assert(Operands.size() == 2 &&
749  "Wrong number of operands for binary operation");
750  return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
751  }
752 
753  unsigned getNumOperands() const override { return 2; }
754  Init *getOperand(unsigned i) const override {
755  switch (i) {
756  default: llvm_unreachable("Invalid operand id for binary operator");
757  case 0: return getLHS();
758  case 1: return getRHS();
759  }
760  }
761 
762  BinaryOp getOpcode() const { return Opc; }
763  Init *getLHS() const { return LHS; }
764  Init *getRHS() const { return RHS; }
765 
766  // Fold - If possible, fold this to a simpler init. Return this if not
767  // possible to fold.
768  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
769 
770  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
771 
772  std::string getAsString() const override;
773 };
774 
775 /// TernOpInit - !op (X, Y, Z) - Combine two inits.
776 ///
777 class TernOpInit : public OpInit {
778 public:
779  enum TernaryOp { SUBST, FOREACH, IF };
780 
781 private:
782  TernaryOp Opc;
783  Init *LHS, *MHS, *RHS;
784 
785  TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
786  RecTy *Type) :
787  OpInit(IK_TernOpInit, Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
788 
789  TernOpInit(const TernOpInit &Other) = delete;
790  TernOpInit &operator=(const TernOpInit &Other) = delete;
791 
792 public:
793  static bool classof(const Init *I) {
794  return I->getKind() == IK_TernOpInit;
795  }
796  static TernOpInit *get(TernaryOp opc, Init *lhs,
797  Init *mhs, Init *rhs,
798  RecTy *Type);
799 
800  // Clone - Clone this operator, replacing arguments with the new list
801  OpInit *clone(std::vector<Init *> &Operands) const override {
802  assert(Operands.size() == 3 &&
803  "Wrong number of operands for ternary operation");
804  return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
805  getType());
806  }
807 
808  unsigned getNumOperands() const override { return 3; }
809  Init *getOperand(unsigned i) const override {
810  switch (i) {
811  default: llvm_unreachable("Invalid operand id for ternary operator");
812  case 0: return getLHS();
813  case 1: return getMHS();
814  case 2: return getRHS();
815  }
816  }
817 
818  TernaryOp getOpcode() const { return Opc; }
819  Init *getLHS() const { return LHS; }
820  Init *getMHS() const { return MHS; }
821  Init *getRHS() const { return RHS; }
822 
823  // Fold - If possible, fold this to a simpler init. Return this if not
824  // possible to fold.
825  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
826 
827  bool isComplete() const override { return false; }
828 
829  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
830 
831  std::string getAsString() const override;
832 };
833 
834 /// VarInit - 'Opcode' - Represent a reference to an entire variable object.
835 ///
836 class VarInit : public TypedInit {
837  Init *VarName;
838 
839  explicit VarInit(const std::string &VN, RecTy *T)
840  : TypedInit(IK_VarInit, T), VarName(StringInit::get(VN)) {}
841  explicit VarInit(Init *VN, RecTy *T)
842  : TypedInit(IK_VarInit, T), VarName(VN) {}
843 
844  VarInit(const VarInit &Other) = delete;
845  VarInit &operator=(const VarInit &Other) = delete;
846 
847 public:
848  static bool classof(const Init *I) {
849  return I->getKind() == IK_VarInit;
850  }
851  static VarInit *get(const std::string &VN, RecTy *T);
852  static VarInit *get(Init *VN, RecTy *T);
853 
854  const std::string &getName() const;
855  Init *getNameInit() const { return VarName; }
856  std::string getNameInitAsString() const {
857  return getNameInit()->getAsUnquotedString();
858  }
859 
861  unsigned Elt) const override;
862 
863  RecTy *getFieldType(const std::string &FieldName) const override;
864  Init *getFieldInit(Record &R, const RecordVal *RV,
865  const std::string &FieldName) const override;
866 
867  /// resolveReferences - This method is used by classes that refer to other
868  /// variables which may not be defined at the time they expression is formed.
869  /// If a value is set for the variable later, this method will be called on
870  /// users of the value to allow the value to propagate out.
871  ///
872  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
873 
874  Init *getBit(unsigned Bit) const override;
875 
876  std::string getAsString() const override { return getName(); }
877 };
878 
879 /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
880 ///
881 class VarBitInit : public Init {
882  TypedInit *TI;
883  unsigned Bit;
884 
885  VarBitInit(TypedInit *T, unsigned B) : Init(IK_VarBitInit), TI(T), Bit(B) {
886  assert(T->getType() &&
887  (isa<IntRecTy>(T->getType()) ||
888  (isa<BitsRecTy>(T->getType()) &&
889  cast<BitsRecTy>(T->getType())->getNumBits() > B)) &&
890  "Illegal VarBitInit expression!");
891  }
892 
893  VarBitInit(const VarBitInit &Other) = delete;
894  VarBitInit &operator=(const VarBitInit &Other) = delete;
895 
896 public:
897  static bool classof(const Init *I) {
898  return I->getKind() == IK_VarBitInit;
899  }
900  static VarBitInit *get(TypedInit *T, unsigned B);
901 
902  Init *convertInitializerTo(RecTy *Ty) const override;
903 
904  Init *getBitVar() const override { return TI; }
905  unsigned getBitNum() const override { return Bit; }
906 
907  std::string getAsString() const override;
908  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
909 
910  Init *getBit(unsigned B) const override {
911  assert(B < 1 && "Bit index out of range!");
912  return const_cast<VarBitInit*>(this);
913  }
914 };
915 
916 /// VarListElementInit - List[4] - Represent access to one element of a var or
917 /// field.
919  TypedInit *TI;
920  unsigned Element;
921 
922  VarListElementInit(TypedInit *T, unsigned E)
924  cast<ListRecTy>(T->getType())->getElementType()),
925  TI(T), Element(E) {
926  assert(T->getType() && isa<ListRecTy>(T->getType()) &&
927  "Illegal VarBitInit expression!");
928  }
929 
931  void operator=(const VarListElementInit &Other) = delete;
932 
933 public:
934  static bool classof(const Init *I) {
935  return I->getKind() == IK_VarListElementInit;
936  }
937  static VarListElementInit *get(TypedInit *T, unsigned E);
938 
939  TypedInit *getVariable() const { return TI; }
940  unsigned getElementNum() const { return Element; }
941 
942  /// resolveListElementReference - This method is used to implement
943  /// VarListElementInit::resolveReferences. If the list element is resolvable
944  /// now, we return the resolved value, otherwise we return null.
946  unsigned Elt) const override;
947 
948  std::string getAsString() const override;
949  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
950 
951  Init *getBit(unsigned Bit) const override;
952 };
953 
954 /// DefInit - AL - Represent a reference to a 'def' in the description
955 ///
956 class DefInit : public TypedInit {
957  Record *Def;
958 
959  DefInit(Record *D, RecordRecTy *T) : TypedInit(IK_DefInit, T), Def(D) {}
960  friend class Record;
961 
962  DefInit(const DefInit &Other) = delete;
963  DefInit &operator=(const DefInit &Other) = delete;
964 
965 public:
966  static bool classof(const Init *I) {
967  return I->getKind() == IK_DefInit;
968  }
969  static DefInit *get(Record*);
970 
971  Init *convertInitializerTo(RecTy *Ty) const override;
972 
973  Record *getDef() const { return Def; }
974 
975  //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
976 
977  RecTy *getFieldType(const std::string &FieldName) const override;
978  Init *getFieldInit(Record &R, const RecordVal *RV,
979  const std::string &FieldName) const override;
980 
981  std::string getAsString() const override;
982 
983  Init *getBit(unsigned Bit) const override {
984  llvm_unreachable("Illegal bit reference off def");
985  }
986 
987  /// resolveListElementReference - This method is used to implement
988  /// VarListElementInit::resolveReferences. If the list element is resolvable
989  /// now, we return the resolved value, otherwise we return null.
991  unsigned Elt) const override {
992  llvm_unreachable("Illegal element reference off def");
993  }
994 };
995 
996 /// FieldInit - X.Y - Represent a reference to a subfield of a variable
997 ///
998 class FieldInit : public TypedInit {
999  Init *Rec; // Record we are referring to
1000  std::string FieldName; // Field we are accessing
1001 
1002  FieldInit(Init *R, const std::string &FN)
1003  : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) {
1004  assert(getType() && "FieldInit with non-record type!");
1005  }
1006 
1007  FieldInit(const FieldInit &Other) = delete;
1008  FieldInit &operator=(const FieldInit &Other) = delete;
1009 
1010 public:
1011  static bool classof(const Init *I) {
1012  return I->getKind() == IK_FieldInit;
1013  }
1014  static FieldInit *get(Init *R, const std::string &FN);
1015 
1016  Init *getBit(unsigned Bit) const override;
1017 
1019  unsigned Elt) const override;
1020 
1021  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
1022 
1023  std::string getAsString() const override {
1024  return Rec->getAsString() + "." + FieldName;
1025  }
1026 };
1027 
1028 /// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
1029 /// to have at least one value then a (possibly empty) list of arguments. Each
1030 /// argument can have a name associated with it.
1031 ///
1032 class DagInit : public TypedInit, public FoldingSetNode {
1033  Init *Val;
1034  std::string ValName;
1035  std::vector<Init*> Args;
1036  std::vector<std::string> ArgNames;
1037 
1038  DagInit(Init *V, const std::string &VN,
1039  ArrayRef<Init *> ArgRange,
1040  ArrayRef<std::string> NameRange)
1041  : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN),
1042  Args(ArgRange.begin(), ArgRange.end()),
1043  ArgNames(NameRange.begin(), NameRange.end()) {}
1044 
1045  DagInit(const DagInit &Other) = delete;
1046  DagInit &operator=(const DagInit &Other) = delete;
1047 
1048 public:
1049  static bool classof(const Init *I) {
1050  return I->getKind() == IK_DagInit;
1051  }
1052  static DagInit *get(Init *V, const std::string &VN,
1053  ArrayRef<Init *> ArgRange,
1054  ArrayRef<std::string> NameRange);
1055  static DagInit *get(Init *V, const std::string &VN,
1056  const std::vector<
1057  std::pair<Init*, std::string> > &args);
1058 
1059  void Profile(FoldingSetNodeID &ID) const;
1060 
1061  Init *convertInitializerTo(RecTy *Ty) const override;
1062 
1063  Init *getOperator() const { return Val; }
1064 
1065  const std::string &getName() const { return ValName; }
1066 
1067  unsigned getNumArgs() const { return Args.size(); }
1068  Init *getArg(unsigned Num) const {
1069  assert(Num < Args.size() && "Arg number out of range!");
1070  return Args[Num];
1071  }
1072  const std::string &getArgName(unsigned Num) const {
1073  assert(Num < ArgNames.size() && "Arg number out of range!");
1074  return ArgNames[Num];
1075  }
1076 
1077  Init *resolveReferences(Record &R, const RecordVal *RV) const override;
1078 
1079  std::string getAsString() const override;
1080 
1081  typedef std::vector<Init*>::const_iterator const_arg_iterator;
1082  typedef std::vector<std::string>::const_iterator const_name_iterator;
1083 
1084  inline const_arg_iterator arg_begin() const { return Args.begin(); }
1085  inline const_arg_iterator arg_end () const { return Args.end(); }
1086 
1087  inline size_t arg_size () const { return Args.size(); }
1088  inline bool arg_empty() const { return Args.empty(); }
1089 
1090  inline const_name_iterator name_begin() const { return ArgNames.begin(); }
1091  inline const_name_iterator name_end () const { return ArgNames.end(); }
1092 
1093  inline size_t name_size () const { return ArgNames.size(); }
1094  inline bool name_empty() const { return ArgNames.empty(); }
1095 
1096  Init *getBit(unsigned Bit) const override {
1097  llvm_unreachable("Illegal bit reference off dag");
1098  }
1099 
1101  unsigned Elt) const override {
1102  llvm_unreachable("Illegal element reference off dag");
1103  }
1104 };
1105 
1106 //===----------------------------------------------------------------------===//
1107 // High-Level Classes
1108 //===----------------------------------------------------------------------===//
1109 
1110 class RecordVal {
1111  PointerIntPair<Init *, 1, bool> NameAndPrefix;
1112  RecTy *Ty;
1113  Init *Value;
1114 
1115 public:
1116  RecordVal(Init *N, RecTy *T, bool P);
1117  RecordVal(const std::string &N, RecTy *T, bool P);
1118 
1119  const std::string &getName() const;
1120  const Init *getNameInit() const { return NameAndPrefix.getPointer(); }
1121  std::string getNameInitAsString() const {
1122  return getNameInit()->getAsUnquotedString();
1123  }
1124 
1125  bool getPrefix() const { return NameAndPrefix.getInt(); }
1126  RecTy *getType() const { return Ty; }
1127  Init *getValue() const { return Value; }
1128 
1129  bool setValue(Init *V) {
1130  if (V) {
1131  Value = V->convertInitializerTo(Ty);
1132  return Value == nullptr;
1133  }
1134  Value = nullptr;
1135  return false;
1136  }
1137 
1138  void dump() const;
1139  void print(raw_ostream &OS, bool PrintSem = true) const;
1140 };
1141 
1142 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1143  RV.print(OS << " ");
1144  return OS;
1145 }
1146 
1147 class Record {
1148  static unsigned LastID;
1149 
1150  // Unique record ID.
1151  unsigned ID;
1152  Init *Name;
1153  // Location where record was instantiated, followed by the location of
1154  // multiclass prototypes used.
1155  SmallVector<SMLoc, 4> Locs;
1156  std::vector<Init *> TemplateArgs;
1157  std::vector<RecordVal> Values;
1158  std::vector<Record *> SuperClasses;
1159  std::vector<SMRange> SuperClassRanges;
1160 
1161  // Tracks Record instances. Not owned by Record.
1162  RecordKeeper &TrackedRecords;
1163 
1164  std::unique_ptr<DefInit> TheInit;
1165  bool IsAnonymous;
1166 
1167  // Class-instance values can be used by other defs. For example, Struct<i>
1168  // is used here as a template argument to another class:
1169  //
1170  // multiclass MultiClass<int i> {
1171  // def Def : Class<Struct<i>>;
1172  //
1173  // These need to get fully resolved before instantiating any other
1174  // definitions that use them (e.g. Def). However, inside a multiclass they
1175  // can't be immediately resolved so we mark them ResolveFirst to fully
1176  // resolve them later as soon as the multiclass is instantiated.
1177  bool ResolveFirst;
1178 
1179  void init();
1180  void checkName();
1181 
1182 public:
1183  // Constructs a record.
1184  explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1185  bool Anonymous = false) :
1186  ID(LastID++), Name(N), Locs(locs.begin(), locs.end()),
1187  TrackedRecords(records), IsAnonymous(Anonymous), ResolveFirst(false) {
1188  init();
1189  }
1190  explicit Record(const std::string &N, ArrayRef<SMLoc> locs,
1191  RecordKeeper &records, bool Anonymous = false)
1192  : Record(StringInit::get(N), locs, records, Anonymous) {}
1193 
1194 
1195  // When copy-constructing a Record, we must still guarantee a globally unique
1196  // ID number. Don't copy TheInit either since it's owned by the original
1197  // record. All other fields can be copied normally.
1198  Record(const Record &O) :
1199  ID(LastID++), Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
1200  Values(O.Values), SuperClasses(O.SuperClasses),
1201  SuperClassRanges(O.SuperClassRanges), TrackedRecords(O.TrackedRecords),
1202  IsAnonymous(O.IsAnonymous),
1203  ResolveFirst(O.ResolveFirst) { }
1204 
1205  static unsigned getNewUID() { return LastID++; }
1206 
1207  unsigned getID() const { return ID; }
1208 
1209  const std::string &getName() const;
1210  Init *getNameInit() const {
1211  return Name;
1212  }
1213  const std::string getNameInitAsString() const {
1214  return getNameInit()->getAsUnquotedString();
1215  }
1216 
1217  void setName(Init *Name); // Also updates RecordKeeper.
1218  void setName(const std::string &Name); // Also updates RecordKeeper.
1219 
1220  ArrayRef<SMLoc> getLoc() const { return Locs; }
1221 
1222  /// get the corresponding DefInit.
1223  DefInit *getDefInit();
1224 
1226  return TemplateArgs;
1227  }
1228  ArrayRef<RecordVal> getValues() const { return Values; }
1229  ArrayRef<Record *> getSuperClasses() const { return SuperClasses; }
1230  ArrayRef<SMRange> getSuperClassRanges() const { return SuperClassRanges; }
1231 
1232  bool isTemplateArg(Init *Name) const {
1233  for (Init *TA : TemplateArgs)
1234  if (TA == Name) return true;
1235  return false;
1236  }
1237  bool isTemplateArg(StringRef Name) const {
1238  return isTemplateArg(StringInit::get(Name));
1239  }
1240 
1241  const RecordVal *getValue(const Init *Name) const {
1242  for (const RecordVal &Val : Values)
1243  if (Val.getNameInit() == Name) return &Val;
1244  return nullptr;
1245  }
1246  const RecordVal *getValue(StringRef Name) const {
1247  return getValue(StringInit::get(Name));
1248  }
1249  RecordVal *getValue(const Init *Name) {
1250  for (RecordVal &Val : Values)
1251  if (Val.getNameInit() == Name) return &Val;
1252  return nullptr;
1253  }
1255  return getValue(StringInit::get(Name));
1256  }
1257 
1258  void addTemplateArg(Init *Name) {
1259  assert(!isTemplateArg(Name) && "Template arg already defined!");
1260  TemplateArgs.push_back(Name);
1261  }
1264  }
1265 
1266  void addValue(const RecordVal &RV) {
1267  assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
1268  Values.push_back(RV);
1269  if (Values.size() > 1)
1270  // Keep NAME at the end of the list. It makes record dumps a
1271  // bit prettier and allows TableGen tests to be written more
1272  // naturally. Tests can use CHECK-NEXT to look for Record
1273  // fields they expect to see after a def. They can't do that if
1274  // NAME is the first Record field.
1275  std::swap(Values[Values.size() - 2], Values[Values.size() - 1]);
1276  }
1277 
1278  void removeValue(Init *Name) {
1279  for (unsigned i = 0, e = Values.size(); i != e; ++i)
1280  if (Values[i].getNameInit() == Name) {
1281  Values.erase(Values.begin()+i);
1282  return;
1283  }
1284  llvm_unreachable("Cannot remove an entry that does not exist!");
1285  }
1286 
1287  void removeValue(StringRef Name) {
1289  }
1290 
1291  bool isSubClassOf(const Record *R) const {
1292  for (const Record *SC : SuperClasses)
1293  if (SC == R)
1294  return true;
1295  return false;
1296  }
1297 
1298  bool isSubClassOf(StringRef Name) const {
1299  for (const Record *SC : SuperClasses)
1300  if (SC->getNameInitAsString() == Name)
1301  return true;
1302  return false;
1303  }
1304 
1305  void addSuperClass(Record *R, SMRange Range) {
1306  assert(!isSubClassOf(R) && "Already subclassing record!");
1307  SuperClasses.push_back(R);
1308  SuperClassRanges.push_back(Range);
1309  }
1310 
1311  /// resolveReferences - If there are any field references that refer to fields
1312  /// that have been filled in, we can propagate the values now.
1313  ///
1315 
1316  /// resolveReferencesTo - If anything in this record refers to RV, replace the
1317  /// reference to RV with the RHS of RV. If RV is null, we resolve all
1318  /// possible references.
1319  void resolveReferencesTo(const RecordVal *RV);
1320 
1322  return TrackedRecords;
1323  }
1324 
1325  bool isAnonymous() const {
1326  return IsAnonymous;
1327  }
1328 
1329  bool isResolveFirst() const {
1330  return ResolveFirst;
1331  }
1332 
1333  void setResolveFirst(bool b) {
1334  ResolveFirst = b;
1335  }
1336 
1337  void dump() const;
1338 
1339  //===--------------------------------------------------------------------===//
1340  // High-level methods useful to tablegen back-ends
1341  //
1342 
1343  /// getValueInit - Return the initializer for a value with the specified name,
1344  /// or throw an exception if the field does not exist.
1345  ///
1346  Init *getValueInit(StringRef FieldName) const;
1347 
1348  /// Return true if the named field is unset.
1349  bool isValueUnset(StringRef FieldName) const {
1350  return isa<UnsetInit>(getValueInit(FieldName));
1351  }
1352 
1353  /// getValueAsString - This method looks up the specified field and returns
1354  /// its value as a string, throwing an exception if the field does not exist
1355  /// or if the value is not a string.
1356  ///
1357  std::string getValueAsString(StringRef FieldName) const;
1358 
1359  /// getValueAsBitsInit - This method looks up the specified field and returns
1360  /// its value as a BitsInit, throwing an exception if the field does not exist
1361  /// or if the value is not the right type.
1362  ///
1363  BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1364 
1365  /// getValueAsListInit - This method looks up the specified field and returns
1366  /// its value as a ListInit, throwing an exception if the field does not exist
1367  /// or if the value is not the right type.
1368  ///
1369  ListInit *getValueAsListInit(StringRef FieldName) const;
1370 
1371  /// getValueAsListOfDefs - This method looks up the specified field and
1372  /// returns its value as a vector of records, throwing an exception if the
1373  /// field does not exist or if the value is not the right type.
1374  ///
1375  std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1376 
1377  /// getValueAsListOfInts - This method looks up the specified field and
1378  /// returns its value as a vector of integers, throwing an exception if the
1379  /// field does not exist or if the value is not the right type.
1380  ///
1381  std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1382 
1383  /// getValueAsListOfStrings - This method looks up the specified field and
1384  /// returns its value as a vector of strings, throwing an exception if the
1385  /// field does not exist or if the value is not the right type.
1386  ///
1387  std::vector<std::string> getValueAsListOfStrings(StringRef FieldName) const;
1388 
1389  /// getValueAsDef - This method looks up the specified field and returns its
1390  /// value as a Record, throwing an exception if the field does not exist or if
1391  /// the value is not the right type.
1392  ///
1393  Record *getValueAsDef(StringRef FieldName) const;
1394 
1395  /// getValueAsBit - This method looks up the specified field and returns its
1396  /// value as a bit, throwing an exception if the field does not exist or if
1397  /// the value is not the right type.
1398  ///
1399  bool getValueAsBit(StringRef FieldName) const;
1400 
1401  /// getValueAsBitOrUnset - This method looks up the specified field and
1402  /// returns its value as a bit. If the field is unset, sets Unset to true and
1403  /// returns false.
1404  ///
1405  bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const;
1406 
1407  /// getValueAsInt - This method looks up the specified field and returns its
1408  /// value as an int64_t, throwing an exception if the field does not exist or
1409  /// if the value is not the right type.
1410  ///
1411  int64_t getValueAsInt(StringRef FieldName) const;
1412 
1413  /// getValueAsDag - This method looks up the specified field and returns its
1414  /// value as an Dag, throwing an exception if the field does not exist or if
1415  /// the value is not the right type.
1416  ///
1417  DagInit *getValueAsDag(StringRef FieldName) const;
1418 };
1419 
1420 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1421 
1422 struct MultiClass {
1423  Record Rec; // Placeholder for template args and Name.
1424  typedef std::vector<std::unique_ptr<Record>> RecordVector;
1426 
1427  void dump() const;
1428 
1429  MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records) :
1430  Rec(Name, Loc, Records) {}
1431 };
1432 
1434  typedef std::map<std::string, std::unique_ptr<Record>> RecordMap;
1435  RecordMap Classes, Defs;
1436 
1437 public:
1438  const RecordMap &getClasses() const { return Classes; }
1439  const RecordMap &getDefs() const { return Defs; }
1440 
1441  Record *getClass(const std::string &Name) const {
1442  auto I = Classes.find(Name);
1443  return I == Classes.end() ? nullptr : I->second.get();
1444  }
1445  Record *getDef(const std::string &Name) const {
1446  auto I = Defs.find(Name);
1447  return I == Defs.end() ? nullptr : I->second.get();
1448  }
1449  void addClass(std::unique_ptr<Record> R) {
1450  bool Ins = Classes.insert(std::make_pair(R->getName(),
1451  std::move(R))).second;
1452  (void)Ins;
1453  assert(Ins && "Class already exists");
1454  }
1455  void addDef(std::unique_ptr<Record> R) {
1456  bool Ins = Defs.insert(std::make_pair(R->getName(),
1457  std::move(R))).second;
1458  (void)Ins;
1459  assert(Ins && "Record already exists");
1460  }
1461 
1462  //===--------------------------------------------------------------------===//
1463  // High-level helper methods, useful for tablegen backends...
1464 
1465  /// getAllDerivedDefinitions - This method returns all concrete definitions
1466  /// that derive from the specified class name. If a class with the specified
1467  /// name does not exist, an exception is thrown.
1468  std::vector<Record*>
1469  getAllDerivedDefinitions(const std::string &ClassName) const;
1470 
1471  void dump() const;
1472 };
1473 
1474 /// LessRecord - Sorting predicate to sort record pointers by name.
1475 ///
1476 struct LessRecord {
1477  bool operator()(const Record *Rec1, const Record *Rec2) const {
1478  return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1479  }
1480 };
1481 
1482 /// LessRecordByID - Sorting predicate to sort record pointers by their
1483 /// unique ID. If you just need a deterministic order, use this, since it
1484 /// just compares two `unsigned`; the other sorting predicates require
1485 /// string manipulation.
1487  bool operator()(const Record *LHS, const Record *RHS) const {
1488  return LHS->getID() < RHS->getID();
1489  }
1490 };
1491 
1492 /// LessRecordFieldName - Sorting predicate to sort record pointers by their
1493 /// name field.
1494 ///
1496  bool operator()(const Record *Rec1, const Record *Rec2) const {
1497  return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1498  }
1499 };
1500 
1502  static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; }
1503 
1504  struct RecordParts {
1506 
1508  if (Rec.empty())
1509  return;
1510 
1511  size_t Len = 0;
1512  const char *Start = Rec.data();
1513  const char *Curr = Start;
1514  bool isDigitPart = ascii_isdigit(Curr[0]);
1515  for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) {
1516  bool isDigit = ascii_isdigit(Curr[I]);
1517  if (isDigit != isDigitPart) {
1518  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1519  Len = 0;
1520  Start = &Curr[I];
1521  isDigitPart = ascii_isdigit(Curr[I]);
1522  }
1523  }
1524  // Push the last part.
1525  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1526  }
1527 
1528  size_t size() { return Parts.size(); }
1529 
1530  std::pair<bool, StringRef> getPart(size_t i) {
1531  assert (i < Parts.size() && "Invalid idx!");
1532  return Parts[i];
1533  }
1534  };
1535 
1536  bool operator()(const Record *Rec1, const Record *Rec2) const {
1537  RecordParts LHSParts(StringRef(Rec1->getName()));
1538  RecordParts RHSParts(StringRef(Rec2->getName()));
1539 
1540  size_t LHSNumParts = LHSParts.size();
1541  size_t RHSNumParts = RHSParts.size();
1542  assert (LHSNumParts && RHSNumParts && "Expected at least one part!");
1543 
1544  if (LHSNumParts != RHSNumParts)
1545  return LHSNumParts < RHSNumParts;
1546 
1547  // We expect the registers to be of the form [_a-zA-z]+([0-9]*[_a-zA-Z]*)*.
1548  for (size_t I = 0, E = LHSNumParts; I < E; I+=2) {
1549  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1550  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1551  // Expect even part to always be alpha.
1552  assert (LHSPart.first == false && RHSPart.first == false &&
1553  "Expected both parts to be alpha.");
1554  if (int Res = LHSPart.second.compare(RHSPart.second))
1555  return Res < 0;
1556  }
1557  for (size_t I = 1, E = LHSNumParts; I < E; I+=2) {
1558  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1559  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1560  // Expect odd part to always be numeric.
1561  assert (LHSPart.first == true && RHSPart.first == true &&
1562  "Expected both parts to be numeric.");
1563  if (LHSPart.second.size() != RHSPart.second.size())
1564  return LHSPart.second.size() < RHSPart.second.size();
1565 
1566  unsigned LHSVal, RHSVal;
1567 
1568  bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed;
1569  assert(!LHSFailed && "Unable to convert LHS to integer.");
1570  bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed;
1571  assert(!RHSFailed && "Unable to convert RHS to integer.");
1572 
1573  if (LHSVal != RHSVal)
1574  return LHSVal < RHSVal;
1575  }
1576  return LHSNumParts < RHSNumParts;
1577  }
1578 };
1579 
1580 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
1581 
1582 /// QualifyName - Return an Init with a qualifier prefix referring
1583 /// to CurRec's name.
1584 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1585  Init *Name, const std::string &Scoper);
1586 
1587 /// QualifyName - Return an Init with a qualifier prefix referring
1588 /// to CurRec's name.
1589 Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
1590  const std::string &Name, const std::string &Scoper);
1591 
1592 } // End llvm namespace
1593 
1594 #endif
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1280
void addTemplateArg(StringRef Name)
Definition: Record.h:1262
static BinOpInit * get(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:726
RecordVal * getValue(const Init *Name)
Definition: Record.h:1249
Represents a range in source code.
Definition: SMLoc.h:47
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:287
void print(raw_ostream &OS) const
Definition: Record.h:64
static bool classof(const Init *I)
Definition: Record.h:934
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.h:1100
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:240
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:539
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1422
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1477
RecTyKind
Subclass discriminator (for dyn_cast<> et al.)
Definition: Record.h:43
virtual bool isComplete() const
isComplete - This virtual method should be overridden by values that may not be completely specified ...
Definition: Record.h:274
RecTy * getFieldType(const std::string &FieldName) const override
getFieldType - This method is used to implement the FieldInit class.
Definition: Record.cpp:1086
MultiClass(const std::string &Name, SMLoc Loc, RecordKeeper &Records)
Definition: Record.h:1429
const std::string & getValue() const
Definition: Record.h:562
void Profile(FoldingSetNodeID &ID) const
Definition: Record.cpp:283
unsigned getNumBits() const
Definition: Record.h:473
unsigned getNumArgs() const
Definition: Record.h:1067
bool getValueAsBit(StringRef FieldName) const
getValueAsBit - This method looks up the specified field and returns its value as a bit...
Definition: Record.cpp:1819
TypedInit(InitKind K, RecTy *T)
Definition: Record.h:368
const std::string & getArgName(unsigned Num) const
Definition: Record.h:1072
LessRecord - Sorting predicate to sort record pointers by name.
Definition: Record.h:1476
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
FieldInit - X.Y - Represent a reference to a subfield of a variable.
Definition: Record.h:998
bool getPrefix() const
Definition: Record.h:1125
Init * getFieldInit(Record &R, const RecordVal *RV, const std::string &FieldName) const override
getFieldInit - This method complements getFieldType to return the initializer for the specified field...
Definition: Record.cpp:1379
ListInit - [AL, AH, CL] - Represent a list of defs.
Definition: Record.h:584
IntInit - 7 - Represent an initialization by a literal integer value.
Definition: Record.h:509
static bool classof(const RecTy *RT)
Definition: Record.h:125
ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of the specified type...
Definition: Record.h:155
BinOpInit - !op (X, Y) - Combine two inits.
Definition: Record.h:725
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.cpp:1341
bool isAnonymous() const
Definition: Record.h:1325
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.h:566
Record * getElementAsRecord(unsigned i) const
Definition: Record.cpp:531
virtual bool typeIsConvertibleTo(const RecTy *RHS) const
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:97
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.h:572
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:707
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.h:494
const RecordVal * getValue(StringRef Name) const
Definition: Record.h:1246
LessRecordFieldName - Sorting predicate to sort record pointers by their name field.
Definition: Record.h:1495
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:242
DefInit - AL - Represent a reference to a 'def' in the description.
Definition: Record.h:956
static bool classof(const Init *I)
Definition: Record.h:740
std::string getNameInitAsString() const
Definition: Record.h:1121
iterator end() const
Definition: ArrayRef.h:123
static UnOpInit * get(UnaryOp opc, Init *lhs, RecTy *Type)
Definition: Record.cpp:606
static bool classof(const Init *I)
Definition: Record.h:466
void addDef(std::unique_ptr< Record > R)
Definition: Record.h:1455
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.cpp:560
Init * getValueInit(StringRef FieldName) const
getValueInit - Return the initializer for a value with the specified name, or throw an exception if t...
Definition: Record.cpp:1672
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.cpp:582
RecTy * getFieldType(const std::string &FieldName) const override
getFieldType - This method is used to implement the FieldInit class.
Definition: Record.cpp:1253
Init * getOperand(unsigned i) const override
Definition: Record.h:706
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.h:990
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1045
RecTy * getType() const
Definition: Record.h:380
static bool classof(const RecTy *RT)
Definition: Record.h:87
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:1305
std::string getAsString() const override
Definition: Record.h:93
virtual RecTy * getFieldType(const std::string &FieldName) const
getFieldType - This method is used to implement the FieldInit class.
Definition: Record.h:319
Init * Fold(Record *CurRec, MultiClass *CurMultiClass) const override
Definition: Record.cpp:977
virtual Init * getFieldInit(Record &R, const RecordVal *RV, const std::string &FieldName) const
getFieldInit - This method complements getFieldType to return the initializer for the specified field...
Definition: Record.h:327
void Profile(FoldingSetNodeID &ID) const
Definition: Record.cpp:495
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:232
BinaryOp getOpcode() const
Definition: Record.h:762
Record * getValueAsDef(StringRef FieldName) const
getValueAsDef - This method looks up the specified field and returns its value as a Record...
Definition: Record.cpp:1803
Init * getElement(unsigned i) const
Definition: Record.h:606
bool allInComplete() const
Definition: Record.h:484
void setResolveFirst(bool b)
Definition: Record.h:1333
Init * convertInitListSlice(const std::vector< unsigned > &Elements) const override
convertInitListSlice - This method is used to implement the list slice selection operator.
Definition: Record.cpp:521
static bool classof(const Init *I)
Definition: Record.h:966
void removeValue(StringRef Name)
Definition: Record.h:1287
std::string getValueAsString(StringRef FieldName) const
getValueAsString - This method looks up the specified field and returns its value as a string...
Definition: Record.cpp:1685
Init * getOperator() const
Definition: Record.h:1063
BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
Definition: Record.h:455
std::pair< bool, StringRef > getPart(size_t i)
Definition: Record.h:1530
std::string getAsString() const override
Definition: Record.cpp:140
virtual std::string getAsUnquotedString() const
getAsUnquotedString - Convert this value to a string form, without adding quote markers.
Definition: Record.h:285
ArrayRef< Init * > getTemplateArgs() const
Definition: Record.h:1225
void print(raw_ostream &OS) const
print - Print out this value.
Definition: Record.h:277
virtual ~RecTy()
Definition: Record.h:61
const std::string & getName() const
Definition: Record.cpp:1582
static bool classof(const Init *I)
Definition: Record.h:376
LessRecordByID - Sorting predicate to sort record pointers by their unique ID.
Definition: Record.h:1486
UnsetInit - ? - Represents an uninitialized value.
Definition: Record.h:404
static bool classof(const Init *I)
Definition: Record.h:435
void addSuperClass(Record *R, SMRange Range)
Definition: Record.h:1305
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:417
BitInit - true/false - Represent a concrete initializer for a bit.
Definition: Record.h:427
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:1096
static bool classof(const Init *I)
Definition: Record.h:656
Init * getValue() const
Definition: Record.h:1127
static BitsRecTy * get(unsigned Sz)
Definition: Record.cpp:110
static bool classof(const RecTy *RT)
Definition: Record.h:198
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:577
static bool classof(const Init *I)
Definition: Record.h:519
virtual Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const =0
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
TypedInit - This is the common super-class of types that have a specific, explicit, type.
Definition: Record.h:361
bool arg_empty() const
Definition: Record.h:1088
bool typeIsConvertibleTo(const RecTy *RHS) const override
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:124
InitKind
Discriminator enum (for isa<>, dyn_cast<>, et al.)
Definition: Record.h:235
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.cpp:600
ArrayRef< SMRange > getSuperClassRanges() const
Definition: Record.h:1230
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
std::vector< std::string >::const_iterator const_name_iterator
Definition: Record.h:1082
void addClass(std::unique_ptr< Record > R)
Definition: Record.h:1449
static StringRecTy * get()
Definition: Record.h:147
Init * getLHS() const
Definition: Record.h:763
Init * getOperand() const
Definition: Record.h:712
std::string getAsString() const override
Definition: Record.cpp:158
std::string getAsString() const override
Definition: Record.cpp:136
VarListElementInit - List[4] - Represent access to one element of a var or field. ...
Definition: Record.h:918
RecordRecTy - '[classname]' - Represent an instance of a class, such as: (R32 X = EAX)...
Definition: Record.h:192
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:461
const_name_iterator name_end() const
Definition: Record.h:1091
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:402
std::vector< std::unique_ptr< Record > > RecordVector
Definition: Record.h:1424
Record * getClass(const std::string &Name) const
Definition: Record.h:1441
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1309
OpInit * clone(std::vector< Init * > &Operands) const override
Definition: Record.h:747
size_t arg_size() const
Definition: Record.h:1087
int64_t getValue() const
Definition: Record.h:524
#define false
Definition: ConvertUTF.c:65
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:591
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:715
virtual unsigned getNumOperands() const =0
void print(raw_ostream &OS, bool PrintSem=true) const
Definition: Record.cpp:1548
BitsInit * getValueAsBitsInit(StringRef FieldName) const
getValueAsBitsInit - This method looks up the specified field and returns its value as a BitsInit...
Definition: Record.cpp:1701
const_iterator begin() const
Definition: Record.h:629
RecTy * getType() const
Definition: Record.h:1126
BitsRecTy - 'bits<n>' - Represent a fixed number of bits.
Definition: Record.h:100
ListInit * getValueAsListInit(StringRef FieldName) const
getValueAsListInit - This method looks up the specified field and returns its value as a ListInit...
Definition: Record.cpp:1717
virtual OpInit * clone(std::vector< Init * > &Operands) const =0
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:107
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1496
const std::string getNameInitAsString() const
Definition: Record.h:1213
#define T
void resolveReferences()
resolveReferences - If there are any field references that refer to fields that have been filled in...
Definition: Record.h:1314
const_arg_iterator arg_end() const
Definition: Record.h:1085
static bool classof(const RecTy *RT)
Definition: Record.h:161
Record(Init *N, ArrayRef< SMLoc > locs, RecordKeeper &records, bool Anonymous=false)
Definition: Record.h:1184
Init * getArg(unsigned Num) const
Definition: Record.h:1068
static bool classof(const Init *I)
Definition: Record.h:897
void Profile(FoldingSetNodeID &ID) const
Definition: Record.cpp:1485
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:573
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
static bool classof(const RecTy *RT)
Definition: Record.h:180
static bool classof(const RecTy *RT)
Definition: Record.h:143
Init * getRHS() const
Definition: Record.h:764
static bool classof(const Init *I)
Definition: Record.h:1011
void dump() const
Definition: Record.cpp:1865
virtual unsigned getBitNum() const
getBitNum - This method is used to retrieve the bit number of a bit reference.
Definition: Record.h:351
bool isResolveFirst() const
Definition: Record.h:1329
Init * convertInitializerBitRange(const std::vector< unsigned > &Bits) const override
convertInitializerBitRange - This method is used to implement the bitrange selection operator...
Definition: Record.cpp:1170
const std::string & getName() const
Definition: Record.cpp:1218
Init * Fold(Record *CurRec, MultiClass *CurMultiClass) const override
Definition: Record.cpp:617
virtual Init * getBit(unsigned Bit) const =0
getBit - This method is used to return the initializer for the specified bit.
DagInit * getValueAsDag(StringRef FieldName) const
getValueAsDag - This method looks up the specified field and returns its value as an Dag...
Definition: Record.cpp:1852
void dump() const
Definition: Record.cpp:89
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.cpp:1347
virtual Init * getOperand(unsigned i) const =0
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
std::vector< std::string > getValueAsListOfStrings(StringRef FieldName) const
getValueAsListOfStrings - This method looks up the specified field and returns its value as a vector ...
Definition: Record.cpp:1786
const std::string & getName() const
Definition: Record.h:1065
bool getValue() const
Definition: Record.h:440
Init(InitKind K)
Definition: Record.h:267
void resolveReferencesTo(const RecordVal *RV)
resolveReferencesTo - If anything in this record refers to RV, replace the reference to RV with the R...
Definition: Record.cpp:1609
std::string getNameInitAsString() const
Definition: Record.h:856
virtual Init * convertInitializerTo(RecTy *Ty) const =0
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
size_t name_size() const
Definition: Record.h:1093
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:501
bool typeIsConvertibleTo(const RecTy *RHS) const override
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:131
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:297
Record * getDef(const std::string &Name) const
Definition: Record.h:1445
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.h:876
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1496
OpInit - Base class for operators.
Definition: Record.h:648
#define P(N)
RecTy(RecTyKind K)
Definition: Record.h:60
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:983
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:1489
bool typeIsConvertibleTo(const RecTy *RHS) const override
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:162
std::vector< Record * > getAllDerivedDefinitions(const std::string &ClassName) const
getAllDerivedDefinitions - This method returns all concrete definitions that derive from the specifie...
Definition: Record.cpp:1893
PointerIntPair - This class implements a pair of a pointer and small integer.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
bool isComplete() const override
isComplete - This virtual method should be overridden by values that may not be completely specified ...
Definition: Record.h:479
Init * getFieldInit(Record &R, const RecordVal *RV, const std::string &FieldName) const override
getFieldInit - This method complements getFieldType to return the initializer for the specified field...
Definition: Record.cpp:1260
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.cpp:1229
StringInit - "foo" - Represent an initialization by a string value.
Definition: Record.h:547
RecordVector DefPrototypes
Definition: Record.h:1425
unsigned getNumOperands() const override
Definition: Record.h:753
bool setValue(Init *V)
Definition: Record.h:1129
UnOpInit - !op (X) - Transform an init.
Definition: Record.h:678
TypedInit * getVariable() const
Definition: Record.h:939
Init * getOperand(unsigned i) const override
Definition: Record.h:809
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:1298
SmallVector< std::pair< bool, StringRef >, 4 > Parts
Definition: Record.h:1505
Init * getLHS() const
Definition: Record.h:819
virtual ~Init()
Definition: Record.h:270
const RecordVal * getValue(const Init *Name) const
Definition: Record.h:1241
iterator begin() const
Definition: ArrayRef.h:122
static bool classof(const Init *I)
Definition: Record.h:693
std::vector< int64_t > getValueAsListOfInts(StringRef FieldName) const
getValueAsListOfInts - This method looks up the specified field and returns its value as a vector of ...
Definition: Record.cpp:1768
StringRecTy - 'string' - Represent an string value.
Definition: Record.h:138
SI Fold Operands
RecTyKind getRecTyKind() const
Definition: Record.h:58
static BitInit * get(bool V)
Definition: Record.cpp:235
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.h:422
bool isTemplateArg(StringRef Name) const
Definition: Record.h:1237
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:1385
unsigned getID() const
Definition: Record.h:1207
static bool classof(const Init *I)
Definition: Record.h:793
bool isValueUnset(StringRef FieldName) const
Return true if the named field is unset.
Definition: Record.h:1349
ArrayRef< Init * > getValues() const
Definition: Record.h:627
DefInit * getDefInit()
get the corresponding DefInit.
Definition: Record.cpp:1576
Record * getDef() const
Definition: Record.h:973
size_t size() const
Definition: Record.h:632
bool isComplete() const override
isComplete - This virtual method should be overridden by values that may not be completely specified ...
Definition: Record.h:827
std::vector< Record * > getValueAsListOfDefs(StringRef FieldName) const
getValueAsListOfDefs - This method looks up the specified field and returns its value as a vector of ...
Definition: Record.cpp:1734
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:1510
virtual Init * resolveReferences(Record &R, const RecordVal *RV) const
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.h:337
Init * QualifyName(Record &CurRec, MultiClass *CurMultiClass, Init *Name, const std::string &Scoper)
QualifyName - Return an Init with a qualifier prefix referring to CurRec's name.
Definition: Record.cpp:1908
const Init * getNameInit() const
Definition: Record.h:1120
static bool classof(const Init *I)
Definition: Record.h:410
int64_t getValueAsInt(StringRef FieldName) const
getValueAsInt - This method looks up the specified field and returns its value as an int64_t...
Definition: Record.cpp:1751
const RecordMap & getClasses() const
Definition: Record.h:1438
Init * convertInitListSlice(const std::vector< unsigned > &Elements) const override
convertInitListSlice - This method is used to implement the list slice selection operator.
Definition: Record.cpp:1186
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:1094
virtual Init * Fold(Record *CurRec, MultiClass *CurMultiClass) const =0
Init * convertInitializerBitRange(const std::vector< unsigned > &Bits) const override
convertInitializerBitRange - This method is used to implement the bitrange selection operator...
Definition: Record.cpp:314
void addTemplateArg(Init *Name)
Definition: Record.h:1258
std::string getAsString() const override
Definition: Record.cpp:120
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1536
static bool classof(const Init *I)
Definition: Record.h:557
RecTy * getFieldType(const std::string &FieldName) const override
getFieldType - This method is used to implement the FieldInit class.
Definition: Record.cpp:1373
ArrayRef< SMLoc > getLoc() const
Definition: Record.h:1220
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
RecordVal * getValue(StringRef Name)
Definition: Record.h:1254
static StringInit * get(StringRef)
Definition: Record.cpp:453
static bool classof(const RecTy *RT)
Definition: Record.h:105
Init * getMHS() const
Definition: Record.h:820
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:325
CHAIN = SC CHAIN, Imm128 - System call.
void dump() const
Definition: Record.cpp:1546
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:1366
Init * getNameInit() const
Definition: Record.h:1210
const_iterator end() const
Definition: Record.h:630
void dump() const
Definition: Record.cpp:1631
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:414
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:540
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:834
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.h:535
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:134
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
static unsigned getNewUID()
Definition: Record.h:1205
unsigned getElementNum() const
Definition: Record.h:940
ArrayRef< Record * > getSuperClasses() const
Definition: Record.h:1229
bool isTemplateArg(Init *Name) const
Definition: Record.h:1232
const_arg_iterator arg_begin() const
Definition: Record.h:1084
bool isSubClassOf(StringRef Name) const
Definition: Record.h:1298
Init * getBitVar() const override
getBitVar - This method is used to retrieve the initializer for bit reference.
Definition: Record.h:904
void removeValue(Init *Name)
Definition: Record.h:1278
const RecordMap & getDefs() const
Definition: Record.h:1439
static bool classof(const Init *I)
Definition: Record.h:599
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:501
IntRecTy - 'int' - Represent an integer value of no particular size.
Definition: Record.h:120
ArrayRef< RecordVal > getValues() const
Definition: Record.h:1228
virtual Init * convertInitListSlice(const std::vector< unsigned > &Elements) const
convertInitListSlice - This method is used to implement the list slice selection operator.
Definition: Record.h:311
static bool ascii_isdigit(char x)
Definition: Record.h:1502
Init * resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override
resolveListElementReference - This method is used to implement VarListElementInit::resolveReferences...
Definition: Record.cpp:1406
RecTy * getElementType() const
Definition: Record.h:166
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.cpp:1223
RecordKeeper & getRecords() const
Definition: Record.h:1321
void dump() const
Definition: Record.cpp:1875
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:843
bool typeIsConvertibleTo(const RecTy *RHS) const override
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:144
unsigned getNumBits() const
Definition: Record.h:111
virtual Init * getBitVar() const
getBitVar - This method is used to retrieve the initializer for bit reference.
Definition: Record.h:347
std::string getAsString() const override
Definition: Record.h:131
bool isSubClassOf(const Record *R) const
Definition: Record.h:1291
bool typeIsConvertibleTo(const RecTy *RHS) const override
typeIsConvertibleTo - Return true if all values of 'this' type can be converted to the specified type...
Definition: Record.cpp:102
std::vector< Init * >::const_iterator const_iterator
Definition: Record.h:588
virtual Init * convertInitializerBitRange(const std::vector< unsigned > &Bits) const
convertInitializerBitRange - This method is used to implement the bitrange selection operator...
Definition: Record.h:301
Init * getBit(unsigned B) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:910
static DagRecTy * get()
Definition: Record.h:184
void addValue(const RecordVal &RV)
Definition: Record.h:1266
static TernOpInit * get(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:859
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
RecTy * resolveTypes(RecTy *T1, RecTy *T2)
resolveTypes - Find a common type that T1 and T2 convert to.
Definition: Record.cpp:180
VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
Definition: Record.h:881
bool isComplete() const override
isComplete - This virtual method should be overridden by values that may not be completely specified ...
Definition: Record.h:421
VarInit - 'Opcode' - Represent a reference to an entire variable object.
Definition: Record.h:836
static ListInit * get(ArrayRef< Init * > Range, RecTy *EltTy)
Definition: Record.cpp:478
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:1075
std::string getAsString() const override
Definition: Record.cpp:150
UnaryOp getOpcode() const
Definition: Record.h:711
BitRecTy - 'bit' - Represent a single bit.
Definition: Record.h:82
TernOpInit - !op (X, Y, Z) - Combine two inits.
Definition: Record.h:777
Init * Fold(Record *CurRec, MultiClass *CurMultiClass) const override
Definition: Record.cpp:743
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:1738
Init * getOperand(unsigned i) const override
Definition: Record.h:754
Record * getRecord() const
Definition: Record.h:204
bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const
getValueAsBitOrUnset - This method looks up the specified field and returns its value as a bit...
Definition: Record.cpp:1831
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:1334
DagRecTy - 'dag' - Represent a dag fragment.
Definition: Record.h:175
unsigned getNumOperands() const override
Definition: Record.h:705
Init * resolveReferences(Record &R, const RecordVal *RV) const override
resolveReferences - This method is used by classes that refer to other variables which may not be def...
Definition: Record.cpp:349
OpInit(InitKind K, RecTy *Type)
Definition: Record.h:653
InitKind getKind() const
Definition: Record.h:264
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.cpp:1400
const std::string & getName() const
Definition: Record.cpp:1542
Init * getNameInit() const
Definition: Record.h:855
LLVM Value Representation.
Definition: Value.h:69
Record(const std::string &N, ArrayRef< SMLoc > locs, RecordKeeper &records, bool Anonymous=false)
Definition: Record.h:1190
OpInit * clone(std::vector< Init * > &Operands) const override
Definition: Record.h:801
DagInit - (v a, b) - Represent a DAG tree value.
Definition: Record.h:1032
virtual std::string getAsString() const =0
getAsString - Convert this value to a string form.
bool name_empty() const
Definition: Record.h:1094
bool empty() const
Definition: Record.h:633
unsigned getNumOperands() const override
Definition: Record.h:808
OpInit * clone(std::vector< Init * > &Operands) const override
Definition: Record.h:699
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:641
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.h:449
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
TernaryOp getOpcode() const
Definition: Record.h:818
void dump() const
dump - Debugging method that may be called through a debugger, just invokes print on stderr...
Definition: Record.cpp:214
void setName(Init *Name)
Definition: Record.cpp:1586
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
unsigned getBitNum() const override
getBitNum - This method is used to retrieve the bit number of a bit reference.
Definition: Record.h:905
std::string getAsUnquotedString() const override
getAsUnquotedString - Convert this value to a string form, without adding quote markers.
Definition: Record.h:567
static bool classof(const Init *I)
Definition: Record.h:1049
Init * getBit(unsigned Bit) const override
getBit - This method is used to return the initializer for the specified bit.
Definition: Record.h:444
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.h:1023
Init * getRHS() const
Definition: Record.h:821
virtual std::string getAsString() const =0
Init * convertInitializerTo(RecTy *Ty) const override
convertInitializerTo - This virtual function converts to the appropriate Init based on the passed in ...
Definition: Record.cpp:221
Represents a location in source code.
Definition: SMLoc.h:23
ListRecTy * getListTy()
getListTy - Returns the type representing list<this>.
Definition: Record.cpp:91
Record(const Record &O)
Definition: Record.h:1198
Init * convertInitializerBitRange(const std::vector< unsigned > &Bits) const override
convertInitializerBitRange - This method is used to implement the bitrange selection operator...
Definition: Record.cpp:441
const_name_iterator name_begin() const
Definition: Record.h:1090
bool operator()(const Record *LHS, const Record *RHS) const
Definition: Record.h:1487
#define T1
std::string getAsString() const override
getAsString - Convert this value to a string form.
Definition: Record.cpp:1329
static bool classof(const Init *I)
Definition: Record.h:848
std::vector< Init * >::const_iterator const_arg_iterator
Definition: Record.h:1081
static IntRecTy * get()
Definition: Record.h:129
RecordVal(Init *N, RecTy *T, bool P)
Definition: Record.cpp:1530
bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:110