1 //===- CodeGenIntrinsic.h - Intrinsic Class Wrapper ------------*- 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 a wrapper class for the 'Intrinsic' TableGen class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
14 #define LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
15 
16 #include "SDNodeProperties.h"
17 #include "llvm/Support/MachineValueType.h"
18 #include <string>
19 #include <vector>
20 
21 namespace llvm {
22 class Record;
23 class RecordKeeper;
24 class CodeGenTarget;
25 
26 struct CodeGenIntrinsic {
27   Record *TheDef;             // The actual record defining this intrinsic.
28   std::string Name;           // The name of the LLVM function "llvm.bswap.i32"
29   std::string EnumName;       // The name of the enum "bswap_i32"
30   std::string GCCBuiltinName; // Name of the corresponding GCC builtin, or "".
31   std::string MSBuiltinName;  // Name of the corresponding MS builtin, or "".
32   std::string TargetPrefix;   // Target prefix, e.g. "ppc" for t-s intrinsics.
33 
34   /// This structure holds the return values and parameter values of an
35   /// intrinsic. If the number of return values is > 1, then the intrinsic
36   /// implicitly returns a first-class aggregate. The numbering of the types
37   /// starts at 0 with the first return value and continues from there through
38   /// the parameter list. This is useful for "matching" types.
39   struct IntrinsicSignature {
40     /// The MVT::SimpleValueType for each return type. Note that this list is
41     /// only populated when in the context of a target .td file. When building
42     /// Intrinsics.td, this isn't available, because we don't know the target
43     /// pointer size.
44     std::vector<MVT::SimpleValueType> RetVTs;
45 
46     /// The records for each return type.
47     std::vector<Record *> RetTypeDefs;
48 
49     /// The MVT::SimpleValueType for each parameter type. Note that this list is
50     /// only populated when in the context of a target .td file.  When building
51     /// Intrinsics.td, this isn't available, because we don't know the target
52     /// pointer size.
53     std::vector<MVT::SimpleValueType> ParamVTs;
54 
55     /// The records for each parameter type.
56     std::vector<Record *> ParamTypeDefs;
57   };
58 
59   IntrinsicSignature IS;
60 
61   /// Bit flags describing the type (ref/mod) and location of memory
62   /// accesses that may be performed by the intrinsics. Analogous to
63   /// \c FunctionModRefBehaviour.
64   enum ModRefBits {
65     /// The intrinsic may access memory that is otherwise inaccessible via
66     /// LLVM IR.
67     MR_InaccessibleMem = 1,
68 
69     /// The intrinsic may access memory through pointer arguments.
70     /// LLVM IR.
71     MR_ArgMem = 2,
72 
73     /// The intrinsic may access memory anywhere, i.e. it is not restricted
74     /// to access through pointer arguments.
75     MR_Anywhere = 4 | MR_ArgMem | MR_InaccessibleMem,
76 
77     /// The intrinsic may read memory.
78     MR_Ref = 8,
79 
80     /// The intrinsic may write memory.
81     MR_Mod = 16,
82 
83     /// The intrinsic may both read and write memory.
84     MR_ModRef = MR_Ref | MR_Mod,
85   };
86 
87   /// Memory mod/ref behavior of this intrinsic, corresponding to intrinsic
88   /// properties (IntrReadMem, IntrArgMemOnly, etc.).
89   enum ModRefBehavior {
90     NoMem = 0,
91     ReadArgMem = MR_Ref | MR_ArgMem,
92     ReadInaccessibleMem = MR_Ref | MR_InaccessibleMem,
93     ReadInaccessibleMemOrArgMem = MR_Ref | MR_ArgMem | MR_InaccessibleMem,
94     ReadMem = MR_Ref | MR_Anywhere,
95     WriteArgMem = MR_Mod | MR_ArgMem,
96     WriteInaccessibleMem = MR_Mod | MR_InaccessibleMem,
97     WriteInaccessibleMemOrArgMem = MR_Mod | MR_ArgMem | MR_InaccessibleMem,
98     WriteMem = MR_Mod | MR_Anywhere,
99     ReadWriteArgMem = MR_ModRef | MR_ArgMem,
100     ReadWriteInaccessibleMem = MR_ModRef | MR_InaccessibleMem,
101     ReadWriteInaccessibleMemOrArgMem = MR_ModRef | MR_ArgMem |
102                                        MR_InaccessibleMem,
103     ReadWriteMem = MR_ModRef | MR_Anywhere,
104   };
105   ModRefBehavior ModRef;
106 
107   /// SDPatternOperator Properties applied to the intrinsic.
108   unsigned Properties;
109 
110   /// This is set to true if the intrinsic is overloaded by its argument
111   /// types.
112   bool isOverloaded;
113 
114   /// True if the intrinsic is commutative.
115   bool isCommutative;
116 
117   /// True if the intrinsic can throw.
118   bool canThrow;
119 
120   /// True if the intrinsic is marked as noduplicate.
121   bool isNoDuplicate;
122 
123   /// True if the intrinsic is no-return.
124   bool isNoReturn;
125 
126   /// True if the intrinsic is no-sync.
127   bool isNoSync;
128 
129   /// True if the intrinsic is no-free.
130   bool isNoFree;
131 
132   /// True if the intrinsic is will-return.
133   bool isWillReturn;
134 
135   /// True if the intrinsic is cold.
136   bool isCold;
137 
138   /// True if the intrinsic is marked as convergent.
139   bool isConvergent;
140 
141   /// True if the intrinsic has side effects that aren't captured by any
142   /// of the other flags.
143   bool hasSideEffects;
144 
145   // True if the intrinsic is marked as speculatable.
146   bool isSpeculatable;
147 
148   enum ArgAttrKind {
149     NoCapture,
150     NoAlias,
151     NoUndef,
152     Returned,
153     ReadOnly,
154     WriteOnly,
155     ReadNone,
156     ImmArg,
157     Alignment
158   };
159 
160   struct ArgAttribute {
161     unsigned Index;
162     ArgAttrKind Kind;
163     uint64_t Value;
164 
165     ArgAttribute(unsigned Idx, ArgAttrKind K, uint64_t V)
166         : Index(Idx), Kind(K), Value(V) {}
167 
168     bool operator<(const ArgAttribute &Other) const {
169       return std::tie(Index, Kind, Value) <
170              std::tie(Other.Index, Other.Kind, Other.Value);
171     }
172   };
173 
174   std::vector<ArgAttribute> ArgumentAttributes;
175 
176   bool hasProperty(enum SDNP Prop) const {
177     return Properties & (1 << Prop);
178   }
179 
180   /// Goes through all IntrProperties that have IsDefault
181   /// value set and sets the property.
182   void setDefaultProperties(Record *R, std::vector<Record *> DefaultProperties);
183 
184   /// Helper function to set property \p Name to true;
185   void setProperty(Record *R);
186 
187   /// Returns true if the parameter at \p ParamIdx is a pointer type. Returns
188   /// false if the parameter is not a pointer, or \p ParamIdx is greater than
189   /// the size of \p IS.ParamVTs.
190   ///
191   /// Note that this requires that \p IS.ParamVTs is available.
192   bool isParamAPointer(unsigned ParamIdx) const;
193 
194   bool isParamImmArg(unsigned ParamIdx) const;
195 
196   CodeGenIntrinsic(Record *R, std::vector<Record *> DefaultProperties);
197 };
198 
199 class CodeGenIntrinsicTable {
200   std::vector<CodeGenIntrinsic> Intrinsics;
201 
202 public:
203   struct TargetSet {
204     std::string Name;
205     size_t Offset;
206     size_t Count;
207   };
208   std::vector<TargetSet> Targets;
209 
210   explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
211   CodeGenIntrinsicTable() = default;
212 
213   bool empty() const { return Intrinsics.empty(); }
214   size_t size() const { return Intrinsics.size(); }
215   CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
216   const CodeGenIntrinsic &operator[](size_t Pos) const {
217     return Intrinsics[Pos];
218   }
219 };
220 }
221 
222 #endif
223