LLVM  10.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
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
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
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 #ifndef NDEBUG
1267  if (!getType()) {
1268  llvm::errs() << "In Record = " << Rec->getAsString()
1269  << ", got FieldName = " << *FieldName
1270  << " with non-record type!\n";
1271  llvm_unreachable("FieldInit with non-record type!");
1272  }
1273 #endif
1274  }
1275 
1276 public:
1277  FieldInit(const FieldInit &) = delete;
1278  FieldInit &operator=(const FieldInit &) = delete;
1279 
1280  static bool classof(const Init *I) {
1281  return I->getKind() == IK_FieldInit;
1282  }
1283 
1284  static FieldInit *get(Init *R, StringInit *FN);
1285 
1286  Init *getRecord() const { return Rec; }
1287  StringInit *getFieldName() const { return FieldName; }
1288 
1289  Init *getBit(unsigned Bit) const override;
1290 
1291  Init *resolveReferences(Resolver &R) const override;
1292  Init *Fold(Record *CurRec) const;
1293 
1294  std::string getAsString() const override {
1295  return Rec->getAsString() + "." + FieldName->getValue().str();
1296  }
1297 };
1298 
1299 /// (v a, b) - Represent a DAG tree value. DAG inits are required
1300 /// to have at least one value then a (possibly empty) list of arguments. Each
1301 /// argument can have a name associated with it.
1302 class DagInit final : public TypedInit, public FoldingSetNode,
1303  public TrailingObjects<DagInit, Init *, StringInit *> {
1304  friend TrailingObjects;
1305 
1306  Init *Val;
1307  StringInit *ValName;
1308  unsigned NumArgs;
1309  unsigned NumArgNames;
1310 
1311  DagInit(Init *V, StringInit *VN, unsigned NumArgs, unsigned NumArgNames)
1312  : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN),
1313  NumArgs(NumArgs), NumArgNames(NumArgNames) {}
1314 
1315  size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; }
1316 
1317 public:
1318  DagInit(const DagInit &) = delete;
1319  DagInit &operator=(const DagInit &) = delete;
1320 
1321  static bool classof(const Init *I) {
1322  return I->getKind() == IK_DagInit;
1323  }
1324 
1325  static DagInit *get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
1326  ArrayRef<StringInit*> NameRange);
1327  static DagInit *get(Init *V, StringInit *VN,
1329 
1330  void Profile(FoldingSetNodeID &ID) const;
1331 
1332  Init *getOperator() const { return Val; }
1333  Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const;
1334 
1335  StringInit *getName() const { return ValName; }
1336 
1338  return ValName ? ValName->getValue() : StringRef();
1339  }
1340 
1341  unsigned getNumArgs() const { return NumArgs; }
1342 
1343  Init *getArg(unsigned Num) const {
1344  assert(Num < NumArgs && "Arg number out of range!");
1345  return getTrailingObjects<Init *>()[Num];
1346  }
1347 
1348  StringInit *getArgName(unsigned Num) const {
1349  assert(Num < NumArgNames && "Arg number out of range!");
1350  return getTrailingObjects<StringInit *>()[Num];
1351  }
1352 
1353  StringRef getArgNameStr(unsigned Num) const {
1354  StringInit *Init = getArgName(Num);
1355  return Init ? Init->getValue() : StringRef();
1356  }
1357 
1359  return makeArrayRef(getTrailingObjects<Init *>(), NumArgs);
1360  }
1361 
1363  return makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames);
1364  }
1365 
1366  Init *resolveReferences(Resolver &R) const override;
1367 
1368  bool isConcrete() const override;
1369  std::string getAsString() const override;
1370 
1373 
1374  inline const_arg_iterator arg_begin() const { return getArgs().begin(); }
1375  inline const_arg_iterator arg_end () const { return getArgs().end(); }
1376 
1377  inline size_t arg_size () const { return NumArgs; }
1378  inline bool arg_empty() const { return NumArgs == 0; }
1379 
1380  inline const_name_iterator name_begin() const { return getArgNames().begin();}
1381  inline const_name_iterator name_end () const { return getArgNames().end(); }
1382 
1383  inline size_t name_size () const { return NumArgNames; }
1384  inline bool name_empty() const { return NumArgNames == 0; }
1385 
1386  Init *getBit(unsigned Bit) const override {
1387  llvm_unreachable("Illegal bit reference off dag");
1388  }
1389 };
1390 
1391 //===----------------------------------------------------------------------===//
1392 // High-Level Classes
1393 //===----------------------------------------------------------------------===//
1394 
1395 class RecordVal {
1396  friend class Record;
1397 
1398  Init *Name;
1400  Init *Value;
1401 
1402 public:
1403  RecordVal(Init *N, RecTy *T, bool P);
1404 
1405  StringRef getName() const;
1406  Init *getNameInit() const { return Name; }
1407 
1408  std::string getNameInitAsString() const {
1409  return getNameInit()->getAsUnquotedString();
1410  }
1411 
1412  bool getPrefix() const { return TyAndPrefix.getInt(); }
1413  RecTy *getType() const { return TyAndPrefix.getPointer(); }
1414  Init *getValue() const { return Value; }
1415 
1416  bool setValue(Init *V);
1417 
1418  void dump() const;
1419  void print(raw_ostream &OS, bool PrintSem = true) const;
1420 };
1421 
1422 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
1423  RV.print(OS << " ");
1424  return OS;
1425 }
1426 
1427 class Record {
1428  static unsigned LastID;
1429 
1430  Init *Name;
1431  // Location where record was instantiated, followed by the location of
1432  // multiclass prototypes used.
1433  SmallVector<SMLoc, 4> Locs;
1436 
1437  // All superclasses in the inheritance forest in reverse preorder (yes, it
1438  // must be a forest; diamond-shaped inheritance is not allowed).
1440 
1441  // Tracks Record instances. Not owned by Record.
1442  RecordKeeper &TrackedRecords;
1443 
1444  DefInit *TheInit = nullptr;
1445 
1446  // Unique record ID.
1447  unsigned ID;
1448 
1449  bool IsAnonymous;
1450  bool IsClass;
1451 
1452  void checkName();
1453 
1454 public:
1455  // Constructs a record.
1456  explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1457  bool Anonymous = false, bool Class = false)
1458  : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records),
1459  ID(LastID++), IsAnonymous(Anonymous), IsClass(Class) {
1460  checkName();
1461  }
1462 
1463  explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records,
1464  bool Class = false)
1465  : Record(StringInit::get(N), locs, records, false, Class) {}
1466 
1467  // When copy-constructing a Record, we must still guarantee a globally unique
1468  // ID number. Don't copy TheInit either since it's owned by the original
1469  // record. All other fields can be copied normally.
1470  Record(const Record &O)
1471  : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
1472  Values(O.Values), SuperClasses(O.SuperClasses),
1473  TrackedRecords(O.TrackedRecords), ID(LastID++),
1474  IsAnonymous(O.IsAnonymous), IsClass(O.IsClass) { }
1475 
1476  static unsigned getNewUID() { return LastID++; }
1477 
1478  unsigned getID() const { return ID; }
1479 
1480  StringRef getName() const { return cast<StringInit>(Name)->getValue(); }
1481 
1482  Init *getNameInit() const {
1483  return Name;
1484  }
1485 
1486  const std::string getNameInitAsString() const {
1487  return getNameInit()->getAsUnquotedString();
1488  }
1489 
1490  void setName(Init *Name); // Also updates RecordKeeper.
1491 
1492  ArrayRef<SMLoc> getLoc() const { return Locs; }
1493  void appendLoc(SMLoc Loc) { Locs.push_back(Loc); }
1494 
1495  // Make the type that this record should have based on its superclasses.
1496  RecordRecTy *getType();
1497 
1498  /// get the corresponding DefInit.
1499  DefInit *getDefInit();
1500 
1501  bool isClass() const { return IsClass; }
1502 
1504  return TemplateArgs;
1505  }
1506 
1507  ArrayRef<RecordVal> getValues() const { return Values; }
1508 
1510  return SuperClasses;
1511  }
1512 
1513  /// Append the direct super classes of this record to Classes.
1514  void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
1515 
1516  bool isTemplateArg(Init *Name) const {
1517  for (Init *TA : TemplateArgs)
1518  if (TA == Name) return true;
1519  return false;
1520  }
1521 
1522  const RecordVal *getValue(const Init *Name) const {
1523  for (const RecordVal &Val : Values)
1524  if (Val.Name == Name) return &Val;
1525  return nullptr;
1526  }
1527 
1528  const RecordVal *getValue(StringRef Name) const {
1529  return getValue(StringInit::get(Name));
1530  }
1531 
1532  RecordVal *getValue(const Init *Name) {
1533  return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
1534  }
1535 
1537  return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
1538  }
1539 
1540  void addTemplateArg(Init *Name) {
1541  assert(!isTemplateArg(Name) && "Template arg already defined!");
1542  TemplateArgs.push_back(Name);
1543  }
1544 
1545  void addValue(const RecordVal &RV) {
1546  assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
1547  Values.push_back(RV);
1548  }
1549 
1550  void removeValue(Init *Name) {
1551  for (unsigned i = 0, e = Values.size(); i != e; ++i)
1552  if (Values[i].getNameInit() == Name) {
1553  Values.erase(Values.begin()+i);
1554  return;
1555  }
1556  llvm_unreachable("Cannot remove an entry that does not exist!");
1557  }
1558 
1559  void removeValue(StringRef Name) {
1560  removeValue(StringInit::get(Name));
1561  }
1562 
1563  bool isSubClassOf(const Record *R) const {
1564  for (const auto &SCPair : SuperClasses)
1565  if (SCPair.first == R)
1566  return true;
1567  return false;
1568  }
1569 
1570  bool isSubClassOf(StringRef Name) const {
1571  for (const auto &SCPair : SuperClasses) {
1572  if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) {
1573  if (SI->getValue() == Name)
1574  return true;
1575  } else if (SCPair.first->getNameInitAsString() == Name) {
1576  return true;
1577  }
1578  }
1579  return false;
1580  }
1581 
1582  void addSuperClass(Record *R, SMRange Range) {
1583  assert(!TheInit && "changing type of record after it has been referenced");
1584  assert(!isSubClassOf(R) && "Already subclassing record!");
1585  SuperClasses.push_back(std::make_pair(R, Range));
1586  }
1587 
1588  /// If there are any field references that refer to fields
1589  /// that have been filled in, we can propagate the values now.
1590  ///
1591  /// This is a final resolve: any error messages, e.g. due to undefined
1592  /// !cast references, are generated now.
1593  void resolveReferences();
1594 
1595  /// Apply the resolver to the name of the record as well as to the
1596  /// initializers of all fields of the record except SkipVal.
1597  ///
1598  /// The resolver should not resolve any of the fields itself, to avoid
1599  /// recursion / infinite loops.
1600  void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr);
1601 
1602  /// If anything in this record refers to RV, replace the
1603  /// reference to RV with the RHS of RV. If RV is null, we resolve all
1604  /// possible references.
1605  void resolveReferencesTo(const RecordVal *RV);
1606 
1608  return TrackedRecords;
1609  }
1610 
1611  bool isAnonymous() const {
1612  return IsAnonymous;
1613  }
1614 
1615  void print(raw_ostream &OS) const;
1616  void dump() const;
1617 
1618  //===--------------------------------------------------------------------===//
1619  // High-level methods useful to tablegen back-ends
1620  //
1621 
1622  /// Return the initializer for a value with the specified name,
1623  /// or throw an exception if the field does not exist.
1624  Init *getValueInit(StringRef FieldName) const;
1625 
1626  /// Return true if the named field is unset.
1627  bool isValueUnset(StringRef FieldName) const {
1628  return isa<UnsetInit>(getValueInit(FieldName));
1629  }
1630 
1631  /// This method looks up the specified field and returns
1632  /// its value as a string, throwing an exception if the field does not exist
1633  /// or if the value is not a string.
1634  StringRef getValueAsString(StringRef FieldName) const;
1635 
1636  /// This method looks up the specified field and returns
1637  /// its value as a BitsInit, throwing an exception if the field does not exist
1638  /// or if the value is not the right type.
1639  BitsInit *getValueAsBitsInit(StringRef FieldName) const;
1640 
1641  /// This method looks up the specified field and returns
1642  /// its value as a ListInit, throwing an exception if the field does not exist
1643  /// or if the value is not the right type.
1644  ListInit *getValueAsListInit(StringRef FieldName) const;
1645 
1646  /// This method looks up the specified field and
1647  /// returns its value as a vector of records, throwing an exception if the
1648  /// field does not exist or if the value is not the right type.
1649  std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
1650 
1651  /// This method looks up the specified field and
1652  /// returns its value as a vector of integers, throwing an exception if the
1653  /// field does not exist or if the value is not the right type.
1654  std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
1655 
1656  /// This method looks up the specified field and
1657  /// returns its value as a vector of strings, throwing an exception if the
1658  /// field does not exist or if the value is not the right type.
1659  std::vector<StringRef> getValueAsListOfStrings(StringRef FieldName) const;
1660 
1661  /// This method looks up the specified field and returns its
1662  /// value as a Record, throwing an exception if the field does not exist or if
1663  /// the value is not the right type.
1664  Record *getValueAsDef(StringRef FieldName) const;
1665 
1666  /// This method looks up the specified field and returns its
1667  /// value as a bit, throwing an exception if the field does not exist or if
1668  /// the value is not the right type.
1669  bool getValueAsBit(StringRef FieldName) const;
1670 
1671  /// This method looks up the specified field and
1672  /// returns its value as a bit. If the field is unset, sets Unset to true and
1673  /// returns false.
1674  bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const;
1675 
1676  /// This method looks up the specified field and returns its
1677  /// value as an int64_t, throwing an exception if the field does not exist or
1678  /// if the value is not the right type.
1679  int64_t getValueAsInt(StringRef FieldName) const;
1680 
1681  /// This method looks up the specified field and returns its
1682  /// value as an Dag, throwing an exception if the field does not exist or if
1683  /// the value is not the right type.
1684  DagInit *getValueAsDag(StringRef FieldName) const;
1685 };
1686 
1687 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
1688 
1690  friend class RecordRecTy;
1691  using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>;
1692  RecordMap Classes, Defs;
1693  FoldingSet<RecordRecTy> RecordTypePool;
1694  std::map<std::string, Init *, std::less<>> ExtraGlobals;
1695  unsigned AnonCounter = 0;
1696 
1697 public:
1698  const RecordMap &getClasses() const { return Classes; }
1699  const RecordMap &getDefs() const { return Defs; }
1700 
1702  auto I = Classes.find(Name);
1703  return I == Classes.end() ? nullptr : I->second.get();
1704  }
1705 
1707  auto I = Defs.find(Name);
1708  return I == Defs.end() ? nullptr : I->second.get();
1709  }
1710 
1712  if (Record *R = getDef(Name))
1713  return R->getDefInit();
1714  auto It = ExtraGlobals.find(Name);
1715  return It == ExtraGlobals.end() ? nullptr : It->second;
1716  }
1717 
1718  void addClass(std::unique_ptr<Record> R) {
1719  bool Ins = Classes.insert(std::make_pair(R->getName(),
1720  std::move(R))).second;
1721  (void)Ins;
1722  assert(Ins && "Class already exists");
1723  }
1724 
1725  void addDef(std::unique_ptr<Record> R) {
1726  bool Ins = Defs.insert(std::make_pair(R->getName(),
1727  std::move(R))).second;
1728  (void)Ins;
1729  assert(Ins && "Record already exists");
1730  }
1731 
1733  bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second;
1734  (void)Ins;
1735  assert(!getDef(Name));
1736  assert(Ins && "Global already exists");
1737  }
1738 
1739  Init *getNewAnonymousName();
1740 
1741  //===--------------------------------------------------------------------===//
1742  // High-level helper methods, useful for tablegen backends...
1743 
1744  /// This method returns all concrete definitions
1745  /// that derive from the specified class name. A class with the specified
1746  /// name must exist.
1747  std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
1748 
1749  void dump() const;
1750 };
1751 
1752 /// Sorting predicate to sort record pointers by name.
1753 struct LessRecord {
1754  bool operator()(const Record *Rec1, const Record *Rec2) const {
1755  return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
1756  }
1757 };
1758 
1759 /// Sorting predicate to sort record pointers by their
1760 /// unique ID. If you just need a deterministic order, use this, since it
1761 /// just compares two `unsigned`; the other sorting predicates require
1762 /// string manipulation.
1764  bool operator()(const Record *LHS, const Record *RHS) const {
1765  return LHS->getID() < RHS->getID();
1766  }
1767 };
1768 
1769 /// Sorting predicate to sort record pointers by their
1770 /// name field.
1772  bool operator()(const Record *Rec1, const Record *Rec2) const {
1773  return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
1774  }
1775 };
1776 
1778  static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; }
1779 
1780  struct RecordParts {
1782 
1784  if (Rec.empty())
1785  return;
1786 
1787  size_t Len = 0;
1788  const char *Start = Rec.data();
1789  const char *Curr = Start;
1790  bool isDigitPart = ascii_isdigit(Curr[0]);
1791  for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) {
1792  bool isDigit = ascii_isdigit(Curr[I]);
1793  if (isDigit != isDigitPart) {
1794  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1795  Len = 0;
1796  Start = &Curr[I];
1797  isDigitPart = ascii_isdigit(Curr[I]);
1798  }
1799  }
1800  // Push the last part.
1801  Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
1802  }
1803 
1804  size_t size() { return Parts.size(); }
1805 
1806  std::pair<bool, StringRef> getPart(size_t i) {
1807  assert (i < Parts.size() && "Invalid idx!");
1808  return Parts[i];
1809  }
1810  };
1811 
1812  bool operator()(const Record *Rec1, const Record *Rec2) const {
1813  RecordParts LHSParts(StringRef(Rec1->getName()));
1814  RecordParts RHSParts(StringRef(Rec2->getName()));
1815 
1816  size_t LHSNumParts = LHSParts.size();
1817  size_t RHSNumParts = RHSParts.size();
1818  assert (LHSNumParts && RHSNumParts && "Expected at least one part!");
1819 
1820  if (LHSNumParts != RHSNumParts)
1821  return LHSNumParts < RHSNumParts;
1822 
1823  // We expect the registers to be of the form [_a-zA-Z]+([0-9]*[_a-zA-Z]*)*.
1824  for (size_t I = 0, E = LHSNumParts; I < E; I+=2) {
1825  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1826  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1827  // Expect even part to always be alpha.
1828  assert (LHSPart.first == false && RHSPart.first == false &&
1829  "Expected both parts to be alpha.");
1830  if (int Res = LHSPart.second.compare(RHSPart.second))
1831  return Res < 0;
1832  }
1833  for (size_t I = 1, E = LHSNumParts; I < E; I+=2) {
1834  std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
1835  std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
1836  // Expect odd part to always be numeric.
1837  assert (LHSPart.first == true && RHSPart.first == true &&
1838  "Expected both parts to be numeric.");
1839  if (LHSPart.second.size() != RHSPart.second.size())
1840  return LHSPart.second.size() < RHSPart.second.size();
1841 
1842  unsigned LHSVal, RHSVal;
1843 
1844  bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed;
1845  assert(!LHSFailed && "Unable to convert LHS to integer.");
1846  bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed;
1847  assert(!RHSFailed && "Unable to convert RHS to integer.");
1848 
1849  if (LHSVal != RHSVal)
1850  return LHSVal < RHSVal;
1851  }
1852  return LHSNumParts < RHSNumParts;
1853  }
1854 };
1855 
1857 
1858 //===----------------------------------------------------------------------===//
1859 // Resolvers
1860 //===----------------------------------------------------------------------===//
1861 
1862 /// Interface for looking up the initializer for a variable name, used by
1863 /// Init::resolveReferences.
1864 class Resolver {
1865  Record *CurRec;
1866  bool IsFinal = false;
1867 
1868 public:
1869  explicit Resolver(Record *CurRec) : CurRec(CurRec) {}
1870  virtual ~Resolver() {}
1871 
1872  Record *getCurrentRecord() const { return CurRec; }
1873 
1874  /// Return the initializer for the given variable name (should normally be a
1875  /// StringInit), or nullptr if the name could not be resolved.
1876  virtual Init *resolve(Init *VarName) = 0;
1877 
1878  // Whether bits in a BitsInit should stay unresolved if resolving them would
1879  // result in a ? (UnsetInit). This behavior is used to represent instruction
1880  // encodings by keeping references to unset variables within a record.
1881  virtual bool keepUnsetBits() const { return false; }
1882 
1883  // Whether this is the final resolve step before adding a record to the
1884  // RecordKeeper. Error reporting during resolve and related constant folding
1885  // should only happen when this is true.
1886  bool isFinal() const { return IsFinal; }
1887 
1888  void setFinal(bool Final) { IsFinal = Final; }
1889 };
1890 
1891 /// Resolve arbitrary mappings.
1892 class MapResolver final : public Resolver {
1893  struct MappedValue {
1894  Init *V;
1895  bool Resolved;
1896 
1897  MappedValue() : V(nullptr), Resolved(false) {}
1898  MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {}
1899  };
1900 
1902 
1903 public:
1904  explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {}
1905 
1906  void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; }
1907 
1908  Init *resolve(Init *VarName) override;
1909 };
1910 
1911 /// Resolve all variables from a record except for unset variables.
1912 class RecordResolver final : public Resolver {
1914  SmallVector<Init *, 4> Stack;
1915 
1916 public:
1917  explicit RecordResolver(Record &R) : Resolver(&R) {}
1918 
1919  Init *resolve(Init *VarName) override;
1920 
1921  bool keepUnsetBits() const override { return true; }
1922 };
1923 
1924 /// Resolve all references to a specific RecordVal.
1925 //
1926 // TODO: This is used for resolving references to template arguments, in a
1927 // rather inefficient way. Change those uses to resolve all template
1928 // arguments simultaneously and get rid of this class.
1929 class RecordValResolver final : public Resolver {
1930  const RecordVal *RV;
1931 
1932 public:
1933  explicit RecordValResolver(Record &R, const RecordVal *RV)
1934  : Resolver(&R), RV(RV) {}
1935 
1936  Init *resolve(Init *VarName) override {
1937  if (VarName == RV->getNameInit())
1938  return RV->getValue();
1939  return nullptr;
1940  }
1941 };
1942 
1943 /// Delegate resolving to a sub-resolver, but shadow some variable names.
1944 class ShadowResolver final : public Resolver {
1945  Resolver &R;
1946  DenseSet<Init *> Shadowed;
1947 
1948 public:
1950  : Resolver(R.getCurrentRecord()), R(R) {
1951  setFinal(R.isFinal());
1952  }
1953 
1954  void addShadow(Init *Key) { Shadowed.insert(Key); }
1955 
1956  Init *resolve(Init *VarName) override {
1957  if (Shadowed.count(VarName))
1958  return nullptr;
1959  return R.resolve(VarName);
1960  }
1961 };
1962 
1963 /// (Optionally) delegate resolving to a sub-resolver, and keep track whether
1964 /// there were unresolved references.
1965 class TrackUnresolvedResolver final : public Resolver {
1966  Resolver *R;
1967  bool FoundUnresolved = false;
1968 
1969 public:
1970  explicit TrackUnresolvedResolver(Resolver *R = nullptr)
1971  : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {}
1972 
1973  bool foundUnresolved() const { return FoundUnresolved; }
1974 
1975  Init *resolve(Init *VarName) override;
1976 };
1977 
1978 /// Do not resolve anything, but keep track of whether a given variable was
1979 /// referenced.
1980 class HasReferenceResolver final : public Resolver {
1981  Init *VarNameToTrack;
1982  bool Found = false;
1983 
1984 public:
1985  explicit HasReferenceResolver(Init *VarNameToTrack)
1986  : Resolver(nullptr), VarNameToTrack(VarNameToTrack) {}
1987 
1988  bool found() const { return Found; }
1989 
1990  Init *resolve(Init *VarName) override;
1991 };
1992 
1993 void EmitJSON(RecordKeeper &RK, raw_ostream &OS);
1994 
1995 } // end namespace llvm
1996 
1997 #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:1532
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
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool getValue() const
Definition: Record.h:498
const_name_iterator name_end() const
Definition: Record.h:1381
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:232
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:1414
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:1753
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:1869
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:1872
bool foundUnresolved() const
Definition: Record.h:1973
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:1337
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:1771
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:1725
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:1985
size_t val_size() const
Definition: Record.h:991
Resolve all references to a specific RecordVal.
Definition: Record.h:1929
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:1559
Resolve all variables from a record except for unset variables.
Definition: Record.h:1912
&#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:1806
std::string getNameInitAsString() const
Definition: Record.h:1408
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:1965
Sorting predicate to sort record pointers by their unique ID.
Definition: Record.h:1763
static bool classof(const Init *I)
Definition: Record.h:636
Init * getArg(unsigned Num) const
Definition: Record.h:1343
ArrayRef< std::pair< Record *, SMRange > > getSuperClasses() const
Definition: Record.h:1509
&#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:1582
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:1386
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:442
Init *const * const_iterator
Definition: Record.h:1244
void addClass(std::unique_ptr< Record > R)
Definition: Record.h:1718
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:1503
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:1611
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:1754
Init * getLHS() const
Definition: Record.h:846
RecordResolver(Record &R)
Definition: Record.h:1917
mir Rename Register Operands
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
!cond(condition_1: value1, ...
Definition: Record.h:923
void print(raw_ostream &OS, bool PrintSem=true) const
Definition: Record.cpp:2022
unsigned getBitNum() const
Definition: Record.h:1129
const_iterator end() const
Definition: Record.h:715
StringInit * getArgName(unsigned Num) const
Definition: Record.h:1348
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:1764
Record * getClass(StringRef Name) const
Definition: Record.h:1701
SmallVectorImpl< Init * >::const_iterator const_arg_iterator
Definition: Record.h:1371
ArrayRef< SMLoc > getLoc() const
Definition: Record.h:1492
&#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:1516
IntType getInt() const
RecTy * getType() const
Definition: Record.h:1413
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:1563
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:1358
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:1886
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:144
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1772
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:1280
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:1507
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:1372
void addShadow(Init *Key)
Definition: Record.h:1954
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:1892
Init * getNameInit() const
Definition: Record.h:1406
bool isClass() const
Definition: Record.h:1501
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:46
bool keepUnsetBits() const override
Definition: Record.h:1921
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:1732
Init * getRHS() const
Definition: Record.h:847
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1864
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:1287
const std::string getNameInitAsString() const
Definition: Record.h:1486
bool getPrefix() const
Definition: Record.h:1412
SmallVector< std::pair< bool, StringRef >, 4 > Parts
Definition: Record.h:1781
bool name_empty() const
Definition: Record.h:1384
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
constexpr double e
Definition: MathExtras.h:57
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:2169
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:1377
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:1528
static bool classof(const Init *I)
Definition: Record.h:874
DefInit * getDefInit()
get the corresponding DefInit.
Definition: Record.cpp:2048
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:1870
iterator erase(const_iterator CI)
Definition: SmallVector.h:434
size_t size() const
Definition: SmallVector.h:52
StringInit * getName() const
Definition: Record.h:1335
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:1456
Delegate resolving to a sub-resolver, but shadow some variable names.
Definition: Record.h:1944
void setFinal(bool Final)
Definition: Record.h:1888
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:1540
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:1522
SmallVectorImpl< Init * >::const_iterator const_case_iterator
Definition: Record.h:979
const RecordMap & getClasses() const
Definition: Record.h:1698
Init * getOperator() const
Definition: Record.h:1332
Init * getMHS() const
Definition: Record.h:904
TrackUnresolvedResolver(Resolver *R=nullptr)
Definition: Record.h:1970
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:1536
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:1607
const_case_iterator arg_begin() const
Definition: Record.h:982
unsigned getNumArgs() const
Definition: Record.h:1341
bool isSubClassOf(StringRef Name) const
Definition: Record.h:1570
unsigned getID() const
Definition: Record.h:1478
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:1378
static unsigned getNewUID()
Definition: Record.h:1476
!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:1463
void removeValue(Init *Name)
Definition: Record.h:1550
const SMLoc & getLoc() const
Definition: Record.h:643
bool operator()(const Record *Rec1, const Record *Rec2) const
Definition: Record.h:1812
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:1778
void appendLoc(SMLoc Loc)
Definition: Record.h:1493
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:419
std::string getNameInitAsString() const
Definition: Record.h:1088
std::string getAsString() const override
Definition: Record.h:170
Init * getNameInit() const
Definition: Record.h:1482
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:1383
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:1980
Init * getGlobal(StringRef Name) const
Definition: Record.h:1711
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:1545
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:1933
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2047
Init * getOperand(unsigned i) const override
Definition: Record.h:837
const_name_iterator name_begin() const
Definition: Record.h:1380
virtual bool keepUnsetBits() const
Definition: Record.h:1881
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:1706
ArrayRef< StringInit * > getArgNames() const
Definition: Record.h:1362
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:1480
MapResolver(Record *CurRec=nullptr)
Definition: Record.h:1904
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:136
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:1302
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:1321
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:1294
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:1374
Init * getRecord() const
Definition: Record.h:1286
Record(const Record &O)
Definition: Record.h:1470
StringRef getArgNameStr(unsigned Num) const
Definition: Record.h:1353
bool isValueUnset(StringRef FieldName) const
Return true if the named field is unset.
Definition: Record.h:1627
const RecordMap & getDefs() const
Definition: Record.h:1699
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:1956
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:1375
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:1936
static bool classof(const Init *I)
Definition: Record.h:1227
ShadowResolver(Resolver &R)
Definition: Record.h:1949