51#define DEBUG_TYPE "memprof"
73 "__memprof_version_mismatch_check_v";
76 "__memprof_shadow_memory_dynamic_address";
85 "memprof-guard-against-version-mismatch",
91 cl::desc(
"instrument read instructions"),
100 "memprof-instrument-atomics",
105 "memprof-use-callbacks",
106 cl::desc(
"Use callbacks instead of inline instrumentation sequences."),
111 cl::desc(
"Prefix for memory access callbacks"),
119 cl::desc(
"scale of memprof shadow mapping"),
124 cl::desc(
"granularity of memprof shadow mapping"),
128 cl::desc(
"Instrument scalar stack variables"),
149 "memprof-match-hot-cold-new",
151 "Match allocation profiles onto existing hot/cold operator new calls"),
155 cl::desc(
"Collect access count histograms"),
160 cl::desc(
"Print matching stats for each allocation "
161 "context in this module's profiles"),
167STATISTIC(NumInstrumentedReads,
"Number of instrumented reads");
168STATISTIC(NumInstrumentedWrites,
"Number of instrumented writes");
169STATISTIC(NumSkippedStackReads,
"Number of non-instrumented stack reads");
170STATISTIC(NumSkippedStackWrites,
"Number of non-instrumented stack writes");
173STATISTIC(NumOfMemProfMissing,
"Number of functions without memory profile.");
175 "Number of functions having mismatched memory profile hash.");
176STATISTIC(NumOfMemProfFunc,
"Number of functions having valid memory profile.");
178 "Number of alloc contexts in memory profile.");
180 "Number of callsites in memory profile.");
182 "Number of matched memory profile alloc contexts.");
184 "Number of matched memory profile allocs.");
186 "Number of matched memory profile callsites.");
192struct ShadowMapping {
196 Mask = ~(Granularity - 1);
209struct InterestingMemoryAccess {
213 Value *MaybeMask =
nullptr;
220 C = &(
M.getContext());
221 LongSize =
M.getDataLayout().getPointerSizeInBits();
223 PtrTy = PointerType::getUnqual(*C);
229 std::optional<InterestingMemoryAccess>
233 InterestingMemoryAccess &Access);
242 bool maybeInsertMemProfInitAtFunctionEntry(
Function &
F);
243 bool insertDynamicShadowAtFunctionEntry(
Function &
F);
246 void initializeCallbacks(
Module &M);
252 ShadowMapping Mapping;
258 Value *DynamicShadowOffset =
nullptr;
261class ModuleMemProfiler {
263 ModuleMemProfiler(
Module &M) { TargetTriple =
Triple(
M.getTargetTriple()); }
265 bool instrumentModule(
Module &);
269 ShadowMapping Mapping;
270 Function *MemProfCtorFunction =
nullptr;
280 MemProfiler Profiler(M);
281 if (Profiler.instrumentFunction(
F))
292 "Cannot use -memprof-histogram without Callbacks. Set "
293 "memprof-use-callbacks");
295 ModuleMemProfiler Profiler(M);
296 if (Profiler.instrumentModule(M))
303 Shadow = IRB.
CreateAnd(Shadow, Mapping.Mask);
304 Shadow = IRB.
CreateLShr(Shadow, Mapping.Scale);
306 assert(DynamicShadowOffset);
307 return IRB.
CreateAdd(Shadow, DynamicShadowOffset);
313 if (isa<MemTransferInst>(
MI)) {
314 IRB.
CreateCall(isa<MemMoveInst>(
MI) ? MemProfMemmove : MemProfMemcpy,
315 {
MI->getOperand(0),
MI->getOperand(1),
317 }
else if (isa<MemSetInst>(
MI)) {
324 MI->eraseFromParent();
327std::optional<InterestingMemoryAccess>
328MemProfiler::isInterestingMemoryAccess(
Instruction *
I)
const {
330 if (DynamicShadowOffset ==
I)
333 InterestingMemoryAccess Access;
335 if (
LoadInst *LI = dyn_cast<LoadInst>(
I)) {
338 Access.IsWrite =
false;
339 Access.AccessTy = LI->getType();
340 Access.Addr = LI->getPointerOperand();
341 }
else if (
StoreInst *SI = dyn_cast<StoreInst>(
I)) {
344 Access.IsWrite =
true;
345 Access.AccessTy =
SI->getValueOperand()->getType();
346 Access.Addr =
SI->getPointerOperand();
350 Access.IsWrite =
true;
351 Access.AccessTy = RMW->getValOperand()->getType();
352 Access.Addr = RMW->getPointerOperand();
356 Access.IsWrite =
true;
357 Access.AccessTy = XCHG->getCompareOperand()->getType();
358 Access.Addr = XCHG->getPointerOperand();
359 }
else if (
auto *CI = dyn_cast<CallInst>(
I)) {
360 auto *
F = CI->getCalledFunction();
361 if (
F && (
F->getIntrinsicID() == Intrinsic::masked_load ||
362 F->getIntrinsicID() == Intrinsic::masked_store)) {
363 unsigned OpOffset = 0;
364 if (
F->getIntrinsicID() == Intrinsic::masked_store) {
369 Access.AccessTy = CI->getArgOperand(0)->getType();
370 Access.IsWrite =
true;
374 Access.AccessTy = CI->getType();
375 Access.IsWrite =
false;
378 auto *
BasePtr = CI->getOperand(0 + OpOffset);
379 Access.MaybeMask = CI->getOperand(2 + OpOffset);
389 Type *PtrTy = cast<PointerType>(Access.Addr->getType()->getScalarType());
397 if (Access.Addr->isSwiftError())
401 auto *
Addr = Access.Addr->stripInBoundsOffsets();
405 if (GV->hasSection()) {
415 if (GV->getName().starts_with(
"__llvm"))
424 Type *AccessTy,
bool IsWrite) {
425 auto *VTy = cast<FixedVectorType>(AccessTy);
426 unsigned Num = VTy->getNumElements();
427 auto *
Zero = ConstantInt::get(IntptrTy, 0);
428 for (
unsigned Idx = 0;
Idx < Num; ++
Idx) {
429 Value *InstrumentedAddress =
nullptr;
431 if (
auto *
Vector = dyn_cast<ConstantVector>(Mask)) {
444 InsertBefore = ThenTerm;
448 InstrumentedAddress =
450 instrumentAddress(
I, InsertBefore, InstrumentedAddress, IsWrite);
455 InterestingMemoryAccess &Access) {
459 ++NumSkippedStackWrites;
461 ++NumSkippedStackReads;
466 NumInstrumentedWrites++;
468 NumInstrumentedReads++;
470 if (Access.MaybeMask) {
471 instrumentMaskedLoadOrStore(
DL, Access.MaybeMask,
I, Access.Addr,
472 Access.AccessTy, Access.IsWrite);
477 instrumentAddress(
I,
I, Access.Addr, Access.IsWrite);
481void MemProfiler::instrumentAddress(
Instruction *OrigIns,
488 IRB.
CreateCall(MemProfMemoryAccessCallback[IsWrite], AddrLong);
496 Value *ShadowPtr = memToShadow(AddrLong, IRB);
500 ShadowValue = IRB.
CreateAdd(ShadowValue, Inc);
507 dyn_cast_or_null<MDString>(M.getModuleFlag(
"MemProfProfileFilename"));
508 if (!MemProfFilename)
511 "Unexpected MemProfProfileFilename metadata with empty string");
513 M.getContext(), MemProfFilename->
getString(),
true);
515 M, ProfileNameConst->
getType(),
true,
517 Triple TT(M.getTargetTriple());
518 if (TT.supportsCOMDAT()) {
532 Triple TT(M.getTargetTriple());
533 if (TT.supportsCOMDAT()) {
535 MemprofHistogramFlag->setComdat(M.getOrInsertComdat(VarName));
540bool ModuleMemProfiler::instrumentModule(
Module &M) {
544 std::string VersionCheckName =
547 std::tie(MemProfCtorFunction, std::ignore) =
550 {}, VersionCheckName);
552 const uint64_t Priority = getCtorAndDtorPriority(TargetTriple);
562void MemProfiler::initializeCallbacks(
Module &M) {
565 for (
size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
566 const std::string TypeStr = AccessIsWrite ?
"store" :
"load";
567 const std::string HistPrefix =
ClHistogram ?
"hist_" :
"";
570 MemProfMemoryAccessCallback[AccessIsWrite] =
M.getOrInsertFunction(
574 MemProfMemmove =
M.getOrInsertFunction(
577 PtrTy, PtrTy, PtrTy, IntptrTy);
583bool MemProfiler::maybeInsertMemProfInitAtFunctionEntry(
Function &
F) {
591 if (
F.getName().contains(
" load]")) {
601bool MemProfiler::insertDynamicShadowAtFunctionEntry(
Function &
F) {
603 Value *GlobalDynamicAddress =
F.getParent()->getOrInsertGlobal(
606 cast<GlobalVariable>(GlobalDynamicAddress)->setDSOLocal(
true);
607 DynamicShadowOffset = IRB.
CreateLoad(IntptrTy, GlobalDynamicAddress);
611bool MemProfiler::instrumentFunction(
Function &
F) {
616 if (
F.getName().starts_with(
"__memprof_"))
619 bool FunctionModified =
false;
624 if (maybeInsertMemProfInitAtFunctionEntry(
F))
625 FunctionModified =
true;
629 initializeCallbacks(*
F.getParent());
635 for (
auto &Inst : BB) {
636 if (isInterestingMemoryAccess(&Inst) || isa<MemIntrinsic>(Inst))
641 if (ToInstrument.
empty()) {
642 LLVM_DEBUG(
dbgs() <<
"MEMPROF done instrumenting: " << FunctionModified
643 <<
" " <<
F <<
"\n");
645 return FunctionModified;
648 FunctionModified |= insertDynamicShadowAtFunctionEntry(
F);
650 int NumInstrumented = 0;
651 for (
auto *Inst : ToInstrument) {
654 std::optional<InterestingMemoryAccess> Access =
655 isInterestingMemoryAccess(Inst);
657 instrumentMop(Inst,
F.getDataLayout(), *Access);
659 instrumentMemIntrinsic(cast<MemIntrinsic>(Inst));
664 if (NumInstrumented > 0)
665 FunctionModified =
true;
667 LLVM_DEBUG(
dbgs() <<
"MEMPROF done instrumenting: " << FunctionModified <<
" "
670 return FunctionModified;
674 std::vector<uint64_t> &InlinedCallStack,
676 I.setMetadata(LLVMContext::MD_callsite,
687 std::memcpy(&Id, Hash.data(),
sizeof(Hash));
705 std::memcpy(&Id, Hash.data(),
sizeof(Hash));
712 for (
const auto &StackFrame :
AllocInfo->CallStack)
719 TotalSize =
AllocInfo->Info.getTotalSize();
733 unsigned StartIndex = 0) {
734 auto StackFrame = ProfileCallStack.
begin() + StartIndex;
735 auto InlCallStackIter = InlinedCallStack.
begin();
736 for (; StackFrame != ProfileCallStack.
end() &&
737 InlCallStackIter != InlinedCallStack.
end();
738 ++StackFrame, ++InlCallStackIter) {
740 if (StackId != *InlCallStackIter)
745 return InlCallStackIter == InlinedCallStack.
end();
757 case LibFunc_ZnwmRKSt9nothrow_t:
758 case LibFunc_ZnwmSt11align_val_t:
759 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
761 case LibFunc_ZnamRKSt9nothrow_t:
762 case LibFunc_ZnamSt11align_val_t:
763 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
765 case LibFunc_Znwm12__hot_cold_t:
766 case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
767 case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
768 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
769 case LibFunc_Znam12__hot_cold_t:
770 case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
771 case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
772 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
782 bool Matched =
false;
788 std::map<uint64_t, AllocMatchInfo> &FullStackIdToAllocMatchInfo) {
789 auto &Ctx = M.getContext();
797 auto FuncName =
F.getName();
799 std::optional<memprof::MemProfRecord> MemProfRec;
800 auto Err =
MemProfReader->getMemProfRecord(FuncGUID).moveInto(MemProfRec);
803 auto Err = IPE.
get();
804 bool SkipWarning =
false;
805 LLVM_DEBUG(
dbgs() <<
"Error in reading profile for Func " << FuncName
808 NumOfMemProfMissing++;
812 NumOfMemProfMismatch++;
818 LLVM_DEBUG(
dbgs() <<
"hash mismatch (skip=" << SkipWarning <<
")");
824 std::string Msg = (IPE.
message() +
Twine(
" ") +
F.getName().str() +
825 Twine(
" Hash = ") + std::to_string(FuncGUID))
840 bool ProfileHasColumns =
false;
844 std::map<uint64_t, std::set<const AllocationInfo *>> LocHashToAllocInfo;
847 std::map<uint64_t, std::set<std::pair<const std::vector<Frame> *,
unsigned>>>
849 for (
auto &AI : MemProfRec->AllocSites) {
850 NumOfMemProfAllocContextProfiles++;
855 LocHashToAllocInfo[StackId].insert(&AI);
856 ProfileHasColumns |= AI.CallStack[0].Column;
858 for (
auto &CS : MemProfRec->CallSites) {
859 NumOfMemProfCallSiteProfiles++;
863 for (
auto &StackFrame : CS) {
865 LocHashToCallSites[StackId].insert(std::make_pair(&CS,
Idx++));
866 ProfileHasColumns |= StackFrame.Column;
868 if (StackFrame.Function == FuncGUID)
871 assert(
Idx <= CS.size() && CS[
Idx - 1].Function == FuncGUID);
875 return (DIL->getLine() - DIL->getScope()->getSubprogram()->getLine()) &
883 if (
I.isDebugOrPseudoInst())
887 auto *CI = dyn_cast<CallBase>(&
I);
890 auto *CalledFunction = CI->getCalledFunction();
891 if (CalledFunction && CalledFunction->isIntrinsic())
895 std::vector<uint64_t> InlinedCallStack;
897 bool LeafFound =
false;
903 std::map<uint64_t, std::set<const AllocationInfo *>>::iterator
905 std::map<uint64_t, std::set<std::pair<const std::vector<Frame> *,
906 unsigned>>>::iterator CallSitesIter;
907 for (
const DILocation *DIL =
I.getDebugLoc(); DIL !=
nullptr;
908 DIL = DIL->getInlinedAt()) {
911 StringRef Name = DIL->getScope()->getSubprogram()->getLinkageName();
913 Name = DIL->getScope()->getSubprogram()->getName();
916 ProfileHasColumns ? DIL->getColumn() : 0);
922 AllocInfoIter = LocHashToAllocInfo.find(StackId);
923 CallSitesIter = LocHashToCallSites.find(StackId);
924 if (AllocInfoIter != LocHashToAllocInfo.end() ||
925 CallSitesIter != LocHashToCallSites.end())
929 InlinedCallStack.push_back(StackId);
939 if (AllocInfoIter != LocHashToAllocInfo.end()) {
948 for (
auto *
AllocInfo : AllocInfoIter->second) {
954 NumOfMemProfMatchedAllocContexts++;
960 FullStackIdToAllocMatchInfo[FullStackId] = {
968 if (!AllocTrie.
empty()) {
969 NumOfMemProfMatchedAllocs++;
973 assert(MemprofMDAttached ==
I.hasMetadata(LLVMContext::MD_memprof));
974 if (MemprofMDAttached) {
991 assert(CallSitesIter != LocHashToCallSites.end());
992 for (
auto CallStackIdx : CallSitesIter->second) {
996 *CallStackIdx.first, InlinedCallStack, CallStackIdx.second)) {
997 NumOfMemProfMatchedCallSites++;
1010 : MemoryProfileFileName(MemoryProfileFile), FS(FS) {
1017 auto &Ctx = M.getContext();
1019 if (
Error E = ReaderOrErr.takeError()) {
1028 std::move(ReaderOrErr.get());
1031 MemoryProfileFileName.data(),
StringRef(
"Cannot get MemProfReader")));
1037 "Not a memory profile"));
1046 std::map<uint64_t, AllocMatchInfo> FullStackIdToAllocMatchInfo;
1049 if (
F.isDeclaration())
1057 for (
const auto &[Id,
Info] : FullStackIdToAllocMatchInfo)
1059 <<
" context with id " << Id <<
" has total profiled size "
1060 <<
Info.TotalSize << (
Info.Matched ?
" is" :
" not")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static cl::opt< int > ClDebugMin("asan-debug-min", cl::desc("Debug min inst"), cl::Hidden, cl::init(-1))
static cl::opt< std::string > ClMemoryAccessCallbackPrefix("asan-memory-access-callback-prefix", cl::desc("Prefix for memory access callbacks"), cl::Hidden, cl::init("__asan_"))
static cl::opt< bool > ClInsertVersionCheck("asan-guard-against-version-mismatch", cl::desc("Guard against compiler/runtime version mismatch."), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInstrumentWrites("asan-instrument-writes", cl::desc("instrument write instructions"), cl::Hidden, cl::init(true))
static cl::opt< int > ClDebugMax("asan-debug-max", cl::desc("Debug max inst"), cl::Hidden, cl::init(-1))
static cl::opt< bool > ClStack("asan-stack", cl::desc("Handle stack memory"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInstrumentAtomics("asan-instrument-atomics", cl::desc("instrument atomic instructions (rmw, cmpxchg)"), cl::Hidden, cl::init(true))
static cl::opt< int > ClMappingScale("asan-mapping-scale", cl::desc("scale of asan shadow mapping"), cl::Hidden, cl::init(0))
static cl::opt< std::string > ClDebugFunc("asan-debug-func", cl::Hidden, cl::desc("Debug func"))
static cl::opt< bool > ClInstrumentReads("asan-instrument-reads", cl::desc("instrument read instructions"), cl::Hidden, cl::init(true))
Analysis containing CSE Info
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static cl::opt< int > ClMappingGranularity("memprof-mapping-granularity", cl::desc("granularity of memprof shadow mapping"), cl::Hidden, cl::init(DefaultMemGranularity))
constexpr char MemProfVersionCheckNamePrefix[]
static AllocationType addCallStack(CallStackTrie &AllocTrie, const AllocationInfo *AllocInfo)
static cl::opt< int > ClDebugMin("memprof-debug-min", cl::desc("Debug min inst"), cl::Hidden, cl::init(-1))
static bool isNewWithHotColdVariant(Function *Callee, const TargetLibraryInfo &TLI)
void createMemprofHistogramFlagVar(Module &M)
constexpr uint64_t MemProfEmscriptenCtorAndDtorPriority
static cl::opt< std::string > ClDebugFunc("memprof-debug-func", cl::Hidden, cl::desc("Debug func"))
constexpr char MemProfShadowMemoryDynamicAddress[]
constexpr uint64_t MemProfCtorAndDtorPriority
constexpr int LLVM_MEM_PROFILER_VERSION
static cl::opt< bool > ClUseCalls("memprof-use-callbacks", cl::desc("Use callbacks instead of inline instrumentation sequences."), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInstrumentAtomics("memprof-instrument-atomics", cl::desc("instrument atomic instructions (rmw, cmpxchg)"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInsertVersionCheck("memprof-guard-against-version-mismatch", cl::desc("Guard against compiler/runtime version mismatch."), cl::Hidden, cl::init(true))
constexpr char MemProfInitName[]
constexpr char MemProfFilenameVar[]
static uint64_t computeStackId(GlobalValue::GUID Function, uint32_t LineOffset, uint32_t Column)
static cl::opt< bool > ClStack("memprof-instrument-stack", cl::desc("Instrument scalar stack variables"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClHistogram("memprof-histogram", cl::desc("Collect access count histograms"), cl::Hidden, cl::init(false))
constexpr uint64_t DefaultMemGranularity
static cl::opt< bool > ClPrintMemProfMatchInfo("memprof-print-match-info", cl::desc("Print matching stats for each allocation " "context in this module's profiles"), cl::Hidden, cl::init(false))
constexpr uint64_t DefaultShadowScale
cl::opt< bool > MemProfReportHintedSizes
static cl::opt< std::string > ClMemoryAccessCallbackPrefix("memprof-memory-access-callback-prefix", cl::desc("Prefix for memory access callbacks"), cl::Hidden, cl::init("__memprof_"))
constexpr char MemProfModuleCtorName[]
static cl::opt< bool > ClInstrumentReads("memprof-instrument-reads", cl::desc("instrument read instructions"), cl::Hidden, cl::init(true))
static cl::opt< int > ClDebugMax("memprof-debug-max", cl::desc("Debug max inst"), cl::Hidden, cl::init(-1))
static cl::opt< bool > ClInstrumentWrites("memprof-instrument-writes", cl::desc("instrument write instructions"), cl::Hidden, cl::init(true))
static cl::opt< int > ClDebug("memprof-debug", cl::desc("debug"), cl::Hidden, cl::init(0))
static cl::opt< int > ClMappingScale("memprof-mapping-scale", cl::desc("scale of memprof shadow mapping"), cl::Hidden, cl::init(DefaultShadowScale))
static void addCallsiteMetadata(Instruction &I, std::vector< uint64_t > &InlinedCallStack, LLVMContext &Ctx)
static void readMemprof(Module &M, Function &F, IndexedInstrProfReader *MemProfReader, const TargetLibraryInfo &TLI, std::map< uint64_t, AllocMatchInfo > &FullStackIdToAllocMatchInfo)
static bool stackFrameIncludesInlinedCallStack(ArrayRef< Frame > ProfileCallStack, ArrayRef< uint64_t > InlinedCallStack, unsigned StartIndex=0)
static uint64_t computeFullStackId(const std::vector< memprof::Frame > &CallStack)
static cl::opt< bool > ClMemProfMatchHotColdNew("memprof-match-hot-cold-new", cl::desc("Match allocation profiles onto existing hot/cold operator new calls"), cl::Hidden, cl::init(false))
constexpr char MemProfHistogramFlagVar[]
cl::opt< bool > MemProfReportHintedSizes("memprof-report-hinted-sizes", cl::init(false), cl::Hidden, cl::desc("Report total allocation sizes of hinted allocations"))
Module.h This file contains the declarations for the Module class.
FunctionAnalysisManager FAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Defines the virtual file system interface vfs::FileSystem.
Class for arbitrary precision integers.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
An instruction that atomically checks whether a specified value is in a memory location,...
an instruction that atomically reads a memory location, combines it with another value,...
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
This is an important base class in LLVM.
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
A parsed version of the target data layout string in and methods for querying it.
Diagnostic information for the PGO profiler.
Base class for error info classes.
virtual std::string message() const
Return the error message as a string.
Lightweight error class with error context and mandatory checking.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
void setComdat(Comdat *C)
void setLinkage(LinkageTypes LT)
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
@ ExternalLinkage
Externally visible function.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
@ AvailableExternallyLinkage
Available for inspection, not emission.
HashResultTy< HasherT_ > final()
Forward to HasherT::final() if available.
Interface to help hash various types through a hasher type.
std::enable_if_t< hashbuilder_detail::IsHashableData< T >::value, HashBuilder & > add(T Value)
Implement hashing for hashable data types, e.g. integral or enum values.
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Type * getVoidTy()
Fetch the type representing void.
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Reader for the indexed binary instrprof format.
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path, vfs::FileSystem &FS, const Twine &RemappingPath="")
Factory method to create an indexed reader.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
instrprof_error get() const
std::string message() const override
Return the error message as a string.
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
StringRef getString() const
This is the common base class for memset/memcpy/memmove.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
MemProfUsePass(std::string MemoryProfileFile, IntrusiveRefCntPtr< vfs::FileSystem > FS=nullptr)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
A Module instance is used to store all the information related to an LLVM module.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
Triple - Helper class for working with autoconf configuration names.
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
bool isOSEmscripten() const
Tests whether the OS is Emscripten.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
static IntegerType * getInt64Ty(LLVMContext &C)
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
Class to build a trie of call stack contexts for a particular profiled allocation call,...
void addCallStack(AllocationType AllocType, ArrayRef< uint64_t > StackIds, uint64_t TotalSize=0)
Add a call stack context with the given allocation type to the Trie.
bool buildAndAttachMIBMetadata(CallBase *CI)
Build and attach the minimal necessary MIB metadata.
Helper class to iterate through stack ids in both metadata (memprof MIB and callsite) and the corresp...
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
MDNode * buildCallstackMetadata(ArrayRef< uint64_t > CallStack, LLVMContext &Ctx)
Build callstack metadata from the provided list of call stack ids.
AllocationType getAllocType(uint64_t TotalLifetimeAccessDensity, uint64_t AllocCount, uint64_t TotalLifetime)
Return the allocation type for a given set of memory profile values.
std::string getAllocTypeAttributeString(AllocationType Type)
Returns the string to use in attributes with the given type.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
This is an optimization pass for GlobalISel generic memory operations.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
cl::opt< bool > PGOWarnMissing
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
std::array< uint8_t, NumBytes > BLAKE3Result
The constant LLVM_BLAKE3_OUT_LEN provides the default output length, 32 bytes, which is recommended f...
FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName, ArrayRef< Type * > InitArgTypes, bool Weak=false)
std::pair< Function *, FunctionCallee > createSanitizerCtorAndInitFunctions(Module &M, StringRef CtorName, StringRef InitName, ArrayRef< Type * > InitArgTypes, ArrayRef< Value * > InitArgs, StringRef VersionCheckName=StringRef(), bool Weak=false)
Creates sanitizer constructor function, and calls sanitizer's init function from it.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
cl::opt< bool > NoPGOWarnMismatch
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput)
void appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Append F to the list of global ctors of module M with the given Priority.
Instruction * SplitBlockAndInsertIfThen(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)
Split the containing block at the specified instruction - everything before SplitBefore stays in the ...
cl::opt< bool > NoPGOWarnMismatchComdatWeak
Summary of memprof metadata on allocations.
GlobalValue::GUID Function