1 | //===- Function.cpp - Implement the Global object classes -----------------===// |
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 implements the Function class for the IR library. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "llvm/IR/Function.h" |
14 | #include "SymbolTableListTraitsImpl.h" |
15 | #include "llvm/ADT/ArrayRef.h" |
16 | #include "llvm/ADT/DenseSet.h" |
17 | #include "llvm/ADT/STLExtras.h" |
18 | #include "llvm/ADT/SmallString.h" |
19 | #include "llvm/ADT/SmallVector.h" |
20 | #include "llvm/ADT/StringExtras.h" |
21 | #include "llvm/ADT/StringRef.h" |
22 | #include "llvm/IR/AbstractCallSite.h" |
23 | #include "llvm/IR/Argument.h" |
24 | #include "llvm/IR/Attributes.h" |
25 | #include "llvm/IR/BasicBlock.h" |
26 | #include "llvm/IR/Constant.h" |
27 | #include "llvm/IR/ConstantRange.h" |
28 | #include "llvm/IR/Constants.h" |
29 | #include "llvm/IR/DerivedTypes.h" |
30 | #include "llvm/IR/GlobalValue.h" |
31 | #include "llvm/IR/InstIterator.h" |
32 | #include "llvm/IR/Instruction.h" |
33 | #include "llvm/IR/IntrinsicInst.h" |
34 | #include "llvm/IR/Intrinsics.h" |
35 | #include "llvm/IR/IntrinsicsAArch64.h" |
36 | #include "llvm/IR/IntrinsicsAMDGPU.h" |
37 | #include "llvm/IR/IntrinsicsARM.h" |
38 | #include "llvm/IR/IntrinsicsBPF.h" |
39 | #include "llvm/IR/IntrinsicsDirectX.h" |
40 | #include "llvm/IR/IntrinsicsHexagon.h" |
41 | #include "llvm/IR/IntrinsicsLoongArch.h" |
42 | #include "llvm/IR/IntrinsicsMips.h" |
43 | #include "llvm/IR/IntrinsicsNVPTX.h" |
44 | #include "llvm/IR/IntrinsicsPowerPC.h" |
45 | #include "llvm/IR/IntrinsicsR600.h" |
46 | #include "llvm/IR/IntrinsicsRISCV.h" |
47 | #include "llvm/IR/IntrinsicsS390.h" |
48 | #include "llvm/IR/IntrinsicsSPIRV.h" |
49 | #include "llvm/IR/IntrinsicsVE.h" |
50 | #include "llvm/IR/IntrinsicsWebAssembly.h" |
51 | #include "llvm/IR/IntrinsicsX86.h" |
52 | #include "llvm/IR/IntrinsicsXCore.h" |
53 | #include "llvm/IR/LLVMContext.h" |
54 | #include "llvm/IR/MDBuilder.h" |
55 | #include "llvm/IR/Metadata.h" |
56 | #include "llvm/IR/Module.h" |
57 | #include "llvm/IR/Operator.h" |
58 | #include "llvm/IR/SymbolTableListTraits.h" |
59 | #include "llvm/IR/Type.h" |
60 | #include "llvm/IR/Use.h" |
61 | #include "llvm/IR/User.h" |
62 | #include "llvm/IR/Value.h" |
63 | #include "llvm/IR/ValueSymbolTable.h" |
64 | #include "llvm/Support/Casting.h" |
65 | #include "llvm/Support/CommandLine.h" |
66 | #include "llvm/Support/Compiler.h" |
67 | #include "llvm/Support/ErrorHandling.h" |
68 | #include "llvm/Support/ModRef.h" |
69 | #include <cassert> |
70 | #include <cstddef> |
71 | #include <cstdint> |
72 | #include <cstring> |
73 | #include <string> |
74 | |
75 | using namespace llvm; |
76 | using ProfileCount = Function::ProfileCount; |
77 | |
78 | // Explicit instantiations of SymbolTableListTraits since some of the methods |
79 | // are not in the public header file... |
80 | template class llvm::SymbolTableListTraits<BasicBlock>; |
81 | |
82 | static cl::opt<unsigned> NonGlobalValueMaxNameSize( |
83 | "non-global-value-max-name-size" , cl::Hidden, cl::init(Val: 1024), |
84 | cl::desc("Maximum size for the name of non-global values." )); |
85 | |
86 | void Function::convertToNewDbgValues() { |
87 | IsNewDbgInfoFormat = true; |
88 | for (auto &BB : *this) { |
89 | BB.convertToNewDbgValues(); |
90 | } |
91 | } |
92 | |
93 | void Function::convertFromNewDbgValues() { |
94 | IsNewDbgInfoFormat = false; |
95 | for (auto &BB : *this) { |
96 | BB.convertFromNewDbgValues(); |
97 | } |
98 | } |
99 | |
100 | void Function::setIsNewDbgInfoFormat(bool NewFlag) { |
101 | if (NewFlag && !IsNewDbgInfoFormat) |
102 | convertToNewDbgValues(); |
103 | else if (!NewFlag && IsNewDbgInfoFormat) |
104 | convertFromNewDbgValues(); |
105 | } |
106 | void Function::setNewDbgInfoFormatFlag(bool NewFlag) { |
107 | for (auto &BB : *this) { |
108 | BB.setNewDbgInfoFormatFlag(NewFlag); |
109 | } |
110 | IsNewDbgInfoFormat = NewFlag; |
111 | } |
112 | |
113 | //===----------------------------------------------------------------------===// |
114 | // Argument Implementation |
115 | //===----------------------------------------------------------------------===// |
116 | |
117 | Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo) |
118 | : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) { |
119 | setName(Name); |
120 | } |
121 | |
122 | void Argument::setParent(Function *parent) { |
123 | Parent = parent; |
124 | } |
125 | |
126 | bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const { |
127 | if (!getType()->isPointerTy()) return false; |
128 | if (getParent()->hasParamAttribute(ArgNo: getArgNo(), Attribute::Kind: NonNull) && |
129 | (AllowUndefOrPoison || |
130 | getParent()->hasParamAttribute(ArgNo: getArgNo(), Attribute::Kind: NoUndef))) |
131 | return true; |
132 | else if (getDereferenceableBytes() > 0 && |
133 | !NullPointerIsDefined(F: getParent(), |
134 | AS: getType()->getPointerAddressSpace())) |
135 | return true; |
136 | return false; |
137 | } |
138 | |
139 | bool Argument::hasByValAttr() const { |
140 | if (!getType()->isPointerTy()) return false; |
141 | return hasAttribute(Attribute::Kind: ByVal); |
142 | } |
143 | |
144 | bool Argument::hasByRefAttr() const { |
145 | if (!getType()->isPointerTy()) |
146 | return false; |
147 | return hasAttribute(Attribute::Kind: ByRef); |
148 | } |
149 | |
150 | bool Argument::hasSwiftSelfAttr() const { |
151 | return getParent()->hasParamAttribute(ArgNo: getArgNo(), Attribute::Kind: SwiftSelf); |
152 | } |
153 | |
154 | bool Argument::hasSwiftErrorAttr() const { |
155 | return getParent()->hasParamAttribute(ArgNo: getArgNo(), Attribute::Kind: SwiftError); |
156 | } |
157 | |
158 | bool Argument::hasInAllocaAttr() const { |
159 | if (!getType()->isPointerTy()) return false; |
160 | return hasAttribute(Attribute::Kind: InAlloca); |
161 | } |
162 | |
163 | bool Argument::hasPreallocatedAttr() const { |
164 | if (!getType()->isPointerTy()) |
165 | return false; |
166 | return hasAttribute(Attribute::Kind: Preallocated); |
167 | } |
168 | |
169 | bool Argument::hasPassPointeeByValueCopyAttr() const { |
170 | if (!getType()->isPointerTy()) return false; |
171 | AttributeList Attrs = getParent()->getAttributes(); |
172 | return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) || |
173 | Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) || |
174 | Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated); |
175 | } |
176 | |
177 | bool Argument::hasPointeeInMemoryValueAttr() const { |
178 | if (!getType()->isPointerTy()) |
179 | return false; |
180 | AttributeList Attrs = getParent()->getAttributes(); |
181 | return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) || |
182 | Attrs.hasParamAttr(getArgNo(), Attribute::StructRet) || |
183 | Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) || |
184 | Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated) || |
185 | Attrs.hasParamAttr(getArgNo(), Attribute::ByRef); |
186 | } |
187 | |
188 | /// For a byval, sret, inalloca, or preallocated parameter, get the in-memory |
189 | /// parameter type. |
190 | static Type *getMemoryParamAllocType(AttributeSet ParamAttrs) { |
191 | // FIXME: All the type carrying attributes are mutually exclusive, so there |
192 | // should be a single query to get the stored type that handles any of them. |
193 | if (Type *ByValTy = ParamAttrs.getByValType()) |
194 | return ByValTy; |
195 | if (Type *ByRefTy = ParamAttrs.getByRefType()) |
196 | return ByRefTy; |
197 | if (Type *PreAllocTy = ParamAttrs.getPreallocatedType()) |
198 | return PreAllocTy; |
199 | if (Type *InAllocaTy = ParamAttrs.getInAllocaType()) |
200 | return InAllocaTy; |
201 | if (Type *SRetTy = ParamAttrs.getStructRetType()) |
202 | return SRetTy; |
203 | |
204 | return nullptr; |
205 | } |
206 | |
207 | uint64_t Argument::getPassPointeeByValueCopySize(const DataLayout &DL) const { |
208 | AttributeSet ParamAttrs = |
209 | getParent()->getAttributes().getParamAttrs(ArgNo: getArgNo()); |
210 | if (Type *MemTy = getMemoryParamAllocType(ParamAttrs)) |
211 | return DL.getTypeAllocSize(Ty: MemTy); |
212 | return 0; |
213 | } |
214 | |
215 | Type *Argument::getPointeeInMemoryValueType() const { |
216 | AttributeSet ParamAttrs = |
217 | getParent()->getAttributes().getParamAttrs(ArgNo: getArgNo()); |
218 | return getMemoryParamAllocType(ParamAttrs); |
219 | } |
220 | |
221 | MaybeAlign Argument::getParamAlign() const { |
222 | assert(getType()->isPointerTy() && "Only pointers have alignments" ); |
223 | return getParent()->getParamAlign(ArgNo: getArgNo()); |
224 | } |
225 | |
226 | MaybeAlign Argument::getParamStackAlign() const { |
227 | return getParent()->getParamStackAlign(ArgNo: getArgNo()); |
228 | } |
229 | |
230 | Type *Argument::getParamByValType() const { |
231 | assert(getType()->isPointerTy() && "Only pointers have byval types" ); |
232 | return getParent()->getParamByValType(ArgNo: getArgNo()); |
233 | } |
234 | |
235 | Type *Argument::getParamStructRetType() const { |
236 | assert(getType()->isPointerTy() && "Only pointers have sret types" ); |
237 | return getParent()->getParamStructRetType(ArgNo: getArgNo()); |
238 | } |
239 | |
240 | Type *Argument::getParamByRefType() const { |
241 | assert(getType()->isPointerTy() && "Only pointers have byref types" ); |
242 | return getParent()->getParamByRefType(ArgNo: getArgNo()); |
243 | } |
244 | |
245 | Type *Argument::getParamInAllocaType() const { |
246 | assert(getType()->isPointerTy() && "Only pointers have inalloca types" ); |
247 | return getParent()->getParamInAllocaType(ArgNo: getArgNo()); |
248 | } |
249 | |
250 | uint64_t Argument::getDereferenceableBytes() const { |
251 | assert(getType()->isPointerTy() && |
252 | "Only pointers have dereferenceable bytes" ); |
253 | return getParent()->getParamDereferenceableBytes(ArgNo: getArgNo()); |
254 | } |
255 | |
256 | uint64_t Argument::getDereferenceableOrNullBytes() const { |
257 | assert(getType()->isPointerTy() && |
258 | "Only pointers have dereferenceable bytes" ); |
259 | return getParent()->getParamDereferenceableOrNullBytes(ArgNo: getArgNo()); |
260 | } |
261 | |
262 | FPClassTest Argument::getNoFPClass() const { |
263 | return getParent()->getParamNoFPClass(ArgNo: getArgNo()); |
264 | } |
265 | |
266 | std::optional<ConstantRange> Argument::getRange() const { |
267 | const Attribute RangeAttr = getAttribute(llvm::Attribute::Kind: Range); |
268 | if (RangeAttr.isValid()) |
269 | return RangeAttr.getRange(); |
270 | return std::nullopt; |
271 | } |
272 | |
273 | bool Argument::hasNestAttr() const { |
274 | if (!getType()->isPointerTy()) return false; |
275 | return hasAttribute(Attribute::Kind: Nest); |
276 | } |
277 | |
278 | bool Argument::hasNoAliasAttr() const { |
279 | if (!getType()->isPointerTy()) return false; |
280 | return hasAttribute(Attribute::Kind: NoAlias); |
281 | } |
282 | |
283 | bool Argument::hasNoCaptureAttr() const { |
284 | if (!getType()->isPointerTy()) return false; |
285 | return hasAttribute(Attribute::Kind: NoCapture); |
286 | } |
287 | |
288 | bool Argument::hasNoFreeAttr() const { |
289 | if (!getType()->isPointerTy()) return false; |
290 | return hasAttribute(Attribute::Kind: NoFree); |
291 | } |
292 | |
293 | bool Argument::hasStructRetAttr() const { |
294 | if (!getType()->isPointerTy()) return false; |
295 | return hasAttribute(Attribute::Kind: StructRet); |
296 | } |
297 | |
298 | bool Argument::hasInRegAttr() const { |
299 | return hasAttribute(Attribute::Kind: InReg); |
300 | } |
301 | |
302 | bool Argument::hasReturnedAttr() const { |
303 | return hasAttribute(Attribute::Kind: Returned); |
304 | } |
305 | |
306 | bool Argument::hasZExtAttr() const { |
307 | return hasAttribute(Attribute::Kind: ZExt); |
308 | } |
309 | |
310 | bool Argument::hasSExtAttr() const { |
311 | return hasAttribute(Attribute::Kind: SExt); |
312 | } |
313 | |
314 | bool Argument::onlyReadsMemory() const { |
315 | AttributeList Attrs = getParent()->getAttributes(); |
316 | return Attrs.hasParamAttr(getArgNo(), Attribute::ReadOnly) || |
317 | Attrs.hasParamAttr(getArgNo(), Attribute::ReadNone); |
318 | } |
319 | |
320 | void Argument::addAttrs(AttrBuilder &B) { |
321 | AttributeList AL = getParent()->getAttributes(); |
322 | AL = AL.addParamAttributes(C&: Parent->getContext(), ArgNo: getArgNo(), B); |
323 | getParent()->setAttributes(AL); |
324 | } |
325 | |
326 | void Argument::addAttr(Attribute::AttrKind Kind) { |
327 | getParent()->addParamAttr(ArgNo: getArgNo(), Kind); |
328 | } |
329 | |
330 | void Argument::addAttr(Attribute Attr) { |
331 | getParent()->addParamAttr(ArgNo: getArgNo(), Attr); |
332 | } |
333 | |
334 | void Argument::removeAttr(Attribute::AttrKind Kind) { |
335 | getParent()->removeParamAttr(ArgNo: getArgNo(), Kind); |
336 | } |
337 | |
338 | void Argument::removeAttrs(const AttributeMask &AM) { |
339 | AttributeList AL = getParent()->getAttributes(); |
340 | AL = AL.removeParamAttributes(C&: Parent->getContext(), ArgNo: getArgNo(), AttrsToRemove: AM); |
341 | getParent()->setAttributes(AL); |
342 | } |
343 | |
344 | bool Argument::hasAttribute(Attribute::AttrKind Kind) const { |
345 | return getParent()->hasParamAttribute(ArgNo: getArgNo(), Kind); |
346 | } |
347 | |
348 | Attribute Argument::getAttribute(Attribute::AttrKind Kind) const { |
349 | return getParent()->getParamAttribute(ArgNo: getArgNo(), Kind); |
350 | } |
351 | |
352 | //===----------------------------------------------------------------------===// |
353 | // Helper Methods in Function |
354 | //===----------------------------------------------------------------------===// |
355 | |
356 | LLVMContext &Function::getContext() const { |
357 | return getType()->getContext(); |
358 | } |
359 | |
360 | unsigned Function::getInstructionCount() const { |
361 | unsigned NumInstrs = 0; |
362 | for (const BasicBlock &BB : BasicBlocks) |
363 | NumInstrs += std::distance(first: BB.instructionsWithoutDebug().begin(), |
364 | last: BB.instructionsWithoutDebug().end()); |
365 | return NumInstrs; |
366 | } |
367 | |
368 | Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage, |
369 | const Twine &N, Module &M) { |
370 | return Create(Ty, Linkage, AddrSpace: M.getDataLayout().getProgramAddressSpace(), N, M: &M); |
371 | } |
372 | |
373 | Function *Function::createWithDefaultAttr(FunctionType *Ty, |
374 | LinkageTypes Linkage, |
375 | unsigned AddrSpace, const Twine &N, |
376 | Module *M) { |
377 | auto *F = new Function(Ty, Linkage, AddrSpace, N, M); |
378 | AttrBuilder B(F->getContext()); |
379 | UWTableKind UWTable = M->getUwtable(); |
380 | if (UWTable != UWTableKind::None) |
381 | B.addUWTableAttr(Kind: UWTable); |
382 | switch (M->getFramePointer()) { |
383 | case FramePointerKind::None: |
384 | // 0 ("none") is the default. |
385 | break; |
386 | case FramePointerKind::NonLeaf: |
387 | B.addAttribute(A: "frame-pointer" , V: "non-leaf" ); |
388 | break; |
389 | case FramePointerKind::All: |
390 | B.addAttribute(A: "frame-pointer" , V: "all" ); |
391 | break; |
392 | } |
393 | if (M->getModuleFlag(Key: "function_return_thunk_extern" )) |
394 | B.addAttribute(Attribute::FnRetThunkExtern); |
395 | F->addFnAttrs(Attrs: B); |
396 | return F; |
397 | } |
398 | |
399 | void Function::removeFromParent() { |
400 | getParent()->getFunctionList().remove(IT: getIterator()); |
401 | } |
402 | |
403 | void Function::eraseFromParent() { |
404 | getParent()->getFunctionList().erase(where: getIterator()); |
405 | } |
406 | |
407 | void Function::splice(Function::iterator ToIt, Function *FromF, |
408 | Function::iterator FromBeginIt, |
409 | Function::iterator FromEndIt) { |
410 | #ifdef EXPENSIVE_CHECKS |
411 | // Check that FromBeginIt is before FromEndIt. |
412 | auto FromFEnd = FromF->end(); |
413 | for (auto It = FromBeginIt; It != FromEndIt; ++It) |
414 | assert(It != FromFEnd && "FromBeginIt not before FromEndIt!" ); |
415 | #endif // EXPENSIVE_CHECKS |
416 | BasicBlocks.splice(where: ToIt, L2&: FromF->BasicBlocks, first: FromBeginIt, last: FromEndIt); |
417 | } |
418 | |
419 | Function::iterator Function::erase(Function::iterator FromIt, |
420 | Function::iterator ToIt) { |
421 | return BasicBlocks.erase(first: FromIt, last: ToIt); |
422 | } |
423 | |
424 | //===----------------------------------------------------------------------===// |
425 | // Function Implementation |
426 | //===----------------------------------------------------------------------===// |
427 | |
428 | static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) { |
429 | // If AS == -1 and we are passed a valid module pointer we place the function |
430 | // in the program address space. Otherwise we default to AS0. |
431 | if (AddrSpace == static_cast<unsigned>(-1)) |
432 | return M ? M->getDataLayout().getProgramAddressSpace() : 0; |
433 | return AddrSpace; |
434 | } |
435 | |
436 | Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, |
437 | const Twine &name, Module *ParentModule) |
438 | : GlobalObject(Ty, Value::FunctionVal, |
439 | OperandTraits<Function>::op_begin(U: this), 0, Linkage, name, |
440 | computeAddrSpace(AddrSpace, M: ParentModule)), |
441 | NumArgs(Ty->getNumParams()), IsNewDbgInfoFormat(false) { |
442 | assert(FunctionType::isValidReturnType(getReturnType()) && |
443 | "invalid return type" ); |
444 | setGlobalObjectSubClassData(0); |
445 | |
446 | // We only need a symbol table for a function if the context keeps value names |
447 | if (!getContext().shouldDiscardValueNames()) |
448 | SymTab = std::make_unique<ValueSymbolTable>(args&: NonGlobalValueMaxNameSize); |
449 | |
450 | // If the function has arguments, mark them as lazily built. |
451 | if (Ty->getNumParams()) |
452 | setValueSubclassData(1); // Set the "has lazy arguments" bit. |
453 | |
454 | if (ParentModule) { |
455 | ParentModule->getFunctionList().push_back(val: this); |
456 | IsNewDbgInfoFormat = ParentModule->IsNewDbgInfoFormat; |
457 | } |
458 | |
459 | HasLLVMReservedName = getName().starts_with(Prefix: "llvm." ); |
460 | // Ensure intrinsics have the right parameter attributes. |
461 | // Note, the IntID field will have been set in Value::setName if this function |
462 | // name is a valid intrinsic ID. |
463 | if (IntID) |
464 | setAttributes(Intrinsic::getAttributes(C&: getContext(), id: IntID)); |
465 | } |
466 | |
467 | Function::~Function() { |
468 | dropAllReferences(); // After this it is safe to delete instructions. |
469 | |
470 | // Delete all of the method arguments and unlink from symbol table... |
471 | if (Arguments) |
472 | clearArguments(); |
473 | |
474 | // Remove the function from the on-the-side GC table. |
475 | clearGC(); |
476 | } |
477 | |
478 | void Function::BuildLazyArguments() const { |
479 | // Create the arguments vector, all arguments start out unnamed. |
480 | auto *FT = getFunctionType(); |
481 | if (NumArgs > 0) { |
482 | Arguments = std::allocator<Argument>().allocate(n: NumArgs); |
483 | for (unsigned i = 0, e = NumArgs; i != e; ++i) { |
484 | Type *ArgTy = FT->getParamType(i); |
485 | assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!" ); |
486 | new (Arguments + i) Argument(ArgTy, "" , const_cast<Function *>(this), i); |
487 | } |
488 | } |
489 | |
490 | // Clear the lazy arguments bit. |
491 | unsigned SDC = getSubclassDataFromValue(); |
492 | SDC &= ~(1 << 0); |
493 | const_cast<Function*>(this)->setValueSubclassData(SDC); |
494 | assert(!hasLazyArguments()); |
495 | } |
496 | |
497 | static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) { |
498 | return MutableArrayRef<Argument>(Args, Count); |
499 | } |
500 | |
501 | bool Function::isConstrainedFPIntrinsic() const { |
502 | return Intrinsic::isConstrainedFPIntrinsic(QID: getIntrinsicID()); |
503 | } |
504 | |
505 | void Function::clearArguments() { |
506 | for (Argument &A : makeArgArray(Args: Arguments, Count: NumArgs)) { |
507 | A.setName("" ); |
508 | A.~Argument(); |
509 | } |
510 | std::allocator<Argument>().deallocate(p: Arguments, t: NumArgs); |
511 | Arguments = nullptr; |
512 | } |
513 | |
514 | void Function::stealArgumentListFrom(Function &Src) { |
515 | assert(isDeclaration() && "Expected no references to current arguments" ); |
516 | |
517 | // Drop the current arguments, if any, and set the lazy argument bit. |
518 | if (!hasLazyArguments()) { |
519 | assert(llvm::all_of(makeArgArray(Arguments, NumArgs), |
520 | [](const Argument &A) { return A.use_empty(); }) && |
521 | "Expected arguments to be unused in declaration" ); |
522 | clearArguments(); |
523 | setValueSubclassData(getSubclassDataFromValue() | (1 << 0)); |
524 | } |
525 | |
526 | // Nothing to steal if Src has lazy arguments. |
527 | if (Src.hasLazyArguments()) |
528 | return; |
529 | |
530 | // Steal arguments from Src, and fix the lazy argument bits. |
531 | assert(arg_size() == Src.arg_size()); |
532 | Arguments = Src.Arguments; |
533 | Src.Arguments = nullptr; |
534 | for (Argument &A : makeArgArray(Args: Arguments, Count: NumArgs)) { |
535 | // FIXME: This does the work of transferNodesFromList inefficiently. |
536 | SmallString<128> Name; |
537 | if (A.hasName()) |
538 | Name = A.getName(); |
539 | if (!Name.empty()) |
540 | A.setName("" ); |
541 | A.setParent(this); |
542 | if (!Name.empty()) |
543 | A.setName(Name); |
544 | } |
545 | |
546 | setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0)); |
547 | assert(!hasLazyArguments()); |
548 | Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0)); |
549 | } |
550 | |
551 | void Function::deleteBodyImpl(bool ShouldDrop) { |
552 | setIsMaterializable(false); |
553 | |
554 | for (BasicBlock &BB : *this) |
555 | BB.dropAllReferences(); |
556 | |
557 | // Delete all basic blocks. They are now unused, except possibly by |
558 | // blockaddresses, but BasicBlock's destructor takes care of those. |
559 | while (!BasicBlocks.empty()) |
560 | BasicBlocks.begin()->eraseFromParent(); |
561 | |
562 | if (getNumOperands()) { |
563 | if (ShouldDrop) { |
564 | // Drop uses of any optional data (real or placeholder). |
565 | User::dropAllReferences(); |
566 | setNumHungOffUseOperands(0); |
567 | } else { |
568 | // The code needs to match Function::allocHungoffUselist(). |
569 | auto *CPN = ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0)); |
570 | Op<0>().set(CPN); |
571 | Op<1>().set(CPN); |
572 | Op<2>().set(CPN); |
573 | } |
574 | setValueSubclassData(getSubclassDataFromValue() & ~0xe); |
575 | } |
576 | |
577 | // Metadata is stored in a side-table. |
578 | clearMetadata(); |
579 | } |
580 | |
581 | void Function::addAttributeAtIndex(unsigned i, Attribute Attr) { |
582 | AttributeSets = AttributeSets.addAttributeAtIndex(C&: getContext(), Index: i, A: Attr); |
583 | } |
584 | |
585 | void Function::addFnAttr(Attribute::AttrKind Kind) { |
586 | AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Kind); |
587 | } |
588 | |
589 | void Function::addFnAttr(StringRef Kind, StringRef Val) { |
590 | AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Kind, Value: Val); |
591 | } |
592 | |
593 | void Function::addFnAttr(Attribute Attr) { |
594 | AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Attr); |
595 | } |
596 | |
597 | void Function::addFnAttrs(const AttrBuilder &Attrs) { |
598 | AttributeSets = AttributeSets.addFnAttributes(C&: getContext(), B: Attrs); |
599 | } |
600 | |
601 | void Function::addRetAttr(Attribute::AttrKind Kind) { |
602 | AttributeSets = AttributeSets.addRetAttribute(C&: getContext(), Kind); |
603 | } |
604 | |
605 | void Function::addRetAttr(Attribute Attr) { |
606 | AttributeSets = AttributeSets.addRetAttribute(C&: getContext(), Attr); |
607 | } |
608 | |
609 | void Function::addRetAttrs(const AttrBuilder &Attrs) { |
610 | AttributeSets = AttributeSets.addRetAttributes(C&: getContext(), B: Attrs); |
611 | } |
612 | |
613 | void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
614 | AttributeSets = AttributeSets.addParamAttribute(C&: getContext(), ArgNo, Kind); |
615 | } |
616 | |
617 | void Function::addParamAttr(unsigned ArgNo, Attribute Attr) { |
618 | AttributeSets = AttributeSets.addParamAttribute(C&: getContext(), ArgNos: ArgNo, A: Attr); |
619 | } |
620 | |
621 | void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) { |
622 | AttributeSets = AttributeSets.addParamAttributes(C&: getContext(), ArgNo, B: Attrs); |
623 | } |
624 | |
625 | void Function::removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) { |
626 | AttributeSets = AttributeSets.removeAttributeAtIndex(C&: getContext(), Index: i, Kind); |
627 | } |
628 | |
629 | void Function::removeAttributeAtIndex(unsigned i, StringRef Kind) { |
630 | AttributeSets = AttributeSets.removeAttributeAtIndex(C&: getContext(), Index: i, Kind); |
631 | } |
632 | |
633 | void Function::removeFnAttr(Attribute::AttrKind Kind) { |
634 | AttributeSets = AttributeSets.removeFnAttribute(C&: getContext(), Kind); |
635 | } |
636 | |
637 | void Function::removeFnAttr(StringRef Kind) { |
638 | AttributeSets = AttributeSets.removeFnAttribute(C&: getContext(), Kind); |
639 | } |
640 | |
641 | void Function::removeFnAttrs(const AttributeMask &AM) { |
642 | AttributeSets = AttributeSets.removeFnAttributes(C&: getContext(), AttrsToRemove: AM); |
643 | } |
644 | |
645 | void Function::removeRetAttr(Attribute::AttrKind Kind) { |
646 | AttributeSets = AttributeSets.removeRetAttribute(C&: getContext(), Kind); |
647 | } |
648 | |
649 | void Function::removeRetAttr(StringRef Kind) { |
650 | AttributeSets = AttributeSets.removeRetAttribute(C&: getContext(), Kind); |
651 | } |
652 | |
653 | void Function::removeRetAttrs(const AttributeMask &Attrs) { |
654 | AttributeSets = AttributeSets.removeRetAttributes(C&: getContext(), AttrsToRemove: Attrs); |
655 | } |
656 | |
657 | void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
658 | AttributeSets = AttributeSets.removeParamAttribute(C&: getContext(), ArgNo, Kind); |
659 | } |
660 | |
661 | void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) { |
662 | AttributeSets = AttributeSets.removeParamAttribute(C&: getContext(), ArgNo, Kind); |
663 | } |
664 | |
665 | void Function::removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs) { |
666 | AttributeSets = |
667 | AttributeSets.removeParamAttributes(C&: getContext(), ArgNo, AttrsToRemove: Attrs); |
668 | } |
669 | |
670 | void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) { |
671 | AttributeSets = |
672 | AttributeSets.addDereferenceableParamAttr(C&: getContext(), ArgNo, Bytes); |
673 | } |
674 | |
675 | bool Function::hasFnAttribute(Attribute::AttrKind Kind) const { |
676 | return AttributeSets.hasFnAttr(Kind); |
677 | } |
678 | |
679 | bool Function::hasFnAttribute(StringRef Kind) const { |
680 | return AttributeSets.hasFnAttr(Kind); |
681 | } |
682 | |
683 | bool Function::hasRetAttribute(Attribute::AttrKind Kind) const { |
684 | return AttributeSets.hasRetAttr(Kind); |
685 | } |
686 | |
687 | bool Function::hasParamAttribute(unsigned ArgNo, |
688 | Attribute::AttrKind Kind) const { |
689 | return AttributeSets.hasParamAttr(ArgNo, Kind); |
690 | } |
691 | |
692 | Attribute Function::getAttributeAtIndex(unsigned i, |
693 | Attribute::AttrKind Kind) const { |
694 | return AttributeSets.getAttributeAtIndex(Index: i, Kind); |
695 | } |
696 | |
697 | Attribute Function::getAttributeAtIndex(unsigned i, StringRef Kind) const { |
698 | return AttributeSets.getAttributeAtIndex(Index: i, Kind); |
699 | } |
700 | |
701 | Attribute Function::getFnAttribute(Attribute::AttrKind Kind) const { |
702 | return AttributeSets.getFnAttr(Kind); |
703 | } |
704 | |
705 | Attribute Function::getFnAttribute(StringRef Kind) const { |
706 | return AttributeSets.getFnAttr(Kind); |
707 | } |
708 | |
709 | Attribute Function::getRetAttribute(Attribute::AttrKind Kind) const { |
710 | return AttributeSets.getRetAttr(Kind); |
711 | } |
712 | |
713 | uint64_t Function::getFnAttributeAsParsedInteger(StringRef Name, |
714 | uint64_t Default) const { |
715 | Attribute A = getFnAttribute(Kind: Name); |
716 | uint64_t Result = Default; |
717 | if (A.isStringAttribute()) { |
718 | StringRef Str = A.getValueAsString(); |
719 | if (Str.getAsInteger(Radix: 0, Result)) |
720 | getContext().emitError(ErrorStr: "cannot parse integer attribute " + Name); |
721 | } |
722 | |
723 | return Result; |
724 | } |
725 | |
726 | /// gets the specified attribute from the list of attributes. |
727 | Attribute Function::getParamAttribute(unsigned ArgNo, |
728 | Attribute::AttrKind Kind) const { |
729 | return AttributeSets.getParamAttr(ArgNo, Kind); |
730 | } |
731 | |
732 | void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo, |
733 | uint64_t Bytes) { |
734 | AttributeSets = AttributeSets.addDereferenceableOrNullParamAttr(C&: getContext(), |
735 | ArgNo, Bytes); |
736 | } |
737 | |
738 | DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const { |
739 | if (&FPType == &APFloat::IEEEsingle()) { |
740 | DenormalMode Mode = getDenormalModeF32Raw(); |
741 | // If the f32 variant of the attribute isn't specified, try to use the |
742 | // generic one. |
743 | if (Mode.isValid()) |
744 | return Mode; |
745 | } |
746 | |
747 | return getDenormalModeRaw(); |
748 | } |
749 | |
750 | DenormalMode Function::getDenormalModeRaw() const { |
751 | Attribute Attr = getFnAttribute(Kind: "denormal-fp-math" ); |
752 | StringRef Val = Attr.getValueAsString(); |
753 | return parseDenormalFPAttribute(Str: Val); |
754 | } |
755 | |
756 | DenormalMode Function::getDenormalModeF32Raw() const { |
757 | Attribute Attr = getFnAttribute(Kind: "denormal-fp-math-f32" ); |
758 | if (Attr.isValid()) { |
759 | StringRef Val = Attr.getValueAsString(); |
760 | return parseDenormalFPAttribute(Str: Val); |
761 | } |
762 | |
763 | return DenormalMode::getInvalid(); |
764 | } |
765 | |
766 | const std::string &Function::getGC() const { |
767 | assert(hasGC() && "Function has no collector" ); |
768 | return getContext().getGC(Fn: *this); |
769 | } |
770 | |
771 | void Function::setGC(std::string Str) { |
772 | setValueSubclassDataBit(Bit: 14, On: !Str.empty()); |
773 | getContext().setGC(Fn: *this, GCName: std::move(Str)); |
774 | } |
775 | |
776 | void Function::clearGC() { |
777 | if (!hasGC()) |
778 | return; |
779 | getContext().deleteGC(Fn: *this); |
780 | setValueSubclassDataBit(Bit: 14, On: false); |
781 | } |
782 | |
783 | bool Function::hasStackProtectorFnAttr() const { |
784 | return hasFnAttribute(Attribute::StackProtect) || |
785 | hasFnAttribute(Attribute::StackProtectStrong) || |
786 | hasFnAttribute(Attribute::StackProtectReq); |
787 | } |
788 | |
789 | /// Copy all additional attributes (those not needed to create a Function) from |
790 | /// the Function Src to this one. |
791 | void Function::copyAttributesFrom(const Function *Src) { |
792 | GlobalObject::copyAttributesFrom(Src); |
793 | setCallingConv(Src->getCallingConv()); |
794 | setAttributes(Src->getAttributes()); |
795 | if (Src->hasGC()) |
796 | setGC(Src->getGC()); |
797 | else |
798 | clearGC(); |
799 | if (Src->hasPersonalityFn()) |
800 | setPersonalityFn(Src->getPersonalityFn()); |
801 | if (Src->hasPrefixData()) |
802 | setPrefixData(Src->getPrefixData()); |
803 | if (Src->hasPrologueData()) |
804 | setPrologueData(Src->getPrologueData()); |
805 | } |
806 | |
807 | MemoryEffects Function::getMemoryEffects() const { |
808 | return getAttributes().getMemoryEffects(); |
809 | } |
810 | void Function::setMemoryEffects(MemoryEffects ME) { |
811 | addFnAttr(Attr: Attribute::getWithMemoryEffects(Context&: getContext(), ME)); |
812 | } |
813 | |
814 | /// Determine if the function does not access memory. |
815 | bool Function::doesNotAccessMemory() const { |
816 | return getMemoryEffects().doesNotAccessMemory(); |
817 | } |
818 | void Function::setDoesNotAccessMemory() { |
819 | setMemoryEffects(MemoryEffects::none()); |
820 | } |
821 | |
822 | /// Determine if the function does not access or only reads memory. |
823 | bool Function::onlyReadsMemory() const { |
824 | return getMemoryEffects().onlyReadsMemory(); |
825 | } |
826 | void Function::setOnlyReadsMemory() { |
827 | setMemoryEffects(getMemoryEffects() & MemoryEffects::readOnly()); |
828 | } |
829 | |
830 | /// Determine if the function does not access or only writes memory. |
831 | bool Function::onlyWritesMemory() const { |
832 | return getMemoryEffects().onlyWritesMemory(); |
833 | } |
834 | void Function::setOnlyWritesMemory() { |
835 | setMemoryEffects(getMemoryEffects() & MemoryEffects::writeOnly()); |
836 | } |
837 | |
838 | /// Determine if the call can access memmory only using pointers based |
839 | /// on its arguments. |
840 | bool Function::onlyAccessesArgMemory() const { |
841 | return getMemoryEffects().onlyAccessesArgPointees(); |
842 | } |
843 | void Function::setOnlyAccessesArgMemory() { |
844 | setMemoryEffects(getMemoryEffects() & MemoryEffects::argMemOnly()); |
845 | } |
846 | |
847 | /// Determine if the function may only access memory that is |
848 | /// inaccessible from the IR. |
849 | bool Function::onlyAccessesInaccessibleMemory() const { |
850 | return getMemoryEffects().onlyAccessesInaccessibleMem(); |
851 | } |
852 | void Function::setOnlyAccessesInaccessibleMemory() { |
853 | setMemoryEffects(getMemoryEffects() & MemoryEffects::inaccessibleMemOnly()); |
854 | } |
855 | |
856 | /// Determine if the function may only access memory that is |
857 | /// either inaccessible from the IR or pointed to by its arguments. |
858 | bool Function::onlyAccessesInaccessibleMemOrArgMem() const { |
859 | return getMemoryEffects().onlyAccessesInaccessibleOrArgMem(); |
860 | } |
861 | void Function::setOnlyAccessesInaccessibleMemOrArgMem() { |
862 | setMemoryEffects(getMemoryEffects() & |
863 | MemoryEffects::inaccessibleOrArgMemOnly()); |
864 | } |
865 | |
866 | /// Table of string intrinsic names indexed by enum value. |
867 | static const char * const IntrinsicNameTable[] = { |
868 | "not_intrinsic" , |
869 | #define GET_INTRINSIC_NAME_TABLE |
870 | #include "llvm/IR/IntrinsicImpl.inc" |
871 | #undef GET_INTRINSIC_NAME_TABLE |
872 | }; |
873 | |
874 | /// Table of per-target intrinsic name tables. |
875 | #define GET_INTRINSIC_TARGET_DATA |
876 | #include "llvm/IR/IntrinsicImpl.inc" |
877 | #undef GET_INTRINSIC_TARGET_DATA |
878 | |
879 | bool Function::isTargetIntrinsic(Intrinsic::ID IID) { |
880 | return IID > TargetInfos[0].Count; |
881 | } |
882 | |
883 | bool Function::isTargetIntrinsic() const { |
884 | return isTargetIntrinsic(IID: IntID); |
885 | } |
886 | |
887 | /// Find the segment of \c IntrinsicNameTable for intrinsics with the same |
888 | /// target as \c Name, or the generic table if \c Name is not target specific. |
889 | /// |
890 | /// Returns the relevant slice of \c IntrinsicNameTable |
891 | static ArrayRef<const char *> findTargetSubtable(StringRef Name) { |
892 | assert(Name.starts_with("llvm." )); |
893 | |
894 | ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos); |
895 | // Drop "llvm." and take the first dotted component. That will be the target |
896 | // if this is target specific. |
897 | StringRef Target = Name.drop_front(N: 5).split(Separator: '.').first; |
898 | auto It = partition_point( |
899 | Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; }); |
900 | // We've either found the target or just fall back to the generic set, which |
901 | // is always first. |
902 | const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0]; |
903 | return ArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count); |
904 | } |
905 | |
906 | /// This does the actual lookup of an intrinsic ID which |
907 | /// matches the given function name. |
908 | Intrinsic::ID Function::lookupIntrinsicID(StringRef Name) { |
909 | ArrayRef<const char *> NameTable = findTargetSubtable(Name); |
910 | int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name); |
911 | if (Idx == -1) |
912 | return Intrinsic::not_intrinsic; |
913 | |
914 | // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have |
915 | // an index into a sub-table. |
916 | int Adjust = NameTable.data() - IntrinsicNameTable; |
917 | Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust); |
918 | |
919 | // If the intrinsic is not overloaded, require an exact match. If it is |
920 | // overloaded, require either exact or prefix match. |
921 | const auto MatchSize = strlen(s: NameTable[Idx]); |
922 | assert(Name.size() >= MatchSize && "Expected either exact or prefix match" ); |
923 | bool IsExactMatch = Name.size() == MatchSize; |
924 | return IsExactMatch || Intrinsic::isOverloaded(id: ID) ? ID |
925 | : Intrinsic::not_intrinsic; |
926 | } |
927 | |
928 | void Function::updateAfterNameChange() { |
929 | LibFuncCache = UnknownLibFunc; |
930 | StringRef Name = getName(); |
931 | if (!Name.starts_with(Prefix: "llvm." )) { |
932 | HasLLVMReservedName = false; |
933 | IntID = Intrinsic::not_intrinsic; |
934 | return; |
935 | } |
936 | HasLLVMReservedName = true; |
937 | IntID = lookupIntrinsicID(Name); |
938 | } |
939 | |
940 | /// Returns a stable mangling for the type specified for use in the name |
941 | /// mangling scheme used by 'any' types in intrinsic signatures. The mangling |
942 | /// of named types is simply their name. Manglings for unnamed types consist |
943 | /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions) |
944 | /// combined with the mangling of their component types. A vararg function |
945 | /// type will have a suffix of 'vararg'. Since function types can contain |
946 | /// other function types, we close a function type mangling with suffix 'f' |
947 | /// which can't be confused with it's prefix. This ensures we don't have |
948 | /// collisions between two unrelated function types. Otherwise, you might |
949 | /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.) |
950 | /// The HasUnnamedType boolean is set if an unnamed type was encountered, |
951 | /// indicating that extra care must be taken to ensure a unique name. |
952 | static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) { |
953 | std::string Result; |
954 | if (PointerType *PTyp = dyn_cast<PointerType>(Val: Ty)) { |
955 | Result += "p" + utostr(X: PTyp->getAddressSpace()); |
956 | } else if (ArrayType *ATyp = dyn_cast<ArrayType>(Val: Ty)) { |
957 | Result += "a" + utostr(X: ATyp->getNumElements()) + |
958 | getMangledTypeStr(Ty: ATyp->getElementType(), HasUnnamedType); |
959 | } else if (StructType *STyp = dyn_cast<StructType>(Val: Ty)) { |
960 | if (!STyp->isLiteral()) { |
961 | Result += "s_" ; |
962 | if (STyp->hasName()) |
963 | Result += STyp->getName(); |
964 | else |
965 | HasUnnamedType = true; |
966 | } else { |
967 | Result += "sl_" ; |
968 | for (auto *Elem : STyp->elements()) |
969 | Result += getMangledTypeStr(Ty: Elem, HasUnnamedType); |
970 | } |
971 | // Ensure nested structs are distinguishable. |
972 | Result += "s" ; |
973 | } else if (FunctionType *FT = dyn_cast<FunctionType>(Val: Ty)) { |
974 | Result += "f_" + getMangledTypeStr(Ty: FT->getReturnType(), HasUnnamedType); |
975 | for (size_t i = 0; i < FT->getNumParams(); i++) |
976 | Result += getMangledTypeStr(Ty: FT->getParamType(i), HasUnnamedType); |
977 | if (FT->isVarArg()) |
978 | Result += "vararg" ; |
979 | // Ensure nested function types are distinguishable. |
980 | Result += "f" ; |
981 | } else if (VectorType *VTy = dyn_cast<VectorType>(Val: Ty)) { |
982 | ElementCount EC = VTy->getElementCount(); |
983 | if (EC.isScalable()) |
984 | Result += "nx" ; |
985 | Result += "v" + utostr(X: EC.getKnownMinValue()) + |
986 | getMangledTypeStr(Ty: VTy->getElementType(), HasUnnamedType); |
987 | } else if (TargetExtType *TETy = dyn_cast<TargetExtType>(Val: Ty)) { |
988 | Result += "t" ; |
989 | Result += TETy->getName(); |
990 | for (Type *ParamTy : TETy->type_params()) |
991 | Result += "_" + getMangledTypeStr(Ty: ParamTy, HasUnnamedType); |
992 | for (unsigned IntParam : TETy->int_params()) |
993 | Result += "_" + utostr(X: IntParam); |
994 | // Ensure nested target extension types are distinguishable. |
995 | Result += "t" ; |
996 | } else if (Ty) { |
997 | switch (Ty->getTypeID()) { |
998 | default: llvm_unreachable("Unhandled type" ); |
999 | case Type::VoidTyID: Result += "isVoid" ; break; |
1000 | case Type::MetadataTyID: Result += "Metadata" ; break; |
1001 | case Type::HalfTyID: Result += "f16" ; break; |
1002 | case Type::BFloatTyID: Result += "bf16" ; break; |
1003 | case Type::FloatTyID: Result += "f32" ; break; |
1004 | case Type::DoubleTyID: Result += "f64" ; break; |
1005 | case Type::X86_FP80TyID: Result += "f80" ; break; |
1006 | case Type::FP128TyID: Result += "f128" ; break; |
1007 | case Type::PPC_FP128TyID: Result += "ppcf128" ; break; |
1008 | case Type::X86_MMXTyID: Result += "x86mmx" ; break; |
1009 | case Type::X86_AMXTyID: Result += "x86amx" ; break; |
1010 | case Type::IntegerTyID: |
1011 | Result += "i" + utostr(X: cast<IntegerType>(Val: Ty)->getBitWidth()); |
1012 | break; |
1013 | } |
1014 | } |
1015 | return Result; |
1016 | } |
1017 | |
1018 | StringRef Intrinsic::getBaseName(ID id) { |
1019 | assert(id < num_intrinsics && "Invalid intrinsic ID!" ); |
1020 | return IntrinsicNameTable[id]; |
1021 | } |
1022 | |
1023 | StringRef Intrinsic::getName(ID id) { |
1024 | assert(id < num_intrinsics && "Invalid intrinsic ID!" ); |
1025 | assert(!Intrinsic::isOverloaded(id) && |
1026 | "This version of getName does not support overloading" ); |
1027 | return getBaseName(id); |
1028 | } |
1029 | |
1030 | static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef<Type *> Tys, |
1031 | Module *M, FunctionType *FT, |
1032 | bool EarlyModuleCheck) { |
1033 | |
1034 | assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!" ); |
1035 | assert((Tys.empty() || Intrinsic::isOverloaded(Id)) && |
1036 | "This version of getName is for overloaded intrinsics only" ); |
1037 | (void)EarlyModuleCheck; |
1038 | assert((!EarlyModuleCheck || M || |
1039 | !any_of(Tys, [](Type *T) { return isa<PointerType>(T); })) && |
1040 | "Intrinsic overloading on pointer types need to provide a Module" ); |
1041 | bool HasUnnamedType = false; |
1042 | std::string Result(Intrinsic::getBaseName(id: Id)); |
1043 | for (Type *Ty : Tys) |
1044 | Result += "." + getMangledTypeStr(Ty, HasUnnamedType); |
1045 | if (HasUnnamedType) { |
1046 | assert(M && "unnamed types need a module" ); |
1047 | if (!FT) |
1048 | FT = Intrinsic::getType(Context&: M->getContext(), id: Id, Tys); |
1049 | else |
1050 | assert((FT == Intrinsic::getType(M->getContext(), Id, Tys)) && |
1051 | "Provided FunctionType must match arguments" ); |
1052 | return M->getUniqueIntrinsicName(BaseName: Result, Id, Proto: FT); |
1053 | } |
1054 | return Result; |
1055 | } |
1056 | |
1057 | std::string Intrinsic::getName(ID Id, ArrayRef<Type *> Tys, Module *M, |
1058 | FunctionType *FT) { |
1059 | assert(M && "We need to have a Module" ); |
1060 | return getIntrinsicNameImpl(Id, Tys, M, FT, EarlyModuleCheck: true); |
1061 | } |
1062 | |
1063 | std::string Intrinsic::getNameNoUnnamedTypes(ID Id, ArrayRef<Type *> Tys) { |
1064 | return getIntrinsicNameImpl(Id, Tys, M: nullptr, FT: nullptr, EarlyModuleCheck: false); |
1065 | } |
1066 | |
1067 | /// IIT_Info - These are enumerators that describe the entries returned by the |
1068 | /// getIntrinsicInfoTableEntries function. |
1069 | /// |
1070 | /// Defined in Intrinsics.td. |
1071 | enum IIT_Info { |
1072 | #define GET_INTRINSIC_IITINFO |
1073 | #include "llvm/IR/IntrinsicImpl.inc" |
1074 | #undef GET_INTRINSIC_IITINFO |
1075 | }; |
1076 | |
1077 | static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, |
1078 | IIT_Info LastInfo, |
1079 | SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { |
1080 | using namespace Intrinsic; |
1081 | |
1082 | bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC); |
1083 | |
1084 | IIT_Info Info = IIT_Info(Infos[NextElt++]); |
1085 | unsigned StructElts = 2; |
1086 | |
1087 | switch (Info) { |
1088 | case IIT_Done: |
1089 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Void, Field: 0)); |
1090 | return; |
1091 | case IIT_VARARG: |
1092 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::VarArg, Field: 0)); |
1093 | return; |
1094 | case IIT_MMX: |
1095 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::MMX, Field: 0)); |
1096 | return; |
1097 | case IIT_AMX: |
1098 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::AMX, Field: 0)); |
1099 | return; |
1100 | case IIT_TOKEN: |
1101 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Token, Field: 0)); |
1102 | return; |
1103 | case IIT_METADATA: |
1104 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Metadata, Field: 0)); |
1105 | return; |
1106 | case IIT_F16: |
1107 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Half, Field: 0)); |
1108 | return; |
1109 | case IIT_BF16: |
1110 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::BFloat, Field: 0)); |
1111 | return; |
1112 | case IIT_F32: |
1113 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Float, Field: 0)); |
1114 | return; |
1115 | case IIT_F64: |
1116 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Double, Field: 0)); |
1117 | return; |
1118 | case IIT_F128: |
1119 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Quad, Field: 0)); |
1120 | return; |
1121 | case IIT_PPCF128: |
1122 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::PPCQuad, Field: 0)); |
1123 | return; |
1124 | case IIT_I1: |
1125 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 1)); |
1126 | return; |
1127 | case IIT_I2: |
1128 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 2)); |
1129 | return; |
1130 | case IIT_I4: |
1131 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 4)); |
1132 | return; |
1133 | case IIT_AARCH64_SVCOUNT: |
1134 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::AArch64Svcount, Field: 0)); |
1135 | return; |
1136 | case IIT_I8: |
1137 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 8)); |
1138 | return; |
1139 | case IIT_I16: |
1140 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer,Field: 16)); |
1141 | return; |
1142 | case IIT_I32: |
1143 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 32)); |
1144 | return; |
1145 | case IIT_I64: |
1146 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 64)); |
1147 | return; |
1148 | case IIT_I128: |
1149 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Integer, Field: 128)); |
1150 | return; |
1151 | case IIT_V1: |
1152 | OutputTable.push_back(IITDescriptor::getVector(Width: 1, IsScalable: IsScalableVector)); |
1153 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1154 | return; |
1155 | case IIT_V2: |
1156 | OutputTable.push_back(IITDescriptor::getVector(Width: 2, IsScalable: IsScalableVector)); |
1157 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1158 | return; |
1159 | case IIT_V3: |
1160 | OutputTable.push_back(IITDescriptor::getVector(Width: 3, IsScalable: IsScalableVector)); |
1161 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1162 | return; |
1163 | case IIT_V4: |
1164 | OutputTable.push_back(IITDescriptor::getVector(Width: 4, IsScalable: IsScalableVector)); |
1165 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1166 | return; |
1167 | case IIT_V6: |
1168 | OutputTable.push_back(IITDescriptor::getVector(Width: 6, IsScalable: IsScalableVector)); |
1169 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1170 | return; |
1171 | case IIT_V8: |
1172 | OutputTable.push_back(IITDescriptor::getVector(Width: 8, IsScalable: IsScalableVector)); |
1173 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1174 | return; |
1175 | case IIT_V10: |
1176 | OutputTable.push_back(IITDescriptor::getVector(Width: 10, IsScalable: IsScalableVector)); |
1177 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1178 | return; |
1179 | case IIT_V16: |
1180 | OutputTable.push_back(IITDescriptor::getVector(Width: 16, IsScalable: IsScalableVector)); |
1181 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1182 | return; |
1183 | case IIT_V32: |
1184 | OutputTable.push_back(IITDescriptor::getVector(Width: 32, IsScalable: IsScalableVector)); |
1185 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1186 | return; |
1187 | case IIT_V64: |
1188 | OutputTable.push_back(IITDescriptor::getVector(Width: 64, IsScalable: IsScalableVector)); |
1189 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1190 | return; |
1191 | case IIT_V128: |
1192 | OutputTable.push_back(IITDescriptor::getVector(Width: 128, IsScalable: IsScalableVector)); |
1193 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1194 | return; |
1195 | case IIT_V256: |
1196 | OutputTable.push_back(IITDescriptor::getVector(Width: 256, IsScalable: IsScalableVector)); |
1197 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1198 | return; |
1199 | case IIT_V512: |
1200 | OutputTable.push_back(IITDescriptor::getVector(Width: 512, IsScalable: IsScalableVector)); |
1201 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1202 | return; |
1203 | case IIT_V1024: |
1204 | OutputTable.push_back(IITDescriptor::getVector(Width: 1024, IsScalable: IsScalableVector)); |
1205 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1206 | return; |
1207 | case IIT_EXTERNREF: |
1208 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Pointer, Field: 10)); |
1209 | return; |
1210 | case IIT_FUNCREF: |
1211 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Pointer, Field: 20)); |
1212 | return; |
1213 | case IIT_PTR: |
1214 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Pointer, Field: 0)); |
1215 | return; |
1216 | case IIT_ANYPTR: // [ANYPTR addrspace] |
1217 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Pointer, |
1218 | Field: Infos[NextElt++])); |
1219 | return; |
1220 | case IIT_ARG: { |
1221 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1222 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Argument, Field: ArgInfo)); |
1223 | return; |
1224 | } |
1225 | case IIT_EXTEND_ARG: { |
1226 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1227 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::ExtendArgument, |
1228 | Field: ArgInfo)); |
1229 | return; |
1230 | } |
1231 | case IIT_TRUNC_ARG: { |
1232 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1233 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::TruncArgument, |
1234 | Field: ArgInfo)); |
1235 | return; |
1236 | } |
1237 | case IIT_HALF_VEC_ARG: { |
1238 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1239 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::HalfVecArgument, |
1240 | Field: ArgInfo)); |
1241 | return; |
1242 | } |
1243 | case IIT_SAME_VEC_WIDTH_ARG: { |
1244 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1245 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::SameVecWidthArgument, |
1246 | Field: ArgInfo)); |
1247 | return; |
1248 | } |
1249 | case IIT_VEC_OF_ANYPTRS_TO_ELT: { |
1250 | unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1251 | unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1252 | OutputTable.push_back( |
1253 | IITDescriptor::get(K: IITDescriptor::VecOfAnyPtrsToElt, Hi: ArgNo, Lo: RefNo)); |
1254 | return; |
1255 | } |
1256 | case IIT_EMPTYSTRUCT: |
1257 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Struct, Field: 0)); |
1258 | return; |
1259 | case IIT_STRUCT9: ++StructElts; [[fallthrough]]; |
1260 | case IIT_STRUCT8: ++StructElts; [[fallthrough]]; |
1261 | case IIT_STRUCT7: ++StructElts; [[fallthrough]]; |
1262 | case IIT_STRUCT6: ++StructElts; [[fallthrough]]; |
1263 | case IIT_STRUCT5: ++StructElts; [[fallthrough]]; |
1264 | case IIT_STRUCT4: ++StructElts; [[fallthrough]]; |
1265 | case IIT_STRUCT3: ++StructElts; [[fallthrough]]; |
1266 | case IIT_STRUCT2: { |
1267 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Struct,Field: StructElts)); |
1268 | |
1269 | for (unsigned i = 0; i != StructElts; ++i) |
1270 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1271 | return; |
1272 | } |
1273 | case IIT_SUBDIVIDE2_ARG: { |
1274 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1275 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Subdivide2Argument, |
1276 | Field: ArgInfo)); |
1277 | return; |
1278 | } |
1279 | case IIT_SUBDIVIDE4_ARG: { |
1280 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1281 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::Subdivide4Argument, |
1282 | Field: ArgInfo)); |
1283 | return; |
1284 | } |
1285 | case IIT_VEC_ELEMENT: { |
1286 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1287 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::VecElementArgument, |
1288 | Field: ArgInfo)); |
1289 | return; |
1290 | } |
1291 | case IIT_SCALABLE_VEC: { |
1292 | DecodeIITType(NextElt, Infos, LastInfo: Info, OutputTable); |
1293 | return; |
1294 | } |
1295 | case IIT_VEC_OF_BITCASTS_TO_INT: { |
1296 | unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); |
1297 | OutputTable.push_back(IITDescriptor::get(K: IITDescriptor::VecOfBitcastsToInt, |
1298 | Field: ArgInfo)); |
1299 | return; |
1300 | } |
1301 | } |
1302 | llvm_unreachable("unhandled" ); |
1303 | } |
1304 | |
1305 | #define GET_INTRINSIC_GENERATOR_GLOBAL |
1306 | #include "llvm/IR/IntrinsicImpl.inc" |
1307 | #undef GET_INTRINSIC_GENERATOR_GLOBAL |
1308 | |
1309 | void Intrinsic::getIntrinsicInfoTableEntries(ID id, |
1310 | SmallVectorImpl<IITDescriptor> &T){ |
1311 | // Check to see if the intrinsic's type was expressible by the table. |
1312 | unsigned TableVal = IIT_Table[id-1]; |
1313 | |
1314 | // Decode the TableVal into an array of IITValues. |
1315 | SmallVector<unsigned char, 8> IITValues; |
1316 | ArrayRef<unsigned char> IITEntries; |
1317 | unsigned NextElt = 0; |
1318 | if ((TableVal >> 31) != 0) { |
1319 | // This is an offset into the IIT_LongEncodingTable. |
1320 | IITEntries = IIT_LongEncodingTable; |
1321 | |
1322 | // Strip sentinel bit. |
1323 | NextElt = (TableVal << 1) >> 1; |
1324 | } else { |
1325 | // Decode the TableVal into an array of IITValues. If the entry was encoded |
1326 | // into a single word in the table itself, decode it now. |
1327 | do { |
1328 | IITValues.push_back(Elt: TableVal & 0xF); |
1329 | TableVal >>= 4; |
1330 | } while (TableVal); |
1331 | |
1332 | IITEntries = IITValues; |
1333 | NextElt = 0; |
1334 | } |
1335 | |
1336 | // Okay, decode the table into the output vector of IITDescriptors. |
1337 | DecodeIITType(NextElt, IITEntries, IIT_Done, T); |
1338 | while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) |
1339 | DecodeIITType(NextElt, IITEntries, IIT_Done, T); |
1340 | } |
1341 | |
1342 | static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, |
1343 | ArrayRef<Type*> Tys, LLVMContext &Context) { |
1344 | using namespace Intrinsic; |
1345 | |
1346 | IITDescriptor D = Infos.front(); |
1347 | Infos = Infos.slice(N: 1); |
1348 | |
1349 | switch (D.Kind) { |
1350 | case IITDescriptor::Void: return Type::getVoidTy(C&: Context); |
1351 | case IITDescriptor::VarArg: return Type::getVoidTy(C&: Context); |
1352 | case IITDescriptor::MMX: return Type::getX86_MMXTy(C&: Context); |
1353 | case IITDescriptor::AMX: return Type::getX86_AMXTy(C&: Context); |
1354 | case IITDescriptor::Token: return Type::getTokenTy(C&: Context); |
1355 | case IITDescriptor::Metadata: return Type::getMetadataTy(C&: Context); |
1356 | case IITDescriptor::Half: return Type::getHalfTy(C&: Context); |
1357 | case IITDescriptor::BFloat: return Type::getBFloatTy(C&: Context); |
1358 | case IITDescriptor::Float: return Type::getFloatTy(C&: Context); |
1359 | case IITDescriptor::Double: return Type::getDoubleTy(C&: Context); |
1360 | case IITDescriptor::Quad: return Type::getFP128Ty(C&: Context); |
1361 | case IITDescriptor::PPCQuad: return Type::getPPC_FP128Ty(C&: Context); |
1362 | case IITDescriptor::AArch64Svcount: |
1363 | return TargetExtType::get(Context, Name: "aarch64.svcount" ); |
1364 | |
1365 | case IITDescriptor::Integer: |
1366 | return IntegerType::get(C&: Context, NumBits: D.Integer_Width); |
1367 | case IITDescriptor::Vector: |
1368 | return VectorType::get(ElementType: DecodeFixedType(Infos, Tys, Context), |
1369 | EC: D.Vector_Width); |
1370 | case IITDescriptor::Pointer: |
1371 | return PointerType::get(C&: Context, AddressSpace: D.Pointer_AddressSpace); |
1372 | case IITDescriptor::Struct: { |
1373 | SmallVector<Type *, 8> Elts; |
1374 | for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) |
1375 | Elts.push_back(Elt: DecodeFixedType(Infos, Tys, Context)); |
1376 | return StructType::get(Context, Elements: Elts); |
1377 | } |
1378 | case IITDescriptor::Argument: |
1379 | return Tys[D.getArgumentNumber()]; |
1380 | case IITDescriptor::ExtendArgument: { |
1381 | Type *Ty = Tys[D.getArgumentNumber()]; |
1382 | if (VectorType *VTy = dyn_cast<VectorType>(Val: Ty)) |
1383 | return VectorType::getExtendedElementVectorType(VTy); |
1384 | |
1385 | return IntegerType::get(C&: Context, NumBits: 2 * cast<IntegerType>(Val: Ty)->getBitWidth()); |
1386 | } |
1387 | case IITDescriptor::TruncArgument: { |
1388 | Type *Ty = Tys[D.getArgumentNumber()]; |
1389 | if (VectorType *VTy = dyn_cast<VectorType>(Val: Ty)) |
1390 | return VectorType::getTruncatedElementVectorType(VTy); |
1391 | |
1392 | IntegerType *ITy = cast<IntegerType>(Val: Ty); |
1393 | assert(ITy->getBitWidth() % 2 == 0); |
1394 | return IntegerType::get(C&: Context, NumBits: ITy->getBitWidth() / 2); |
1395 | } |
1396 | case IITDescriptor::Subdivide2Argument: |
1397 | case IITDescriptor::Subdivide4Argument: { |
1398 | Type *Ty = Tys[D.getArgumentNumber()]; |
1399 | VectorType *VTy = dyn_cast<VectorType>(Val: Ty); |
1400 | assert(VTy && "Expected an argument of Vector Type" ); |
1401 | int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2; |
1402 | return VectorType::getSubdividedVectorType(VTy, NumSubdivs: SubDivs); |
1403 | } |
1404 | case IITDescriptor::HalfVecArgument: |
1405 | return VectorType::getHalfElementsVectorType(VTy: cast<VectorType>( |
1406 | Val: Tys[D.getArgumentNumber()])); |
1407 | case IITDescriptor::SameVecWidthArgument: { |
1408 | Type *EltTy = DecodeFixedType(Infos, Tys, Context); |
1409 | Type *Ty = Tys[D.getArgumentNumber()]; |
1410 | if (auto *VTy = dyn_cast<VectorType>(Val: Ty)) |
1411 | return VectorType::get(ElementType: EltTy, EC: VTy->getElementCount()); |
1412 | return EltTy; |
1413 | } |
1414 | case IITDescriptor::VecElementArgument: { |
1415 | Type *Ty = Tys[D.getArgumentNumber()]; |
1416 | if (VectorType *VTy = dyn_cast<VectorType>(Val: Ty)) |
1417 | return VTy->getElementType(); |
1418 | llvm_unreachable("Expected an argument of Vector Type" ); |
1419 | } |
1420 | case IITDescriptor::VecOfBitcastsToInt: { |
1421 | Type *Ty = Tys[D.getArgumentNumber()]; |
1422 | VectorType *VTy = dyn_cast<VectorType>(Val: Ty); |
1423 | assert(VTy && "Expected an argument of Vector Type" ); |
1424 | return VectorType::getInteger(VTy); |
1425 | } |
1426 | case IITDescriptor::VecOfAnyPtrsToElt: |
1427 | // Return the overloaded type (which determines the pointers address space) |
1428 | return Tys[D.getOverloadArgNumber()]; |
1429 | } |
1430 | llvm_unreachable("unhandled" ); |
1431 | } |
1432 | |
1433 | FunctionType *Intrinsic::getType(LLVMContext &Context, |
1434 | ID id, ArrayRef<Type*> Tys) { |
1435 | SmallVector<IITDescriptor, 8> Table; |
1436 | getIntrinsicInfoTableEntries(id, T&: Table); |
1437 | |
1438 | ArrayRef<IITDescriptor> TableRef = Table; |
1439 | Type *ResultTy = DecodeFixedType(Infos&: TableRef, Tys, Context); |
1440 | |
1441 | SmallVector<Type*, 8> ArgTys; |
1442 | while (!TableRef.empty()) |
1443 | ArgTys.push_back(Elt: DecodeFixedType(Infos&: TableRef, Tys, Context)); |
1444 | |
1445 | // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg |
1446 | // If we see void type as the type of the last argument, it is vararg intrinsic |
1447 | if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) { |
1448 | ArgTys.pop_back(); |
1449 | return FunctionType::get(Result: ResultTy, Params: ArgTys, isVarArg: true); |
1450 | } |
1451 | return FunctionType::get(Result: ResultTy, Params: ArgTys, isVarArg: false); |
1452 | } |
1453 | |
1454 | bool Intrinsic::isOverloaded(ID id) { |
1455 | #define GET_INTRINSIC_OVERLOAD_TABLE |
1456 | #include "llvm/IR/IntrinsicImpl.inc" |
1457 | #undef GET_INTRINSIC_OVERLOAD_TABLE |
1458 | } |
1459 | |
1460 | /// This defines the "Intrinsic::getAttributes(ID id)" method. |
1461 | #define GET_INTRINSIC_ATTRIBUTES |
1462 | #include "llvm/IR/IntrinsicImpl.inc" |
1463 | #undef GET_INTRINSIC_ATTRIBUTES |
1464 | |
1465 | Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { |
1466 | // There can never be multiple globals with the same name of different types, |
1467 | // because intrinsics must be a specific type. |
1468 | auto *FT = getType(Context&: M->getContext(), id, Tys); |
1469 | return cast<Function>( |
1470 | Val: M->getOrInsertFunction( |
1471 | Name: Tys.empty() ? getName(id) : getName(Id: id, Tys, M, FT), T: FT) |
1472 | .getCallee()); |
1473 | } |
1474 | |
1475 | // This defines the "Intrinsic::getIntrinsicForClangBuiltin()" method. |
1476 | #define GET_LLVM_INTRINSIC_FOR_CLANG_BUILTIN |
1477 | #include "llvm/IR/IntrinsicImpl.inc" |
1478 | #undef GET_LLVM_INTRINSIC_FOR_CLANG_BUILTIN |
1479 | |
1480 | // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method. |
1481 | #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN |
1482 | #include "llvm/IR/IntrinsicImpl.inc" |
1483 | #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN |
1484 | |
1485 | bool Intrinsic::isConstrainedFPIntrinsic(ID QID) { |
1486 | switch (QID) { |
1487 | #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \ |
1488 | case Intrinsic::INTRINSIC: |
1489 | #include "llvm/IR/ConstrainedOps.def" |
1490 | return true; |
1491 | #undef INSTRUCTION |
1492 | default: |
1493 | return false; |
1494 | } |
1495 | } |
1496 | |
1497 | using DeferredIntrinsicMatchPair = |
1498 | std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>; |
1499 | |
1500 | static bool matchIntrinsicType( |
1501 | Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos, |
1502 | SmallVectorImpl<Type *> &ArgTys, |
1503 | SmallVectorImpl<DeferredIntrinsicMatchPair> &DeferredChecks, |
1504 | bool IsDeferredCheck) { |
1505 | using namespace Intrinsic; |
1506 | |
1507 | // If we ran out of descriptors, there are too many arguments. |
1508 | if (Infos.empty()) return true; |
1509 | |
1510 | // Do this before slicing off the 'front' part |
1511 | auto InfosRef = Infos; |
1512 | auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) { |
1513 | DeferredChecks.emplace_back(Args&: T, Args&: InfosRef); |
1514 | return false; |
1515 | }; |
1516 | |
1517 | IITDescriptor D = Infos.front(); |
1518 | Infos = Infos.slice(N: 1); |
1519 | |
1520 | switch (D.Kind) { |
1521 | case IITDescriptor::Void: return !Ty->isVoidTy(); |
1522 | case IITDescriptor::VarArg: return true; |
1523 | case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); |
1524 | case IITDescriptor::AMX: return !Ty->isX86_AMXTy(); |
1525 | case IITDescriptor::Token: return !Ty->isTokenTy(); |
1526 | case IITDescriptor::Metadata: return !Ty->isMetadataTy(); |
1527 | case IITDescriptor::Half: return !Ty->isHalfTy(); |
1528 | case IITDescriptor::BFloat: return !Ty->isBFloatTy(); |
1529 | case IITDescriptor::Float: return !Ty->isFloatTy(); |
1530 | case IITDescriptor::Double: return !Ty->isDoubleTy(); |
1531 | case IITDescriptor::Quad: return !Ty->isFP128Ty(); |
1532 | case IITDescriptor::PPCQuad: return !Ty->isPPC_FP128Ty(); |
1533 | case IITDescriptor::Integer: return !Ty->isIntegerTy(Bitwidth: D.Integer_Width); |
1534 | case IITDescriptor::AArch64Svcount: |
1535 | return !isa<TargetExtType>(Val: Ty) || |
1536 | cast<TargetExtType>(Val: Ty)->getName() != "aarch64.svcount" ; |
1537 | case IITDescriptor::Vector: { |
1538 | VectorType *VT = dyn_cast<VectorType>(Val: Ty); |
1539 | return !VT || VT->getElementCount() != D.Vector_Width || |
1540 | matchIntrinsicType(Ty: VT->getElementType(), Infos, ArgTys, |
1541 | DeferredChecks, IsDeferredCheck); |
1542 | } |
1543 | case IITDescriptor::Pointer: { |
1544 | PointerType *PT = dyn_cast<PointerType>(Val: Ty); |
1545 | return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace; |
1546 | } |
1547 | |
1548 | case IITDescriptor::Struct: { |
1549 | StructType *ST = dyn_cast<StructType>(Val: Ty); |
1550 | if (!ST || !ST->isLiteral() || ST->isPacked() || |
1551 | ST->getNumElements() != D.Struct_NumElements) |
1552 | return true; |
1553 | |
1554 | for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) |
1555 | if (matchIntrinsicType(Ty: ST->getElementType(N: i), Infos, ArgTys, |
1556 | DeferredChecks, IsDeferredCheck)) |
1557 | return true; |
1558 | return false; |
1559 | } |
1560 | |
1561 | case IITDescriptor::Argument: |
1562 | // If this is the second occurrence of an argument, |
1563 | // verify that the later instance matches the previous instance. |
1564 | if (D.getArgumentNumber() < ArgTys.size()) |
1565 | return Ty != ArgTys[D.getArgumentNumber()]; |
1566 | |
1567 | if (D.getArgumentNumber() > ArgTys.size() || |
1568 | D.getArgumentKind() == IITDescriptor::AK_MatchType) |
1569 | return IsDeferredCheck || DeferCheck(Ty); |
1570 | |
1571 | assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck && |
1572 | "Table consistency error" ); |
1573 | ArgTys.push_back(Elt: Ty); |
1574 | |
1575 | switch (D.getArgumentKind()) { |
1576 | case IITDescriptor::AK_Any: return false; // Success |
1577 | case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy(); |
1578 | case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy(); |
1579 | case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Val: Ty); |
1580 | case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Val: Ty); |
1581 | default: break; |
1582 | } |
1583 | llvm_unreachable("all argument kinds not covered" ); |
1584 | |
1585 | case IITDescriptor::ExtendArgument: { |
1586 | // If this is a forward reference, defer the check for later. |
1587 | if (D.getArgumentNumber() >= ArgTys.size()) |
1588 | return IsDeferredCheck || DeferCheck(Ty); |
1589 | |
1590 | Type *NewTy = ArgTys[D.getArgumentNumber()]; |
1591 | if (VectorType *VTy = dyn_cast<VectorType>(Val: NewTy)) |
1592 | NewTy = VectorType::getExtendedElementVectorType(VTy); |
1593 | else if (IntegerType *ITy = dyn_cast<IntegerType>(Val: NewTy)) |
1594 | NewTy = IntegerType::get(C&: ITy->getContext(), NumBits: 2 * ITy->getBitWidth()); |
1595 | else |
1596 | return true; |
1597 | |
1598 | return Ty != NewTy; |
1599 | } |
1600 | case IITDescriptor::TruncArgument: { |
1601 | // If this is a forward reference, defer the check for later. |
1602 | if (D.getArgumentNumber() >= ArgTys.size()) |
1603 | return IsDeferredCheck || DeferCheck(Ty); |
1604 | |
1605 | Type *NewTy = ArgTys[D.getArgumentNumber()]; |
1606 | if (VectorType *VTy = dyn_cast<VectorType>(Val: NewTy)) |
1607 | NewTy = VectorType::getTruncatedElementVectorType(VTy); |
1608 | else if (IntegerType *ITy = dyn_cast<IntegerType>(Val: NewTy)) |
1609 | NewTy = IntegerType::get(C&: ITy->getContext(), NumBits: ITy->getBitWidth() / 2); |
1610 | else |
1611 | return true; |
1612 | |
1613 | return Ty != NewTy; |
1614 | } |
1615 | case IITDescriptor::HalfVecArgument: |
1616 | // If this is a forward reference, defer the check for later. |
1617 | if (D.getArgumentNumber() >= ArgTys.size()) |
1618 | return IsDeferredCheck || DeferCheck(Ty); |
1619 | return !isa<VectorType>(Val: ArgTys[D.getArgumentNumber()]) || |
1620 | VectorType::getHalfElementsVectorType( |
1621 | VTy: cast<VectorType>(Val: ArgTys[D.getArgumentNumber()])) != Ty; |
1622 | case IITDescriptor::SameVecWidthArgument: { |
1623 | if (D.getArgumentNumber() >= ArgTys.size()) { |
1624 | // Defer check and subsequent check for the vector element type. |
1625 | Infos = Infos.slice(N: 1); |
1626 | return IsDeferredCheck || DeferCheck(Ty); |
1627 | } |
1628 | auto *ReferenceType = dyn_cast<VectorType>(Val: ArgTys[D.getArgumentNumber()]); |
1629 | auto *ThisArgType = dyn_cast<VectorType>(Val: Ty); |
1630 | // Both must be vectors of the same number of elements or neither. |
1631 | if ((ReferenceType != nullptr) != (ThisArgType != nullptr)) |
1632 | return true; |
1633 | Type *EltTy = Ty; |
1634 | if (ThisArgType) { |
1635 | if (ReferenceType->getElementCount() != |
1636 | ThisArgType->getElementCount()) |
1637 | return true; |
1638 | EltTy = ThisArgType->getElementType(); |
1639 | } |
1640 | return matchIntrinsicType(Ty: EltTy, Infos, ArgTys, DeferredChecks, |
1641 | IsDeferredCheck); |
1642 | } |
1643 | case IITDescriptor::VecOfAnyPtrsToElt: { |
1644 | unsigned RefArgNumber = D.getRefArgNumber(); |
1645 | if (RefArgNumber >= ArgTys.size()) { |
1646 | if (IsDeferredCheck) |
1647 | return true; |
1648 | // If forward referencing, already add the pointer-vector type and |
1649 | // defer the checks for later. |
1650 | ArgTys.push_back(Elt: Ty); |
1651 | return DeferCheck(Ty); |
1652 | } |
1653 | |
1654 | if (!IsDeferredCheck){ |
1655 | assert(D.getOverloadArgNumber() == ArgTys.size() && |
1656 | "Table consistency error" ); |
1657 | ArgTys.push_back(Elt: Ty); |
1658 | } |
1659 | |
1660 | // Verify the overloaded type "matches" the Ref type. |
1661 | // i.e. Ty is a vector with the same width as Ref. |
1662 | // Composed of pointers to the same element type as Ref. |
1663 | auto *ReferenceType = dyn_cast<VectorType>(Val: ArgTys[RefArgNumber]); |
1664 | auto *ThisArgVecTy = dyn_cast<VectorType>(Val: Ty); |
1665 | if (!ThisArgVecTy || !ReferenceType || |
1666 | (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount())) |
1667 | return true; |
1668 | return !ThisArgVecTy->getElementType()->isPointerTy(); |
1669 | } |
1670 | case IITDescriptor::VecElementArgument: { |
1671 | if (D.getArgumentNumber() >= ArgTys.size()) |
1672 | return IsDeferredCheck ? true : DeferCheck(Ty); |
1673 | auto *ReferenceType = dyn_cast<VectorType>(Val: ArgTys[D.getArgumentNumber()]); |
1674 | return !ReferenceType || Ty != ReferenceType->getElementType(); |
1675 | } |
1676 | case IITDescriptor::Subdivide2Argument: |
1677 | case IITDescriptor::Subdivide4Argument: { |
1678 | // If this is a forward reference, defer the check for later. |
1679 | if (D.getArgumentNumber() >= ArgTys.size()) |
1680 | return IsDeferredCheck || DeferCheck(Ty); |
1681 | |
1682 | Type *NewTy = ArgTys[D.getArgumentNumber()]; |
1683 | if (auto *VTy = dyn_cast<VectorType>(Val: NewTy)) { |
1684 | int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2; |
1685 | NewTy = VectorType::getSubdividedVectorType(VTy, NumSubdivs: SubDivs); |
1686 | return Ty != NewTy; |
1687 | } |
1688 | return true; |
1689 | } |
1690 | case IITDescriptor::VecOfBitcastsToInt: { |
1691 | if (D.getArgumentNumber() >= ArgTys.size()) |
1692 | return IsDeferredCheck || DeferCheck(Ty); |
1693 | auto *ReferenceType = dyn_cast<VectorType>(Val: ArgTys[D.getArgumentNumber()]); |
1694 | auto *ThisArgVecTy = dyn_cast<VectorType>(Val: Ty); |
1695 | if (!ThisArgVecTy || !ReferenceType) |
1696 | return true; |
1697 | return ThisArgVecTy != VectorType::getInteger(VTy: ReferenceType); |
1698 | } |
1699 | } |
1700 | llvm_unreachable("unhandled" ); |
1701 | } |
1702 | |
1703 | Intrinsic::MatchIntrinsicTypesResult |
1704 | Intrinsic::matchIntrinsicSignature(FunctionType *FTy, |
1705 | ArrayRef<Intrinsic::IITDescriptor> &Infos, |
1706 | SmallVectorImpl<Type *> &ArgTys) { |
1707 | SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks; |
1708 | if (matchIntrinsicType(Ty: FTy->getReturnType(), Infos, ArgTys, DeferredChecks, |
1709 | IsDeferredCheck: false)) |
1710 | return MatchIntrinsicTypes_NoMatchRet; |
1711 | |
1712 | unsigned NumDeferredReturnChecks = DeferredChecks.size(); |
1713 | |
1714 | for (auto *Ty : FTy->params()) |
1715 | if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, IsDeferredCheck: false)) |
1716 | return MatchIntrinsicTypes_NoMatchArg; |
1717 | |
1718 | for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) { |
1719 | DeferredIntrinsicMatchPair &Check = DeferredChecks[I]; |
1720 | if (matchIntrinsicType(Ty: Check.first, Infos&: Check.second, ArgTys, DeferredChecks, |
1721 | IsDeferredCheck: true)) |
1722 | return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet |
1723 | : MatchIntrinsicTypes_NoMatchArg; |
1724 | } |
1725 | |
1726 | return MatchIntrinsicTypes_Match; |
1727 | } |
1728 | |
1729 | bool |
1730 | Intrinsic::matchIntrinsicVarArg(bool isVarArg, |
1731 | ArrayRef<Intrinsic::IITDescriptor> &Infos) { |
1732 | // If there are no descriptors left, then it can't be a vararg. |
1733 | if (Infos.empty()) |
1734 | return isVarArg; |
1735 | |
1736 | // There should be only one descriptor remaining at this point. |
1737 | if (Infos.size() != 1) |
1738 | return true; |
1739 | |
1740 | // Check and verify the descriptor. |
1741 | IITDescriptor D = Infos.front(); |
1742 | Infos = Infos.slice(N: 1); |
1743 | if (D.Kind == IITDescriptor::VarArg) |
1744 | return !isVarArg; |
1745 | |
1746 | return true; |
1747 | } |
1748 | |
1749 | bool Intrinsic::getIntrinsicSignature(Intrinsic::ID ID, FunctionType *FT, |
1750 | SmallVectorImpl<Type *> &ArgTys) { |
1751 | if (!ID) |
1752 | return false; |
1753 | |
1754 | SmallVector<Intrinsic::IITDescriptor, 8> Table; |
1755 | getIntrinsicInfoTableEntries(id: ID, T&: Table); |
1756 | ArrayRef<Intrinsic::IITDescriptor> TableRef = Table; |
1757 | |
1758 | if (Intrinsic::matchIntrinsicSignature(FTy: FT, Infos&: TableRef, ArgTys) != |
1759 | Intrinsic::MatchIntrinsicTypesResult::MatchIntrinsicTypes_Match) { |
1760 | return false; |
1761 | } |
1762 | if (Intrinsic::matchIntrinsicVarArg(isVarArg: FT->isVarArg(), Infos&: TableRef)) |
1763 | return false; |
1764 | return true; |
1765 | } |
1766 | |
1767 | bool Intrinsic::getIntrinsicSignature(Function *F, |
1768 | SmallVectorImpl<Type *> &ArgTys) { |
1769 | return getIntrinsicSignature(ID: F->getIntrinsicID(), FT: F->getFunctionType(), |
1770 | ArgTys); |
1771 | } |
1772 | |
1773 | std::optional<Function *> Intrinsic::remangleIntrinsicFunction(Function *F) { |
1774 | SmallVector<Type *, 4> ArgTys; |
1775 | if (!getIntrinsicSignature(F, ArgTys)) |
1776 | return std::nullopt; |
1777 | |
1778 | Intrinsic::ID ID = F->getIntrinsicID(); |
1779 | StringRef Name = F->getName(); |
1780 | std::string WantedName = |
1781 | Intrinsic::getName(Id: ID, Tys: ArgTys, M: F->getParent(), FT: F->getFunctionType()); |
1782 | if (Name == WantedName) |
1783 | return std::nullopt; |
1784 | |
1785 | Function *NewDecl = [&] { |
1786 | if (auto *ExistingGV = F->getParent()->getNamedValue(Name: WantedName)) { |
1787 | if (auto *ExistingF = dyn_cast<Function>(Val: ExistingGV)) |
1788 | if (ExistingF->getFunctionType() == F->getFunctionType()) |
1789 | return ExistingF; |
1790 | |
1791 | // The name already exists, but is not a function or has the wrong |
1792 | // prototype. Make place for the new one by renaming the old version. |
1793 | // Either this old version will be removed later on or the module is |
1794 | // invalid and we'll get an error. |
1795 | ExistingGV->setName(WantedName + ".renamed" ); |
1796 | } |
1797 | return Intrinsic::getDeclaration(M: F->getParent(), id: ID, Tys: ArgTys); |
1798 | }(); |
1799 | |
1800 | NewDecl->setCallingConv(F->getCallingConv()); |
1801 | assert(NewDecl->getFunctionType() == F->getFunctionType() && |
1802 | "Shouldn't change the signature" ); |
1803 | return NewDecl; |
1804 | } |
1805 | |
1806 | /// hasAddressTaken - returns true if there are any uses of this function |
1807 | /// other than direct calls or invokes to it. Optionally ignores callback |
1808 | /// uses, assume like pointer annotation calls, and references in llvm.used |
1809 | /// and llvm.compiler.used variables. |
1810 | bool Function::hasAddressTaken(const User **PutOffender, |
1811 | bool IgnoreCallbackUses, |
1812 | bool IgnoreAssumeLikeCalls, bool IgnoreLLVMUsed, |
1813 | bool IgnoreARCAttachedCall, |
1814 | bool IgnoreCastedDirectCall) const { |
1815 | for (const Use &U : uses()) { |
1816 | const User *FU = U.getUser(); |
1817 | if (isa<BlockAddress>(Val: FU)) |
1818 | continue; |
1819 | |
1820 | if (IgnoreCallbackUses) { |
1821 | AbstractCallSite ACS(&U); |
1822 | if (ACS && ACS.isCallbackCall()) |
1823 | continue; |
1824 | } |
1825 | |
1826 | const auto *Call = dyn_cast<CallBase>(Val: FU); |
1827 | if (!Call) { |
1828 | if (IgnoreAssumeLikeCalls && |
1829 | isa<BitCastOperator, AddrSpaceCastOperator>(Val: FU) && |
1830 | all_of(Range: FU->users(), P: [](const User *U) { |
1831 | if (const auto *I = dyn_cast<IntrinsicInst>(Val: U)) |
1832 | return I->isAssumeLikeIntrinsic(); |
1833 | return false; |
1834 | })) { |
1835 | continue; |
1836 | } |
1837 | |
1838 | if (IgnoreLLVMUsed && !FU->user_empty()) { |
1839 | const User *FUU = FU; |
1840 | if (isa<BitCastOperator, AddrSpaceCastOperator>(Val: FU) && |
1841 | FU->hasOneUse() && !FU->user_begin()->user_empty()) |
1842 | FUU = *FU->user_begin(); |
1843 | if (llvm::all_of(Range: FUU->users(), P: [](const User *U) { |
1844 | if (const auto *GV = dyn_cast<GlobalVariable>(Val: U)) |
1845 | return GV->hasName() && |
1846 | (GV->getName().equals(RHS: "llvm.compiler.used" ) || |
1847 | GV->getName().equals(RHS: "llvm.used" )); |
1848 | return false; |
1849 | })) |
1850 | continue; |
1851 | } |
1852 | if (PutOffender) |
1853 | *PutOffender = FU; |
1854 | return true; |
1855 | } |
1856 | |
1857 | if (IgnoreAssumeLikeCalls) { |
1858 | if (const auto *I = dyn_cast<IntrinsicInst>(Val: Call)) |
1859 | if (I->isAssumeLikeIntrinsic()) |
1860 | continue; |
1861 | } |
1862 | |
1863 | if (!Call->isCallee(U: &U) || (!IgnoreCastedDirectCall && |
1864 | Call->getFunctionType() != getFunctionType())) { |
1865 | if (IgnoreARCAttachedCall && |
1866 | Call->isOperandBundleOfType(ID: LLVMContext::OB_clang_arc_attachedcall, |
1867 | Idx: U.getOperandNo())) |
1868 | continue; |
1869 | |
1870 | if (PutOffender) |
1871 | *PutOffender = FU; |
1872 | return true; |
1873 | } |
1874 | } |
1875 | return false; |
1876 | } |
1877 | |
1878 | bool Function::isDefTriviallyDead() const { |
1879 | // Check the linkage |
1880 | if (!hasLinkOnceLinkage() && !hasLocalLinkage() && |
1881 | !hasAvailableExternallyLinkage()) |
1882 | return false; |
1883 | |
1884 | // Check if the function is used by anything other than a blockaddress. |
1885 | for (const User *U : users()) |
1886 | if (!isa<BlockAddress>(Val: U)) |
1887 | return false; |
1888 | |
1889 | return true; |
1890 | } |
1891 | |
1892 | /// callsFunctionThatReturnsTwice - Return true if the function has a call to |
1893 | /// setjmp or other function that gcc recognizes as "returning twice". |
1894 | bool Function::callsFunctionThatReturnsTwice() const { |
1895 | for (const Instruction &I : instructions(F: this)) |
1896 | if (const auto *Call = dyn_cast<CallBase>(Val: &I)) |
1897 | if (Call->hasFnAttr(Attribute::ReturnsTwice)) |
1898 | return true; |
1899 | |
1900 | return false; |
1901 | } |
1902 | |
1903 | Constant *Function::getPersonalityFn() const { |
1904 | assert(hasPersonalityFn() && getNumOperands()); |
1905 | return cast<Constant>(Val: Op<0>()); |
1906 | } |
1907 | |
1908 | void Function::setPersonalityFn(Constant *Fn) { |
1909 | setHungoffOperand<0>(Fn); |
1910 | setValueSubclassDataBit(Bit: 3, On: Fn != nullptr); |
1911 | } |
1912 | |
1913 | Constant *Function::getPrefixData() const { |
1914 | assert(hasPrefixData() && getNumOperands()); |
1915 | return cast<Constant>(Val: Op<1>()); |
1916 | } |
1917 | |
1918 | void Function::setPrefixData(Constant *PrefixData) { |
1919 | setHungoffOperand<1>(PrefixData); |
1920 | setValueSubclassDataBit(Bit: 1, On: PrefixData != nullptr); |
1921 | } |
1922 | |
1923 | Constant *Function::getPrologueData() const { |
1924 | assert(hasPrologueData() && getNumOperands()); |
1925 | return cast<Constant>(Val: Op<2>()); |
1926 | } |
1927 | |
1928 | void Function::setPrologueData(Constant *PrologueData) { |
1929 | setHungoffOperand<2>(PrologueData); |
1930 | setValueSubclassDataBit(Bit: 2, On: PrologueData != nullptr); |
1931 | } |
1932 | |
1933 | void Function::allocHungoffUselist() { |
1934 | // If we've already allocated a uselist, stop here. |
1935 | if (getNumOperands()) |
1936 | return; |
1937 | |
1938 | allocHungoffUses(N: 3, /*IsPhi=*/ false); |
1939 | setNumHungOffUseOperands(3); |
1940 | |
1941 | // Initialize the uselist with placeholder operands to allow traversal. |
1942 | auto *CPN = ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0)); |
1943 | Op<0>().set(CPN); |
1944 | Op<1>().set(CPN); |
1945 | Op<2>().set(CPN); |
1946 | } |
1947 | |
1948 | template <int Idx> |
1949 | void Function::setHungoffOperand(Constant *C) { |
1950 | if (C) { |
1951 | allocHungoffUselist(); |
1952 | Op<Idx>().set(C); |
1953 | } else if (getNumOperands()) { |
1954 | Op<Idx>().set(ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0))); |
1955 | } |
1956 | } |
1957 | |
1958 | void Function::setValueSubclassDataBit(unsigned Bit, bool On) { |
1959 | assert(Bit < 16 && "SubclassData contains only 16 bits" ); |
1960 | if (On) |
1961 | setValueSubclassData(getSubclassDataFromValue() | (1 << Bit)); |
1962 | else |
1963 | setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit)); |
1964 | } |
1965 | |
1966 | void Function::setEntryCount(ProfileCount Count, |
1967 | const DenseSet<GlobalValue::GUID> *S) { |
1968 | #if !defined(NDEBUG) |
1969 | auto PrevCount = getEntryCount(); |
1970 | assert(!PrevCount || PrevCount->getType() == Count.getType()); |
1971 | #endif |
1972 | |
1973 | auto ImportGUIDs = getImportGUIDs(); |
1974 | if (S == nullptr && ImportGUIDs.size()) |
1975 | S = &ImportGUIDs; |
1976 | |
1977 | MDBuilder MDB(getContext()); |
1978 | setMetadata( |
1979 | KindID: LLVMContext::MD_prof, |
1980 | Node: MDB.createFunctionEntryCount(Count: Count.getCount(), Synthetic: Count.isSynthetic(), Imports: S)); |
1981 | } |
1982 | |
1983 | void Function::setEntryCount(uint64_t Count, Function::ProfileCountType Type, |
1984 | const DenseSet<GlobalValue::GUID> *Imports) { |
1985 | setEntryCount(Count: ProfileCount(Count, Type), S: Imports); |
1986 | } |
1987 | |
1988 | std::optional<ProfileCount> Function::getEntryCount(bool AllowSynthetic) const { |
1989 | MDNode *MD = getMetadata(KindID: LLVMContext::MD_prof); |
1990 | if (MD && MD->getOperand(I: 0)) |
1991 | if (MDString *MDS = dyn_cast<MDString>(Val: MD->getOperand(I: 0))) { |
1992 | if (MDS->getString().equals(RHS: "function_entry_count" )) { |
1993 | ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 1)); |
1994 | uint64_t Count = CI->getValue().getZExtValue(); |
1995 | // A value of -1 is used for SamplePGO when there were no samples. |
1996 | // Treat this the same as unknown. |
1997 | if (Count == (uint64_t)-1) |
1998 | return std::nullopt; |
1999 | return ProfileCount(Count, PCT_Real); |
2000 | } else if (AllowSynthetic && |
2001 | MDS->getString().equals(RHS: "synthetic_function_entry_count" )) { |
2002 | ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 1)); |
2003 | uint64_t Count = CI->getValue().getZExtValue(); |
2004 | return ProfileCount(Count, PCT_Synthetic); |
2005 | } |
2006 | } |
2007 | return std::nullopt; |
2008 | } |
2009 | |
2010 | DenseSet<GlobalValue::GUID> Function::getImportGUIDs() const { |
2011 | DenseSet<GlobalValue::GUID> R; |
2012 | if (MDNode *MD = getMetadata(KindID: LLVMContext::MD_prof)) |
2013 | if (MDString *MDS = dyn_cast<MDString>(Val: MD->getOperand(I: 0))) |
2014 | if (MDS->getString().equals(RHS: "function_entry_count" )) |
2015 | for (unsigned i = 2; i < MD->getNumOperands(); i++) |
2016 | R.insert(V: mdconst::extract<ConstantInt>(MD: MD->getOperand(I: i)) |
2017 | ->getValue() |
2018 | .getZExtValue()); |
2019 | return R; |
2020 | } |
2021 | |
2022 | void Function::setSectionPrefix(StringRef Prefix) { |
2023 | MDBuilder MDB(getContext()); |
2024 | setMetadata(KindID: LLVMContext::MD_section_prefix, |
2025 | Node: MDB.createFunctionSectionPrefix(Prefix)); |
2026 | } |
2027 | |
2028 | std::optional<StringRef> Function::getSectionPrefix() const { |
2029 | if (MDNode *MD = getMetadata(KindID: LLVMContext::MD_section_prefix)) { |
2030 | assert(cast<MDString>(MD->getOperand(0)) |
2031 | ->getString() |
2032 | .equals("function_section_prefix" ) && |
2033 | "Metadata not match" ); |
2034 | return cast<MDString>(Val: MD->getOperand(I: 1))->getString(); |
2035 | } |
2036 | return std::nullopt; |
2037 | } |
2038 | |
2039 | bool Function::nullPointerIsDefined() const { |
2040 | return hasFnAttribute(Attribute::NullPointerIsValid); |
2041 | } |
2042 | |
2043 | bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) { |
2044 | if (F && F->nullPointerIsDefined()) |
2045 | return true; |
2046 | |
2047 | if (AS != 0) |
2048 | return true; |
2049 | |
2050 | return false; |
2051 | } |
2052 | |