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