39#define DEBUG_TYPE "sancov"
66 "sancov.module_ctor_trace_pc_guard";
68 "sancov.module_ctor_8bit_counters";
88 "sanitizer-coverage-level",
89 cl::desc(
"Sanitizer Coverage. 0: none, 1: entry block, 2: all blocks, "
90 "3: all blocks and critical edges"),
108 cl::desc(
"create a static PC table"),
113 cl::desc(
"increments 8-bit counter for every edge"),
123 cl::desc(
"Tracing of CMP and similar instructions"),
127 cl::desc(
"Tracing of DIV instructions"),
131 cl::desc(
"Tracing of load instructions"),
135 cl::desc(
"Tracing of store instructions"),
139 cl::desc(
"Tracing of GEP instructions"),
144 cl::desc(
"Reduce the number of instrumented blocks"),
148 cl::desc(
"max stack depth tracing"),
160 switch (LegacyCoverageLevel) {
207using PostDomTreeCallback =
210class ModuleSanitizerCoverage {
212 ModuleSanitizerCoverage(
217 Blocklist(Blocklist) {}
218 bool instrumentModule(
Module &M, DomTreeCallback DTCallback,
219 PostDomTreeCallback PDTCallback);
222 void createFunctionControlFlow(
Function &
F);
223 void instrumentFunction(
Function &
F, DomTreeCallback DTCallback,
224 PostDomTreeCallback PDTCallback);
225 void InjectCoverageForIndirectCalls(
Function &
F,
237 bool IsLeafFunc =
true);
238 GlobalVariable *CreateFunctionLocalArrayInSection(
size_t NumElements,
240 const char *Section);
244 bool IsLeafFunc =
true);
245 Function *CreateInitCallsForSections(
Module &M,
const char *CtorName,
246 const char *InitFunctionName,
Type *Ty,
247 const char *Section);
248 std::pair<Value *, Value *> CreateSecStartEnd(
Module &M,
const char *Section,
251 std::string getSectionName(
const std::string &Section)
const;
252 std::string getSectionStart(
const std::string &Section)
const;
253 std::string getSectionEnd(
const std::string &Section)
const;
256 std::array<FunctionCallee, 4> SanCovTraceCmpFunction;
257 std::array<FunctionCallee, 4> SanCovTraceConstCmpFunction;
258 std::array<FunctionCallee, 5> SanCovLoadFunction;
259 std::array<FunctionCallee, 5> SanCovStoreFunction;
260 std::array<FunctionCallee, 2> SanCovTraceDivFunction;
264 Type *Int128PtrTy, *IntptrTy, *IntptrPtrTy, *Int64Ty, *Int64PtrTy, *
Int32Ty,
265 *Int32PtrTy, *Int16PtrTy, *Int16Ty, *Int8Ty, *Int8PtrTy, *Int1Ty,
268 std::string CurModuleUniqueId;
290 ModuleSanitizerCoverage ModuleSancov(
Options, Allowlist.get(),
299 if (!ModuleSancov.instrumentModule(M, DTCallback, PDTCallback))
310std::pair<Value *, Value *>
311ModuleSanitizerCoverage::CreateSecStartEnd(
Module &M,
const char *Section,
322 getSectionStart(Section));
326 getSectionEnd(Section));
329 if (!TargetTriple.isOSBinFormatCOFF())
330 return std::make_pair(SecStart, SecEnd);
334 auto SecStartI8Ptr = IRB.CreatePointerCast(SecStart, Int8PtrTy);
335 auto GEP = IRB.CreateGEP(Int8Ty, SecStartI8Ptr,
341Function *ModuleSanitizerCoverage::CreateInitCallsForSections(
342 Module &M,
const char *CtorName,
const char *InitFunctionName,
Type *Ty,
343 const char *Section) {
344 auto SecStartEnd = CreateSecStartEnd(M, Section, Ty);
345 auto SecStart = SecStartEnd.first;
346 auto SecEnd = SecStartEnd.second;
350 M, CtorName, InitFunctionName, {PtrTy, PtrTy}, {SecStart, SecEnd});
353 if (TargetTriple.supportsCOMDAT()) {
355 CtorFunc->
setComdat(
M.getOrInsertComdat(CtorName));
361 if (TargetTriple.isOSBinFormatCOFF()) {
373bool ModuleSanitizerCoverage::instrumentModule(
374 Module &M, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
378 !Allowlist->inSection(
"coverage",
"src",
M.getSourceFileName()))
381 Blocklist->inSection(
"coverage",
"src",
M.getSourceFileName()))
383 C = &(
M.getContext());
384 DL = &
M.getDataLayout();
387 TargetTriple =
Triple(
M.getTargetTriple());
388 FunctionGuardArray =
nullptr;
389 Function8bitCounterArray =
nullptr;
390 FunctionBoolArray =
nullptr;
391 FunctionPCsArray =
nullptr;
392 FunctionCFsArray =
nullptr;
403 Int64Ty = IRB.getInt64Ty();
414 SanCovTraceCmpZeroExtAL =
416 SanCovTraceCmpZeroExtAL =
419 SanCovTraceCmpFunction[0] =
421 IRB.getInt8Ty(), IRB.getInt8Ty());
422 SanCovTraceCmpFunction[1] =
424 IRB.getInt16Ty(), IRB.getInt16Ty());
425 SanCovTraceCmpFunction[2] =
427 IRB.getInt32Ty(), IRB.getInt32Ty());
428 SanCovTraceCmpFunction[3] =
431 SanCovTraceConstCmpFunction[0] =
M.getOrInsertFunction(
433 SanCovTraceConstCmpFunction[1] =
M.getOrInsertFunction(
435 SanCovTraceConstCmpFunction[2] =
M.getOrInsertFunction(
437 SanCovTraceConstCmpFunction[3] =
441 SanCovLoadFunction[0] =
M.getOrInsertFunction(
SanCovLoad1, VoidTy, Int8PtrTy);
442 SanCovLoadFunction[1] =
444 SanCovLoadFunction[2] =
446 SanCovLoadFunction[3] =
448 SanCovLoadFunction[4] =
451 SanCovStoreFunction[0] =
453 SanCovStoreFunction[1] =
455 SanCovStoreFunction[2] =
457 SanCovStoreFunction[3] =
459 SanCovStoreFunction[4] =
464 AL =
AL.addParamAttribute(*
C, 0, Attribute::ZExt);
465 SanCovTraceDivFunction[0] =
468 SanCovTraceDivFunction[1] =
470 SanCovTraceGepFunction =
472 SanCovTraceSwitchFunction =
475 Constant *SanCovLowestStackConstant =
477 SanCovLowestStack = dyn_cast<GlobalVariable>(SanCovLowestStackConstant);
478 if (!SanCovLowestStack || SanCovLowestStack->getValueType() != IntptrTy) {
480 "' should not be declared by the user");
483 SanCovLowestStack->setThreadLocalMode(
485 if (
Options.StackDepth && !SanCovLowestStack->isDeclaration())
493 instrumentFunction(
F, DTCallback, PDTCallback);
497 if (FunctionGuardArray)
501 if (Function8bitCounterArray)
505 if (FunctionBoolArray) {
515 IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second});
518 if (Ctor &&
Options.CollectControlFlow) {
523 IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second});
569 if (
Options.NoPrune || &
F.getEntryBlock() == BB)
573 &
F.getEntryBlock() != BB)
605 if (CMP->hasOneUse())
606 if (
auto BR = dyn_cast<BranchInst>(CMP->user_back()))
613void ModuleSanitizerCoverage::instrumentFunction(
614 Function &
F, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
617 if (
F.getName().find(
".module_ctor") != std::string::npos)
619 if (
F.getName().startswith(
"__sanitizer_"))
626 if (
F.getName() ==
"__local_stdio_printf_options" ||
627 F.getName() ==
"__local_stdio_scanf_options")
629 if (isa<UnreachableInst>(
F.getEntryBlock().getTerminator()))
634 if (
F.hasPersonalityFn() &&
637 if (Allowlist && !Allowlist->inSection(
"coverage",
"fun",
F.getName()))
639 if (Blocklist && Blocklist->inSection(
"coverage",
"fun",
F.getName()))
641 if (
F.hasFnAttribute(Attribute::NoSanitizeCoverage))
656 bool IsLeafFunc =
true;
661 for (
auto &Inst : BB) {
663 CallBase *CB = dyn_cast<CallBase>(&Inst);
668 if (
ICmpInst *CMP = dyn_cast<ICmpInst>(&Inst))
671 if (isa<SwitchInst>(&Inst))
676 if (BO->getOpcode() == Instruction::SDiv ||
677 BO->getOpcode() == Instruction::UDiv)
683 if (
LoadInst *LI = dyn_cast<LoadInst>(&Inst))
686 if (
StoreInst *SI = dyn_cast<StoreInst>(&Inst))
689 if (isa<InvokeInst>(Inst) ||
690 (isa<CallInst>(Inst) && !isa<IntrinsicInst>(Inst)))
695 if (
Options.CollectControlFlow)
696 createFunctionControlFlow(
F);
698 InjectCoverage(
F, BlocksToInstrument, IsLeafFunc);
699 InjectCoverageForIndirectCalls(
F, IndirCalls);
700 InjectTraceForCmp(
F, CmpTraceTargets);
701 InjectTraceForSwitch(
F, SwitchTraceTargets);
702 InjectTraceForDiv(
F, DivTraceTargets);
703 InjectTraceForGep(
F, GepTraceTargets);
704 InjectTraceForLoadsAndStores(
F, Loads, Stores);
707GlobalVariable *ModuleSanitizerCoverage::CreateFunctionLocalArrayInSection(
708 size_t NumElements,
Function &
F,
Type *Ty,
const char *Section) {
714 if (TargetTriple.supportsCOMDAT() &&
715 (TargetTriple.isOSBinFormatELF() || !
F.isInterposable()))
718 Array->setSection(getSectionName(Section));
719 Array->setAlignment(
Align(
DL->getTypeStoreSize(Ty).getFixedValue()));
730 if (
Array->hasComdat())
731 GlobalsToAppendToCompilerUsed.push_back(Array);
733 GlobalsToAppendToUsed.push_back(Array);
739ModuleSanitizerCoverage::CreatePCArray(
Function &
F,
741 size_t N = AllBlocks.
size();
744 IRBuilder<> IRB(&*
F.getEntryBlock().getFirstInsertionPt());
745 for (
size_t i = 0; i <
N; i++) {
746 if (&
F.getEntryBlock() == AllBlocks[i]) {
756 auto *PCArray = CreateFunctionLocalArrayInSection(
N * 2,
F, IntptrPtrTy,
758 PCArray->setInitializer(
760 PCArray->setConstant(
true);
765void ModuleSanitizerCoverage::CreateFunctionLocalArrays(
768 FunctionGuardArray = CreateFunctionLocalArrayInSection(
771 if (
Options.Inline8bitCounters)
772 Function8bitCounterArray = CreateFunctionLocalArrayInSection(
775 FunctionBoolArray = CreateFunctionLocalArrayInSection(
779 FunctionPCsArray = CreatePCArray(
F, AllBlocks);
782bool ModuleSanitizerCoverage::InjectCoverage(
Function &
F,
785 if (AllBlocks.
empty())
return false;
786 CreateFunctionLocalArrays(
F, AllBlocks);
787 for (
size_t i = 0,
N = AllBlocks.
size(); i <
N; i++)
788 InjectCoverageAtBlock(
F, *AllBlocks[i], i, IsLeafFunc);
799void ModuleSanitizerCoverage::InjectCoverageForIndirectCalls(
801 if (IndirCalls.
empty())
805 for (
auto *
I : IndirCalls) {
809 if (isa<InlineAsm>(
Callee))
811 IRB.CreateCall(SanCovTracePCIndir, IRB.CreatePointerCast(
Callee, IntptrTy));
819void ModuleSanitizerCoverage::InjectTraceForSwitch(
821 for (
auto *
I : SwitchTraceTargets) {
826 if (
Cond->getType()->getScalarSizeInBits() >
827 Int64Ty->getScalarSizeInBits())
832 if (
Cond->getType()->getScalarSizeInBits() <
833 Int64Ty->getScalarSizeInBits())
834 Cond = IRB.CreateIntCast(
Cond, Int64Ty,
false);
835 for (
auto It :
SI->cases()) {
837 if (
C->getType()->getScalarSizeInBits() <
838 Int64Ty->getScalarSizeInBits())
844 return cast<ConstantInt>(
A)->getLimitedValue() <
845 cast<ConstantInt>(
B)->getLimitedValue();
851 "__sancov_gen_cov_switch_values");
852 IRB.CreateCall(SanCovTraceSwitchFunction,
853 {
Cond, IRB.CreatePointerCast(GV, Int64PtrTy)});
858void ModuleSanitizerCoverage::InjectTraceForDiv(
860 for (
auto *BO : DivTraceTargets) {
862 Value *A1 = BO->getOperand(1);
863 if (isa<ConstantInt>(A1))
continue;
867 int CallbackIdx =
TypeSize == 32 ? 0 :
869 if (CallbackIdx < 0)
continue;
871 IRB.CreateCall(SanCovTraceDivFunction[CallbackIdx],
872 {IRB.CreateIntCast(A1, Ty,
true)});
876void ModuleSanitizerCoverage::InjectTraceForGep(
878 for (
auto *
GEP : GepTraceTargets) {
881 if (!isa<ConstantInt>(
Idx) &&
Idx->getType()->isIntegerTy())
882 IRB.CreateCall(SanCovTraceGepFunction,
883 {IRB.CreateIntCast(
Idx, IntptrTy,
true)});
887void ModuleSanitizerCoverage::InjectTraceForLoadsAndStores(
889 auto CallbackIdx = [&](
Type *ElementTy) ->
int {
900 for (
auto *LI : Loads) {
902 auto Ptr = LI->getPointerOperand();
903 int Idx = CallbackIdx(LI->getType());
906 IRB.CreateCall(SanCovLoadFunction[
Idx],
909 for (
auto *SI : Stores) {
911 auto Ptr =
SI->getPointerOperand();
912 int Idx = CallbackIdx(
SI->getValueOperand()->getType());
915 IRB.CreateCall(SanCovStoreFunction[
Idx],
920void ModuleSanitizerCoverage::InjectTraceForCmp(
922 for (
auto *
I : CmpTraceTargets) {
923 if (
ICmpInst *ICMP = dyn_cast<ICmpInst>(
I)) {
930 int CallbackIdx =
TypeSize == 8 ? 0 :
934 if (CallbackIdx < 0)
continue;
936 auto CallbackFunc = SanCovTraceCmpFunction[CallbackIdx];
937 bool FirstIsConst = isa<ConstantInt>(A0);
938 bool SecondIsConst = isa<ConstantInt>(A1);
940 if (FirstIsConst && SecondIsConst)
continue;
942 if (FirstIsConst || SecondIsConst) {
943 CallbackFunc = SanCovTraceConstCmpFunction[CallbackIdx];
949 IRB.CreateCall(CallbackFunc, {IRB.CreateIntCast(A0, Ty,
true),
950 IRB.CreateIntCast(A1, Ty,
true)});
959 bool IsEntryBB = &BB == &
F.getEntryBlock();
962 if (
auto SP =
F.getSubprogram())
963 EntryLoc =
DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP);
972 IRB.SetCurrentDebugLocation(EntryLoc);
974 IRB.CreateCall(SanCovTracePC)
978 auto GuardPtr = IRB.CreateIntToPtr(
979 IRB.CreateAdd(IRB.CreatePointerCast(FunctionGuardArray, IntptrTy),
982 IRB.CreateCall(SanCovTracePCGuard, GuardPtr)->setCannotMerge();
984 if (
Options.Inline8bitCounters) {
985 auto CounterPtr = IRB.CreateGEP(
986 Function8bitCounterArray->getValueType(), Function8bitCounterArray,
987 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
988 auto Load = IRB.CreateLoad(Int8Ty, CounterPtr);
990 auto Store = IRB.CreateStore(Inc, CounterPtr);
991 Load->setNoSanitizeMetadata();
992 Store->setNoSanitizeMetadata();
995 auto FlagPtr = IRB.CreateGEP(
996 FunctionBoolArray->getValueType(), FunctionBoolArray,
997 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
998 auto Load = IRB.CreateLoad(Int1Ty, FlagPtr);
1003 Load->setNoSanitizeMetadata();
1004 Store->setNoSanitizeMetadata();
1006 if (
Options.StackDepth && IsEntryBB && !IsLeafFunc) {
1010 M, Intrinsic::frameaddress,
1011 IRB.getInt8PtrTy(
M->getDataLayout().getAllocaAddrSpace()));
1014 auto FrameAddrInt = IRB.CreatePtrToInt(FrameAddrPtr, IntptrTy);
1015 auto LowestStack = IRB.CreateLoad(IntptrTy, SanCovLowestStack);
1016 auto IsStackLower = IRB.CreateICmpULT(FrameAddrInt, LowestStack);
1019 auto Store = ThenIRB.CreateStore(FrameAddrInt, SanCovLowestStack);
1020 LowestStack->setNoSanitizeMetadata();
1021 Store->setNoSanitizeMetadata();
1026ModuleSanitizerCoverage::getSectionName(
const std::string &Section)
const {
1027 if (TargetTriple.isOSBinFormatCOFF()) {
1036 if (TargetTriple.isOSBinFormatMachO())
1042ModuleSanitizerCoverage::getSectionStart(
const std::string &Section)
const {
1043 if (TargetTriple.isOSBinFormatMachO())
1044 return "\1section$start$__DATA$__" +
Section;
1045 return "__start___" +
Section;
1049ModuleSanitizerCoverage::getSectionEnd(
const std::string &Section)
const {
1050 if (TargetTriple.isOSBinFormatMachO())
1051 return "\1section$end$__DATA$__" +
Section;
1055void ModuleSanitizerCoverage::createFunctionControlFlow(
Function &
F) {
1057 IRBuilder<> IRB(&*
F.getEntryBlock().getFirstInsertionPt());
1059 for (
auto &BB :
F) {
1061 if (&BB == &
F.getEntryBlock())
1068 assert(SuccBB != &
F.getEntryBlock());
1075 for (
auto &Inst : BB) {
1076 if (
CallBase *CB = dyn_cast<CallBase>(&Inst)) {
1083 if (CalledF && !CalledF->isIntrinsic())
1085 (
Constant *)IRB.CreatePointerCast(CalledF, IntptrPtrTy));
1093 FunctionCFsArray = CreateFunctionLocalArrayInSection(
1095 FunctionCFsArray->setInitializer(
1097 FunctionCFsArray->setConstant(
true);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu Simplify well known AMD library false FunctionCallee Callee
SmallVector< MachineOperand, 4 > Cond
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
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
This is the interface for a simple mod/ref and alias analysis over globals.
Module.h This file contains the declarations for the Module class.
static cl::opt< bool > SplitAllCriticalEdges("phi-elim-split-all-critical-edges", cl::init(false), cl::Hidden, cl::desc("Split all critical edges during " "PHI elimination"))
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static cl::opt< bool > ClCreatePCTable("sanitizer-coverage-pc-table", cl::desc("create a static PC table"), cl::Hidden, cl::init(false))
const char SanCovCFsSectionName[]
static cl::opt< bool > ClStoreTracing("sanitizer-coverage-trace-stores", cl::desc("Tracing of store instructions"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInline8bitCounters("sanitizer-coverage-inline-8bit-counters", cl::desc("increments 8-bit counter for every edge"), cl::Hidden, cl::init(false))
const char SanCovTraceConstCmp4[]
const char SanCovBoolFlagSectionName[]
static bool IsBackEdge(BasicBlock *From, BasicBlock *To, const DominatorTree *DT)
static cl::opt< bool > ClCollectCF("sanitizer-coverage-control-flow", cl::desc("collect control flow for each function"), cl::Hidden, cl::init(false))
const char SanCov8bitCountersInitName[]
static cl::opt< bool > ClInlineBoolFlag("sanitizer-coverage-inline-bool-flag", cl::desc("sets a boolean flag for every edge"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClLoadTracing("sanitizer-coverage-trace-loads", cl::desc("Tracing of load instructions"), cl::Hidden, cl::init(false))
static bool isFullPostDominator(const BasicBlock *BB, const PostDominatorTree *PDT)
const char SanCovTraceSwitchName[]
const char SanCovTraceCmp1[]
const char SanCovModuleCtorTracePcGuardName[]
static cl::opt< bool > ClCMPTracing("sanitizer-coverage-trace-compares", cl::desc("Tracing of CMP and similar instructions"), cl::Hidden, cl::init(false))
const char SanCovCountersSectionName[]
const char SanCovPCsInitName[]
const char SanCovTracePCGuardName[]
const char SanCovModuleCtor8bitCountersName[]
const char SanCovTracePCGuardInitName[]
const char SanCovTraceDiv4[]
static const uint64_t SanCtorAndDtorPriority
const char SanCovBoolFlagInitName[]
static cl::opt< bool > ClStackDepth("sanitizer-coverage-stack-depth", cl::desc("max stack depth tracing"), cl::Hidden, cl::init(false))
const char SanCovTraceGep[]
static cl::opt< bool > ClTracePC("sanitizer-coverage-trace-pc", cl::desc("Experimental pc tracing"), cl::Hidden, cl::init(false))
const char SanCovLoad16[]
const char SanCovTraceConstCmp8[]
const char SanCovGuardsSectionName[]
const char SanCovStore1[]
const char SanCovTraceConstCmp2[]
const char SanCovTraceConstCmp1[]
static bool shouldInstrumentBlock(const Function &F, const BasicBlock *BB, const DominatorTree *DT, const PostDominatorTree *PDT, const SanitizerCoverageOptions &Options)
static cl::opt< bool > ClTracePCGuard("sanitizer-coverage-trace-pc-guard", cl::desc("pc tracing with a guard"), cl::Hidden, cl::init(false))
const char SanCovTraceDiv8[]
const char SanCovCFsInitName[]
const char SanCovStore2[]
static cl::opt< bool > ClPruneBlocks("sanitizer-coverage-prune-blocks", cl::desc("Reduce the number of instrumented blocks"), cl::Hidden, cl::init(true))
static cl::opt< int > ClCoverageLevel("sanitizer-coverage-level", cl::desc("Sanitizer Coverage. 0: none, 1: entry block, 2: all blocks, " "3: all blocks and critical edges"), cl::Hidden, cl::init(0))
const char SanCovPCsSectionName[]
const char SanCovTraceCmp8[]
const char SanCovStore16[]
const char SanCovModuleCtorBoolFlagName[]
static bool IsInterestingCmp(ICmpInst *CMP, const DominatorTree *DT, const SanitizerCoverageOptions &Options)
const char SanCovTraceCmp2[]
const char SanCovStore8[]
const char SanCovTracePCName[]
const char SanCovStore4[]
static bool isFullDominator(const BasicBlock *BB, const DominatorTree *DT)
const char SanCovTraceCmp4[]
const char SanCovLowestStackName[]
static cl::opt< bool > ClDIVTracing("sanitizer-coverage-trace-divs", cl::desc("Tracing of DIV instructions"), cl::Hidden, cl::init(false))
const char SanCovTracePCIndirName[]
static cl::opt< bool > ClGEPTracing("sanitizer-coverage-trace-geps", cl::desc("Tracing of GEP instructions"), cl::Hidden, cl::init(false))
This file defines the SmallVector class.
Defines the virtual file system interface vfs::FileSystem.
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),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
LLVM Basic Block Representation.
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
const BasicBlock * getUniqueSuccessor() const
Return the successor of this block if it has a unique successor.
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const Instruction * getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode, a debug intrinsic,...
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
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...
bool isIndirectCall() const
Return true if the callsite is an indirect call.
Value * getCalledOperand() const
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
static ConstantInt * getTrue(LLVMContext &Context)
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
This is an important base class in LLVM.
static Constant * getAllOnesValue(Type *Ty)
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.
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
const BasicBlock & getEntryBlock() const
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
void setComdat(Comdat *C)
void setLinkage(LinkageTypes LT)
@ HiddenVisibility
The GV is hidden.
void setVisibility(VisibilityTypes V)
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
@ WeakODRLinkage
Same, but only replaced by something equivalent.
@ ExternalLinkage
Externally visible function.
@ AvailableExternallyLinkage
Available for inspection, not emission.
@ ExternalWeakLinkage
ExternalWeak linkage description.
Analysis pass providing a never-invalidated alias analysis result.
This instruction compares its operands according to the predicate given to the constructor.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
A Module instance is used to store all the information related to an LLVM module.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Analysis pass which computes a PostDominatorTree.
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
bool dominates(const Instruction *I1, const Instruction *I2) const
Return true if I1 dominates I2.
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 abandon()
Mark an analysis as abandoned.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
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.
Triple - Helper class for working with autoconf configuration names.
The instances of the Type class are immutable: once they are created, they are never changed.
static IntegerType * getInt1Ty(LLVMContext &C)
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt16Ty(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
StringRef getName() const
Return a constant reference to the value's name.
An efficient, type-erasing, non-owning reference to a callable.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool succ_empty(const Instruction *I)
auto successors(const MachineBasicBlock *BB)
Instruction * SplitBlockAndInsertIfThen(Value *Cond, Instruction *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 ...
FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName, ArrayRef< Type * > InitArgTypes, bool Weak=false)
std::string getUniqueModuleId(Module *M)
Produce a unique identifier for this module by taking the MD5 sum of the names of the module's strong...
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.
void sort(IteratorTy Start, IteratorTy End)
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Comdat * getOrCreateFunctionComdat(Function &F, Triple &T)
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
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.
auto predecessors(const MachineBasicBlock *BB)
bool pred_empty(const BasicBlock *BB)
BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, BasicBlock::iterator IP)
Instrumentation passes often insert conditional checks into entry blocks.
void appendToUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.used list.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Option class for critical edge splitting.
enum llvm::SanitizerCoverageOptions::Type CoverageType