LLVM  9.0.0svn
Record.h
Go to the documentation of this file.
1 //===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the main TableGen data structures, including the TableGen
10 // types, values, and high-level data structures.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_TABLEGEN_RECORD_H
15 #define LLVM_TABLEGEN_RECORD_H
16 
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DenseSet.h"
20 #include "llvm/ADT/FoldingSet.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/Support/Casting.h"
26 #include "llvm/Support/SMLoc.h"
29 #include <algorithm>
30 #include <cassert>
31 #include <cstddef>
32 #include <cstdint>
33 #include <map>
34 #include <memory>
35 #include <string>
36 #include <utility>
37 #include <vector>
38 
39 namespace llvm {
40 
41 class ListRecTy;
42 struct MultiClass;
43 class Record;
44 class RecordKeeper;
45 class RecordVal;
46 class Resolver;
47 class StringInit;
48 class TypedInit;
49 
50 //===----------------------------------------------------------------------===//
51 // Type Classes
52 //===----------------------------------------------------------------------===//
53 
54 class RecTy {
55 public:
56  /// Subclass discriminator (for dyn_cast<> et al.)
57  enum RecTyKind {
66  };
67 
68 private:
69  RecTyKind Kind;
70  ListRecTy *ListTy = nullptr;
71 
72 public:
73  RecTy(RecTyKind K) : Kind(K) {}
74  virtual ~RecTy() = default;
75 
76  RecTyKind getRecTyKind() const { return Kind; }
77 
78  virtual std::string getAsString() const = 0;
79  void print(raw_ostream &OS) const { OS << getAsString(); }
80  void dump() const;
81 
82  /// Return true if all values of 'this' type can be converted to the specified
83  /// type.
84  virtual bool typeIsConvertibleTo(const RecTy *RHS) const;
85 
86  /// Return true if 'this' type is equal to or a subtype of RHS. For example,
87  /// a bit set is not an int, but they are convertible.
88  virtual bool typeIsA(const RecTy *RHS) const;
89 
90  /// Returns the type representing list<this>.
92 };
93 
94 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
95  Ty.print(OS);
96  return OS;
97 }
98 
99 /// 'bit' - Represent a single bit
100 class BitRecTy : public RecTy {
101  static BitRecTy Shared;
102 
103  BitRecTy() : RecTy(BitRecTyKind) {}
104 
105 public:
106  static bool classof(const RecTy *RT) {
107  return RT->getRecTyKind() == BitRecTyKind;
108  }
109 
110  static BitRecTy *get() { return &Shared; }
111 
112  std::string getAsString() const override { return "bit"; }
113 
114  bool typeIsConvertibleTo(const RecTy *RHS) const override;
115 };
116 
117 /// 'bits<n>' - Represent a fixed number of bits
118 class BitsRecTy : public RecTy {
119  unsigned Size;
120 
121  explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
122 
123 public:
124  static bool classof(const RecTy *RT) {
125  return RT->getRecTyKind() == BitsRecTyKind;
126  }
127 
128  static BitsRecTy *get(unsigned Sz);
129 
130  unsigned getNumBits() const { return Size; }
131 
132  std::string getAsString() const override;
133 
134  bool typeIsConvertibleTo(const RecTy *RHS) const override;
135 
136  bool typeIsA(const RecTy *RHS) const override;
137 };
138 
139 /// 'code' - Represent a code fragment
140 class CodeRecTy : public RecTy {
141  static CodeRecTy Shared;
142 
144 
145 public:
146  static bool classof(const RecTy *RT) {
147  return RT->getRecTyKind() == CodeRecTyKind;
148  }
149 
150  static CodeRecTy *get() { return &Shared; }
151 
152  std::string getAsString() const override { return "code"; }
153 
154  bool typeIsConvertibleTo(const RecTy *RHS) const override;
155 };
156 
157 /// 'int' - Represent an integer value of no particular size
158 class IntRecTy : public RecTy {
159  static IntRecTy Shared;
160 
161  IntRecTy() : RecTy(IntRecTyKind) {}
162 
163 public:
164  static bool classof(const RecTy *RT) {
165  return RT->getRecTyKind() == IntRecTyKind;
166  }
167 
168  static IntRecTy *get() { return &Shared; }
169 
170  std::string getAsString() const override { return "int"; }
171 
172  bool typeIsConvertibleTo(const RecTy *RHS) const override;
173 };
174 
175 /// 'string' - Represent an string value
176 class StringRecTy : public RecTy {
177  static StringRecTy Shared;
178 
180 
181 public:
182  static bool classof(const RecTy *RT) {
183  return RT->getRecTyKind() == StringRecTyKind;
184  }
185 
186  static StringRecTy *get() { return &Shared; }
187 
188  std::string getAsString() const override;
189 
190  bool typeIsConvertibleTo(const RecTy *RHS) const override;
191 };
192 
193 /// 'list<Ty>' - Represent a list of values, all of which must be of
194 /// the specified type.
195 class ListRecTy : public RecTy {
196  friend ListRecTy *RecTy::getListTy();
197 
198  RecTy *Ty;
199 
200  explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
201 
202 public:
203  static bool classof(const RecTy *RT) {
204  return RT->getRecTyKind() == ListRecTyKind;
205  }
206 
207  static ListRecTy *get(RecTy *T) { return T->getListTy(); }
208  RecTy *getElementType() const { return Ty; }
209 
210  std::string getAsString() const override;
211 
212  bool typeIsConvertibleTo(const RecTy *RHS) const override;
213 
214  bool typeIsA(const RecTy *RHS) const override;
215 };
216 
217 /// 'dag' - Represent a dag fragment
218 class DagRecTy : public RecTy {
219  static DagRecTy Shared;
220 
221  DagRecTy() : RecTy(DagRecTyKind) {}
222 
223 public:
224  static bool classof(const RecTy *RT) {
225  return RT->getRecTyKind() == DagRecTyKind;
226  }
227 
228  static DagRecTy *get() { return &Shared; }
229 
230  std::string getAsString() const override;
231 };
232 
233 /// '[classname]' - Type of record values that have zero or more superclasses.
234 ///
235 /// The list of superclasses is non-redundant, i.e. only contains classes that
236 /// are not the superclass of some other listed class.
237 class RecordRecTy final : public RecTy, public FoldingSetNode,
238  public TrailingObjects<RecordRecTy, Record *> {
239  friend class Record;
240 
241  unsigned NumClasses;
242 
243  explicit RecordRecTy(unsigned Num)
244  : RecTy(RecordRecTyKind), NumClasses(Num) {}
245 
246 public:
247  RecordRecTy(const RecordRecTy &) = delete;
248  RecordRecTy &operator=(const RecordRecTy &) = delete;
249 
250  // Do not use sized deallocation due to trailing objects.
251  void operator delete(void *p) { ::operator delete(p); }
252 
253  static bool classof(const RecTy *RT) {
254  return RT->getRecTyKind() == RecordRecTyKind;
255  }
256 
257  /// Get the record type with the given non-redundant list of superclasses.
258  static RecordRecTy *get(ArrayRef<Record *> Classes);
259 
260  void Profile(FoldingSetNodeID &ID) const;
261 
263  return makeArrayRef(getTrailingObjects<Record *>(), NumClasses);
264  }
265 
266  using const_record_iterator = Record * const *;
267 
268  const_record_iterator classes_begin() const { return getClasses().begin(); }
269  const_record_iterator classes_end() const { return getClasses().end(); }
270 
271  std::string getAsString() const override;
272 
273  bool isSubClassOf(Record *Class) const;
274  bool typeIsConvertibleTo(const RecTy *RHS) const override;
275 
276  bool typeIsA(const RecTy *RHS) const override;
277 };
278 
279 /// Find a common type that T1 and T2 convert to.
280 /// Return 0 if no such type exists.
282 
283 //===----------------------------------------------------------------------===//
284 // Initializer Classes
285 //===----------------------------------------------------------------------===//
286 
287 class Init {
288 protected:
289  /// Discriminator enum (for isa<>, dyn_cast<>, et al.)
290  ///
291  /// This enum is laid out by a preorder traversal of the inheritance
292  /// hierarchy, and does not contain an entry for abstract classes, as per
293  /// the recommendation in docs/HowToSetUpLLVMStyleRTTI.rst.
294  ///
295  /// We also explicitly include "first" and "last" values for each
296  /// interior node of the inheritance tree, to make it easier to read the
297  /// corresponding classof().
298  ///
299  /// We could pack these a bit tighter by not having the IK_FirstXXXInit
300  /// and IK_LastXXXInit be their own values, but that would degrade
301  /// readability for really no benefit.
302  enum InitKind : uint8_t {
303  IK_First, // unused; silence a spurious warning
327  IK_UnsetInit
328  };
329 
330 private:
331  const InitKind Kind;
332 
333 protected:
334  uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit
335 
336 private:
337  virtual void anchor();
338 
339 public:
340  InitKind getKind() const { return Kind; }
341 
342 protected:
343  explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {}
344 
345 public:
346  Init(const Init &) = delete;
347  Init &operator=(const Init &) = delete;
348  virtual ~Init() = default;
349 
350  /// This virtual method should be overridden by values that may
351  /// not be completely specified yet.
352  virtual bool isComplete() const { return true; }
353 
354  /// Is this a concrete and fully resolved value without any references or
355  /// stuck operations? Unset values are concrete.
356  virtual bool isConcrete() const { return false; }
357 
358  /// Print out this value.
359  void print(raw_ostream &OS) const { OS << getAsString(); }
360 
361  /// Convert this value to a string form.
362  virtual std::string getAsString() const = 0;
363  /// Convert this value to a string form,
364  /// without adding quote markers. This primaruly affects
365  /// StringInits where we will not surround the string value with
366  /// quotes.
367  virtual std::string getAsUnquotedString() const { return getAsString(); }
368 
369  /// Debugging method that may be called through a debugger, just
370  /// invokes print on stderr.
371  void dump() const;
372 
373  /// If this initializer is convertible to Ty, return an initializer whose
374  /// type is-a Ty, generating a !cast operation if required. Otherwise, return
375  /// nullptr.
376  virtual Init *getCastTo(RecTy *Ty) const = 0;
377 
378  /// Convert to an initializer whose type is-a Ty, or return nullptr if this
379  /// is not possible (this can happen if the initializer's type is convertible
380  /// to Ty, but there are unresolved references).
381  virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
382 
383  /// This method is used to implement the bitrange
384  /// selection operator. Given an initializer, it selects the specified bits
385  /// out, returning them as a new init of bits type. If it is not legal to use
386  /// the bit subscript operator on this initializer, return null.
388  return nullptr;
389  }
390 
391  /// This method is used to implement the list slice
392  /// selection operator. Given an initializer, it selects the specified list
393  /// elements, returning them as a new init of list type. If it is not legal
394  /// to take a slice of this, return null.
395  virtual Init *convertInitListSlice(ArrayRef<unsigned> Elements) const {
396  return nullptr;
397  }
398 
399  /// This method is used to implement the FieldInit class.
400  /// Implementors of this method should return the type of the named field if
401  /// they are of record type.
402  virtual RecTy *getFieldType(StringInit *FieldName) const {
403  return nullptr;
404  }
405 
406  /// This method is used by classes that refer to other
407  /// variables which may not be defined at the time the expression is formed.
408  /// If a value is set for the variable later, this method will be called on
409  /// users of the value to allow the value to propagate out.
410  virtual Init *resolveReferences(Resolver &R) const {
411  return const_cast<Init *>(this);
412  }
413 
414  /// This method is used to return the initializer for the specified
415  /// bit.
416  virtual Init *getBit(unsigned Bit) const = 0;
417 };
418 
419 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
420  I.print(OS); return OS;
421 }
422 
423 /// This is the common super-class of types that have a specific,
424 /// explicit, type.
425 class TypedInit : public Init {
426  RecTy *Ty;
427 
428 protected:
429  explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0)
430  : Init(K, Opc), Ty(T) {}
431 
432 public:
433  TypedInit(const TypedInit &) = delete;
434  TypedInit &operator=(const TypedInit &) = delete;
435 
436  static bool classof(const Init *I) {
437  return I->getKind() >= IK_FirstTypedInit &&
438  I->getKind() <= IK_LastTypedInit;
439  }
440 
441  RecTy *getType() const { return Ty; }
442 
443  Init *getCastTo(RecTy *Ty) const override;
444  Init *convertInitializerTo(RecTy *Ty) const override;
445 
446  Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
447  Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
448 
449  /// This method is used to implement the FieldInit class.
450  /// Implementors of this method should return the type of the named field if
451  /// they are of record type.
452  ///
453  RecTy *getFieldType(StringInit *FieldName) const override;
454 };
455 
456 /// '?' - Represents an uninitialized value
457 class UnsetInit : public Init {
458  UnsetInit() : Init(IK_UnsetInit) {}
459 
460 public:
461  UnsetInit(const UnsetInit &) = delete;
462  UnsetInit &operator=(const UnsetInit &) = delete;
463 
464  static bool classof(const Init *I) {
465  return I->getKind() == IK_UnsetInit;
466  }
467 
468  static UnsetInit *get();
469 
470  Init *getCastTo(RecTy *Ty) const override;
471  Init *convertInitializerTo(RecTy *Ty) const override;
472 
473  Init *getBit(unsigned Bit) const override {
474  return const_cast<UnsetInit*>(this);
475  }
476 
477  bool isComplete() const override { return false; }
478  bool isConcrete() const override { return true; }
479  std::string getAsString() const override { return "?"; }
480 };
481 
482 /// 'true'/'false' - Represent a concrete initializer for a bit.
483 class BitInit final : public TypedInit {
484  bool Value;
485 
486  explicit BitInit(bool V) : TypedInit(IK_BitInit, BitRecTy::get()), Value(V) {}
487 
488 public:
489  BitInit(const BitInit &) = delete;
490  BitInit &operator=(BitInit &) = delete;
491 
492  static bool classof(const Init *I) {
493  return I->getKind() == IK_BitInit;
494  }
495 
496  static BitInit *get(bool V);
497 
498  bool getValue() const { return Value; }
499 
500  Init *convertInitializerTo(RecTy *Ty) const override;
501 
502  Init *getBit(unsigned Bit) const override {
503  assert(Bit < 1 && "Bit index out of range!");
504  return const_cast<BitInit*>(this);
505  }
506 
507  bool isConcrete() const override { return true; }
508  std::string getAsString() const override { return Value ? "1" : "0"; }
509 };
510 
511 /// '{ a, b, c }' - Represents an initializer for a BitsRecTy value.
512 /// It contains a vector of bits, whose size is determined by the type.
513 class BitsInit final : public TypedInit, public FoldingSetNode,
514  public TrailingObjects<BitsInit, Init *> {
515  unsigned NumBits;
516 
517  BitsInit(unsigned N)
518  : TypedInit(IK_BitsInit, BitsRecTy::get(N)), NumBits(N) {}
519 
520 public:
521  BitsInit(const BitsInit &) = delete;
522  BitsInit &operator=(const BitsInit &) = delete;
523 
524  // Do not use sized deallocation due to trailing objects.
525  void operator delete(void *p) { ::operator delete(p); }
526 
527  static bool classof(const Init *I) {
528  return I->getKind() == IK_BitsInit;
529  }
530 
531  static BitsInit *get(ArrayRef<Init *> Range);
532 
533  void Profile(FoldingSetNodeID &ID) const;
534 
535  unsigned getNumBits() const { return NumBits; }
536 
537  Init *convertInitializerTo(RecTy *Ty) const override;
538  Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
539 
540  bool isComplete() const override {
541  for (unsigned i = 0; i != getNumBits(); ++i)
542  if (!getBit(i)->isComplete()) return false;
543  return true;
544  }
545 
546  bool allInComplete() const {
547  for (unsigned i = 0; i != getNumBits(); ++i)
548  if (getBit(i)->isComplete()) return false;
549  return true;
550  }
551 
552  bool isConcrete() const override;
553  std::string getAsString() const override;
554 
555  Init *resolveReferences(Resolver &R) const override;
556 
557  Init *getBit(unsigned Bit) const override {
558  assert(Bit < NumBits && "Bit index out of range!");
559  return getTrailingObjects<Init *>()[Bit];
560  }
561 };
562 
563 /// '7' - Represent an initialization by a literal integer value.
564 class IntInit : public TypedInit {
565  int64_t Value;
566 
567  explicit IntInit(int64_t V)
568  : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {}
569 
570 public:
571  IntInit(const IntInit &) = delete;
572  IntInit &operator=(const IntInit &) = delete;
573 
574  static bool classof(const Init *I) {
575  return I->getKind() == IK_IntInit;
576  }
577 
578  static IntInit *get(int64_t V);
579 
580  int64_t getValue() const { return Value; }
581 
582  Init *convertInitializerTo(RecTy *Ty) const override;
583  Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
584 
585  bool isConcrete() const override { return true; }
586  std::string getAsString() const override;
587 
588  Init *getBit(unsigned Bit) const override {
589  return BitInit::get((Value & (1ULL << Bit)) != 0);
590  }
591 };
592 
593 /// "foo" - Represent an initialization by a string value.
594 class StringInit : public TypedInit {
596 
597  explicit StringInit(StringRef V)
598  : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {}
599 
600 public:
601  StringInit(const StringInit &) = delete;
602  StringInit &operator=(const StringInit &) = delete;
603 
604  static bool classof(const Init *I) {
605  return I->getKind() == IK_StringInit;
606  }
607 
608  static StringInit *get(StringRef);
609 
610  StringRef getValue() const { return Value; }
611 
612  Init *convertInitializerTo(RecTy *Ty) const override;
613 
614  bool isConcrete() const override { return true; }
615  std::string getAsString() const override { return "\"" + Value.str() + "\""; }
616 
617  std::string getAsUnquotedString() const override { return Value; }
618 
619  Init *getBit(unsigned Bit) const override {
620  llvm_unreachable("Illegal bit reference off string");
621  }
622 };
623 
624 class CodeInit : public TypedInit {
626  SMLoc Loc;
627 
628  explicit CodeInit(StringRef V, const SMLoc &Loc)
629  : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
630  Value(V), Loc(Loc) {}
631 
632 public:
633  CodeInit(const StringInit &) = delete;
634  CodeInit &operator=(const StringInit &) = delete;
635 
636  static bool classof(const Init *I) {
637  return I->getKind() == IK_CodeInit;
638  }
639 
640  static CodeInit *get(StringRef, const SMLoc &Loc);
641 
642  StringRef getValue() const { return Value; }
643  const SMLoc &getLoc() const { return Loc; }
644 
645  Init *convertInitializerTo(RecTy *Ty) const override;
646 
647  bool isConcrete() const override { return true; }
648  std::string getAsString() const override {
649  return "[{" + Value.str() + "}]";
650  }
651 
652  std::string getAsUnquotedString() const override { return Value; }
653 
654  Init *getBit(unsigned Bit) const override {
655  llvm_unreachable("Illegal bit reference off string");
656  }
657 };
658 
659 /// [AL, AH, CL] - Represent a list of defs
660 ///
661 class ListInit final : public TypedInit, public FoldingSetNode,
662  public TrailingObjects<ListInit, Init *> {
663  unsigned NumValues;
664 
665 public:
666  using const_iterator = Init *const *;
667 
668 private:
669  explicit ListInit(unsigned N, RecTy *EltTy)
670  : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), NumValues(N) {}
671 
672 public:
673  ListInit(const ListInit &) = delete;
674  ListInit &operator=(const ListInit &) = delete;
675 
676  // Do not use sized deallocation due to trailing objects.
677  void operator delete(void *p) { ::operator delete(p); }
678 
679  static bool classof(const Init *I) {
680  return I->getKind() == IK_ListInit;
681  }
682  static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
683 
684  void Profile(FoldingSetNodeID &ID) const;
685 
686  Init *getElement(unsigned i) const {
687  assert(i < NumValues && "List element index out of range!");
688  return getTrailingObjects<Init *>()[i];
689  }
691  return cast<ListRecTy>(getType())->getElementType();
692  }
693 
694  Record *getElementAsRecord(unsigned i) const;
695 
696  Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
697 
698  Init *convertInitializerTo(RecTy *Ty) const override;
699 
700  /// This method is used by classes that refer to other
701  /// variables which may not be defined at the time they expression is formed.
702  /// If a value is set for the variable later, this method will be called on
703  /// users of the value to allow the value to propagate out.
704  ///
705  Init *resolveReferences(Resolver &R) const override;
706 
707  bool isConcrete() const override;
708  std::string getAsString() const override;
709 
711  return makeArrayRef(getTrailingObjects<Init *>(), NumValues);
712  }
713 
714  const_iterator begin() const { return getTrailingObjects<Init *>(); }
715  const_iterator end () const { return begin() + NumValues; }
716 
717  size_t size () const { return NumValues; }
718  bool empty() const { return NumValues == 0; }
719 
720  Init *getBit(unsigned Bit) const override {
721  llvm_unreachable("Illegal bit reference off list");
722  }
723 };
724 
725 /// Base class for operators
726 ///
727 class OpInit : public TypedInit {
728 protected:
729  explicit OpInit(InitKind K, RecTy *Type, uint8_t Opc)
730  : TypedInit(K, Type, Opc) {}
731 
732 public:
733  OpInit(const OpInit &) = delete;
734  OpInit &operator=(OpInit &) = delete;
735 
736  static bool classof(const Init *I) {
737  return I->getKind() >= IK_FirstOpInit &&
738  I->getKind() <= IK_LastOpInit;
739  }
740 
741  // Clone - Clone this operator, replacing arguments with the new list
742  virtual OpInit *clone(ArrayRef<Init *> Operands) const = 0;
743 
744  virtual unsigned getNumOperands() const = 0;
745  virtual Init *getOperand(unsigned i) const = 0;
746 
747  Init *getBit(unsigned Bit) const override;
748 };
749 
750 /// !op (X) - Transform an init.
751 ///
752 class UnOpInit : public OpInit, public FoldingSetNode {
753 public:
754  enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY };
755 
756 private:
757  Init *LHS;
758 
759  UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
760  : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
761 
762 public:
763  UnOpInit(const UnOpInit &) = delete;
764  UnOpInit &operator=(const UnOpInit &) = delete;
765 
766  static bool classof(const Init *I) {
767  return I->getKind() == IK_UnOpInit;
768  }
769 
770  static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
771 
772  void Profile(FoldingSetNodeID &ID) const;
773 
774  // Clone - Clone this operator, replacing arguments with the new list
775  OpInit *clone(ArrayRef<Init *> Operands) const override {
776  assert(Operands.size() == 1 &&
777  "Wrong number of operands for unary operation");
778  return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
779  }
780 
781  unsigned getNumOperands() const override { return 1; }
782 
783  Init *getOperand(unsigned i) const override {
784  assert(i == 0 && "Invalid operand id for unary operator");
785  return getOperand();
786  }
787 
788  UnaryOp getOpcode() const { return (UnaryOp)Opc; }
789  Init *getOperand() const { return LHS; }
790 
791  // Fold - If possible, fold this to a simpler init. Return this if not
792  // possible to fold.
793  Init *Fold(Record *CurRec, bool IsFinal = false) const;
794 
795  Init *resolveReferences(Resolver &R) const override;
796 
797  std::string getAsString() const override;
798 };
799 
800 /// !op (X, Y) - Combine two inits.
801 class BinOpInit : public OpInit, public FoldingSetNode {
802 public:
803  enum BinaryOp : uint8_t { ADD, MUL, AND, OR, SHL, SRA, SRL, LISTCONCAT,
804  LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
805  GT };
806 
807 private:
808  Init *LHS, *RHS;
809 
810  BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
811  OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
812 
813 public:
814  BinOpInit(const BinOpInit &) = delete;
815  BinOpInit &operator=(const BinOpInit &) = delete;
816 
817  static bool classof(const Init *I) {
818  return I->getKind() == IK_BinOpInit;
819  }
820 
821  static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
822  RecTy *Type);
823  static Init *getStrConcat(Init *lhs, Init *rhs);
824  static Init *getListConcat(TypedInit *lhs, Init *rhs);
825  static Init *getListSplat(TypedInit *lhs, Init *rhs);
826 
827  void Profile(FoldingSetNodeID &ID) const;
828 
829  // Clone - Clone this operator, replacing arguments with the new list
830  OpInit *clone(ArrayRef<Init *> Operands) const override {
831  assert(Operands.size() == 2 &&
832  "Wrong number of operands for binary operation");
833  return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
834  }
835 
836  unsigned getNumOperands() const override { return 2; }
837  Init *getOperand(unsigned i) const override {
838  switch (i) {
839  default: llvm_unreachable("Invalid operand id for binary operator");
840  case 0: return getLHS();
841  case 1: return getRHS();
842  }
843  }
844 
845  BinaryOp getOpcode() const { return (BinaryOp)Opc; }
846  Init *getLHS() const { return LHS; }
847  Init *getRHS() const { return RHS; }
848 
849  // Fold - If possible, fold this to a simpler init. Return this if not
850  // possible to fold.
851  Init *Fold(Record *CurRec) const;
852 
853  Init *resolveReferences(Resolver &R) const override;
854 
855  std::string getAsString() const override;
856 };
857 
858 /// !op (X, Y, Z) - Combine two inits.
859 class TernOpInit : public OpInit, public FoldingSetNode {
860 public:
861  enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG };
862 
863 private:
864  Init *LHS, *MHS, *RHS;
865 
866  TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
867  RecTy *Type) :
868  OpInit(IK_TernOpInit, Type, opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
869 
870 public:
871  TernOpInit(const TernOpInit &) = delete;
872  TernOpInit &operator=(const TernOpInit &) = delete;
873 
874  static bool classof(const Init *I) {
875  return I->getKind() == IK_TernOpInit;
876  }
877 
878  static TernOpInit *get(TernaryOp opc, Init *lhs,
879  Init *mhs, Init *rhs,
880  RecTy *Type);
881 
882  void Profile(FoldingSetNodeID &ID) const;
883 
884  // Clone - Clone this operator, replacing arguments with the new list
885  OpInit *clone(ArrayRef<Init *> Operands) const override {
886  assert(Operands.size() == 3 &&
887  "Wrong number of operands for ternary operation");
888  return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
889  getType());
890  }
891 
892  unsigned getNumOperands() const override { return 3; }
893  Init *getOperand(unsigned i) const override {
894  switch (i) {
895  default: llvm_unreachable("Invalid operand id for ternary operator");
896  case 0: return getLHS();
897  case 1: return getMHS();
898  case 2: return getRHS();
899  }
900  }
901 
902  TernaryOp getOpcode() const { return (TernaryOp)Opc; }
903  Init *getLHS() const { return LHS; }
904  Init *getMHS() const { return MHS; }
905  Init *getRHS() const { return RHS; }
906 
907  // Fold - If possible, fold this to a simpler init. Return this if not
908  // possible to fold.
909  Init *Fold(Record *CurRec) const;
910 
911  bool isComplete() const override {
912  return LHS->isComplete() && MHS->isComplete() && RHS->isComplete();
913  }
914 
915  Init *resolveReferences(Resolver &R) const override;
916 
917  std::string getAsString() const override;
918 };
919 
920 /// !cond(condition_1: value1, ... , condition_n: value)
921 /// Selects the first value for which condition is true.
922 /// Otherwise reports an error.
923 class CondOpInit final : public TypedInit, public FoldingSetNode,
924  public TrailingObjects<CondOpInit, Init *> {
925  unsigned NumConds;
926  RecTy *ValType;
927 
928  CondOpInit(unsigned NC, RecTy *Type)
929  : TypedInit(IK_CondOpInit, Type),
930  NumConds(NC), ValType(Type) {}
931 
932  size_t numTrailingObjects(OverloadToken<Init *>) const {
933  return 2*NumConds;
934  }
935 
936 public:
937  CondOpInit(const CondOpInit &) = delete;
938  CondOpInit &operator=(const CondOpInit &) = delete;
939 
940  static bool classof(const Init *I) {
941  return I->getKind() == IK_CondOpInit;
942  }
943 
945  RecTy *Type);
946 
947  void Profile(FoldingSetNodeID &ID) const;
948 
949  RecTy *getValType() const { return ValType; }
950 
951  unsigned getNumConds() const { return NumConds; }
952 
953  Init *getCond(unsigned Num) const {
954  assert(Num < NumConds && "Condition number out of range!");
955  return getTrailingObjects<Init *>()[Num];
956  }
957 
958  Init *getVal(unsigned Num) const {
959  assert(Num < NumConds && "Val number out of range!");
960  return getTrailingObjects<Init *>()[Num+NumConds];
961  }
962 
964  return makeArrayRef(getTrailingObjects<Init *>(), NumConds);
965  }
966 
968  return makeArrayRef(getTrailingObjects<Init *>()+NumConds, NumConds);
969  }
970 
971  Init *Fold(Record *CurRec) const;
972 
973  Init *resolveReferences(Resolver &R) const override;
974 
975  bool isConcrete() const override;
976  bool isComplete() const override;
977  std::string getAsString() const override;
978 
981 
982  inline const_case_iterator arg_begin() const { return getConds().begin(); }
983  inline const_case_iterator arg_end () const { return getConds().end(); }
984 
985  inline size_t case_size () const { return NumConds; }
986  inline bool case_empty() const { return NumConds == 0; }
987 
988  inline const_val_iterator name_begin() const { return getVals().begin();}
989  inline const_val_iterator name_end () const { return getVals().end(); }
990 
991  inline size_t val_size () const { return NumConds; }
992  inline bool val_empty() const { return NumConds == 0; }
993 
994  Init *getBit(unsigned Bit) const override;
995 };
996 
997 /// !foldl (a, b, expr, start, lst) - Fold over a list.
998 class FoldOpInit : public TypedInit, public FoldingSetNode {
999 private:
1000  Init *Start;
1001  Init *List;
1002  Init *A;
1003  Init *B;
1004  Init *Expr;
1005 
1006  FoldOpInit(Init *Start, Init *List, Init *A, Init *B, Init *Expr, RecTy *Type)
1007  : TypedInit(IK_FoldOpInit, Type), Start(Start), List(List), A(A), B(B),
1008  Expr(Expr) {}
1009 
1010 public:
1011  FoldOpInit(const FoldOpInit &) = delete;
1012  FoldOpInit &operator=(const FoldOpInit &) = delete;
1013 
1014  static bool classof(const Init *I) { return I->getKind() == IK_FoldOpInit; }
1015 
1016  static FoldOpInit *get(Init *Start, Init *List, Init *A, Init *B, Init *Expr,
1017  RecTy *Type);
1018 
1019  void Profile(FoldingSetNodeID &ID) const;
1020 
1021  // Fold - If possible, fold this to a simpler init. Return this if not
1022  // possible to fold.
1023  Init *Fold(Record *CurRec) const;
1024 
1025  bool isComplete() const override { return false; }
1026 
1027  Init *resolveReferences(Resolver &R) const override;
1028 
1029  Init *getBit(unsigned Bit) const override;
1030 
1031  std::string getAsString() const override;
1032 };
1033 
1034 /// !isa<type>(expr) - Dynamically determine the type of an expression.
1035 class IsAOpInit : public TypedInit, public FoldingSetNode {
1036 private:
1037  RecTy *CheckType;
1038  Init *Expr;
1039 
1040  IsAOpInit(RecTy *CheckType, Init *Expr)
1041  : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType),
1042  Expr(Expr) {}
1043 
1044 public:
1045  IsAOpInit(const IsAOpInit &) = delete;
1046  IsAOpInit &operator=(const IsAOpInit &) = delete;
1047 
1048  static bool classof(const Init *I) { return I->getKind() == IK_IsAOpInit; }
1049 
1050  static IsAOpInit *get(RecTy *CheckType, Init *Expr);
1051 
1052  void Profile(FoldingSetNodeID &ID) const;
1053 
1054  // Fold - If possible, fold this to a simpler init. Return this if not
1055  // possible to fold.
1056  Init *Fold() const;
1057 
1058  bool isComplete() const override { return false; }
1059 
1060  Init *resolveReferences(Resolver &R) const override;
1061 
1062  Init *getBit(unsigned Bit) const override;
1063 
1064  std::string getAsString() const override;
1065 };
1066 
1067 /// 'Opcode' - Represent a reference to an entire variable object.
1068 class VarInit : public TypedInit {
1069  Init *VarName;
1070 
1071  explicit VarInit(Init *VN, RecTy *T)
1072  : TypedInit(IK_VarInit, T), VarName(VN) {}
1073 
1074 public:
1075  VarInit(const VarInit &) = delete;
1076  VarInit &operator=(const VarInit &) = delete;
1077 
1078  static bool classof(const Init *I) {
1079  return I->getKind() == IK_VarInit;
1080  }
1081 
1082  static VarInit *get(StringRef VN, RecTy *T);
1083  static VarInit *get(Init *VN, RecTy *T);
1084 
1085  StringRef getName() const;
1086  Init *getNameInit() const { return VarName; }
1087 
1088  std::string getNameInitAsString() const {
1089  return getNameInit()->getAsUnquotedString();
1090  }
1091 
1092  /// This method is used by classes that refer to other
1093  /// variables which may not be defined at the time they expression is formed.
1094  /// If a value is set for the variable later, this method will be called on
1095  /// users of the value to allow the value to propagate out.
1096  ///
1097  Init *resolveReferences(Resolver &R) const override;
1098 
1099  Init *getBit(unsigned Bit) const override;
1100 
1101  std::string getAsString() const override { return getName(); }
1102 };
1103 
1104 /// Opcode{0} - Represent access to one bit of a variable or field.
1105 class VarBitInit final : public TypedInit {
1106  TypedInit *TI;
1107  unsigned Bit;
1108 
1109  VarBitInit(TypedInit *T, unsigned B)
1110  : TypedInit(IK_VarBitInit, BitRecTy::get()), TI(T), Bit(B) {
1111  assert(T->getType() &&
1112  (isa<IntRecTy>(T->getType()) ||
1113  (isa<BitsRecTy>(T->getType()) &&
1114  cast<BitsRecTy>(T->getType())->getNumBits() > B)) &&
1115  "Illegal VarBitInit expression!");
1116  }
1117 
1118 public:
1119  VarBitInit(const VarBitInit &) = delete;
1120  VarBitInit &operator=(const VarBitInit &) = delete;
1121 
1122  static bool classof(const Init *I) {
1123  return I->getKind() == IK_VarBitInit;
1124  }
1125 
1126  static VarBitInit *get(TypedInit *T, unsigned B);
1127 
1128  Init *getBitVar() const { return TI; }
1129  unsigned getBitNum() const { return Bit; }
1130 
1131  std::string getAsString() const override;
1132  Init *resolveReferences(Resolver &R) const override;
1133 
1134  Init *getBit(unsigned B) const override {
1135  assert(B < 1 && "Bit index out of range!");
1136  return const_cast<VarBitInit*>(this);
1137  }
1138 };
1139 
1140 /// List[4] - Represent access to one element of a var or
1141 /// field.
1143  TypedInit *TI;
1144  unsigned Element;
1145 
1146  VarListElementInit(TypedInit *T, unsigned E)
1147  : TypedInit(IK_VarListElementInit,
1148  cast<ListRecTy>(T->getType())->getElementType()),
1149  TI(T), Element(E) {
1150  assert(T->getType() && isa<ListRecTy>(T->getType()) &&
1151  "Illegal VarBitInit expression!");
1152  }
1153 
1154 public:
1155  VarListElementInit(const VarListElementInit &) = delete;
1156  VarListElementInit &operator=(const VarListElementInit &) = delete;
1157 
1158  static bool classof(const Init *I) {
1159  return I->getKind() == IK_VarListElementInit;
1160  }
1161 
1162  static VarListElementInit *get(TypedInit *T, unsigned E);
1163 
1164  TypedInit *getVariable() const { return TI; }
1165  unsigned getElementNum() const { return Element; }
1166 
1167  std::string getAsString() const override;
1168  Init *resolveReferences(Resolver &R) const override;
1169 
1170  Init *getBit(unsigned Bit) const override;
1171 };
1172 
1173 /// AL - Represent a reference to a 'def' in the description
1174 class DefInit : public TypedInit {
1175  friend class Record;
1176 
1177  Record *Def;
1178 
1179  explicit DefInit(Record *D);
1180 
1181 public:
1182  DefInit(const DefInit &) = delete;
1183  DefInit &operator=(const DefInit &) = delete;
1184 
1185  static bool classof(const Init *I) {
1186  return I->getKind() == IK_DefInit;
1187  }
1188 
1189  static DefInit *get(Record*);
1190 
1191  Init *convertInitializerTo(RecTy *Ty) const override;
1192 
1193  Record *getDef() const { return Def; }
1194 
1195  //virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits);
1196 
1197  RecTy *getFieldType(StringInit *FieldName) const override;
1198 
1199  bool isConcrete() const override { return true; }
1200  std::string getAsString() const override;
1201 
1202  Init *getBit(unsigned Bit) const override {
1203  llvm_unreachable("Illegal bit reference off def");
1204  }
1205 };
1206 
1207 /// classname<targs...> - Represent an uninstantiated anonymous class
1208 /// instantiation.
1209 class VarDefInit final : public TypedInit, public FoldingSetNode,
1210  public TrailingObjects<VarDefInit, Init *> {
1211  Record *Class;
1212  DefInit *Def = nullptr; // after instantiation
1213  unsigned NumArgs;
1214 
1215  explicit VarDefInit(Record *Class, unsigned N)
1216  : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class), NumArgs(N) {}
1217 
1218  DefInit *instantiate();
1219 
1220 public:
1221  VarDefInit(const VarDefInit &) = delete;
1222  VarDefInit &operator=(const VarDefInit &) = delete;
1223 
1224  // Do not use sized deallocation due to trailing objects.
1225  void operator delete(void *p) { ::operator delete(p); }
1226 
1227  static bool classof(const Init *I) {
1228  return I->getKind() == IK_VarDefInit;
1229  }
1230  static VarDefInit *get(Record *Class, ArrayRef<Init *> Args);
1231 
1232  void Profile(FoldingSetNodeID &ID) const;
1233 
1234  Init *resolveReferences(Resolver &R) const override;
1235  Init *Fold() const;
1236 
1237  std::string getAsString() const override;
1238 
1239  Init *getArg(unsigned i) const {
1240  assert(i < NumArgs && "Argument index out of range!");
1241  return getTrailingObjects<Init *>()[i];
1242  }
1243 
1244  using const_iterator = Init *const *;
1245 
1246  const_iterator args_begin() const { return getTrailingObjects<Init *>(); }
1247  const_iterator args_end () const { return args_begin() + NumArgs; }
1248 
1249  size_t args_size () const { return NumArgs; }
1250  bool args_empty() const { return NumArgs == 0; }
1251 
1252  ArrayRef<Init *> args() const { return makeArrayRef(args_begin(), NumArgs); }
1253 
1254  Init *getBit(unsigned Bit) const override {
1255  llvm_unreachable("Illegal bit reference off anonymous def");
1256  }
1257 };
1258 
1259 /// X.Y - Represent a reference to a subfield of a variable
1260 class FieldInit : public TypedInit {
1261  Init *Rec; // Record we are referring to
1262  StringInit *FieldName; // Field we are accessing
1263 
1264  FieldInit(Init *R, StringInit *FN)
1265  : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) {
1266  assert(getType() && "FieldInit with non-record type!");
1267  }
1268 
1269 public:
1270  FieldInit(const FieldInit &) = delete;
1271  FieldInit &operator=(const FieldInit &) = delete;
1272 
1273  static bool classof(const Init *I) {
1274  return I->getKind() == IK_FieldInit;
1275  }
1276 
1277  static FieldInit *get(Init *R, StringInit *FN);
1278 
1279  Init *getRecord() const { return Rec; }
1280  StringInit *getFieldName() const { return FieldName; }
1281 
1282  Init *getBit(unsigned Bit) const override;
1283 
1284  Init *resolveReferences(Resolver &R) const override;
1285  Init *Fold(Record *CurRec) const;
1286 
1287  std::string getAsString() const override {
1288  return Rec->getAsString() + "." + FieldName->getValue().str();
1289  }
1290 };
1291 
1292 /// (v a, b) - Represent a DAG tree value. DAG inits are required
1293 /// to have at least one value then a (possibly empty) list of arguments. Each
1294 /// argument can have a name associated with it.
1295 class DagInit final : public TypedInit, public FoldingSetNode,
1296  public TrailingObjects<DagInit, Init *, StringInit *> {
1297  friend TrailingObjects;
1298 
1299  Init *Val;
1300  StringInit *ValName;
1301  unsigned NumArgs;
1302  unsigned NumArgNames;
1303 
1304  DagInit(Init *V, StringInit *VN, unsigned NumArgs, unsigned NumArgNames)
1305  : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN),
1306  NumArgs(NumArgs), NumArgNames(NumArgNames) {}
1307 
1308  size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; }
1309 
1310 public:
1311  DagInit(const DagInit &) = delete;
1312  DagInit &operator=(const DagInit &) = delete;
1313 
1314  static bool classof(const Init *I) {
1315  return I->getKind() == IK_DagInit;
1316  }
1317 
1318  static DagInit *get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
1319  ArrayRef<StringInit*> NameRange);
1320  static DagInit *get(Init *V, StringInit *VN,
1322 
1323  void Profile(FoldingSetNodeID &ID) const;
1324 
1325  Init *getOperator() const { return Val; }
1326 
1327  StringInit *getName() const { return ValName; }
1328 
1330  return ValName ? ValName->getValue() : StringRef();
1331  }
1332 
1333  unsigned getNumArgs() const { return NumArgs; }
1334 
1335  Init *getArg(unsigned Num) const {
1336  assert(Num < NumArgs && "Arg number out of range!");
1337  return getTrailingObjects<Init *>()[Num];
1338  }
1339 
1340  StringInit *getArgName(unsigned Num) const {
1341  assert(Num < NumArgNames && "Arg number out of range!");
1342  return getTrailingObjects<StringInit *>()[Num];
1343  }
1344 
1345  StringRef getArgNameStr(unsigned Num) const {
1346  StringInit *Init = getArgName(Num);
1347  return Init ? Init->getValue() : StringRef();
1348  }
1349 
1351  return makeArrayRef(getTrailingObjects<Init *>(), NumArgs);
1352  }
1353 
1355  return makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames);
1356  }
1357 
1358  Init *resolveReferences(Resolver &R) const override;
1359 
1360  bool isConcrete() const override;
1361  std::string getAsString() const override;
1362 
1365 
1366  inline const_arg_iterator arg_begin() const { return getArgs().begin(); }
1367  inline const_arg_iterator arg_end () const { return getArgs().end(); }
1368 
1369  inline size_t arg_size () const { return NumArgs; }
1370  inline bool arg_empty() const { return NumArgs == 0; }
1371 
1372  inline const_name_iterator name_begin() const { return getArgNames().begin();}
1373  inline const_name_iterator name_end () const { return getArgNames().end(); }
1374 
1375  inline size_t name_size () const { return NumArgNames; }
1376  inline bool name_empty() const { return NumArgNames == 0; }
1377 
1378  Init *getBit(unsigned Bit) const override {
1379  llvm_unreachable("Illegal bit reference off dag");
1380  }
1381 };
1382 
1383 //===----------------------------------------------------------------------===//
1384 // High-Level Classes
1385 //===----------------------------------------------------------------------===//
1386 
1387 class RecordVal {
1388  friend class Record;
1389 
1390  Init *Name;
1392  Init *Value;
1393 
1394 public:
1395  RecordVal(Init *N, RecTy *T, bool P);
1396 
1397  StringRef getName() const;
1398  Init *getNameInit() const { return Name; }
1399 
1400  std::string getNameInitAsString() const {
1401  return getNameInit()->getAsUnquotedString();
1402  }
1403 
1404  bool getPrefix() const { return TyAndPrefix.getInt(); }
1405  RecTy *getType() const { return TyAndPrefix.getPointer(); }
1406  Init *getValue() const { return Value; }
1407 
1408  bool setValue(Init *V);
1409 
1410  void dump() const;
1411  void print(raw_ostream &OS, bool PrintSem = true) const;
1412 };
1413 
1414 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1415  RV.print(OS << " ");
1416  return OS;
1417 }
1418 
1419 class Record {
1420  static unsigned LastID;
1421 
1422  Init *Name;
1423  // Location where record was instantiated, followed by the location of
1424  // multiclass prototypes used.
1425  SmallVector<SMLoc, 4> Locs;
1428 
1429  // All superclasses in the inheritance forest in reverse preorder (yes, it
1430  // must be a forest; diamond-shaped inheritance is not allowed).
1432 
1433  // Tracks Record instances. Not owned by Record.
1434  RecordKeeper &TrackedRecords;
1435 
1436  DefInit *TheInit = nullptr;
1437 
1438  // Unique record ID.
1439  unsigned ID;
1440 
1441  bool IsAnonymous;
1442  bool IsClass;
1443 
1444  void checkName();
1445 
1446 public:
1447  // Constructs a record.
1448  explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1449  bool Anonymous = false, bool Class = false)
1450  : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records),
1451  ID(LastID++), IsAnonymous(Anonymous), IsClass(Class) {
1452  checkName();
1453  }
1454 
1455  explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1456  bool Class = false)
1457  : Record(StringInit::get(N), locs, records, false, Class) {}
1458 
1459  // When copy-constructing a Record, we must still guarantee a globally unique
1460  // ID number. Don't copy TheInit either since it's owned by the original
1461  // record. All other fields can be copied normally.
1462  Record(const Record &O)
1463  : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
1464  Values(O.Values), SuperClasses(O.SuperClasses),
1465  TrackedRecords(O.TrackedRecords), ID(LastID++),
1466  IsAnonymous(O.IsAnonymous), IsClass(O.IsClass) { }
1467 
1468  static unsigned getNewUID() { return LastID++; }
1469 
1470  unsigned getID() const { return ID; }
1471 
1472  StringRef getName() const { return cast<StringInit>(Name)->getValue(); }
1473 
1474  Init *getNameInit() const {
1475  return Name;
1476  }
1477 
1478  const std::string getNameInitAsString() const {
1479  return getNameInit()->getAsUnquotedString();
1480  }
1481 
1482  void setName(Init *Name); // Also updates RecordKeeper.
1483 
1484  ArrayRef<SMLoc> getLoc() const { return Locs; }
1485  void appendLoc(SMLoc Loc) { Locs.push_back(Loc); }
1486 
1487  // Make the type that this record should have based on its superclasses.
1488  RecordRecTy *getType();
1489 
1490  /// get the corresponding DefInit.
1491  DefInit *getDefInit();
1492 
1493  bool isClass() const { return IsClass; }
1494 
1496  return TemplateArgs;
1497  }
1498 
1499  ArrayRef<RecordVal> getValues() const { return Values; }
1500 
1502  return SuperClasses;
1503  }
1504 
1505  /// Append the direct super classes of this record to Classes.
1506  void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
1507 
1508  bool isTemplateArg(Init *Name) const {
1509  for (Init *TA : TemplateArgs)
1510  if (TA == Name) return true;
1511  return false;
1512  }
1513 
1514  const RecordVal *getValue(const Init *Name) const {
1515  for (const RecordVal &Val : Values)
1516  if (Val.Name == Name) return &Val;
1517  return nullptr;
1518  }
1519 
1520  const RecordVal *getValue(StringRef Name) const {
1521  return getValue(StringInit::get(Name));
1522  }
1523 
1524  RecordVal *getValue(const Init *Name) {
1525  return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
1526  }
1527 
1529  return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
1530  }
1531 
1532  void addTemplateArg(Init *Name) {
1533  assert(!isTemplateArg(Name) && "Template arg already defined!");
1534  TemplateArgs.push_back(Name);
1535  }
1536 
1537  void addValue(const RecordVal &RV) {
1538  assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
1539  Values.push_back(RV);
1540  }
1541 
1542  void removeValue(Init *Name) {
1543  for (unsigned i = 0, e = Values.size(); i != e; ++i)
1544  if (Values[i].getNameInit() == Name) {
1545  Values.erase(Values.begin()+i);
1546  return;
1547  }
1548  llvm_unreachable("Cannot remove an entry that does not exist!");
1549  }
1550 
1551  void removeValue(StringRef Name) {
1552  removeValue(StringInit::get(Name));
1553  }
1554 
1555  bool isSubClassOf(const Record *R) const {
1556  for (const auto &SCPair : SuperClasses)
1557  if (SCPair.first == R)
1558  return true;
1559  return false;
1560  }
1561 
1562  bool isSubClassOf(StringRef Name) const {
1563  for (const auto &SCPair : SuperClasses) {
1564  if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) {
1565  if (SI->getValue() == Name)
1566  return true;
1567  } else if (SCPair.first->getNameInitAsString() == Name) {
1568  return true;
1569  }
1570  }
1571  return false;
1572  }
1573 
1574  void addSuperClass(Record *R, SMRange Range) {
1575  assert(!TheInit && "changing type of record after it has been referenced");
1576  assert(!isSubClassOf(R) && "Already subclassing record!");
1577  SuperClasses.push_back(std::make_pair(R, Range));
1578  }
1579 
1580  /// If there are any field references that refer to fields
1581  /// that have been filled in, we can propagate the values now.
1582  ///
1583  /// This is a final resolve: any error messages, e.g. due to undefined
1584  /// !cast references, are generated now.
1585  void resolveReferences();
1586 
1587  /// Apply the resolver to the name of the record as well as to the
1588  /// initializers of all fields of the record except SkipVal.
1589  ///
1590  /// The resolver should not resolve any of the fields itself, to avoid
1591  /// recursion / infinite loops.
1592  void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr);
1593 
1594  /// If anything in this record refers to RV, replace the
1595  /// reference to RV with the RHS of RV. If RV is null, we resolve all
1596  /// possible references.
1597  void resolveReferencesTo(const RecordVal *RV);
1598 
1600  return TrackedRecords;
1601  }
1602 
1603  bool isAnonymous() const {
1604  return IsAnonymous;
1605  }
1606 
1607  void print(raw_ostream &OS) const;
1608  void dump() const;
1609 
1610  //===--------------------------------------------------------------------===//
1611  // High-level methods useful to tablegen back-ends
1612  //
1613 
1614  /// Return the initializer for a value with the specified name,
1615  /// or throw an exception if the field does not exist.
1616  Init *getValueInit(StringRef FieldName) const;
1617 
1618  /// Return true if the named field is unset.
1619  bool isValueUnset(StringRef FieldName) const {
1620  return isa<UnsetInit>(getValueInit(FieldName));
1621  }
1622 
1623  /// This method looks up the specified field and returns
1624  /// its value as a string, throwing an exception if the field does not exist
1625  /// or if the value is not a string.
1626  StringRef getValueAsString(StringRef FieldName) const;
1627 
1628  /// This method looks up the specified field and returns
1629  /// its value as a BitsInit, throwing an exception if the field does not exist
1630  /// or if the value is not the right type.
1631  BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1632 
1633  /// This method looks up the specified field and returns
1634  /// its value as a ListInit, throwing an exception if the field does not exist
1635  /// or if the value is not the right type.
1636  ListInit *getValueAsListInit(StringRef FieldName) const;
1637 
1638  /// This method looks up the specified field and
1639  /// returns its value as a vector of records, throwing an exception if the
1640  /// field does not exist or if the value is not the right type.
1641  std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1642 
1643  /// This method looks up the specified field and
1644  /// returns its value as a vector of integers, throwing an exception if the
1645  /// field does not exist or if the value is not the right type.
1646  std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1647 
1648  /// This method looks up the specified field and
1649  /// returns its value as a vector of strings, throwing an exception if the
1650  /// field does not exist or if the value is not the right type.
1651  std::vector<StringRef> getValueAsListOfStrings(StringRef FieldName) const;
1652 
1653  /// This method looks up the specified field and returns its
1654  /// value as a Record, throwing an exception if the field does not exist or if
1655  /// the value is not the right type.
1656  Record *getValueAsDef(StringRef FieldName) const;
1657 
1658  /// This method looks up the specified field and returns its
1659  /// value as a bit, throwing an exception if the field does not exist or if
1660  /// the value is not the right type.
1661  bool getValueAsBit(StringRef FieldName) const;
1662 
1663  /// This method looks up the specified field and
1664  /// returns its value as a bit. If the field is unset, sets Unset to true and
1665  /// returns false.
1666  bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const;
1667 
1668  /// This method looks up the specified field and returns its
1669  /// value as an int64_t, throwing an exception if the field does not exist or
1670  /// if the value is not the right type.
1671  int64_t getValueAsInt(StringRef FieldName) const;
1672 
1673  /// This method looks up the specified field and returns its
1674  /// value as an Dag, throwing an exception if the field does not exist or if
1675  /// the value is not the right type.
1676  DagInit *getValueAsDag(StringRef FieldName) const;
1677 };
1678 
1679 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1680 
1682  friend class RecordRecTy;
1683  using RecordMap = std::map<std::string, std::unique_ptr<Record>>;
1684  RecordMap Classes, Defs;
1685  FoldingSet<RecordRecTy> RecordTypePool;
1686  std::map<std::string, Init *> ExtraGlobals;
1687  unsigned AnonCounter = 0;
1688 
1689 public:
1690  const RecordMap &getClasses() const { return Classes; }
1691  const RecordMap &getDefs() const { return Defs; }
1692 
1694  auto I = Classes.find(Name);
1695  return I == Classes.end() ? nullptr : I->second.get();
1696  }
1697 
1699  auto I = Defs.find(Name);
1700  return I == Defs.end() ? nullptr : I->second.get();
1701  }
1702 
1704  if (Record *R = getDef(Name))
1705  return R->getDefInit();
1706  auto It = ExtraGlobals.find(Name);
1707  return It == ExtraGlobals.end() ? nullptr : It->second;
1708  }
1709 
1710  void addClass(std::unique_ptr<Record> R) {
1711  bool Ins = Classes.insert(std::make_pair(R->getName(),
1712  std::move(R))).second;
1713  (void)Ins;
1714  assert(Ins && "Class already exists");
1715  }
1716 
1717  void addDef(std::unique_ptr<Record> R) {
1718  bool Ins = Defs.insert(std::make_pair(R->getName(),
1719  std::move(R))).second;
1720  (void)Ins;
1721  assert(Ins && "Record already exists");
1722  }
1723 
1725  bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second;
1726  (void)Ins;
1727  assert(!getDef(Name));
1728  assert(Ins && "Global already exists");
1729  }
1730 
1731  Init *getNewAnonymousName();
1732 
1733  //===--------------------------------------------------------------------===//
1734  // High-level helper methods, useful for tablegen backends...
1735 
1736  /// This method returns all concrete definitions
1737  /// that derive from the specified class name. A class with the specified
1738  /// name must exist.
1739  std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
1740 
1741  void dump() const;
1742 };
1743 
1744 /// Sorting predicate to sort record pointers by name.
1745 struct LessRecord {
1746  bool operator()(const Record *Rec1, const Record *Rec2) const {
1747  return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1748  }
1749 };
1750 
1751 /// Sorting predicate to sort record pointers by their
1752 /// unique ID. If you just need a deterministic order, use this, since it
1753 /// just compares two `unsigned`; the other sorting predicates require
1754 /// string manipulation.
1756  bool operator()(const Record *LHS, const Record *RHS) const {
1757  return LHS->getID() < RHS->getID();
1758  }
1759 };
1760 
1761 /// Sorting predicate to sort record pointers by their
1762 /// name field.
1764  bool operator()(const Record *Rec1, const Record *Rec2) const {
1765  return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1766  }
1767 };
1768 
1770  static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; }
1771 
1772  struct RecordParts {
1774 
1776  if (Rec.empty())
1777  return;
1778 
1779  size_t Len = 0;
1780  const char *Start = Rec.data();
1781  const char *Curr = Start;
1782  bool isDigitPart = ascii_isdigit(Curr[0]);
1783  for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) {
1784  bool isDigit = ascii_isdigit(Curr[I]);
1785  if (isDigit != isDigitPart) {
1786  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1787  Len = 0;
1788  Start = &Curr[I];
1789  isDigitPart = ascii_isdigit(Curr[I]);
1790  }
1791  }
1792  // Push the last part.
1793  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1794  }
1795 
1796  size_t size() { return Parts.size(); }
1797 
1798  std::pair<bool, StringRef> getPart(size_t i) {
1799  assert (i < Parts.size() && "Invalid idx!");
1800  return Parts[i];
1801  }
1802  };
1803 
1804  bool operator()(const Record *Rec1, const Record *Rec2) const {
1805  RecordParts LHSParts(StringRef(Rec1->getName()));
1806  RecordParts RHSParts(StringRef(Rec2->getName()));
1807 
1808  size_t LHSNumParts = LHSParts.size();
1809  size_t RHSNumParts = RHSParts.size();
1810  assert (LHSNumParts && RHSNumParts && "Expected at least one part!");
1811 
1812  if (LHSNumParts != RHSNumParts)
1813  return LHSNumParts < RHSNumParts;
1814 
1815  // We expect the registers to be of the form [_a-zA-Z]+([0-9]*[_a-zA-Z]*)*.
1816  for (size_t I = 0, E = LHSNumParts; I < E; I+=2) {
1817  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1818  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1819  // Expect even part to always be alpha.
1820  assert (LHSPart.first == false && RHSPart.first == false &&
1821  "Expected both parts to be alpha.");
1822  if (int Res = LHSPart.second.compare(RHSPart.second))
1823  return Res < 0;
1824  }
1825  for (size_t I = 1, E = LHSNumParts; I < E; I+=2) {
1826  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1827  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1828  // Expect odd part to always be numeric.
1829  assert (LHSPart.first == true && RHSPart.first == true &&
1830  "Expected both parts to be numeric.");
1831  if (LHSPart.second.size() != RHSPart.second.size())
1832  return LHSPart.second.size() < RHSPart.second.size();
1833 
1834  unsigned LHSVal, RHSVal;
1835 
1836  bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed;
1837  assert(!LHSFailed && "Unable to convert LHS to integer.");
1838  bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed;
1839  assert(!RHSFailed && "Unable to convert RHS to integer.");
1840 
1841  if (LHSVal != RHSVal)
1842  return LHSVal < RHSVal;
1843  }
1844  return LHSNumParts < RHSNumParts;
1845  }
1846 };
1847 
1849 
1850 //===----------------------------------------------------------------------===//
1851 // Resolvers
1852 //===----------------------------------------------------------------------===//
1853 
1854 /// Interface for looking up the initializer for a variable name, used by
1855 /// Init::resolveReferences.
1856 class Resolver {
1857  Record *CurRec;
1858  bool IsFinal = false;
1859 
1860 public:
1861  explicit Resolver(Record *CurRec) : CurRec(CurRec) {}
1862  virtual ~Resolver() {}
1863 
1864  Record *getCurrentRecord() const { return CurRec; }
1865 
1866  /// Return the initializer for the given variable name (should normally be a
1867  /// StringInit), or nullptr if the name could not be resolved.
1868  virtual Init *resolve(Init *VarName) = 0;
1869 
1870  // Whether bits in a BitsInit should stay unresolved if resolving them would
1871  // result in a ? (UnsetInit). This behavior is used to represent instruction
1872  // encodings by keeping references to unset variables within a record.
1873  virtual bool keepUnsetBits() const { return false; }
1874 
1875  // Whether this is the final resolve step before adding a record to the
1876  // RecordKeeper. Error reporting during resolve and related constant folding
1877  // should only happen when this is true.
1878  bool isFinal() const { return IsFinal; }
1879 
1880  void setFinal(bool Final) { IsFinal = Final; }
1881 };
1882 
1883 /// Resolve arbitrary mappings.
1884 class MapResolver final : public Resolver {
1885  struct MappedValue {
1886  Init *V;
1887  bool Resolved;
1888 
1889  MappedValue() : V(nullptr), Resolved(false) {}
1890  MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {}
1891  };
1892 
1894 
1895 public:
1896  explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {}
1897 
1898  void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; }
1899 
1900  Init *resolve(Init *VarName) override;
1901 };
1902 
1903 /// Resolve all variables from a record except for unset variables.
1904 class RecordResolver final : public Resolver {
1906  SmallVector<Init *, 4> Stack;
1907 
1908 public:
1909  explicit RecordResolver(Record &R) : Resolver(&R) {}
1910 
1911  Init *resolve(Init *VarName) override;
1912 
1913  bool keepUnsetBits() const override { return true; }
1914 };
1915 
1916 /// Resolve all references to a specific RecordVal.
1917 //
1918 // TODO: This is used for resolving references to template arguments, in a
1919 // rather inefficient way. Change those uses to resolve all template
1920 // arguments simultaneously and get rid of this class.
1921 class RecordValResolver final : public Resolver {
1922  const RecordVal *RV;
1923 
1924 public:
1925  explicit RecordValResolver(Record &R, const RecordVal *RV)
1926  : Resolver(&R), RV(RV) {}
1927 
1928  Init *resolve(Init *VarName) override {
1929  if (VarName == RV->getNameInit())
1930  return RV->getValue();
1931  return nullptr;
1932  }
1933 };
1934 
1935 /// Delegate resolving to a sub-resolver, but shadow some variable names.
1936 class ShadowResolver final : public Resolver {
1937  Resolver &R;
1938  DenseSet<Init *> Shadowed;
1939 
1940 public:
1942  : Resolver(R.getCurrentRecord()), R(R) {
1943  setFinal(R.isFinal());
1944  }
1945 
1946  void addShadow(Init *Key) { Shadowed.insert(Key); }
1947 
1948  Init *resolve(Init *VarName) override {
1949  if (Shadowed.count(VarName))
1950  return nullptr;
1951  return R.resolve(VarName);
1952  }
1953 };
1954 
1955 /// (Optionally) delegate resolving to a sub-resolver, and keep track whether
1956 /// there were unresolved references.
1957 class TrackUnresolvedResolver final : public Resolver {
1958  Resolver *R;
1959  bool FoundUnresolved = false;
1960 
1961 public:
1962  explicit TrackUnresolvedResolver(Resolver *R = nullptr)
1963  : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {}
1964 
1965  bool foundUnresolved() const { return FoundUnresolved; }
1966 
1967  Init *resolve(Init *VarName) override;
1968 };
1969 
1970 /// Do not resolve anything, but keep track of whether a given variable was
1971 /// referenced.
1972 class HasReferenceResolver final : public Resolver {
1973  Init *VarNameToTrack;
1974  bool Found = false;
1975 
1976 public:
1977  explicit HasReferenceResolver(Init *VarNameToTrack)
1978  : Resolver(nullptr), VarNameToTrack(VarNameToTrack) {}
1979 
1980  bool found() const { return Found; }
1981 
1982  Init *resolve(Init *VarName) override;
1983 };
1984 
1985 void EmitJSON(RecordKeeper &RK, raw_ostream &OS);
1986 
1987 } // end namespace llvm
1988 
1989 #endif // LLVM_TABLEGEN_RECORD_H
Init * getOperand() const
Definition: Record.h:789
static BinOpInit * get(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:825
Init * getCond(unsigned Num) const
Definition: Record.h:953
uint64_t CallInst * C
unsigned getNumBits() const
Definition: Record.h:535
RecordVal * getValue(const Init *Name)
Definition: Record.h:1524
Represents a range in source code.
Definition: SMLoc.h:48
unsigned getNumConds() const
Definition: Record.h:951
static bool classof(const Init *I)
Definition: Record.h:1158
std::string getAsString() const override
Definition: Record.h:152
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:614
RecTyKind
Subclass discriminator (for dyn_cast<> et al.)
Definition: Record.h:57
void print(raw_ostream &OS) const
Definition: Record.h:79
bool getValue() const
Definition: Record.h:498
const_name_iterator name_end() const
Definition: Record.h:1373
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:218
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
bool allInComplete() const
Definition: Record.h:546
Init * getValue() const
Definition: Record.h:1406
const_case_iterator arg_end() const
Definition: Record.h:983
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:320
Sorting predicate to sort record pointers by name.
Definition: Record.h:1745
This class represents lattice values for constants.
Definition: AllocatorList.h:23
X.Y - Represent a reference to a subfield of a variable.
Definition: Record.h:1260
PointerTy getPointer() const
Resolver(Record *CurRec)
Definition: Record.h:1861
virtual std::string getAsUnquotedString() const
Convert this value to a string form, without adding quote markers.
Definition: Record.h:367
Record * getCurrentRecord() const
Definition: Record.h:1864
bool foundUnresolved() const
Definition: Record.h:1965
bool empty() const
Definition: Record.h:718
[AL, AH, CL] - Represent a list of defs
Definition: Record.h:661
iterator begin() const
Definition: ArrayRef.h:136
&#39;7&#39; - Represent an initialization by a literal integer value.
Definition: Record.h:564
StringRef getNameStr() const
Definition: Record.h:1329
virtual RecTy * getFieldType(StringInit *FieldName) const
This method is used to implement the FieldInit class.
Definition: Record.h:402
static bool classof(const RecTy *RT)
Definition: Record.h:164
&#39;list<Ty>&#39; - Represent a list of values, all of which must be of the specified type.
Definition: Record.h:195
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
!op (X, Y) - Combine two inits.
Definition: Record.h:801
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:615
Init * getRHS() const
Definition: Record.h:905
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
Sorting predicate to sort record pointers by their name field.
Definition: Record.h:1763
AL - Represent a reference to a &#39;def&#39; in the description.
Definition: Record.h:1174
static bool classof(const Init *I)
Definition: Record.h:817
static UnOpInit * get(UnaryOp opc, Init *lhs, RecTy *Type)
Definition: Record.cpp:693
static bool classof(const Init *I)
Definition: Record.h:527
void addDef(std::unique_ptr< Record > R)
Definition: Record.h:1717
static bool classof(const Init *I)
Definition: Record.h:1014
Init * getOperand(unsigned i) const override
Definition: Record.h:783
static bool classof(const RecTy *RT)
Definition: Record.h:106
std::string getAsString() const override
Definition: Record.h:112
HasReferenceResolver(Init *VarNameToTrack)
Definition: Record.h:1977
size_t val_size() const
Definition: Record.h:991
Resolve all references to a specific RecordVal.
Definition: Record.h:1921
static CodeRecTy * get()
Definition: Record.h:150
const_record_iterator classes_begin() const
Definition: Record.h:268
static bool classof(const Init *I)
Definition: Record.h:1185
void removeValue(StringRef Name)
Definition: Record.h:1551
Resolve all variables from a record except for unset variables.
Definition: Record.h:1904
&#39;{ a, b, c }&#39; - Represents an initializer for a BitsRecTy value.
Definition: Record.h:513
Init * getArg(unsigned i) const
Definition: Record.h:1239
std::pair< bool, StringRef > getPart(size_t i)
Definition: Record.h:1798
std::string getNameInitAsString() const
Definition: Record.h:1400
static BitRecTy * get()
Definition: Record.h:110
static bool classof(const Init *I)
Definition: Record.h:436
(Optionally) delegate resolving to a sub-resolver, and keep track whether there were unresolved refer...
Definition: Record.h:1957
Sorting predicate to sort record pointers by their unique ID.
Definition: Record.h:1755
static bool classof(const Init *I)
Definition: Record.h:636
Init * getArg(unsigned Num) const
Definition: Record.h:1335
ArrayRef< std::pair< Record *, SMRange > > getSuperClasses() const
Definition: Record.h:1501
&#39;?&#39; - Represents an uninitialized value
Definition: Record.h:457
static bool classof(const Init *I)
Definition: Record.h:492
void addSuperClass(Record *R, SMRange Range)
Definition: Record.h:1574
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:473
&#39;true&#39;/&#39;false&#39; - Represent a concrete initializer for a bit.
Definition: Record.h:483
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:1378
TypedInit * getVariable() const
Definition: Record.h:1164
SmallVectorImpl< Init * >::const_iterator const_val_iterator
Definition: Record.h:980
static bool classof(const Init *I)
Definition: Record.h:736
static BitsRecTy * get(unsigned Sz)
Definition: Record.cpp:84
Record * getDef() const
Definition: Record.h:1193
static bool classof(const RecTy *RT)
Definition: Record.h:253
const_val_iterator name_end() const
Definition: Record.h:989
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:619
static bool classof(const Init *I)
Definition: Record.h:574
This is the common super-class of types that have a specific, explicit, type.
Definition: Record.h:425
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
Shift and rotation operations.
Definition: ISDOpcodes.h:434
Init *const * const_iterator
Definition: Record.h:1244
void addClass(std::unique_ptr< Record > R)
Definition: Record.h:1710
RecTy * getElementType() const
Definition: Record.h:208
static StringRecTy * get()
Definition: Record.h:186
static Optional< unsigned > getOpcode(ArrayRef< VPValue *> Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition: VPlanSLP.cpp:196
ArrayRef< Init * > getTemplateArgs() const
Definition: Record.h:1495
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
List[4] - Represent access to one element of a var or field.
Definition: Record.h:1142
&#39;[classname]&#39; - Type of record values that have zero or more superclasses.
Definition: Record.h:237
virtual bool isComplete() const
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:352
const_iterator args_begin() const
Definition: Record.h:1246
bool isAnonymous() const
Definition: Record.h:1603
static StringRef getName(Value *V)
bool case_empty() const
Definition: Record.h:986
!foldl (a, b, expr, start, lst) - Fold over a list.
Definition: Record.h:998
const_iterator args_end() const
Definition: Record.h:1247
bool args_empty() const
Definition: Record.h:1250
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1746
Init * getLHS() const
Definition: Record.h:846
RecordResolver(Record &R)
Definition: Record.h:1909
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
!cond(condition_1: value1, ...
Definition: Record.h:923
void print(raw_ostream &OS, bool PrintSem=true) const
Definition: Record.cpp:2015
unsigned getBitNum() const
Definition: Record.h:1129
const_iterator end() const
Definition: Record.h:715
StringInit * getArgName(unsigned Num) const
Definition: Record.h:1340
virtual Init * convertInitializerBitRange(ArrayRef< unsigned > Bits) const
This method is used to implement the bitrange selection operator.
Definition: Record.h:387
Key
PAL metadata keys.
bool operator()(const Record *LHS, const Record *RHS) const
Definition: Record.h:1756
Record * getClass(StringRef Name) const
Definition: Record.h:1693
SmallVectorImpl< Init * >::const_iterator const_arg_iterator
Definition: Record.h:1363
ArrayRef< SMLoc > getLoc() const
Definition: Record.h:1484
&#39;bits<n>&#39; - Represent a fixed number of bits
Definition: Record.h:118
ArrayRef< Record * > getClasses() const
Definition: Record.h:262
bool isComplete() const override
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:1058
bool isTemplateArg(Init *Name) const
Definition: Record.h:1508
IntType getInt() const
RecTy * getType() const
Definition: Record.h:1405
StringRef getValue() const
Definition: Record.h:642
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:200
bool isSubClassOf(const Record *R) const
Definition: Record.h:1555
static bool classof(const RecTy *RT)
Definition: Record.h:203
ArrayRef< Init * > getValues() const
Definition: Record.h:710
ArrayRef< Init * > getArgs() const
Definition: Record.h:1350
OpInit(InitKind K, RecTy *Type, uint8_t Opc)
Definition: Record.h:729
static bool classof(const Init *I)
Definition: Record.h:1122
bool isFinal() const
Definition: Record.h:1878
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
static bool classof(const RecTy *RT)
Definition: Record.h:224
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1764
static bool classof(const RecTy *RT)
Definition: Record.h:182
bool isComplete() const override
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:1025
static bool classof(const Init *I)
Definition: Record.h:1273
unsigned getNumBits() const
Definition: Record.h:130
void print(raw_ostream &OS) const
Print out this value.
Definition: Record.h:359
#define EQ(a, b)
Definition: regexec.c:112
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:1254
Init * getBitVar() const
Definition: Record.h:1128
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:478
virtual Init * convertInitListSlice(ArrayRef< unsigned > Elements) const
This method is used to implement the list slice selection operator.
Definition: Record.h:395
ArrayRef< RecordVal > getValues() const
Definition: Record.h:1499
const_record_iterator classes_end() const
Definition: Record.h:269
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:585
&#39;code&#39; - Represent a code fragment
Definition: Record.h:140
ArrayRef< Init * > getVals() const
Definition: Record.h:967
SmallVectorImpl< StringInit * >::const_iterator const_name_iterator
Definition: Record.h:1364
void addShadow(Init *Key)
Definition: Record.h:1946
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:305
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:1101
unsigned getElementNum() const
Definition: Record.h:1165
Base class for operators.
Definition: Record.h:727
#define P(N)
static bool classof(const Init *I)
Definition: Record.h:1048
OpInit * clone(ArrayRef< Init *> Operands) const override
Definition: Record.h:830
RecTy(RecTyKind K)
Definition: Record.h:73
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:1202
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:647
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
RecTy * getType() const
Definition: Record.h:441
Init * getElement(unsigned i) const
Definition: Record.h:686
Resolve arbitrary mappings.
Definition: Record.h:1884
Init * getNameInit() const
Definition: Record.h:1398
bool isClass() const
Definition: Record.h:1493
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 keepUnsetBits() const override
Definition: Record.h:1913
bool isComplete() const override
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:540
virtual bool isConcrete() const
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:356
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
size_t args_size() const
Definition: Record.h:1249
"foo" - Represent an initialization by a string value.
Definition: Record.h:594
unsigned getNumOperands() const override
Definition: Record.h:836
void addExtraGlobal(StringRef Name, Init *I)
Definition: Record.h:1724
Init * getRHS() const
Definition: Record.h:847
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1856
static ManagedStatic< OptionRegistry > OR
Definition: Options.cpp:30
ArrayRef< Init * > args() const
Definition: Record.h:1252
!op (X) - Transform an init.
Definition: Record.h:752
bool val_empty() const
Definition: Record.h:992
Init * getOperand(unsigned i) const override
Definition: Record.h:893
StringInit * getFieldName() const
Definition: Record.h:1280
const std::string getNameInitAsString() const
Definition: Record.h:1478
bool getPrefix() const
Definition: Record.h:1404
SmallVector< std::pair< bool, StringRef >, 4 > Parts
Definition: Record.h:1773
bool name_empty() const
Definition: Record.h:1376
void dump() const
Definition: Record.cpp:60
See the file comment for details on the usage of the TrailingObjects type.
size_t case_size() const
Definition: Record.h:985
StringRef getValueAsString(StringRef FieldName) const
This method looks up the specified field and returns its value as a string, throwing an exception if ...
Definition: Record.cpp:2162
OpInit * clone(ArrayRef< Init *> Operands) const override
Definition: Record.h:885
UnaryOp getOpcode() const
Definition: Record.h:788
static bool classof(const Init *I)
Definition: Record.h:766
virtual ~RecTy()=default
int64_t getValue() const
Definition: Record.h:580
void EmitJSON(RecordKeeper &RK, raw_ostream &OS)
&#39;string&#39; - Represent an string value
Definition: Record.h:176
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:1199
static BitInit * get(bool V)
Definition: Record.cpp:311
size_t arg_size() const
Definition: Record.h:1369
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:479
const RecordVal * getValue(StringRef Name) const
Definition: Record.h:1520
static bool classof(const Init *I)
Definition: Record.h:874
DefInit * getDefInit()
get the corresponding DefInit.
Definition: Record.cpp:2041
std::string getAsUnquotedString() const override
Convert this value to a string form, without adding quote markers.
Definition: Record.h:652
virtual ~Resolver()
Definition: Record.h:1862
iterator erase(const_iterator CI)
Definition: SmallVector.h:434
size_t size() const
Definition: SmallVector.h:52
StringInit * getName() const
Definition: Record.h:1327
static wasm::ValType getType(const TargetRegisterClass *RC)
bool isComplete() const override
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:911
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:473
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static bool classof(const Init *I)
Definition: Record.h:464
static RecordRecTy * get(ArrayRef< Record *> Classes)
Get the record type with the given non-redundant list of superclasses.
Definition: Record.cpp:157
Record(Init *N, ArrayRef< SMLoc > locs, RecordKeeper &records, bool Anonymous=false, bool Class=false)
Definition: Record.h:1448
Delegate resolving to a sub-resolver, but shadow some variable names.
Definition: Record.h:1936
void setFinal(bool Final)
Definition: Record.h:1880
virtual Init * resolveReferences(Resolver &R) const
This method is used by classes that refer to other variables which may not be defined at the time the...
Definition: Record.h:410
void addTemplateArg(Init *Name)
Definition: Record.h:1532
static bool classof(const Init *I)
Definition: Record.h:604
virtual bool typeIsA(const RecTy *RHS) const
Return true if &#39;this&#39; type is equal to or a subtype of RHS.
Definition: Record.cpp:74
const RecordVal * getValue(const Init *Name) const
Definition: Record.h:1514
SmallVectorImpl< Init * >::const_iterator const_case_iterator
Definition: Record.h:979
const RecordMap & getClasses() const
Definition: Record.h:1690
Init * getOperator() const
Definition: Record.h:1325
Init * getMHS() const
Definition: Record.h:904
TrackUnresolvedResolver(Resolver *R=nullptr)
Definition: Record.h:1962
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
RecordVal * getValue(StringRef Name)
Definition: Record.h:1528
static StringInit * get(StringRef)
Definition: Record.cpp:533
static bool classof(const RecTy *RT)
Definition: Record.h:146
static bool classof(const RecTy *RT)
Definition: Record.h:124
RecordKeeper & getRecords() const
Definition: Record.h:1599
const_case_iterator arg_begin() const
Definition: Record.h:982
unsigned getNumArgs() const
Definition: Record.h:1333
bool isSubClassOf(StringRef Name) const
Definition: Record.h:1562
unsigned getID() const
Definition: Record.h:1470
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
uint8_t Opc
Definition: Record.h:334
RecTy * getElementType() const
Definition: Record.h:690
classname<targs...> - Represent an uninstantiated anonymous class instantiation.
Definition: Record.h:1209
#define NC
Definition: regutils.h:42
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:588
bool arg_empty() const
Definition: Record.h:1370
static unsigned getNewUID()
Definition: Record.h:1468
!isa<type>(expr) - Dynamically determine the type of an expression.
Definition: Record.h:1035
Record(StringRef N, ArrayRef< SMLoc > locs, RecordKeeper &records, bool Class=false)
Definition: Record.h:1455
void removeValue(Init *Name)
Definition: Record.h:1542
const SMLoc & getLoc() const
Definition: Record.h:643
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1804
static bool classof(const Init *I)
Definition: Record.h:679
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:557
&#39;int&#39; - Represent an integer value of no particular size
Definition: Record.h:158
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:648
OpInit * clone(ArrayRef< Init *> Operands) const override
Definition: Record.h:775
InitKind getKind() const
Definition: Record.h:340
static bool ascii_isdigit(char x)
Definition: Record.h:1770
void appendLoc(SMLoc Loc)
Definition: Record.h:1485
RecTy * getValType() const
Definition: Record.h:949
bool isDigit(char C)
Checks if character C is one of the 10 decimal digits.
Definition: StringExtras.h:76
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:411
std::string getNameInitAsString() const
Definition: Record.h:1088
std::string getAsString() const override
Definition: Record.h:170
Init * getNameInit() const
Definition: Record.h:1474
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:135
size_t name_size() const
Definition: Record.h:1375
TypedInit(InitKind K, RecTy *T, uint8_t Opc=0)
Definition: Record.h:429
Do not resolve anything, but keep track of whether a given variable was referenced.
Definition: Record.h:1972
Init * getGlobal(StringRef Name) const
Definition: Record.h:1703
Init * getBit(unsigned B) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:1134
Record *const * const_record_iterator
Definition: Record.h:266
static DagRecTy * get()
Definition: Record.h:228
void addValue(const RecordVal &RV)
Definition: Record.h:1537
ArrayRef< Init * > getConds() const
Definition: Record.h:963
const NodeList & List
Definition: RDFGraph.cpp:201
static TernOpInit * get(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type)
Definition: Record.cpp:1054
const_iterator begin() const
Definition: Record.h:714
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
RecTy * resolveTypes(RecTy *T1, RecTy *T2)
Find a common type that T1 and T2 convert to.
Definition: Record.cpp:262
Opcode{0} - Represent access to one bit of a variable or field.
Definition: Record.h:1105
bool isComplete() const override
This virtual method should be overridden by values that may not be completely specified yet...
Definition: Record.h:477
&#39;Opcode&#39; - Represent a reference to an entire variable object.
Definition: Record.h:1068
Init(InitKind K, uint8_t Opc=0)
Definition: Record.h:343
uint32_t Size
Definition: Profile.cpp:46
&#39;bit&#39; - Represent a single bit
Definition: Record.h:100
!op (X, Y, Z) - Combine two inits.
Definition: Record.h:859
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
static bool classof(const Init *I)
Definition: Record.h:940
RecordValResolver(Record &R, const RecordVal *RV)
Definition: Record.h:1925
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2038
Init * getOperand(unsigned i) const override
Definition: Record.h:837
const_name_iterator name_begin() const
Definition: Record.h:1372
virtual bool keepUnsetBits() const
Definition: Record.h:1873
RecTyKind getRecTyKind() const
Definition: Record.h:76
virtual bool typeIsConvertibleTo(const RecTy *RHS) const
Return true if all values of &#39;this&#39; type can be converted to the specified type.
Definition: Record.cpp:69
StringRef getValue() const
Definition: Record.h:610
&#39;dag&#39; - Represent a dag fragment
Definition: Record.h:218
unsigned getNumOperands() const override
Definition: Record.h:781
Record * getDef(StringRef Name) const
Definition: Record.h:1698
ArrayRef< StringInit * > getArgNames() const
Definition: Record.h:1354
static LLVM_ATTRIBUTE_ALWAYS_INLINE bool CheckType(const unsigned char *MatcherTable, unsigned &MatcherIndex, SDValue N, const TargetLowering *TLI, const DataLayout &DL)
StringRef getName() const
Definition: Record.h:1472
MapResolver(Record *CurRec=nullptr)
Definition: Record.h:1896
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:122
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:654
BinaryOp getOpcode() const
Definition: Record.h:845
TernaryOp getOpcode() const
Definition: Record.h:902
(v a, b) - Represent a DAG tree value.
Definition: Record.h:1295
virtual std::string getAsString() const =0
Convert this value to a string form.
size_t size() const
Definition: Record.h:717
This header defines support for implementing classes that have some trailing object (or arrays of obj...
unsigned getNumOperands() const override
Definition: Record.h:892
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:720
const_val_iterator name_begin() const
Definition: Record.h:988
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:508
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
InitKind
Discriminator enum (for isa<>, dyn_cast<>, et al.)
Definition: Record.h:302
Init * getVal(unsigned Num) const
Definition: Record.h:958
Init *const * const_iterator
Definition: Record.h:666
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
bool isConcrete() const override
Is this a concrete and fully resolved value without any references or stuck operations? Unset values are concrete.
Definition: Record.h:507
std::string getAsUnquotedString() const override
Convert this value to a string form, without adding quote markers.
Definition: Record.h:617
static bool classof(const Init *I)
Definition: Record.h:1314
Init * getBit(unsigned Bit) const override
This method is used to return the initializer for the specified bit.
Definition: Record.h:502
std::string getAsString() const override
Convert this value to a string form.
Definition: Record.h:1287
Init * getLHS() const
Definition: Record.h:903
virtual std::string getAsString() const =0
Represents a location in source code.
Definition: SMLoc.h:23
ListRecTy * getListTy()
Returns the type representing list<this>.
Definition: Record.cpp:63
Init * getNameInit() const
Definition: Record.h:1086
const_arg_iterator arg_begin() const
Definition: Record.h:1366
Init * getRecord() const
Definition: Record.h:1279
Record(const Record &O)
Definition: Record.h:1462
StringRef getArgNameStr(unsigned Num) const
Definition: Record.h:1345
bool isValueUnset(StringRef FieldName) const
Return true if the named field is unset.
Definition: Record.h:1619
const RecordMap & getDefs() const
Definition: Record.h:1691
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
#define T1
Init * resolve(Init *VarName) override
Return the initializer for the given variable name (should normally be a StringInit), or nullptr if the name could not be resolved.
Definition: Record.h:1948
static bool classof(const Init *I)
Definition: Record.h:1078
static IntRecTy * get()
Definition: Record.h:168
const_arg_iterator arg_end() const
Definition: Record.h:1367
Init * resolve(Init *VarName) override
Return the initializer for the given variable name (should normally be a StringInit), or nullptr if the name could not be resolved.
Definition: Record.h:1928
static bool classof(const Init *I)
Definition: Record.h:1227
ShadowResolver(Resolver &R)
Definition: Record.h:1941