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