52#define DEBUG_TYPE "memory-builtins"
55 "object-size-offset-visitor-max-visit-instructions",
56 cl::desc(
"Maximum number of instructions for ObjectSizeOffsetVisitor to "
88 return "_ZnwmSt11align_val_t";
92 return "_ZnamSt11align_val_t";
94 return "??2@YAPAXI@Z";
96 return "??_U@YAPAXI@Z";
100 return "__kmpc_alloc_shared";
163 if (isa<IntrinsicInst>(V))
166 const auto *CB = dyn_cast<CallBase>(V);
170 IsNoBuiltin = CB->isNoBuiltin();
172 if (
const Function *Callee = CB->getCalledFunction())
179static std::optional<AllocFnsTy>
184 if (!Callee->getReturnType()->isPointerTy())
189 if (!TLI || !TLI->
getLibFunc(*Callee, TLIFn) || !TLI->
has(TLIFn))
194 return P.first == TLIFn;
209 if (FTy->getReturnType()->isPointerTy() &&
210 FTy->getNumParams() == FnData->
NumParams &&
212 (FTy->getParamType(FstParam)->isIntegerTy(32) ||
213 FTy->getParamType(FstParam)->isIntegerTy(64))) &&
215 FTy->getParamType(SndParam)->isIntegerTy(32) ||
216 FTy->getParamType(SndParam)->isIntegerTy(64)))
221static std::optional<AllocFnsTy>
224 bool IsNoBuiltinCall;
226 if (!IsNoBuiltinCall)
231static std::optional<AllocFnsTy>
234 bool IsNoBuiltinCall;
236 if (!IsNoBuiltinCall)
238 Callee, AllocTy, &GetTLI(
const_cast<Function &
>(*Callee)));
242static std::optional<AllocFnsTy>
244 bool IsNoBuiltinCall;
252 if (!IsNoBuiltinCall)
253 if (std::optional<AllocFnsTy> Data =
257 Attribute Attr = Callee->getFnAttribute(Attribute::AllocSize);
261 std::pair<unsigned, std::optional<unsigned>> Args = Attr.
getAllocSizeArgs();
267 Result.NumParams = Callee->getNumOperands();
268 Result.FstParam = Args.first;
269 Result.SndParam = Args.second.value_or(-1);
271 Result.AlignParam = -1;
276 if (
const auto *CB = dyn_cast<CallBase>(V)) {
277 Attribute Attr = CB->getFnAttr(Attribute::AllocKind);
281 return AllocFnKind::Unknown;
285 return F->getAttributes().getAllocKind();
356 if (FnData && FnData->AlignParam >= 0) {
357 return V->getOperand(FnData->AlignParam);
359 return V->getArgOperandWithAttribute(Attribute::AllocAlign);
371 if (
I.getBitWidth() > IntTyBits &&
I.getActiveBits() > IntTyBits)
373 if (
I.getBitWidth() != IntTyBits)
374 I =
I.zextOrTrunc(IntTyBits);
390 const unsigned IntTyBits =
DL.getIndexTypeSizeInBits(CB->
getType());
399 if (FnData->FstParam > 0) {
401 dyn_cast<ConstantInt>(Mapper(CB->
getArgOperand(FnData->FstParam)));
406 if (
Size.ugt(MaxSize))
413 dyn_cast<ConstantInt>(Mapper(CB->
getArgOperand(FnData->FstParam)));
422 if (FnData->SndParam < 0)
425 Arg = dyn_cast<ConstantInt>(Mapper(CB->
getArgOperand(FnData->SndParam)));
434 Size =
Size.umul_ov(NumElems, Overflow);
443 auto *Alloc = dyn_cast<CallBase>(V);
452 if ((AK & AllocFnKind::Uninitialized) != AllocFnKind::Unknown)
454 if ((AK & AllocFnKind::Zeroed) != AllocFnKind::Unknown)
504 return P.first == TLIFn;
511std::optional<StringRef>
515 if (Callee ==
nullptr || IsNoBuiltin)
519 if (TLI && TLI->
getLibFunc(*Callee, TLIFn) && TLI->
has(TLIFn)) {
530 AllocFnKind::Realloc)) {
531 Attribute Attr = cast<CallBase>(
I)->getFnAttr(
"alloc-family");
559 bool IsNoBuiltinCall;
561 if (Callee ==
nullptr || IsNoBuiltinCall)
565 if (TLI && TLI->
getLibFunc(*Callee, TLIFn) && TLI->
has(TLIFn) &&
596 if (!Data.bothKnown())
616 "ObjectSize must be a call to llvm.objectsize!");
618 bool MaxVal = cast<ConstantInt>(ObjectSize->
getArgOperand(1))->isZero();
626 MaxVal ? ObjectSizeOpts::Mode::Max : ObjectSizeOpts::Mode::Min;
628 EvalOptions.
EvalMode = ObjectSizeOpts::Mode::ExactSizeFromOffset;
633 auto *ResultType = cast<IntegerType>(ObjectSize->
getType());
634 bool StaticOnly = cast<ConstantInt>(ObjectSize->
getArgOperand(3))->isZero();
641 return ConstantInt::get(ResultType,
Size);
650 if (InsertedInstructions)
664 UseZero, ConstantInt::get(ResultType, 0), ResultSize);
667 if (!isa<Constant>(
Size) || !isa<Constant>(
Offset))
669 Builder.
CreateICmpNE(Ret, ConstantInt::get(ResultType, -1)));
678 return ConstantInt::get(ResultType, MaxVal ? -1ULL : 0);
682 "Number of arguments with unsolved size and offset");
684 "Number of load instructions with unsolved size and offset");
702 InstructionsVisited = 0;
703 return computeImpl(V);
715 V = V->stripAndAccumulateConstantOffsets(
725 bool IndexTypeSizeChanged = InitialIntTyBits != IntTyBits;
726 if (!IndexTypeSizeChanged &&
Offset.isZero())
732 if (IndexTypeSizeChanged) {
733 if (SOT.
knownSize() && !::CheckedZextOrTrunc(SOT.
Size, InitialIntTyBits))
736 !::CheckedZextOrTrunc(SOT.
Offset, InitialIntTyBits))
748 auto P = SeenInsts.try_emplace(
I, ObjectSizeOffsetVisitor::unknown());
750 return P.first->second;
751 ++InstructionsVisited;
753 return ObjectSizeOffsetVisitor::unknown();
771 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetVisitor::compute() unhandled value: "
773 return ObjectSizeOffsetVisitor::unknown();
776bool ObjectSizeOffsetVisitor::CheckedZextOrTrunc(
APInt &
I) {
777 return ::CheckedZextOrTrunc(
I, IntTyBits);
783 return ObjectSizeOffsetVisitor::unknown();
785 if (!
I.isArrayAllocation())
788 Value *ArraySize =
I.getArraySize();
789 if (
const ConstantInt *
C = dyn_cast<ConstantInt>(ArraySize)) {
790 APInt NumElems =
C->getValue();
791 if (!CheckedZextOrTrunc(NumElems))
792 return ObjectSizeOffsetVisitor::unknown();
795 Size =
Size.umul_ov(NumElems, Overflow);
796 return Overflow ? ObjectSizeOffsetVisitor::unknown()
799 return ObjectSizeOffsetVisitor::unknown();
803 Type *MemoryTy =
A.getPointeeInMemoryValueType();
805 if (!MemoryTy|| !MemoryTy->
isSized()) {
806 ++ObjectVisitorArgument;
807 return ObjectSizeOffsetVisitor::unknown();
817 return ObjectSizeOffsetVisitor::unknown();
830 return ObjectSizeOffsetVisitor::unknown();
836 return ObjectSizeOffsetVisitor::unknown();
842 return ObjectSizeOffsetVisitor::unknown();
847 return ObjectSizeOffsetVisitor::unknown();
856 return ObjectSizeOffsetVisitor::unknown();
864 return ObjectSizeOffsetVisitor::unknown();
870 unsigned &ScannedInstCount) {
871 constexpr unsigned MaxInstsToScan = 128;
873 auto Where = VisitedBlocks.
find(&BB);
874 if (Where != VisitedBlocks.
end())
875 return Where->second;
877 auto Unknown = [&BB, &VisitedBlocks]() {
878 return VisitedBlocks[&BB] = ObjectSizeOffsetVisitor::unknown();
881 return VisitedBlocks[&BB] = SO;
887 if (
I.isDebugOrPseudoInst())
890 if (++ScannedInstCount > MaxInstsToScan)
893 if (!
I.mayWriteToMemory())
896 if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
898 Options.
AA->
alias(
SI->getPointerOperand(),
Load.getPointerOperand());
903 if (
SI->getValueOperand()->getType()->isPointerTy())
904 return Known(computeImpl(
SI->getValueOperand()));
912 if (
auto *CB = dyn_cast<CallBase>(&
I)) {
924 if (TLIFn != LibFunc_posix_memalign)
943 if (!Checked || !*Checked)
947 auto *
C = dyn_cast<ConstantInt>(
Size);
951 return Known({
C->getValue(),
APInt(
C->getValue().getBitWidth(), 0)});
959 PredecessorSizeOffsets.
push_back(findLoadSizeOffset(
961 VisitedBlocks, ScannedInstCount));
962 if (!PredecessorSizeOffsets.
back().bothKnown())
966 if (PredecessorSizeOffsets.
empty())
969 return Known(std::accumulate(
970 PredecessorSizeOffsets.
begin() + 1, PredecessorSizeOffsets.
end(),
971 PredecessorSizeOffsets.
front(),
973 return combineSizeOffset(LHS, RHS);
980 return ObjectSizeOffsetVisitor::unknown();
984 unsigned ScannedInstCount = 0;
987 VisitedBlocks, ScannedInstCount);
996 if (!
LHS.bothKnown() || !
RHS.bothKnown())
997 return ObjectSizeOffsetVisitor::unknown();
1007 : ObjectSizeOffsetVisitor::unknown();
1009 return LHS ==
RHS ?
LHS : ObjectSizeOffsetVisitor::unknown();
1016 return ObjectSizeOffsetVisitor::unknown();
1018 return std::accumulate(IncomingValues.begin() + 1, IncomingValues.end(),
1019 computeImpl(*IncomingValues.begin()),
1021 return combineSizeOffset(LHS, computeImpl(VRHS));
1026 return combineSizeOffset(computeImpl(
I.getTrueValue()),
1027 computeImpl(
I.getFalseValue()));
1035 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetVisitor unknown instruction:" <<
I
1037 return ObjectSizeOffsetVisitor::unknown();
1051 EvalOpts(EvalOpts) {
1058 IntTy = cast<IntegerType>(DL.
getIndexType(V->getType()));
1059 Zero = ConstantInt::get(IntTy, 0);
1063 if (!Result.bothKnown()) {
1067 for (
const Value *SeenVal : SeenVals) {
1070 if (CacheIt != CacheMap.
end() && CacheIt->second.anyKnown())
1071 CacheMap.
erase(CacheIt);
1077 I->eraseFromParent();
1082 InsertedInstructions.clear();
1089 if (Const.bothKnown())
1091 ConstantInt::get(Context, Const.Offset));
1093 V = V->stripPointerCasts();
1097 if (CacheIt != CacheMap.
end())
1098 return CacheIt->second;
1112 if (!SeenVals.
insert(V).second) {
1116 }
else if (
Instruction *
I = dyn_cast<Instruction>(V)) {
1118 }
else if (isa<Argument>(V) ||
1119 (isa<ConstantExpr>(V) &&
1120 cast<ConstantExpr>(V)->
getOpcode() == Instruction::IntToPtr) ||
1121 isa<GlobalAlias>(V) ||
1122 isa<GlobalVariable>(V)) {
1127 dbgs() <<
"ObjectSizeOffsetEvaluator::compute() unhandled value: " << *V
1138 if (!
I.getAllocatedType()->isSized())
1142 assert(
I.isArrayAllocation());
1150 "Expected zero constant to have pointer index type");
1171 if (FnData->SndParam < 0)
1218 for (
unsigned i = 0, e =
PHI.getNumIncomingValues(); i != e; ++i) {
1226 InsertedInstructions.erase(OffsetPHI);
1229 InsertedInstructions.erase(SizePHI);
1241 InsertedInstructions.erase(SizePHI);
1247 InsertedInstructions.erase(OffsetPHI);
1258 if (TrueSide == FalseSide)
1269 LLVM_DEBUG(
dbgs() <<
"ObjectSizeOffsetEvaluator unknown instruction:" <<
I
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file implements a class to represent arbitrary precision integral constant values and operations...
This file contains the simple types necessary to represent the attributes associated with functions a...
BlockVerifier::State From
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...
static AllocFnKind getAllocFnKind(const Value *V)
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)
std::optional< FreeFnsTy > getFreeFunctionDataForFunction(const Function *Callee, const LibFunc TLIFn)
static std::optional< AllocFnsTy > getAllocationSize(const Value *V, const TargetLibraryInfo *TLI)
static bool checkFnAllocKind(const Value *V, AllocFnKind Wanted)
StringRef mangledNameForMallocFamily(const MallocFamily &Family)
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 const std::pair< LibFunc, FreeFnsTy > FreeFnData[]
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 const std::pair< LibFunc, AllocFnsTy > AllocationFnData[]
static const Function * getCalledFunction(const Value *V, bool &IsNoBuiltin)
static APInt getSizeWithOverflow(const SizeOffsetAPInt &Data)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
The main low level interface to the alias analysis implementation.
Class for arbitrary precision integers.
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.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
The possible results of an alias query.
@ 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.
uint64_t getValueAsInt() const
Return the attribute's value as an integer.
std::pair< unsigned, std::optional< unsigned > > getAllocSizeArgs() const
Returns the argument numbers for the allocsize attribute.
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.
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...
Value * getArgOperand(unsigned i) const
Value * getArgOperandWithAttribute(Attribute::AttrKind Kind) const
If one of the arguments has the specified attribute, returns its operand value.
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 * getType() const
Specialize the getType() method to always return an PointerType, which reduces the amount of casting ...
This is an important base class in LLVM.
static 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.
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
unsigned getAllocaAddrSpace() const
IntegerType * getIndexType(LLVMContext &C, unsigned AddressSpace) const
Returns the type of a GEP index in AddressSpace.
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
iterator find(const_arg_type_t< KeyT > Val)
bool erase(const KeyT &Val)
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
Class to represent function types.
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Type * getParamType(unsigned i) const
Parameter type accessors.
Type * getReturnType() const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
const Constant * getAliasee() const
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
bool hasExternalWeakLinkage() const
bool isInterposable() const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
Type * getValueType() const
bool hasInitializer() const
Definitions have initializers, declarations don't.
Value * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
CallInst * CreateAssumption(Value *Cond, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Create an assume intrinsic call that allows the optimizer to assume that the provided condition will ...
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
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)
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
const BasicBlock * getParent() const
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
const Function * getFunction() const
Return the function 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.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Evaluate the size and offset of an object pointed to by a Value*.
SizeOffsetValue visitExtractValueInst(ExtractValueInst &I)
SizeOffsetValue visitExtractElementInst(ExtractElementInst &I)
SizeOffsetValue compute(Value *V)
SizeOffsetValue visitInstruction(Instruction &I)
ObjectSizeOffsetEvaluator(const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context, ObjectSizeOpts EvalOpts={})
SizeOffsetValue visitLoadInst(LoadInst &I)
SizeOffsetValue visitGEPOperator(GEPOperator &GEP)
SizeOffsetValue visitIntToPtrInst(IntToPtrInst &)
SizeOffsetValue visitPHINode(PHINode &PHI)
SizeOffsetValue visitCallBase(CallBase &CB)
SizeOffsetValue visitSelectInst(SelectInst &I)
SizeOffsetValue visitAllocaInst(AllocaInst &I)
static SizeOffsetValue unknown()
Evaluate the size and offset of an object pointed to by a Value* statically.
SizeOffsetAPInt visitLoadInst(LoadInst &I)
SizeOffsetAPInt visitConstantPointerNull(ConstantPointerNull &)
SizeOffsetAPInt visitCallBase(CallBase &CB)
SizeOffsetAPInt visitInstruction(Instruction &I)
ObjectSizeOffsetVisitor(const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context, ObjectSizeOpts Options={})
SizeOffsetAPInt visitGlobalAlias(GlobalAlias &GA)
SizeOffsetAPInt visitIntToPtrInst(IntToPtrInst &)
SizeOffsetAPInt visitExtractElementInst(ExtractElementInst &I)
SizeOffsetAPInt compute(Value *V)
SizeOffsetAPInt visitExtractValueInst(ExtractValueInst &I)
SizeOffsetAPInt visitUndefValue(UndefValue &)
SizeOffsetAPInt visitPHINode(PHINode &)
SizeOffsetAPInt visitArgument(Argument &A)
SizeOffsetAPInt visitGlobalVariable(GlobalVariable &GV)
SizeOffsetAPInt visitSelectInst(SelectInst &I)
SizeOffsetAPInt visitAllocaInst(AllocaInst &I)
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
op_range incoming_values()
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 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)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - 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.
bool has(LibFunc F) const
Tests whether a library function is available.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
bool isVoidTy() const
Return true if this is 'void'.
'undef' values are things that do not have specified contents.
static 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.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
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.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
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,...
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
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...
std::optional< StringRef > getAllocationFamily(const Value *I, const TargetLibraryInfo *TLI)
If a function is part of an allocation family (e.g.
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.
Value * getAllocAlignment(const CallBase *V, const TargetLibraryInfo *TLI)
Gets the alignment argument for an aligned_alloc-like function, using either built-in knowledge based...
bool isLibFreeFunction(const Function *F, const LibFunc TLIFn)
isLibFreeFunction - Returns true if the function is a builtin free()
Value * getReallocatedOperand(const CallBase *CB)
If this is a call to a realloc function, return the reallocated operand.
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,...
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.
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...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
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'.
bool isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates memory similar to malloc or...
bool isReallocLikeFn(const Function *F)
Tests if a function is a call or invoke to a library function that reallocates memory (e....
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
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)
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...
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.
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...
bool isNewLikeFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates memory via new.
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.
@ 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.
SizeOffsetAPInt - Used by ObjectSizeOffsetVisitor, which works with APInts.
SizeOffsetType - A base template class for the object size visitors.
SizeOffsetWeakTrackingVH - Used by ObjectSizeOffsetEvaluator in a DenseMap.