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/BitVector.h"
17#include "llvm/ADT/DenseSet.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallString.h"
20#include "llvm/ADT/SmallVector.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/LLVMContext.h"
36#include "llvm/IR/MDBuilder.h"
37#include "llvm/IR/Metadata.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Operator.h"
40#include "llvm/IR/ProfDataUtils.h"
41#include "llvm/IR/SymbolTableListTraits.h"
42#include "llvm/IR/Type.h"
43#include "llvm/IR/Use.h"
44#include "llvm/IR/User.h"
45#include "llvm/IR/Value.h"
46#include "llvm/IR/ValueSymbolTable.h"
47#include "llvm/Support/Casting.h"
48#include "llvm/Support/CommandLine.h"
49#include "llvm/Support/Compiler.h"
50#include "llvm/Support/ErrorHandling.h"
51#include "llvm/Support/ModRef.h"
52#include <cassert>
53#include <cstddef>
54#include <cstdint>
55#include <cstring>
56#include <string>
57
58using namespace llvm;
59
60// Explicit instantiations of SymbolTableListTraits since some of the methods
61// are not in the public header file...
62template class LLVM_EXPORT_TEMPLATE llvm::SymbolTableListTraits<BasicBlock>;
63
64static cl::opt<int> NonGlobalValueMaxNameSize(
65 "non-global-value-max-name-size", cl::Hidden, cl::init(Val: 1024),
66 cl::desc("Maximum size for the name of non-global values."));
67
68void Function::renumberBlocks() {
69 validateBlockNumbers();
70
71 NextBlockNum = 0;
72 for (auto &BB : *this)
73 BB.Number = NextBlockNum++;
74 BlockNumEpoch++;
75}
76
77void Function::validateBlockNumbers() const {
78#ifndef NDEBUG
79 BitVector Numbers(NextBlockNum);
80 for (const auto &BB : *this) {
81 unsigned Num = BB.getNumber();
82 assert(Num < NextBlockNum && "out of range block number");
83 assert(!Numbers[Num] && "duplicate block numbers");
84 Numbers.set(Num);
85 }
86#endif
87}
88
89void Function::convertToNewDbgValues() {
90 for (auto &BB : *this) {
91 BB.convertToNewDbgValues();
92 }
93}
94
95void Function::convertFromNewDbgValues() {
96 for (auto &BB : *this) {
97 BB.convertFromNewDbgValues();
98 }
99}
100
101//===----------------------------------------------------------------------===//
102// Argument Implementation
103//===----------------------------------------------------------------------===//
104
105Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
106 : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
107 setName(Name);
108}
109
110void Argument::setParent(Function *parent) {
111 Parent = parent;
112}
113
114bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const {
115 if (!getType()->isPointerTy()) return false;
116 AttributeSet Attrs = getAttributes();
117 if (Attrs.hasAttribute(Kind: Attribute::NonNull) &&
118 (AllowUndefOrPoison || Attrs.hasAttribute(Kind: Attribute::NoUndef)))
119 return true;
120 else if (getDereferenceableBytes() > 0 &&
121 !NullPointerIsDefined(F: getParent(),
122 AS: getType()->getPointerAddressSpace()))
123 return true;
124 return false;
125}
126
127bool Argument::hasByValAttr() const {
128 if (!getType()->isPointerTy()) return false;
129 return hasAttribute(Kind: Attribute::ByVal);
130}
131
132DeadOnReturnInfo Argument::getDeadOnReturnInfo() const {
133 assert(getType()->isPointerTy() && "Only pointers have dead_on_return bytes");
134 return getParent()->getDeadOnReturnInfo(ArgNo: getArgNo());
135}
136
137bool Argument::hasByRefAttr() const {
138 if (!getType()->isPointerTy())
139 return false;
140 return hasAttribute(Kind: Attribute::ByRef);
141}
142
143bool Argument::hasSwiftSelfAttr() const {
144 return getParent()->hasParamAttribute(ArgNo: getArgNo(), Kind: Attribute::SwiftSelf);
145}
146
147bool Argument::hasSwiftErrorAttr() const {
148 return getParent()->hasParamAttribute(ArgNo: getArgNo(), Kind: Attribute::SwiftError);
149}
150
151bool Argument::hasInAllocaAttr() const {
152 if (!getType()->isPointerTy()) return false;
153 return hasAttribute(Kind: Attribute::InAlloca);
154}
155
156bool Argument::hasPreallocatedAttr() const {
157 if (!getType()->isPointerTy())
158 return false;
159 return hasAttribute(Kind: Attribute::Preallocated);
160}
161
162bool Argument::hasPassPointeeByValueCopyAttr() const {
163 if (!getType()->isPointerTy()) return false;
164 AttributeSet Attrs = getAttributes();
165 return Attrs.hasAttribute(Kind: Attribute::ByVal) ||
166 Attrs.hasAttribute(Kind: Attribute::InAlloca) ||
167 Attrs.hasAttribute(Kind: Attribute::Preallocated);
168}
169
170bool Argument::hasPointeeInMemoryValueAttr() const {
171 if (!getType()->isPointerTy())
172 return false;
173 AttributeSet Attrs = getAttributes();
174 return Attrs.hasAttribute(Kind: Attribute::ByVal) ||
175 Attrs.hasAttribute(Kind: Attribute::StructRet) ||
176 Attrs.hasAttribute(Kind: Attribute::InAlloca) ||
177 Attrs.hasAttribute(Kind: Attribute::Preallocated) ||
178 Attrs.hasAttribute(Kind: Attribute::ByRef);
179}
180
181/// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
182/// parameter type.
183static Type *getMemoryParamAllocType(AttributeSet ParamAttrs) {
184 // FIXME: All the type carrying attributes are mutually exclusive, so there
185 // should be a single query to get the stored type that handles any of them.
186 if (Type *ByValTy = ParamAttrs.getByValType())
187 return ByValTy;
188 if (Type *ByRefTy = ParamAttrs.getByRefType())
189 return ByRefTy;
190 if (Type *PreAllocTy = ParamAttrs.getPreallocatedType())
191 return PreAllocTy;
192 if (Type *InAllocaTy = ParamAttrs.getInAllocaType())
193 return InAllocaTy;
194 if (Type *SRetTy = ParamAttrs.getStructRetType())
195 return SRetTy;
196
197 return nullptr;
198}
199
200uint64_t Argument::getPassPointeeByValueCopySize(const DataLayout &DL) const {
201 if (Type *MemTy = getMemoryParamAllocType(ParamAttrs: getAttributes()))
202 return DL.getTypeAllocSize(Ty: MemTy);
203 return 0;
204}
205
206Type *Argument::getPointeeInMemoryValueType() const {
207 return getMemoryParamAllocType(ParamAttrs: getAttributes());
208}
209
210MaybeAlign Argument::getParamAlign() const {
211 assert(getType()->isPointerTy() && "Only pointers have alignments");
212 return getParent()->getParamAlign(ArgNo: getArgNo());
213}
214
215MaybeAlign Argument::getParamStackAlign() const {
216 return getParent()->getParamStackAlign(ArgNo: getArgNo());
217}
218
219Type *Argument::getParamByValType() const {
220 assert(getType()->isPointerTy() && "Only pointers have byval types");
221 return getParent()->getParamByValType(ArgNo: getArgNo());
222}
223
224Type *Argument::getParamStructRetType() const {
225 assert(getType()->isPointerTy() && "Only pointers have sret types");
226 return getParent()->getParamStructRetType(ArgNo: getArgNo());
227}
228
229Type *Argument::getParamByRefType() const {
230 assert(getType()->isPointerTy() && "Only pointers have byref types");
231 return getParent()->getParamByRefType(ArgNo: getArgNo());
232}
233
234Type *Argument::getParamInAllocaType() const {
235 assert(getType()->isPointerTy() && "Only pointers have inalloca types");
236 return getParent()->getParamInAllocaType(ArgNo: getArgNo());
237}
238
239uint64_t Argument::getDereferenceableBytes() const {
240 assert(getType()->isPointerTy() &&
241 "Only pointers have dereferenceable bytes");
242 return getParent()->getParamDereferenceableBytes(ArgNo: getArgNo());
243}
244
245uint64_t Argument::getDereferenceableOrNullBytes() const {
246 assert(getType()->isPointerTy() &&
247 "Only pointers have dereferenceable bytes");
248 return getParent()->getParamDereferenceableOrNullBytes(ArgNo: getArgNo());
249}
250
251FPClassTest Argument::getNoFPClass() const {
252 return getParent()->getParamNoFPClass(ArgNo: getArgNo());
253}
254
255std::optional<ConstantRange> Argument::getRange() const {
256 const Attribute RangeAttr = getAttribute(Kind: llvm::Attribute::Range);
257 if (RangeAttr.isValid())
258 return RangeAttr.getRange();
259 return std::nullopt;
260}
261
262bool Argument::hasNestAttr() const {
263 if (!getType()->isPointerTy()) return false;
264 return hasAttribute(Kind: Attribute::Nest);
265}
266
267bool Argument::hasNoAliasAttr() const {
268 if (!getType()->isPointerTy()) return false;
269 return hasAttribute(Kind: Attribute::NoAlias);
270}
271
272bool Argument::hasNoCaptureAttr() const {
273 if (!getType()->isPointerTy()) return false;
274 return capturesNothing(CC: getAttributes().getCaptureInfo());
275}
276
277bool Argument::hasNoFreeAttr() const {
278 if (!getType()->isPointerTy()) return false;
279 return hasAttribute(Kind: Attribute::NoFree);
280}
281
282bool Argument::hasStructRetAttr() const {
283 if (!getType()->isPointerTy()) return false;
284 return hasAttribute(Kind: Attribute::StructRet);
285}
286
287bool Argument::hasInRegAttr() const {
288 return hasAttribute(Kind: Attribute::InReg);
289}
290
291bool Argument::hasReturnedAttr() const {
292 return hasAttribute(Kind: Attribute::Returned);
293}
294
295bool Argument::hasZExtAttr() const {
296 return hasAttribute(Kind: Attribute::ZExt);
297}
298
299bool Argument::hasSExtAttr() const {
300 return hasAttribute(Kind: Attribute::SExt);
301}
302
303bool Argument::onlyReadsMemory() const {
304 AttributeSet Attrs = getAttributes();
305 return Attrs.hasAttribute(Kind: Attribute::ReadOnly) ||
306 Attrs.hasAttribute(Kind: Attribute::ReadNone);
307}
308
309void Argument::addAttrs(AttrBuilder &B) {
310 AttributeList AL = getParent()->getAttributes();
311 AL = AL.addParamAttributes(C&: Parent->getContext(), ArgNo: getArgNo(), B);
312 getParent()->setAttributes(AL);
313}
314
315void Argument::addAttr(Attribute::AttrKind Kind) {
316 getParent()->addParamAttr(ArgNo: getArgNo(), Kind);
317}
318
319void Argument::addAttr(Attribute Attr) {
320 getParent()->addParamAttr(ArgNo: getArgNo(), Attr);
321}
322
323void Argument::removeAttr(Attribute::AttrKind Kind) {
324 getParent()->removeParamAttr(ArgNo: getArgNo(), Kind);
325}
326
327void Argument::removeAttrs(const AttributeMask &AM) {
328 AttributeList AL = getParent()->getAttributes();
329 AL = AL.removeParamAttributes(C&: Parent->getContext(), ArgNo: getArgNo(), AttrsToRemove: AM);
330 getParent()->setAttributes(AL);
331}
332
333bool Argument::hasAttribute(Attribute::AttrKind Kind) const {
334 return getParent()->hasParamAttribute(ArgNo: getArgNo(), Kind);
335}
336
337bool Argument::hasAttribute(StringRef Kind) const {
338 return getParent()->hasParamAttribute(ArgNo: getArgNo(), Kind);
339}
340
341Attribute Argument::getAttribute(Attribute::AttrKind Kind) const {
342 return getParent()->getParamAttribute(ArgNo: getArgNo(), Kind);
343}
344
345AttributeSet Argument::getAttributes() const {
346 return getParent()->getAttributes().getParamAttrs(ArgNo: getArgNo());
347}
348
349//===----------------------------------------------------------------------===//
350// Helper Methods in Function
351//===----------------------------------------------------------------------===//
352
353LLVMContext &Function::getContext() const {
354 return getType()->getContext();
355}
356
357const DataLayout &Function::getDataLayout() const {
358 return getParent()->getDataLayout();
359}
360
361unsigned Function::getInstructionCount() const {
362 unsigned NumInstrs = 0;
363 for (const BasicBlock &BB : BasicBlocks)
364 NumInstrs += BB.size();
365 return NumInstrs;
366}
367
368Function *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
373Function *Function::createWithDefaultAttr(FunctionType *Ty,
374 LinkageTypes Linkage,
375 unsigned AddrSpace, const Twine &N,
376 Module *M) {
377 auto *F = new (AllocMarker) 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::Reserved:
387 B.addAttribute(A: "frame-pointer", V: "reserved");
388 break;
389 case FramePointerKind::NonLeaf:
390 B.addAttribute(A: "frame-pointer", V: "non-leaf");
391 break;
392 case FramePointerKind::NonLeafNoReserve:
393 B.addAttribute(A: "frame-pointer", V: "non-leaf-no-reserve");
394 break;
395 case FramePointerKind::All:
396 B.addAttribute(A: "frame-pointer", V: "all");
397 break;
398 }
399 if (M->getModuleFlag(Key: "function_return_thunk_extern"))
400 B.addAttribute(Val: Attribute::FnRetThunkExtern);
401 StringRef DefaultCPU = F->getContext().getDefaultTargetCPU();
402 if (!DefaultCPU.empty())
403 B.addAttribute(A: "target-cpu", V: DefaultCPU);
404 StringRef DefaultFeatures = F->getContext().getDefaultTargetFeatures();
405 if (!DefaultFeatures.empty())
406 B.addAttribute(A: "target-features", V: DefaultFeatures);
407
408 // Check if the module attribute is present and not zero.
409 auto isModuleAttributeSet = [&](const StringRef &ModAttr) -> bool {
410 const auto *Attr =
411 mdconst::extract_or_null<ConstantInt>(MD: M->getModuleFlag(Key: ModAttr));
412 return Attr && !Attr->isZero();
413 };
414
415 auto AddAttributeIfSet = [&](const StringRef &ModAttr) {
416 if (isModuleAttributeSet(ModAttr))
417 B.addAttribute(A: ModAttr);
418 };
419
420 StringRef SignType = "none";
421 if (isModuleAttributeSet("sign-return-address"))
422 SignType = "non-leaf";
423 if (isModuleAttributeSet("sign-return-address-all"))
424 SignType = "all";
425 if (SignType != "none") {
426 B.addAttribute(A: "sign-return-address", V: SignType);
427 B.addAttribute(A: "sign-return-address-key",
428 V: isModuleAttributeSet("sign-return-address-with-bkey")
429 ? "b_key"
430 : "a_key");
431 }
432 AddAttributeIfSet("branch-target-enforcement");
433 AddAttributeIfSet("branch-protection-pauth-lr");
434 AddAttributeIfSet("guarded-control-stack");
435
436 F->addFnAttrs(Attrs: B);
437 return F;
438}
439
440void Function::removeFromParent() {
441 getParent()->getFunctionList().remove(IT: getIterator());
442}
443
444void Function::eraseFromParent() {
445 getParent()->getFunctionList().erase(where: getIterator());
446}
447
448void Function::splice(Function::iterator ToIt, Function *FromF,
449 Function::iterator FromBeginIt,
450 Function::iterator FromEndIt) {
451#ifdef EXPENSIVE_CHECKS
452 // Check that FromBeginIt is before FromEndIt.
453 auto FromFEnd = FromF->end();
454 for (auto It = FromBeginIt; It != FromEndIt; ++It)
455 assert(It != FromFEnd && "FromBeginIt not before FromEndIt!");
456#endif // EXPENSIVE_CHECKS
457 BasicBlocks.splice(where: ToIt, L2&: FromF->BasicBlocks, first: FromBeginIt, last: FromEndIt);
458}
459
460Function::iterator Function::erase(Function::iterator FromIt,
461 Function::iterator ToIt) {
462 return BasicBlocks.erase(first: FromIt, last: ToIt);
463}
464
465//===----------------------------------------------------------------------===//
466// Function Implementation
467//===----------------------------------------------------------------------===//
468
469static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
470 // If AS == -1 and we are passed a valid module pointer we place the function
471 // in the program address space. Otherwise we default to AS0.
472 if (AddrSpace == static_cast<unsigned>(-1))
473 return M ? M->getDataLayout().getProgramAddressSpace() : 0;
474 return AddrSpace;
475}
476
477Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
478 const Twine &name, Module *ParentModule)
479 : GlobalObject(Ty, Value::FunctionVal, AllocMarker, Linkage, name,
480 computeAddrSpace(AddrSpace, M: ParentModule)),
481 NumArgs(Ty->getNumParams()) {
482 assert(FunctionType::isValidReturnType(getReturnType()) &&
483 "invalid return type");
484 setGlobalObjectSubClassData(0);
485
486 // We only need a symbol table for a function if the context keeps value names
487 if (!getContext().shouldDiscardValueNames())
488 SymTab = std::make_unique<ValueSymbolTable>(args&: NonGlobalValueMaxNameSize);
489
490 // If the function has arguments, mark them as lazily built.
491 if (Ty->getNumParams())
492 setValueSubclassData(1); // Set the "has lazy arguments" bit.
493
494 if (ParentModule) {
495 ParentModule->getFunctionList().push_back(val: this);
496 }
497
498 HasLLVMReservedName = getName().starts_with(Prefix: "llvm.");
499 // Ensure intrinsics have the right parameter attributes.
500 // Note, the IntID field will have been set in Value::setName if this function
501 // name is a valid intrinsic ID.
502 if (IntID) {
503 // Don't set the attributes if the intrinsic signature is invalid. This
504 // case will either be auto-upgraded or fail verification.
505 SmallVector<Type *> OverloadTys;
506 if (!Intrinsic::isSignatureValid(ID: IntID, FT: Ty, OverloadTys))
507 return;
508
509 setAttributes(Intrinsic::getAttributes(C&: getContext(), id: IntID, FT: Ty));
510 }
511}
512
513Function::~Function() {
514 validateBlockNumbers();
515
516 dropAllReferences(); // After this it is safe to delete instructions.
517
518 // Delete all of the method arguments and unlink from symbol table...
519 if (Arguments)
520 clearArguments();
521
522 // Remove the function from the on-the-side GC table.
523 clearGC();
524}
525
526void Function::BuildLazyArguments() const {
527 // Create the arguments vector, all arguments start out unnamed.
528 auto *FT = getFunctionType();
529 if (NumArgs > 0) {
530 Arguments = std::allocator<Argument>().allocate(n: NumArgs);
531 for (unsigned i = 0, e = NumArgs; i != e; ++i) {
532 Type *ArgTy = FT->getParamType(i);
533 assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
534 new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
535 }
536 }
537
538 // Clear the lazy arguments bit.
539 unsigned SDC = getSubclassDataFromValue();
540 SDC &= ~(1 << 0);
541 const_cast<Function*>(this)->setValueSubclassData(SDC);
542 assert(!hasLazyArguments());
543}
544
545static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) {
546 return MutableArrayRef<Argument>(Args, Count);
547}
548
549bool Function::isConstrainedFPIntrinsic() const {
550 return Intrinsic::isConstrainedFPIntrinsic(QID: getIntrinsicID());
551}
552
553void Function::clearArguments() {
554 for (Argument &A : makeArgArray(Args: Arguments, Count: NumArgs)) {
555 A.setName("");
556 A.~Argument();
557 }
558 std::allocator<Argument>().deallocate(p: Arguments, n: NumArgs);
559 Arguments = nullptr;
560}
561
562void Function::stealArgumentListFrom(Function &Src) {
563 assert(isDeclaration() && "Expected no references to current arguments");
564
565 // Drop the current arguments, if any, and set the lazy argument bit.
566 if (!hasLazyArguments()) {
567 assert(llvm::all_of(makeArgArray(Arguments, NumArgs),
568 [](const Argument &A) { return A.use_empty(); }) &&
569 "Expected arguments to be unused in declaration");
570 clearArguments();
571 setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
572 }
573
574 // Nothing to steal if Src has lazy arguments.
575 if (Src.hasLazyArguments())
576 return;
577
578 // Steal arguments from Src, and fix the lazy argument bits.
579 assert(arg_size() == Src.arg_size());
580 Arguments = Src.Arguments;
581 Src.Arguments = nullptr;
582 for (Argument &A : makeArgArray(Args: Arguments, Count: NumArgs)) {
583 // FIXME: This does the work of transferNodesFromList inefficiently.
584 SmallString<128> Name;
585 if (A.hasName())
586 Name = A.getName();
587 if (!Name.empty())
588 A.setName("");
589 A.setParent(this);
590 if (!Name.empty())
591 A.setName(Name);
592 }
593
594 setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
595 assert(!hasLazyArguments());
596 Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
597}
598
599void Function::deleteBodyImpl(bool ShouldDrop) {
600 setIsMaterializable(false);
601
602 for (BasicBlock &BB : *this)
603 BB.dropAllReferences();
604
605 // Delete all basic blocks. They are now unused, except possibly by
606 // blockaddresses, but BasicBlock's destructor takes care of those.
607 while (!BasicBlocks.empty())
608 BasicBlocks.begin()->eraseFromParent();
609
610 if (getNumOperands()) {
611 if (ShouldDrop) {
612 // Drop uses of any optional data (real or placeholder).
613 User::dropAllReferences();
614 setNumHungOffUseOperands(0);
615 } else {
616 // The code needs to match Function::allocHungoffUselist().
617 auto *CPN = ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0));
618 Op<0>().set(CPN);
619 Op<1>().set(CPN);
620 Op<2>().set(CPN);
621 }
622 setValueSubclassData(getSubclassDataFromValue() & ~0xe);
623 }
624
625 // Metadata is stored in a side-table.
626 clearMetadata();
627}
628
629void Function::addAttributeAtIndex(unsigned i, Attribute Attr) {
630 AttributeSets = AttributeSets.addAttributeAtIndex(C&: getContext(), Index: i, A: Attr);
631}
632
633void Function::addFnAttr(Attribute::AttrKind Kind) {
634 AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Kind);
635}
636
637void Function::addFnAttr(StringRef Kind, StringRef Val) {
638 AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Kind, Value: Val);
639}
640
641void Function::addFnAttr(Attribute Attr) {
642 AttributeSets = AttributeSets.addFnAttribute(C&: getContext(), Attr);
643}
644
645void Function::addFnAttrs(const AttrBuilder &Attrs) {
646 AttributeSets = AttributeSets.addFnAttributes(C&: getContext(), B: Attrs);
647}
648
649void Function::addRetAttr(Attribute::AttrKind Kind) {
650 AttributeSets = AttributeSets.addRetAttribute(C&: getContext(), Kind);
651}
652
653void Function::addRetAttr(Attribute Attr) {
654 AttributeSets = AttributeSets.addRetAttribute(C&: getContext(), Attr);
655}
656
657void Function::addRetAttrs(const AttrBuilder &Attrs) {
658 AttributeSets = AttributeSets.addRetAttributes(C&: getContext(), B: Attrs);
659}
660
661void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
662 AttributeSets = AttributeSets.addParamAttribute(C&: getContext(), ArgNo, Kind);
663}
664
665void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
666 AttributeSets = AttributeSets.addParamAttribute(C&: getContext(), ArgNos: ArgNo, A: Attr);
667}
668
669void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
670 AttributeSets = AttributeSets.addParamAttributes(C&: getContext(), ArgNo, B: Attrs);
671}
672
673void Function::removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) {
674 AttributeSets = AttributeSets.removeAttributeAtIndex(C&: getContext(), Index: i, Kind);
675}
676
677void Function::removeAttributeAtIndex(unsigned i, StringRef Kind) {
678 AttributeSets = AttributeSets.removeAttributeAtIndex(C&: getContext(), Index: i, Kind);
679}
680
681void Function::removeFnAttr(Attribute::AttrKind Kind) {
682 AttributeSets = AttributeSets.removeFnAttribute(C&: getContext(), Kind);
683}
684
685void Function::removeFnAttr(StringRef Kind) {
686 AttributeSets = AttributeSets.removeFnAttribute(C&: getContext(), Kind);
687}
688
689void Function::removeFnAttrs(const AttributeMask &AM) {
690 AttributeSets = AttributeSets.removeFnAttributes(C&: getContext(), AttrsToRemove: AM);
691}
692
693void Function::removeRetAttr(Attribute::AttrKind Kind) {
694 AttributeSets = AttributeSets.removeRetAttribute(C&: getContext(), Kind);
695}
696
697void Function::removeRetAttr(StringRef Kind) {
698 AttributeSets = AttributeSets.removeRetAttribute(C&: getContext(), Kind);
699}
700
701void Function::removeRetAttrs(const AttributeMask &Attrs) {
702 AttributeSets = AttributeSets.removeRetAttributes(C&: getContext(), AttrsToRemove: Attrs);
703}
704
705void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
706 AttributeSets = AttributeSets.removeParamAttribute(C&: getContext(), ArgNo, Kind);
707}
708
709void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
710 AttributeSets = AttributeSets.removeParamAttribute(C&: getContext(), ArgNo, Kind);
711}
712
713void Function::removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs) {
714 AttributeSets =
715 AttributeSets.removeParamAttributes(C&: getContext(), ArgNo, AttrsToRemove: Attrs);
716}
717
718void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
719 AttributeSets =
720 AttributeSets.addDereferenceableParamAttr(C&: getContext(), ArgNo, Bytes);
721}
722
723bool Function::hasFnAttribute(Attribute::AttrKind Kind) const {
724 return AttributeSets.hasFnAttr(Kind);
725}
726
727bool Function::hasFnAttribute(StringRef Kind) const {
728 return AttributeSets.hasFnAttr(Kind);
729}
730
731bool Function::hasRetAttribute(Attribute::AttrKind Kind) const {
732 return AttributeSets.hasRetAttr(Kind);
733}
734
735bool Function::hasParamAttribute(unsigned ArgNo,
736 Attribute::AttrKind Kind) const {
737 return AttributeSets.hasParamAttr(ArgNo, Kind);
738}
739
740bool Function::hasParamAttribute(unsigned ArgNo, StringRef Kind) const {
741 return AttributeSets.hasParamAttr(ArgNo, Kind);
742}
743
744Attribute Function::getAttributeAtIndex(unsigned i,
745 Attribute::AttrKind Kind) const {
746 return AttributeSets.getAttributeAtIndex(Index: i, Kind);
747}
748
749Attribute Function::getAttributeAtIndex(unsigned i, StringRef Kind) const {
750 return AttributeSets.getAttributeAtIndex(Index: i, Kind);
751}
752
753bool Function::hasAttributeAtIndex(unsigned Idx,
754 Attribute::AttrKind Kind) const {
755 return AttributeSets.hasAttributeAtIndex(Index: Idx, Kind);
756}
757
758Attribute Function::getFnAttribute(Attribute::AttrKind Kind) const {
759 return AttributeSets.getFnAttr(Kind);
760}
761
762Attribute Function::getFnAttribute(StringRef Kind) const {
763 return AttributeSets.getFnAttr(Kind);
764}
765
766Attribute Function::getRetAttribute(Attribute::AttrKind Kind) const {
767 return AttributeSets.getRetAttr(Kind);
768}
769
770uint64_t Function::getFnAttributeAsParsedInteger(StringRef Name,
771 uint64_t Default) const {
772 Attribute A = getFnAttribute(Kind: Name);
773 uint64_t Result = Default;
774 if (A.isStringAttribute()) {
775 StringRef Str = A.getValueAsString();
776 if (Str.getAsInteger(Radix: 0, Result))
777 getContext().emitError(ErrorStr: "cannot parse integer attribute " + Name);
778 }
779
780 return Result;
781}
782
783/// gets the specified attribute from the list of attributes.
784Attribute Function::getParamAttribute(unsigned ArgNo,
785 Attribute::AttrKind Kind) const {
786 return AttributeSets.getParamAttr(ArgNo, Kind);
787}
788
789void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo,
790 uint64_t Bytes) {
791 AttributeSets = AttributeSets.addDereferenceableOrNullParamAttr(C&: getContext(),
792 ArgNo, Bytes);
793}
794
795void Function::addRangeRetAttr(const ConstantRange &CR) {
796 AttributeSets = AttributeSets.addRangeRetAttr(C&: getContext(), CR);
797}
798
799DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const {
800 Attribute Attr = getFnAttribute(Kind: Attribute::DenormalFPEnv);
801 if (!Attr.isValid())
802 return DenormalMode::getDefault();
803
804 DenormalFPEnv FPEnv = Attr.getDenormalFPEnv();
805 return &FPType == &APFloat::IEEEsingle() ? FPEnv.F32Mode : FPEnv.DefaultMode;
806}
807
808DenormalFPEnv Function::getDenormalFPEnv() const {
809 Attribute Attr = getFnAttribute(Kind: Attribute::DenormalFPEnv);
810 return Attr.isValid() ? Attr.getDenormalFPEnv() : DenormalFPEnv::getDefault();
811}
812
813const std::string &Function::getGC() const {
814 assert(hasGC() && "Function has no collector");
815 return getContext().getGC(Fn: *this);
816}
817
818void Function::setGC(std::string Str) {
819 setValueSubclassDataBit(Bit: 14, On: !Str.empty());
820 getContext().setGC(Fn: *this, GCName: std::move(Str));
821}
822
823void Function::clearGC() {
824 if (!hasGC())
825 return;
826 getContext().deleteGC(Fn: *this);
827 setValueSubclassDataBit(Bit: 14, On: false);
828}
829
830bool Function::hasStackProtectorFnAttr() const {
831 return hasFnAttribute(Kind: Attribute::StackProtect) ||
832 hasFnAttribute(Kind: Attribute::StackProtectStrong) ||
833 hasFnAttribute(Kind: Attribute::StackProtectReq);
834}
835
836/// Copy all additional attributes (those not needed to create a Function) from
837/// the Function Src to this one.
838void Function::copyAttributesFrom(const Function *Src) {
839 GlobalObject::copyAttributesFrom(Src);
840 setCallingConv(Src->getCallingConv());
841 setAttributes(Src->getAttributes());
842 if (Src->hasGC())
843 setGC(Src->getGC());
844 else
845 clearGC();
846 if (Src->hasPersonalityFn())
847 setPersonalityFn(Src->getPersonalityFn());
848 if (Src->hasPrefixData())
849 setPrefixData(Src->getPrefixData());
850 if (Src->hasPrologueData())
851 setPrologueData(Src->getPrologueData());
852}
853
854MemoryEffects Function::getMemoryEffects() const {
855 return getAttributes().getMemoryEffects();
856}
857void Function::setMemoryEffects(MemoryEffects ME) {
858 addFnAttr(Attr: Attribute::getWithMemoryEffects(Context&: getContext(), ME));
859}
860
861/// Determine if the function does not access memory.
862bool Function::doesNotAccessMemory() const {
863 return getMemoryEffects().doesNotAccessMemory();
864}
865void Function::setDoesNotAccessMemory() {
866 setMemoryEffects(MemoryEffects::none());
867}
868
869/// Determine if the function does not access or only reads memory.
870bool Function::onlyReadsMemory() const {
871 return getMemoryEffects().onlyReadsMemory();
872}
873void Function::setOnlyReadsMemory() {
874 setMemoryEffects(getMemoryEffects() & MemoryEffects::readOnly());
875}
876
877/// Determine if the function does not access or only writes memory.
878bool Function::onlyWritesMemory() const {
879 return getMemoryEffects().onlyWritesMemory();
880}
881void Function::setOnlyWritesMemory() {
882 setMemoryEffects(getMemoryEffects() & MemoryEffects::writeOnly());
883}
884
885/// Determine if the call can access memory only using pointers based
886/// on its arguments.
887bool Function::onlyAccessesArgMemory() const {
888 return getMemoryEffects().onlyAccessesArgPointees();
889}
890void Function::setOnlyAccessesArgMemory() {
891 setMemoryEffects(getMemoryEffects() & MemoryEffects::argMemOnly());
892}
893
894/// Determine if the function may only access memory that is
895/// inaccessible from the IR.
896bool Function::onlyAccessesInaccessibleMemory() const {
897 return getMemoryEffects().onlyAccessesInaccessibleMem();
898}
899void Function::setOnlyAccessesInaccessibleMemory() {
900 setMemoryEffects(getMemoryEffects() & MemoryEffects::inaccessibleMemOnly());
901}
902
903/// Determine if the function may only access memory that is
904/// either inaccessible from the IR or pointed to by its arguments.
905bool Function::onlyAccessesInaccessibleMemOrArgMem() const {
906 return getMemoryEffects().onlyAccessesInaccessibleOrArgMem();
907}
908void Function::setOnlyAccessesInaccessibleMemOrArgMem() {
909 setMemoryEffects(getMemoryEffects() &
910 MemoryEffects::inaccessibleOrArgMemOnly());
911}
912
913bool Function::isTargetIntrinsic() const {
914 return Intrinsic::isTargetIntrinsic(IID: IntID);
915}
916
917void Function::updateAfterNameChange() {
918 LibFuncCache = UnknownLibFunc;
919 StringRef Name = getName();
920 if (!Name.starts_with(Prefix: "llvm.")) {
921 HasLLVMReservedName = false;
922 IntID = Intrinsic::not_intrinsic;
923 return;
924 }
925 HasLLVMReservedName = true;
926 IntID = Intrinsic::lookupIntrinsicID(Name);
927}
928
929/// hasAddressTaken - returns true if there are any uses of this function
930/// other than direct calls or invokes to it. Optionally ignores callback
931/// uses, assume like pointer annotation calls, and references in llvm.used
932/// and llvm.compiler.used variables.
933bool Function::hasAddressTaken(const User **PutOffender,
934 bool IgnoreCallbackUses,
935 bool IgnoreAssumeLikeCalls, bool IgnoreLLVMUsed,
936 bool IgnoreARCAttachedCall,
937 bool IgnoreCastedDirectCall) const {
938 for (const Use &U : uses()) {
939 const User *FU = U.getUser();
940 if (IgnoreCallbackUses) {
941 AbstractCallSite ACS(&U);
942 if (ACS && ACS.isCallbackCall())
943 continue;
944 }
945
946 const auto *Call = dyn_cast<CallBase>(Val: FU);
947 if (!Call) {
948 if (IgnoreAssumeLikeCalls &&
949 isa<BitCastOperator, AddrSpaceCastOperator>(Val: FU) &&
950 all_of(Range: FU->users(), P: [](const User *U) {
951 if (const auto *I = dyn_cast<IntrinsicInst>(Val: U))
952 return I->isAssumeLikeIntrinsic();
953 return false;
954 })) {
955 continue;
956 }
957
958 if (IgnoreLLVMUsed && !FU->user_empty()) {
959 const User *FUU = FU;
960 if (isa<BitCastOperator, AddrSpaceCastOperator>(Val: FU) &&
961 FU->hasOneUse() && !FU->user_begin()->user_empty())
962 FUU = *FU->user_begin();
963 if (llvm::all_of(Range: FUU->users(), P: [](const User *U) {
964 if (const auto *GV = dyn_cast<GlobalVariable>(Val: U))
965 return GV->hasName() &&
966 (GV->getName() == "llvm.compiler.used" ||
967 GV->getName() == "llvm.used");
968 return false;
969 }))
970 continue;
971 }
972 if (PutOffender)
973 *PutOffender = FU;
974 return true;
975 }
976
977 if (IgnoreAssumeLikeCalls) {
978 if (const auto *I = dyn_cast<IntrinsicInst>(Val: Call))
979 if (I->isAssumeLikeIntrinsic())
980 continue;
981 }
982
983 if (!Call->isCallee(U: &U) || (!IgnoreCastedDirectCall &&
984 Call->getFunctionType() != getFunctionType())) {
985 if (IgnoreARCAttachedCall &&
986 Call->isOperandBundleOfType(ID: LLVMContext::OB_clang_arc_attachedcall,
987 Idx: U.getOperandNo()))
988 continue;
989
990 if (PutOffender)
991 *PutOffender = FU;
992 return true;
993 }
994 }
995 return false;
996}
997
998bool Function::isDefTriviallyDead() const {
999 // Check the linkage
1000 if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1001 !hasAvailableExternallyLinkage())
1002 return false;
1003
1004 return use_empty();
1005}
1006
1007/// callsFunctionThatReturnsTwice - Return true if the function has a call to
1008/// setjmp or other function that gcc recognizes as "returning twice".
1009bool Function::callsFunctionThatReturnsTwice() const {
1010 for (const Instruction &I : instructions(F: this))
1011 if (const auto *Call = dyn_cast<CallBase>(Val: &I))
1012 if (Call->hasFnAttr(Kind: Attribute::ReturnsTwice))
1013 return true;
1014
1015 return false;
1016}
1017
1018Constant *Function::getPersonalityFn() const {
1019 assert(hasPersonalityFn() && getNumOperands());
1020 return cast<Constant>(Val: Op<0>());
1021}
1022
1023void Function::setPersonalityFn(Constant *Fn) {
1024 setHungoffOperand<0>(Fn);
1025 setValueSubclassDataBit(Bit: 3, On: Fn != nullptr);
1026}
1027
1028Constant *Function::getPrefixData() const {
1029 assert(hasPrefixData() && getNumOperands());
1030 return cast<Constant>(Val: Op<1>());
1031}
1032
1033void Function::setPrefixData(Constant *PrefixData) {
1034 setHungoffOperand<1>(PrefixData);
1035 setValueSubclassDataBit(Bit: 1, On: PrefixData != nullptr);
1036}
1037
1038Constant *Function::getPrologueData() const {
1039 assert(hasPrologueData() && getNumOperands());
1040 return cast<Constant>(Val: Op<2>());
1041}
1042
1043void Function::setPrologueData(Constant *PrologueData) {
1044 setHungoffOperand<2>(PrologueData);
1045 setValueSubclassDataBit(Bit: 2, On: PrologueData != nullptr);
1046}
1047
1048void Function::allocHungoffUselist() {
1049 // If we've already allocated a uselist, stop here.
1050 if (getNumOperands())
1051 return;
1052
1053 allocHungoffUses(N: 3, /*IsPhi=*/ WithExtraValues: false);
1054 setNumHungOffUseOperands(3);
1055
1056 // Initialize the uselist with placeholder operands to allow traversal.
1057 auto *CPN = ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0));
1058 Op<0>().set(CPN);
1059 Op<1>().set(CPN);
1060 Op<2>().set(CPN);
1061}
1062
1063template <int Idx>
1064void Function::setHungoffOperand(Constant *C) {
1065 if (C) {
1066 allocHungoffUselist();
1067 Op<Idx>().set(C);
1068 } else if (getNumOperands()) {
1069 Op<Idx>().set(ConstantPointerNull::get(T: PointerType::get(C&: getContext(), AddressSpace: 0)));
1070 }
1071}
1072
1073void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1074 assert(Bit < 16 && "SubclassData contains only 16 bits");
1075 if (On)
1076 setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
1077 else
1078 setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
1079}
1080
1081void Function::setEntryCount(uint64_t Count,
1082 const DenseSet<GlobalValue::GUID> *S) {
1083 auto ImportGUIDs = getImportGUIDs();
1084 if (S == nullptr && ImportGUIDs.size())
1085 S = &ImportGUIDs;
1086
1087 MDBuilder MDB(getContext());
1088 setMetadata(KindID: LLVMContext::MD_prof,
1089 Node: MDB.createFunctionEntryCount(Count, Synthetic: false, Imports: S));
1090}
1091
1092std::optional<uint64_t> Function::getEntryCount() const {
1093 MDNode *MD = getMetadata(KindID: LLVMContext::MD_prof);
1094 if (MD && MD->getOperand(I: 0))
1095 if (MDString *MDS = dyn_cast<MDString>(Val: MD->getOperand(I: 0))) {
1096 if (MDS->getString() != MDProfLabels::FunctionEntryCount)
1097 return std::nullopt;
1098 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 1));
1099 uint64_t Count = CI->getValue().getZExtValue();
1100 // A value of -1 is used for SamplePGO when there were no samples.
1101 // Treat this the same as unknown.
1102 if (Count == static_cast<uint64_t>(-1))
1103 return std::nullopt;
1104 return Count;
1105 }
1106 return std::nullopt;
1107}
1108
1109DenseSet<GlobalValue::GUID> Function::getImportGUIDs() const {
1110 DenseSet<GlobalValue::GUID> R;
1111 if (MDNode *MD = getMetadata(KindID: LLVMContext::MD_prof))
1112 if (MDString *MDS = dyn_cast<MDString>(Val: MD->getOperand(I: 0)))
1113 if (MDS->getString() == MDProfLabels::FunctionEntryCount)
1114 for (unsigned i = 2; i < MD->getNumOperands(); i++)
1115 R.insert(V: mdconst::extract<ConstantInt>(MD: MD->getOperand(I: i))
1116 ->getValue()
1117 .getZExtValue());
1118 return R;
1119}
1120
1121bool Function::nullPointerIsDefined() const {
1122 return hasFnAttribute(Kind: Attribute::NullPointerIsValid);
1123}
1124
1125unsigned Function::getVScaleValue() const {
1126 Attribute Attr = getFnAttribute(Kind: Attribute::VScaleRange);
1127 if (!Attr.isValid())
1128 return 0;
1129
1130 unsigned VScale = Attr.getVScaleRangeMin();
1131 if (VScale && VScale == Attr.getVScaleRangeMax())
1132 return VScale;
1133
1134 return 0;
1135}
1136
1137bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
1138 if (F && F->nullPointerIsDefined())
1139 return true;
1140
1141 if (AS != 0)
1142 return true;
1143
1144 return false;
1145}
1146
1147bool llvm::CallingConv::supportsNonVoidReturnType(CallingConv::ID CC) {
1148 switch (CC) {
1149 case CallingConv::C:
1150 case CallingConv::Fast:
1151 case CallingConv::Cold:
1152 case CallingConv::GHC:
1153 case CallingConv::HiPE:
1154 case CallingConv::AnyReg:
1155 case CallingConv::PreserveMost:
1156 case CallingConv::PreserveAll:
1157 case CallingConv::Swift:
1158 case CallingConv::CXX_FAST_TLS:
1159 case CallingConv::Tail:
1160 case CallingConv::CFGuard_Check:
1161 case CallingConv::SwiftTail:
1162 case CallingConv::PreserveNone:
1163 case CallingConv::X86_StdCall:
1164 case CallingConv::X86_FastCall:
1165 case CallingConv::ARM_APCS:
1166 case CallingConv::ARM_AAPCS:
1167 case CallingConv::ARM_AAPCS_VFP:
1168 case CallingConv::MSP430_INTR:
1169 case CallingConv::X86_ThisCall:
1170 case CallingConv::PTX_Device:
1171 case CallingConv::SPIR_FUNC:
1172 case CallingConv::Intel_OCL_BI:
1173 case CallingConv::X86_64_SysV:
1174 case CallingConv::Win64:
1175 case CallingConv::X86_VectorCall:
1176 case CallingConv::DUMMY_HHVM:
1177 case CallingConv::DUMMY_HHVM_C:
1178 case CallingConv::X86_INTR:
1179 case CallingConv::AVR_INTR:
1180 case CallingConv::AVR_SIGNAL:
1181 case CallingConv::AVR_BUILTIN:
1182 return true;
1183 case CallingConv::AMDGPU_KERNEL:
1184 case CallingConv::SPIR_KERNEL:
1185 case CallingConv::AMDGPU_CS_Chain:
1186 case CallingConv::AMDGPU_CS_ChainPreserve:
1187 return false;
1188 case CallingConv::AMDGPU_VS:
1189 case CallingConv::AMDGPU_HS:
1190 case CallingConv::AMDGPU_GS:
1191 case CallingConv::AMDGPU_PS:
1192 case CallingConv::AMDGPU_CS:
1193 case CallingConv::AMDGPU_LS:
1194 case CallingConv::AMDGPU_ES:
1195 case CallingConv::MSP430_BUILTIN:
1196 case CallingConv::AArch64_VectorCall:
1197 case CallingConv::AArch64_SVE_VectorCall:
1198 case CallingConv::WASM_EmscriptenInvoke:
1199 case CallingConv::AMDGPU_Gfx:
1200 case CallingConv::AMDGPU_Gfx_WholeWave:
1201 case CallingConv::M68k_INTR:
1202 case CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0:
1203 case CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2:
1204 case CallingConv::M68k_RTD:
1205 case CallingConv::GRAAL:
1206 case CallingConv::ARM64EC_Thunk_X64:
1207 case CallingConv::ARM64EC_Thunk_Native:
1208 case CallingConv::RISCV_VectorCall:
1209 case CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X1:
1210 case CallingConv::RISCV_VLSCall_32:
1211 case CallingConv::RISCV_VLSCall_64:
1212 case CallingConv::RISCV_VLSCall_128:
1213 case CallingConv::RISCV_VLSCall_256:
1214 case CallingConv::RISCV_VLSCall_512:
1215 case CallingConv::RISCV_VLSCall_1024:
1216 case CallingConv::RISCV_VLSCall_2048:
1217 case CallingConv::RISCV_VLSCall_4096:
1218 case CallingConv::RISCV_VLSCall_8192:
1219 case CallingConv::RISCV_VLSCall_16384:
1220 case CallingConv::RISCV_VLSCall_32768:
1221 case CallingConv::RISCV_VLSCall_65536:
1222 return true;
1223 default:
1224 return false;
1225 }
1226
1227 llvm_unreachable("covered callingconv switch");
1228}
1229