LLVM 19.0.0git
MemoryBuiltins.h
Go to the documentation of this file.
1//==- llvm/Analysis/MemoryBuiltins.h - Calls to memory builtins --*- 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 family of functions identifies calls to builtin functions that allocate
10// or free memory.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ANALYSIS_MEMORYBUILTINS_H
15#define LLVM_ANALYSIS_MEMORYBUILTINS_H
16
17#include "llvm/ADT/APInt.h"
18#include "llvm/ADT/DenseMap.h"
22#include "llvm/IR/IRBuilder.h"
23#include "llvm/IR/InstVisitor.h"
24#include "llvm/IR/ValueHandle.h"
25#include <cstdint>
26#include <optional>
27#include <utility>
28
29namespace llvm {
30
31class AllocaInst;
32class AAResults;
33class Argument;
34class ConstantPointerNull;
35class DataLayout;
36class ExtractElementInst;
37class ExtractValueInst;
38class GEPOperator;
39class GlobalAlias;
40class GlobalVariable;
41class Instruction;
42class IntegerType;
43class IntrinsicInst;
44class IntToPtrInst;
45class LLVMContext;
46class LoadInst;
47class PHINode;
48class SelectInst;
49class Type;
50class UndefValue;
51class Value;
52
53/// Tests if a value is a call or invoke to a library function that
54/// allocates or reallocates memory (either malloc, calloc, realloc, or strdup
55/// like).
56bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI);
57bool isAllocationFn(const Value *V,
58 function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
59
60/// Tests if a value is a call or invoke to a library function that
61/// allocates memory via new.
62bool isNewLikeFn(const Value *V, const TargetLibraryInfo *TLI);
63
64/// Tests if a value is a call or invoke to a library function that
65/// allocates memory similar to malloc or calloc.
66bool isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI);
67
68/// Tests if a value is a call or invoke to a library function that
69/// allocates memory (either malloc, calloc, or strdup like).
70bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI);
71
72/// Tests if a function is a call or invoke to a library function that
73/// reallocates memory (e.g., realloc).
74bool isReallocLikeFn(const Function *F);
75
76/// If this is a call to a realloc function, return the reallocated operand.
77Value *getReallocatedOperand(const CallBase *CB);
78
79//===----------------------------------------------------------------------===//
80// free Call Utility Functions.
81//
82
83/// isLibFreeFunction - Returns true if the function is a builtin free()
84bool isLibFreeFunction(const Function *F, const LibFunc TLIFn);
85
86/// If this if a call to a free function, return the freed operand.
87Value *getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI);
88
89//===----------------------------------------------------------------------===//
90// Properties of allocation functions
91//
92
93/// Return true if this is a call to an allocation function that does not have
94/// side effects that we are required to preserve beyond the effect of
95/// allocating a new object.
96/// Ex: If our allocation routine has a counter for the number of objects
97/// allocated, and the program prints it on exit, can the value change due
98/// to optimization? Answer is highly language dependent.
99/// Note: *Removable* really does mean removable; it does not mean observable.
100/// A language (e.g. C++) can allow removing allocations without allowing
101/// insertion or speculative execution of allocation routines.
102bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI);
103
104/// Gets the alignment argument for an aligned_alloc-like function, using either
105/// built-in knowledge based on fuction names/signatures or allocalign
106/// attributes. Note: the Value returned may not indicate a valid alignment, per
107/// the definition of the allocalign attribute.
108Value *getAllocAlignment(const CallBase *V, const TargetLibraryInfo *TLI);
109
110/// Return the size of the requested allocation. With a trivial mapper, this is
111/// similar to calling getObjectSize(..., Exact), but without looking through
112/// calls that return their argument. A mapper function can be used to replace
113/// one Value* (operand to the allocation) with another. This is useful when
114/// doing abstract interpretation.
115std::optional<APInt> getAllocSize(
116 const CallBase *CB, const TargetLibraryInfo *TLI,
117 function_ref<const Value *(const Value *)> Mapper = [](const Value *V) {
118 return V;
119 });
120
121/// If this is a call to an allocation function that initializes memory to a
122/// fixed value, return said value in the requested type. Otherwise, return
123/// nullptr.
125 const TargetLibraryInfo *TLI,
126 Type *Ty);
127
128/// If a function is part of an allocation family (e.g.
129/// malloc/realloc/calloc/free), return the identifier for its family
130/// of functions.
131std::optional<StringRef> getAllocationFamily(const Value *I,
132 const TargetLibraryInfo *TLI);
133
134//===----------------------------------------------------------------------===//
135// Utility functions to compute size of objects.
136//
137
138/// Various options to control the behavior of getObjectSize.
140 /// Controls how we handle conditional statements with unknown conditions.
141 enum class Mode : uint8_t {
142 /// All branches must be known and have the same size, starting from the
143 /// offset, to be merged.
145 /// All branches must be known and have the same underlying size and offset
146 /// to be merged.
148 /// Evaluate all branches of an unknown condition. If all evaluations
149 /// succeed, pick the minimum size.
150 Min,
151 /// Same as Min, except we pick the maximum size of all of the branches.
152 Max,
153 };
154
155 /// How we want to evaluate this object's size.
157 /// Whether to round the result up to the alignment of allocas, byval
158 /// arguments, and global variables.
159 bool RoundToAlign = false;
160 /// If this is true, null pointers in address space 0 will be treated as
161 /// though they can't be evaluated. Otherwise, null is always considered to
162 /// point to a 0 byte region of memory.
163 bool NullIsUnknownSize = false;
164 /// If set, used for more accurate evaluation
165 AAResults *AA = nullptr;
166};
167
168/// Compute the size of the object pointed by Ptr. Returns true and the
169/// object size in Size if successful, and false otherwise. In this context, by
170/// object we mean the region of memory starting at Ptr to the end of the
171/// underlying object pointed to by Ptr.
172///
173/// WARNING: The object size returned is the allocation size. This does not
174/// imply dereferenceability at site of use since the object may be freeed in
175/// between.
176bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
177 const TargetLibraryInfo *TLI, ObjectSizeOpts Opts = {});
178
179/// Try to turn a call to \@llvm.objectsize into an integer value of the given
180/// Type. Returns null on failure. If MustSucceed is true, this function will
181/// not return null, and may return conservative values governed by the second
182/// argument of the call to objectsize.
183Value *lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL,
184 const TargetLibraryInfo *TLI, bool MustSucceed);
186 IntrinsicInst *ObjectSize, const DataLayout &DL,
187 const TargetLibraryInfo *TLI, AAResults *AA, bool MustSucceed,
188 SmallVectorImpl<Instruction *> *InsertedInstructions = nullptr);
189
190/// SizeOffsetType - A base template class for the object size visitors. Used
191/// here as a self-documenting way to handle the values rather than using a
192/// \p std::pair.
193template <typename T, class C> struct SizeOffsetType {
194public:
197
198 SizeOffsetType() = default;
200
201 bool knownSize() const { return C::known(Size); }
202 bool knownOffset() const { return C::known(Offset); }
203 bool anyKnown() const { return knownSize() || knownOffset(); }
204 bool bothKnown() const { return knownSize() && knownOffset(); }
205
207 return Size == RHS.Size && Offset == RHS.Offset;
208 }
210 return !(*this == RHS);
211 }
212};
213
214/// SizeOffsetAPInt - Used by \p ObjectSizeOffsetVisitor, which works with
215/// \p APInts.
216struct SizeOffsetAPInt : public SizeOffsetType<APInt, SizeOffsetAPInt> {
217 SizeOffsetAPInt() = default;
219
220 static bool known(APInt V) { return V.getBitWidth() > 1; }
221};
222
223/// Evaluate the size and offset of an object pointed to by a Value*
224/// statically. Fails if size or offset are not known at compile time.
226 : public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetAPInt> {
227 const DataLayout &DL;
228 const TargetLibraryInfo *TLI;
229 ObjectSizeOpts Options;
230 unsigned IntTyBits;
231 APInt Zero;
233 unsigned InstructionsVisited;
234
236
237 static SizeOffsetAPInt unknown() { return SizeOffsetAPInt(); }
238
239public:
242
244
245 // These are "private", except they can't actually be made private. Only
246 // compute() should be used by external users.
261
262private:
263 SizeOffsetAPInt findLoadSizeOffset(
266 unsigned &ScannedInstCount);
268 SizeOffsetAPInt computeImpl(Value *V);
269 SizeOffsetAPInt computeValue(Value *V);
270 bool CheckedZextOrTrunc(APInt &I);
271};
272
273/// SizeOffsetValue - Used by \p ObjectSizeOffsetEvaluator, which works with
274/// \p Values.
276struct SizeOffsetValue : public SizeOffsetType<Value *, SizeOffsetValue> {
277 SizeOffsetValue() : SizeOffsetType(nullptr, nullptr) {}
280
281 static bool known(Value *V) { return V != nullptr; }
282};
283
284/// SizeOffsetWeakTrackingVH - Used by \p ObjectSizeOffsetEvaluator in a
285/// \p DenseMap.
287 : public SizeOffsetType<WeakTrackingVH, SizeOffsetWeakTrackingVH> {
292 : SizeOffsetType(SOV.Size, SOV.Offset) {}
293
294 static bool known(WeakTrackingVH V) { return V.pointsToAliveValue(); }
295};
296
297/// Evaluate the size and offset of an object pointed to by a Value*.
298/// May create code to compute the result at run-time.
300 : public InstVisitor<ObjectSizeOffsetEvaluator, SizeOffsetValue> {
305
306 const DataLayout &DL;
307 const TargetLibraryInfo *TLI;
308 LLVMContext &Context;
309 BuilderTy Builder;
310 IntegerType *IntTy;
311 Value *Zero;
312 CacheMapTy CacheMap;
313 PtrSetTy SeenVals;
314 ObjectSizeOpts EvalOpts;
315 SmallPtrSet<Instruction *, 8> InsertedInstructions;
316
317 SizeOffsetValue compute_(Value *V);
318
319public:
321 LLVMContext &Context, ObjectSizeOpts EvalOpts = {});
322
324
326
327 // The individual instruction visitors should be treated as private.
338};
339
340} // end namespace llvm
341
342#endif // LLVM_ANALYSIS_MEMORYBUILTINS_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Rewrite undef for PHI
This file implements a class to represent arbitrary precision integral constant values and operations...
BlockVerifier::State From
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
RelocType Type
Definition: COFFYAML.cpp:391
This file defines the DenseMap class.
uint64_t Size
Hexagon Common GEP
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
LLVMContext & Context
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
This file defines the SmallPtrSet class.
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:76
an instruction to allocate memory on the stack
Definition: Instructions.h:59
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:173
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1259
A constant pointer value that points to null.
Definition: Constants.h:533
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
This instruction extracts a single (scalar) element from a VectorType value.
This instruction extracts a struct member or array element value from an aggregate value.
Base class for instruction visitors.
Definition: InstVisitor.h:78
This class represents a cast from an integer to a pointer.
Class to represent integer types.
Definition: DerivedTypes.h:40
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
An instruction for reading from memory.
Definition: Instructions.h:178
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)
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)
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)
This class represents the LLVM 'select' instruction.
Provides information about what library functions are available for the current target.
'undef' values are things that do not have specified contents.
Definition: Constants.h:1336
LLVM Value Representation.
Definition: Value.h:74
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:204
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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 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.
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....
Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
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.
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 (non-zero power of two) alignment.
Definition: Alignment.h:39
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
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.
SizeOffsetAPInt - Used by ObjectSizeOffsetVisitor, which works with APInts.
static bool known(APInt V)
SizeOffsetAPInt(APInt Size, APInt Offset)
SizeOffsetType - A base template class for the object size visitors.
bool operator!=(const SizeOffsetType< T, C > &RHS) const
bool operator==(const SizeOffsetType< T, C > &RHS) const
SizeOffsetType()=default
SizeOffsetType(T Size, T Offset)
bool knownOffset() const
bool knownSize() const
bool bothKnown() const
SizeOffsetValue(Value *Size, Value *Offset)
static bool known(Value *V)
SizeOffsetWeakTrackingVH - Used by ObjectSizeOffsetEvaluator in a DenseMap.
SizeOffsetWeakTrackingVH(const SizeOffsetValue &SOV)
static bool known(WeakTrackingVH V)
SizeOffsetWeakTrackingVH(Value *Size, Value *Offset)