[llvm] 0e0759f - Revert "[LegacyPM] Remove AddressSanitizerLegacyPass"
Nico Weber via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 21 19:14:52 PDT 2022
Author: Nico Weber
Date: 2022-04-21T22:14:36-04:00
New Revision: 0e0759f441c9d9433ae8f13ed9f274f3d3e856a8
URL: https://github.com/llvm/llvm-project/commit/0e0759f441c9d9433ae8f13ed9f274f3d3e856a8
DIFF: https://github.com/llvm/llvm-project/commit/0e0759f441c9d9433ae8f13ed9f274f3d3e856a8.diff
LOG: Revert "[LegacyPM] Remove AddressSanitizerLegacyPass"
This reverts commit e68c589e53da4a53bf1cea79a9cb38308edbb8c6.
Breaks check-llvm, see comments on https://reviews.llvm.org/D124216
Added:
Modified:
llvm/bindings/go/llvm/InstrumentationBindings.cpp
llvm/bindings/go/llvm/InstrumentationBindings.h
llvm/bindings/go/llvm/transforms_instrumentation.go
llvm/include/llvm/InitializePasses.h
llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
llvm/lib/Transforms/Instrumentation/Instrumentation.cpp
Removed:
################################################################################
diff --git a/llvm/bindings/go/llvm/InstrumentationBindings.cpp b/llvm/bindings/go/llvm/InstrumentationBindings.cpp
index a7d1b999a250d..30eb4e3a7b4c4 100644
--- a/llvm/bindings/go/llvm/InstrumentationBindings.cpp
+++ b/llvm/bindings/go/llvm/InstrumentationBindings.cpp
@@ -16,11 +16,20 @@
#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
#include "llvm/Transforms/Instrumentation.h"
+#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
using namespace llvm;
+void LLVMAddAddressSanitizerFunctionPass(LLVMPassManagerRef PM) {
+ unwrap(PM)->add(createAddressSanitizerFunctionPass());
+}
+
+void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM) {
+ unwrap(PM)->add(createModuleAddressSanitizerLegacyPassPass());
+}
+
void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM) {
unwrap(PM)->add(createThreadSanitizerLegacyPassPass());
}
diff --git a/llvm/bindings/go/llvm/InstrumentationBindings.h b/llvm/bindings/go/llvm/InstrumentationBindings.h
index 405dc7e469aef..edb5f79e0011b 100644
--- a/llvm/bindings/go/llvm/InstrumentationBindings.h
+++ b/llvm/bindings/go/llvm/InstrumentationBindings.h
@@ -23,6 +23,8 @@ extern "C" {
// a (somewhat) less stable collection of C APIs for use in creating bindings of
// LLVM in other languages.
+void LLVMAddAddressSanitizerFunctionPass(LLVMPassManagerRef PM);
+void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM);
void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM);
void LLVMAddDataFlowSanitizerPass(LLVMPassManagerRef PM, int ABIListFilesNum,
const char **ABIListFiles);
diff --git a/llvm/bindings/go/llvm/transforms_instrumentation.go b/llvm/bindings/go/llvm/transforms_instrumentation.go
index cddabc76b95cf..f8b5991341d6e 100644
--- a/llvm/bindings/go/llvm/transforms_instrumentation.go
+++ b/llvm/bindings/go/llvm/transforms_instrumentation.go
@@ -19,6 +19,14 @@ package llvm
import "C"
import "unsafe"
+func (pm PassManager) AddAddressSanitizerFunctionPass() {
+ C.LLVMAddAddressSanitizerFunctionPass(pm.C)
+}
+
+func (pm PassManager) AddAddressSanitizerModulePass() {
+ C.LLVMAddAddressSanitizerModulePass(pm.C)
+}
+
func (pm PassManager) AddThreadSanitizerPass() {
C.LLVMAddThreadSanitizerPass(pm.C)
}
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index cc286affac7db..96f12fa7cf926 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -62,6 +62,9 @@ void initializeAAResultsWrapperPassPass(PassRegistry&);
void initializeADCELegacyPassPass(PassRegistry&);
void initializeAddDiscriminatorsLegacyPassPass(PassRegistry&);
void initializeAddFSDiscriminatorsPass(PassRegistry &);
+void initializeModuleAddressSanitizerLegacyPassPass(PassRegistry &);
+void initializeASanGlobalsMetadataWrapperPassPass(PassRegistry &);
+void initializeAddressSanitizerLegacyPassPass(PassRegistry &);
void initializeAggressiveInstCombinerLegacyPassPass(PassRegistry&);
void initializeAliasSetPrinterPass(PassRegistry&);
void initializeAlignmentFromAssumptionsPass(PassRegistry&);
diff --git a/llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h b/llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
index 1b4426ea28506..69f0a8014b6dd 100644
--- a/llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
+++ b/llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h
@@ -126,6 +126,17 @@ class ModuleAddressSanitizerPass
AsanDtorKind DestructorKind;
};
+// Insert AddressSanitizer (address basic correctness checking) instrumentation
+FunctionPass *createAddressSanitizerFunctionPass(
+ bool CompileKernel = false, bool Recover = false,
+ bool UseAfterScope = false,
+ AsanDetectStackUseAfterReturnMode UseAfterReturn =
+ AsanDetectStackUseAfterReturnMode::Runtime);
+ModulePass *createModuleAddressSanitizerLegacyPassPass(
+ bool CompileKernel = false, bool Recover = false, bool UseGlobalsGC = true,
+ bool UseOdrIndicator = true,
+ AsanDtorKind DestructorKind = AsanDtorKind::Global);
+
struct ASanAccessInfo {
const int32_t Packed;
const uint8_t AccessSizeIndex;
diff --git a/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
index 751ec39e2d011..7dfe98c1a92a0 100644
--- a/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
@@ -623,6 +623,37 @@ static uint64_t GetCtorAndDtorPriority(Triple &TargetTriple) {
namespace {
+/// Module analysis for getting various metadata about the module.
+class ASanGlobalsMetadataWrapperPass : public ModulePass {
+public:
+ static char ID;
+
+ ASanGlobalsMetadataWrapperPass() : ModulePass(ID) {
+ initializeASanGlobalsMetadataWrapperPassPass(
+ *PassRegistry::getPassRegistry());
+ }
+
+ bool runOnModule(Module &M) override {
+ GlobalsMD = GlobalsMetadata(M);
+ return false;
+ }
+
+ StringRef getPassName() const override {
+ return "ASanGlobalsMetadataWrapperPass";
+ }
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.setPreservesAll();
+ }
+
+ GlobalsMetadata &getGlobalsMD() { return GlobalsMD; }
+
+private:
+ GlobalsMetadata GlobalsMD;
+};
+
+char ASanGlobalsMetadataWrapperPass::ID = 0;
+
/// AddressSanitizer: instrument the code in module to find memory bugs.
struct AddressSanitizer {
AddressSanitizer(Module &M, const GlobalsMetadata *GlobalsMD,
@@ -758,6 +789,52 @@ struct AddressSanitizer {
FunctionCallee AMDGPUAddressPrivate;
};
+class AddressSanitizerLegacyPass : public FunctionPass {
+public:
+ static char ID;
+
+ explicit AddressSanitizerLegacyPass(
+ bool CompileKernel = false, bool Recover = false,
+ bool UseAfterScope = false,
+ AsanDetectStackUseAfterReturnMode UseAfterReturn =
+ AsanDetectStackUseAfterReturnMode::Runtime)
+ : FunctionPass(ID), CompileKernel(CompileKernel), Recover(Recover),
+ UseAfterScope(UseAfterScope), UseAfterReturn(UseAfterReturn) {
+ initializeAddressSanitizerLegacyPassPass(*PassRegistry::getPassRegistry());
+ }
+
+ StringRef getPassName() const override {
+ return "AddressSanitizerFunctionPass";
+ }
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.addRequired<ASanGlobalsMetadataWrapperPass>();
+ if (ClUseStackSafety)
+ AU.addRequired<StackSafetyGlobalInfoWrapperPass>();
+ AU.addRequired<TargetLibraryInfoWrapperPass>();
+ }
+
+ bool runOnFunction(Function &F) override {
+ GlobalsMetadata &GlobalsMD =
+ getAnalysis<ASanGlobalsMetadataWrapperPass>().getGlobalsMD();
+ const StackSafetyGlobalInfo *const SSGI =
+ ClUseStackSafety
+ ? &getAnalysis<StackSafetyGlobalInfoWrapperPass>().getResult()
+ : nullptr;
+ const TargetLibraryInfo *TLI =
+ &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
+ AddressSanitizer ASan(*F.getParent(), &GlobalsMD, SSGI, CompileKernel,
+ Recover, UseAfterScope, UseAfterReturn);
+ return ASan.instrumentFunction(F, TLI);
+ }
+
+private:
+ bool CompileKernel;
+ bool Recover;
+ bool UseAfterScope;
+ AsanDetectStackUseAfterReturnMode UseAfterReturn;
+};
+
class ModuleAddressSanitizer {
public:
ModuleAddressSanitizer(Module &M, const GlobalsMetadata *GlobalsMD,
@@ -856,6 +933,44 @@ class ModuleAddressSanitizer {
Function *AsanDtorFunction = nullptr;
};
+class ModuleAddressSanitizerLegacyPass : public ModulePass {
+public:
+ static char ID;
+
+ explicit ModuleAddressSanitizerLegacyPass(
+ bool CompileKernel = false, bool Recover = false, bool UseGlobalGC = true,
+ bool UseOdrIndicator = false,
+ AsanDtorKind DestructorKind = AsanDtorKind::Global)
+ : ModulePass(ID), CompileKernel(CompileKernel), Recover(Recover),
+ UseGlobalGC(UseGlobalGC), UseOdrIndicator(UseOdrIndicator),
+ DestructorKind(DestructorKind) {
+ initializeModuleAddressSanitizerLegacyPassPass(
+ *PassRegistry::getPassRegistry());
+ }
+
+ StringRef getPassName() const override { return "ModuleAddressSanitizer"; }
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.addRequired<ASanGlobalsMetadataWrapperPass>();
+ }
+
+ bool runOnModule(Module &M) override {
+ GlobalsMetadata &GlobalsMD =
+ getAnalysis<ASanGlobalsMetadataWrapperPass>().getGlobalsMD();
+ ModuleAddressSanitizer ASanModule(M, &GlobalsMD, CompileKernel, Recover,
+ UseGlobalGC, UseOdrIndicator,
+ DestructorKind);
+ return ASanModule.instrumentModule(M);
+ }
+
+private:
+ bool CompileKernel;
+ bool Recover;
+ bool UseGlobalGC;
+ bool UseOdrIndicator;
+ AsanDtorKind DestructorKind;
+};
+
// Stack poisoning does not play well with exception handling.
// When an exception is thrown, we essentially bypass the code
// that unpoisones the stack. This is why the run-time library has
@@ -1194,6 +1309,49 @@ PreservedAnalyses ModuleAddressSanitizerPass::run(Module &M,
return Modified ? PreservedAnalyses::none() : PreservedAnalyses::all();
}
+INITIALIZE_PASS(ASanGlobalsMetadataWrapperPass, "asan-globals-md",
+ "Read metadata to mark which globals should be instrumented "
+ "when running ASan.",
+ false, true)
+
+char AddressSanitizerLegacyPass::ID = 0;
+
+INITIALIZE_PASS_BEGIN(
+ AddressSanitizerLegacyPass, "asan",
+ "AddressSanitizer: detects use-after-free and out-of-bounds bugs.", false,
+ false)
+INITIALIZE_PASS_DEPENDENCY(ASanGlobalsMetadataWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
+INITIALIZE_PASS_END(
+ AddressSanitizerLegacyPass, "asan",
+ "AddressSanitizer: detects use-after-free and out-of-bounds bugs.", false,
+ false)
+
+FunctionPass *llvm::createAddressSanitizerFunctionPass(
+ bool CompileKernel, bool Recover, bool UseAfterScope,
+ AsanDetectStackUseAfterReturnMode UseAfterReturn) {
+ assert(!CompileKernel || Recover);
+ return new AddressSanitizerLegacyPass(CompileKernel, Recover, UseAfterScope,
+ UseAfterReturn);
+}
+
+char ModuleAddressSanitizerLegacyPass::ID = 0;
+
+INITIALIZE_PASS(
+ ModuleAddressSanitizerLegacyPass, "asan-module",
+ "AddressSanitizer: detects use-after-free and out-of-bounds bugs."
+ "ModulePass",
+ false, false)
+
+ModulePass *llvm::createModuleAddressSanitizerLegacyPassPass(
+ bool CompileKernel, bool Recover, bool UseGlobalsGC, bool UseOdrIndicator,
+ AsanDtorKind Destructor) {
+ assert(!CompileKernel || Recover);
+ return new ModuleAddressSanitizerLegacyPass(
+ CompileKernel, Recover, UseGlobalsGC, UseOdrIndicator, Destructor);
+}
+
static size_t TypeSizeToSizeIndex(uint32_t TypeSize) {
size_t Res = countTrailingZeros(TypeSize / 8);
assert(Res < kNumberOfAccessSizes);
diff --git a/llvm/lib/Transforms/Instrumentation/Instrumentation.cpp b/llvm/lib/Transforms/Instrumentation/Instrumentation.cpp
index 83bd2e0771e03..40cb0c1c2ff78 100644
--- a/llvm/lib/Transforms/Instrumentation/Instrumentation.cpp
+++ b/llvm/lib/Transforms/Instrumentation/Instrumentation.cpp
@@ -91,6 +91,8 @@ Comdat *llvm::getOrCreateFunctionComdat(Function &F, Triple &T) {
/// initializeInstrumentation - Initialize all passes in the TransformUtils
/// library.
void llvm::initializeInstrumentation(PassRegistry &Registry) {
+ initializeAddressSanitizerLegacyPassPass(Registry);
+ initializeModuleAddressSanitizerLegacyPassPass(Registry);
initializeMemProfilerLegacyPassPass(Registry);
initializeModuleMemProfilerLegacyPassPass(Registry);
initializeBoundsCheckingLegacyPassPass(Registry);
More information about the llvm-commits
mailing list