1//===- CodeGenIntrinsics.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/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Support/ModRef.h"
20#include <string>
21#include <tuple>
22#include <vector>
23
24namespace llvm {
25class Record;
26class RecordKeeper;
27
28struct CodeGenIntrinsic {
29 Record *TheDef; // The actual record defining this intrinsic.
30 std::string Name; // The name of the LLVM function "llvm.bswap.i32"
31 std::string EnumName; // The name of the enum "bswap_i32"
32 std::string ClangBuiltinName; // Name of the corresponding GCC builtin, or "".
33 std::string MSBuiltinName; // Name of the corresponding MS builtin, or "".
34 std::string TargetPrefix; // Target prefix, e.g. "ppc" for t-s intrinsics.
35
36 /// This structure holds the return values and parameter values of an
37 /// intrinsic. If the number of return values is > 1, then the intrinsic
38 /// implicitly returns a first-class aggregate. The numbering of the types
39 /// starts at 0 with the first return value and continues from there through
40 /// the parameter list. This is useful for "matching" types.
41 struct IntrinsicSignature {
42 /// The MVT::SimpleValueType for each return type. Note that this list is
43 /// only populated when in the context of a target .td file. When building
44 /// Intrinsics.td, this isn't available, because we don't know the target
45 /// pointer size.
46 std::vector<Record *> RetTys;
47
48 /// The MVT::SimpleValueType for each parameter type. Note that this list is
49 /// only populated when in the context of a target .td file. When building
50 /// Intrinsics.td, this isn't available, because we don't know the target
51 /// pointer size.
52 std::vector<Record *> ParamTys;
53 };
54
55 IntrinsicSignature IS;
56
57 /// Memory effects of the intrinsic.
58 MemoryEffects ME = MemoryEffects::unknown();
59
60 /// SDPatternOperator Properties applied to the intrinsic.
61 unsigned Properties;
62
63 /// This is set to true if the intrinsic is overloaded by its argument
64 /// types.
65 bool isOverloaded;
66
67 /// True if the intrinsic is commutative.
68 bool isCommutative;
69
70 /// True if the intrinsic can throw.
71 bool canThrow;
72
73 /// True if the intrinsic is marked as noduplicate.
74 bool isNoDuplicate;
75
76 /// True if the intrinsic is marked as nomerge.
77 bool isNoMerge;
78
79 /// True if the intrinsic is no-return.
80 bool isNoReturn;
81
82 /// True if the intrinsic is no-callback.
83 bool isNoCallback;
84
85 /// True if the intrinsic is no-sync.
86 bool isNoSync;
87
88 /// True if the intrinsic is no-free.
89 bool isNoFree;
90
91 /// True if the intrinsic is will-return.
92 bool isWillReturn;
93
94 /// True if the intrinsic is cold.
95 bool isCold;
96
97 /// True if the intrinsic is marked as convergent.
98 bool isConvergent;
99
100 /// True if the intrinsic has side effects that aren't captured by any
101 /// of the other flags.
102 bool hasSideEffects;
103
104 // True if the intrinsic is marked as speculatable.
105 bool isSpeculatable;
106
107 // True if the intrinsic is marked as strictfp.
108 bool isStrictFP;
109
110 enum ArgAttrKind {
111 NoCapture,
112 NoAlias,
113 NoUndef,
114 NonNull,
115 Returned,
116 ReadOnly,
117 WriteOnly,
118 ReadNone,
119 ImmArg,
120 Alignment,
121 Dereferenceable
122 };
123
124 struct ArgAttribute {
125 ArgAttrKind Kind;
126 uint64_t Value;
127
128 ArgAttribute(ArgAttrKind K, uint64_t V) : Kind(K), Value(V) {}
129
130 bool operator<(const ArgAttribute &Other) const {
131 return std::tie(args: Kind, args: Value) < std::tie(args: Other.Kind, args: Other.Value);
132 }
133 };
134
135 /// Vector of attributes for each argument.
136 SmallVector<SmallVector<ArgAttribute, 0>> ArgumentAttributes;
137
138 void addArgAttribute(unsigned Idx, ArgAttrKind AK, uint64_t V = 0);
139
140 bool hasProperty(enum SDNP Prop) const { return Properties & (1 << Prop); }
141
142 /// Goes through all IntrProperties that have IsDefault
143 /// value set and sets the property.
144 void setDefaultProperties(Record *R, ArrayRef<Record *> DefaultProperties);
145
146 /// Helper function to set property \p Name to true;
147 void setProperty(Record *R);
148
149 /// Returns true if the parameter at \p ParamIdx is a pointer type. Returns
150 /// false if the parameter is not a pointer, or \p ParamIdx is greater than
151 /// the size of \p IS.ParamVTs.
152 ///
153 /// Note that this requires that \p IS.ParamVTs is available.
154 bool isParamAPointer(unsigned ParamIdx) const;
155
156 bool isParamImmArg(unsigned ParamIdx) const;
157
158 CodeGenIntrinsic(Record *R, ArrayRef<Record *> DefaultProperties);
159};
160
161class CodeGenIntrinsicTable {
162 std::vector<CodeGenIntrinsic> Intrinsics;
163
164public:
165 struct TargetSet {
166 std::string Name;
167 size_t Offset;
168 size_t Count;
169 };
170 std::vector<TargetSet> Targets;
171
172 explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
173 CodeGenIntrinsicTable() = default;
174
175 bool empty() const { return Intrinsics.empty(); }
176 size_t size() const { return Intrinsics.size(); }
177 auto begin() const { return Intrinsics.begin(); }
178 auto end() const { return Intrinsics.end(); }
179 CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
180 const CodeGenIntrinsic &operator[](size_t Pos) const {
181 return Intrinsics[Pos];
182 }
183};
184} // namespace llvm
185
186#endif
187