• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- CodeGenIntrinsic.h - Intrinsic Class Wrapper ------------*- C++ -*--===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines a wrapper class for the 'Intrinsic' TableGen class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
15 #define LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
16 
17 #include "SDNodeProperties.h"
18 #include "llvm/Support/MachineValueType.h"
19 #include <string>
20 #include <vector>
21 
22 namespace llvm {
23 class Record;
24 class RecordKeeper;
25 class CodeGenTarget;
26 
27 struct CodeGenIntrinsic {
28   Record *TheDef;             // The actual record defining this intrinsic.
29   std::string Name;           // The name of the LLVM function "llvm.bswap.i32"
30   std::string EnumName;       // The name of the enum "bswap_i32"
31   std::string GCCBuiltinName; // Name of the corresponding GCC builtin, or "".
32   std::string MSBuiltinName;  // Name of the corresponding MS builtin, or "".
33   std::string TargetPrefix;   // Target prefix, e.g. "ppc" for t-s intrinsics.
34 
35   /// This structure holds the return values and parameter values of an
36   /// intrinsic. If the number of return values is > 1, then the intrinsic
37   /// implicitly returns a first-class aggregate. The numbering of the types
38   /// starts at 0 with the first return value and continues from there through
39   /// the parameter list. This is useful for "matching" types.
40   struct IntrinsicSignature {
41     /// The MVT::SimpleValueType for each return type. Note that this list is
42     /// only populated when in the context of a target .td file. When building
43     /// Intrinsics.td, this isn't available, because we don't know the target
44     /// pointer size.
45     std::vector<MVT::SimpleValueType> RetVTs;
46 
47     /// The records for each return type.
48     std::vector<Record *> RetTypeDefs;
49 
50     /// The MVT::SimpleValueType for each parameter type. Note that this list is
51     /// only populated when in the context of a target .td file.  When building
52     /// Intrinsics.td, this isn't available, because we don't know the target
53     /// pointer size.
54     std::vector<MVT::SimpleValueType> ParamVTs;
55 
56     /// The records for each parameter type.
57     std::vector<Record *> ParamTypeDefs;
58   };
59 
60   IntrinsicSignature IS;
61 
62   /// Bit flags describing the type (ref/mod) and location of memory
63   /// accesses that may be performed by the intrinsics. Analogous to
64   /// \c FunctionModRefBehaviour.
65   enum ModRefBits {
66     /// The intrinsic may access memory that is otherwise inaccessible via
67     /// LLVM IR.
68     MR_InaccessibleMem = 1,
69 
70     /// The intrinsic may access memory through pointer arguments.
71     /// LLVM IR.
72     MR_ArgMem = 2,
73 
74     /// The intrinsic may access memory anywhere, i.e. it is not restricted
75     /// to access through pointer arguments.
76     MR_Anywhere = 4 | MR_ArgMem | MR_InaccessibleMem,
77 
78     /// The intrinsic may read memory.
79     MR_Ref = 8,
80 
81     /// The intrinsic may write memory.
82     MR_Mod = 16,
83 
84     /// The intrinsic may both read and write memory.
85     MR_ModRef = MR_Ref | MR_Mod,
86   };
87 
88   /// Memory mod/ref behavior of this intrinsic, corresponding to intrinsic
89   /// properties (IntrReadMem, IntrArgMemOnly, etc.).
90   enum ModRefBehavior {
91     NoMem = 0,
92     ReadArgMem = MR_Ref | MR_ArgMem,
93     ReadInaccessibleMem = MR_Ref | MR_InaccessibleMem,
94     ReadInaccessibleMemOrArgMem = MR_Ref | MR_ArgMem | MR_InaccessibleMem,
95     ReadMem = MR_Ref | MR_Anywhere,
96     WriteArgMem = MR_Mod | MR_ArgMem,
97     WriteInaccessibleMem = MR_Mod | MR_InaccessibleMem,
98     WriteInaccessibleMemOrArgMem = MR_Mod | MR_ArgMem | MR_InaccessibleMem,
99     WriteMem = MR_Mod | MR_Anywhere,
100     ReadWriteArgMem = MR_ModRef | MR_ArgMem,
101     ReadWriteInaccessibleMem = MR_ModRef | MR_InaccessibleMem,
102     ReadWriteInaccessibleMemOrArgMem = MR_ModRef | MR_ArgMem |
103                                        MR_InaccessibleMem,
104     ReadWriteMem = MR_ModRef | MR_Anywhere,
105   };
106   ModRefBehavior ModRef;
107 
108   /// SDPatternOperator Properties applied to the intrinsic.
109   unsigned Properties;
110 
111   /// This is set to true if the intrinsic is overloaded by its argument
112   /// types.
113   bool isOverloaded;
114 
115   /// True if the intrinsic is commutative.
116   bool isCommutative;
117 
118   /// True if the intrinsic can throw.
119   bool canThrow;
120 
121   /// True if the intrinsic is marked as noduplicate.
122   bool isNoDuplicate;
123 
124   /// True if the intrinsic is no-return.
125   bool isNoReturn;
126 
127   /// True if the intrinsic is marked as convergent.
128   bool isConvergent;
129 
130   /// True if the intrinsic has side effects that aren't captured by any
131   /// of the other flags.
132   bool hasSideEffects;
133 
134   // True if the intrinsic is marked as speculatable.
135   bool isSpeculatable;
136 
137   enum ArgAttribute { NoCapture, Returned, ReadOnly, WriteOnly, ReadNone };
138   std::vector<std::pair<unsigned, ArgAttribute>> ArgumentAttributes;
139 
hasPropertyCodeGenIntrinsic140   bool hasProperty(enum SDNP Prop) const {
141     return Properties & (1 << Prop);
142   }
143 
144   CodeGenIntrinsic(Record *R);
145 };
146 
147 class CodeGenIntrinsicTable {
148   std::vector<CodeGenIntrinsic> Intrinsics;
149 
150 public:
151   struct TargetSet {
152     std::string Name;
153     size_t Offset;
154     size_t Count;
155   };
156   std::vector<TargetSet> Targets;
157 
158   explicit CodeGenIntrinsicTable(const RecordKeeper &RC, bool TargetOnly);
159   CodeGenIntrinsicTable() = default;
160 
empty()161   bool empty() const { return Intrinsics.empty(); }
size()162   size_t size() const { return Intrinsics.size(); }
163   CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
164   const CodeGenIntrinsic &operator[](size_t Pos) const {
165     return Intrinsics[Pos];
166   }
167 };
168 }
169 
170 #endif
171