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
|
//===- CodeGenIntrinsic.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_CODEGENINTRINSICS_H
#define LLVM_UTILS_TABLEGEN_CODEGENINTRINSICS_H
#include "SDNodeProperties.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/MachineValueType.h"
#include "llvm/Support/ModRef.h"
#include <string>
#include <vector>
namespace llvm {
class Record;
class RecordKeeper;
struct CodeGenIntrinsic {
Record *TheDef; // The actual record defining this intrinsic.
std::string Name; // The name of the LLVM function "llvm.bswap.i32"
std::string EnumName; // The name of the enum "bswap_i32"
std::string ClangBuiltinName; // Name of the corresponding GCC builtin, or "".
std::string MSBuiltinName; // Name of the corresponding MS builtin, or "".
std::string 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<MVT::SimpleValueType> RetVTs;
/// The records for each return type.
std::vector<Record *> RetTypeDefs;
/// 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<MVT::SimpleValueType> ParamVTs;
/// The records for each parameter type.
std::vector<Record *> ParamTypeDefs;
};
IntrinsicSignature IS;
/// Memory effects of the intrinsic.
MemoryEffects ME = MemoryEffects::unknown();
/// SDPatternOperator Properties applied to the intrinsic.
unsigned Properties;
/// This is set to true if the intrinsic is overloaded by its argument
/// types.
bool isOverloaded;
/// True if the intrinsic is commutative.
bool isCommutative;
/// True if the intrinsic can throw.
bool canThrow;
/// True if the intrinsic is marked as noduplicate.
bool isNoDuplicate;
/// True if the intrinsic is marked as nomerge.
bool isNoMerge;
/// True if the intrinsic is no-return.
bool isNoReturn;
/// True if the intrinsic is no-callback.
bool isNoCallback;
/// True if the intrinsic is no-sync.
bool isNoSync;
/// True if the intrinsic is no-free.
bool isNoFree;
/// True if the intrinsic is will-return.
bool isWillReturn;
/// True if the intrinsic is cold.
bool isCold;
/// True if the intrinsic is marked as convergent.
bool isConvergent;
/// True if the intrinsic has side effects that aren't captured by any
/// of the other flags.
bool hasSideEffects;
// True if the intrinsic is marked as speculatable.
bool isSpeculatable;
enum ArgAttrKind {
NoCapture,
NoAlias,
NoUndef,
NonNull,
Returned,
ReadOnly,
WriteOnly,
ReadNone,
ImmArg,
Alignment
};
struct ArgAttribute {
ArgAttrKind Kind;
uint64_t Value;
ArgAttribute(ArgAttrKind K, uint64_t V) : Kind(K), Value(V) {}
bool operator<(const ArgAttribute &Other) const {
return std::tie(Kind, Value) < std::tie(Other.Kind, Other.Value);
}
};
/// Vector of attributes for each argument.
SmallVector<SmallVector<ArgAttribute, 0>> ArgumentAttributes;
void addArgAttribute(unsigned Idx, ArgAttrKind AK, uint64_t V = 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(Record *R, std::vector<Record *> DefaultProperties);
/// Helper function to set property \p Name to true;
void setProperty(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(Record *R, std::vector<Record *> DefaultProperties);
};
class CodeGenIntrinsicTable {
std::vector<CodeGenIntrinsic> Intrinsics;
public:
struct TargetSet {
std::string Name;
size_t Offset;
size_t Count;
};
std::vector<TargetSet> Targets;
explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
CodeGenIntrinsicTable() = default;
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(); }
CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
const CodeGenIntrinsic &operator[](size_t Pos) const {
return Intrinsics[Pos];
}
};
}
#endif
|
