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