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