52#define DEBUG_TYPE "memory-builtins"
59 "object-size-offset-visitor-max-visit-instructions",
60 cl::desc(
"Maximum number of instructions for ObjectSizeOffsetVisitor to "
121 if (CB->isNoBuiltin())
124 return CB->getCalledFunction();
129static std::optional<AllocFnsTy>
134 if (!Callee->getReturnType()->isPointerTy())
141 LibFunc TLIFn =
TLI->getLibFunc(*Callee);
142 if (!
TLI->has(TLIFn))
146 [TLIFn](
const std::pair<LibFunc, AllocFnsTy> &
P) {
147 return P.first == TLIFn;
162 if (FTy->getReturnType()->isPointerTy() &&
163 FTy->getNumParams() == FnData->
NumParams &&
164 (FstParam < 0 || (FTy->getParamType(FstParam)->isIntegerTy(32) ||
165 FTy->getParamType(FstParam)->isIntegerTy(64))) &&
166 (SndParam < 0 || FTy->getParamType(SndParam)->isIntegerTy(32) ||
167 FTy->getParamType(SndParam)->isIntegerTy(64)))
172static std::optional<AllocFnsTy>
180static std::optional<AllocFnsTy>
185 Callee, AllocTy, &GetTLI(
const_cast<Function &
>(*Callee)));
189static std::optional<AllocFnsTy>
194 if (std::optional<AllocFnsTy>
Data =
203 std::pair<unsigned, std::optional<unsigned>> Args = Attr.
getAllocSizeArgs();
210 Result.FstParam = Args.first;
211 Result.SndParam = Args.second.value_or(-1);
213 Result.AlignParam = -1;
219 Attribute Attr = CB->getFnAttr(Attribute::AllocKind);
227 return F->getAttributes().getAllocKind();
243 if (!V->getType()->isPointerTy())
252 if (!V->getType()->isPointerTy())
262 if (!V->getType()->isPointerTy())
294 if (FnData && FnData->AlignParam >= 0) {
295 return V->getOperand(FnData->AlignParam);
297 return V->getArgOperandWithAttribute(Attribute::AllocAlign);
309 if (
I.getBitWidth() > IntTyBits &&
I.getActiveBits() > IntTyBits)
311 if (
I.getBitWidth() != IntTyBits)
312 I =
I.zextOrTrunc(IntTyBits);
328 const unsigned IntTyBits =
DL.getIndexTypeSizeInBits(CB->
getType());
337 if (FnData->FstParam > 0) {
344 if (
Size.ugt(MaxSize))
360 if (FnData->SndParam < 0)
372 Size =
Size.umul_ov(NumElems, Overflow);
401std::optional<StringRef>
404 LibFunc TLIFn =
TLI ?
TLI->getLibFunc(*Callee) : NotLibFunc;
405 if (TLIFn != NotLibFunc &&
TLI->has(TLIFn)) {
407 const auto AllocData =
436 LibFunc TLIFn =
TLI ?
TLI->getLibFunc(*Callee) : NotLibFunc;
437 if (TLIFn != NotLibFunc &&
TLI->has(TLIFn) &&
471 if (!
Data.bothKnown())
483 "Other modes are currently not supported");
501 if (!GV->getValueType()->isSized() || GV->hasExternalWeakLinkage() ||
502 !GV->hasInitializer() || GV->isInterposable())
508 Type *MemoryTy =
A->getPointeeInMemoryValueType();
509 if (!MemoryTy || !MemoryTy->
isSized())
511 return Align(
DL.getTypeAllocSize(MemoryTy),
A->getParamAlign());
515 if (std::optional<TypeSize>
Size = AI->getAllocationSize(
DL))
522 if (std::optional<uint64_t> ZExtSize =
Size->tryZExtValue())
544 "ObjectSize must be a call to llvm.objectsize!");
570 return ConstantInt::get(ResultType,
Size);
579 if (InsertedInstructions)
590 ResultSize = Builder.CreateZExtOrTrunc(ResultSize, ResultType);
591 Value *Ret = Builder.CreateSelect(
592 UseZero, ConstantInt::get(ResultType, 0), ResultSize);
596 Builder.CreateAssumption(Builder.CreateICmpNE(
611 "Number of arguments with unsolved size and offset");
613 "Number of load instructions with unsolved size and offset");
615static std::optional<APInt>
617 std::optional<APInt>
RHS,
628 unsigned RecursionDepth) {
629 constexpr unsigned MaxRecursionDepth = 4;
630 if (RecursionDepth == MaxRecursionDepth)
634 return CI->getValue().sextOrTrunc(
BitWidth);
643 unsigned Count = PN->getNumIncomingValues();
647 PN->getIncomingValue(0), EvalMode,
BitWidth, RecursionDepth + 1);
648 for (
unsigned I = 1; Acc &&
I <
Count; ++
I) {
650 PN->getIncomingValue(
I), EvalMode,
BitWidth, RecursionDepth + 1);
659static std::optional<APInt>
663 return CI->getValue().sextOrTrunc(
BitWidth);
679 if (Options.RoundToAlign && Alignment)
682 return Size.isNegative() ? APInt() :
Size;
689 : DL(DL), TLI(TLI), Options(Options) {
695 InstructionsVisited = 0;
711 unsigned InitialIntTyBits =
DL.getIndexTypeSizeInBits(V->getType());
719 V = V->stripAndAccumulateConstantOffsets(
737 unsigned IdxTyBits =
DL.getIndexTypeSizeInBits(V->getType());
738 auto OffsetRangeAnalysis = [EvalMode, IdxTyBits](
Value &VOffset,
740 if (
auto PossibleOffset =
748 V =
V->stripAndAccumulateConstantOffsets(
750 OffsetRangeAnalysis);
755 IntTyBits = DL.getIndexTypeSizeInBits(
V->getType());
757 OffsetSpan ORT = computeValue(
V);
759 bool IndexTypeSizeChanged = InitialIntTyBits != IntTyBits;
760 if (!IndexTypeSizeChanged &&
Offset.isZero())
766 if (IndexTypeSizeChanged) {
768 !::checkedZextOrTrunc(ORT.
Before, InitialIntTyBits))
770 if (ORT.
knownAfter() && !::checkedZextOrTrunc(ORT.
After, InitialIntTyBits))
796 return ObjectSizeOffsetVisitor::unknown();
807 auto P = SeenInsts.try_emplace(
I, ObjectSizeOffsetVisitor::unknown());
809 return P.first->second;
810 ++InstructionsVisited;
812 return ObjectSizeOffsetVisitor::unknown();
813 OffsetSpan Res =
visit(*
I);
830 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetVisitor::compute() unhandled value: "
832 return ObjectSizeOffsetVisitor::unknown();
835bool ObjectSizeOffsetVisitor::checkedZextOrTrunc(
APInt &
I) {
836 return ::checkedZextOrTrunc(
I, IntTyBits);
840 TypeSize ElemSize =
I.getAllocationBaseSize(DL);
842 return ObjectSizeOffsetVisitor::unknown();
844 return ObjectSizeOffsetVisitor::unknown();
847 if (!
I.isArrayAllocation())
850 Value *ArraySize =
I.getArraySize();
852 ArraySize, Options.EvalMode,
854 APInt NumElems = *PossibleSize;
855 if (!checkedZextOrTrunc(NumElems))
856 return ObjectSizeOffsetVisitor::unknown();
859 Size =
Size.umul_ov(NumElems, Overflow);
861 return Overflow ? ObjectSizeOffsetVisitor::unknown()
864 return ObjectSizeOffsetVisitor::unknown();
868 Type *MemoryTy =
A.getPointeeInMemoryValueType();
870 if (!MemoryTy || !MemoryTy->
isSized()) {
871 ++ObjectVisitorArgument;
872 return ObjectSizeOffsetVisitor::unknown();
875 APInt Size(IntTyBits, DL.getTypeAllocSize(MemoryTy));
880 auto Mapper = [
this](
const Value *V) ->
const Value * {
881 if (!V->getType()->isIntegerTy())
885 V, Options.EvalMode, V->getType()->getScalarSizeInBits()))
886 return ConstantInt::get(V->getType(), *PossibleBound);
893 if (
Size->isNegative())
894 return ObjectSizeOffsetVisitor::unknown();
897 return ObjectSizeOffsetVisitor::unknown();
910 return ObjectSizeOffsetVisitor::unknown();
916 return ObjectSizeOffsetVisitor::unknown();
921 return ObjectSizeOffsetVisitor::unknown();
926 return ObjectSizeOffsetVisitor::unknown();
934 return ObjectSizeOffsetVisitor::unknown();
942 return ObjectSizeOffsetVisitor::unknown();
945OffsetSpan ObjectSizeOffsetVisitor::findLoadOffsetRange(
948 unsigned &ScannedInstCount) {
949 constexpr unsigned MaxInstsToScan = 128;
953 return Where->second;
956 return VisitedBlocks[&BB] = ObjectSizeOffsetVisitor::unknown();
968 if (++ScannedInstCount > MaxInstsToScan)
971 if (!
I.mayWriteToMemory())
976 Options.AA->alias(
SI->getPointerOperand(),
Load.getPointerOperand());
981 if (
SI->getValueOperand()->getType()->isPointerTy())
982 return Known(computeImpl(
SI->getValueOperand()));
1000 if (!TLI->has(TLIFn))
1004 if (TLIFn != LibFunc_posix_memalign)
1023 if (!Checked || !*Checked)
1031 APInt CSize =
C->getValue();
1039 }
while (From-- != BB.
begin());
1043 PredecessorSizeOffsets.
push_back(findLoadOffsetRange(
1046 if (!PredecessorSizeOffsets.
back().bothKnown())
1050 if (PredecessorSizeOffsets.
empty())
1053 return Known(std::accumulate(
1054 PredecessorSizeOffsets.
begin() + 1, PredecessorSizeOffsets.
end(),
1055 PredecessorSizeOffsets.
front(), [
this](OffsetSpan
LHS, OffsetSpan
RHS) {
1056 return combineOffsetRange(LHS, RHS);
1062 ++ObjectVisitorLoad;
1063 return ObjectSizeOffsetVisitor::unknown();
1067 unsigned ScannedInstCount = 0;
1072 ++ObjectVisitorLoad;
1078 if (!LHS.bothKnown() || !RHS.bothKnown())
1079 return ObjectSizeOffsetVisitor::unknown();
1083 return {LHS.Before.slt(RHS.Before) ? LHS.Before : RHS.Before,
1084 LHS.After.slt(RHS.After) ? LHS.After : RHS.After};
1086 return {
LHS.Before.sgt(
RHS.Before) ?
LHS.Before :
RHS.Before,
1090 return {
LHS.Before.eq(
RHS.Before) ?
LHS.Before : APInt(),
1091 LHS.After.eq(
RHS.After) ?
LHS.After : APInt()};
1093 return (
LHS ==
RHS) ?
LHS : ObjectSizeOffsetVisitor::unknown();
1100 return ObjectSizeOffsetVisitor::unknown();
1102 return std::accumulate(IncomingValues.begin() + 1, IncomingValues.end(),
1103 computeImpl(*IncomingValues.begin()),
1105 return combineOffsetRange(LHS, computeImpl(VRHS));
1110 return combineOffsetRange(computeImpl(
I.getTrueValue()),
1111 computeImpl(
I.getFalseValue()));
1119 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetVisitor unknown instruction:" <<
I
1121 return ObjectSizeOffsetVisitor::unknown();
1130 : DL(M.getDataLayout()), TLI(TLI), Context(M.
getContext()),
1134 EvalOpts(EvalOpts) {
1142 Zero = ConstantInt::get(IntTy, 0);
1146 if (!Result.bothKnown()) {
1150 for (
const Value *SeenVal : SeenVals) {
1153 if (CacheIt != CacheMap.end() && CacheIt->second.anyKnown())
1154 CacheMap.erase(CacheIt);
1160 I->eraseFromParent();
1165 InsertedInstructions.clear();
1178 if (Const.bothKnown())
1180 ConstantInt::get(Context, Const.Offset));
1182 V = V->stripPointerCasts();
1186 if (CacheIt != CacheMap.
end())
1187 return CacheIt->second;
1193 Builder.SetInsertPoint(
I);
1201 if (!SeenVals.
insert(V).second) {
1215 dbgs() <<
"ObjectSizeOffsetEvaluator::compute() unhandled value: " << *
V
1221 CacheMap[
V] = SizeOffsetWeakTrackingVH(Result);
1227 assert(
I.isArrayAllocation() ||
I.isScalable());
1231 Type *IndexTy = DL.getIndexType(
I.getContext(), DL.getAllocaAddrSpace());
1232 assert(IndexTy == Zero->getType() &&
1233 "Expected zero constant to have pointer index type");
1235 Value *
Size = Builder.CreateAllocationSize(IndexTy, &
I);
1251 FirstArg = Builder.CreateZExtOrTrunc(FirstArg, IntTy);
1252 if (FnData->SndParam < 0)
1256 SecondArg = Builder.CreateZExtOrTrunc(SecondArg, IntTy);
1257 Value *
Size = Builder.CreateMul(FirstArg, SecondArg);
1292 PHINode *SizePHI = Builder.CreatePHI(IntTy,
PHI.getNumIncomingValues());
1293 PHINode *OffsetPHI = Builder.CreatePHI(IntTy,
PHI.getNumIncomingValues());
1299 for (
unsigned i = 0, e =
PHI.getNumIncomingValues(); i != e; ++i) {
1307 InsertedInstructions.erase(OffsetPHI);
1310 InsertedInstructions.erase(SizePHI);
1322 InsertedInstructions.erase(SizePHI);
1328 InsertedInstructions.erase(OffsetPHI);
1339 if (TrueSide == FalseSide)
1343 Builder.CreateSelect(
I.getCondition(), TrueSide.
Size, FalseSide.
Size,
"",
1346 Builder.CreateSelect(
I.getCondition(), TrueSide.
Offset, FalseSide.
Offset,
1352 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetEvaluator unknown instruction:" <<
I
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
SmallPtrSet< const BasicBlock *, 8 > VisitedBlocks
static std::optional< APInt > combinePossibleConstantValues(std::optional< APInt > LHS, std::optional< APInt > RHS, ObjectSizeOpts::Mode EvalMode)
static AllocFnKind getAllocFnKind(const Value *V)
static std::optional< APInt > aggregatePossibleConstantValuesImpl(const Value *V, ObjectSizeOpts::Mode EvalMode, unsigned BitWidth, unsigned RecursionDepth)
static bool checkedZextOrTrunc(APInt &I, unsigned IntTyBits)
When we're compiling N-bit code, and the user uses parameters that are greater than N bits (e....
static std::optional< AllocFnsTy > getAllocationDataForFunction(const Function *Callee, AllocType AllocTy, const TargetLibraryInfo *TLI)
Returns the allocation data for the given value if it's a call to a known allocation function.
static std::optional< AllocFnsTy > getAllocationData(const Value *V, AllocType AllocTy, const TargetLibraryInfo *TLI)
static bool checkFnAllocKind(const Value *V, AllocFnKind Wanted)
static std::optional< AllocFnsTy > getAllocationSize(const CallBase *CB, const TargetLibraryInfo *TLI)
static const Function * getCalledFunction(const Value *V)
static cl::opt< unsigned > ObjectSizeOffsetVisitorMaxVisitInstructions("object-size-offset-visitor-max-visit-instructions", cl::desc("Maximum number of instructions for ObjectSizeOffsetVisitor to " "look at"), cl::init(100))
static StringRef mangledNameForMallocFamily(const MallocFamily &Family)
static const std::pair< LibFunc, AllocFnsTy > AllocationFnData[]
static APInt getSizeWithOverflow(const SizeOffsetAPInt &Data)
static std::optional< APInt > aggregatePossibleConstantValues(const Value *V, ObjectSizeOpts::Mode EvalMode, unsigned BitWidth)
This file contains the declarations for profiling metadata utility functions.
Func getContext().diagnose(DiagnosticInfoUnsupported(Func
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Class for arbitrary precision integers.
LLVM_ABI APInt zext(unsigned width) const
Zero extend to a new width.
uint64_t getZExtValue() const
Get zero extended value.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool isNegative() const
Determine sign of this APInt.
LLVM_ABI APInt sadd_ov(const APInt &RHS, bool &Overflow) const
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
LLVM_ABI APInt ssub_ov(const APInt &RHS, bool &Overflow) const
@ NoAlias
The two locations do not alias at all.
@ MustAlias
The two locations precisely alias each other.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
Functions, function parameters, and return types can have attributes to indicate how they should be t...
LLVM_ABI uint64_t getValueAsInt() const
Return the attribute's value as an integer.
LLVM_ABI std::pair< unsigned, std::optional< unsigned > > getAllocSizeArgs() const
Returns the argument numbers for the allocsize attribute.
LLVM_ABI StringRef getValueAsString() const
Return the attribute's value as a string.
bool isValid() const
Return true if the attribute is any kind of attribute.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
LLVM_ABI const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
InstListType::iterator iterator
Instruction iterators...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Attribute getFnAttr(StringRef Kind) const
Get the attribute of a given kind for the function.
Value * getArgOperand(unsigned i) const
LLVM_ABI Value * getArgOperandWithAttribute(Attribute::AttrKind Kind) const
If one of the arguments has the specified attribute, returns its operand value.
unsigned arg_size() const
This is the shared class of boolean and integer constants.
const APInt & getValue() const
Return the constant as an APInt value reference.
A constant pointer value that points to null.
PointerType * getPointerType() const
Return the scalar pointer type for this null value.
This is an important base class in LLVM.
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
A parsed version of the target data layout string in and methods for querying it.
iterator find(const_arg_type_t< KeyT > Val)
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
const Constant * getAliasee() const
bool hasExternalWeakLinkage() const
Type * getValueType() const
LLVM_ABI bool isInterposable(bool CheckNoIPA=true) const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
bool hasInitializer() const
Definitions have initializers, declarations don't.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
LLVM_ABI uint64_t getGlobalSize(const DataLayout &DL) const
Get the size of this global variable in bytes.
Provides an 'InsertHelper' that calls a user-provided callback after performing the default insertion...
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
void visit(Iterator Start, Iterator End)
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
LLVM_ABI InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
This class represents a cast from an integer to a pointer.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
A Module instance is used to store all the information related to an LLVM module.
Evaluate the size and offset of an object pointed to by a Value*.
LLVM_ABI SizeOffsetValue visitExtractValueInst(ExtractValueInst &I)
LLVM_ABI SizeOffsetValue visitExtractElementInst(ExtractElementInst &I)
LLVM_ABI SizeOffsetValue compute(Value *V)
LLVM_ABI SizeOffsetValue visitInstruction(Instruction &I)
LLVM_ABI SizeOffsetValue visitLoadInst(LoadInst &I)
LLVM_ABI SizeOffsetValue visitGEPOperator(GEPOperator &GEP)
LLVM_ABI SizeOffsetValue visitIntToPtrInst(IntToPtrInst &)
LLVM_ABI SizeOffsetValue visitPHINode(PHINode &PHI)
LLVM_ABI SizeOffsetValue visitCallBase(CallBase &CB)
LLVM_ABI ObjectSizeOffsetEvaluator(Module &M, const TargetLibraryInfo *TLI, ObjectSizeOpts EvalOpts={})
LLVM_ABI SizeOffsetValue visitSelectInst(SelectInst &I)
LLVM_ABI SizeOffsetValue visitAllocaInst(AllocaInst &I)
static SizeOffsetValue unknown()
Evaluate the size and offset of an object pointed to by a Value* statically.
LLVM_ABI OffsetSpan visitSelectInst(SelectInst &I)
LLVM_ABI OffsetSpan visitExtractValueInst(ExtractValueInst &I)
LLVM_ABI OffsetSpan visitConstantPointerNull(ConstantPointerNull &)
LLVM_ABI OffsetSpan visitExtractElementInst(ExtractElementInst &I)
LLVM_ABI OffsetSpan visitGlobalVariable(GlobalVariable &GV)
LLVM_ABI OffsetSpan visitCallBase(CallBase &CB)
LLVM_ABI OffsetSpan visitIntToPtrInst(IntToPtrInst &)
LLVM_ABI OffsetSpan visitAllocaInst(AllocaInst &I)
LLVM_ABI ObjectSizeOffsetVisitor(const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context, ObjectSizeOpts Options={})
LLVM_ABI OffsetSpan visitLoadInst(LoadInst &I)
LLVM_ABI OffsetSpan visitPHINode(PHINode &)
LLVM_ABI OffsetSpan visitGlobalAlias(GlobalAlias &GA)
LLVM_ABI OffsetSpan visitInstruction(Instruction &I)
LLVM_ABI SizeOffsetAPInt compute(Value *V)
LLVM_ABI OffsetSpan visitUndefValue(UndefValue &)
LLVM_ABI OffsetSpan visitArgument(Argument &A)
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
op_range incoming_values()
LLVM_ABI Value * hasConstantValue() const
If the specified PHI node always merges together the same value, return the value,...
unsigned getNumIncomingValues() const
Return the number of incoming edges.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents the LLVM 'select' instruction.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
Represent a constant reference to a string, i.e.
TargetFolder - Create constants with target dependent folding.
Provides information about what library functions are available for the current target.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
static constexpr TypeSize getZero()
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
bool isSized() const
Return true if it makes sense to take the size of this type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isVoidTy() const
Return true if this is 'void'.
'undef' values are things that do not have specified contents.
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
LLVMContext & getContext() const
All values hold a context through their type.
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
An efficient, type-erasing, non-owning reference to a callable.
const ParentTy * getParent() const
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract Attribute helper functions.
initializer< Ty > init(const Ty &Val)
friend class Instruction
Iterator for Instructions in a `BasicBlock.
unsigned getOpcode(const VPValue *V)
Return the instruction opcode for the recipe defining V or 0 for unsupported recipes and VPValues not...
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI cl::opt< bool > ProfcheckDisableMetadataFixes
LLVM_ABI Constant * getInitialValueOfAllocation(const Value *V, const TargetLibraryInfo *TLI, Type *Ty)
If this is a call to an allocation function that initializes memory to a fixed value,...
@ Known
Known to have no common set bits.
@ Unknown
Not known to have no common set bits.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI)
Return true if this is a call to an allocation function that does not have side effects that we are r...
LLVM_ABI std::optional< StringRef > getAllocationFamily(const Value *I, const TargetLibraryInfo *TLI)
If a function is part of an allocation family (e.g.
@ Load
The value being inserted comes from a load (InsertElement only).
LLVM_ABI Value * lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL, const TargetLibraryInfo *TLI, bool MustSucceed)
Try to turn a call to @llvm.objectsize into an integer value of the given Type.
LLVM_ABI Value * getAllocAlignment(const CallBase *V, const TargetLibraryInfo *TLI)
Gets the alignment argument for an aligned_alloc-like function, using either built-in knowledge based...
constexpr bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
LLVM_ABI bool isLibFreeFunction(const Function *F, const LibFunc TLIFn)
isLibFreeFunction - Returns true if the function is a builtin free()
LLVM_ABI Value * getReallocatedOperand(const CallBase *CB)
If this is a call to a realloc function, return the reallocated operand.
LLVM_ABI std::optional< TypeSize > getBaseObjectSize(const Value *Ptr, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Like getObjectSize(), but only returns the size of base objects (like allocas, global variables and a...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
LLVM_ABI bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc,...
LLVM_ABI bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Compute the size of the object pointed by Ptr.
LLVM_ABI Value * emitGEPOffset(IRBuilderBase *Builder, const DataLayout &DL, User *GEP, bool NoAssumptions=false)
Given a getelementptr instruction/constantexpr, emit the code necessary to compute the offset from th...
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
LLVM_ABI uint64_t GetStringLength(const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI bool isReallocLikeFn(const Function *F)
Tests if a function is a call or invoke to a library function that reallocates memory (e....
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
LLVM_ABI Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
constexpr unsigned BitWidth
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
auto predecessors(const MachineBasicBlock *BB)
LLVM_ABI bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates or reallocates memory (eith...
LLVM_ABI std::optional< APInt > getAllocSize(const CallBase *CB, const TargetLibraryInfo *TLI, function_ref< const Value *(const Value *)> Mapper=[](const Value *V) { return V;})
Return the size of the requested allocation.
LLVM_ABI std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
This struct is a compact representation of a valid (non-zero power of two) alignment.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Various options to control the behavior of getObjectSize.
bool NullIsUnknownSize
If this is true, null pointers in address space 0 will be treated as though they can't be evaluated.
Mode EvalMode
How we want to evaluate this object's size.
AAResults * AA
If set, used for more accurate evaluation.
bool RoundToAlign
Whether to round the result up to the alignment of allocas, byval arguments, and global variables.
Mode
Controls how we handle conditional statements with unknown conditions.
@ ExactUnderlyingSizeAndOffset
All branches must be known and have the same underlying size and offset to be merged.
@ Max
Same as Min, except we pick the maximum size of all of the branches.
@ Min
Evaluate all branches of an unknown condition.
@ ExactSizeFromOffset
All branches must be known and have the same size, starting from the offset, to be merged.
OffsetSpan - Used internally by ObjectSizeOffsetVisitor.
APInt After
Number of allocated bytes before this point.
SizeOffsetAPInt - Used by ObjectSizeOffsetVisitor, which works with APInts.
SizeOffsetWeakTrackingVH - Used by ObjectSizeOffsetEvaluator in a DenseMap.