reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

include/llvm/TableGen/Record.h
  100 class BitRecTy : public RecTy {
  118 class BitsRecTy : public RecTy {
  140 class CodeRecTy : public RecTy {
  158 class IntRecTy : public RecTy {
  176 class StringRecTy : public RecTy {
  195 class ListRecTy : public RecTy {
  218 class DagRecTy : public RecTy {
  237 class RecordRecTy final : public RecTy, public FoldingSetNode,

Declarations

lib/TableGen/TGParser.h
   27   class RecTy;

References

include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Support/Casting.h
   57   static inline bool doit(const From &Val) {
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
include/llvm/TableGen/Record.h
   84   virtual bool typeIsConvertibleTo(const RecTy *RHS) const;
   88   virtual bool typeIsA(const RecTy *RHS) const;
   94 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
  100 class BitRecTy : public RecTy {
  106   static bool classof(const RecTy *RT) {
  114   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  118 class BitsRecTy : public RecTy {
  124   static bool classof(const RecTy *RT) {
  134   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  136   bool typeIsA(const RecTy *RHS) const override;
  140 class CodeRecTy : public RecTy {
  146   static bool classof(const RecTy *RT) {
  154   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  158 class IntRecTy : public RecTy {
  164   static bool classof(const RecTy *RT) {
  172   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  176 class StringRecTy : public RecTy {
  182   static bool classof(const RecTy *RT) {
  190   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  195 class ListRecTy : public RecTy {
  198   RecTy *Ty;
  200   explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
  203   static bool classof(const RecTy *RT) {
  207   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
  208   RecTy *getElementType() const { return Ty; }
  212   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  214   bool typeIsA(const RecTy *RHS) const override;
  218 class DagRecTy : public RecTy {
  224   static bool classof(const RecTy *RT) {
  237 class RecordRecTy final : public RecTy, public FoldingSetNode,
  253   static bool classof(const RecTy *RT) {
  274   bool typeIsConvertibleTo(const RecTy *RHS) const override;
  276   bool typeIsA(const RecTy *RHS) const override;
  281 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
  281 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
  281 RecTy *resolveTypes(RecTy *T1, RecTy *T2);
  376   virtual Init *getCastTo(RecTy *Ty) const = 0;
  381   virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
  402   virtual RecTy *getFieldType(StringInit *FieldName) const {
  426   RecTy *Ty;
  429   explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0)
  441   RecTy *getType() const { return Ty; }
  443   Init *getCastTo(RecTy *Ty) const override;
  444   Init *convertInitializerTo(RecTy *Ty) const override;
  453   RecTy *getFieldType(StringInit *FieldName) const override;
  470   Init *getCastTo(RecTy *Ty) const override;
  471   Init *convertInitializerTo(RecTy *Ty) const override;
  500   Init *convertInitializerTo(RecTy *Ty) const override;
  537   Init *convertInitializerTo(RecTy *Ty) const override;
  582   Init *convertInitializerTo(RecTy *Ty) const override;
  612   Init *convertInitializerTo(RecTy *Ty) const override;
  645   Init *convertInitializerTo(RecTy *Ty) const override;
  669   explicit ListInit(unsigned N, RecTy *EltTy)
  682   static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
  690   RecTy *getElementType() const {
  698   Init *convertInitializerTo(RecTy *Ty) const override;
  729   explicit OpInit(InitKind K, RecTy *Type, uint8_t Opc)
  759   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
  770   static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
  810   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
  822                         RecTy *Type);
  867              RecTy *Type) :
  880                          RecTy *Type);
  926   RecTy *ValType;
  928   CondOpInit(unsigned NC, RecTy *Type)
  945                         RecTy *Type);
  949   RecTy *getValType() const { return ValType; }
 1006   FoldOpInit(Init *Start, Init *List, Init *A, Init *B, Init *Expr, RecTy *Type)
 1017                          RecTy *Type);
 1037   RecTy *CheckType;
 1040   IsAOpInit(RecTy *CheckType, Init *Expr)
 1050   static IsAOpInit *get(RecTy *CheckType, Init *Expr);
 1071   explicit VarInit(Init *VN, RecTy *T)
 1082   static VarInit *get(StringRef VN, RecTy *T);
 1083   static VarInit *get(Init *VN, RecTy *T);
 1191   Init *convertInitializerTo(RecTy *Ty) const override;
 1197   RecTy *getFieldType(StringInit *FieldName) const override;
 1399   PointerIntPair<RecTy *, 1, bool> TyAndPrefix;
 1403   RecordVal(Init *N, RecTy *T, bool P);
 1413   RecTy *getType() const { return TyAndPrefix.getPointer(); }
lib/TableGen/Record.cpp
   69 bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   74 bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
   76 bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
   98 bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  105 bool BitsRecTy::typeIsA(const RecTy *RHS) const {
  111 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  116 bool CodeRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  125 bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  134 bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  140 bool ListRecTy::typeIsA(const RecTy *RHS) const {
  225 bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
  238 bool RecordRecTy::typeIsA(const RecTy *RHS) const {
  262 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
  262 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
  262 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
  278       RecTy* NewType = resolveTypes(ListTy1->getElementType(),
  303 Init *UnsetInit::getCastTo(RecTy *Ty) const {
  307 Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
  318 Init *BitInit::convertInitializerTo(RecTy *Ty) const {
  365 Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
  478 Init *IntInit::convertInitializerTo(RecTy *Ty) const {
  542 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
  551 Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
  562                             RecTy *EltTy) {
  570 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
  593   RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
  598 Init *ListInit::convertInitializerTo(RecTy *Ty) const {
  609     RecTy *ElementType = LRT->getElementType();
  687 ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
  693 UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
  818                  RecTy *Type) {
  826                           Init *RHS, RecTy *Type) {
 1046                   Init *RHS, RecTy *Type) {
 1055                             RecTy *Type) {
 1109 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
 1263                               RecTy *Type) {
 1273                             Init *Expr, RecTy *Type) {
 1332 static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
 1338 IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
 1394 RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
 1405 TypedInit::convertInitializerTo(RecTy *Ty) const {
 1432 Init *TypedInit::getCastTo(RecTy *Ty) const {
 1466 VarInit *VarInit::get(StringRef VN, RecTy *T) {
 1471 VarInit *VarInit::get(Init *VN, RecTy *T) {
 1472   using Key = std::pair<RecTy *, Init *>;
 1566 Init *DefInit::convertInitializerTo(RecTy *Ty) const {
 1573 RecTy *DefInit::getFieldType(StringInit *FieldName) const {
 1749                              const RecTy *ValType) {
 1771                 ArrayRef<Init *> ValRange, RecTy *Ty) {
 1986 RecordVal::RecordVal(Init *N, RecTy *T, bool P)
lib/TableGen/TGParser.cpp
  797 RecTy *TGParser::ParseType() {
  832     RecTy *SubType = ParseType();
  899 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
  910     RecTy *Type = nullptr;
 1019     RecTy *Type = ParseOperatorType();
 1085     RecTy *Type = nullptr;
 1086     RecTy *ArgType = nullptr;
 1150       RecTy *ListType = cast<TypedInit>(InitList.back())->getType();
 1201         RecTy *Resolved = resolveTypes(ArgType, ListType);
 1298     RecTy *InEltType = nullptr;
 1299     RecTy *OutEltType = nullptr;
 1349     RecTy *OutType;
 1369     RecTy *Type = nullptr;
 1457       RecTy *MHSTy = nullptr;
 1458       RecTy *RHSTy = nullptr;
 1642 RecTy *TGParser::ParseOperatorType() {
 1643   RecTy *Type = nullptr;
 1667 Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
 1719   RecTy *Type = nullptr;
 1721     RecTy *VTy = nullptr;
 1734         RecTy *RType = resolveTypes(Type, VTy);
 1773 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
 1857           RecTy *ExpectedType = ExpectedArg->getType();
 1934     RecTy *DeducedEltTy = nullptr;
 1958     RecTy *GivenEltTy = nullptr;
 1977     RecTy *EltTy = nullptr;
 2104 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
 2310                               Record *ArgsRec, RecTy *EltTy) {
 2311   RecTy *ItemType = EltTy;
 2378   RecTy *Type = ParseType();
 2450   RecTy *IterType = nullptr;
 2590   RecTy *Type = Field->getType();
 2726   RecTy *Type = ParseType();
lib/TableGen/TGParser.h
   73     RecTy *EltTy;
  181   Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
  183   Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
  186                       Record *ArgsRec = nullptr, RecTy *EltTy = nullptr);
  195   RecTy *ParseType();
  196   Init *ParseOperation(Record *CurRec, RecTy *ItemType);
  197   Init *ParseOperationCond(Record *CurRec, RecTy *ItemType);
  198   RecTy *ParseOperatorType();
usr/include/c++/7.4.0/type_traits
 1983     { typedef _Up     type; };
utils/TableGen/CodeGenRegisters.cpp
  641     RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl);
utils/TableGen/SearchableTableEmitter.cpp
   55   RecTy *RecType = nullptr;
  610         RecTy *Ty = resolveTypes(Field.RecType, TI->getType());