/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/DerivedTypes.h

Bug Summary

File:	llvm/include/llvm/IR/DerivedTypes.h
Warning:	line 440, column 24 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Function.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/Function.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/Function.cpp

→

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//===----------------------------------------------------------------------===//

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/AbstractCallSite.h"
24#include "llvm/IR/Argument.h"
25#include "llvm/IR/Attributes.h"
26#include "llvm/IR/BasicBlock.h"
27#include "llvm/IR/Constant.h"
28#include "llvm/IR/Constants.h"
29#include "llvm/IR/DerivedTypes.h"
30#include "llvm/IR/GlobalValue.h"
31#include "llvm/IR/InstIterator.h"
32#include "llvm/IR/Instruction.h"
33#include "llvm/IR/Instructions.h"
34#include "llvm/IR/IntrinsicInst.h"
35#include "llvm/IR/Intrinsics.h"
36#include "llvm/IR/IntrinsicsAArch64.h"
37#include "llvm/IR/IntrinsicsAMDGPU.h"
38#include "llvm/IR/IntrinsicsARM.h"
39#include "llvm/IR/IntrinsicsBPF.h"
40#include "llvm/IR/IntrinsicsHexagon.h"
41#include "llvm/IR/IntrinsicsMips.h"
42#include "llvm/IR/IntrinsicsNVPTX.h"
43#include "llvm/IR/IntrinsicsPowerPC.h"
44#include "llvm/IR/IntrinsicsR600.h"
45#include "llvm/IR/IntrinsicsRISCV.h"
46#include "llvm/IR/IntrinsicsS390.h"
47#include "llvm/IR/IntrinsicsVE.h"
48#include "llvm/IR/IntrinsicsWebAssembly.h"
49#include "llvm/IR/IntrinsicsX86.h"
50#include "llvm/IR/IntrinsicsXCore.h"
51#include "llvm/IR/LLVMContext.h"
52#include "llvm/IR/MDBuilder.h"
53#include "llvm/IR/Metadata.h"
54#include "llvm/IR/Module.h"
55#include "llvm/IR/Operator.h"
56#include "llvm/IR/SymbolTableListTraits.h"
57#include "llvm/IR/Type.h"
58#include "llvm/IR/Use.h"
59#include "llvm/IR/User.h"
60#include "llvm/IR/Value.h"
61#include "llvm/IR/ValueSymbolTable.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/CommandLine.h"
64#include "llvm/Support/Compiler.h"
65#include "llvm/Support/ErrorHandling.h"
66#include <algorithm>
67#include <cassert>
68#include <cstddef>
69#include <cstdint>
70#include <cstring>
71#include <string>

73using namespace llvm;
74using ProfileCount = Function::ProfileCount;

76// Explicit instantiations of SymbolTableListTraits since some of the methods
77// are not in the public header file...
78template class llvm::SymbolTableListTraits<BasicBlock>;

80static 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."));

84//===----------------------------------------------------------------------===//
85// Argument Implementation
86//===----------------------------------------------------------------------===//

88Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
  : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
setName(Name);
91}

93void Argument::setParent(Function *parent) {
Parent = parent;
95}

97bool Argument::hasNonNullAttr(bool AllowUndefOrPoison) const {
if (!getType()->isPointerTy()) return false;
if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull) &&
    (AllowUndefOrPoison ||
     getParent()->hasParamAttribute(getArgNo(), Attribute::NoUndef)))
  return true;
else if (getDereferenceableBytes() > 0 &&
         !NullPointerIsDefined(getParent(),
                               getType()->getPointerAddressSpace()))
  return true;
return false;
108}

110bool Argument::hasByValAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::ByVal);
113}

115bool Argument::hasByRefAttr() const {
if (!getType()->isPointerTy())
  return false;
return hasAttribute(Attribute::ByRef);
119}

121bool Argument::hasSwiftSelfAttr() const {
return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
123}

125bool Argument::hasSwiftErrorAttr() const {
return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
127}

129bool Argument::hasInAllocaAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::InAlloca);
132}

134bool Argument::hasPreallocatedAttr() const {
if (!getType()->isPointerTy())
  return false;
return hasAttribute(Attribute::Preallocated);
138}

140bool Argument::hasPassPointeeByValueCopyAttr() const {
if (!getType()->isPointerTy()) return false;
AttributeList Attrs = getParent()->getAttributes();
return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated);
146}

148bool Argument::hasPointeeInMemoryValueAttr() const {
if (!getType()->isPointerTy())
  return false;
AttributeList Attrs = getParent()->getAttributes();
return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::StructRet) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::ByRef);
157}

159/// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
160/// parameter type.
161static Type *getMemoryParamAllocType(AttributeSet ParamAttrs, Type *ArgTy) {
// FIXME: All the type carrying attributes are mutually exclusive, so there
// should be a single query to get the stored type that handles any of them.
if (Type *ByValTy = ParamAttrs.getByValType())
  return ByValTy;
if (Type *ByRefTy = ParamAttrs.getByRefType())
  return ByRefTy;
if (Type *PreAllocTy = ParamAttrs.getPreallocatedType())
  return PreAllocTy;
if (Type *InAllocaTy = ParamAttrs.getInAllocaType())
  return InAllocaTy;
if (Type *SRetTy = ParamAttrs.getStructRetType())
  return SRetTy;

return nullptr;
176}

178uint64_t Argument::getPassPointeeByValueCopySize(const DataLayout &DL) const {
AttributeSet ParamAttrs =
    getParent()->getAttributes().getParamAttrs(getArgNo());
if (Type *MemTy = getMemoryParamAllocType(ParamAttrs, getType()))
  return DL.getTypeAllocSize(MemTy);
return 0;
184}

186Type *Argument::getPointeeInMemoryValueType() const {
AttributeSet ParamAttrs =
    getParent()->getAttributes().getParamAttrs(getArgNo());
return getMemoryParamAllocType(ParamAttrs, getType());
190}

192unsigned Argument::getParamAlignment() const {
assert(getType()->isPointerTy() && "Only pointers have alignments")(static_cast<void> (0));
return getParent()->getParamAlignment(getArgNo());
195}

197MaybeAlign Argument::getParamAlign() const {
assert(getType()->isPointerTy() && "Only pointers have alignments")(static_cast<void> (0));
return getParent()->getParamAlign(getArgNo());
200}

202MaybeAlign Argument::getParamStackAlign() const {
return getParent()->getParamStackAlign(getArgNo());
204}

206Type *Argument::getParamByValType() const {
assert(getType()->isPointerTy() && "Only pointers have byval types")(static_cast<void> (0));
return getParent()->getParamByValType(getArgNo());
209}

211Type *Argument::getParamStructRetType() const {
assert(getType()->isPointerTy() && "Only pointers have sret types")(static_cast<void> (0));
return getParent()->getParamStructRetType(getArgNo());
214}

216Type *Argument::getParamByRefType() const {
assert(getType()->isPointerTy() && "Only pointers have byref types")(static_cast<void> (0));
return getParent()->getParamByRefType(getArgNo());
219}

221Type *Argument::getParamInAllocaType() const {
assert(getType()->isPointerTy() && "Only pointers have inalloca types")(static_cast<void> (0));
return getParent()->getParamInAllocaType(getArgNo());
224}

226uint64_t Argument::getDereferenceableBytes() const {
assert(getType()->isPointerTy() &&(static_cast<void> (0))
       "Only pointers have dereferenceable bytes")(static_cast<void> (0));
return getParent()->getParamDereferenceableBytes(getArgNo());
230}

232uint64_t Argument::getDereferenceableOrNullBytes() const {
assert(getType()->isPointerTy() &&(static_cast<void> (0))
       "Only pointers have dereferenceable bytes")(static_cast<void> (0));
return getParent()->getParamDereferenceableOrNullBytes(getArgNo());
236}

238bool Argument::hasNestAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::Nest);
241}

243bool Argument::hasNoAliasAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::NoAlias);
246}

248bool Argument::hasNoCaptureAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::NoCapture);
251}

253bool Argument::hasNoFreeAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::NoFree);
256}

258bool Argument::hasStructRetAttr() const {
if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::StructRet);
261}

263bool Argument::hasInRegAttr() const {
return hasAttribute(Attribute::InReg);
265}

267bool Argument::hasReturnedAttr() const {
return hasAttribute(Attribute::Returned);
269}

271bool Argument::hasZExtAttr() const {
return hasAttribute(Attribute::ZExt);
273}

275bool Argument::hasSExtAttr() const {
return hasAttribute(Attribute::SExt);
277}

279bool Argument::onlyReadsMemory() const {
AttributeList Attrs = getParent()->getAttributes();
return Attrs.hasParamAttr(getArgNo(), Attribute::ReadOnly) ||
       Attrs.hasParamAttr(getArgNo(), Attribute::ReadNone);
283}

285void Argument::addAttrs(AttrBuilder &B) {
AttributeList AL = getParent()->getAttributes();
AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
getParent()->setAttributes(AL);
289}

291void Argument::addAttr(Attribute::AttrKind Kind) {
getParent()->addParamAttr(getArgNo(), Kind);
293}

295void Argument::addAttr(Attribute Attr) {
getParent()->addParamAttr(getArgNo(), Attr);
297}

299void Argument::removeAttr(Attribute::AttrKind Kind) {
getParent()->removeParamAttr(getArgNo(), Kind);
301}

303void Argument::removeAttrs(const AttrBuilder &B) {
AttributeList AL = getParent()->getAttributes();
AL = AL.removeParamAttributes(Parent->getContext(), getArgNo(), B);
getParent()->setAttributes(AL);
307}

309bool Argument::hasAttribute(Attribute::AttrKind Kind) const {
return getParent()->hasParamAttribute(getArgNo(), Kind);
311}

313Attribute Argument::getAttribute(Attribute::AttrKind Kind) const {
return getParent()->getParamAttribute(getArgNo(), Kind);
315}

317//===----------------------------------------------------------------------===//
318// Helper Methods in Function
319//===----------------------------------------------------------------------===//

321LLVMContext &Function::getContext() const {
return getType()->getContext();
323}

325unsigned Function::getInstructionCount() const {
unsigned NumInstrs = 0;
for (const BasicBlock &BB : BasicBlocks)
  NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
                             BB.instructionsWithoutDebug().end());
return NumInstrs;
331}

333Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
                         const Twine &N, Module &M) {
return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
336}

338Function *Function::createWithDefaultAttr(FunctionType *Ty,
                                        LinkageTypes Linkage,
                                        unsigned AddrSpace, const Twine &N,
                                        Module *M) {
auto *F = new Function(Ty, Linkage, AddrSpace, N, M);
AttrBuilder B;
if (M->getUwtable())
  B.addAttribute(Attribute::UWTable);
switch (M->getFramePointer()) {
case FramePointerKind::None:
  // 0 ("none") is the default.
  break;
case FramePointerKind::NonLeaf:
  B.addAttribute("frame-pointer", "non-leaf");
  break;
case FramePointerKind::All:
  B.addAttribute("frame-pointer", "all");
  break;
}
F->addFnAttrs(B);
return F;
359}

361void Function::removeFromParent() {
getParent()->getFunctionList().remove(getIterator());
363}

365void Function::eraseFromParent() {
getParent()->getFunctionList().erase(getIterator());
367}

369//===----------------------------------------------------------------------===//
370// Function Implementation
371//===----------------------------------------------------------------------===//

373static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
// If AS == -1 and we are passed a valid module pointer we place the function
// in the program address space. Otherwise we default to AS0.
if (AddrSpace == static_cast<unsigned>(-1))
  return M ? M->getDataLayout().getProgramAddressSpace() : 0;
return AddrSpace;
379}

381Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
                 const Twine &name, Module *ParentModule)
  : GlobalObject(Ty, Value::FunctionVal,
                 OperandTraits<Function>::op_begin(this), 0, Linkage, name,
                 computeAddrSpace(AddrSpace, ParentModule)),
    NumArgs(Ty->getNumParams()) {
assert(FunctionType::isValidReturnType(getReturnType()) &&(static_cast<void> (0))
       "invalid return type")(static_cast<void> (0));
setGlobalObjectSubClassData(0);

// We only need a symbol table for a function if the context keeps value names
if (!getContext().shouldDiscardValueNames())
  SymTab = std::make_unique<ValueSymbolTable>(NonGlobalValueMaxNameSize);

// If the function has arguments, mark them as lazily built.
if (Ty->getNumParams())
  setValueSubclassData(1);   // Set the "has lazy arguments" bit.

if (ParentModule)
  ParentModule->getFunctionList().push_back(this);

HasLLVMReservedName = getName().startswith("llvm.");
// Ensure intrinsics have the right parameter attributes.
// Note, the IntID field will have been set in Value::setName if this function
// name is a valid intrinsic ID.
if (IntID)
  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
408}

410Function::~Function() {
dropAllReferences();    // After this it is safe to delete instructions.

// Delete all of the method arguments and unlink from symbol table...
if (Arguments)
  clearArguments();

// Remove the function from the on-the-side GC table.
clearGC();
419}

421void Function::BuildLazyArguments() const {
// Create the arguments vector, all arguments start out unnamed.
auto *FT = getFunctionType();
if (NumArgs > 0) {
  Arguments = std::allocator<Argument>().allocate(NumArgs);
  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
    Type *ArgTy = FT->getParamType(i);
    assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!")(static_cast<void> (0));
    new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
  }
}

// Clear the lazy arguments bit.
unsigned SDC = getSubclassDataFromValue();
SDC &= ~(1 << 0);
const_cast<Function*>(this)->setValueSubclassData(SDC);
assert(!hasLazyArguments())(static_cast<void> (0));
438}

440static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) {
return MutableArrayRef<Argument>(Args, Count);
442}

444bool Function::isConstrainedFPIntrinsic() const {
switch (getIntrinsicID()) {
446#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
case Intrinsic::INTRINSIC:
448#include "llvm/IR/ConstrainedOps.def"
  return true;
450#undef INSTRUCTION
default:
  return false;
}
454}

456void Function::clearArguments() {
for (Argument &A : makeArgArray(Arguments, NumArgs)) {
  A.setName("");
  A.~Argument();
}
std::allocator<Argument>().deallocate(Arguments, NumArgs);
Arguments = nullptr;
463}

465void Function::stealArgumentListFrom(Function &Src) {
assert(isDeclaration() && "Expected no references to current arguments")(static_cast<void> (0));

// Drop the current arguments, if any, and set the lazy argument bit.
if (!hasLazyArguments()) {
  assert(llvm::all_of(makeArgArray(Arguments, NumArgs),(static_cast<void> (0))
                      [](const Argument &A) { return A.use_empty(); }) &&(static_cast<void> (0))
         "Expected arguments to be unused in declaration")(static_cast<void> (0));
  clearArguments();
  setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
}

// Nothing to steal if Src has lazy arguments.
if (Src.hasLazyArguments())
  return;

// Steal arguments from Src, and fix the lazy argument bits.
assert(arg_size() == Src.arg_size())(static_cast<void> (0));
Arguments = Src.Arguments;
Src.Arguments = nullptr;
for (Argument &A : makeArgArray(Arguments, NumArgs)) {
  // FIXME: This does the work of transferNodesFromList inefficiently.
  SmallString<128> Name;
  if (A.hasName())
    Name = A.getName();
  if (!Name.empty())
    A.setName("");
  A.setParent(this);
  if (!Name.empty())
    A.setName(Name);
}

setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
assert(!hasLazyArguments())(static_cast<void> (0));
Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
500}

502// dropAllReferences() - This function causes all the subinstructions to "let
503// go" of all references that they are maintaining.  This allows one to
504// 'delete' a whole class at a time, even though there may be circular
505// references... first all references are dropped, and all use counts go to
506// zero.  Then everything is deleted for real.  Note that no operations are
507// valid on an object that has "dropped all references", except operator
508// delete.
509//
510void Function::dropAllReferences() {
setIsMaterializable(false);

for (BasicBlock &BB : *this)
  BB.dropAllReferences();

// Delete all basic blocks. They are now unused, except possibly by
// blockaddresses, but BasicBlock's destructor takes care of those.
while (!BasicBlocks.empty())
  BasicBlocks.begin()->eraseFromParent();

// Drop uses of any optional data (real or placeholder).
if (getNumOperands()) {
  User::dropAllReferences();
  setNumHungOffUseOperands(0);
  setValueSubclassData(getSubclassDataFromValue() & ~0xe);
}

// Metadata is stored in a side-table.
clearMetadata();
530}

532void Function::addAttributeAtIndex(unsigned i, Attribute Attr) {
AttributeSets = AttributeSets.addAttributeAtIndex(getContext(), i, Attr);
534}

536void Function::addFnAttr(Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind);
538}

540void Function::addFnAttr(StringRef Kind, StringRef Val) {
AttributeSets = AttributeSets.addFnAttribute(getContext(), Kind, Val);
542}

544void Function::addFnAttr(Attribute Attr) {
AttributeSets = AttributeSets.addFnAttribute(getContext(), Attr);
546}

548void Function::addFnAttrs(const AttrBuilder &Attrs) {
AttributeSets = AttributeSets.addFnAttributes(getContext(), Attrs);
550}

552void Function::addRetAttr(Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.addRetAttribute(getContext(), Kind);
554}

556void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Kind);
558}

560void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
AttributeSets = AttributeSets.addParamAttribute(getContext(), ArgNo, Attr);
562}

564void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
AttributeSets = AttributeSets.addParamAttributes(getContext(), ArgNo, Attrs);
566}

568void Function::removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
570}

572void Function::removeAttributeAtIndex(unsigned i, StringRef Kind) {
AttributeSets = AttributeSets.removeAttributeAtIndex(getContext(), i, Kind);
574}

576void Function::removeFnAttr(Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
578}

580void Function::removeFnAttr(StringRef Kind) {
AttributeSets = AttributeSets.removeFnAttribute(getContext(), Kind);
582}

584void Function::removeFnAttrs(const AttrBuilder &Attrs) {
AttributeSets = AttributeSets.removeFnAttributes(getContext(), Attrs);
586}

588void Function::removeRetAttr(Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
590}

592void Function::removeRetAttr(StringRef Kind) {
AttributeSets = AttributeSets.removeRetAttribute(getContext(), Kind);
594}

596void Function::removeRetAttrs(const AttrBuilder &Attrs) {
AttributeSets = AttributeSets.removeRetAttributes(getContext(), Attrs);
598}

600void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
602}

604void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
AttributeSets = AttributeSets.removeParamAttribute(getContext(), ArgNo, Kind);
606}

608void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
AttributeSets =
    AttributeSets.removeParamAttributes(getContext(), ArgNo, Attrs);
611}

613void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
AttributeSets =
    AttributeSets.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
616}

618bool Function::hasFnAttribute(Attribute::AttrKind Kind) const {
return AttributeSets.hasFnAttr(Kind);
620}

622bool Function::hasFnAttribute(StringRef Kind) const {
return AttributeSets.hasFnAttr(Kind);
624}

626bool Function::hasRetAttribute(Attribute::AttrKind Kind) const {
return AttributeSets.hasRetAttr(Kind);
628}

630bool Function::hasParamAttribute(unsigned ArgNo,
                               Attribute::AttrKind Kind) const {
return AttributeSets.hasParamAttr(ArgNo, Kind);
633}

635Attribute Function::getAttributeAtIndex(unsigned i,
                                      Attribute::AttrKind Kind) const {
return AttributeSets.getAttributeAtIndex(i, Kind);
638}

640Attribute Function::getAttributeAtIndex(unsigned i, StringRef Kind) const {
return AttributeSets.getAttributeAtIndex(i, Kind);
642}

644Attribute Function::getFnAttribute(Attribute::AttrKind Kind) const {
return AttributeSets.getFnAttr(Kind);
646}

648Attribute Function::getFnAttribute(StringRef Kind) const {
return AttributeSets.getFnAttr(Kind);
650}

652/// gets the specified attribute from the list of attributes.
653Attribute Function::getParamAttribute(unsigned ArgNo,
                                    Attribute::AttrKind Kind) const {
return AttributeSets.getParamAttr(ArgNo, Kind);
656}

658void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo,
                                               uint64_t Bytes) {
AttributeSets = AttributeSets.addDereferenceableOrNullParamAttr(getContext(),
                                                                ArgNo, Bytes);
662}

664DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const {
if (&FPType == &APFloat::IEEEsingle()) {
  Attribute Attr = getFnAttribute("denormal-fp-math-f32");
  StringRef Val = Attr.getValueAsString();
  if (!Val.empty())
    return parseDenormalFPAttribute(Val);

  // If the f32 variant of the attribute isn't specified, try to use the
  // generic one.
}

Attribute Attr = getFnAttribute("denormal-fp-math");
return parseDenormalFPAttribute(Attr.getValueAsString());
677}

679const std::string &Function::getGC() const {
assert(hasGC() && "Function has no collector")(static_cast<void> (0));
return getContext().getGC(*this);
682}

684void Function::setGC(std::string Str) {
setValueSubclassDataBit(14, !Str.empty());
getContext().setGC(*this, std::move(Str));
687}

689void Function::clearGC() {
if (!hasGC())
  return;
getContext().deleteGC(*this);
setValueSubclassDataBit(14, false);
694}

696bool Function::hasStackProtectorFnAttr() const {
return hasFnAttribute(Attribute::StackProtect) ||
       hasFnAttribute(Attribute::StackProtectStrong) ||
       hasFnAttribute(Attribute::StackProtectReq);
700}

702/// Copy all additional attributes (those not needed to create a Function) from
703/// the Function Src to this one.
704void Function::copyAttributesFrom(const Function *Src) {
GlobalObject::copyAttributesFrom(Src);
setCallingConv(Src->getCallingConv());
setAttributes(Src->getAttributes());
if (Src->hasGC())
  setGC(Src->getGC());
else
  clearGC();
if (Src->hasPersonalityFn())
  setPersonalityFn(Src->getPersonalityFn());
if (Src->hasPrefixData())
  setPrefixData(Src->getPrefixData());
if (Src->hasPrologueData())
  setPrologueData(Src->getPrologueData());
718}

720/// Table of string intrinsic names indexed by enum value.
721static const char * const IntrinsicNameTable[] = {
"not_intrinsic",
723#define GET_INTRINSIC_NAME_TABLE
724#include "llvm/IR/IntrinsicImpl.inc"
725#undef GET_INTRINSIC_NAME_TABLE
726};

728/// Table of per-target intrinsic name tables.
729#define GET_INTRINSIC_TARGET_DATA
730#include "llvm/IR/IntrinsicImpl.inc"
731#undef GET_INTRINSIC_TARGET_DATA

733bool Function::isTargetIntrinsic(Intrinsic::ID IID) {
return IID > TargetInfos[0].Count;
735}

737bool Function::isTargetIntrinsic() const {
return isTargetIntrinsic(IntID);
739}

741/// Find the segment of \c IntrinsicNameTable for intrinsics with the same
742/// target as \c Name, or the generic table if \c Name is not target specific.
743///
744/// Returns the relevant slice of \c IntrinsicNameTable
745static ArrayRef<const char *> findTargetSubtable(StringRef Name) {
assert(Name.startswith("llvm."))(static_cast<void> (0));

ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
// Drop "llvm." and take the first dotted component. That will be the target
// if this is target specific.
StringRef Target = Name.drop_front(5).split('.').first;
auto It = partition_point(
    Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
// We've either found the target or just fall back to the generic set, which
// is always first.
const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
758}

760/// This does the actual lookup of an intrinsic ID which
761/// matches the given function name.
762Intrinsic::ID Function::lookupIntrinsicID(StringRef Name) {
ArrayRef<const char *> NameTable = findTargetSubtable(Name);
int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
if (Idx == -1)
  return Intrinsic::not_intrinsic;

// Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
// an index into a sub-table.
int Adjust = NameTable.data() - IntrinsicNameTable;
Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);

// If the intrinsic is not overloaded, require an exact match. If it is
// overloaded, require either exact or prefix match.
const auto MatchSize = strlen(NameTable[Idx]);
assert(Name.size() >= MatchSize && "Expected either exact or prefix match")(static_cast<void> (0));
bool IsExactMatch = Name.size() == MatchSize;
return IsExactMatch || Intrinsic::isOverloaded(ID) ? ID
                                                   : Intrinsic::not_intrinsic;
780}

782void Function::recalculateIntrinsicID() {
StringRef Name = getName();
if (!Name.startswith("llvm.")) {
  HasLLVMReservedName = false;
  IntID = Intrinsic::not_intrinsic;
  return;
}
HasLLVMReservedName = true;
IntID = lookupIntrinsicID(Name);
791}

793/// Returns a stable mangling for the type specified for use in the name
794/// mangling scheme used by 'any' types in intrinsic signatures.  The mangling
795/// of named types is simply their name.  Manglings for unnamed types consist
796/// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
797/// combined with the mangling of their component types.  A vararg function
798/// type will have a suffix of 'vararg'.  Since function types can contain
799/// other function types, we close a function type mangling with suffix 'f'
800/// which can't be confused with it's prefix.  This ensures we don't have
801/// collisions between two unrelated function types. Otherwise, you might
802/// parse ffXX as f(fXX) or f(fX)X.  (X is a placeholder for any other type.)
803/// The HasUnnamedType boolean is set if an unnamed type was encountered,
804/// indicating that extra care must be taken to ensure a unique name.
805static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) {
std::string Result;
if (PointerType *PTyp = dyn_cast<PointerType>(Ty)) {
  Result += "p" + utostr(PTyp->getAddressSpace());
  // Opaque pointer doesn't have pointee type information, so we just mangle
  // address space for opaque pointer.
  if (!PTyp->isOpaque())
    Result += getMangledTypeStr(PTyp->getElementType(), HasUnnamedType);
} else if (ArrayType *ATyp = dyn_cast<ArrayType>(Ty)) {
  Result += "a" + utostr(ATyp->getNumElements()) +
            getMangledTypeStr(ATyp->getElementType(), HasUnnamedType);
} else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
  if (!STyp->isLiteral()) {
    Result += "s_";
    if (STyp->hasName())
      Result += STyp->getName();
    else
      HasUnnamedType = true;
  } else {
    Result += "sl_";
    for (auto Elem : STyp->elements())
      Result += getMangledTypeStr(Elem, HasUnnamedType);
  }
  // Ensure nested structs are distinguishable.
  Result += "s";
} else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
  Result += "f_" + getMangledTypeStr(FT->getReturnType(), HasUnnamedType);
  for (size_t i = 0; i < FT->getNumParams(); i++)
    Result += getMangledTypeStr(FT->getParamType(i), HasUnnamedType);
  if (FT->isVarArg())
    Result += "vararg";
  // Ensure nested function types are distinguishable.
  Result += "f";
} else if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
  ElementCount EC = VTy->getElementCount();
  if (EC.isScalable())
    Result += "nx";
  Result += "v" + utostr(EC.getKnownMinValue()) +
            getMangledTypeStr(VTy->getElementType(), HasUnnamedType);
} else if (Ty) {
  switch (Ty->getTypeID()) {
  default: llvm_unreachable("Unhandled type")__builtin_unreachable();
  case Type::VoidTyID:      Result += "isVoid";   break;
  case Type::MetadataTyID:  Result += "Metadata"; break;
  case Type::HalfTyID:      Result += "f16";      break;
  case Type::BFloatTyID:    Result += "bf16";     break;
  case Type::FloatTyID:     Result += "f32";      break;
  case Type::DoubleTyID:    Result += "f64";      break;
  case Type::X86_FP80TyID:  Result += "f80";      break;
  case Type::FP128TyID:     Result += "f128";     break;
  case Type::PPC_FP128TyID: Result += "ppcf128";  break;
  case Type::X86_MMXTyID:   Result += "x86mmx";   break;
  case Type::X86_AMXTyID:   Result += "x86amx";   break;
  case Type::IntegerTyID:
    Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
    break;
  }
}
return Result;
864}

866StringRef Intrinsic::getBaseName(ID id) {
assert(id < num_intrinsics && "Invalid intrinsic ID!")(static_cast<void> (0));
return IntrinsicNameTable[id];
869}

871StringRef Intrinsic::getName(ID id) {
assert(id < num_intrinsics && "Invalid intrinsic ID!")(static_cast<void> (0));
assert(!Intrinsic::isOverloaded(id) &&(static_cast<void> (0))
       "This version of getName does not support overloading")(static_cast<void> (0));
return getBaseName(id);
876}

878static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef<Type *> Tys,
                                      Module *M, FunctionType *FT,
                                      bool EarlyModuleCheck) {

assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!")(static_cast<void> (0));
assert((Tys.empty() || Intrinsic::isOverloaded(Id)) &&(static_cast<void> (0))
       "This version of getName is for overloaded intrinsics only")(static_cast<void> (0));
(void)EarlyModuleCheck;
assert((!EarlyModuleCheck || M ||(static_cast<void> (0))
        !any_of(Tys, [](Type *T) { return isa<PointerType>(T); })) &&(static_cast<void> (0))
       "Intrinsic overloading on pointer types need to provide a Module")(static_cast<void> (0));
bool HasUnnamedType = false;
std::string Result(Intrinsic::getBaseName(Id));
for (Type *Ty : Tys)
  Result += "." + getMangledTypeStr(Ty, HasUnnamedType);
if (HasUnnamedType) {
  assert(M && "unnamed types need a module")(static_cast<void> (0));
  if (!FT)
    FT = Intrinsic::getType(M->getContext(), Id, Tys);
  else
    assert((FT == Intrinsic::getType(M->getContext(), Id, Tys)) &&(static_cast<void> (0))
           "Provided FunctionType must match arguments")(static_cast<void> (0));
  return M->getUniqueIntrinsicName(Result, Id, FT);
}
return Result;
903}

905std::string Intrinsic::getName(ID Id, ArrayRef<Type *> Tys, Module *M,
                             FunctionType *FT) {
assert(M && "We need to have a Module")(static_cast<void> (0));
return getIntrinsicNameImpl(Id, Tys, M, FT, true);
909}

911std::string Intrinsic::getNameNoUnnamedTypes(ID Id, ArrayRef<Type *> Tys) {
return getIntrinsicNameImpl(Id, Tys, nullptr, nullptr, false);
913}

915/// IIT_Info - These are enumerators that describe the entries returned by the
916/// getIntrinsicInfoTableEntries function.
917///
918/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
919enum IIT_Info {
// Common values should be encoded with 0-15.
IIT_Done = 0,
IIT_I1   = 1,
IIT_I8   = 2,
IIT_I16  = 3,
IIT_I32  = 4,
IIT_I64  = 5,
IIT_F16  = 6,
IIT_F32  = 7,
IIT_F64  = 8,
IIT_V2   = 9,
IIT_V4   = 10,
IIT_V8   = 11,
IIT_V16  = 12,
IIT_V32  = 13,
IIT_PTR  = 14,
IIT_ARG  = 15,

// Values from 16+ are only encodable with the inefficient encoding.
IIT_V64  = 16,
IIT_MMX  = 17,
IIT_TOKEN = 18,
IIT_METADATA = 19,
IIT_EMPTYSTRUCT = 20,
IIT_STRUCT2 = 21,
IIT_STRUCT3 = 22,
IIT_STRUCT4 = 23,
IIT_STRUCT5 = 24,
IIT_EXTEND_ARG = 25,
IIT_TRUNC_ARG = 26,
IIT_ANYPTR = 27,
IIT_V1   = 28,
IIT_VARARG = 29,
IIT_HALF_VEC_ARG = 30,
IIT_SAME_VEC_WIDTH_ARG = 31,
IIT_PTR_TO_ARG = 32,
IIT_PTR_TO_ELT = 33,
IIT_VEC_OF_ANYPTRS_TO_ELT = 34,
IIT_I128 = 35,
IIT_V512 = 36,
IIT_V1024 = 37,
IIT_STRUCT6 = 38,
IIT_STRUCT7 = 39,
IIT_STRUCT8 = 40,
IIT_F128 = 41,
IIT_VEC_ELEMENT = 42,
IIT_SCALABLE_VEC = 43,
IIT_SUBDIVIDE2_ARG = 44,
IIT_SUBDIVIDE4_ARG = 45,
IIT_VEC_OF_BITCASTS_TO_INT = 46,
IIT_V128 = 47,
IIT_BF16 = 48,
IIT_STRUCT9 = 49,
IIT_V256 = 50,
IIT_AMX  = 51
975};

977static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
                    IIT_Info LastInfo,
                    SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
using namespace Intrinsic;

bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC);

IIT_Info Info = IIT_Info(Infos[NextElt++]);
unsigned StructElts = 2;

switch (Info) {
case IIT_Done:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
  return;
case IIT_VARARG:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
  return;
case IIT_MMX:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
  return;
case IIT_AMX:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0));
  return;
case IIT_TOKEN:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
  return;
case IIT_METADATA:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
  return;
case IIT_F16:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
  return;
case IIT_BF16:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::BFloat, 0));
  return;
case IIT_F32:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
  return;
case IIT_F64:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
  return;
case IIT_F128:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
  return;
case IIT_I1:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
  return;
case IIT_I8:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
  return;
case IIT_I16:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
  return;
case IIT_I32:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
  return;
case IIT_I64:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
  return;
case IIT_I128:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
  return;
case IIT_V1:
  OutputTable.push_back(IITDescriptor::getVector(1, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V2:
  OutputTable.push_back(IITDescriptor::getVector(2, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V4:
  OutputTable.push_back(IITDescriptor::getVector(4, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V8:
  OutputTable.push_back(IITDescriptor::getVector(8, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V16:
  OutputTable.push_back(IITDescriptor::getVector(16, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V32:
  OutputTable.push_back(IITDescriptor::getVector(32, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V64:
  OutputTable.push_back(IITDescriptor::getVector(64, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V128:
  OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V256:
  OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V512:
  OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_V1024:
  OutputTable.push_back(IITDescriptor::getVector(1024, IsScalableVector));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_PTR:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
case IIT_ANYPTR: {  // [ANYPTR addrspace, subtype]
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
                                           Infos[NextElt++]));
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
}
case IIT_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
  return;
}
case IIT_EXTEND_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
                                           ArgInfo));
  return;
}
case IIT_TRUNC_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
                                           ArgInfo));
  return;
}
case IIT_HALF_VEC_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
                                           ArgInfo));
  return;
}
case IIT_SAME_VEC_WIDTH_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
                                           ArgInfo));
  return;
}
case IIT_PTR_TO_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
                                           ArgInfo));
  return;
}
case IIT_PTR_TO_ELT: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
  return;
}
case IIT_VEC_OF_ANYPTRS_TO_ELT: {
  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(
      IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));
  return;
}
case IIT_EMPTYSTRUCT:
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
  return;
case IIT_STRUCT9: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH[[gnu::fallthrough]];
case IIT_STRUCT2: {
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));

  for (unsigned i = 0; i != StructElts; ++i)
    DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
}
case IIT_SUBDIVIDE2_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide2Argument,
                                           ArgInfo));
  return;
}
case IIT_SUBDIVIDE4_ARG: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide4Argument,
                                           ArgInfo));
  return;
}
case IIT_VEC_ELEMENT: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecElementArgument,
                                           ArgInfo));
  return;
}
case IIT_SCALABLE_VEC: {
  DecodeIITType(NextElt, Infos, Info, OutputTable);
  return;
}
case IIT_VEC_OF_BITCASTS_TO_INT: {
  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfBitcastsToInt,
                                           ArgInfo));
  return;
}
}
llvm_unreachable("unhandled")__builtin_unreachable();
1187}

1189#define GET_INTRINSIC_GENERATOR_GLOBAL
1190#include "llvm/IR/IntrinsicImpl.inc"
1191#undef GET_INTRINSIC_GENERATOR_GLOBAL

1193void Intrinsic::getIntrinsicInfoTableEntries(ID id,
                                           SmallVectorImpl<IITDescriptor> &T){
// Check to see if the intrinsic's type was expressible by the table.
unsigned TableVal = IIT_Table[id-1];

// Decode the TableVal into an array of IITValues.
SmallVector<unsigned char, 8> IITValues;
ArrayRef<unsigned char> IITEntries;
unsigned NextElt = 0;
if ((TableVal >> 31) != 0) {
  // This is an offset into the IIT_LongEncodingTable.
  IITEntries = IIT_LongEncodingTable;

  // Strip sentinel bit.
  NextElt = (TableVal << 1) >> 1;
} else {
  // Decode the TableVal into an array of IITValues.  If the entry was encoded
  // into a single word in the table itself, decode it now.
  do {
    IITValues.push_back(TableVal & 0xF);
    TableVal >>= 4;
  } while (TableVal);

  IITEntries = IITValues;
  NextElt = 0;
}

// Okay, decode the table into the output vector of IITDescriptors.
DecodeIITType(NextElt, IITEntries, IIT_Done, T);
while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
  DecodeIITType(NextElt, IITEntries, IIT_Done, T);
1224}

1226static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
                           ArrayRef<Type*> Tys, LLVMContext &Context) {
using namespace Intrinsic;

IITDescriptor D = Infos.front();
Infos = Infos.slice(1);

switch (D.Kind) {
10
←
Control jumps to 'case VecOfBitcastsToInt:'  at line 1314→
case IITDescriptor::Void: return Type::getVoidTy(Context);
case IITDescriptor::VarArg: return Type::getVoidTy(Context);
case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
case IITDescriptor::AMX: return Type::getX86_AMXTy(Context);
case IITDescriptor::Token: return Type::getTokenTy(Context);
case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
case IITDescriptor::Half: return Type::getHalfTy(Context);
case IITDescriptor::BFloat: return Type::getBFloatTy(Context);
case IITDescriptor::Float: return Type::getFloatTy(Context);
case IITDescriptor::Double: return Type::getDoubleTy(Context);
case IITDescriptor::Quad: return Type::getFP128Ty(Context);

case IITDescriptor::Integer:
  return IntegerType::get(Context, D.Integer_Width);
case IITDescriptor::Vector:
  return VectorType::get(DecodeFixedType(Infos, Tys, Context),
                         D.Vector_Width);
case IITDescriptor::Pointer:
  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
                          D.Pointer_AddressSpace);
case IITDescriptor::Struct: {
  SmallVector<Type *, 8> Elts;
  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
    Elts.push_back(DecodeFixedType(Infos, Tys, Context));
  return StructType::get(Context, Elts);
}
case IITDescriptor::Argument:
  return Tys[D.getArgumentNumber()];
case IITDescriptor::ExtendArgument: {
  Type *Ty = Tys[D.getArgumentNumber()];
  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
    return VectorType::getExtendedElementVectorType(VTy);

  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
}
case IITDescriptor::TruncArgument: {
  Type *Ty = Tys[D.getArgumentNumber()];
  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
    return VectorType::getTruncatedElementVectorType(VTy);

  IntegerType *ITy = cast<IntegerType>(Ty);
  assert(ITy->getBitWidth() % 2 == 0)(static_cast<void> (0));
  return IntegerType::get(Context, ITy->getBitWidth() / 2);
}
case IITDescriptor::Subdivide2Argument:
case IITDescriptor::Subdivide4Argument: {
  Type *Ty = Tys[D.getArgumentNumber()];
  VectorType *VTy = dyn_cast<VectorType>(Ty);
  assert(VTy && "Expected an argument of Vector Type")(static_cast<void> (0));
  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
  return VectorType::getSubdividedVectorType(VTy, SubDivs);
}
case IITDescriptor::HalfVecArgument:
  return VectorType::getHalfElementsVectorType(cast<VectorType>(
                                                Tys[D.getArgumentNumber()]));
case IITDescriptor::SameVecWidthArgument: {
  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
  Type *Ty = Tys[D.getArgumentNumber()];
  if (auto *VTy = dyn_cast<VectorType>(Ty))
    return VectorType::get(EltTy, VTy->getElementCount());
  return EltTy;
}
case IITDescriptor::PtrToArgument: {
  Type *Ty = Tys[D.getArgumentNumber()];
  return PointerType::getUnqual(Ty);
}
case IITDescriptor::PtrToElt: {
  Type *Ty = Tys[D.getArgumentNumber()];
  VectorType *VTy = dyn_cast<VectorType>(Ty);
  if (!VTy)
    llvm_unreachable("Expected an argument of Vector Type")__builtin_unreachable();
  Type *EltTy = VTy->getElementType();
  return PointerType::getUnqual(EltTy);
}
case IITDescriptor::VecElementArgument: {
  Type *Ty = Tys[D.getArgumentNumber()];
  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
    return VTy->getElementType();
  llvm_unreachable("Expected an argument of Vector Type")__builtin_unreachable();
}
case IITDescriptor::VecOfBitcastsToInt: {
  Type *Ty = Tys[D.getArgumentNumber()];
  VectorType *VTy = dyn_cast<VectorType>(Ty);
11
←
Assuming 'Ty' is not a 'VectorType'→
12
←
'VTy' initialized to a null pointer value→
  assert(VTy && "Expected an argument of Vector Type")(static_cast<void> (0));
  return VectorType::getInteger(VTy);
13
←
Passing null pointer value via 1st parameter 'VTy'→
14
←
Calling 'VectorType::getInteger'→
}
case IITDescriptor::VecOfAnyPtrsToElt:
  // Return the overloaded type (which determines the pointers address space)
  return Tys[D.getOverloadArgNumber()];
}
llvm_unreachable("unhandled")__builtin_unreachable();
1325}

1327FunctionType *Intrinsic::getType(LLVMContext &Context,
                               ID id, ArrayRef<Type*> Tys) {
SmallVector<IITDescriptor, 8> Table;
getIntrinsicInfoTableEntries(id, Table);

ArrayRef<IITDescriptor> TableRef = Table;
Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
9
←
Calling 'DecodeFixedType'→

SmallVector<Type*, 8> ArgTys;
while (!TableRef.empty())
  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));

// DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
// If we see void type as the type of the last argument, it is vararg intrinsic
if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
  ArgTys.pop_back();
  return FunctionType::get(ResultTy, ArgTys, true);
}
return FunctionType::get(ResultTy, ArgTys, false);
1346}

1348bool Intrinsic::isOverloaded(ID id) {
1349#define GET_INTRINSIC_OVERLOAD_TABLE
1350#include "llvm/IR/IntrinsicImpl.inc"
1351#undef GET_INTRINSIC_OVERLOAD_TABLE
1352}

1354bool Intrinsic::isLeaf(ID id) {
switch (id) {
default:
  return true;

case Intrinsic::experimental_gc_statepoint:
case Intrinsic::experimental_patchpoint_void:
case Intrinsic::experimental_patchpoint_i64:
  return false;
}
1364}

1366/// This defines the "Intrinsic::getAttributes(ID id)" method.
1367#define GET_INTRINSIC_ATTRIBUTES
1368#include "llvm/IR/IntrinsicImpl.inc"
1369#undef GET_INTRINSIC_ATTRIBUTES

1371Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
// There can never be multiple globals with the same name of different types,
// because intrinsics must be a specific type.
auto *FT = getType(M->getContext(), id, Tys);
8
←
Calling 'getType'→
return cast<Function>(
    M->getOrInsertFunction(Tys.empty() ? getName(id)
                                       : getName(id, Tys, M, FT),
                           getType(M->getContext(), id, Tys))
        .getCallee());
1380}

1382// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1383#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1384#include "llvm/IR/IntrinsicImpl.inc"
1385#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN

1387// This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1388#define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1389#include "llvm/IR/IntrinsicImpl.inc"
1390#undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN

1392using DeferredIntrinsicMatchPair =
  std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;

1395static bool matchIntrinsicType(
  Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
  SmallVectorImpl<Type *> &ArgTys,
  SmallVectorImpl<DeferredIntrinsicMatchPair> &DeferredChecks,
  bool IsDeferredCheck) {
using namespace Intrinsic;

// If we ran out of descriptors, there are too many arguments.
if (Infos.empty()) return true;

// Do this before slicing off the 'front' part
auto InfosRef = Infos;
auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {
  DeferredChecks.emplace_back(T, InfosRef);
  return false;
};

IITDescriptor D = Infos.front();
Infos = Infos.slice(1);

switch (D.Kind) {
  case IITDescriptor::Void: return !Ty->isVoidTy();
  case IITDescriptor::VarArg: return true;
  case IITDescriptor::MMX:  return !Ty->isX86_MMXTy();
  case IITDescriptor::AMX:  return !Ty->isX86_AMXTy();
  case IITDescriptor::Token: return !Ty->isTokenTy();
  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
  case IITDescriptor::Half: return !Ty->isHalfTy();
  case IITDescriptor::BFloat: return !Ty->isBFloatTy();
  case IITDescriptor::Float: return !Ty->isFloatTy();
  case IITDescriptor::Double: return !Ty->isDoubleTy();
  case IITDescriptor::Quad: return !Ty->isFP128Ty();
  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
  case IITDescriptor::Vector: {
    VectorType *VT = dyn_cast<VectorType>(Ty);
    return !VT || VT->getElementCount() != D.Vector_Width ||
           matchIntrinsicType(VT->getElementType(), Infos, ArgTys,
                              DeferredChecks, IsDeferredCheck);
  }
  case IITDescriptor::Pointer: {
    PointerType *PT = dyn_cast<PointerType>(Ty);
    if (!PT || PT->getAddressSpace() != D.Pointer_AddressSpace)
      return true;
    if (!PT->isOpaque())
      return matchIntrinsicType(PT->getElementType(), Infos, ArgTys,
                                DeferredChecks, IsDeferredCheck);
    // If typed pointers are supported, do not allow using opaque pointer in
    // place of fixed pointer type. This would make the intrinsic signature
    // non-unique.
    if (Ty->getContext().supportsTypedPointers())
      return true;
    // Consume IIT descriptors relating to the pointer element type.
    while (Infos.front().Kind == IITDescriptor::Pointer)
      Infos = Infos.slice(1);
    Infos = Infos.slice(1);
    return false;
  }

  case IITDescriptor::Struct: {
    StructType *ST = dyn_cast<StructType>(Ty);
    if (!ST || ST->getNumElements() != D.Struct_NumElements)
      return true;

    for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
      if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys,
                             DeferredChecks, IsDeferredCheck))
        return true;
    return false;
  }

  case IITDescriptor::Argument:
    // If this is the second occurrence of an argument,
    // verify that the later instance matches the previous instance.
    if (D.getArgumentNumber() < ArgTys.size())
      return Ty != ArgTys[D.getArgumentNumber()];

    if (D.getArgumentNumber() > ArgTys.size() ||
        D.getArgumentKind() == IITDescriptor::AK_MatchType)
      return IsDeferredCheck || DeferCheck(Ty);

    assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&(static_cast<void> (0))
           "Table consistency error")(static_cast<void> (0));
    ArgTys.push_back(Ty);

    switch (D.getArgumentKind()) {
      case IITDescriptor::AK_Any:        return false; // Success
      case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
      case IITDescriptor::AK_AnyFloat:   return !Ty->isFPOrFPVectorTy();
      case IITDescriptor::AK_AnyVector:  return !isa<VectorType>(Ty);
      case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
      default:                           break;
    }
    llvm_unreachable("all argument kinds not covered")__builtin_unreachable();

  case IITDescriptor::ExtendArgument: {
    // If this is a forward reference, defer the check for later.
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);

    Type *NewTy = ArgTys[D.getArgumentNumber()];
    if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
      NewTy = VectorType::getExtendedElementVectorType(VTy);
    else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
      NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
    else
      return true;

    return Ty != NewTy;
  }
  case IITDescriptor::TruncArgument: {
    // If this is a forward reference, defer the check for later.
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);

    Type *NewTy = ArgTys[D.getArgumentNumber()];
    if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
      NewTy = VectorType::getTruncatedElementVectorType(VTy);
    else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
      NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
    else
      return true;

    return Ty != NewTy;
  }
  case IITDescriptor::HalfVecArgument:
    // If this is a forward reference, defer the check for later.
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);
    return !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
           VectorType::getHalfElementsVectorType(
                   cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
  case IITDescriptor::SameVecWidthArgument: {
    if (D.getArgumentNumber() >= ArgTys.size()) {
      // Defer check and subsequent check for the vector element type.
      Infos = Infos.slice(1);
      return IsDeferredCheck || DeferCheck(Ty);
    }
    auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
    auto *ThisArgType = dyn_cast<VectorType>(Ty);
    // Both must be vectors of the same number of elements or neither.
    if ((ReferenceType != nullptr) != (ThisArgType != nullptr))
      return true;
    Type *EltTy = Ty;
    if (ThisArgType) {
      if (ReferenceType->getElementCount() !=
          ThisArgType->getElementCount())
        return true;
      EltTy = ThisArgType->getElementType();
    }
    return matchIntrinsicType(EltTy, Infos, ArgTys, DeferredChecks,
                              IsDeferredCheck);
  }
  case IITDescriptor::PtrToArgument: {
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);
    Type * ReferenceType = ArgTys[D.getArgumentNumber()];
    PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
    return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
  }
  case IITDescriptor::PtrToElt: {
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);
    VectorType * ReferenceType =
      dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
    PointerType *ThisArgType = dyn_cast<PointerType>(Ty);

    if (!ThisArgType || !ReferenceType)
      return true;
    if (!ThisArgType->isOpaque())
      return ThisArgType->getElementType() != ReferenceType->getElementType();
    // If typed pointers are supported, do not allow opaque pointer to ensure
    // uniqueness.
    return Ty->getContext().supportsTypedPointers();
  }
  case IITDescriptor::VecOfAnyPtrsToElt: {
    unsigned RefArgNumber = D.getRefArgNumber();
    if (RefArgNumber >= ArgTys.size()) {
      if (IsDeferredCheck)
        return true;
      // If forward referencing, already add the pointer-vector type and
      // defer the checks for later.
      ArgTys.push_back(Ty);
      return DeferCheck(Ty);
    }

    if (!IsDeferredCheck){
      assert(D.getOverloadArgNumber() == ArgTys.size() &&(static_cast<void> (0))
             "Table consistency error")(static_cast<void> (0));
      ArgTys.push_back(Ty);
    }

    // Verify the overloaded type "matches" the Ref type.
    // i.e. Ty is a vector with the same width as Ref.
    // Composed of pointers to the same element type as Ref.
    auto *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
    auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
    if (!ThisArgVecTy || !ReferenceType ||
        (ReferenceType->getElementCount() != ThisArgVecTy->getElementCount()))
      return true;
    PointerType *ThisArgEltTy =
        dyn_cast<PointerType>(ThisArgVecTy->getElementType());
    if (!ThisArgEltTy)
      return true;
    return !ThisArgEltTy->isOpaqueOrPointeeTypeMatches(
        ReferenceType->getElementType());
  }
  case IITDescriptor::VecElementArgument: {
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck ? true : DeferCheck(Ty);
    auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
    return !ReferenceType || Ty != ReferenceType->getElementType();
  }
  case IITDescriptor::Subdivide2Argument:
  case IITDescriptor::Subdivide4Argument: {
    // If this is a forward reference, defer the check for later.
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);

    Type *NewTy = ArgTys[D.getArgumentNumber()];
    if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
      int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
      NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
      return Ty != NewTy;
    }
    return true;
  }
  case IITDescriptor::VecOfBitcastsToInt: {
    if (D.getArgumentNumber() >= ArgTys.size())
      return IsDeferredCheck || DeferCheck(Ty);
    auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
    auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
    if (!ThisArgVecTy || !ReferenceType)
      return true;
    return ThisArgVecTy != VectorType::getInteger(ReferenceType);
  }
}
llvm_unreachable("unhandled")__builtin_unreachable();
1632}

1634Intrinsic::MatchIntrinsicTypesResult
1635Intrinsic::matchIntrinsicSignature(FunctionType *FTy,
                                 ArrayRef<Intrinsic::IITDescriptor> &Infos,
                                 SmallVectorImpl<Type *> &ArgTys) {
SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks;
if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
                       false))
  return MatchIntrinsicTypes_NoMatchRet;

unsigned NumDeferredReturnChecks = DeferredChecks.size();

for (auto Ty : FTy->params())
  if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
    return MatchIntrinsicTypes_NoMatchArg;

for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
  DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
  if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
                         true))
    return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
                                       : MatchIntrinsicTypes_NoMatchArg;
}

return MatchIntrinsicTypes_Match;
1658}

1660bool
1661Intrinsic::matchIntrinsicVarArg(bool isVarArg,
                              ArrayRef<Intrinsic::IITDescriptor> &Infos) {
// If there are no descriptors left, then it can't be a vararg.
if (Infos.empty())
  return isVarArg;

// There should be only one descriptor remaining at this point.
if (Infos.size() != 1)
  return true;

// Check and verify the descriptor.
IITDescriptor D = Infos.front();
Infos = Infos.slice(1);
if (D.Kind == IITDescriptor::VarArg)
  return !isVarArg;

return true;
1678}

1680bool Intrinsic::getIntrinsicSignature(Function *F,
                                    SmallVectorImpl<Type *> &ArgTys) {
Intrinsic::ID ID = F->getIntrinsicID();
if (!ID)
  return false;

SmallVector<Intrinsic::IITDescriptor, 8> Table;
getIntrinsicInfoTableEntries(ID, Table);
ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;

if (Intrinsic::matchIntrinsicSignature(F->getFunctionType(), TableRef,
                                       ArgTys) !=
    Intrinsic::MatchIntrinsicTypesResult::MatchIntrinsicTypes_Match) {
  return false;
}
if (Intrinsic::matchIntrinsicVarArg(F->getFunctionType()->isVarArg(),
                                    TableRef))
  return false;
return true;
1699}

1701Optional<Function *> Intrinsic::remangleIntrinsicFunction(Function *F) {
SmallVector<Type *, 4> ArgTys;
if (!getIntrinsicSignature(F, ArgTys))
1
Taking false branch→
  return None;

Intrinsic::ID ID = F->getIntrinsicID();
StringRef Name = F->getName();
std::string WantedName =
    Intrinsic::getName(ID, ArgTys, F->getParent(), F->getFunctionType());
if (Name == WantedName)
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return None;

Function *NewDecl = [&] {
4
←
Calling 'operator()'→
  if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {
5
←
Assuming 'ExistingGV' is null→
6
←
Taking false branch→
    if (auto *ExistingF = dyn_cast<Function>(ExistingGV))
      if (ExistingF->getFunctionType() == F->getFunctionType())
        return ExistingF;

    // The name already exists, but is not a function or has the wrong
    // prototype. Make place for the new one by renaming the old version.
    // Either this old version will be removed later on or the module is
    // invalid and we'll get an error.
    ExistingGV->setName(WantedName + ".renamed");
  }
  return Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
7
←
Calling 'getDeclaration'→
}();

NewDecl->setCallingConv(F->getCallingConv());
assert(NewDecl->getFunctionType() == F->getFunctionType() &&(static_cast<void> (0))
       "Shouldn't change the signature")(static_cast<void> (0));
return NewDecl;
1732}

1734/// hasAddressTaken - returns true if there are any uses of this function
1735/// other than direct calls or invokes to it. Optionally ignores callback
1736/// uses, assume like pointer annotation calls, and references in llvm.used
1737/// and llvm.compiler.used variables.
1738bool Function::hasAddressTaken(const User **PutOffender,
                             bool IgnoreCallbackUses,
                             bool IgnoreAssumeLikeCalls,
                             bool IgnoreLLVMUsed) const {
for (const Use &U : uses()) {
  const User *FU = U.getUser();
  if (isa<BlockAddress>(FU))
    continue;

  if (IgnoreCallbackUses) {
    AbstractCallSite ACS(&U);
    if (ACS && ACS.isCallbackCall())
      continue;
  }

  const auto *Call = dyn_cast<CallBase>(FU);
  if (!Call) {
    if (IgnoreAssumeLikeCalls) {
      if (const auto *FI = dyn_cast<Instruction>(FU)) {
        if (FI->isCast() && !FI->user_empty() &&
            llvm::all_of(FU->users(), [](const User *U) {
              if (const auto *I = dyn_cast<IntrinsicInst>(U))
                return I->isAssumeLikeIntrinsic();
              return false;
            }))
          continue;
      }
    }
    if (IgnoreLLVMUsed && !FU->user_empty()) {
      const User *FUU = FU;
      if (isa<BitCastOperator>(FU) && FU->hasOneUse() &&
          !FU->user_begin()->user_empty())
        FUU = *FU->user_begin();
      if (llvm::all_of(FUU->users(), [](const User *U) {
            if (const auto *GV = dyn_cast<GlobalVariable>(U))
              return GV->hasName() &&
                     (GV->getName().equals("llvm.compiler.used") ||
                      GV->getName().equals("llvm.used"));
            return false;
          }))
        continue;
    }
    if (PutOffender)
      *PutOffender = FU;
    return true;
  }
  if (!Call->isCallee(&U)) {
    if (PutOffender)
      *PutOffender = FU;
    return true;
  }
}
return false;
1791}

1793bool Function::isDefTriviallyDead() const {
// Check the linkage
if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
    !hasAvailableExternallyLinkage())
  return false;

// Check if the function is used by anything other than a blockaddress.
for (const User *U : users())
  if (!isa<BlockAddress>(U))
    return false;

return true;
1805}

1807/// callsFunctionThatReturnsTwice - Return true if the function has a call to
1808/// setjmp or other function that gcc recognizes as "returning twice".
1809bool Function::callsFunctionThatReturnsTwice() const {
for (const Instruction &I : instructions(this))
  if (const auto *Call = dyn_cast<CallBase>(&I))
    if (Call->hasFnAttr(Attribute::ReturnsTwice))
      return true;

return false;
1816}

1818Constant *Function::getPersonalityFn() const {
assert(hasPersonalityFn() && getNumOperands())(static_cast<void> (0));
return cast<Constant>(Op<0>());
1821}

1823void Function::setPersonalityFn(Constant *Fn) {
setHungoffOperand<0>(Fn);
setValueSubclassDataBit(3, Fn != nullptr);
1826}

1828Constant *Function::getPrefixData() const {
assert(hasPrefixData() && getNumOperands())(static_cast<void> (0));
return cast<Constant>(Op<1>());
1831}

1833void Function::setPrefixData(Constant *PrefixData) {
setHungoffOperand<1>(PrefixData);
setValueSubclassDataBit(1, PrefixData != nullptr);
1836}

1838Constant *Function::getPrologueData() const {
assert(hasPrologueData() && getNumOperands())(static_cast<void> (0));
return cast<Constant>(Op<2>());
1841}

1843void Function::setPrologueData(Constant *PrologueData) {
setHungoffOperand<2>(PrologueData);
setValueSubclassDataBit(2, PrologueData != nullptr);
1846}

1848void Function::allocHungoffUselist() {
// If we've already allocated a uselist, stop here.
if (getNumOperands())
  return;

allocHungoffUses(3, /*IsPhi=*/ false);
setNumHungOffUseOperands(3);

// Initialize the uselist with placeholder operands to allow traversal.
auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0));
Op<0>().set(CPN);
Op<1>().set(CPN);
Op<2>().set(CPN);
1861}

1863template <int Idx>
1864void Function::setHungoffOperand(Constant *C) {
if (C) {
  allocHungoffUselist();
  Op<Idx>().set(C);
} else if (getNumOperands()) {
  Op<Idx>().set(
      ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)));
}
1872}

1874void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
assert(Bit < 16 && "SubclassData contains only 16 bits")(static_cast<void> (0));
if (On)
  setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
else
  setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
1880}

1882void Function::setEntryCount(ProfileCount Count,
                           const DenseSet<GlobalValue::GUID> *S) {
assert(Count.hasValue())(static_cast<void> (0));
1885#if !defined(NDEBUG1)
auto PrevCount = getEntryCount();
assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType())(static_cast<void> (0));
1888#endif

auto ImportGUIDs = getImportGUIDs();
if (S == nullptr && ImportGUIDs.size())
  S = &ImportGUIDs;

MDBuilder MDB(getContext());
setMetadata(
    LLVMContext::MD_prof,
    MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1898}

1900void Function::setEntryCount(uint64_t Count, Function::ProfileCountType Type,
                           const DenseSet<GlobalValue::GUID> *Imports) {
setEntryCount(ProfileCount(Count, Type), Imports);
1903}

1905ProfileCount Function::getEntryCount(bool AllowSynthetic) const {
MDNode *MD = getMetadata(LLVMContext::MD_prof);
if (MD && MD->getOperand(0))
  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
    if (MDS->getString().equals("function_entry_count")) {
      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
      uint64_t Count = CI->getValue().getZExtValue();
      // A value of -1 is used for SamplePGO when there were no samples.
      // Treat this the same as unknown.
      if (Count == (uint64_t)-1)
        return ProfileCount::getInvalid();
      return ProfileCount(Count, PCT_Real);
    } else if (AllowSynthetic &&
               MDS->getString().equals("synthetic_function_entry_count")) {
      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
      uint64_t Count = CI->getValue().getZExtValue();
      return ProfileCount(Count, PCT_Synthetic);
    }
  }
return ProfileCount::getInvalid();
1925}

1927DenseSet<GlobalValue::GUID> Function::getImportGUIDs() const {
DenseSet<GlobalValue::GUID> R;
if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
    if (MDS->getString().equals("function_entry_count"))
      for (unsigned i = 2; i < MD->getNumOperands(); i++)
        R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
                     ->getValue()
                     .getZExtValue());
return R;
1937}

1939void Function::setSectionPrefix(StringRef Prefix) {
MDBuilder MDB(getContext());
setMetadata(LLVMContext::MD_section_prefix,
            MDB.createFunctionSectionPrefix(Prefix));
1943}

1945Optional<StringRef> Function::getSectionPrefix() const {
if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
  assert(cast<MDString>(MD->getOperand(0))(static_cast<void> (0))
             ->getString()(static_cast<void> (0))
             .equals("function_section_prefix") &&(static_cast<void> (0))
         "Metadata not match")(static_cast<void> (0));
  return cast<MDString>(MD->getOperand(1))->getString();
}
return None;
1954}

1956bool Function::nullPointerIsDefined() const {
return hasFnAttribute(Attribute::NullPointerIsValid);
1958}

1960bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
if (F && F->nullPointerIsDefined())
  return true;

if (AS != 0)
  return true;

return false;
1968}

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/DerivedTypes.h

1//===- llvm/DerivedTypes.h - Classes for handling data types ----*- C++ -*-===//
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 contains the declarations of classes that represent "derived
10// types".  These are things like "arrays of x" or "structure of x, y, z" or
11// "function returning x taking (y,z) as parameters", etc...
12//
13// The implementations of these classes live in the Type.cpp file.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_IR_DERIVEDTYPES_H
18#define LLVM_IR_DERIVEDTYPES_H

20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/IR/Type.h"
24#include "llvm/Support/Casting.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Support/TypeSize.h"
27#include <cassert>
28#include <cstdint>

30namespace llvm {

32class Value;
33class APInt;
34class LLVMContext;

36/// Class to represent integer types. Note that this class is also used to
37/// represent the built-in integer types: Int1Ty, Int8Ty, Int16Ty, Int32Ty and
38/// Int64Ty.
39/// Integer representation type
40class IntegerType : public Type {
friend class LLVMContextImpl;

43protected:
explicit IntegerType(LLVMContext &C, unsigned NumBits) : Type(C, IntegerTyID){
  setSubclassData(NumBits);
}

48public:
/// This enum is just used to hold constants we need for IntegerType.
enum {
  MIN_INT_BITS = 1,        ///< Minimum number of bits that can be specified
  MAX_INT_BITS = (1<<24)-1 ///< Maximum number of bits that can be specified
    ///< Note that bit width is stored in the Type classes SubclassData field
    ///< which has 24 bits. This yields a maximum bit width of 16,777,215
    ///< bits.
};

/// This static method is the primary way of constructing an IntegerType.
/// If an IntegerType with the same NumBits value was previously instantiated,
/// that instance will be returned. Otherwise a new one will be created. Only
/// one instance with a given NumBits value is ever created.
/// Get or create an IntegerType instance.
static IntegerType *get(LLVMContext &C, unsigned NumBits);

/// Returns type twice as wide the input type.
IntegerType *getExtendedType() const {
  return Type::getIntNTy(getContext(), 2 * getScalarSizeInBits());
}

/// Get the number of bits in this IntegerType
unsigned getBitWidth() const { return getSubclassData(); }

/// Return a bitmask with ones set for all of the bits that can be set by an
/// unsigned version of this type. This is 0xFF for i8, 0xFFFF for i16, etc.
uint64_t getBitMask() const {
  return ~uint64_t(0UL) >> (64-getBitWidth());
}

/// Return a uint64_t with just the most significant bit set (the sign bit, if
/// the value is treated as a signed number).
uint64_t getSignBit() const {
  return 1ULL << (getBitWidth()-1);
}

/// For example, this is 0xFF for an 8 bit integer, 0xFFFF for i16, etc.
/// @returns a bit mask with ones set for all the bits of this type.
/// Get a bit mask for this type.
APInt getMask() const;

/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == IntegerTyID;
}
94};

96unsigned Type::getIntegerBitWidth() const {
return cast<IntegerType>(this)->getBitWidth();
98}

100/// Class to represent function types
101///
102class FunctionType : public Type {
FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);

105public:
FunctionType(const FunctionType &) = delete;
FunctionType &operator=(const FunctionType &) = delete;

/// This static method is the primary way of constructing a FunctionType.
static FunctionType *get(Type *Result,
                         ArrayRef<Type*> Params, bool isVarArg);

/// Create a FunctionType taking no parameters.
static FunctionType *get(Type *Result, bool isVarArg);

/// Return true if the specified type is valid as a return type.
static bool isValidReturnType(Type *RetTy);

/// Return true if the specified type is valid as an argument type.
static bool isValidArgumentType(Type *ArgTy);

bool isVarArg() const { return getSubclassData()!=0; }
Type *getReturnType() const { return ContainedTys[0]; }

using param_iterator = Type::subtype_iterator;

param_iterator param_begin() const { return ContainedTys + 1; }
param_iterator param_end() const { return &ContainedTys[NumContainedTys]; }
ArrayRef<Type *> params() const {
  return makeArrayRef(param_begin(), param_end());
}

/// Parameter type accessors.
Type *getParamType(unsigned i) const { return ContainedTys[i+1]; }

/// Return the number of fixed parameters this function type requires.
/// This does not consider varargs.
unsigned getNumParams() const { return NumContainedTys - 1; }

/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == FunctionTyID;
}
144};
145static_assert(alignof(FunctionType) >= alignof(Type *),
            "Alignment sufficient for objects appended to FunctionType");

148bool Type::isFunctionVarArg() const {
return cast<FunctionType>(this)->isVarArg();
150}

152Type *Type::getFunctionParamType(unsigned i) const {
return cast<FunctionType>(this)->getParamType(i);
154}

156unsigned Type::getFunctionNumParams() const {
return cast<FunctionType>(this)->getNumParams();
158}

160/// A handy container for a FunctionType+Callee-pointer pair, which can be
161/// passed around as a single entity. This assists in replacing the use of
162/// PointerType::getElementType() to access the function's type, since that's
163/// slated for removal as part of the [opaque pointer types] project.
164class FunctionCallee {
165public:
// Allow implicit conversion from types which have a getFunctionType member
// (e.g. Function and InlineAsm).
template <typename T, typename U = decltype(&T::getFunctionType)>
FunctionCallee(T *Fn)
    : FnTy(Fn ? Fn->getFunctionType() : nullptr), Callee(Fn) {}

FunctionCallee(FunctionType *FnTy, Value *Callee)
    : FnTy(FnTy), Callee(Callee) {
  assert((FnTy == nullptr) == (Callee == nullptr))(static_cast<void> (0));
}

FunctionCallee(std::nullptr_t) {}

FunctionCallee() = default;

FunctionType *getFunctionType() { return FnTy; }

Value *getCallee() { return Callee; }

explicit operator bool() { return Callee; }

187private:
FunctionType *FnTy = nullptr;
Value *Callee = nullptr;
190};

192/// Class to represent struct types. There are two different kinds of struct
193/// types: Literal structs and Identified structs.
194///
195/// Literal struct types (e.g. { i32, i32 }) are uniqued structurally, and must
196/// always have a body when created.  You can get one of these by using one of
197/// the StructType::get() forms.
198///
199/// Identified structs (e.g. %foo or %42) may optionally have a name and are not
200/// uniqued.  The names for identified structs are managed at the LLVMContext
201/// level, so there can only be a single identified struct with a given name in
202/// a particular LLVMContext.  Identified structs may also optionally be opaque
203/// (have no body specified).  You get one of these by using one of the
204/// StructType::create() forms.
205///
206/// Independent of what kind of struct you have, the body of a struct type are
207/// laid out in memory consecutively with the elements directly one after the
208/// other (if the struct is packed) or (if not packed) with padding between the
209/// elements as defined by DataLayout (which is required to match what the code
210/// generator for a target expects).
211///
212class StructType : public Type {
StructType(LLVMContext &C) : Type(C, StructTyID) {}

enum {
  /// This is the contents of the SubClassData field.
  SCDB_HasBody = 1,
  SCDB_Packed = 2,
  SCDB_IsLiteral = 4,
  SCDB_IsSized = 8
};

/// For a named struct that actually has a name, this is a pointer to the
/// symbol table entry (maintained by LLVMContext) for the struct.
/// This is null if the type is an literal struct or if it is a identified
/// type that has an empty name.
void *SymbolTableEntry = nullptr;

229public:
StructType(const StructType &) = delete;
StructType &operator=(const StructType &) = delete;

/// This creates an identified struct.
static StructType *create(LLVMContext &Context, StringRef Name);
static StructType *create(LLVMContext &Context);

static StructType *create(ArrayRef<Type *> Elements, StringRef Name,
                          bool isPacked = false);
static StructType *create(ArrayRef<Type *> Elements);
static StructType *create(LLVMContext &Context, ArrayRef<Type *> Elements,
                          StringRef Name, bool isPacked = false);
static StructType *create(LLVMContext &Context, ArrayRef<Type *> Elements);
template <class... Tys>
static std::enable_if_t<are_base_of<Type, Tys...>::value, StructType *>
create(StringRef Name, Type *elt1, Tys *... elts) {
  assert(elt1 && "Cannot create a struct type with no elements with this")(static_cast<void> (0));
  return create(ArrayRef<Type *>({elt1, elts...}), Name);
}

/// This static method is the primary way to create a literal StructType.
static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements,
                       bool isPacked = false);

/// Create an empty structure type.
static StructType *get(LLVMContext &Context, bool isPacked = false);

/// This static method is a convenience method for creating structure types by
/// specifying the elements as arguments. Note that this method always returns
/// a non-packed struct, and requires at least one element type.
template <class... Tys>
static std::enable_if_t<are_base_of<Type, Tys...>::value, StructType *>
get(Type *elt1, Tys *... elts) {
  assert(elt1 && "Cannot create a struct type with no elements with this")(static_cast<void> (0));
  LLVMContext &Ctx = elt1->getContext();
  return StructType::get(Ctx, ArrayRef<Type *>({elt1, elts...}));
}

/// Return the type with the specified name, or null if there is none by that
/// name.
static StructType *getTypeByName(LLVMContext &C, StringRef Name);

bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; }

/// Return true if this type is uniqued by structural equivalence, false if it
/// is a struct definition.
bool isLiteral() const { return (getSubclassData() & SCDB_IsLiteral) != 0; }

/// Return true if this is a type with an identity that has no body specified
/// yet. These prints as 'opaque' in .ll files.
bool isOpaque() const { return (getSubclassData() & SCDB_HasBody) == 0; }

/// isSized - Return true if this is a sized type.
bool isSized(SmallPtrSetImpl<Type *> *Visited = nullptr) const;

/// Returns true if this struct contains a scalable vector.
bool containsScalableVectorType() const;

/// Return true if this is a named struct that has a non-empty name.
bool hasName() const { return SymbolTableEntry != nullptr; }

/// Return the name for this struct type if it has an identity.
/// This may return an empty string for an unnamed struct type.  Do not call
/// this on an literal type.
StringRef getName() const;

/// Change the name of this type to the specified name, or to a name with a
/// suffix if there is a collision. Do not call this on an literal type.
void setName(StringRef Name);

/// Specify a body for an opaque identified type.
void setBody(ArrayRef<Type*> Elements, bool isPacked = false);

template <typename... Tys>
std::enable_if_t<are_base_of<Type, Tys...>::value, void>
setBody(Type *elt1, Tys *... elts) {
  assert(elt1 && "Cannot create a struct type with no elements with this")(static_cast<void> (0));
  setBody(ArrayRef<Type *>({elt1, elts...}));
}

/// Return true if the specified type is valid as a element type.
static bool isValidElementType(Type *ElemTy);

// Iterator access to the elements.
using element_iterator = Type::subtype_iterator;

element_iterator element_begin() const { return ContainedTys; }
element_iterator element_end() const { return &ContainedTys[NumContainedTys];}
ArrayRef<Type *> elements() const {
  return makeArrayRef(element_begin(), element_end());
}

/// Return true if this is layout identical to the specified struct.
bool isLayoutIdentical(StructType *Other) const;

/// Random access to the elements
unsigned getNumElements() const { return NumContainedTys; }
Type *getElementType(unsigned N) const {
  assert(N < NumContainedTys && "Element number out of range!")(static_cast<void> (0));
  return ContainedTys[N];
}
/// Given an index value into the type, return the type of the element.
Type *getTypeAtIndex(const Value *V) const;
Type *getTypeAtIndex(unsigned N) const { return getElementType(N); }
bool indexValid(const Value *V) const;
bool indexValid(unsigned Idx) const { return Idx < getNumElements(); }

/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == StructTyID;
}
341};

343StringRef Type::getStructName() const {
return cast<StructType>(this)->getName();
345}

347unsigned Type::getStructNumElements() const {
return cast<StructType>(this)->getNumElements();
349}

351Type *Type::getStructElementType(unsigned N) const {
return cast<StructType>(this)->getElementType(N);
353}

355/// Class to represent array types.
356class ArrayType : public Type {
/// The element type of the array.
Type *ContainedType;
/// Number of elements in the array.
uint64_t NumElements;

ArrayType(Type *ElType, uint64_t NumEl);

364public:
ArrayType(const ArrayType &) = delete;
ArrayType &operator=(const ArrayType &) = delete;

uint64_t getNumElements() const { return NumElements; }
Type *getElementType() const { return ContainedType; }

/// This static method is the primary way to construct an ArrayType
static ArrayType *get(Type *ElementType, uint64_t NumElements);

/// Return true if the specified type is valid as a element type.
static bool isValidElementType(Type *ElemTy);

/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == ArrayTyID;
}
381};

383uint64_t Type::getArrayNumElements() const {
return cast<ArrayType>(this)->getNumElements();
385}

387/// Base class of all SIMD vector types
388class VectorType : public Type {
/// A fully specified VectorType is of the form <vscale x n x Ty>. 'n' is the
/// minimum number of elements of type Ty contained within the vector, and
/// 'vscale x' indicates that the total element count is an integer multiple
/// of 'n', where the multiple is either guaranteed to be one, or is
/// statically unknown at compile time.
///
/// If the multiple is known to be 1, then the extra term is discarded in
/// textual IR:
///
/// <4 x i32>          - a vector containing 4 i32s
/// <vscale x 4 x i32> - a vector containing an unknown integer multiple
///                      of 4 i32s

/// The element type of the vector.
Type *ContainedType;

405protected:
/// The element quantity of this vector. The meaning of this value depends
/// on the type of vector:
/// - For FixedVectorType = <ElementQuantity x ty>, there are
///   exactly ElementQuantity elements in this vector.
/// - For ScalableVectorType = <vscale x ElementQuantity x ty>,
///   there are vscale * ElementQuantity elements in this vector, where
///   vscale is a runtime-constant integer greater than 0.
const unsigned ElementQuantity;

VectorType(Type *ElType, unsigned EQ, Type::TypeID TID);

417public:
VectorType(const VectorType &) = delete;
VectorType &operator=(const VectorType &) = delete;

Type *getElementType() const { return ContainedType; }

/// This static method is the primary way to construct an VectorType.
static VectorType *get(Type *ElementType, ElementCount EC);

static VectorType *get(Type *ElementType, unsigned NumElements,
                       bool Scalable) {
  return VectorType::get(ElementType,
                         ElementCount::get(NumElements, Scalable));
}

static VectorType *get(Type *ElementType, const VectorType *Other) {
  return VectorType::get(ElementType, Other->getElementCount());
}

/// This static method gets a VectorType with the same number of elements as
/// the input type, and the element type is an integer type of the same width
/// as the input element type.
static VectorType *getInteger(VectorType *VTy) {
  unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
15
←
Called C++ object pointer is null
  assert(EltBits && "Element size must be of a non-zero size")(static_cast<void> (0));
  Type *EltTy = IntegerType::get(VTy->getContext(), EltBits);
  return VectorType::get(EltTy, VTy->getElementCount());
}

/// This static method is like getInteger except that the element types are
/// twice as wide as the elements in the input type.
static VectorType *getExtendedElementVectorType(VectorType *VTy) {
  assert(VTy->isIntOrIntVectorTy() && "VTy expected to be a vector of ints.")(static_cast<void> (0));
  auto *EltTy = cast<IntegerType>(VTy->getElementType());
  return VectorType::get(EltTy->getExtendedType(), VTy->getElementCount());
}

// This static method gets a VectorType with the same number of elements as
// the input type, and the element type is an integer or float type which
// is half as wide as the elements in the input type.
static VectorType *getTruncatedElementVectorType(VectorType *VTy) {
  Type *EltTy;
  if (VTy->getElementType()->isFloatingPointTy()) {
    switch(VTy->getElementType()->getTypeID()) {
    case DoubleTyID:
      EltTy = Type::getFloatTy(VTy->getContext());
      break;
    case FloatTyID:
      EltTy = Type::getHalfTy(VTy->getContext());
      break;
    default:
      llvm_unreachable("Cannot create narrower fp vector element type")__builtin_unreachable();
    }
  } else {
    unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
    assert((EltBits & 1) == 0 &&(static_cast<void> (0))
           "Cannot truncate vector element with odd bit-width")(static_cast<void> (0));
    EltTy = IntegerType::get(VTy->getContext(), EltBits / 2);
  }
  return VectorType::get(EltTy, VTy->getElementCount());
}

// This static method returns a VectorType with a smaller number of elements
// of a larger type than the input element type. For example, a <16 x i8>
// subdivided twice would return <4 x i32>
static VectorType *getSubdividedVectorType(VectorType *VTy, int NumSubdivs) {
  for (int i = 0; i < NumSubdivs; ++i) {
    VTy = VectorType::getDoubleElementsVectorType(VTy);
    VTy = VectorType::getTruncatedElementVectorType(VTy);
  }
  return VTy;
}

/// This static method returns a VectorType with half as many elements as the
/// input type and the same element type.
static VectorType *getHalfElementsVectorType(VectorType *VTy) {
  auto EltCnt = VTy->getElementCount();
  assert(EltCnt.isKnownEven() &&(static_cast<void> (0))
         "Cannot halve vector with odd number of elements.")(static_cast<void> (0));
  return VectorType::get(VTy->getElementType(),
                         EltCnt.divideCoefficientBy(2));
}

/// This static method returns a VectorType with twice as many elements as the
/// input type and the same element type.
static VectorType *getDoubleElementsVectorType(VectorType *VTy) {
  auto EltCnt = VTy->getElementCount();
  assert((EltCnt.getKnownMinValue() * 2ull) <= UINT_MAX &&(static_cast<void> (0))
         "Too many elements in vector")(static_cast<void> (0));
  return VectorType::get(VTy->getElementType(), EltCnt * 2);
}

/// Return true if the specified type is valid as a element type.
static bool isValidElementType(Type *ElemTy);

/// Return an ElementCount instance to represent the (possibly scalable)
/// number of elements in the vector.
inline ElementCount getElementCount() const;

/// Methods for support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == FixedVectorTyID ||
         T->getTypeID() == ScalableVectorTyID;
}
521};

523/// Class to represent fixed width SIMD vectors
524class FixedVectorType : public VectorType {
525protected:
FixedVectorType(Type *ElTy, unsigned NumElts)
    : VectorType(ElTy, NumElts, FixedVectorTyID) {}

529public:
static FixedVectorType *get(Type *ElementType, unsigned NumElts);

static FixedVectorType *get(Type *ElementType, const FixedVectorType *FVTy) {
  return get(ElementType, FVTy->getNumElements());
}

static FixedVectorType *getInteger(FixedVectorType *VTy) {
  return cast<FixedVectorType>(VectorType::getInteger(VTy));
}

static FixedVectorType *getExtendedElementVectorType(FixedVectorType *VTy) {
  return cast<FixedVectorType>(VectorType::getExtendedElementVectorType(VTy));
}

static FixedVectorType *getTruncatedElementVectorType(FixedVectorType *VTy) {
  return cast<FixedVectorType>(
      VectorType::getTruncatedElementVectorType(VTy));
}

static FixedVectorType *getSubdividedVectorType(FixedVectorType *VTy,
                                                int NumSubdivs) {
  return cast<FixedVectorType>(
      VectorType::getSubdividedVectorType(VTy, NumSubdivs));
}

static FixedVectorType *getHalfElementsVectorType(FixedVectorType *VTy) {
  return cast<FixedVectorType>(VectorType::getHalfElementsVectorType(VTy));
}

static FixedVectorType *getDoubleElementsVectorType(FixedVectorType *VTy) {
  return cast<FixedVectorType>(VectorType::getDoubleElementsVectorType(VTy));
}

static bool classof(const Type *T) {
  return T->getTypeID() == FixedVectorTyID;
}

unsigned getNumElements() const { return ElementQuantity; }
568};

570/// Class to represent scalable SIMD vectors
571class ScalableVectorType : public VectorType {
572protected:
ScalableVectorType(Type *ElTy, unsigned MinNumElts)
    : VectorType(ElTy, MinNumElts, ScalableVectorTyID) {}

576public:
static ScalableVectorType *get(Type *ElementType, unsigned MinNumElts);

static ScalableVectorType *get(Type *ElementType,
                               const ScalableVectorType *SVTy) {
  return get(ElementType, SVTy->getMinNumElements());
}

static ScalableVectorType *getInteger(ScalableVectorType *VTy) {
  return cast<ScalableVectorType>(VectorType::getInteger(VTy));
}

static ScalableVectorType *
getExtendedElementVectorType(ScalableVectorType *VTy) {
  return cast<ScalableVectorType>(
      VectorType::getExtendedElementVectorType(VTy));
}

static ScalableVectorType *
getTruncatedElementVectorType(ScalableVectorType *VTy) {
  return cast<ScalableVectorType>(
      VectorType::getTruncatedElementVectorType(VTy));
}

static ScalableVectorType *getSubdividedVectorType(ScalableVectorType *VTy,
                                                   int NumSubdivs) {
  return cast<ScalableVectorType>(
      VectorType::getSubdividedVectorType(VTy, NumSubdivs));
}

static ScalableVectorType *
getHalfElementsVectorType(ScalableVectorType *VTy) {
  return cast<ScalableVectorType>(VectorType::getHalfElementsVectorType(VTy));
}

static ScalableVectorType *
getDoubleElementsVectorType(ScalableVectorType *VTy) {
  return cast<ScalableVectorType>(
      VectorType::getDoubleElementsVectorType(VTy));
}

/// Get the minimum number of elements in this vector. The actual number of
/// elements in the vector is an integer multiple of this value.
uint64_t getMinNumElements() const { return ElementQuantity; }

static bool classof(const Type *T) {
  return T->getTypeID() == ScalableVectorTyID;
}
624};

626inline ElementCount VectorType::getElementCount() const {
return ElementCount::get(ElementQuantity, isa<ScalableVectorType>(this));
628}

630/// Class to represent pointers.
631class PointerType : public Type {
explicit PointerType(Type *ElType, unsigned AddrSpace);
explicit PointerType(LLVMContext &C, unsigned AddrSpace);

Type *PointeeTy;

637public:
PointerType(const PointerType &) = delete;
PointerType &operator=(const PointerType &) = delete;

/// This constructs a pointer to an object of the specified type in a numbered
/// address space.
static PointerType *get(Type *ElementType, unsigned AddressSpace);
/// This constructs an opaque pointer to an object in a numbered address
/// space.
static PointerType *get(LLVMContext &C, unsigned AddressSpace);

/// This constructs a pointer to an object of the specified type in the
/// default address space (address space zero).
static PointerType *getUnqual(Type *ElementType) {
  return PointerType::get(ElementType, 0);
}

/// This constructs an opaque pointer to an object in the
/// default address space (address space zero).
static PointerType *getUnqual(LLVMContext &C) {
  return PointerType::get(C, 0);
}

/// This constructs a pointer type with the same pointee type as input
/// PointerType (or opaque pointer is the input PointerType is opaque) and the
/// given address space. This is only useful during the opaque pointer
/// transition.
/// TODO: remove after opaque pointer transition is complete.
static PointerType *getWithSamePointeeType(PointerType *PT,
                                           unsigned AddressSpace) {
  if (PT->isOpaque())
    return get(PT->getContext(), AddressSpace);
  return get(PT->getElementType(), AddressSpace);
}

Type *getElementType() const {
  assert(!isOpaque() && "Attempting to get element type of opaque pointer")(static_cast<void> (0));
  return PointeeTy;
}

bool isOpaque() const { return !PointeeTy; }

/// Return true if the specified type is valid as a element type.
static bool isValidElementType(Type *ElemTy);

/// Return true if we can load or store from a pointer to this type.
static bool isLoadableOrStorableType(Type *ElemTy);

/// Return the address space of the Pointer type.
inline unsigned getAddressSpace() const { return getSubclassData(); }

/// Return true if either this is an opaque pointer type or if this pointee
/// type matches Ty. Primarily used for checking if an instruction's pointer
/// operands are valid types. Will be useless after non-opaque pointers are
/// removed.
bool isOpaqueOrPointeeTypeMatches(Type *Ty) {
  return isOpaque() || PointeeTy == Ty;
}

/// Return true if both pointer types have the same element type. Two opaque
/// pointers are considered to have the same element type, while an opaque
/// and a non-opaque pointer have different element types.
/// TODO: Remove after opaque pointer transition is complete.
bool hasSameElementTypeAs(PointerType *Other) {
  return PointeeTy == Other->PointeeTy;
}

/// Implement support type inquiry through isa, cast, and dyn_cast.
static bool classof(const Type *T) {
  return T->getTypeID() == PointerTyID;
}
708};

710Type *Type::getExtendedType() const {
assert((static_cast<void> (0))
    isIntOrIntVectorTy() &&(static_cast<void> (0))
    "Original type expected to be a vector of integers or a scalar integer.")(static_cast<void> (0));
if (auto *VTy = dyn_cast<VectorType>(this))
  return VectorType::getExtendedElementVectorType(
      const_cast<VectorType *>(VTy));
return cast<IntegerType>(this)->getExtendedType();
718}

720Type *Type::getWithNewType(Type *EltTy) const {
if (auto *VTy = dyn_cast<VectorType>(this))
  return VectorType::get(EltTy, VTy->getElementCount());
return EltTy;
724}

726Type *Type::getWithNewBitWidth(unsigned NewBitWidth) const {
assert((static_cast<void> (0))
    isIntOrIntVectorTy() &&(static_cast<void> (0))
    "Original type expected to be a vector of integers or a scalar integer.")(static_cast<void> (0));
return getWithNewType(getIntNTy(getContext(), NewBitWidth));
731}

733unsigned Type::getPointerAddressSpace() const {
return cast<PointerType>(getScalarType())->getAddressSpace();
735}

737} // end namespace llvm

739#endif // LLVM_IR_DERIVEDTYPES_H