68#define DEBUG_TYPE "instrumentor"
74template <
typename IRBuilderTy>
void ensureDbgLoc(IRBuilderTy &IRB) {
75 if (IRB.getCurrentDebugLocation())
77 auto *BB = IRB.GetInsertBlock();
78 if (
auto *SP = BB->getParent()->getSubprogram())
79 IRB.SetCurrentDebugLocation(
DILocation::get(BB->getContext(), 0, 0, SP));
85template <
typename IRBTy>
87 bool AllowTruncate =
false) {
90 Type *VTy =
V->getType();
96 return IRB.CreatePointerBitCastOrAddrSpaceCast(
V, Ty);
97 TypeSize RequestedSize =
DL.getTypeSizeInBits(Ty);
98 TypeSize ValueSize =
DL.getTypeSizeInBits(VTy);
99 bool ShouldTruncate = RequestedSize < ValueSize;
100 if (ShouldTruncate && !AllowTruncate)
102 if (ShouldTruncate && AllowTruncate) {
106 IntV = IRB.CreateBitCast(
V, IRB.getIntNTy(ValueSize));
107 return tryToCast(IRB,
108 IRB.CreateIntCast(IntV, IRB.getIntNTy(RequestedSize),
110 Ty,
DL, AllowTruncate);
113 return IRB.CreateIntCast(
V, Ty,
false);
117 return tryToCast(IRB, IRB.CreateBitCast(
V, IRB.getIntNTy(ValueSize)), Ty,
122 if (VTy->
isIntegerTy() && Ty->isFloatingPointTy()) {
123 if (ValueSize == RequestedSize)
124 return IRB.CreateBitCast(
V, Ty);
127 IRB.CreateIntCast(
V, IRB.getIntNTy(RequestedSize),
false),
128 Ty,
DL, AllowTruncate);
130 return IRB.CreateBitOrPointerCast(
V, Ty);
134template <
typename Ty>
136 return ConstantInt::get(
IT, Val, IsSigned);
140 switch (
OpTy.getTypeID()) {
141 case Type::TypeID::ArrayTyID:
142 case Type::TypeID::FixedVectorTyID:
143 case Type::TypeID::ScalableVectorTyID:
144 return getCI(&ReqTy,
OpTy.getContainedType(0)->getTypeID());
149 return getCI(&ReqTy, -1,
true);
154class InstrumentorImpl final {
159 : IConf(IConf), M(M), IIRB(IIRB) {}
167 InstChoicesPRE.clear();
168 InstChoicesPOST.clear();
169 ParsedFunctionRegex =
Regex();
178 bool shouldInstrumentTarget();
181 bool shouldInstrumentFunction(
Function &Fn);
189 bool instrumentFunction(
Function &Fn);
190 bool instrumentModule();
201 Regex ParsedFunctionRegex;
219 Twine(
"failed to parse ") + Name +
" regex: " + ErrMsg,
DS_Error));
227bool InstrumentorImpl::linkRuntime() {
229 if (RuntimeBitcodes.
empty())
234 for (StringRef RuntimeBitcode : RuntimeBitcodes) {
235 if (RuntimeBitcode.empty())
242 Twine(
"Failed to parse runtime bitcode file '") + RuntimeBitcode +
250 Twine(
"Failed to link in runtime bitcode file '") + RuntimeBitcode +
266 InlineFunctionInfo IFI;
268 if (!InlineResult.isSuccess()) {
270 raw_string_ostream
SS(WarnMsg);
271 SS <<
"Inlining of runtime call failed: "
272 << CI->getCalledFunction()->getName() <<
"\n";
273 SS <<
"Reason: " << InlineResult.getFailureReason() <<
"\n";
274 SS <<
"Signatures: " << *CI->getFunctionType() <<
" vs "
275 << *CI->getCalledFunction()->getFunctionType() <<
"\n";
282 auto *Fn = It.first.first;
283 DominatorTree DT(*Fn);
294bool InstrumentorImpl::shouldInstrumentTarget() {
296 const bool IsGPU =
T.
isAMDGPU() ||
T.isNVPTX();
298 bool RegexMatches =
true;
301 RegexMatches = RX.
match(
T.str());
304 return ((IsGPU && IConf.
GPUEnabled->getBool()) ||
309bool InstrumentorImpl::shouldInstrumentFunction(
Function &Fn) {
312 if (Fn.
hasFnAttribute(Attribute::DisableSanitizerInstrumentation))
314 bool RegexMatches =
true;
315 if (ParsedFunctionRegex.
isValid())
321bool InstrumentorImpl::shouldInstrumentGlobalVariable(GlobalVariable &GV) {
326bool InstrumentorImpl::instrumentInstruction(Instruction &
I,
327 InstrumentationCaches &ICaches) {
338 if (
auto *IO = InstChoicesPRE.lookup(
I.getOpcode())) {
339 IIRB.
IRB.SetInsertPoint(&
I);
340 ensureDbgLoc(IIRB.
IRB);
341 IO->instrument(IPtr,
Changed, IConf, IIRB, ICaches);
344 if (
auto *IO = InstChoicesPOST.lookup(
I.getOpcode())) {
345 IIRB.
IRB.SetInsertPoint(
I.getNextNode());
346 ensureDbgLoc(IIRB.
IRB);
347 IO->instrument(IPtr,
Changed, IConf, IIRB, ICaches);
354bool InstrumentorImpl::instrumentFunction(
Function &Fn) {
356 if (!shouldInstrumentFunction(Fn))
359 InstrumentationCaches ICaches;
360 SmallVector<Instruction *> FinalTIs;
361 ReversePostOrderTraversal<Function *> RPOT(&Fn);
362 for (
auto &It : RPOT) {
364 Changed |= instrumentInstruction(
I, ICaches);
366 auto *TI = It->getTerminator();
367 if (!TI->getNumSuccessors())
372 for (
auto &[Name, IO] :
379 IIRB.
IRB.SetInsertPoint(
381 ensureDbgLoc(IIRB.
IRB);
382 IO->instrument(FPtr,
Changed, IConf, IIRB, ICaches);
386 for (
auto &[Name, IO] :
393 for (Instruction *FinalTI : FinalTIs) {
394 IIRB.
IRB.SetInsertPoint(FinalTI);
395 ensureDbgLoc(IIRB.
IRB);
396 IO->instrument(FPtr,
Changed, IConf, IIRB, ICaches);
403bool InstrumentorImpl::instrumentModule() {
406 for (GlobalVariable &GV : M.
globals()) {
409 GV.
getName() ==
"llvm.global_dtors" ||
410 GV.
getName() ==
"llvm.global_ctors")
415 auto CreateYtor = [&](
bool Ctor) {
418 IConf.
getRTName(Ctor ?
"ctor" :
"dtor",
""), M);
421 IIRB.
IRB.SetInsertPoint(EntryBB->begin());
422 ensureDbgLoc(IIRB.
IRB);
423 IIRB.
IRB.CreateRetVoid();
432 InstrumentationCaches ICaches;
434 Function *CtorFn =
nullptr, *DtorFn =
nullptr;
439 Function *&YtorFn = IsPRE ? CtorFn : DtorFn;
440 for (
auto &ChoiceIt : IConf.
IChoices[Loc]) {
441 auto *IO = ChoiceIt.second;
445 YtorFn = CreateYtor(IsPRE);
448 IIRB.
IRB.SetInsertPointPastAllocas(YtorFn);
449 ensureDbgLoc(IIRB.
IRB);
450 Value *YtorPtr = YtorFn;
455 IO->instrument(YtorPtr,
Changed, IConf, IIRB, ICaches);
463 Function *&YtorFn = IsPRE ? CtorFn : DtorFn;
464 for (
auto &ChoiceIt : IConf.
IChoices[Loc]) {
465 auto *IO = ChoiceIt.second;
469 YtorFn = CreateYtor(IsPRE);
472 for (GlobalVariable *GV : Globals) {
473 if (!shouldInstrumentGlobalVariable(*GV))
478 IIRB.
IRB.SetInsertPointPastAllocas(YtorFn);
479 ensureDbgLoc(IIRB.
IRB);
485 IO->instrument(GVPtr,
Changed, IConf, IIRB, ICaches);
494bool InstrumentorImpl::instrument() {
496 if (!shouldInstrumentTarget())
499 StringRef FunctionRegexStr = IConf.
FunctionRegex->getString();
500 ParsedFunctionRegex =
createRegex(FunctionRegexStr,
"function", IIRB.
Ctx);
503 auto RegisterForAllOpcodes = [](
auto &InstChoices,
504 InstrumentationOpportunity *IO) {
505 ArrayRef<unsigned> Opcodes = IO->getAllOpcodes();
507 for (
unsigned Opcode : Opcodes)
508 InstChoices[Opcode] = IO;
511 for (
auto &[Name, IO] :
514 RegisterForAllOpcodes(InstChoicesPRE, IO);
515 for (
auto &[Name, IO] :
518 RegisterForAllOpcodes(InstChoicesPOST, IO);
522 Changed |= instrumentFunction(Fn);
530 InstrumentationConfig *IC,
531 InstrumentorIRBuilderTy *IIRB)
532 : FS(FS), UserIConf(IC), UserIIRB(IIRB) {
542 InstrumentorImpl Impl(IConf, IIRB, M);
553 bool MultipleConfigs = ConfigFiles.size() > 1;
556 std::string ConfigFile =
557 ReadConfig && !ConfigFiles.empty() ? ConfigFiles[Idx] :
"";
569 ? (Opts.instrumentor_write_config_file +
"." + std::to_string(Idx))
571 : Opts.instrumentor_write_config_file.str(),
577 }
while (++Idx < ConfigFiles.size());
586 std::unique_ptr<InstrumentationConfig> IConfInt(
587 !UserIConf ?
new InstrumentationConfig() :
nullptr);
588 std::unique_ptr<InstrumentorIRBuilderTy> IIRBInt(
589 !UserIIRB ?
new InstrumentorIRBuilderTy(M) :
nullptr);
591 auto *IConf = IConfInt ? IConfInt.get() : UserIConf;
592 auto *IIRB = IIRBInt ? IIRBInt.get() : UserIIRB;
594 auto PA = run(M, *IConf, *IIRB, !UserIConf);
600std::unique_ptr<BaseConfigurationOption>
606 BCO->setBool(DefaultValue);
611std::unique_ptr<BaseConfigurationOption>
618 BCO->setString(DefaultValue);
623std::unique_ptr<BaseConfigurationOption>
629 BCO->setStringList(DefaultValue);
654 Twine(
"registered two instrumentation opportunities for the same "
665 Function *Fn = IIRB.
IRB.GetInsertBlock()->getParent();
681 if (!BPIO || !BPIO->Enabled) {
683 "Base pointer info disabled but required, passing nullptr.",
690 std::optional<BasicBlock::iterator> IP =
691 BasePtrI->getInsertionPointAfterDef();
693 IIRB.
IRB.SetInsertPoint(*IP);
696 "Base pointer info could not be placed, passing nullptr.",
701 IIRB.
IRB.SetInsertPointPastAllocas(IIRB.
IRB.GetInsertBlock()->getParent());
706 ensureDbgLoc(IIRB.
IRB);
712 BPI = BPIO->instrument(Obj,
Changed, *
this, IIRB, ICaches);
733 if (V.getType()->isVoidTy())
735 return tryToCast(IIRB.
IRB, &V, &Ty, IIRB.
IRB.getDataLayout());
741 if (V.getType()->isVoidTy())
744 auto *NewVCasted = &NewV;
747 IIRB.
IRB.SetInsertPoint(
I->getNextNode());
748 ensureDbgLoc(IIRB.
IRB);
749 NewVCasted = tryToCast(IIRB.
IRB, &NewV, V.
getType(), IIRB.
DL,
764 for (
auto &It :
IO.IRTArgs) {
767 NumReplaceableArgs += bool(It.Flags & IRTArg::REPLACABLE);
768 MightRequireIndirection |= It.Flags & IRTArg::POTENTIALLY_INDIRECT;
779 "Wrong indirection setting!");
782 for (
auto &It :
IO.IRTArgs) {
811 auto IP = IIRB.
IRB.GetInsertPoint();
814 for (
auto &It :
IO.IRTArgs) {
818 if (!Param || It.NoCache)
820 Param = It.GetterCB(*V, *It.Ty, IConf, IIRB);
823 if (Param->getType()->isVoidTy()) {
825 }
else if (Param->getType()->isAggregateType() ||
826 Param->getType()->isVectorTy() ||
827 DL.getTypeSizeInBits(Param->getType()) >
828 DL.getTypeSizeInBits(It.Ty)) {
831 Twine(
"indirection needed for ") + It.Name +
Twine(
" in ") +
833 Twine(
", but not indicated. Instrumentation is skipped"),
837 ForceIndirection =
true;
839 Param = tryToCast(IIRB.
IRB, Param, It.Ty,
DL);
844 if (ForceIndirection) {
845 Function *Fn = IIRB.
IRB.GetInsertBlock()->getParent();
848 for (
auto &It :
IO.IRTArgs) {
856 auto *&CallParam = CallParams[
Offset++];
858 CallParams.
insert(&CallParam + 1, IIRB.
IRB.getInt32(
DL.getTypeStoreSize(
859 CallParam->getType())));
866 CallParam = CachedParam;
871 IIRB.
IRB.CreateStore(CallParam, AI);
872 CallParam = CachedParam = tryToCast(IIRB.
IRB, AI, IIRB.
PtrTy,
DL);
876 if (!ForceIndirection)
877 IIRB.
IRB.SetInsertPoint(IP);
878 ensureDbgLoc(IIRB.
IRB);
882 IConf.
getRTName(
IO.IP.isPRE() ?
"pre_" :
"post_",
IO.getName(),
883 ForceIndirection ?
"_ind" :
"");
884 auto FC = IIRB.
IRB.getModule()->getOrInsertFunction(CompleteName, FnTy);
885 auto *CI = IIRB.
IRB.CreateCall(FC, CallParams);
888 for (
unsigned I = 0, E =
IO.IRTArgs.size();
I < E; ++
I) {
889 if (!
IO.IRTArgs[
I].Enabled)
894 Value *NewValue = FnTy->isVoidTy() || IsCustomReplaceable
899 if (ForceIndirection && !IsCustomReplaceable &&
904 NewValue = IIRB.
IRB.CreateLoad(V->getType(), Q);
906 V =
IO.IRTArgs[
I].SetterCB(*V, *NewValue, IConf, IIRB);
912 if constexpr (std::is_same<Ty, Use>::value)
913 return ValueOrUse.get();
915 return static_cast<Value *
>(&ValueOrUse);
918template <
typename Range>
921 auto *Fn = IIRB.
IRB.GetInsertBlock()->getParent();
922 auto *I32Ty = IIRB.
IRB.getInt32Ty();
928 if (!
V->getType()->isSized())
931 ConstantValues.
push_back(getCI(I32Ty, VSize));
932 Types.push_back(I32Ty);
933 ConstantValues.
push_back(getCI(I32Ty,
V->getType()->getTypeID()));
934 Types.push_back(I32Ty);
935 if (
uint32_t MisAlign = VSize % 8) {
939 Types.push_back(
V->getType());
960 IIRB.
IRB.CreateMemCpy(AI, AI->getAlign(), GV, GV->
getAlign(),
962 for (
auto [Param, Idx] :
Values) {
963 auto *Ptr = IIRB.
IRB.CreateStructGEP(STy, AI, Idx);
964 IIRB.
IRB.CreateStore(Param, Ptr);
969template <
typename Range>
973 auto *Fn = IIRB.
IRB.GetInsertBlock()->getParent();
976 for (
const auto &[Idx, RE] :
enumerate(R)) {
978 if (!
V->getType()->isSized())
981 auto VSize =
DL.getTypeAllocSize(
V->getType());
982 auto Padding =
alignTo(VSize, 8) - VSize;
984 auto *Ptr = IIRB.
IRB.CreateConstInBoundsGEP1_32(IIRB.
Int8Ty, &Pack,
Offset);
985 auto *NewV = IIRB.
IRB.CreateLoad(
V->getType(), Ptr);
995 return getCI(&Ty,
I.getOpcode());
1002 auto &
DL =
I.getDataLayout();
1003 return getCI(&Ty,
DL.getTypeStoreSize(V.getType()));
1010 return I.getOperand(0);
1017 if (
I.getNumOperands() > 1)
1018 return I.getOperand(1);
1025 return getCI(&Ty, V.getType()->getTypeID());
1031 return getSubTypeID(*V.getType(), Ty);
1038 using namespace std::placeholders;
1052 "Number of function arguments (without varargs).",
IRTArg::NONE,
1056 IIRB.
PtrTy,
"arguments",
"Description of the arguments.",
1064 "Flag to indicate it is the main function.",
1094 return getCI(&Ty, std::distance(FRange.begin(), FRange.end()));
1110 auto CB = [&](
int Idx,
Value *ReplV) {
1129 return getCI(&Ty, Fn.
getName() ==
"main");
1153 IRTArg(IIRB.
PtrTy,
"address",
"The allocated memory address.",
1159 IIRB.
Int64Ty,
"size",
"The allocation size.",
1174 return IIRB.
IRB.CreateAllocationSize(&Ty, &AI);
1181 auto *NewAI = IIRB.
IRB.CreateAlloca(IIRB.
IRB.getInt8Ty(),
1182 DL.getAllocaAddrSpace(), &NewV);
1183 NewAI->setAlignment(AI.getAlign());
1184 AI.replaceAllUsesWith(NewAI);
1203 IRTArg(IIRB.
PtrTy,
"pointer",
"The accessed pointer.",
1210 "The address space of the accessed pointer.",
1215 "The runtime provided base pointer info.",
1243 IIRB.
Int32Ty,
"value_sub_type_id",
1244 "The type id of the stored value (for arrays and vectors, or -1).",
1249 "The atomicity ordering of the store.",
1270 return SI.getPointerOperand();
1276 SI.setOperand(
SI.getPointerOperandIndex(), &NewV);
1283 return getCI(&Ty,
SI.getPointerAddressSpace());
1296 return SI.getValueOperand();
1302 auto &
DL =
SI.getDataLayout();
1303 return getCI(&Ty,
DL.getTypeStoreSize(
SI.getValueOperand()->getType()));
1309 return getCI(&Ty,
SI.getAlign().value());
1315 return getCI(&Ty,
SI.getValueOperand()->getType()->getTypeID());
1322 return getSubTypeID(*
SI.getValueOperand()->getType(), Ty);
1329 return getCI(&Ty,
uint64_t(
SI.getOrdering()));
1335 return getCI(&Ty,
uint64_t(
SI.getSyncScopeID()));
1341 return getCI(&Ty,
SI.isVolatile());
1351 IRTArg(IIRB.
PtrTy,
"pointer",
"The accessed pointer.",
1358 "The address space of the accessed pointer.",
1363 "The runtime provided base pointer info.",
1393 IIRB.
Int32Ty,
"value_sub_type_id",
1394 "The sub type id of the loaded value (for arrays and vectors, or -1).",
1399 "The atomicity ordering of the load.",
1420 return LI.getPointerOperand();
1426 LI.setOperand(LI.getPointerOperandIndex(), &NewV);
1433 return getCI(&Ty, LI.getPointerAddressSpace());
1451 auto &
DL = LI.getDataLayout();
1452 return getCI(&Ty,
DL.getTypeStoreSize(LI.getType()));
1458 return getCI(&Ty, LI.getAlign().value());
1464 return getCI(&Ty, LI.getType()->getTypeID());
1471 return getSubTypeID(*LI.getType(), Ty);
1478 return getCI(&Ty,
uint64_t(LI.getOrdering()));
1484 return getCI(&Ty,
uint64_t(LI.getSyncScopeID()));
1490 return getCI(&Ty, LI.isVolatile());
1499 "The base pointer in question.",
1503 IIRB.
Int32Ty,
"base_pointer_kind",
1504 "The base pointer kind (argument, global, instruction, unknown).",
1514 return getCI(&Ty, 0);
1516 return getCI(&Ty, 1);
1518 return getCI(&Ty, 2);
1519 return getCI(&Ty, 3);
1529 "The module/translation unit name.",
1560 IIRB.
PtrTy,
"address",
1561 "The address of the global (replaceable for definitions).",
1570 "The size of the declared type of the global.",
1581 IIRB.
Int64Ty,
"initial_value",
"The initial value of the global.",
1590 "Flag to indicate global definitions.",
1614 DL.getDefaultGlobalsAddressSpace());
1619 IIRB.
IRB.CreateStore(&NewV, ShadowGV);
1627 auto MakeInstForConst = [&](
Use &U) {
1633 I = CE->getAsInstruction();
1647 while (!Worklist.
empty()) {
1650 U->set(ReloadMap[
I->getFunction()]);
1653 if (
auto *CI = ConstToInstMap[*U]) {
1654 auto *CIClone = CI->clone();
1657 auto *BB =
PHI->getIncomingBlock(U->getOperandNo());
1658 CIClone->insertBefore(BB->getTerminator()->getIterator());
1660 CIClone->insertBefore(
I->getIterator());
1663 for (
auto &CICUse : CIClone->operands()) {
1670 while (!Worklist.
empty()) {
1672 if (!
Done.insert(U).second)
1674 MakeInstForConst(*U);
1685 if (
II->getIntrinsicID() == Intrinsic::eh_typeid_for)
1688 InsertConsts(
I, *U);
1691 for (
auto &It : ConstToInstMap)
1693 It.second->deleteValue();
1707 return getCI(&Ty, Alignment ? Alignment->value() : 0);
1761 IIRB.
Int32Ty,
"input_sub_type_id",
1762 "The sub type id of the input value (for arrays and vectors, or -1).",
1781 IIRB.
Int32Ty,
"result_sub_type_id",
1782 "The sub type id of the result value (for arrays and vectors, or -1).",
1790 "The opcode of the cast instruction.",
1800 return CI.getOperand(0);
1806 return getCI(&Ty, CI.getSrcTy()->getTypeID());
1813 return getSubTypeID(*CI.getSrcTy(), Ty);
1819 auto &
DL = CI.getDataLayout();
1820 return getCI(&Ty,
DL.getTypeStoreSize(CI.getSrcTy()));
1826 return getCI(&Ty, CI.getDestTy()->getTypeID());
1833 return getSubTypeID(*CI.getDestTy(), Ty);
1839 auto &
DL = CI.getDataLayout();
1840 return getCI(&Ty,
DL.getTypeStoreSize(CI.getDestTy()));
1849 switch (
I.getOpcode()) {
1850 case Instruction::Add:
1851 case Instruction::Sub:
1852 case Instruction::Mul:
1853 case Instruction::Shl:
1854 if (
I.hasNoSignedWrap())
1856 if (
I.hasNoUnsignedWrap())
1859 case Instruction::FAdd:
1860 case Instruction::FSub:
1861 case Instruction::FMul:
1862 case Instruction::FDiv:
1863 case Instruction::FNeg:
1868 if (
I.hasNoSignedZeros())
1871 case Instruction::AShr:
1872 case Instruction::LShr:
1873 case Instruction::SDiv:
1874 case Instruction::UDiv:
1881 if (DI->isDisjoint())
1884 return getCI(&Ty, Flag);
1901 const auto ValArgOpts =
1911 "The operation's sub type id (for arrays and vectors, or -1).",
1921 "The operation's left operand.", ValArgOpts,
1925 "The operation's right operand. This value is "
1926 "poison for unary operations.",
1936 "A bitmask value signaling which instruction flags are present.",
1947 return getCI(&Ty,
I.getOperand(0)->getType()->getTypeID());
1954 auto &
DL =
I.getDataLayout();
1955 return getCI(&Ty,
DL.getTypeStoreSize(
I.getOperand(0)->getType()));
1961 return getCI(&Ty, CI->getPredicate());
1976 switch (
I.getOpcode()) {
1977 case Instruction::ICmp:
1981 case Instruction::FCmp:
1986 if (
I.hasNoSignedZeros())
1991 return getCI(&Ty, Flag);
1999 const auto OperandArgOpts =
2019 "The comparison's left operand.", OperandArgOpts,
2023 "The comparison's right operand.", OperandArgOpts,
2043 "A bitmask value signaling which instruction flags are present.",
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMap class.
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
post inline ee instrument
Hexagon Lower HLX Pair Allocas
static MaybeAlign getAlign(Value *Ptr)
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
@ COMPARE_FLAG_HAS_NO_NANS
@ COMPARE_FLAG_HAS_NO_INFS
@ COMPARE_FLAG_HAS_NO_SIGNED_ZEROS
@ NUMERIC_FLAG_NO_SIGNED_WRAP
@ NUMERIC_FLAG_NO_UNSIGNED_WRAP
@ NUMERIC_FLAG_HAS_NO_SIGNED_ZEROS
@ NUMERIC_FLAG_HAS_NO_INFS
@ NUMERIC_FLAG_HAS_NO_NANS
@ NUMERIC_FLAG_IS_DISJOINT
static void readValuePack(const Range &R, Value &Pack, InstrumentorIRBuilderTy &IIRB, function_ref< void(int, Value *)> SetterCB)
static constexpr Value * getValue(Ty &ValueOrUse)
static Value * createValuePack(const Range &R, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static Regex createRegex(StringRef Str, StringRef Name, LLVMContext &Ctx)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
ModuleAnalysisManager MAM
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
Defines the virtual file system interface vfs::FileSystem.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
Check if the array is empty.
static LLVM_ABI ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
static LLVM_ABI Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
LLVM_ABI const_iterator getFirstNonPHIOrAlloca() const
Returns an iterator to the first instruction in this block that is not a PHINode, a static alloca,...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
This class represents a function call, abstracting a target machine's calling convention.
static LLVM_ABI Constant * getAddrSpaceCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static LLVM_ABI ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)
This is an important base class in LLVM.
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
static LLVM_ABI 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.
LLVM_ABI TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Diagnostic information for IR instrumentation reporting.
Class to represent function types.
static LLVM_ABI FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
const BasicBlock & getEntryBlock() const
const DataLayout & getDataLayout() const
Get the data layout of the module this function belongs to.
iterator_range< arg_iterator > args()
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Argument * getArg(unsigned i) const
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
StringRef getSection() const
Get the custom section of this global if it has one.
LLVM_ABI bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
LinkageTypes getLinkage() const
ThreadLocalMode getThreadLocalMode() const
unsigned getAddressSpace() const
Module * getParent()
Get the module that this global value is contained inside of...
PointerType * getType() const
Global values are always pointers.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
LLVM_ABI InstrumentorPass(IntrusiveRefCntPtr< vfs::FileSystem > FS=nullptr, InstrumentationConfig *IC=nullptr, InstrumentorIRBuilderTy *IIRB=nullptr)
Construct an instrumentor pass that will use the instrumentation configuration IC and the IR builder ...
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.
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
static LLVM_ABI bool linkModules(Module &Dest, std::unique_ptr< Module > Src, unsigned Flags=Flags::None, std::function< void(Module &, const StringSet<> &)> InternalizeCallback={})
This function links two modules together, with the resulting Dest module modified to be the composite...
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.
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
LLVMContext & getContext() const
Get the global data context.
size_t global_size() const
StringRef getName() const
Get a short "name" for the module.
iterator_range< global_iterator > globals()
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
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.
LLVM_ABI bool isValid(std::string &Error) const
isValid - returns the error encountered during regex compilation, if any.
LLVM_ABI bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr, std::string *Error=nullptr) const
matches - Match the regex against a given String.
StringRef getMessage() const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
void reserve(size_type N)
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Class to represent struct types.
static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
const std::string & getTriple() const
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.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isAggregateType() const
Return true if the type is an aggregate type.
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
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.
LLVM_ABI bool replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
iterator_range< use_iterator > uses()
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI void writeConfigToJSON(InstrumentationConfig &IConf, StringRef OutputFile, LLVMContext &Ctx)
Write the configuration in /p IConf to the file with path OutputFile.
LLVM_ABI bool readConfigFromJSON(InstrumentationConfig &IConf, StringRef InputFile, LLVMContext &Ctx, vfs::FileSystem &FS)
Read the configuration from the file with path InputFile into /p IConf.
LLVM_ABI void printRuntimeStub(const InstrumentationConfig &IConf, StringRef StubRuntimeName, LLVMContext &Ctx)
Print a runtime stub file with the implementation of the instrumentation runtime functions correspond...
LLVM_ABI bool readConfigPathsFile(StringRef InputFile, SmallVectorImpl< std::string > &Configs, LLVMContext &Ctx, vfs::FileSystem &FS)
Read the configuration paths from the file with path InputFile into Configs.
LLVM_ABI 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.
LLVM_ABI void PromoteMemToReg(ArrayRef< AllocaInst * > Allocas, DominatorTree &DT, AssumptionCache *AC=nullptr)
Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appro...
RelativeUniformCounterPtr Values
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
LLVM_ABI InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, bool TrackInlineHistory=false, Function *ForwardVarArgsTo=nullptr, OptimizationRemarkEmitter *ORE=nullptr)
This function inlines the called function into the basic block of the caller.
LLVM_ABI bool isAllocaPromotable(const AllocaInst *AI)
Return true if this alloca is legal for promotion.
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
const IPOOptions & getIPOOptions(const LLVMContext &C)
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
LLVM_ABI const Value * getUnderlyingObjectAggressive(const Value *V, bool MustPreserveProvenance=false)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI 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.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
iterator_range< pointer_iterator< WrappedIteratorT > > make_pointer_range(RangeT &&Range)
LLVM_ABI std::unique_ptr< Module > parseIRFile(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context, ParserCallbacks Callbacks={}, AsmParserContext *ParserContext=nullptr)
If the given file holds a bitcode image, return a Module for it.
LLVM_ABI void appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Same as appendToGlobalCtors(), but for global dtors.
SmallVector< Out, Size > to_vector_of(R &&Range)
DEMANGLE_ABI std::string demangle(std::string_view MangledName)
Attempt to demangle a string using different demangling schemes.
LLVM_ABI bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
}
BaseConfigTy< ConfigKind > ConfigTy
static LLVM_ABI Value * getSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * setSize(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAlignment(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI std::unique_ptr< BaseConfigurationOption > createStringListOption(InstrumentationConfig &IC, StringRef Name, StringRef Description, ArrayRef< StringRef > DefaultValue)
Create a string-list option with Name name, Description description and DefaultValue as string-list d...
static LLVM_ABI std::unique_ptr< BaseConfigurationOption > createStringOption(InstrumentationConfig &IC, StringRef Name, StringRef Description, StringRef DefaultValue)
Create a string option with Name name, Description description and DefaultValue as string default val...
static LLVM_ABI std::unique_ptr< BaseConfigurationOption > createBoolOption(InstrumentationConfig &IC, StringRef Name, StringRef Description, bool DefaultValue)
Create a boolean option with Name name, Description description and DefaultValue as boolean default v...
static LLVM_ABI Value * getOpcode(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getRightOperand(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getSubTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getTypeSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getLeftOperand(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getPointerKind(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static Value * setValueNoop(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
This is necessary to produce a return value that can be used by other IOs.
BaseConfigTy< ConfigKind > ConfigTy
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
CastIO {.
static LLVM_ABI Value * getResultTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getInputSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getResultSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getResultSubTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getInput(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getInputSubTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
static LLVM_ABI Value * getInputTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getFlags(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getOperandSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getOperandTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
LLVM_ABI void addFlagNames()
static LLVM_ABI Value * getPredicate(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
llvm::instrumentor::FunctionIO::ConfigTy Config
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI Value * setArguments(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getFunctionAddress(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * isMainFunction(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI Value * getArguments(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI Value * getNumArguments(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getFunctionName(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
FunctionIO {.
static LLVM_ABI Value * setAddress(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
static LLVM_ABI Value * getAS(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAlignment(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getInitialValue(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * isDefinition(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getDeclaredSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getSymbolName(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAddress(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
static LLVM_ABI Value * isConstant(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
bool isReplacable(IRTArg &IRTA) const
Return whether the IRTA argument can be replaced.
LLVM_ABI IRTCallDescription(InstrumentationOpportunity &IO, Type *RetTy=nullptr)
Construct an instrumentation function description linked to the IO instrumentation opportunity and Re...
bool MightRequireIndirection
Whether any argument may require indirection.
LLVM_ABI CallInst * createLLVMCall(Value *&V, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, const DataLayout &DL, InstrumentationCaches &ICaches)
Create a call instruction that calls to the instrumentation function and passes the corresponding arg...
Type * RetTy
The return type of the instrumentation function.
InstrumentationOpportunity & IO
The instrumentation opportunity which it is linked to.
LLVM_ABI FunctionType * createLLVMSignature(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, const DataLayout &DL, bool ForceIndirection)
Create the type of the instrumentation function.
unsigned NumReplaceableArgs
The number of arguments that can be replaced.
bool RequiresIndirection
Whether the function requires indirection in some argument.
bool isPotentiallyIndirect(IRTArg &IRTA) const
Return whether the function may have any indirect argument.
Helper that represent the caches for instrumentation call arguments.
DenseMap< std::tuple< unsigned, StringRef, StringRef >, Value * > DirectArgCache
A cache for direct and indirect arguments.
DenseMap< std::tuple< unsigned, StringRef, StringRef >, Value * > IndirectArgCache
The class that contains the configuration for the instrumentor.
virtual void populate(InstrumentorIRBuilderTy &IIRB)
Populate the instrumentation opportunities.
std::unique_ptr< BaseConfigurationOption > InlineRuntimeEagerly
void addChoice(InstrumentationOpportunity &IO, LLVMContext &Ctx)
Register instrumentation opportunity IO.
Constant * getGlobalString(StringRef S, InstrumentorIRBuilderTy &IIRB)
DenseMap< Value *, Value * > UnderlyingObjsMap
Map to remember underlying objects for pointers.
std::unique_ptr< BaseConfigurationOption > HostEnabled
std::unique_ptr< BaseConfigurationOption > DemangleFunctionNames
void init(InstrumentorIRBuilderTy &IIRB)
Initialize the config to a clean base state without loosing cached values that can be reused across c...
DenseMap< std::pair< Value *, Function * >, Value * > BasePointerInfoMap
Map to remember base pointer info for values in a specific function.
EnumeratedArray< MapVector< StringRef, InstrumentationOpportunity * >, InstrumentationLocation::KindTy > IChoices
The map registered instrumentation opportunities.
std::unique_ptr< BaseConfigurationOption > GPUEnabled
std::unique_ptr< BaseConfigurationOption > RuntimeBitcodes
DenseMap< Constant *, GlobalVariable * > ConstantGlobalsCache
Mapping from constants to globals with the constant as initializer.
Value * getBasePointerInfo(Value &V, InstrumentorIRBuilderTy &IIRB)
Return the base pointer info for V.
std::unique_ptr< BaseConfigurationOption > RuntimeStubsFile
StringRef getRTName() const
Get the runtime prefix for the instrumentation runtime functions.
void addBaseChoice(BaseConfigurationOption *BCO)
Add the base configuration option BCO into the list of base options.
std::unique_ptr< BaseConfigurationOption > FunctionRegex
std::unique_ptr< BaseConfigurationOption > TargetRegex
bool isPRE() const
Return whether the instrumentation location is before the event occurs.
Base class for instrumentation opportunities.
InstrumentationLocation::KindTy getLocationKind() const
Get the location kind of the instrumentation opportunity.
static LLVM_ABI Value * getIdPre(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
Get the opportunity identifier for the pre and post positions.
static LLVM_ABI Value * forceCast(Value &V, Type &Ty, InstrumentorIRBuilderTy &IIRB)
Helpers to cast values, pass them to the runtime, and replace them.
static int32_t getIdFromEpoch(uint32_t CurrentEpoch)
}
static LLVM_ABI Value * getIdPost(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static Value * getValue(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * replaceValue(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
StringMap< int32_t > FlagNames
Flag names and their integer bitmask values.
virtual StringRef getName() const =0
Get the name of the instrumentation opportunity.
SmallVector< IRTArg > IRTArgs
The list of possible arguments for the instrumentation runtime function.
void addCommonArgs(InstrumentationConfig &IConf, LLVMContext &Ctx, bool PassId)
}
An IR builder augmented with extra information for the instrumentor pass.
IRBuilder< ConstantFolder, IRBuilderCallbackInserter > IRB
The underlying IR builder with insertion callback.
unsigned Epoch
The current epoch number.
AllocaInst * getAlloca(Function *Fn, Type *Ty)
Get a temporary alloca to communicate (large) values with the runtime.
void returnAllocas()
Return the temporary allocas.
DenseMap< Instruction *, unsigned > NewInsts
A mapping from instrumentation instructions to the epoch they have been created.
DenseMap< std::pair< Function *, unsigned >, AllocaListTy * > AllocaMap
Map that holds a list of currently available allocas for a function and alloca size.
void eraseLater(Instruction *I)
Save instruction I to be erased later.
static LLVM_ABI Value * getValueSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getSyncScopeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAtomicityOrdering(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
virtual Type * getValueType(InstrumentorIRBuilderTy &IIRB) const
}
static LLVM_ABI Value * getValueSubTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getValue(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAlignment(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getPointer(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
Getters and setters for the arguments of the instrumentation function for the load opportunity.
static LLVM_ABI Value * isVolatile(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getBasePointerInfo(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * setPointer(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
static LLVM_ABI Value * getPointerAS(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
}
static LLVM_ABI Value * getValueTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
Initialize the load opportunity using the instrumentation config IConf and the user config UserConfig...
static LLVM_ABI Value * getModuleName(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getTargetTriple(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
BaseConfigTy< ConfigKind > ConfigTy
LLVM_ABI void addFlagNames()
static LLVM_ABI Value * getFlags(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
}
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
static LLVM_ABI Value * getPointer(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
Getters and setters for the arguments of the instrumentation function for the store opportunity.
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
}
static LLVM_ABI Value * getValueTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
virtual Type * getValueType(InstrumentorIRBuilderTy &IIRB) const
}
static LLVM_ABI Value * getSyncScopeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getPointerAS(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAlignment(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getValue(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * setPointer(Value &V, Value &NewV, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * isVolatile(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getValueSize(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getValueSubTypeId(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
BaseConfigTy< ConfigKind > ConfigTy
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
Initialize the store opportunity using the instrumentation config IConf and the user config UserConfi...
static LLVM_ABI Value * getBasePointerInfo(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static LLVM_ABI Value * getAtomicityOrdering(Value &V, Type &Ty, InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
static void populate(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB)
LLVM_ABI void init(InstrumentationConfig &IConf, InstrumentorIRBuilderTy &IIRB, ConfigTy *UserConfig=nullptr)
UnreachableIO {.
BaseConfigTy< ConfigKind > ConfigTy