1 //===- Function.cpp - Implement the Global object classes -----------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file implements the Function class for the IR library.
11 //===----------------------------------------------------------------------===//
13 #include "llvm/IR/Function.h"
14 #include "SymbolTableListTraitsImpl.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/IR/Argument.h"
24 #include "llvm/IR/Attributes.h"
25 #include "llvm/IR/BasicBlock.h"
26 #include "llvm/IR/Constant.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/GlobalValue.h"
30 #include "llvm/IR/InstIterator.h"
31 #include "llvm/IR/Instruction.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/Intrinsics.h"
34 #include "llvm/IR/IntrinsicsAArch64.h"
35 #include "llvm/IR/IntrinsicsAMDGPU.h"
36 #include "llvm/IR/IntrinsicsARM.h"
37 #include "llvm/IR/IntrinsicsBPF.h"
38 #include "llvm/IR/IntrinsicsHexagon.h"
39 #include "llvm/IR/IntrinsicsMips.h"
40 #include "llvm/IR/IntrinsicsNVPTX.h"
41 #include "llvm/IR/IntrinsicsPowerPC.h"
42 #include "llvm/IR/IntrinsicsR600.h"
43 #include "llvm/IR/IntrinsicsRISCV.h"
44 #include "llvm/IR/IntrinsicsS390.h"
45 #include "llvm/IR/IntrinsicsWebAssembly.h"
46 #include "llvm/IR/IntrinsicsX86.h"
47 #include "llvm/IR/IntrinsicsXCore.h"
48 #include "llvm/IR/LLVMContext.h"
49 #include "llvm/IR/MDBuilder.h"
50 #include "llvm/IR/Metadata.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/IR/SymbolTableListTraits.h"
53 #include "llvm/IR/Type.h"
54 #include "llvm/IR/Use.h"
55 #include "llvm/IR/User.h"
56 #include "llvm/IR/Value.h"
57 #include "llvm/IR/ValueSymbolTable.h"
58 #include "llvm/Support/Casting.h"
59 #include "llvm/Support/Compiler.h"
60 #include "llvm/Support/ErrorHandling.h"
69 using ProfileCount = Function::ProfileCount;
71 // Explicit instantiations of SymbolTableListTraits since some of the methods
72 // are not in the public header file...
73 template class llvm::SymbolTableListTraits<BasicBlock>;
75 //===----------------------------------------------------------------------===//
76 // Argument Implementation
77 //===----------------------------------------------------------------------===//
79 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
80 : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
84 void Argument::setParent(Function *parent) {
88 bool Argument::hasNonNullAttr() const {
89 if (!getType()->isPointerTy()) return false;
90 if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull))
92 else if (getDereferenceableBytes() > 0 &&
93 !NullPointerIsDefined(getParent(),
94 getType()->getPointerAddressSpace()))
99 bool Argument::hasByValAttr() const {
100 if (!getType()->isPointerTy()) return false;
101 return hasAttribute(Attribute::ByVal);
104 bool Argument::hasSwiftSelfAttr() const {
105 return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
108 bool Argument::hasSwiftErrorAttr() const {
109 return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
112 bool Argument::hasInAllocaAttr() const {
113 if (!getType()->isPointerTy()) return false;
114 return hasAttribute(Attribute::InAlloca);
117 bool Argument::hasByValOrInAllocaAttr() const {
118 if (!getType()->isPointerTy()) return false;
119 AttributeList Attrs = getParent()->getAttributes();
120 return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
121 Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca);
124 unsigned Argument::getParamAlignment() const {
125 assert(getType()->isPointerTy() && "Only pointers have alignments");
126 return getParent()->getParamAlignment(getArgNo());
129 MaybeAlign Argument::getParamAlign() const {
130 assert(getType()->isPointerTy() && "Only pointers have alignments");
131 return getParent()->getParamAlign(getArgNo());
134 Type *Argument::getParamByValType() const {
135 assert(getType()->isPointerTy() && "Only pointers have byval types");
136 return getParent()->getParamByValType(getArgNo());
139 uint64_t Argument::getDereferenceableBytes() const {
140 assert(getType()->isPointerTy() &&
141 "Only pointers have dereferenceable bytes");
142 return getParent()->getParamDereferenceableBytes(getArgNo());
145 uint64_t Argument::getDereferenceableOrNullBytes() const {
146 assert(getType()->isPointerTy() &&
147 "Only pointers have dereferenceable bytes");
148 return getParent()->getParamDereferenceableOrNullBytes(getArgNo());
151 bool Argument::hasNestAttr() const {
152 if (!getType()->isPointerTy()) return false;
153 return hasAttribute(Attribute::Nest);
156 bool Argument::hasNoAliasAttr() const {
157 if (!getType()->isPointerTy()) return false;
158 return hasAttribute(Attribute::NoAlias);
161 bool Argument::hasNoCaptureAttr() const {
162 if (!getType()->isPointerTy()) return false;
163 return hasAttribute(Attribute::NoCapture);
166 bool Argument::hasStructRetAttr() const {
167 if (!getType()->isPointerTy()) return false;
168 return hasAttribute(Attribute::StructRet);
171 bool Argument::hasInRegAttr() const {
172 return hasAttribute(Attribute::InReg);
175 bool Argument::hasReturnedAttr() const {
176 return hasAttribute(Attribute::Returned);
179 bool Argument::hasZExtAttr() const {
180 return hasAttribute(Attribute::ZExt);
183 bool Argument::hasSExtAttr() const {
184 return hasAttribute(Attribute::SExt);
187 bool Argument::onlyReadsMemory() const {
188 AttributeList Attrs = getParent()->getAttributes();
189 return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) ||
190 Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone);
193 void Argument::addAttrs(AttrBuilder &B) {
194 AttributeList AL = getParent()->getAttributes();
195 AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
196 getParent()->setAttributes(AL);
199 void Argument::addAttr(Attribute::AttrKind Kind) {
200 getParent()->addParamAttr(getArgNo(), Kind);
203 void Argument::addAttr(Attribute Attr) {
204 getParent()->addParamAttr(getArgNo(), Attr);
207 void Argument::removeAttr(Attribute::AttrKind Kind) {
208 getParent()->removeParamAttr(getArgNo(), Kind);
211 bool Argument::hasAttribute(Attribute::AttrKind Kind) const {
212 return getParent()->hasParamAttribute(getArgNo(), Kind);
215 Attribute Argument::getAttribute(Attribute::AttrKind Kind) const {
216 return getParent()->getParamAttribute(getArgNo(), Kind);
219 //===----------------------------------------------------------------------===//
220 // Helper Methods in Function
221 //===----------------------------------------------------------------------===//
223 LLVMContext &Function::getContext() const {
224 return getType()->getContext();
227 unsigned Function::getInstructionCount() const {
228 unsigned NumInstrs = 0;
229 for (const BasicBlock &BB : BasicBlocks)
230 NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
231 BB.instructionsWithoutDebug().end());
235 Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
236 const Twine &N, Module &M) {
237 return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
240 void Function::removeFromParent() {
241 getParent()->getFunctionList().remove(getIterator());
244 void Function::eraseFromParent() {
245 getParent()->getFunctionList().erase(getIterator());
248 //===----------------------------------------------------------------------===//
249 // Function Implementation
250 //===----------------------------------------------------------------------===//
252 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
253 // If AS == -1 and we are passed a valid module pointer we place the function
254 // in the program address space. Otherwise we default to AS0.
255 if (AddrSpace == static_cast<unsigned>(-1))
256 return M ? M->getDataLayout().getProgramAddressSpace() : 0;
260 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
261 const Twine &name, Module *ParentModule)
262 : GlobalObject(Ty, Value::FunctionVal,
263 OperandTraits<Function>::op_begin(this), 0, Linkage, name,
264 computeAddrSpace(AddrSpace, ParentModule)),
265 NumArgs(Ty->getNumParams()) {
266 assert(FunctionType::isValidReturnType(getReturnType()) &&
267 "invalid return type");
268 setGlobalObjectSubClassData(0);
270 // We only need a symbol table for a function if the context keeps value names
271 if (!getContext().shouldDiscardValueNames())
272 SymTab = std::make_unique<ValueSymbolTable>();
274 // If the function has arguments, mark them as lazily built.
275 if (Ty->getNumParams())
276 setValueSubclassData(1); // Set the "has lazy arguments" bit.
279 ParentModule->getFunctionList().push_back(this);
281 HasLLVMReservedName = getName().startswith("llvm.");
282 // Ensure intrinsics have the right parameter attributes.
283 // Note, the IntID field will have been set in Value::setName if this function
284 // name is a valid intrinsic ID.
286 setAttributes(Intrinsic::getAttributes(getContext(), IntID));
289 Function::~Function() {
290 dropAllReferences(); // After this it is safe to delete instructions.
292 // Delete all of the method arguments and unlink from symbol table...
296 // Remove the function from the on-the-side GC table.
300 void Function::BuildLazyArguments() const {
301 // Create the arguments vector, all arguments start out unnamed.
302 auto *FT = getFunctionType();
304 Arguments = std::allocator<Argument>().allocate(NumArgs);
305 for (unsigned i = 0, e = NumArgs; i != e; ++i) {
306 Type *ArgTy = FT->getParamType(i);
307 assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
308 new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
312 // Clear the lazy arguments bit.
313 unsigned SDC = getSubclassDataFromValue();
315 const_cast<Function*>(this)->setValueSubclassData(SDC);
316 assert(!hasLazyArguments());
319 static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) {
320 return MutableArrayRef<Argument>(Args, Count);
323 void Function::clearArguments() {
324 for (Argument &A : makeArgArray(Arguments, NumArgs)) {
328 std::allocator<Argument>().deallocate(Arguments, NumArgs);
332 void Function::stealArgumentListFrom(Function &Src) {
333 assert(isDeclaration() && "Expected no references to current arguments");
335 // Drop the current arguments, if any, and set the lazy argument bit.
336 if (!hasLazyArguments()) {
337 assert(llvm::all_of(makeArgArray(Arguments, NumArgs),
338 [](const Argument &A) { return A.use_empty(); }) &&
339 "Expected arguments to be unused in declaration");
341 setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
344 // Nothing to steal if Src has lazy arguments.
345 if (Src.hasLazyArguments())
348 // Steal arguments from Src, and fix the lazy argument bits.
349 assert(arg_size() == Src.arg_size());
350 Arguments = Src.Arguments;
351 Src.Arguments = nullptr;
352 for (Argument &A : makeArgArray(Arguments, NumArgs)) {
353 // FIXME: This does the work of transferNodesFromList inefficiently.
354 SmallString<128> Name;
364 setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
365 assert(!hasLazyArguments());
366 Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
369 // dropAllReferences() - This function causes all the subinstructions to "let
370 // go" of all references that they are maintaining. This allows one to
371 // 'delete' a whole class at a time, even though there may be circular
372 // references... first all references are dropped, and all use counts go to
373 // zero. Then everything is deleted for real. Note that no operations are
374 // valid on an object that has "dropped all references", except operator
377 void Function::dropAllReferences() {
378 setIsMaterializable(false);
380 for (BasicBlock &BB : *this)
381 BB.dropAllReferences();
383 // Delete all basic blocks. They are now unused, except possibly by
384 // blockaddresses, but BasicBlock's destructor takes care of those.
385 while (!BasicBlocks.empty())
386 BasicBlocks.begin()->eraseFromParent();
388 // Drop uses of any optional data (real or placeholder).
389 if (getNumOperands()) {
390 User::dropAllReferences();
391 setNumHungOffUseOperands(0);
392 setValueSubclassData(getSubclassDataFromValue() & ~0xe);
395 // Metadata is stored in a side-table.
399 void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) {
400 AttributeList PAL = getAttributes();
401 PAL = PAL.addAttribute(getContext(), i, Kind);
405 void Function::addAttribute(unsigned i, Attribute Attr) {
406 AttributeList PAL = getAttributes();
407 PAL = PAL.addAttribute(getContext(), i, Attr);
411 void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) {
412 AttributeList PAL = getAttributes();
413 PAL = PAL.addAttributes(getContext(), i, Attrs);
417 void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
418 AttributeList PAL = getAttributes();
419 PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
423 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
424 AttributeList PAL = getAttributes();
425 PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
429 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
430 AttributeList PAL = getAttributes();
431 PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs);
435 void Function::removeAttribute(unsigned i, Attribute::AttrKind Kind) {
436 AttributeList PAL = getAttributes();
437 PAL = PAL.removeAttribute(getContext(), i, Kind);
441 void Function::removeAttribute(unsigned i, StringRef Kind) {
442 AttributeList PAL = getAttributes();
443 PAL = PAL.removeAttribute(getContext(), i, Kind);
447 void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) {
448 AttributeList PAL = getAttributes();
449 PAL = PAL.removeAttributes(getContext(), i, Attrs);
453 void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
454 AttributeList PAL = getAttributes();
455 PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
459 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
460 AttributeList PAL = getAttributes();
461 PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
465 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
466 AttributeList PAL = getAttributes();
467 PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
471 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
472 AttributeList PAL = getAttributes();
473 PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
477 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
478 AttributeList PAL = getAttributes();
479 PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
483 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
484 AttributeList PAL = getAttributes();
485 PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
489 void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo,
491 AttributeList PAL = getAttributes();
492 PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes);
496 const std::string &Function::getGC() const {
497 assert(hasGC() && "Function has no collector");
498 return getContext().getGC(*this);
501 void Function::setGC(std::string Str) {
502 setValueSubclassDataBit(14, !Str.empty());
503 getContext().setGC(*this, std::move(Str));
506 void Function::clearGC() {
509 getContext().deleteGC(*this);
510 setValueSubclassDataBit(14, false);
513 /// Copy all additional attributes (those not needed to create a Function) from
514 /// the Function Src to this one.
515 void Function::copyAttributesFrom(const Function *Src) {
516 GlobalObject::copyAttributesFrom(Src);
517 setCallingConv(Src->getCallingConv());
518 setAttributes(Src->getAttributes());
523 if (Src->hasPersonalityFn())
524 setPersonalityFn(Src->getPersonalityFn());
525 if (Src->hasPrefixData())
526 setPrefixData(Src->getPrefixData());
527 if (Src->hasPrologueData())
528 setPrologueData(Src->getPrologueData());
531 /// Table of string intrinsic names indexed by enum value.
532 static const char * const IntrinsicNameTable[] = {
534 #define GET_INTRINSIC_NAME_TABLE
535 #include "llvm/IR/IntrinsicImpl.inc"
536 #undef GET_INTRINSIC_NAME_TABLE
539 /// Table of per-target intrinsic name tables.
540 #define GET_INTRINSIC_TARGET_DATA
541 #include "llvm/IR/IntrinsicImpl.inc"
542 #undef GET_INTRINSIC_TARGET_DATA
544 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
545 /// target as \c Name, or the generic table if \c Name is not target specific.
547 /// Returns the relevant slice of \c IntrinsicNameTable
548 static ArrayRef<const char *> findTargetSubtable(StringRef Name) {
549 assert(Name.startswith("llvm."));
551 ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
552 // Drop "llvm." and take the first dotted component. That will be the target
553 // if this is target specific.
554 StringRef Target = Name.drop_front(5).split('.').first;
555 auto It = partition_point(
556 Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
557 // We've either found the target or just fall back to the generic set, which
559 const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
560 return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
563 /// This does the actual lookup of an intrinsic ID which
564 /// matches the given function name.
565 Intrinsic::ID Function::lookupIntrinsicID(StringRef Name) {
566 ArrayRef<const char *> NameTable = findTargetSubtable(Name);
567 int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
569 return Intrinsic::not_intrinsic;
571 // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
572 // an index into a sub-table.
573 int Adjust = NameTable.data() - IntrinsicNameTable;
574 Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
576 // If the intrinsic is not overloaded, require an exact match. If it is
577 // overloaded, require either exact or prefix match.
578 const auto MatchSize = strlen(NameTable[Idx]);
579 assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
580 bool IsExactMatch = Name.size() == MatchSize;
581 return IsExactMatch || Intrinsic::isOverloaded(ID) ? ID
582 : Intrinsic::not_intrinsic;
585 void Function::recalculateIntrinsicID() {
586 StringRef Name = getName();
587 if (!Name.startswith("llvm.")) {
588 HasLLVMReservedName = false;
589 IntID = Intrinsic::not_intrinsic;
592 HasLLVMReservedName = true;
593 IntID = lookupIntrinsicID(Name);
596 /// Returns a stable mangling for the type specified for use in the name
597 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
598 /// of named types is simply their name. Manglings for unnamed types consist
599 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
600 /// combined with the mangling of their component types. A vararg function
601 /// type will have a suffix of 'vararg'. Since function types can contain
602 /// other function types, we close a function type mangling with suffix 'f'
603 /// which can't be confused with it's prefix. This ensures we don't have
604 /// collisions between two unrelated function types. Otherwise, you might
605 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
607 static std::string getMangledTypeStr(Type* Ty) {
609 if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
610 Result += "p" + utostr(PTyp->getAddressSpace()) +
611 getMangledTypeStr(PTyp->getElementType());
612 } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
613 Result += "a" + utostr(ATyp->getNumElements()) +
614 getMangledTypeStr(ATyp->getElementType());
615 } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
616 if (!STyp->isLiteral()) {
618 Result += STyp->getName();
621 for (auto Elem : STyp->elements())
622 Result += getMangledTypeStr(Elem);
624 // Ensure nested structs are distinguishable.
626 } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
627 Result += "f_" + getMangledTypeStr(FT->getReturnType());
628 for (size_t i = 0; i < FT->getNumParams(); i++)
629 Result += getMangledTypeStr(FT->getParamType(i));
632 // Ensure nested function types are distinguishable.
634 } else if (VectorType* VTy = dyn_cast<VectorType>(Ty)) {
635 if (VTy->isScalable())
637 Result += "v" + utostr(VTy->getVectorNumElements()) +
638 getMangledTypeStr(VTy->getVectorElementType());
640 switch (Ty->getTypeID()) {
641 default: llvm_unreachable("Unhandled type");
642 case Type::VoidTyID: Result += "isVoid"; break;
643 case Type::MetadataTyID: Result += "Metadata"; break;
644 case Type::HalfTyID: Result += "f16"; break;
645 case Type::FloatTyID: Result += "f32"; break;
646 case Type::DoubleTyID: Result += "f64"; break;
647 case Type::X86_FP80TyID: Result += "f80"; break;
648 case Type::FP128TyID: Result += "f128"; break;
649 case Type::PPC_FP128TyID: Result += "ppcf128"; break;
650 case Type::X86_MMXTyID: Result += "x86mmx"; break;
651 case Type::IntegerTyID:
652 Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
659 StringRef Intrinsic::getName(ID id) {
660 assert(id < num_intrinsics && "Invalid intrinsic ID!");
661 assert(!Intrinsic::isOverloaded(id) &&
662 "This version of getName does not support overloading");
663 return IntrinsicNameTable[id];
666 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
667 assert(id < num_intrinsics && "Invalid intrinsic ID!");
668 std::string Result(IntrinsicNameTable[id]);
669 for (Type *Ty : Tys) {
670 Result += "." + getMangledTypeStr(Ty);
675 /// IIT_Info - These are enumerators that describe the entries returned by the
676 /// getIntrinsicInfoTableEntries function.
678 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
680 // Common values should be encoded with 0-15.
698 // Values from 16+ are only encodable with the inefficient encoding.
703 IIT_EMPTYSTRUCT = 20,
713 IIT_HALF_VEC_ARG = 30,
714 IIT_SAME_VEC_WIDTH_ARG = 31,
717 IIT_VEC_OF_ANYPTRS_TO_ELT = 34,
725 IIT_VEC_ELEMENT = 42,
726 IIT_SCALABLE_VEC = 43,
727 IIT_SUBDIVIDE2_ARG = 44,
728 IIT_SUBDIVIDE4_ARG = 45,
729 IIT_VEC_OF_BITCASTS_TO_INT = 46
732 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
733 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
734 using namespace Intrinsic;
736 IIT_Info Info = IIT_Info(Infos[NextElt++]);
737 unsigned StructElts = 2;
741 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
744 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
747 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
750 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
753 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
756 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
759 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
762 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
765 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
768 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
771 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
774 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
777 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
780 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
783 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
786 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
787 DecodeIITType(NextElt, Infos, OutputTable);
790 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
791 DecodeIITType(NextElt, Infos, OutputTable);
794 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
795 DecodeIITType(NextElt, Infos, OutputTable);
798 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
799 DecodeIITType(NextElt, Infos, OutputTable);
802 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
803 DecodeIITType(NextElt, Infos, OutputTable);
806 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
807 DecodeIITType(NextElt, Infos, OutputTable);
810 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64));
811 DecodeIITType(NextElt, Infos, OutputTable);
814 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512));
815 DecodeIITType(NextElt, Infos, OutputTable);
818 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024));
819 DecodeIITType(NextElt, Infos, OutputTable);
822 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
823 DecodeIITType(NextElt, Infos, OutputTable);
825 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
826 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
828 DecodeIITType(NextElt, Infos, OutputTable);
832 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
833 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
836 case IIT_EXTEND_ARG: {
837 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
838 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
842 case IIT_TRUNC_ARG: {
843 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
844 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
848 case IIT_HALF_VEC_ARG: {
849 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
850 OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
854 case IIT_SAME_VEC_WIDTH_ARG: {
855 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
856 OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
860 case IIT_PTR_TO_ARG: {
861 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
862 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
866 case IIT_PTR_TO_ELT: {
867 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
868 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
871 case IIT_VEC_OF_ANYPTRS_TO_ELT: {
872 unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
873 unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
874 OutputTable.push_back(
875 IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));
878 case IIT_EMPTYSTRUCT:
879 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
881 case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
882 case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
883 case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
884 case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
885 case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
886 case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
888 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
890 for (unsigned i = 0; i != StructElts; ++i)
891 DecodeIITType(NextElt, Infos, OutputTable);
894 case IIT_SUBDIVIDE2_ARG: {
895 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
896 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide2Argument,
900 case IIT_SUBDIVIDE4_ARG: {
901 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
902 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide4Argument,
906 case IIT_VEC_ELEMENT: {
907 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
908 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecElementArgument,
912 case IIT_SCALABLE_VEC: {
913 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ScalableVecArgument,
915 DecodeIITType(NextElt, Infos, OutputTable);
918 case IIT_VEC_OF_BITCASTS_TO_INT: {
919 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
920 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfBitcastsToInt,
925 llvm_unreachable("unhandled");
928 #define GET_INTRINSIC_GENERATOR_GLOBAL
929 #include "llvm/IR/IntrinsicImpl.inc"
930 #undef GET_INTRINSIC_GENERATOR_GLOBAL
932 void Intrinsic::getIntrinsicInfoTableEntries(ID id,
933 SmallVectorImpl<IITDescriptor> &T){
934 // Check to see if the intrinsic's type was expressible by the table.
935 unsigned TableVal = IIT_Table[id-1];
937 // Decode the TableVal into an array of IITValues.
938 SmallVector<unsigned char, 8> IITValues;
939 ArrayRef<unsigned char> IITEntries;
940 unsigned NextElt = 0;
941 if ((TableVal >> 31) != 0) {
942 // This is an offset into the IIT_LongEncodingTable.
943 IITEntries = IIT_LongEncodingTable;
945 // Strip sentinel bit.
946 NextElt = (TableVal << 1) >> 1;
948 // Decode the TableVal into an array of IITValues. If the entry was encoded
949 // into a single word in the table itself, decode it now.
951 IITValues.push_back(TableVal & 0xF);
955 IITEntries = IITValues;
959 // Okay, decode the table into the output vector of IITDescriptors.
960 DecodeIITType(NextElt, IITEntries, T);
961 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
962 DecodeIITType(NextElt, IITEntries, T);
965 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
966 ArrayRef<Type*> Tys, LLVMContext &Context) {
967 using namespace Intrinsic;
969 IITDescriptor D = Infos.front();
970 Infos = Infos.slice(1);
973 case IITDescriptor::Void: return Type::getVoidTy(Context);
974 case IITDescriptor::VarArg: return Type::getVoidTy(Context);
975 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
976 case IITDescriptor::Token: return Type::getTokenTy(Context);
977 case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
978 case IITDescriptor::Half: return Type::getHalfTy(Context);
979 case IITDescriptor::Float: return Type::getFloatTy(Context);
980 case IITDescriptor::Double: return Type::getDoubleTy(Context);
981 case IITDescriptor::Quad: return Type::getFP128Ty(Context);
983 case IITDescriptor::Integer:
984 return IntegerType::get(Context, D.Integer_Width);
985 case IITDescriptor::Vector:
986 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
987 case IITDescriptor::Pointer:
988 return PointerType::get(DecodeFixedType(Infos, Tys, Context),
989 D.Pointer_AddressSpace);
990 case IITDescriptor::Struct: {
991 SmallVector<Type *, 8> Elts;
992 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
993 Elts.push_back(DecodeFixedType(Infos, Tys, Context));
994 return StructType::get(Context, Elts);
996 case IITDescriptor::Argument:
997 return Tys[D.getArgumentNumber()];
998 case IITDescriptor::ExtendArgument: {
999 Type *Ty = Tys[D.getArgumentNumber()];
1000 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1001 return VectorType::getExtendedElementVectorType(VTy);
1003 return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
1005 case IITDescriptor::TruncArgument: {
1006 Type *Ty = Tys[D.getArgumentNumber()];
1007 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1008 return VectorType::getTruncatedElementVectorType(VTy);
1010 IntegerType *ITy = cast<IntegerType>(Ty);
1011 assert(ITy->getBitWidth() % 2 == 0);
1012 return IntegerType::get(Context, ITy->getBitWidth() / 2);
1014 case IITDescriptor::Subdivide2Argument:
1015 case IITDescriptor::Subdivide4Argument: {
1016 Type *Ty = Tys[D.getArgumentNumber()];
1017 VectorType *VTy = dyn_cast<VectorType>(Ty);
1018 assert(VTy && "Expected an argument of Vector Type");
1019 int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1020 return VectorType::getSubdividedVectorType(VTy, SubDivs);
1022 case IITDescriptor::HalfVecArgument:
1023 return VectorType::getHalfElementsVectorType(cast<VectorType>(
1024 Tys[D.getArgumentNumber()]));
1025 case IITDescriptor::SameVecWidthArgument: {
1026 Type *EltTy = DecodeFixedType(Infos, Tys, Context);
1027 Type *Ty = Tys[D.getArgumentNumber()];
1028 if (auto *VTy = dyn_cast<VectorType>(Ty))
1029 return VectorType::get(EltTy, VTy->getElementCount());
1032 case IITDescriptor::PtrToArgument: {
1033 Type *Ty = Tys[D.getArgumentNumber()];
1034 return PointerType::getUnqual(Ty);
1036 case IITDescriptor::PtrToElt: {
1037 Type *Ty = Tys[D.getArgumentNumber()];
1038 VectorType *VTy = dyn_cast<VectorType>(Ty);
1040 llvm_unreachable("Expected an argument of Vector Type");
1041 Type *EltTy = VTy->getVectorElementType();
1042 return PointerType::getUnqual(EltTy);
1044 case IITDescriptor::VecElementArgument: {
1045 Type *Ty = Tys[D.getArgumentNumber()];
1046 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1047 return VTy->getElementType();
1048 llvm_unreachable("Expected an argument of Vector Type");
1050 case IITDescriptor::VecOfBitcastsToInt: {
1051 Type *Ty = Tys[D.getArgumentNumber()];
1052 VectorType *VTy = dyn_cast<VectorType>(Ty);
1053 assert(VTy && "Expected an argument of Vector Type");
1054 return VectorType::getInteger(VTy);
1056 case IITDescriptor::VecOfAnyPtrsToElt:
1057 // Return the overloaded type (which determines the pointers address space)
1058 return Tys[D.getOverloadArgNumber()];
1059 case IITDescriptor::ScalableVecArgument: {
1060 Type *Ty = DecodeFixedType(Infos, Tys, Context);
1061 return VectorType::get(Ty->getVectorElementType(),
1062 { Ty->getVectorNumElements(), true });
1065 llvm_unreachable("unhandled");
1068 FunctionType *Intrinsic::getType(LLVMContext &Context,
1069 ID id, ArrayRef<Type*> Tys) {
1070 SmallVector<IITDescriptor, 8> Table;
1071 getIntrinsicInfoTableEntries(id, Table);
1073 ArrayRef<IITDescriptor> TableRef = Table;
1074 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
1076 SmallVector<Type*, 8> ArgTys;
1077 while (!TableRef.empty())
1078 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
1080 // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
1081 // If we see void type as the type of the last argument, it is vararg intrinsic
1082 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
1084 return FunctionType::get(ResultTy, ArgTys, true);
1086 return FunctionType::get(ResultTy, ArgTys, false);
1089 bool Intrinsic::isOverloaded(ID id) {
1090 #define GET_INTRINSIC_OVERLOAD_TABLE
1091 #include "llvm/IR/IntrinsicImpl.inc"
1092 #undef GET_INTRINSIC_OVERLOAD_TABLE
1095 bool Intrinsic::isLeaf(ID id) {
1100 case Intrinsic::experimental_gc_statepoint:
1101 case Intrinsic::experimental_patchpoint_void:
1102 case Intrinsic::experimental_patchpoint_i64:
1107 /// This defines the "Intrinsic::getAttributes(ID id)" method.
1108 #define GET_INTRINSIC_ATTRIBUTES
1109 #include "llvm/IR/IntrinsicImpl.inc"
1110 #undef GET_INTRINSIC_ATTRIBUTES
1112 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
1113 // There can never be multiple globals with the same name of different types,
1114 // because intrinsics must be a specific type.
1115 return cast<Function>(
1116 M->getOrInsertFunction(getName(id, Tys),
1117 getType(M->getContext(), id, Tys))
1121 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1122 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1123 #include "llvm/IR/IntrinsicImpl.inc"
1124 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1126 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1127 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1128 #include "llvm/IR/IntrinsicImpl.inc"
1129 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1131 using DeferredIntrinsicMatchPair =
1132 std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;
1134 static bool matchIntrinsicType(
1135 Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
1136 SmallVectorImpl<Type *> &ArgTys,
1137 SmallVectorImpl<DeferredIntrinsicMatchPair> &DeferredChecks,
1138 bool IsDeferredCheck) {
1139 using namespace Intrinsic;
1141 // If we ran out of descriptors, there are too many arguments.
1142 if (Infos.empty()) return true;
1144 // Do this before slicing off the 'front' part
1145 auto InfosRef = Infos;
1146 auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {
1147 DeferredChecks.emplace_back(T, InfosRef);
1151 IITDescriptor D = Infos.front();
1152 Infos = Infos.slice(1);
1155 case IITDescriptor::Void: return !Ty->isVoidTy();
1156 case IITDescriptor::VarArg: return true;
1157 case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1158 case IITDescriptor::Token: return !Ty->isTokenTy();
1159 case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1160 case IITDescriptor::Half: return !Ty->isHalfTy();
1161 case IITDescriptor::Float: return !Ty->isFloatTy();
1162 case IITDescriptor::Double: return !Ty->isDoubleTy();
1163 case IITDescriptor::Quad: return !Ty->isFP128Ty();
1164 case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1165 case IITDescriptor::Vector: {
1166 VectorType *VT = dyn_cast<VectorType>(Ty);
1167 return !VT || VT->getNumElements() != D.Vector_Width ||
1168 matchIntrinsicType(VT->getElementType(), Infos, ArgTys,
1169 DeferredChecks, IsDeferredCheck);
1171 case IITDescriptor::Pointer: {
1172 PointerType *PT = dyn_cast<PointerType>(Ty);
1173 return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
1174 matchIntrinsicType(PT->getElementType(), Infos, ArgTys,
1175 DeferredChecks, IsDeferredCheck);
1178 case IITDescriptor::Struct: {
1179 StructType *ST = dyn_cast<StructType>(Ty);
1180 if (!ST || ST->getNumElements() != D.Struct_NumElements)
1183 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1184 if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys,
1185 DeferredChecks, IsDeferredCheck))
1190 case IITDescriptor::Argument:
1191 // If this is the second occurrence of an argument,
1192 // verify that the later instance matches the previous instance.
1193 if (D.getArgumentNumber() < ArgTys.size())
1194 return Ty != ArgTys[D.getArgumentNumber()];
1196 if (D.getArgumentNumber() > ArgTys.size() ||
1197 D.getArgumentKind() == IITDescriptor::AK_MatchType)
1198 return IsDeferredCheck || DeferCheck(Ty);
1200 assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&
1201 "Table consistency error");
1202 ArgTys.push_back(Ty);
1204 switch (D.getArgumentKind()) {
1205 case IITDescriptor::AK_Any: return false; // Success
1206 case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
1207 case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1208 case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1209 case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1212 llvm_unreachable("all argument kinds not covered");
1214 case IITDescriptor::ExtendArgument: {
1215 // If this is a forward reference, defer the check for later.
1216 if (D.getArgumentNumber() >= ArgTys.size())
1217 return IsDeferredCheck || DeferCheck(Ty);
1219 Type *NewTy = ArgTys[D.getArgumentNumber()];
1220 if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1221 NewTy = VectorType::getExtendedElementVectorType(VTy);
1222 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1223 NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1229 case IITDescriptor::TruncArgument: {
1230 // If this is a forward reference, defer the check for later.
1231 if (D.getArgumentNumber() >= ArgTys.size())
1232 return IsDeferredCheck || DeferCheck(Ty);
1234 Type *NewTy = ArgTys[D.getArgumentNumber()];
1235 if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1236 NewTy = VectorType::getTruncatedElementVectorType(VTy);
1237 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1238 NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1244 case IITDescriptor::HalfVecArgument:
1245 // If this is a forward reference, defer the check for later.
1246 if (D.getArgumentNumber() >= ArgTys.size())
1247 return IsDeferredCheck || DeferCheck(Ty);
1248 return !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1249 VectorType::getHalfElementsVectorType(
1250 cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1251 case IITDescriptor::SameVecWidthArgument: {
1252 if (D.getArgumentNumber() >= ArgTys.size()) {
1253 // Defer check and subsequent check for the vector element type.
1254 Infos = Infos.slice(1);
1255 return IsDeferredCheck || DeferCheck(Ty);
1257 auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1258 auto *ThisArgType = dyn_cast<VectorType>(Ty);
1259 // Both must be vectors of the same number of elements or neither.
1260 if ((ReferenceType != nullptr) != (ThisArgType != nullptr))
1264 if (ReferenceType->getElementCount() !=
1265 ThisArgType->getElementCount())
1267 EltTy = ThisArgType->getVectorElementType();
1269 return matchIntrinsicType(EltTy, Infos, ArgTys, DeferredChecks,
1272 case IITDescriptor::PtrToArgument: {
1273 if (D.getArgumentNumber() >= ArgTys.size())
1274 return IsDeferredCheck || DeferCheck(Ty);
1275 Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1276 PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1277 return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
1279 case IITDescriptor::PtrToElt: {
1280 if (D.getArgumentNumber() >= ArgTys.size())
1281 return IsDeferredCheck || DeferCheck(Ty);
1282 VectorType * ReferenceType =
1283 dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1284 PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1286 return (!ThisArgType || !ReferenceType ||
1287 ThisArgType->getElementType() != ReferenceType->getElementType());
1289 case IITDescriptor::VecOfAnyPtrsToElt: {
1290 unsigned RefArgNumber = D.getRefArgNumber();
1291 if (RefArgNumber >= ArgTys.size()) {
1292 if (IsDeferredCheck)
1294 // If forward referencing, already add the pointer-vector type and
1295 // defer the checks for later.
1296 ArgTys.push_back(Ty);
1297 return DeferCheck(Ty);
1300 if (!IsDeferredCheck){
1301 assert(D.getOverloadArgNumber() == ArgTys.size() &&
1302 "Table consistency error");
1303 ArgTys.push_back(Ty);
1306 // Verify the overloaded type "matches" the Ref type.
1307 // i.e. Ty is a vector with the same width as Ref.
1308 // Composed of pointers to the same element type as Ref.
1309 VectorType *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1310 VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1311 if (!ThisArgVecTy || !ReferenceType ||
1312 (ReferenceType->getVectorNumElements() !=
1313 ThisArgVecTy->getVectorNumElements()))
1315 PointerType *ThisArgEltTy =
1316 dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());
1319 return ThisArgEltTy->getElementType() !=
1320 ReferenceType->getVectorElementType();
1322 case IITDescriptor::VecElementArgument: {
1323 if (D.getArgumentNumber() >= ArgTys.size())
1324 return IsDeferredCheck ? true : DeferCheck(Ty);
1325 auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1326 return !ReferenceType || Ty != ReferenceType->getElementType();
1328 case IITDescriptor::Subdivide2Argument:
1329 case IITDescriptor::Subdivide4Argument: {
1330 // If this is a forward reference, defer the check for later.
1331 if (D.getArgumentNumber() >= ArgTys.size())
1332 return IsDeferredCheck || DeferCheck(Ty);
1334 Type *NewTy = ArgTys[D.getArgumentNumber()];
1335 if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
1336 int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1337 NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
1342 case IITDescriptor::ScalableVecArgument: {
1343 VectorType *VTy = dyn_cast<VectorType>(Ty);
1344 if (!VTy || !VTy->isScalable())
1346 return matchIntrinsicType(VTy, Infos, ArgTys, DeferredChecks,
1349 case IITDescriptor::VecOfBitcastsToInt: {
1350 if (D.getArgumentNumber() >= ArgTys.size())
1351 return IsDeferredCheck || DeferCheck(Ty);
1352 auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1353 auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1354 if (!ThisArgVecTy || !ReferenceType)
1356 return ThisArgVecTy != VectorType::getInteger(ReferenceType);
1359 llvm_unreachable("unhandled");
1362 Intrinsic::MatchIntrinsicTypesResult
1363 Intrinsic::matchIntrinsicSignature(FunctionType *FTy,
1364 ArrayRef<Intrinsic::IITDescriptor> &Infos,
1365 SmallVectorImpl<Type *> &ArgTys) {
1366 SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks;
1367 if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
1369 return MatchIntrinsicTypes_NoMatchRet;
1371 unsigned NumDeferredReturnChecks = DeferredChecks.size();
1373 for (auto Ty : FTy->params())
1374 if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
1375 return MatchIntrinsicTypes_NoMatchArg;
1377 for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
1378 DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
1379 if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
1381 return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
1382 : MatchIntrinsicTypes_NoMatchArg;
1385 return MatchIntrinsicTypes_Match;
1389 Intrinsic::matchIntrinsicVarArg(bool isVarArg,
1390 ArrayRef<Intrinsic::IITDescriptor> &Infos) {
1391 // If there are no descriptors left, then it can't be a vararg.
1395 // There should be only one descriptor remaining at this point.
1396 if (Infos.size() != 1)
1399 // Check and verify the descriptor.
1400 IITDescriptor D = Infos.front();
1401 Infos = Infos.slice(1);
1402 if (D.Kind == IITDescriptor::VarArg)
1408 Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) {
1409 Intrinsic::ID ID = F->getIntrinsicID();
1413 FunctionType *FTy = F->getFunctionType();
1414 // Accumulate an array of overloaded types for the given intrinsic
1415 SmallVector<Type *, 4> ArgTys;
1417 SmallVector<Intrinsic::IITDescriptor, 8> Table;
1418 getIntrinsicInfoTableEntries(ID, Table);
1419 ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
1421 if (Intrinsic::matchIntrinsicSignature(FTy, TableRef, ArgTys))
1423 if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef))
1427 StringRef Name = F->getName();
1428 if (Name == Intrinsic::getName(ID, ArgTys))
1431 auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1432 NewDecl->setCallingConv(F->getCallingConv());
1433 assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature");
1437 /// hasAddressTaken - returns true if there are any uses of this function
1438 /// other than direct calls or invokes to it.
1439 bool Function::hasAddressTaken(const User* *PutOffender) const {
1440 for (const Use &U : uses()) {
1441 const User *FU = U.getUser();
1442 if (isa<BlockAddress>(FU))
1444 const auto *Call = dyn_cast<CallBase>(FU);
1450 if (!Call->isCallee(&U)) {
1459 bool Function::isDefTriviallyDead() const {
1460 // Check the linkage
1461 if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1462 !hasAvailableExternallyLinkage())
1465 // Check if the function is used by anything other than a blockaddress.
1466 for (const User *U : users())
1467 if (!isa<BlockAddress>(U))
1473 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1474 /// setjmp or other function that gcc recognizes as "returning twice".
1475 bool Function::callsFunctionThatReturnsTwice() const {
1476 for (const Instruction &I : instructions(this))
1477 if (const auto *Call = dyn_cast<CallBase>(&I))
1478 if (Call->hasFnAttr(Attribute::ReturnsTwice))
1484 Constant *Function::getPersonalityFn() const {
1485 assert(hasPersonalityFn() && getNumOperands());
1486 return cast<Constant>(Op<0>());
1489 void Function::setPersonalityFn(Constant *Fn) {
1490 setHungoffOperand<0>(Fn);
1491 setValueSubclassDataBit(3, Fn != nullptr);
1494 Constant *Function::getPrefixData() const {
1495 assert(hasPrefixData() && getNumOperands());
1496 return cast<Constant>(Op<1>());
1499 void Function::setPrefixData(Constant *PrefixData) {
1500 setHungoffOperand<1>(PrefixData);
1501 setValueSubclassDataBit(1, PrefixData != nullptr);
1504 Constant *Function::getPrologueData() const {
1505 assert(hasPrologueData() && getNumOperands());
1506 return cast<Constant>(Op<2>());
1509 void Function::setPrologueData(Constant *PrologueData) {
1510 setHungoffOperand<2>(PrologueData);
1511 setValueSubclassDataBit(2, PrologueData != nullptr);
1514 void Function::allocHungoffUselist() {
1515 // If we've already allocated a uselist, stop here.
1516 if (getNumOperands())
1519 allocHungoffUses(3, /*IsPhi=*/ false);
1520 setNumHungOffUseOperands(3);
1522 // Initialize the uselist with placeholder operands to allow traversal.
1523 auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0));
1530 void Function::setHungoffOperand(Constant *C) {
1532 allocHungoffUselist();
1534 } else if (getNumOperands()) {
1536 ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)));
1540 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1541 assert(Bit < 16 && "SubclassData contains only 16 bits");
1543 setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
1545 setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
1548 void Function::setEntryCount(ProfileCount Count,
1549 const DenseSet<GlobalValue::GUID> *S) {
1550 assert(Count.hasValue());
1551 #if !defined(NDEBUG)
1552 auto PrevCount = getEntryCount();
1553 assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType());
1556 auto ImportGUIDs = getImportGUIDs();
1557 if (S == nullptr && ImportGUIDs.size())
1560 MDBuilder MDB(getContext());
1562 LLVMContext::MD_prof,
1563 MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1566 void Function::setEntryCount(uint64_t Count, Function::ProfileCountType Type,
1567 const DenseSet<GlobalValue::GUID> *Imports) {
1568 setEntryCount(ProfileCount(Count, Type), Imports);
1571 ProfileCount Function::getEntryCount(bool AllowSynthetic) const {
1572 MDNode *MD = getMetadata(LLVMContext::MD_prof);
1573 if (MD && MD->getOperand(0))
1574 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
1575 if (MDS->getString().equals("function_entry_count")) {
1576 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1577 uint64_t Count = CI->getValue().getZExtValue();
1578 // A value of -1 is used for SamplePGO when there were no samples.
1579 // Treat this the same as unknown.
1580 if (Count == (uint64_t)-1)
1581 return ProfileCount::getInvalid();
1582 return ProfileCount(Count, PCT_Real);
1583 } else if (AllowSynthetic &&
1584 MDS->getString().equals("synthetic_function_entry_count")) {
1585 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1586 uint64_t Count = CI->getValue().getZExtValue();
1587 return ProfileCount(Count, PCT_Synthetic);
1590 return ProfileCount::getInvalid();
1593 DenseSet<GlobalValue::GUID> Function::getImportGUIDs() const {
1594 DenseSet<GlobalValue::GUID> R;
1595 if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1596 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1597 if (MDS->getString().equals("function_entry_count"))
1598 for (unsigned i = 2; i < MD->getNumOperands(); i++)
1599 R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
1605 void Function::setSectionPrefix(StringRef Prefix) {
1606 MDBuilder MDB(getContext());
1607 setMetadata(LLVMContext::MD_section_prefix,
1608 MDB.createFunctionSectionPrefix(Prefix));
1611 Optional<StringRef> Function::getSectionPrefix() const {
1612 if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
1613 assert(cast<MDString>(MD->getOperand(0))
1615 .equals("function_section_prefix") &&
1616 "Metadata not match");
1617 return cast<MDString>(MD->getOperand(1))->getString();
1622 bool Function::nullPointerIsDefined() const {
1623 return getFnAttribute("null-pointer-is-valid")
1628 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
1629 if (F && F->nullPointerIsDefined())