clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Attributes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/IR/Attributes.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | #include "llvm/IR/Attributes.h" |
16 | #include "AttributeImpl.h" |
17 | #include "LLVMContextImpl.h" |
18 | #include "llvm/ADT/ArrayRef.h" |
19 | #include "llvm/ADT/FoldingSet.h" |
20 | #include "llvm/ADT/Optional.h" |
21 | #include "llvm/ADT/STLExtras.h" |
22 | #include "llvm/ADT/SmallVector.h" |
23 | #include "llvm/ADT/StringExtras.h" |
24 | #include "llvm/ADT/StringRef.h" |
25 | #include "llvm/ADT/StringSwitch.h" |
26 | #include "llvm/ADT/Twine.h" |
27 | #include "llvm/Config/llvm-config.h" |
28 | #include "llvm/IR/Function.h" |
29 | #include "llvm/IR/LLVMContext.h" |
30 | #include "llvm/IR/Type.h" |
31 | #include "llvm/Support/Compiler.h" |
32 | #include "llvm/Support/Debug.h" |
33 | #include "llvm/Support/ErrorHandling.h" |
34 | #include "llvm/Support/MathExtras.h" |
35 | #include "llvm/Support/raw_ostream.h" |
36 | #include <algorithm> |
37 | #include <cassert> |
38 | #include <climits> |
39 | #include <cstddef> |
40 | #include <cstdint> |
41 | #include <limits> |
42 | #include <string> |
43 | #include <tuple> |
44 | #include <utility> |
45 | |
46 | using namespace llvm; |
47 | |
48 | |
49 | |
50 | |
51 | |
52 | |
53 | |
54 | |
55 | |
56 | |
57 | |
58 | static const unsigned AllocSizeNumElemsNotPresent = -1; |
59 | |
60 | static uint64_t packAllocSizeArgs(unsigned ElemSizeArg, |
61 | const Optional<unsigned> &NumElemsArg) { |
62 | assert((!NumElemsArg.hasValue() || |
63 | *NumElemsArg != AllocSizeNumElemsNotPresent) && |
64 | "Attempting to pack a reserved value"); |
65 | |
66 | return uint64_t(ElemSizeArg) << 32 | |
67 | NumElemsArg.getValueOr(AllocSizeNumElemsNotPresent); |
68 | } |
69 | |
70 | static std::pair<unsigned, Optional<unsigned>> |
71 | unpackAllocSizeArgs(uint64_t Num) { |
72 | unsigned NumElems = Num & std::numeric_limits<unsigned>::max(); |
73 | unsigned ElemSizeArg = Num >> 32; |
74 | |
75 | Optional<unsigned> NumElemsArg; |
76 | if (NumElems != AllocSizeNumElemsNotPresent) |
77 | NumElemsArg = NumElems; |
78 | return std::make_pair(ElemSizeArg, NumElemsArg); |
79 | } |
80 | |
81 | static uint64_t packVScaleRangeArgs(unsigned MinValue, unsigned MaxValue) { |
82 | return uint64_t(MinValue) << 32 | MaxValue; |
83 | } |
84 | |
85 | static std::pair<unsigned, unsigned> unpackVScaleRangeArgs(uint64_t Value) { |
86 | unsigned MaxValue = Value & std::numeric_limits<unsigned>::max(); |
87 | unsigned MinValue = Value >> 32; |
88 | |
89 | return std::make_pair(MinValue, MaxValue); |
90 | } |
91 | |
92 | Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind, |
93 | uint64_t Val) { |
94 | if (Val) |
95 | assert(Attribute::isIntAttrKind(Kind) && "Not an int attribute"); |
96 | else |
97 | assert(Attribute::isEnumAttrKind(Kind) && "Not an enum attribute"); |
98 | |
99 | LLVMContextImpl *pImpl = Context.pImpl; |
100 | FoldingSetNodeID ID; |
101 | ID.AddInteger(Kind); |
102 | if (Val) ID.AddInteger(Val); |
103 | |
104 | void *InsertPoint; |
105 | AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); |
106 | |
107 | if (!PA) { |
108 | |
109 | |
110 | if (!Val) |
111 | PA = new (pImpl->Alloc) EnumAttributeImpl(Kind); |
112 | else |
113 | PA = new (pImpl->Alloc) IntAttributeImpl(Kind, Val); |
114 | pImpl->AttrsSet.InsertNode(PA, InsertPoint); |
115 | } |
116 | |
117 | |
118 | return Attribute(PA); |
119 | } |
120 | |
121 | Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) { |
122 | LLVMContextImpl *pImpl = Context.pImpl; |
123 | FoldingSetNodeID ID; |
124 | ID.AddString(Kind); |
125 | if (!Val.empty()) ID.AddString(Val); |
126 | |
127 | void *InsertPoint; |
128 | AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); |
129 | |
130 | if (!PA) { |
131 | |
132 | |
133 | void *Mem = |
134 | pImpl->Alloc.Allocate(StringAttributeImpl::totalSizeToAlloc(Kind, Val), |
135 | alignof(StringAttributeImpl)); |
136 | PA = new (Mem) StringAttributeImpl(Kind, Val); |
137 | pImpl->AttrsSet.InsertNode(PA, InsertPoint); |
138 | } |
139 | |
140 | |
141 | return Attribute(PA); |
142 | } |
143 | |
144 | Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind, |
145 | Type *Ty) { |
146 | assert(Attribute::isTypeAttrKind(Kind) && "Not a type attribute"); |
147 | LLVMContextImpl *pImpl = Context.pImpl; |
148 | FoldingSetNodeID ID; |
149 | ID.AddInteger(Kind); |
150 | ID.AddPointer(Ty); |
151 | |
152 | void *InsertPoint; |
153 | AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint); |
154 | |
155 | if (!PA) { |
| |
| |
156 | |
157 | |
158 | PA = new (pImpl->Alloc) TypeAttributeImpl(Kind, Ty); |
| 4 | | Calling 'operator new<llvm::MallocAllocator, 4096UL, 4096UL, 128UL>' | |
|
159 | pImpl->AttrsSet.InsertNode(PA, InsertPoint); |
160 | } |
161 | |
162 | |
163 | return Attribute(PA); |
164 | } |
165 | |
166 | Attribute Attribute::getWithAlignment(LLVMContext &Context, Align A) { |
167 | assert(A <= llvm::Value::MaximumAlignment && "Alignment too large."); |
168 | return get(Context, Alignment, A.value()); |
169 | } |
170 | |
171 | Attribute Attribute::getWithStackAlignment(LLVMContext &Context, Align A) { |
172 | assert(A <= 0x100 && "Alignment too large."); |
173 | return get(Context, StackAlignment, A.value()); |
174 | } |
175 | |
176 | Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context, |
177 | uint64_t Bytes) { |
178 | assert(Bytes && "Bytes must be non-zero."); |
179 | return get(Context, Dereferenceable, Bytes); |
180 | } |
181 | |
182 | Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context, |
183 | uint64_t Bytes) { |
184 | assert(Bytes && "Bytes must be non-zero."); |
185 | return get(Context, DereferenceableOrNull, Bytes); |
186 | } |
187 | |
188 | Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) { |
189 | return get(Context, ByVal, Ty); |
190 | } |
191 | |
192 | Attribute Attribute::getWithStructRetType(LLVMContext &Context, Type *Ty) { |
193 | return get(Context, StructRet, Ty); |
194 | } |
195 | |
196 | Attribute Attribute::getWithByRefType(LLVMContext &Context, Type *Ty) { |
197 | return get(Context, ByRef, Ty); |
198 | } |
199 | |
200 | Attribute Attribute::getWithPreallocatedType(LLVMContext &Context, Type *Ty) { |
201 | return get(Context, Preallocated, Ty); |
202 | } |
203 | |
204 | Attribute Attribute::getWithInAllocaType(LLVMContext &Context, Type *Ty) { |
205 | return get(Context, InAlloca, Ty); |
| 1 | Calling 'Attribute::get' | |
|
206 | } |
207 | |
208 | Attribute |
209 | Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg, |
210 | const Optional<unsigned> &NumElemsArg) { |
211 | assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) && |
212 | "Invalid allocsize arguments -- given allocsize(0, 0)"); |
213 | return get(Context, AllocSize, packAllocSizeArgs(ElemSizeArg, NumElemsArg)); |
214 | } |
215 | |
216 | Attribute Attribute::getWithVScaleRangeArgs(LLVMContext &Context, |
217 | unsigned MinValue, |
218 | unsigned MaxValue) { |
219 | return get(Context, VScaleRange, packVScaleRangeArgs(MinValue, MaxValue)); |
220 | } |
221 | |
222 | Attribute::AttrKind Attribute::getAttrKindFromName(StringRef AttrName) { |
223 | return StringSwitch<Attribute::AttrKind>(AttrName) |
224 | #define GET_ATTR_NAMES |
225 | #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \ |
226 | .Case(#DISPLAY_NAME, Attribute::ENUM_NAME) |
227 | #include "llvm/IR/Attributes.inc" |
228 | .Default(Attribute::None); |
229 | } |
230 | |
231 | StringRef Attribute::getNameFromAttrKind(Attribute::AttrKind AttrKind) { |
232 | switch (AttrKind) { |
233 | #define GET_ATTR_NAMES |
234 | #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \ |
235 | case Attribute::ENUM_NAME: \ |
236 | return #DISPLAY_NAME; |
237 | #include "llvm/IR/Attributes.inc" |
238 | case Attribute::None: |
239 | return "none"; |
240 | default: |
241 | llvm_unreachable("invalid Kind"); |
242 | } |
243 | } |
244 | |
245 | bool Attribute::isExistingAttribute(StringRef Name) { |
246 | return StringSwitch<bool>(Name) |
247 | #define GET_ATTR_NAMES |
248 | #define ATTRIBUTE_ALL(ENUM_NAME, DISPLAY_NAME) .Case(#DISPLAY_NAME, true) |
249 | #include "llvm/IR/Attributes.inc" |
250 | .Default(false); |
251 | } |
252 | |
253 | |
254 | |
255 | |
256 | |
257 | bool Attribute::isEnumAttribute() const { |
258 | return pImpl && pImpl->isEnumAttribute(); |
259 | } |
260 | |
261 | bool Attribute::isIntAttribute() const { |
262 | return pImpl && pImpl->isIntAttribute(); |
263 | } |
264 | |
265 | bool Attribute::isStringAttribute() const { |
266 | return pImpl && pImpl->isStringAttribute(); |
267 | } |
268 | |
269 | bool Attribute::isTypeAttribute() const { |
270 | return pImpl && pImpl->isTypeAttribute(); |
271 | } |
272 | |
273 | Attribute::AttrKind Attribute::getKindAsEnum() const { |
274 | if (!pImpl) return None; |
275 | assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) && |
276 | "Invalid attribute type to get the kind as an enum!"); |
277 | return pImpl->getKindAsEnum(); |
278 | } |
279 | |
280 | uint64_t Attribute::getValueAsInt() const { |
281 | if (!pImpl) return 0; |
282 | assert(isIntAttribute() && |
283 | "Expected the attribute to be an integer attribute!"); |
284 | return pImpl->getValueAsInt(); |
285 | } |
286 | |
287 | bool Attribute::getValueAsBool() const { |
288 | if (!pImpl) return false; |
289 | assert(isStringAttribute() && |
290 | "Expected the attribute to be a string attribute!"); |
291 | return pImpl->getValueAsBool(); |
292 | } |
293 | |
294 | StringRef Attribute::getKindAsString() const { |
295 | if (!pImpl) return {}; |
296 | assert(isStringAttribute() && |
297 | "Invalid attribute type to get the kind as a string!"); |
298 | return pImpl->getKindAsString(); |
299 | } |
300 | |
301 | StringRef Attribute::getValueAsString() const { |
302 | if (!pImpl) return {}; |
303 | assert(isStringAttribute() && |
304 | "Invalid attribute type to get the value as a string!"); |
305 | return pImpl->getValueAsString(); |
306 | } |
307 | |
308 | Type *Attribute::getValueAsType() const { |
309 | if (!pImpl) return {}; |
310 | assert(isTypeAttribute() && |
311 | "Invalid attribute type to get the value as a type!"); |
312 | return pImpl->getValueAsType(); |
313 | } |
314 | |
315 | |
316 | bool Attribute::hasAttribute(AttrKind Kind) const { |
317 | return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None); |
318 | } |
319 | |
320 | bool Attribute::hasAttribute(StringRef Kind) const { |
321 | if (!isStringAttribute()) return false; |
322 | return pImpl && pImpl->hasAttribute(Kind); |
323 | } |
324 | |
325 | MaybeAlign Attribute::getAlignment() const { |
326 | assert(hasAttribute(Attribute::Alignment) && |
327 | "Trying to get alignment from non-alignment attribute!"); |
328 | return MaybeAlign(pImpl->getValueAsInt()); |
329 | } |
330 | |
331 | MaybeAlign Attribute::getStackAlignment() const { |
332 | assert(hasAttribute(Attribute::StackAlignment) && |
333 | "Trying to get alignment from non-alignment attribute!"); |
334 | return MaybeAlign(pImpl->getValueAsInt()); |
335 | } |
336 | |
337 | uint64_t Attribute::getDereferenceableBytes() const { |
338 | assert(hasAttribute(Attribute::Dereferenceable) && |
339 | "Trying to get dereferenceable bytes from " |
340 | "non-dereferenceable attribute!"); |
341 | return pImpl->getValueAsInt(); |
342 | } |
343 | |
344 | uint64_t Attribute::getDereferenceableOrNullBytes() const { |
345 | assert(hasAttribute(Attribute::DereferenceableOrNull) && |
346 | "Trying to get dereferenceable bytes from " |
347 | "non-dereferenceable attribute!"); |
348 | return pImpl->getValueAsInt(); |
349 | } |
350 | |
351 | std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const { |
352 | assert(hasAttribute(Attribute::AllocSize) && |
353 | "Trying to get allocsize args from non-allocsize attribute"); |
354 | return unpackAllocSizeArgs(pImpl->getValueAsInt()); |
355 | } |
356 | |
357 | std::pair<unsigned, unsigned> Attribute::getVScaleRangeArgs() const { |
358 | assert(hasAttribute(Attribute::VScaleRange) && |
359 | "Trying to get vscale args from non-vscale attribute"); |
360 | return unpackVScaleRangeArgs(pImpl->getValueAsInt()); |
361 | } |
362 | |
363 | std::string Attribute::getAsString(bool InAttrGrp) const { |
364 | if (!pImpl) return {}; |
365 | |
366 | if (isEnumAttribute()) |
367 | return getNameFromAttrKind(getKindAsEnum()).str(); |
368 | |
369 | if (isTypeAttribute()) { |
370 | std::string Result = getNameFromAttrKind(getKindAsEnum()).str(); |
371 | Result += '('; |
372 | raw_string_ostream OS(Result); |
373 | getValueAsType()->print(OS, false, true); |
374 | OS.flush(); |
375 | Result += ')'; |
376 | return Result; |
377 | } |
378 | |
379 | |
380 | |
381 | |
382 | |
383 | |
384 | if (hasAttribute(Attribute::Alignment)) { |
385 | std::string Result; |
386 | Result += "align"; |
387 | Result += (InAttrGrp) ? "=" : " "; |
388 | Result += utostr(getValueAsInt()); |
389 | return Result; |
390 | } |
391 | |
392 | auto AttrWithBytesToString = [&](const char *Name) { |
393 | std::string Result; |
394 | Result += Name; |
395 | if (InAttrGrp) { |
396 | Result += "="; |
397 | Result += utostr(getValueAsInt()); |
398 | } else { |
399 | Result += "("; |
400 | Result += utostr(getValueAsInt()); |
401 | Result += ")"; |
402 | } |
403 | return Result; |
404 | }; |
405 | |
406 | if (hasAttribute(Attribute::StackAlignment)) |
407 | return AttrWithBytesToString("alignstack"); |
408 | |
409 | if (hasAttribute(Attribute::Dereferenceable)) |
410 | return AttrWithBytesToString("dereferenceable"); |
411 | |
412 | if (hasAttribute(Attribute::DereferenceableOrNull)) |
413 | return AttrWithBytesToString("dereferenceable_or_null"); |
414 | |
415 | if (hasAttribute(Attribute::AllocSize)) { |
416 | unsigned ElemSize; |
417 | Optional<unsigned> NumElems; |
418 | std::tie(ElemSize, NumElems) = getAllocSizeArgs(); |
419 | |
420 | std::string Result = "allocsize("; |
421 | Result += utostr(ElemSize); |
422 | if (NumElems.hasValue()) { |
423 | Result += ','; |
424 | Result += utostr(*NumElems); |
425 | } |
426 | Result += ')'; |
427 | return Result; |
428 | } |
429 | |
430 | if (hasAttribute(Attribute::VScaleRange)) { |
431 | unsigned MinValue, MaxValue; |
432 | std::tie(MinValue, MaxValue) = getVScaleRangeArgs(); |
433 | |
434 | std::string Result = "vscale_range("; |
435 | Result += utostr(MinValue); |
436 | Result += ','; |
437 | Result += utostr(MaxValue); |
438 | Result += ')'; |
439 | return Result; |
440 | } |
441 | |
442 | |
443 | |
444 | |
445 | |
446 | |
447 | if (isStringAttribute()) { |
448 | std::string Result; |
449 | { |
450 | raw_string_ostream OS(Result); |
451 | OS << '"' << getKindAsString() << '"'; |
452 | |
453 | |
454 | |
455 | |
456 | const auto &AttrVal = pImpl->getValueAsString(); |
457 | if (!AttrVal.empty()) { |
458 | OS << "=\""; |
459 | printEscapedString(AttrVal, OS); |
460 | OS << "\""; |
461 | } |
462 | } |
463 | return Result; |
464 | } |
465 | |
466 | llvm_unreachable("Unknown attribute"); |
467 | } |
468 | |
469 | bool Attribute::hasParentContext(LLVMContext &C) const { |
470 | assert(isValid() && "invalid Attribute doesn't refer to any context"); |
471 | FoldingSetNodeID ID; |
472 | pImpl->Profile(ID); |
473 | void *Unused; |
474 | return C.pImpl->AttrsSet.FindNodeOrInsertPos(ID, Unused) == pImpl; |
475 | } |
476 | |
477 | bool Attribute::operator<(Attribute A) const { |
478 | if (!pImpl && !A.pImpl) return false; |
479 | if (!pImpl) return true; |
480 | if (!A.pImpl) return false; |
481 | return *pImpl < *A.pImpl; |
482 | } |
483 | |
484 | void Attribute::Profile(FoldingSetNodeID &ID) const { |
485 | ID.AddPointer(pImpl); |
486 | } |
487 | |
488 | enum AttributeProperty { |
489 | FnAttr = (1 << 0), |
490 | ParamAttr = (1 << 1), |
491 | RetAttr = (1 << 2), |
492 | }; |
493 | |
494 | #define GET_ATTR_PROP_TABLE |
495 | #include "llvm/IR/Attributes.inc" |
496 | |
497 | static bool hasAttributeProperty(Attribute::AttrKind Kind, |
498 | AttributeProperty Prop) { |
499 | unsigned Index = Kind - 1; |
500 | assert(Index < sizeof(AttrPropTable) / sizeof(AttrPropTable[0]) && |
501 | "Invalid attribute kind"); |
502 | return AttrPropTable[Index] & Prop; |
503 | } |
504 | |
505 | bool Attribute::canUseAsFnAttr(AttrKind Kind) { |
506 | return hasAttributeProperty(Kind, AttributeProperty::FnAttr); |
507 | } |
508 | |
509 | bool Attribute::canUseAsParamAttr(AttrKind Kind) { |
510 | return hasAttributeProperty(Kind, AttributeProperty::ParamAttr); |
511 | } |
512 | |
513 | bool Attribute::canUseAsRetAttr(AttrKind Kind) { |
514 | return hasAttributeProperty(Kind, AttributeProperty::RetAttr); |
515 | } |
516 | |
517 | |
518 | |
519 | |
520 | |
521 | bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const { |
522 | if (isStringAttribute()) return false; |
523 | return getKindAsEnum() == A; |
524 | } |
525 | |
526 | bool AttributeImpl::hasAttribute(StringRef Kind) const { |
527 | if (!isStringAttribute()) return false; |
528 | return getKindAsString() == Kind; |
529 | } |
530 | |
531 | Attribute::AttrKind AttributeImpl::getKindAsEnum() const { |
532 | assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute()); |
533 | return static_cast<const EnumAttributeImpl *>(this)->getEnumKind(); |
534 | } |
535 | |
536 | uint64_t AttributeImpl::getValueAsInt() const { |
537 | assert(isIntAttribute()); |
538 | return static_cast<const IntAttributeImpl *>(this)->getValue(); |
539 | } |
540 | |
541 | bool AttributeImpl::getValueAsBool() const { |
542 | assert(getValueAsString().empty() || getValueAsString() == "false" || getValueAsString() == "true"); |
543 | return getValueAsString() == "true"; |
544 | } |
545 | |
546 | StringRef AttributeImpl::getKindAsString() const { |
547 | assert(isStringAttribute()); |
548 | return static_cast<const StringAttributeImpl *>(this)->getStringKind(); |
549 | } |
550 | |
551 | StringRef AttributeImpl::getValueAsString() const { |
552 | assert(isStringAttribute()); |
553 | return static_cast<const StringAttributeImpl *>(this)->getStringValue(); |
554 | } |
555 | |
556 | Type *AttributeImpl::getValueAsType() const { |
557 | assert(isTypeAttribute()); |
558 | return static_cast<const TypeAttributeImpl *>(this)->getTypeValue(); |
559 | } |
560 | |
561 | bool AttributeImpl::operator<(const AttributeImpl &AI) const { |
562 | if (this == &AI) |
563 | return false; |
564 | |
565 | |
566 | |
567 | if (!isStringAttribute()) { |
568 | if (AI.isStringAttribute()) |
569 | return true; |
570 | if (getKindAsEnum() != AI.getKindAsEnum()) |
571 | return getKindAsEnum() < AI.getKindAsEnum(); |
572 | assert(!AI.isEnumAttribute() && "Non-unique attribute"); |
573 | assert(!AI.isTypeAttribute() && "Comparison of types would be unstable"); |
574 | |
575 | assert(AI.isIntAttribute() && "Only possibility left"); |
576 | return getValueAsInt() < AI.getValueAsInt(); |
577 | } |
578 | |
579 | if (!AI.isStringAttribute()) |
580 | return false; |
581 | if (getKindAsString() == AI.getKindAsString()) |
582 | return getValueAsString() < AI.getValueAsString(); |
583 | return getKindAsString() < AI.getKindAsString(); |
584 | } |
585 | |
586 | |
587 | |
588 | |
589 | |
590 | AttributeSet AttributeSet::get(LLVMContext &C, const AttrBuilder &B) { |
591 | return AttributeSet(AttributeSetNode::get(C, B)); |
592 | } |
593 | |
594 | AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<Attribute> Attrs) { |
595 | return AttributeSet(AttributeSetNode::get(C, Attrs)); |
596 | } |
597 | |
598 | AttributeSet AttributeSet::addAttribute(LLVMContext &C, |
599 | Attribute::AttrKind Kind) const { |
600 | if (hasAttribute(Kind)) return *this; |
601 | AttrBuilder B; |
602 | B.addAttribute(Kind); |
603 | return addAttributes(C, AttributeSet::get(C, B)); |
604 | } |
605 | |
606 | AttributeSet AttributeSet::addAttribute(LLVMContext &C, StringRef Kind, |
607 | StringRef Value) const { |
608 | AttrBuilder B; |
609 | B.addAttribute(Kind, Value); |
610 | return addAttributes(C, AttributeSet::get(C, B)); |
611 | } |
612 | |
613 | AttributeSet AttributeSet::addAttributes(LLVMContext &C, |
614 | const AttributeSet AS) const { |
615 | if (!hasAttributes()) |
616 | return AS; |
617 | |
618 | if (!AS.hasAttributes()) |
619 | return *this; |
620 | |
621 | AttrBuilder B(AS); |
622 | for (const auto &I : *this) |
623 | B.addAttribute(I); |
624 | |
625 | return get(C, B); |
626 | } |
627 | |
628 | AttributeSet AttributeSet::removeAttribute(LLVMContext &C, |
629 | Attribute::AttrKind Kind) const { |
630 | if (!hasAttribute(Kind)) return *this; |
631 | AttrBuilder B(*this); |
632 | B.removeAttribute(Kind); |
633 | return get(C, B); |
634 | } |
635 | |
636 | AttributeSet AttributeSet::removeAttribute(LLVMContext &C, |
637 | StringRef Kind) const { |
638 | if (!hasAttribute(Kind)) return *this; |
639 | AttrBuilder B(*this); |
640 | B.removeAttribute(Kind); |
641 | return get(C, B); |
642 | } |
643 | |
644 | AttributeSet AttributeSet::removeAttributes(LLVMContext &C, |
645 | const AttrBuilder &Attrs) const { |
646 | AttrBuilder B(*this); |
647 | |
648 | if (!B.overlaps(Attrs)) |
649 | return *this; |
650 | |
651 | B.remove(Attrs); |
652 | return get(C, B); |
653 | } |
654 | |
655 | unsigned AttributeSet::getNumAttributes() const { |
656 | return SetNode ? SetNode->getNumAttributes() : 0; |
657 | } |
658 | |
659 | bool AttributeSet::hasAttribute(Attribute::AttrKind Kind) const { |
660 | return SetNode ? SetNode->hasAttribute(Kind) : false; |
661 | } |
662 | |
663 | bool AttributeSet::hasAttribute(StringRef Kind) const { |
664 | return SetNode ? SetNode->hasAttribute(Kind) : false; |
665 | } |
666 | |
667 | Attribute AttributeSet::getAttribute(Attribute::AttrKind Kind) const { |
668 | return SetNode ? SetNode->getAttribute(Kind) : Attribute(); |
669 | } |
670 | |
671 | Attribute AttributeSet::getAttribute(StringRef Kind) const { |
672 | return SetNode ? SetNode->getAttribute(Kind) : Attribute(); |
673 | } |
674 | |
675 | MaybeAlign AttributeSet::getAlignment() const { |
676 | return SetNode ? SetNode->getAlignment() : None; |
677 | } |
678 | |
679 | MaybeAlign AttributeSet::getStackAlignment() const { |
680 | return SetNode ? SetNode->getStackAlignment() : None; |
681 | } |
682 | |
683 | uint64_t AttributeSet::getDereferenceableBytes() const { |
684 | return SetNode ? SetNode->getDereferenceableBytes() : 0; |
685 | } |
686 | |
687 | uint64_t AttributeSet::getDereferenceableOrNullBytes() const { |
688 | return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0; |
689 | } |
690 | |
691 | Type *AttributeSet::getByRefType() const { |
692 | return SetNode ? SetNode->getAttributeType(Attribute::ByRef) : nullptr; |
693 | } |
694 | |
695 | Type *AttributeSet::getByValType() const { |
696 | return SetNode ? SetNode->getAttributeType(Attribute::ByVal) : nullptr; |
697 | } |
698 | |
699 | Type *AttributeSet::getStructRetType() const { |
700 | return SetNode ? SetNode->getAttributeType(Attribute::StructRet) : nullptr; |
701 | } |
702 | |
703 | Type *AttributeSet::getPreallocatedType() const { |
704 | return SetNode ? SetNode->getAttributeType(Attribute::Preallocated) : nullptr; |
705 | } |
706 | |
707 | Type *AttributeSet::getInAllocaType() const { |
708 | return SetNode ? SetNode->getAttributeType(Attribute::InAlloca) : nullptr; |
709 | } |
710 | |
711 | Type *AttributeSet::getElementType() const { |
712 | return SetNode ? SetNode->getAttributeType(Attribute::ElementType) : nullptr; |
713 | } |
714 | |
715 | std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const { |
716 | return SetNode ? SetNode->getAllocSizeArgs() |
717 | : std::pair<unsigned, Optional<unsigned>>(0, 0); |
718 | } |
719 | |
720 | std::pair<unsigned, unsigned> AttributeSet::getVScaleRangeArgs() const { |
721 | return SetNode ? SetNode->getVScaleRangeArgs() |
722 | : std::pair<unsigned, unsigned>(0, 0); |
723 | } |
724 | |
725 | std::string AttributeSet::getAsString(bool InAttrGrp) const { |
726 | return SetNode ? SetNode->getAsString(InAttrGrp) : ""; |
727 | } |
728 | |
729 | bool AttributeSet::hasParentContext(LLVMContext &C) const { |
730 | assert(hasAttributes() && "empty AttributeSet doesn't refer to any context"); |
731 | FoldingSetNodeID ID; |
732 | SetNode->Profile(ID); |
733 | void *Unused; |
734 | return C.pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, Unused) == SetNode; |
735 | } |
736 | |
737 | AttributeSet::iterator AttributeSet::begin() const { |
738 | return SetNode ? SetNode->begin() : nullptr; |
739 | } |
740 | |
741 | AttributeSet::iterator AttributeSet::end() const { |
742 | return SetNode ? SetNode->end() : nullptr; |
743 | } |
744 | |
745 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
746 | LLVM_DUMP_METHOD void AttributeSet::dump() const { |
747 | dbgs() << "AS =\n"; |
748 | dbgs() << " { "; |
749 | dbgs() << getAsString(true) << " }\n"; |
750 | } |
751 | #endif |
752 | |
753 | |
754 | |
755 | |
756 | |
757 | AttributeSetNode::AttributeSetNode(ArrayRef<Attribute> Attrs) |
758 | : NumAttrs(Attrs.size()) { |
759 | |
760 | llvm::copy(Attrs, getTrailingObjects<Attribute>()); |
761 | |
762 | for (const auto &I : *this) { |
763 | if (I.isStringAttribute()) |
764 | StringAttrs.insert({ I.getKindAsString(), I }); |
765 | else |
766 | AvailableAttrs.addAttribute(I.getKindAsEnum()); |
767 | } |
768 | } |
769 | |
770 | AttributeSetNode *AttributeSetNode::get(LLVMContext &C, |
771 | ArrayRef<Attribute> Attrs) { |
772 | SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end()); |
773 | llvm::sort(SortedAttrs); |
774 | return getSorted(C, SortedAttrs); |
775 | } |
776 | |
777 | AttributeSetNode *AttributeSetNode::getSorted(LLVMContext &C, |
778 | ArrayRef<Attribute> SortedAttrs) { |
779 | if (SortedAttrs.empty()) |
780 | return nullptr; |
781 | |
782 | |
783 | LLVMContextImpl *pImpl = C.pImpl; |
784 | FoldingSetNodeID ID; |
785 | |
786 | assert(llvm::is_sorted(SortedAttrs) && "Expected sorted attributes!"); |
787 | for (const auto &Attr : SortedAttrs) |
788 | Attr.Profile(ID); |
789 | |
790 | void *InsertPoint; |
791 | AttributeSetNode *PA = |
792 | pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint); |
793 | |
794 | |
795 | |
796 | if (!PA) { |
797 | |
798 | void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size())); |
799 | PA = new (Mem) AttributeSetNode(SortedAttrs); |
800 | pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint); |
801 | } |
802 | |
803 | |
804 | return PA; |
805 | } |
806 | |
807 | AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) { |
808 | |
809 | SmallVector<Attribute, 8> Attrs; |
810 | for (Attribute::AttrKind Kind = Attribute::None; |
811 | Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) { |
812 | if (!B.contains(Kind)) |
813 | continue; |
814 | |
815 | if (Attribute::isTypeAttrKind(Kind)) { |
816 | Attrs.push_back(Attribute::get(C, Kind, B.getTypeAttr(Kind))); |
817 | continue; |
818 | } |
819 | |
820 | Attribute Attr; |
821 | switch (Kind) { |
822 | case Attribute::Alignment: |
823 | assert(B.getAlignment() && "Alignment must be set"); |
824 | Attr = Attribute::getWithAlignment(C, *B.getAlignment()); |
825 | break; |
826 | case Attribute::StackAlignment: |
827 | assert(B.getStackAlignment() && "StackAlignment must be set"); |
828 | Attr = Attribute::getWithStackAlignment(C, *B.getStackAlignment()); |
829 | break; |
830 | case Attribute::Dereferenceable: |
831 | Attr = Attribute::getWithDereferenceableBytes( |
832 | C, B.getDereferenceableBytes()); |
833 | break; |
834 | case Attribute::DereferenceableOrNull: |
835 | Attr = Attribute::getWithDereferenceableOrNullBytes( |
836 | C, B.getDereferenceableOrNullBytes()); |
837 | break; |
838 | case Attribute::AllocSize: { |
839 | auto A = B.getAllocSizeArgs(); |
840 | Attr = Attribute::getWithAllocSizeArgs(C, A.first, A.second); |
841 | break; |
842 | } |
843 | case Attribute::VScaleRange: { |
844 | auto A = B.getVScaleRangeArgs(); |
845 | Attr = Attribute::getWithVScaleRangeArgs(C, A.first, A.second); |
846 | break; |
847 | } |
848 | default: |
849 | Attr = Attribute::get(C, Kind); |
850 | } |
851 | Attrs.push_back(Attr); |
852 | } |
853 | |
854 | |
855 | for (const auto &TDA : B.td_attrs()) |
856 | Attrs.emplace_back(Attribute::get(C, TDA.first, TDA.second)); |
857 | |
858 | return getSorted(C, Attrs); |
859 | } |
860 | |
861 | bool AttributeSetNode::hasAttribute(StringRef Kind) const { |
862 | return StringAttrs.count(Kind); |
863 | } |
864 | |
865 | Optional<Attribute> |
866 | AttributeSetNode::findEnumAttribute(Attribute::AttrKind Kind) const { |
867 | |
868 | if (!hasAttribute(Kind)) |
869 | return None; |
870 | |
871 | |
872 | |
873 | const Attribute *I = |
874 | std::lower_bound(begin(), end() - StringAttrs.size(), Kind, |
875 | [](Attribute A, Attribute::AttrKind Kind) { |
876 | return A.getKindAsEnum() < Kind; |
877 | }); |
878 | assert(I != end() && I->hasAttribute(Kind) && "Presence check failed?"); |
879 | return *I; |
880 | } |
881 | |
882 | Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const { |
883 | if (auto A = findEnumAttribute(Kind)) |
884 | return *A; |
885 | return {}; |
886 | } |
887 | |
888 | Attribute AttributeSetNode::getAttribute(StringRef Kind) const { |
889 | return StringAttrs.lookup(Kind); |
890 | } |
891 | |
892 | MaybeAlign AttributeSetNode::getAlignment() const { |
893 | if (auto A = findEnumAttribute(Attribute::Alignment)) |
894 | return A->getAlignment(); |
895 | return None; |
896 | } |
897 | |
898 | MaybeAlign AttributeSetNode::getStackAlignment() const { |
899 | if (auto A = findEnumAttribute(Attribute::StackAlignment)) |
900 | return A->getStackAlignment(); |
901 | return None; |
902 | } |
903 | |
904 | Type *AttributeSetNode::getAttributeType(Attribute::AttrKind Kind) const { |
905 | if (auto A = findEnumAttribute(Kind)) |
906 | return A->getValueAsType(); |
907 | return nullptr; |
908 | } |
909 | |
910 | uint64_t AttributeSetNode::getDereferenceableBytes() const { |
911 | if (auto A = findEnumAttribute(Attribute::Dereferenceable)) |
912 | return A->getDereferenceableBytes(); |
913 | return 0; |
914 | } |
915 | |
916 | uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const { |
917 | if (auto A = findEnumAttribute(Attribute::DereferenceableOrNull)) |
918 | return A->getDereferenceableOrNullBytes(); |
919 | return 0; |
920 | } |
921 | |
922 | std::pair<unsigned, Optional<unsigned>> |
923 | AttributeSetNode::getAllocSizeArgs() const { |
924 | if (auto A = findEnumAttribute(Attribute::AllocSize)) |
925 | return A->getAllocSizeArgs(); |
926 | return std::make_pair(0, 0); |
927 | } |
928 | |
929 | std::pair<unsigned, unsigned> AttributeSetNode::getVScaleRangeArgs() const { |
930 | if (auto A = findEnumAttribute(Attribute::VScaleRange)) |
931 | return A->getVScaleRangeArgs(); |
932 | return std::make_pair(0, 0); |
933 | } |
934 | |
935 | std::string AttributeSetNode::getAsString(bool InAttrGrp) const { |
936 | std::string Str; |
937 | for (iterator I = begin(), E = end(); I != E; ++I) { |
938 | if (I != begin()) |
939 | Str += ' '; |
940 | Str += I->getAsString(InAttrGrp); |
941 | } |
942 | return Str; |
943 | } |
944 | |
945 | |
946 | |
947 | |
948 | |
949 | |
950 | |
951 | static unsigned attrIdxToArrayIdx(unsigned Index) { |
952 | return Index + 1; |
953 | } |
954 | |
955 | AttributeListImpl::AttributeListImpl(ArrayRef<AttributeSet> Sets) |
956 | : NumAttrSets(Sets.size()) { |
957 | assert(!Sets.empty() && "pointless AttributeListImpl"); |
958 | |
959 | |
960 | llvm::copy(Sets, getTrailingObjects<AttributeSet>()); |
961 | |
962 | |
963 | |
964 | for (const auto &I : Sets[attrIdxToArrayIdx(AttributeList::FunctionIndex)]) |
965 | if (!I.isStringAttribute()) |
966 | AvailableFunctionAttrs.addAttribute(I.getKindAsEnum()); |
967 | |
968 | for (const auto &Set : Sets) |
969 | for (const auto &I : Set) |
970 | if (!I.isStringAttribute()) |
971 | AvailableSomewhereAttrs.addAttribute(I.getKindAsEnum()); |
972 | } |
973 | |
974 | void AttributeListImpl::Profile(FoldingSetNodeID &ID) const { |
975 | Profile(ID, makeArrayRef(begin(), end())); |
976 | } |
977 | |
978 | void AttributeListImpl::Profile(FoldingSetNodeID &ID, |
979 | ArrayRef<AttributeSet> Sets) { |
980 | for (const auto &Set : Sets) |
981 | ID.AddPointer(Set.SetNode); |
982 | } |
983 | |
984 | bool AttributeListImpl::hasAttrSomewhere(Attribute::AttrKind Kind, |
985 | unsigned *Index) const { |
986 | if (!AvailableSomewhereAttrs.hasAttribute(Kind)) |
987 | return false; |
988 | |
989 | if (Index) { |
990 | for (unsigned I = 0, E = NumAttrSets; I != E; ++I) { |
991 | if (begin()[I].hasAttribute(Kind)) { |
992 | *Index = I - 1; |
993 | break; |
994 | } |
995 | } |
996 | } |
997 | |
998 | return true; |
999 | } |
1000 | |
1001 | |
1002 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
1003 | LLVM_DUMP_METHOD void AttributeListImpl::dump() const { |
1004 | AttributeList(const_cast<AttributeListImpl *>(this)).dump(); |
1005 | } |
1006 | #endif |
1007 | |
1008 | |
1009 | |
1010 | |
1011 | |
1012 | AttributeList AttributeList::getImpl(LLVMContext &C, |
1013 | ArrayRef<AttributeSet> AttrSets) { |
1014 | assert(!AttrSets.empty() && "pointless AttributeListImpl"); |
1015 | |
1016 | LLVMContextImpl *pImpl = C.pImpl; |
1017 | FoldingSetNodeID ID; |
1018 | AttributeListImpl::Profile(ID, AttrSets); |
1019 | |
1020 | void *InsertPoint; |
1021 | AttributeListImpl *PA = |
1022 | pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint); |
1023 | |
1024 | |
1025 | |
1026 | if (!PA) { |
1027 | |
1028 | void *Mem = pImpl->Alloc.Allocate( |
1029 | AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.size()), |
1030 | alignof(AttributeListImpl)); |
1031 | PA = new (Mem) AttributeListImpl(AttrSets); |
1032 | pImpl->AttrsLists.InsertNode(PA, InsertPoint); |
1033 | } |
1034 | |
1035 | |
1036 | return AttributeList(PA); |
1037 | } |
1038 | |
1039 | AttributeList |
1040 | AttributeList::get(LLVMContext &C, |
1041 | ArrayRef<std::pair<unsigned, Attribute>> Attrs) { |
1042 | |
1043 | if (Attrs.empty()) |
1044 | return {}; |
1045 | |
1046 | assert(llvm::is_sorted(Attrs, |
1047 | [](const std::pair<unsigned, Attribute> &LHS, |
1048 | const std::pair<unsigned, Attribute> &RHS) { |
1049 | return LHS.first < RHS.first; |
1050 | }) && |
1051 | "Misordered Attributes list!"); |
1052 | assert(llvm::all_of(Attrs, |
1053 | [](const std::pair<unsigned, Attribute> &Pair) { |
1054 | return Pair.second.isValid(); |
1055 | }) && |
1056 | "Pointless attribute!"); |
1057 | |
1058 | |
1059 | |
1060 | SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec; |
1061 | for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(), |
1062 | E = Attrs.end(); I != E; ) { |
1063 | unsigned Index = I->first; |
1064 | SmallVector<Attribute, 4> AttrVec; |
1065 | while (I != E && I->first == Index) { |
1066 | AttrVec.push_back(I->second); |
1067 | ++I; |
1068 | } |
1069 | |
1070 | AttrPairVec.emplace_back(Index, AttributeSet::get(C, AttrVec)); |
1071 | } |
1072 | |
1073 | return get(C, AttrPairVec); |
1074 | } |
1075 | |
1076 | AttributeList |
1077 | AttributeList::get(LLVMContext &C, |
1078 | ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) { |
1079 | |
1080 | if (Attrs.empty()) |
1081 | return {}; |
1082 | |
1083 | assert(llvm::is_sorted(Attrs, |
1084 | [](const std::pair<unsigned, AttributeSet> &LHS, |
1085 | const std::pair<unsigned, AttributeSet> &RHS) { |
1086 | return LHS.first < RHS.first; |
1087 | }) && |
1088 | "Misordered Attributes list!"); |
1089 | assert(llvm::none_of(Attrs, |
1090 | [](const std::pair<unsigned, AttributeSet> &Pair) { |
1091 | return !Pair.second.hasAttributes(); |
1092 | }) && |
1093 | "Pointless attribute!"); |
1094 | |
1095 | unsigned MaxIndex = Attrs.back().first; |
1096 | |
1097 | |
1098 | if (MaxIndex == FunctionIndex && Attrs.size() > 1) |
1099 | MaxIndex = Attrs[Attrs.size() - 2].first; |
1100 | |
1101 | SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1); |
1102 | for (const auto &Pair : Attrs) |
1103 | AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second; |
1104 | |
1105 | return getImpl(C, AttrVec); |
1106 | } |
1107 | |
1108 | AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs, |
1109 | AttributeSet RetAttrs, |
1110 | ArrayRef<AttributeSet> ArgAttrs) { |
1111 | |
1112 | |
1113 | |
1114 | unsigned NumSets = 0; |
1115 | for (size_t I = ArgAttrs.size(); I != 0; --I) { |
1116 | if (ArgAttrs[I - 1].hasAttributes()) { |
1117 | NumSets = I + 2; |
1118 | break; |
1119 | } |
1120 | } |
1121 | if (NumSets == 0) { |
1122 | |
1123 | |
1124 | if (RetAttrs.hasAttributes()) |
1125 | NumSets = 2; |
1126 | else if (FnAttrs.hasAttributes()) |
1127 | NumSets = 1; |
1128 | } |
1129 | |
1130 | |
1131 | if (NumSets == 0) |
1132 | return {}; |
1133 | |
1134 | SmallVector<AttributeSet, 8> AttrSets; |
1135 | AttrSets.reserve(NumSets); |
1136 | |
1137 | AttrSets.push_back(FnAttrs); |
1138 | if (NumSets > 1) |
1139 | AttrSets.push_back(RetAttrs); |
1140 | if (NumSets > 2) { |
1141 | |
1142 | ArgAttrs = ArgAttrs.take_front(NumSets - 2); |
1143 | llvm::append_range(AttrSets, ArgAttrs); |
1144 | } |
1145 | |
1146 | return getImpl(C, AttrSets); |
1147 | } |
1148 | |
1149 | AttributeList AttributeList::get(LLVMContext &C, unsigned Index, |
1150 | const AttrBuilder &B) { |
1151 | if (!B.hasAttributes()) |
1152 | return {}; |
1153 | Index = attrIdxToArrayIdx(Index); |
1154 | SmallVector<AttributeSet, 8> AttrSets(Index + 1); |
1155 | AttrSets[Index] = AttributeSet::get(C, B); |
1156 | return getImpl(C, AttrSets); |
1157 | } |
1158 | |
1159 | AttributeList AttributeList::get(LLVMContext &C, unsigned Index, |
1160 | ArrayRef<Attribute::AttrKind> Kinds) { |
1161 | SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; |
1162 | for (const auto K : Kinds) |
1163 | Attrs.emplace_back(Index, Attribute::get(C, K)); |
1164 | return get(C, Attrs); |
1165 | } |
1166 | |
1167 | AttributeList AttributeList::get(LLVMContext &C, unsigned Index, |
1168 | ArrayRef<Attribute::AttrKind> Kinds, |
1169 | ArrayRef<uint64_t> Values) { |
1170 | assert(Kinds.size() == Values.size() && "Mismatched attribute values."); |
1171 | SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; |
1172 | auto VI = Values.begin(); |
1173 | for (const auto K : Kinds) |
1174 | Attrs.emplace_back(Index, Attribute::get(C, K, *VI++)); |
1175 | return get(C, Attrs); |
1176 | } |
1177 | |
1178 | AttributeList AttributeList::get(LLVMContext &C, unsigned Index, |
1179 | ArrayRef<StringRef> Kinds) { |
1180 | SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; |
1181 | for (const auto &K : Kinds) |
1182 | Attrs.emplace_back(Index, Attribute::get(C, K)); |
1183 | return get(C, Attrs); |
1184 | } |
1185 | |
1186 | AttributeList AttributeList::get(LLVMContext &C, |
1187 | ArrayRef<AttributeList> Attrs) { |
1188 | if (Attrs.empty()) |
1189 | return {}; |
1190 | if (Attrs.size() == 1) |
1191 | return Attrs[0]; |
1192 | |
1193 | unsigned MaxSize = 0; |
1194 | for (const auto &List : Attrs) |
1195 | MaxSize = std::max(MaxSize, List.getNumAttrSets()); |
1196 | |
1197 | |
1198 | if (MaxSize == 0) |
1199 | return {}; |
1200 | |
1201 | SmallVector<AttributeSet, 8> NewAttrSets(MaxSize); |
1202 | for (unsigned I = 0; I < MaxSize; ++I) { |
1203 | AttrBuilder CurBuilder; |
1204 | for (const auto &List : Attrs) |
1205 | CurBuilder.merge(List.getAttributes(I - 1)); |
1206 | NewAttrSets[I] = AttributeSet::get(C, CurBuilder); |
1207 | } |
1208 | |
1209 | return getImpl(C, NewAttrSets); |
1210 | } |
1211 | |
1212 | AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, |
1213 | Attribute::AttrKind Kind) const { |
1214 | if (hasAttribute(Index, Kind)) return *this; |
1215 | AttributeSet Attrs = getAttributes(Index); |
1216 | |
1217 | SmallVector<Attribute, 8> NewAttrs(Attrs.begin(), Attrs.end()); |
1218 | NewAttrs.push_back(Attribute::get(C, Kind)); |
1219 | return setAttributes(C, Index, AttributeSet::get(C, NewAttrs)); |
1220 | } |
1221 | |
1222 | AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, |
1223 | StringRef Kind, |
1224 | StringRef Value) const { |
1225 | AttrBuilder B; |
1226 | B.addAttribute(Kind, Value); |
1227 | return addAttributes(C, Index, B); |
1228 | } |
1229 | |
1230 | AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index, |
1231 | Attribute A) const { |
1232 | AttrBuilder B; |
1233 | B.addAttribute(A); |
1234 | return addAttributes(C, Index, B); |
1235 | } |
1236 | |
1237 | AttributeList AttributeList::setAttributes(LLVMContext &C, unsigned Index, |
1238 | AttributeSet Attrs) const { |
1239 | Index = attrIdxToArrayIdx(Index); |
1240 | SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); |
1241 | if (Index >= AttrSets.size()) |
1242 | AttrSets.resize(Index + 1); |
1243 | AttrSets[Index] = Attrs; |
1244 | return AttributeList::getImpl(C, AttrSets); |
1245 | } |
1246 | |
1247 | AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index, |
1248 | const AttrBuilder &B) const { |
1249 | if (!B.hasAttributes()) |
1250 | return *this; |
1251 | |
1252 | if (!pImpl) |
1253 | return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}}); |
1254 | |
1255 | #ifndef NDEBUG |
1256 | |
1257 | |
1258 | const MaybeAlign OldAlign = getAttributes(Index).getAlignment(); |
1259 | const MaybeAlign NewAlign = B.getAlignment(); |
1260 | assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && |
1261 | "Attempt to change alignment!"); |
1262 | #endif |
1263 | |
1264 | AttrBuilder Merged(getAttributes(Index)); |
1265 | Merged.merge(B); |
1266 | return setAttributes(C, Index, AttributeSet::get(C, Merged)); |
1267 | } |
1268 | |
1269 | AttributeList AttributeList::addParamAttribute(LLVMContext &C, |
1270 | ArrayRef<unsigned> ArgNos, |
1271 | Attribute A) const { |
1272 | assert(llvm::is_sorted(ArgNos)); |
1273 | |
1274 | SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); |
1275 | unsigned MaxIndex = attrIdxToArrayIdx(ArgNos.back() + FirstArgIndex); |
1276 | if (MaxIndex >= AttrSets.size()) |
1277 | AttrSets.resize(MaxIndex + 1); |
1278 | |
1279 | for (unsigned ArgNo : ArgNos) { |
1280 | unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex); |
1281 | AttrBuilder B(AttrSets[Index]); |
1282 | B.addAttribute(A); |
1283 | AttrSets[Index] = AttributeSet::get(C, B); |
1284 | } |
1285 | |
1286 | return getImpl(C, AttrSets); |
1287 | } |
1288 | |
1289 | AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index, |
1290 | Attribute::AttrKind Kind) const { |
1291 | if (!hasAttribute(Index, Kind)) return *this; |
1292 | |
1293 | Index = attrIdxToArrayIdx(Index); |
1294 | SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); |
1295 | assert(Index < AttrSets.size()); |
1296 | |
1297 | AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind); |
1298 | |
1299 | return getImpl(C, AttrSets); |
1300 | } |
1301 | |
1302 | AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index, |
1303 | StringRef Kind) const { |
1304 | if (!hasAttribute(Index, Kind)) return *this; |
1305 | |
1306 | Index = attrIdxToArrayIdx(Index); |
1307 | SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); |
1308 | assert(Index < AttrSets.size()); |
1309 | |
1310 | AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind); |
1311 | |
1312 | return getImpl(C, AttrSets); |
1313 | } |
1314 | |
1315 | AttributeList |
1316 | AttributeList::removeAttributes(LLVMContext &C, unsigned Index, |
1317 | const AttrBuilder &AttrsToRemove) const { |
1318 | AttributeSet Attrs = getAttributes(Index); |
1319 | AttributeSet NewAttrs = Attrs.removeAttributes(C, AttrsToRemove); |
1320 | |
1321 | if (Attrs == NewAttrs) |
1322 | return *this; |
1323 | return setAttributes(C, Index, NewAttrs); |
1324 | } |
1325 | |
1326 | AttributeList AttributeList::removeAttributes(LLVMContext &C, |
1327 | unsigned WithoutIndex) const { |
1328 | if (!pImpl) |
1329 | return {}; |
1330 | WithoutIndex = attrIdxToArrayIdx(WithoutIndex); |
1331 | if (WithoutIndex >= getNumAttrSets()) |
1332 | return *this; |
1333 | SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end()); |
1334 | AttrSets[WithoutIndex] = AttributeSet(); |
1335 | return getImpl(C, AttrSets); |
1336 | } |
1337 | |
1338 | AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C, |
1339 | unsigned Index, |
1340 | uint64_t Bytes) const { |
1341 | AttrBuilder B; |
1342 | B.addDereferenceableAttr(Bytes); |
1343 | return addAttributes(C, Index, B); |
1344 | } |
1345 | |
1346 | AttributeList |
1347 | AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, |
1348 | uint64_t Bytes) const { |
1349 | AttrBuilder B; |
1350 | B.addDereferenceableOrNullAttr(Bytes); |
1351 | return addAttributes(C, Index, B); |
1352 | } |
1353 | |
1354 | AttributeList |
1355 | AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index, |
1356 | unsigned ElemSizeArg, |
1357 | const Optional<unsigned> &NumElemsArg) { |
1358 | AttrBuilder B; |
1359 | B.addAllocSizeAttr(ElemSizeArg, NumElemsArg); |
1360 | return addAttributes(C, Index, B); |
1361 | } |
1362 | |
1363 | AttributeList AttributeList::addVScaleRangeAttr(LLVMContext &C, unsigned Index, |
1364 | unsigned MinValue, |
1365 | unsigned MaxValue) { |
1366 | AttrBuilder B; |
1367 | B.addVScaleRangeAttr(MinValue, MaxValue); |
1368 | return addAttributes(C, Index, B); |
1369 | } |
1370 | |
1371 | |
1372 | |
1373 | |
1374 | |
1375 | AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const { |
1376 | return getAttributes(ArgNo + FirstArgIndex); |
1377 | } |
1378 | |
1379 | AttributeSet AttributeList::getRetAttributes() const { |
1380 | return getAttributes(ReturnIndex); |
1381 | } |
1382 | |
1383 | AttributeSet AttributeList::getFnAttributes() const { |
1384 | return getAttributes(FunctionIndex); |
1385 | } |
1386 | |
1387 | bool AttributeList::hasAttribute(unsigned Index, |
1388 | Attribute::AttrKind Kind) const { |
1389 | return getAttributes(Index).hasAttribute(Kind); |
1390 | } |
1391 | |
1392 | bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const { |
1393 | return getAttributes(Index).hasAttribute(Kind); |
1394 | } |
1395 | |
1396 | bool AttributeList::hasAttributes(unsigned Index) const { |
1397 | return getAttributes(Index).hasAttributes(); |
1398 | } |
1399 | |
1400 | bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const { |
1401 | return pImpl && pImpl->hasFnAttribute(Kind); |
1402 | } |
1403 | |
1404 | bool AttributeList::hasFnAttribute(StringRef Kind) const { |
1405 | return hasAttribute(AttributeList::FunctionIndex, Kind); |
1406 | } |
1407 | |
1408 | bool AttributeList::hasParamAttribute(unsigned ArgNo, |
1409 | Attribute::AttrKind Kind) const { |
1410 | return hasAttribute(ArgNo + FirstArgIndex, Kind); |
1411 | } |
1412 | |
1413 | bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr, |
1414 | unsigned *Index) const { |
1415 | return pImpl && pImpl->hasAttrSomewhere(Attr, Index); |
1416 | } |
1417 | |
1418 | Attribute AttributeList::getAttribute(unsigned Index, |
1419 | Attribute::AttrKind Kind) const { |
1420 | return getAttributes(Index).getAttribute(Kind); |
1421 | } |
1422 | |
1423 | Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const { |
1424 | return getAttributes(Index).getAttribute(Kind); |
1425 | } |
1426 | |
1427 | MaybeAlign AttributeList::getRetAlignment() const { |
1428 | return getAttributes(ReturnIndex).getAlignment(); |
1429 | } |
1430 | |
1431 | MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const { |
1432 | return getAttributes(ArgNo + FirstArgIndex).getAlignment(); |
1433 | } |
1434 | |
1435 | MaybeAlign AttributeList::getParamStackAlignment(unsigned ArgNo) const { |
1436 | return getAttributes(ArgNo + FirstArgIndex).getStackAlignment(); |
1437 | } |
1438 | |
1439 | Type *AttributeList::getParamByValType(unsigned Index) const { |
1440 | return getAttributes(Index+FirstArgIndex).getByValType(); |
1441 | } |
1442 | |
1443 | Type *AttributeList::getParamStructRetType(unsigned Index) const { |
1444 | return getAttributes(Index + FirstArgIndex).getStructRetType(); |
1445 | } |
1446 | |
1447 | Type *AttributeList::getParamByRefType(unsigned Index) const { |
1448 | return getAttributes(Index + FirstArgIndex).getByRefType(); |
1449 | } |
1450 | |
1451 | Type *AttributeList::getParamPreallocatedType(unsigned Index) const { |
1452 | return getAttributes(Index + FirstArgIndex).getPreallocatedType(); |
1453 | } |
1454 | |
1455 | Type *AttributeList::getParamInAllocaType(unsigned Index) const { |
1456 | return getAttributes(Index + FirstArgIndex).getInAllocaType(); |
1457 | } |
1458 | |
1459 | Type *AttributeList::getParamElementType(unsigned Index) const { |
1460 | return getAttributes(Index + FirstArgIndex).getElementType(); |
1461 | } |
1462 | |
1463 | MaybeAlign AttributeList::getStackAlignment(unsigned Index) const { |
1464 | return getAttributes(Index).getStackAlignment(); |
1465 | } |
1466 | |
1467 | uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const { |
1468 | return getAttributes(Index).getDereferenceableBytes(); |
1469 | } |
1470 | |
1471 | uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const { |
1472 | return getAttributes(Index).getDereferenceableOrNullBytes(); |
1473 | } |
1474 | |
1475 | std::pair<unsigned, Optional<unsigned>> |
1476 | AttributeList::getAllocSizeArgs(unsigned Index) const { |
1477 | return getAttributes(Index).getAllocSizeArgs(); |
1478 | } |
1479 | |
1480 | std::pair<unsigned, unsigned> |
1481 | AttributeList::getVScaleRangeArgs(unsigned Index) const { |
1482 | return getAttributes(Index).getVScaleRangeArgs(); |
1483 | } |
1484 | |
1485 | std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const { |
1486 | return getAttributes(Index).getAsString(InAttrGrp); |
1487 | } |
1488 | |
1489 | AttributeSet AttributeList::getAttributes(unsigned Index) const { |
1490 | Index = attrIdxToArrayIdx(Index); |
1491 | if (!pImpl || Index >= getNumAttrSets()) |
1492 | return {}; |
1493 | return pImpl->begin()[Index]; |
1494 | } |
1495 | |
1496 | bool AttributeList::hasParentContext(LLVMContext &C) const { |
1497 | assert(!isEmpty() && "an empty attribute list has no parent context"); |
1498 | FoldingSetNodeID ID; |
1499 | pImpl->Profile(ID); |
1500 | void *Unused; |
1501 | return C.pImpl->AttrsLists.FindNodeOrInsertPos(ID, Unused) == pImpl; |
1502 | } |
1503 | |
1504 | AttributeList::iterator AttributeList::begin() const { |
1505 | return pImpl ? pImpl->begin() : nullptr; |
1506 | } |
1507 | |
1508 | AttributeList::iterator AttributeList::end() const { |
1509 | return pImpl ? pImpl->end() : nullptr; |
1510 | } |
1511 | |
1512 | |
1513 | |
1514 | |
1515 | |
1516 | unsigned AttributeList::getNumAttrSets() const { |
1517 | return pImpl ? pImpl->NumAttrSets : 0; |
1518 | } |
1519 | |
1520 | void AttributeList::print(raw_ostream &O) const { |
1521 | O << "AttributeList[\n"; |
1522 | |
1523 | for (unsigned i = index_begin(), e = index_end(); i != e; ++i) { |
1524 | if (!getAttributes(i).hasAttributes()) |
1525 | continue; |
1526 | O << " { "; |
1527 | switch (i) { |
1528 | case AttrIndex::ReturnIndex: |
1529 | O << "return"; |
1530 | break; |
1531 | case AttrIndex::FunctionIndex: |
1532 | O << "function"; |
1533 | break; |
1534 | default: |
1535 | O << "arg(" << i - AttrIndex::FirstArgIndex << ")"; |
1536 | } |
1537 | O << " => " << getAsString(i) << " }\n"; |
1538 | } |
1539 | |
1540 | O << "]\n"; |
1541 | } |
1542 | |
1543 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
1544 | LLVM_DUMP_METHOD void AttributeList::dump() const { print(dbgs()); } |
1545 | #endif |
1546 | |
1547 | |
1548 | |
1549 | |
1550 | |
1551 | |
1552 | AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) { |
1553 | AttributeSet AS = AL.getAttributes(Index); |
1554 | for (const auto &A : AS) |
1555 | addAttribute(A); |
1556 | } |
1557 | |
1558 | AttrBuilder::AttrBuilder(AttributeSet AS) { |
1559 | for (const auto &A : AS) |
1560 | addAttribute(A); |
1561 | } |
1562 | |
1563 | void AttrBuilder::clear() { |
1564 | Attrs.reset(); |
1565 | TargetDepAttrs.clear(); |
1566 | Alignment.reset(); |
1567 | StackAlignment.reset(); |
1568 | DerefBytes = DerefOrNullBytes = 0; |
1569 | AllocSizeArgs = 0; |
1570 | VScaleRangeArgs = 0; |
1571 | TypeAttrs = {}; |
1572 | } |
1573 | |
1574 | Optional<unsigned> |
1575 | AttrBuilder::kindToTypeIndex(Attribute::AttrKind Kind) const { |
1576 | if (Attribute::isTypeAttrKind(Kind)) |
1577 | return Kind - Attribute::FirstTypeAttr; |
1578 | return None; |
1579 | } |
1580 | |
1581 | AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) { |
1582 | if (Attr.isStringAttribute()) { |
1583 | addAttribute(Attr.getKindAsString(), Attr.getValueAsString()); |
1584 | return *this; |
1585 | } |
1586 | |
1587 | Attribute::AttrKind Kind = Attr.getKindAsEnum(); |
1588 | Attrs[Kind] = true; |
1589 | |
1590 | if (Optional<unsigned> TypeIndex = kindToTypeIndex(Kind)) |
1591 | TypeAttrs[*TypeIndex] = Attr.getValueAsType(); |
1592 | else if (Kind == Attribute::Alignment) |
1593 | Alignment = Attr.getAlignment(); |
1594 | else if (Kind == Attribute::StackAlignment) |
1595 | StackAlignment = Attr.getStackAlignment(); |
1596 | else if (Kind == Attribute::Dereferenceable) |
1597 | DerefBytes = Attr.getDereferenceableBytes(); |
1598 | else if (Kind == Attribute::DereferenceableOrNull) |
1599 | DerefOrNullBytes = Attr.getDereferenceableOrNullBytes(); |
1600 | else if (Kind == Attribute::AllocSize) |
1601 | AllocSizeArgs = Attr.getValueAsInt(); |
1602 | else if (Kind == Attribute::VScaleRange) |
1603 | VScaleRangeArgs = Attr.getValueAsInt(); |
1604 | |
1605 | return *this; |
1606 | } |
1607 | |
1608 | AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) { |
1609 | TargetDepAttrs[A] = V; |
1610 | return *this; |
1611 | } |
1612 | |
1613 | AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) { |
1614 | assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!"); |
1615 | Attrs[Val] = false; |
1616 | |
1617 | if (Optional<unsigned> TypeIndex = kindToTypeIndex(Val)) |
1618 | TypeAttrs[*TypeIndex] = nullptr; |
1619 | else if (Val == Attribute::Alignment) |
1620 | Alignment.reset(); |
1621 | else if (Val == Attribute::StackAlignment) |
1622 | StackAlignment.reset(); |
1623 | else if (Val == Attribute::Dereferenceable) |
1624 | DerefBytes = 0; |
1625 | else if (Val == Attribute::DereferenceableOrNull) |
1626 | DerefOrNullBytes = 0; |
1627 | else if (Val == Attribute::AllocSize) |
1628 | AllocSizeArgs = 0; |
1629 | else if (Val == Attribute::VScaleRange) |
1630 | VScaleRangeArgs = 0; |
1631 | |
1632 | return *this; |
1633 | } |
1634 | |
1635 | AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) { |
1636 | remove(A.getAttributes(Index)); |
1637 | return *this; |
1638 | } |
1639 | |
1640 | AttrBuilder &AttrBuilder::removeAttribute(StringRef A) { |
1641 | auto I = TargetDepAttrs.find(A); |
1642 | if (I != TargetDepAttrs.end()) |
1643 | TargetDepAttrs.erase(I); |
1644 | return *this; |
1645 | } |
1646 | |
1647 | std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const { |
1648 | return unpackAllocSizeArgs(AllocSizeArgs); |
1649 | } |
1650 | |
1651 | std::pair<unsigned, unsigned> AttrBuilder::getVScaleRangeArgs() const { |
1652 | return unpackVScaleRangeArgs(VScaleRangeArgs); |
1653 | } |
1654 | |
1655 | AttrBuilder &AttrBuilder::addAlignmentAttr(MaybeAlign Align) { |
1656 | if (!Align) |
1657 | return *this; |
1658 | |
1659 | assert(*Align <= llvm::Value::MaximumAlignment && "Alignment too large."); |
1660 | |
1661 | Attrs[Attribute::Alignment] = true; |
1662 | Alignment = Align; |
1663 | return *this; |
1664 | } |
1665 | |
1666 | AttrBuilder &AttrBuilder::addStackAlignmentAttr(MaybeAlign Align) { |
1667 | |
1668 | if (!Align) |
1669 | return *this; |
1670 | |
1671 | assert(*Align <= 0x100 && "Alignment too large."); |
1672 | |
1673 | Attrs[Attribute::StackAlignment] = true; |
1674 | StackAlignment = Align; |
1675 | return *this; |
1676 | } |
1677 | |
1678 | AttrBuilder &AttrBuilder::addDereferenceableAttr(uint64_t Bytes) { |
1679 | if (Bytes == 0) return *this; |
1680 | |
1681 | Attrs[Attribute::Dereferenceable] = true; |
1682 | DerefBytes = Bytes; |
1683 | return *this; |
1684 | } |
1685 | |
1686 | AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) { |
1687 | if (Bytes == 0) |
1688 | return *this; |
1689 | |
1690 | Attrs[Attribute::DereferenceableOrNull] = true; |
1691 | DerefOrNullBytes = Bytes; |
1692 | return *this; |
1693 | } |
1694 | |
1695 | AttrBuilder &AttrBuilder::addAllocSizeAttr(unsigned ElemSize, |
1696 | const Optional<unsigned> &NumElems) { |
1697 | return addAllocSizeAttrFromRawRepr(packAllocSizeArgs(ElemSize, NumElems)); |
1698 | } |
1699 | |
1700 | AttrBuilder &AttrBuilder::addAllocSizeAttrFromRawRepr(uint64_t RawArgs) { |
1701 | |
1702 | assert(RawArgs && "Invalid allocsize arguments -- given allocsize(0, 0)"); |
1703 | |
1704 | Attrs[Attribute::AllocSize] = true; |
1705 | |
1706 | |
1707 | AllocSizeArgs = RawArgs; |
1708 | return *this; |
1709 | } |
1710 | |
1711 | AttrBuilder &AttrBuilder::addVScaleRangeAttr(unsigned MinValue, |
1712 | unsigned MaxValue) { |
1713 | return addVScaleRangeAttrFromRawRepr(packVScaleRangeArgs(MinValue, MaxValue)); |
1714 | } |
1715 | |
1716 | AttrBuilder &AttrBuilder::addVScaleRangeAttrFromRawRepr(uint64_t RawArgs) { |
1717 | |
1718 | if (RawArgs == 0) |
1719 | return *this; |
1720 | |
1721 | Attrs[Attribute::VScaleRange] = true; |
1722 | |
1723 | |
1724 | VScaleRangeArgs = RawArgs; |
1725 | return *this; |
1726 | } |
1727 | |
1728 | Type *AttrBuilder::getTypeAttr(Attribute::AttrKind Kind) const { |
1729 | Optional<unsigned> TypeIndex = kindToTypeIndex(Kind); |
1730 | assert(TypeIndex && "Not a type attribute"); |
1731 | return TypeAttrs[*TypeIndex]; |
1732 | } |
1733 | |
1734 | AttrBuilder &AttrBuilder::addTypeAttr(Attribute::AttrKind Kind, Type *Ty) { |
1735 | Optional<unsigned> TypeIndex = kindToTypeIndex(Kind); |
1736 | assert(TypeIndex && "Not a type attribute"); |
1737 | Attrs[Kind] = true; |
1738 | TypeAttrs[*TypeIndex] = Ty; |
1739 | return *this; |
1740 | } |
1741 | |
1742 | AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) { |
1743 | return addTypeAttr(Attribute::ByVal, Ty); |
1744 | } |
1745 | |
1746 | AttrBuilder &AttrBuilder::addStructRetAttr(Type *Ty) { |
1747 | return addTypeAttr(Attribute::StructRet, Ty); |
1748 | } |
1749 | |
1750 | AttrBuilder &AttrBuilder::addByRefAttr(Type *Ty) { |
1751 | return addTypeAttr(Attribute::ByRef, Ty); |
1752 | } |
1753 | |
1754 | AttrBuilder &AttrBuilder::addPreallocatedAttr(Type *Ty) { |
1755 | return addTypeAttr(Attribute::Preallocated, Ty); |
1756 | } |
1757 | |
1758 | AttrBuilder &AttrBuilder::addInAllocaAttr(Type *Ty) { |
1759 | return addTypeAttr(Attribute::InAlloca, Ty); |
1760 | } |
1761 | |
1762 | AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) { |
1763 | |
1764 | if (!Alignment) |
1765 | Alignment = B.Alignment; |
1766 | |
1767 | if (!StackAlignment) |
1768 | StackAlignment = B.StackAlignment; |
1769 | |
1770 | if (!DerefBytes) |
1771 | DerefBytes = B.DerefBytes; |
1772 | |
1773 | if (!DerefOrNullBytes) |
1774 | DerefOrNullBytes = B.DerefOrNullBytes; |
1775 | |
1776 | if (!AllocSizeArgs) |
1777 | AllocSizeArgs = B.AllocSizeArgs; |
1778 | |
1779 | if (!VScaleRangeArgs) |
1780 | VScaleRangeArgs = B.VScaleRangeArgs; |
1781 | |
1782 | for (unsigned Index = 0; Index < Attribute::NumTypeAttrKinds; ++Index) |
1783 | if (!TypeAttrs[Index]) |
1784 | TypeAttrs[Index] = B.TypeAttrs[Index]; |
1785 | |
1786 | Attrs |= B.Attrs; |
1787 | |
1788 | for (const auto &I : B.td_attrs()) |
1789 | TargetDepAttrs[I.first] = I.second; |
1790 | |
1791 | return *this; |
1792 | } |
1793 | |
1794 | AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) { |
1795 | |
1796 | if (B.Alignment) |
1797 | Alignment.reset(); |
1798 | |
1799 | if (B.StackAlignment) |
1800 | StackAlignment.reset(); |
1801 | |
1802 | if (B.DerefBytes) |
1803 | DerefBytes = 0; |
1804 | |
1805 | if (B.DerefOrNullBytes) |
1806 | DerefOrNullBytes = 0; |
1807 | |
1808 | if (B.AllocSizeArgs) |
1809 | AllocSizeArgs = 0; |
1810 | |
1811 | if (B.VScaleRangeArgs) |
1812 | VScaleRangeArgs = 0; |
1813 | |
1814 | for (unsigned Index = 0; Index < Attribute::NumTypeAttrKinds; ++Index) |
1815 | if (B.TypeAttrs[Index]) |
1816 | TypeAttrs[Index] = nullptr; |
1817 | |
1818 | Attrs &= ~B.Attrs; |
1819 | |
1820 | for (const auto &I : B.td_attrs()) |
1821 | TargetDepAttrs.erase(I.first); |
1822 | |
1823 | return *this; |
1824 | } |
1825 | |
1826 | bool AttrBuilder::overlaps(const AttrBuilder &B) const { |
1827 | |
1828 | if ((Attrs & B.Attrs).any()) |
1829 | return true; |
1830 | |
1831 | |
1832 | for (const auto &I : td_attrs()) |
1833 | if (B.contains(I.first)) |
1834 | return true; |
1835 | |
1836 | return false; |
1837 | } |
1838 | |
1839 | bool AttrBuilder::contains(StringRef A) const { |
1840 | return TargetDepAttrs.find(A) != TargetDepAttrs.end(); |
1841 | } |
1842 | |
1843 | bool AttrBuilder::hasAttributes() const { |
1844 | return !Attrs.none() || !TargetDepAttrs.empty(); |
1845 | } |
1846 | |
1847 | bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const { |
1848 | AttributeSet AS = AL.getAttributes(Index); |
1849 | |
1850 | for (const auto &Attr : AS) { |
1851 | if (Attr.isEnumAttribute() || Attr.isIntAttribute()) { |
1852 | if (contains(Attr.getKindAsEnum())) |
1853 | return true; |
1854 | } else { |
1855 | assert(Attr.isStringAttribute() && "Invalid attribute kind!"); |
1856 | return contains(Attr.getKindAsString()); |
1857 | } |
1858 | } |
1859 | |
1860 | return false; |
1861 | } |
1862 | |
1863 | bool AttrBuilder::hasAlignmentAttr() const { |
1864 | return Alignment != 0; |
1865 | } |
1866 | |
1867 | bool AttrBuilder::operator==(const AttrBuilder &B) const { |
1868 | if (Attrs != B.Attrs) |
1869 | return false; |
1870 | |
1871 | for (const auto &TDA : TargetDepAttrs) |
1872 | if (B.TargetDepAttrs.find(TDA.first) == B.TargetDepAttrs.end()) |
1873 | return false; |
1874 | |
1875 | return Alignment == B.Alignment && StackAlignment == B.StackAlignment && |
1876 | DerefBytes == B.DerefBytes && TypeAttrs == B.TypeAttrs && |
1877 | VScaleRangeArgs == B.VScaleRangeArgs; |
1878 | } |
1879 | |
1880 | |
1881 | |
1882 | |
1883 | |
1884 | |
1885 | AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) { |
1886 | AttrBuilder Incompatible; |
1887 | |
1888 | if (!Ty->isIntegerTy()) |
1889 | |
1890 | Incompatible.addAttribute(Attribute::SExt) |
1891 | .addAttribute(Attribute::ZExt); |
1892 | |
1893 | if (!Ty->isPointerTy()) |
1894 | |
1895 | Incompatible.addAttribute(Attribute::Nest) |
1896 | .addAttribute(Attribute::NoAlias) |
1897 | .addAttribute(Attribute::NoCapture) |
1898 | .addAttribute(Attribute::NonNull) |
1899 | .addAttribute(Attribute::ReadNone) |
1900 | .addAttribute(Attribute::ReadOnly) |
1901 | .addAttribute(Attribute::SwiftError) |
1902 | .addAlignmentAttr(1) |
1903 | .addDereferenceableAttr(1) |
1904 | .addDereferenceableOrNullAttr(1) |
1905 | .addPreallocatedAttr(Ty) |
1906 | .addInAllocaAttr(Ty) |
1907 | .addByValAttr(Ty) |
1908 | .addStructRetAttr(Ty) |
1909 | .addByRefAttr(Ty) |
1910 | .addTypeAttr(Attribute::ElementType, Ty); |
1911 | |
1912 | |
1913 | if (Ty->isVoidTy()) |
1914 | Incompatible.addAttribute(Attribute::NoUndef); |
1915 | |
1916 | return Incompatible; |
1917 | } |
1918 | |
1919 | AttrBuilder AttributeFuncs::getUBImplyingAttributes() { |
1920 | AttrBuilder B; |
1921 | B.addAttribute(Attribute::NoUndef); |
1922 | B.addDereferenceableAttr(1); |
1923 | B.addDereferenceableOrNullAttr(1); |
1924 | return B; |
1925 | } |
1926 | |
1927 | template<typename AttrClass> |
1928 | static bool isEqual(const Function &Caller, const Function &Callee) { |
1929 | return Caller.getFnAttribute(AttrClass::getKind()) == |
1930 | Callee.getFnAttribute(AttrClass::getKind()); |
1931 | } |
1932 | |
1933 | |
1934 | |
1935 | |
1936 | |
1937 | |
1938 | template<typename AttrClass> |
1939 | static void setAND(Function &Caller, const Function &Callee) { |
1940 | if (AttrClass::isSet(Caller, AttrClass::getKind()) && |
1941 | !AttrClass::isSet(Callee, AttrClass::getKind())) |
1942 | AttrClass::set(Caller, AttrClass::getKind(), false); |
1943 | } |
1944 | |
1945 | |
1946 | |
1947 | |
1948 | |
1949 | |
1950 | template<typename AttrClass> |
1951 | static void setOR(Function &Caller, const Function &Callee) { |
1952 | if (!AttrClass::isSet(Caller, AttrClass::getKind()) && |
1953 | AttrClass::isSet(Callee, AttrClass::getKind())) |
1954 | AttrClass::set(Caller, AttrClass::getKind(), true); |
1955 | } |
1956 | |
1957 | |
1958 | |
1959 | static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) { |
1960 | |
1961 | |
1962 | |
1963 | AttrBuilder OldSSPAttr; |
1964 | OldSSPAttr.addAttribute(Attribute::StackProtect) |
1965 | .addAttribute(Attribute::StackProtectStrong) |
1966 | .addAttribute(Attribute::StackProtectReq); |
1967 | |
1968 | if (Callee.hasFnAttribute(Attribute::StackProtectReq)) { |
1969 | Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr); |
1970 | Caller.addFnAttr(Attribute::StackProtectReq); |
1971 | } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) && |
1972 | !Caller.hasFnAttribute(Attribute::StackProtectReq)) { |
1973 | Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr); |
1974 | Caller.addFnAttr(Attribute::StackProtectStrong); |
1975 | } else if (Callee.hasFnAttribute(Attribute::StackProtect) && |
1976 | !Caller.hasFnAttribute(Attribute::StackProtectReq) && |
1977 | !Caller.hasFnAttribute(Attribute::StackProtectStrong)) |
1978 | Caller.addFnAttr(Attribute::StackProtect); |
1979 | } |
1980 | |
1981 | |
1982 | |
1983 | static void adjustCallerStackProbes(Function &Caller, const Function &Callee) { |
1984 | if (!Caller.hasFnAttribute("probe-stack") && |
1985 | Callee.hasFnAttribute("probe-stack")) { |
1986 | Caller.addFnAttr(Callee.getFnAttribute("probe-stack")); |
1987 | } |
1988 | } |
1989 | |
1990 | |
1991 | |
1992 | |
1993 | static void |
1994 | adjustCallerStackProbeSize(Function &Caller, const Function &Callee) { |
1995 | Attribute CalleeAttr = Callee.getFnAttribute("stack-probe-size"); |
1996 | if (CalleeAttr.isValid()) { |
1997 | Attribute CallerAttr = Caller.getFnAttribute("stack-probe-size"); |
1998 | if (CallerAttr.isValid()) { |
1999 | uint64_t CallerStackProbeSize, CalleeStackProbeSize; |
2000 | CallerAttr.getValueAsString().getAsInteger(0, CallerStackProbeSize); |
2001 | CalleeAttr.getValueAsString().getAsInteger(0, CalleeStackProbeSize); |
2002 | |
2003 | if (CallerStackProbeSize > CalleeStackProbeSize) { |
2004 | Caller.addFnAttr(CalleeAttr); |
2005 | } |
2006 | } else { |
2007 | Caller.addFnAttr(CalleeAttr); |
2008 | } |
2009 | } |
2010 | } |
2011 | |
2012 | |
2013 | |
2014 | |
2015 | |
2016 | |
2017 | |
2018 | |
2019 | |
2020 | |
2021 | static void |
2022 | adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) { |
2023 | Attribute CallerAttr = Caller.getFnAttribute("min-legal-vector-width"); |
2024 | if (CallerAttr.isValid()) { |
2025 | Attribute CalleeAttr = Callee.getFnAttribute("min-legal-vector-width"); |
2026 | if (CalleeAttr.isValid()) { |
2027 | uint64_t CallerVectorWidth, CalleeVectorWidth; |
2028 | CallerAttr.getValueAsString().getAsInteger(0, CallerVectorWidth); |
2029 | CalleeAttr.getValueAsString().getAsInteger(0, CalleeVectorWidth); |
2030 | if (CallerVectorWidth < CalleeVectorWidth) |
2031 | Caller.addFnAttr(CalleeAttr); |
2032 | } else { |
2033 | |
2034 | |
2035 | Caller.removeFnAttr("min-legal-vector-width"); |
2036 | } |
2037 | } |
2038 | } |
2039 | |
2040 | |
2041 | |
2042 | static void |
2043 | adjustNullPointerValidAttr(Function &Caller, const Function &Callee) { |
2044 | if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) { |
2045 | Caller.addFnAttr(Attribute::NullPointerIsValid); |
2046 | } |
2047 | } |
2048 | |
2049 | struct EnumAttr { |
2050 | static bool isSet(const Function &Fn, |
2051 | Attribute::AttrKind Kind) { |
2052 | return Fn.hasFnAttribute(Kind); |
2053 | } |
2054 | |
2055 | static void set(Function &Fn, |
2056 | Attribute::AttrKind Kind, bool Val) { |
2057 | if (Val) |
2058 | Fn.addFnAttr(Kind); |
2059 | else |
2060 | Fn.removeFnAttr(Kind); |
2061 | } |
2062 | }; |
2063 | |
2064 | struct StrBoolAttr { |
2065 | static bool isSet(const Function &Fn, |
2066 | StringRef Kind) { |
2067 | auto A = Fn.getFnAttribute(Kind); |
2068 | return A.getValueAsString().equals("true"); |
2069 | } |
2070 | |
2071 | static void set(Function &Fn, |
2072 | StringRef Kind, bool Val) { |
2073 | Fn.addFnAttr(Kind, Val ? "true" : "false"); |
2074 | } |
2075 | }; |
2076 | |
2077 | #define GET_ATTR_NAMES |
2078 | #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \ |
2079 | struct ENUM_NAME##Attr : EnumAttr { \ |
2080 | static enum Attribute::AttrKind getKind() { \ |
2081 | return llvm::Attribute::ENUM_NAME; \ |
2082 | } \ |
2083 | }; |
2084 | #define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \ |
2085 | struct ENUM_NAME##Attr : StrBoolAttr { \ |
2086 | static StringRef getKind() { return #DISPLAY_NAME; } \ |
2087 | }; |
2088 | #include "llvm/IR/Attributes.inc" |
2089 | |
2090 | #define GET_ATTR_COMPAT_FUNC |
2091 | #include "llvm/IR/Attributes.inc" |
2092 | |
2093 | bool AttributeFuncs::areInlineCompatible(const Function &Caller, |
2094 | const Function &Callee) { |
2095 | return hasCompatibleFnAttrs(Caller, Callee); |
2096 | } |
2097 | |
2098 | bool AttributeFuncs::areOutlineCompatible(const Function &A, |
2099 | const Function &B) { |
2100 | return hasCompatibleFnAttrs(A, B); |
2101 | } |
2102 | |
2103 | void AttributeFuncs::mergeAttributesForInlining(Function &Caller, |
2104 | const Function &Callee) { |
2105 | mergeFnAttrs(Caller, Callee); |
2106 | } |
2107 | |
2108 | void AttributeFuncs::mergeAttributesForOutlining(Function &Base, |
2109 | const Function &ToMerge) { |
2110 | |
2111 | |
2112 | |
2113 | |
2114 | |
2115 | |
2116 | |
2117 | |
2118 | mergeFnAttrs(Base, ToMerge); |
2119 | } |