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,
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 *PtrTy, *IntptrTy, *Int64Ty, *
Int32Ty, *Int16Ty, *Int8Ty, *Int1Ty;
266 std::string CurModuleUniqueId;
288 ModuleSanitizerCoverage ModuleSancov(
Options, Allowlist.get(),
297 if (!ModuleSancov.instrumentModule(M, DTCallback, PDTCallback))
308std::pair<Value *, Value *>
309ModuleSanitizerCoverage::CreateSecStartEnd(
Module &M,
const char *Section,
320 getSectionStart(Section));
324 getSectionEnd(Section));
327 if (!TargetTriple.isOSBinFormatCOFF())
328 return std::make_pair(SecStart, SecEnd);
332 auto SecStartI8Ptr = IRB.CreatePointerCast(SecStart, PtrTy);
333 auto GEP = IRB.CreateGEP(Int8Ty, SecStartI8Ptr,
335 return std::make_pair(
GEP, SecEnd);
338Function *ModuleSanitizerCoverage::CreateInitCallsForSections(
339 Module &M,
const char *CtorName,
const char *InitFunctionName,
Type *Ty,
340 const char *Section) {
341 auto SecStartEnd = CreateSecStartEnd(M, Section, Ty);
342 auto SecStart = SecStartEnd.first;
343 auto SecEnd = SecStartEnd.second;
346 M, CtorName, InitFunctionName, {PtrTy, PtrTy}, {SecStart, SecEnd});
349 if (TargetTriple.supportsCOMDAT()) {
351 CtorFunc->
setComdat(
M.getOrInsertComdat(CtorName));
357 if (TargetTriple.isOSBinFormatCOFF()) {
369bool ModuleSanitizerCoverage::instrumentModule(
370 Module &M, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
374 !Allowlist->inSection(
"coverage",
"src",
M.getSourceFileName()))
377 Blocklist->inSection(
"coverage",
"src",
M.getSourceFileName()))
379 C = &(
M.getContext());
380 DL = &
M.getDataLayout();
383 TargetTriple =
Triple(
M.getTargetTriple());
384 FunctionGuardArray =
nullptr;
385 Function8bitCounterArray =
nullptr;
386 FunctionBoolArray =
nullptr;
387 FunctionPCsArray =
nullptr;
388 FunctionCFsArray =
nullptr;
393 Int64Ty = IRB.getInt64Ty();
404 SanCovTraceCmpZeroExtAL =
406 SanCovTraceCmpZeroExtAL =
409 SanCovTraceCmpFunction[0] =
411 IRB.getInt8Ty(), IRB.getInt8Ty());
412 SanCovTraceCmpFunction[1] =
414 IRB.getInt16Ty(), IRB.getInt16Ty());
415 SanCovTraceCmpFunction[2] =
417 IRB.getInt32Ty(), IRB.getInt32Ty());
418 SanCovTraceCmpFunction[3] =
421 SanCovTraceConstCmpFunction[0] =
M.getOrInsertFunction(
423 SanCovTraceConstCmpFunction[1] =
M.getOrInsertFunction(
425 SanCovTraceConstCmpFunction[2] =
M.getOrInsertFunction(
427 SanCovTraceConstCmpFunction[3] =
431 SanCovLoadFunction[0] =
M.getOrInsertFunction(
SanCovLoad1, VoidTy, PtrTy);
432 SanCovLoadFunction[1] =
434 SanCovLoadFunction[2] =
436 SanCovLoadFunction[3] =
438 SanCovLoadFunction[4] =
441 SanCovStoreFunction[0] =
443 SanCovStoreFunction[1] =
445 SanCovStoreFunction[2] =
447 SanCovStoreFunction[3] =
449 SanCovStoreFunction[4] =
454 AL =
AL.addParamAttribute(*
C, 0, Attribute::ZExt);
455 SanCovTraceDivFunction[0] =
458 SanCovTraceDivFunction[1] =
460 SanCovTraceGepFunction =
462 SanCovTraceSwitchFunction =
465 Constant *SanCovLowestStackConstant =
467 SanCovLowestStack = dyn_cast<GlobalVariable>(SanCovLowestStackConstant);
468 if (!SanCovLowestStack || SanCovLowestStack->getValueType() != IntptrTy) {
470 "' should not be declared by the user");
473 SanCovLowestStack->setThreadLocalMode(
475 if (
Options.StackDepth && !SanCovLowestStack->isDeclaration())
483 instrumentFunction(
F, DTCallback, PDTCallback);
487 if (FunctionGuardArray)
491 if (Function8bitCounterArray)
495 if (FunctionBoolArray) {
505 IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second});
508 if (Ctor &&
Options.CollectControlFlow) {
513 IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second});
559 if (
Options.NoPrune || &
F.getEntryBlock() == BB)
563 &
F.getEntryBlock() != BB)
595 if (CMP->hasOneUse())
596 if (
auto BR = dyn_cast<BranchInst>(CMP->user_back()))
603void ModuleSanitizerCoverage::instrumentFunction(
604 Function &
F, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
607 if (
F.getName().find(
".module_ctor") != std::string::npos)
609 if (
F.getName().starts_with(
"__sanitizer_"))
616 if (
F.getName() ==
"__local_stdio_printf_options" ||
617 F.getName() ==
"__local_stdio_scanf_options")
619 if (isa<UnreachableInst>(
F.getEntryBlock().getTerminator()))
624 if (
F.hasPersonalityFn() &&
627 if (Allowlist && !Allowlist->inSection(
"coverage",
"fun",
F.getName()))
629 if (Blocklist && Blocklist->inSection(
"coverage",
"fun",
F.getName()))
631 if (
F.hasFnAttribute(Attribute::NoSanitizeCoverage))
646 bool IsLeafFunc =
true;
651 for (
auto &Inst : BB) {
653 CallBase *CB = dyn_cast<CallBase>(&Inst);
658 if (
ICmpInst *CMP = dyn_cast<ICmpInst>(&Inst))
661 if (isa<SwitchInst>(&Inst))
666 if (BO->getOpcode() == Instruction::SDiv ||
667 BO->getOpcode() == Instruction::UDiv)
673 if (
LoadInst *LI = dyn_cast<LoadInst>(&Inst))
676 if (
StoreInst *SI = dyn_cast<StoreInst>(&Inst))
679 if (isa<InvokeInst>(Inst) ||
680 (isa<CallInst>(Inst) && !isa<IntrinsicInst>(Inst)))
685 if (
Options.CollectControlFlow)
686 createFunctionControlFlow(
F);
688 InjectCoverage(
F, BlocksToInstrument, IsLeafFunc);
689 InjectCoverageForIndirectCalls(
F, IndirCalls);
690 InjectTraceForCmp(
F, CmpTraceTargets);
691 InjectTraceForSwitch(
F, SwitchTraceTargets);
692 InjectTraceForDiv(
F, DivTraceTargets);
693 InjectTraceForGep(
F, GepTraceTargets);
694 InjectTraceForLoadsAndStores(
F, Loads, Stores);
697GlobalVariable *ModuleSanitizerCoverage::CreateFunctionLocalArrayInSection(
698 size_t NumElements,
Function &
F,
Type *Ty,
const char *Section) {
704 if (TargetTriple.supportsCOMDAT() &&
705 (TargetTriple.isOSBinFormatELF() || !
F.isInterposable()))
709 Array->setAlignment(
Align(
DL->getTypeStoreSize(Ty).getFixedValue()));
720 if (
Array->hasComdat())
721 GlobalsToAppendToCompilerUsed.push_back(Array);
723 GlobalsToAppendToUsed.push_back(Array);
729ModuleSanitizerCoverage::CreatePCArray(
Function &
F,
731 size_t N = AllBlocks.
size();
734 IRBuilder<> IRB(&*
F.getEntryBlock().getFirstInsertionPt());
735 for (
size_t i = 0; i <
N; i++) {
736 if (&
F.getEntryBlock() == AllBlocks[i]) {
746 auto *PCArray = CreateFunctionLocalArrayInSection(
N * 2,
F, PtrTy,
748 PCArray->setInitializer(
750 PCArray->setConstant(
true);
755void ModuleSanitizerCoverage::CreateFunctionLocalArrays(
758 FunctionGuardArray = CreateFunctionLocalArrayInSection(
761 if (
Options.Inline8bitCounters)
762 Function8bitCounterArray = CreateFunctionLocalArrayInSection(
765 FunctionBoolArray = CreateFunctionLocalArrayInSection(
769 FunctionPCsArray = CreatePCArray(
F, AllBlocks);
772bool ModuleSanitizerCoverage::InjectCoverage(
Function &
F,
775 if (AllBlocks.
empty())
return false;
776 CreateFunctionLocalArrays(
F, AllBlocks);
777 for (
size_t i = 0,
N = AllBlocks.
size(); i <
N; i++)
778 InjectCoverageAtBlock(
F, *AllBlocks[i], i, IsLeafFunc);
789void ModuleSanitizerCoverage::InjectCoverageForIndirectCalls(
791 if (IndirCalls.
empty())
795 for (
auto *
I : IndirCalls) {
799 if (isa<InlineAsm>(Callee))
801 IRB.CreateCall(SanCovTracePCIndir, IRB.CreatePointerCast(Callee, IntptrTy));
809void ModuleSanitizerCoverage::InjectTraceForSwitch(
811 for (
auto *
I : SwitchTraceTargets) {
816 if (
Cond->getType()->getScalarSizeInBits() >
817 Int64Ty->getScalarSizeInBits())
822 if (
Cond->getType()->getScalarSizeInBits() <
823 Int64Ty->getScalarSizeInBits())
824 Cond = IRB.CreateIntCast(
Cond, Int64Ty,
false);
825 for (
auto It :
SI->cases()) {
827 if (
C->getType()->getScalarSizeInBits() < 64)
833 return cast<ConstantInt>(
A)->getLimitedValue() <
834 cast<ConstantInt>(
B)->getLimitedValue();
840 "__sancov_gen_cov_switch_values");
841 IRB.CreateCall(SanCovTraceSwitchFunction,
842 {
Cond, IRB.CreatePointerCast(GV, PtrTy)});
847void ModuleSanitizerCoverage::InjectTraceForDiv(
849 for (
auto *BO : DivTraceTargets) {
851 Value *A1 = BO->getOperand(1);
852 if (isa<ConstantInt>(A1))
continue;
856 int CallbackIdx =
TypeSize == 32 ? 0 :
858 if (CallbackIdx < 0)
continue;
860 IRB.CreateCall(SanCovTraceDivFunction[CallbackIdx],
861 {IRB.CreateIntCast(A1, Ty,
true)});
865void ModuleSanitizerCoverage::InjectTraceForGep(
867 for (
auto *
GEP : GepTraceTargets) {
870 if (!isa<ConstantInt>(
Idx) &&
Idx->getType()->isIntegerTy())
871 IRB.CreateCall(SanCovTraceGepFunction,
872 {IRB.CreateIntCast(
Idx, IntptrTy,
true)});
876void ModuleSanitizerCoverage::InjectTraceForLoadsAndStores(
878 auto CallbackIdx = [&](
Type *ElementTy) ->
int {
887 for (
auto *LI : Loads) {
889 auto Ptr = LI->getPointerOperand();
890 int Idx = CallbackIdx(LI->getType());
893 IRB.CreateCall(SanCovLoadFunction[
Idx],
Ptr);
895 for (
auto *SI : Stores) {
897 auto Ptr =
SI->getPointerOperand();
898 int Idx = CallbackIdx(
SI->getValueOperand()->getType());
901 IRB.CreateCall(SanCovStoreFunction[
Idx],
Ptr);
905void ModuleSanitizerCoverage::InjectTraceForCmp(
907 for (
auto *
I : CmpTraceTargets) {
908 if (
ICmpInst *ICMP = dyn_cast<ICmpInst>(
I)) {
915 int CallbackIdx =
TypeSize == 8 ? 0 :
919 if (CallbackIdx < 0)
continue;
921 auto CallbackFunc = SanCovTraceCmpFunction[CallbackIdx];
922 bool FirstIsConst = isa<ConstantInt>(A0);
923 bool SecondIsConst = isa<ConstantInt>(A1);
925 if (FirstIsConst && SecondIsConst)
continue;
927 if (FirstIsConst || SecondIsConst) {
928 CallbackFunc = SanCovTraceConstCmpFunction[CallbackIdx];
934 IRB.CreateCall(CallbackFunc, {IRB.CreateIntCast(A0, Ty,
true),
935 IRB.CreateIntCast(A1, Ty,
true)});
944 bool IsEntryBB = &BB == &
F.getEntryBlock();
947 if (
auto SP =
F.getSubprogram())
948 EntryLoc =
DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP);
957 IRB.SetCurrentDebugLocation(EntryLoc);
959 IRB.CreateCall(SanCovTracePC)
963 auto GuardPtr = IRB.CreateIntToPtr(
964 IRB.CreateAdd(IRB.CreatePointerCast(FunctionGuardArray, IntptrTy),
967 IRB.CreateCall(SanCovTracePCGuard, GuardPtr)->setCannotMerge();
969 if (
Options.Inline8bitCounters) {
970 auto CounterPtr = IRB.CreateGEP(
971 Function8bitCounterArray->getValueType(), Function8bitCounterArray,
972 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
973 auto Load = IRB.CreateLoad(Int8Ty, CounterPtr);
975 auto Store = IRB.CreateStore(Inc, CounterPtr);
976 Load->setNoSanitizeMetadata();
977 Store->setNoSanitizeMetadata();
980 auto FlagPtr = IRB.CreateGEP(
981 FunctionBoolArray->getValueType(), FunctionBoolArray,
982 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
983 auto Load = IRB.CreateLoad(Int1Ty, FlagPtr);
988 Load->setNoSanitizeMetadata();
989 Store->setNoSanitizeMetadata();
991 if (
Options.StackDepth && IsEntryBB && !IsLeafFunc) {
995 M, Intrinsic::frameaddress,
996 IRB.getPtrTy(
M->getDataLayout().getAllocaAddrSpace()));
999 auto FrameAddrInt = IRB.CreatePtrToInt(FrameAddrPtr, IntptrTy);
1000 auto LowestStack = IRB.CreateLoad(IntptrTy, SanCovLowestStack);
1001 auto IsStackLower = IRB.CreateICmpULT(FrameAddrInt, LowestStack);
1004 auto Store = ThenIRB.CreateStore(FrameAddrInt, SanCovLowestStack);
1005 LowestStack->setNoSanitizeMetadata();
1006 Store->setNoSanitizeMetadata();
1011ModuleSanitizerCoverage::getSectionName(
const std::string &Section)
const {
1012 if (TargetTriple.isOSBinFormatCOFF()) {
1021 if (TargetTriple.isOSBinFormatMachO())
1027ModuleSanitizerCoverage::getSectionStart(
const std::string &Section)
const {
1028 if (TargetTriple.isOSBinFormatMachO())
1029 return "\1section$start$__DATA$__" +
Section;
1030 return "__start___" +
Section;
1034ModuleSanitizerCoverage::getSectionEnd(
const std::string &Section)
const {
1035 if (TargetTriple.isOSBinFormatMachO())
1036 return "\1section$end$__DATA$__" +
Section;
1040void ModuleSanitizerCoverage::createFunctionControlFlow(
Function &
F) {
1042 IRBuilder<> IRB(&*
F.getEntryBlock().getFirstInsertionPt());
1044 for (
auto &BB :
F) {
1046 if (&BB == &
F.getEntryBlock())
1053 assert(SuccBB != &
F.getEntryBlock());
1060 for (
auto &Inst : BB) {
1061 if (
CallBase *CB = dyn_cast<CallBase>(&Inst)) {
1068 if (CalledF && !CalledF->isIntrinsic())
1070 (
Constant *)IRB.CreatePointerCast(CalledF, PtrTy));
1078 FunctionCFsArray = CreateFunctionLocalArrayInSection(
1080 FunctionCFsArray->setInitializer(
1082 FunctionCFsArray->setConstant(
true);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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
const SmallVectorImpl< MachineOperand > & Cond
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)
This is the shared class of boolean and integer constants.
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.
This is a utility class used to parse user-provided text files with "special case lists" for code san...
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)
const StringLiteral & getSectionName(DebugSectionKind SectionKind)
Return the name of the section.
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)
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.
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 ...
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