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