[llvm] 9ae87b5 - [Instrumentation] Share InstrumentationIRBuilder between TSan and SanCov
Marco Elver via llvm-commits
llvm-commits at lists.llvm.org
Fri May 6 00:15:46 PDT 2022
Author: Marco Elver
Date: 2022-05-06T09:15:17+02:00
New Revision: 9ae87b597351765ad4a925abffd208a94b0f3a21
URL: https://github.com/llvm/llvm-project/commit/9ae87b597351765ad4a925abffd208a94b0f3a21
DIFF: https://github.com/llvm/llvm-project/commit/9ae87b597351765ad4a925abffd208a94b0f3a21.diff
LOG: [Instrumentation] Share InstrumentationIRBuilder between TSan and SanCov
Factor our InstrumentationIRBuilder and share it between ThreadSanitizer
and SanitizerCoverage. Simplify its usage at the same time (use function
of passed Instruction or BasicBlock).
This class may be used in other instrumentation passes in future.
NFCI.
Reviewed By: nickdesaulniers
Differential Revision: https://reviews.llvm.org/D125038
Added:
Modified:
llvm/include/llvm/Transforms/Instrumentation.h
llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/Instrumentation.h b/llvm/include/llvm/Transforms/Instrumentation.h
index 37acbff6b801..9ff45fc29b06 100644
--- a/llvm/include/llvm/Transforms/Instrumentation.h
+++ b/llvm/include/llvm/Transforms/Instrumentation.h
@@ -15,6 +15,10 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Instruction.h"
#include <cassert>
#include <cstdint>
#include <limits>
@@ -179,6 +183,26 @@ static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) {
assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits");
return Scaled;
}
+
+// Use to ensure the inserted instrumentation has a DebugLocation; if none is
+// attached to the source instruction, try to use a DILocation with offset 0
+// scoped to surrounding function (if it has a DebugLocation).
+//
+// Some non-call instructions may be missing debug info, but when inserting
+// instrumentation calls, some builds (e.g. LTO) want calls to have debug info
+// if the enclosing function does.
+struct InstrumentationIRBuilder : IRBuilder<> {
+ static void ensureDebugInfo(IRBuilder<> &IRB, const Function &F) {
+ if (IRB.getCurrentDebugLocation())
+ return;
+ if (DISubprogram *SP = F.getSubprogram())
+ IRB.SetCurrentDebugLocation(DILocation::get(SP->getContext(), 0, 0, SP));
+ }
+
+ explicit InstrumentationIRBuilder(Instruction *IP) : IRBuilder<>(IP) {
+ ensureDebugInfo(*this, *IP->getFunction());
+ }
+};
} // end namespace llvm
#endif // LLVM_TRANSFORMS_INSTRUMENTATION_H
diff --git a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
index e732250d6544..61628223ddef 100644
--- a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
+++ b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
@@ -990,15 +990,11 @@ void ModuleSanitizerCoverage::InjectCoverageAtBlock(Function &F, BasicBlock &BB,
// if we aren't splitting the block, it's nice for allocas to be before
// calls.
IP = PrepareToSplitEntryBlock(BB, IP);
- } else {
- EntryLoc = IP->getDebugLoc();
- if (!EntryLoc)
- if (auto *SP = F.getSubprogram())
- EntryLoc = DILocation::get(SP->getContext(), 0, 0, SP);
}
- IRBuilder<> IRB(&*IP);
- IRB.SetCurrentDebugLocation(EntryLoc);
+ InstrumentationIRBuilder IRB(&*IP);
+ if (EntryLoc)
+ IRB.SetCurrentDebugLocation(EntryLoc);
if (Options.TracePC) {
IRB.CreateCall(SanCovTracePC)
->setCannotMerge(); // gets the PC using GET_CALLER_PC.
diff --git a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
index 18d5a679c12d..765baea4b80b 100644
--- a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
@@ -43,6 +43,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/EscapeEnumerator.h"
#include "llvm/Transforms/Utils/Local.h"
@@ -133,10 +134,8 @@ struct ThreadSanitizer {
};
void initialize(Module &M);
- bool instrumentLoadOrStore(const InstructionInfo &II, const DataLayout &DL,
- const Function &F);
- bool instrumentAtomic(Instruction *I, const DataLayout &DL,
- const Function &F);
+ bool instrumentLoadOrStore(const InstructionInfo &II, const DataLayout &DL);
+ bool instrumentAtomic(Instruction *I, const DataLayout &DL);
bool instrumentMemIntrinsic(Instruction *I);
void chooseInstructionsToInstrument(SmallVectorImpl<Instruction *> &Local,
SmallVectorImpl<InstructionInfo> &All,
@@ -182,28 +181,6 @@ void insertModuleCtor(Module &M) {
// time. Hook them into the global ctors list in that case:
[&](Function *Ctor, FunctionCallee) { appendToGlobalCtors(M, Ctor, 0); });
}
-
-// Use to ensure the inserted instrumentation has a DebugLocation; if none is
-// attached to the source instruction, try to use a DILocation with offset 0
-// scoped to surrounding function (if it has a DebugLocation).
-//
-// Some non-call instructions may be missing debug info, but when inserting
-// instrumentation calls, some builds (e.g. LTO) want calls to have debug info
-// if the enclosing function does.
-struct InstrumentationIRBuilder : IRBuilder<> {
- static void ensureDebugInfo(IRBuilder<> &IRB, const Function &F) {
- if (IRB.getCurrentDebugLocation())
- return;
- if (DISubprogram *SP = F.getSubprogram())
- IRB.SetCurrentDebugLocation(DILocation::get(SP->getContext(), 0, 0, SP));
- }
-
- explicit InstrumentationIRBuilder(Instruction *I, const Function &F)
- : IRBuilder<>(I) {
- ensureDebugInfo(*this, F);
- }
-};
-
} // namespace
PreservedAnalyses ThreadSanitizerPass::run(Function &F,
@@ -514,7 +491,7 @@ static bool isTsanAtomic(const Instruction *I) {
}
void ThreadSanitizer::InsertRuntimeIgnores(Function &F) {
- InstrumentationIRBuilder IRB(F.getEntryBlock().getFirstNonPHI(), F);
+ InstrumentationIRBuilder IRB(F.getEntryBlock().getFirstNonPHI());
IRB.CreateCall(TsanIgnoreBegin);
EscapeEnumerator EE(F, "tsan_ignore_cleanup", ClHandleCxxExceptions);
while (IRBuilder<> *AtExit = EE.Next()) {
@@ -578,14 +555,14 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
// Instrument memory accesses only if we want to report bugs in the function.
if (ClInstrumentMemoryAccesses && SanitizeFunction)
for (const auto &II : AllLoadsAndStores) {
- Res |= instrumentLoadOrStore(II, DL, F);
+ Res |= instrumentLoadOrStore(II, DL);
}
// Instrument atomic memory accesses in any case (they can be used to
// implement synchronization).
if (ClInstrumentAtomics)
for (auto Inst : AtomicAccesses) {
- Res |= instrumentAtomic(Inst, DL, F);
+ Res |= instrumentAtomic(Inst, DL);
}
if (ClInstrumentMemIntrinsics && SanitizeFunction)
@@ -601,7 +578,7 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
// Instrument function entry/exit points if there were instrumented accesses.
if ((Res || HasCalls) && ClInstrumentFuncEntryExit) {
- InstrumentationIRBuilder IRB(F.getEntryBlock().getFirstNonPHI(), F);
+ InstrumentationIRBuilder IRB(F.getEntryBlock().getFirstNonPHI());
Value *ReturnAddress = IRB.CreateCall(
Intrinsic::getDeclaration(F.getParent(), Intrinsic::returnaddress),
IRB.getInt32(0));
@@ -618,9 +595,8 @@ bool ThreadSanitizer::sanitizeFunction(Function &F,
}
bool ThreadSanitizer::instrumentLoadOrStore(const InstructionInfo &II,
- const DataLayout &DL,
- const Function &F) {
- InstrumentationIRBuilder IRB(II.Inst, F);
+ const DataLayout &DL) {
+ InstrumentationIRBuilder IRB(II.Inst);
const bool IsWrite = isa<StoreInst>(*II.Inst);
Value *Addr = IsWrite ? cast<StoreInst>(II.Inst)->getPointerOperand()
: cast<LoadInst>(II.Inst)->getPointerOperand();
@@ -748,9 +724,8 @@ bool ThreadSanitizer::instrumentMemIntrinsic(Instruction *I) {
// The following page contains more background information:
// http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/
-bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL,
- const Function &F) {
- InstrumentationIRBuilder IRB(I, F);
+bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
+ InstrumentationIRBuilder IRB(I);
if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
Value *Addr = LI->getPointerOperand();
Type *OrigTy = LI->getType();
More information about the llvm-commits
mailing list