1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
//===- CodeGenIntrinsics.h - Intrinsic Class Wrapper -----------*- C++ -*--===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines a wrapper class for the 'Intrinsic' TableGen class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_UTILS_TABLEGEN_BASIC_CODEGENINTRINSICS_H
#define LLVM_UTILS_TABLEGEN_BASIC_CODEGENINTRINSICS_H
#include "SDNodeProperties.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ModRef.h"
#include <string>
#include <tuple>
#include <vector>
namespace llvm {
class Record;
class RecordKeeper;
// Global information needed to build intrinsics.
struct CodeGenIntrinsicContext {
explicit CodeGenIntrinsicContext(const RecordKeeper &RC);
std::vector<const Record *> DefaultProperties;
// Maximum number of values an intrinsic can return.
unsigned MaxNumReturn;
};
struct CodeGenIntrinsic {
const Record *TheDef; // The actual record defining this intrinsic.
std::string Name; // The name of the LLVM function "llvm.bswap.i32"
StringRef EnumName; // The name of the enum "bswap_i32"
StringRef ClangBuiltinName; // Name of the corresponding GCC builtin, or "".
StringRef MSBuiltinName; // Name of the corresponding MS builtin, or "".
StringRef TargetPrefix; // Target prefix, e.g. "ppc" for t-s intrinsics.
/// This structure holds the return values and parameter values of an
/// intrinsic. If the number of return values is > 1, then the intrinsic
/// implicitly returns a first-class aggregate. The numbering of the types
/// starts at 0 with the first return value and continues from there through
/// the parameter list. This is useful for "matching" types.
struct IntrinsicSignature {
/// The MVT::SimpleValueType for each return type. Note that this list is
/// only populated when in the context of a target .td file. When building
/// Intrinsics.td, this isn't available, because we don't know the target
/// pointer size.
std::vector<const Record *> RetTys;
/// The MVT::SimpleValueType for each parameter type. Note that this list is
/// only populated when in the context of a target .td file. When building
/// Intrinsics.td, this isn't available, because we don't know the target
/// pointer size.
std::vector<const Record *> ParamTys;
};
IntrinsicSignature IS;
/// Memory effects of the intrinsic.
MemoryEffects ME = MemoryEffects::unknown();
/// SDPatternOperator Properties applied to the intrinsic.
unsigned Properties = 0;
/// This is set to true if the intrinsic is overloaded by its argument
/// types.
bool isOverloaded = false;
/// True if the intrinsic is commutative.
bool isCommutative = false;
/// True if the intrinsic can throw.
bool canThrow = false;
/// True if the intrinsic is marked as noduplicate.
bool isNoDuplicate = false;
/// True if the intrinsic is marked as nomerge.
bool isNoMerge = false;
/// True if the intrinsic is no-return.
bool isNoReturn = false;
/// True if the intrinsic is no-callback.
bool isNoCallback = false;
/// True if the intrinsic is no-sync.
bool isNoSync = false;
/// True if the intrinsic is no-free.
bool isNoFree = false;
/// True if the intrinsic is will-return.
bool isWillReturn = false;
/// True if the intrinsic is cold.
bool isCold = false;
/// True if the intrinsic is marked as convergent.
bool isConvergent = false;
/// True if the intrinsic has side effects that aren't captured by any
/// of the other flags.
bool hasSideEffects = false;
// True if the intrinsic is marked as speculatable.
bool isSpeculatable = false;
// True if the intrinsic is marked as strictfp.
bool isStrictFP = false;
enum ArgAttrKind {
NoCapture,
NoAlias,
NoUndef,
NonNull,
Returned,
ReadOnly,
WriteOnly,
ReadNone,
ImmArg,
Alignment,
Dereferenceable,
Range,
};
struct ArgAttribute {
ArgAttrKind Kind;
uint64_t Value;
uint64_t Value2;
ArgAttribute(ArgAttrKind K, uint64_t V, uint64_t V2)
: Kind(K), Value(V), Value2(V2) {}
bool operator<(const ArgAttribute &Other) const {
return std::tie(Kind, Value, Value2) <
std::tie(Other.Kind, Other.Value, Other.Value2);
}
};
/// Vector of attributes for each argument.
SmallVector<SmallVector<ArgAttribute, 0>> ArgumentAttributes;
void addArgAttribute(unsigned Idx, ArgAttrKind AK, uint64_t V = 0,
uint64_t V2 = 0);
bool hasProperty(enum SDNP Prop) const { return Properties & (1 << Prop); }
/// Goes through all IntrProperties that have IsDefault value set and sets
/// the property.
void setDefaultProperties(ArrayRef<const Record *> DefaultProperties);
/// Helper function to set property \p Name to true.
void setProperty(const Record *R);
/// Returns true if the parameter at \p ParamIdx is a pointer type. Returns
/// false if the parameter is not a pointer, or \p ParamIdx is greater than
/// the size of \p IS.ParamVTs.
///
/// Note that this requires that \p IS.ParamVTs is available.
bool isParamAPointer(unsigned ParamIdx) const;
bool isParamImmArg(unsigned ParamIdx) const;
CodeGenIntrinsic(const Record *R, const CodeGenIntrinsicContext &Ctx);
};
class CodeGenIntrinsicTable {
public:
struct TargetSet {
StringRef Name;
size_t Offset;
size_t Count;
};
explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
bool empty() const { return Intrinsics.empty(); }
size_t size() const { return Intrinsics.size(); }
auto begin() const { return Intrinsics.begin(); }
auto end() const { return Intrinsics.end(); }
const CodeGenIntrinsic &operator[](size_t Pos) const {
return Intrinsics[Pos];
}
ArrayRef<CodeGenIntrinsic> operator[](const TargetSet &Set) const {
return ArrayRef(&Intrinsics[Set.Offset], Set.Count);
}
ArrayRef<TargetSet> getTargets() const { return Targets; }
private:
void CheckDuplicateIntrinsics() const;
void CheckTargetIndependentIntrinsics() const;
void CheckOverloadSuffixConflicts() const;
std::vector<CodeGenIntrinsic> Intrinsics;
std::vector<TargetSet> Targets;
};
// This class builds `CodeGenIntrinsic` on demand for a given Def.
class CodeGenIntrinsicMap {
DenseMap<const Record *, std::unique_ptr<CodeGenIntrinsic>> Map;
const CodeGenIntrinsicContext Ctx;
public:
explicit CodeGenIntrinsicMap(const RecordKeeper &RC) : Ctx(RC) {}
const CodeGenIntrinsic &operator[](const Record *Def);
};
} // namespace llvm
#endif // LLVM_UTILS_TABLEGEN_BASIC_CODEGENINTRINSICS_H
|
