[ASan] Removed unused AddressSanitizerPass functional pass.

[kstoimenov]

Summary

This is a clean-up patch. The functional pass was rolled into the module pass in D112732.

[kstoimenov]

Removed asan-function-pipeline.

[kstoimenov]

Removed some extra occurrences of asan-function-pipeline.

[vitalybuka]

llvm/test/Instrumentation/AddressSanitizer/str-nobuiltin.ll

3

maybe you can remove -pipeline thing as well
it was needed because of two passes (probably)

follow up patch is fine

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h

 struct AddressSanitizerOptions {
   bool CompileKernel = false;
   bool Recover = false;
   bool UseAfterScope = false;
   AsanDetectStackUseAfterReturnMode UseAfterReturn =
       AsanDetectStackUseAfterReturnMode::Runtime;
 };
 
-/// Public interface to the address sanitizer pass for instrumenting code to
-/// check for various memory errors at runtime.
-///
-/// The sanitizer itself is a function pass that works by inserting various
-/// calls to the ASan runtime library functions. The runtime library essentially
-/// replaces malloc() and free() with custom implementations that allow regions
-/// surrounding requested memory to be checked for invalid accesses.
-class AddressSanitizerPass : public PassInfoMixin<AddressSanitizerPass> {
-public:
-  AddressSanitizerPass(const AddressSanitizerOptions &Options)
-      : Options(Options){};
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
-  void printPipeline(raw_ostream &OS,
-                     function_ref<StringRef(StringRef)> MapClassName2PassName);
-  static bool isRequired() { return true; }
-
-private:
-  AddressSanitizerOptions Options;
-};
-
 /// Public interface to the address sanitizer module pass for instrumenting code
 /// to check for various memory errors.
 ///
 /// This adds 'asan.module_ctor' to 'llvm.global_ctors'. This pass may also
 /// run intependently of the function address sanitizer.
 class ModuleAddressSanitizerPass
     : public PassInfoMixin<ModuleAddressSanitizerPass> {
 public:

llvm/lib/Passes/PassRegistry.def

FUNCTION_PASS_WITH_PARAMS("loop-unroll",
                            },
                           parseLoopUnrollOptions,
                           "O0;O1;O2;O3;full-unroll-max=N;"
                           "no-partial;partial;"
                           "no-peeling;peeling;"
                           "no-profile-peeling;profile-peeling;"
                           "no-runtime;runtime;"
                           "no-upperbound;upperbound")
-FUNCTION_PASS_WITH_PARAMS("asan",
-                          "AddressSanitizerPass",
-                           [](AddressSanitizerOptions Opts) {
-                             return AddressSanitizerPass(Opts);
-                           },
-                          parseASanPassOptions,
-                          "kernel")
 FUNCTION_PASS_WITH_PARAMS("msan",
                           "MemorySanitizerPass",
                            [](MemorySanitizerOptions Opts) {
                              return MemorySanitizerPass(Opts);
                            },
                           parseMSanPassOptions,
                           "recover;kernel;eager-checks;track-origins=N")
 FUNCTION_PASS_WITH_PARAMS("simplifycfg",

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

 
 AnalysisKey ASanGlobalsMetadataAnalysis::Key;
 
 GlobalsMetadata ASanGlobalsMetadataAnalysis::run(Module &M,
                                                  ModuleAnalysisManager &AM) {
   return GlobalsMetadata(M);
 }
 
-PreservedAnalyses AddressSanitizerPass::run(Function &F,
-                                            AnalysisManager<Function> &AM) {
-  auto &MAMProxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
-  Module &M = *F.getParent();
-  if (auto *R = MAMProxy.getCachedResult<ASanGlobalsMetadataAnalysis>(M)) {
-    const TargetLibraryInfo *TLI = &AM.getResult<TargetLibraryAnalysis>(F);
-    AddressSanitizer Sanitizer(M, R, nullptr, Options.CompileKernel,
-                               Options.Recover, Options.UseAfterScope,
-                               Options.UseAfterReturn);
-    if (Sanitizer.instrumentFunction(F, TLI))
-      return PreservedAnalyses::none();
-    return PreservedAnalyses::all();
-  }
-
-  report_fatal_error(
-      "The ASanGlobalsMetadataAnalysis is required to run before "
-      "AddressSanitizer can run");
-  return PreservedAnalyses::all();
-}
-
-void AddressSanitizerPass::printPipeline(
-    raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
-  static_cast<PassInfoMixin<AddressSanitizerPass> *>(this)->printPipeline(
-      OS, MapClassName2PassName);
-  OS << "<";
-  if (Options.CompileKernel)
-    OS << "kernel";
-  OS << ">";
-}
-
 void ModuleAddressSanitizerPass::printPipeline(
     raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
   static_cast<PassInfoMixin<ModuleAddressSanitizerPass> *>(this)->printPipeline(
       OS, MapClassName2PassName);
   OS << "<";
   if (Options.CompileKernel)
     OS << "kernel";
   OS << ">";

llvm/test/DebugInfo/Generic/block-asan.ll

 ; RUN: opt -S -asan -enable-new-pm=0 %s | FileCheck %s
-; RUN: opt -S -passes=asan-function-pipeline %s | FileCheck %s
+; RUN: opt -S -passes=asan-pipeline %s | FileCheck %s
 
 ; The IR of this testcase is generated from the following C code:
 ; void bar (int);
 ;
 ; void foo() {
 ;   __block int x;
 ;   bar(x);
 ; }

llvm/test/Instrumentation/AddressSanitizer/X86/asm_cpuid.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S -o %t.ll
+; RUN: opt < %s -passes='asan-pipeline' -S -o %t.ll
 ; RUN: FileCheck %s < %t.ll
 ; RUN: llc < %t.ll | FileCheck %s --check-prefix=ASM
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-S32"
 target triple = "i386-pc-windows-msvc"
 
 define void @MyCPUID(i32 %fxn, i32* %out) sanitize_address {
   %fxn.ptr = alloca i32

llvm/test/Instrumentation/AddressSanitizer/X86/asm_more_registers_than_available.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S -o %t.ll
+; RUN: opt < %s -passes='asan-pipeline' -S -o %t.ll
 ; RUN: FileCheck %s < %t.ll
 
 ; Don't do stack malloc on functions containing inline assembly on 64-bit
 ; platforms. It makes LLVM run out of registers.
 
 ; CHECK-LABEL: define void @TestAbsenceOfStackMalloc(i8* %S, i32 %pS, i8* %D, i32 %pD, i32 %h)
 ; CHECK: %MyAlloca
 ; CHECK-NOT: call {{.*}} @__asan_stack_malloc

llvm/test/Instrumentation/AddressSanitizer/alloca-offset-lifetime.ll

 ; Test that ASAN will not instrument lifetime markers on alloca offsets.
 ;
-; RUN: opt < %s -passes=asan-function-pipeline --asan-use-after-scope -S | FileCheck %s
+; RUN: opt < %s -passes=asan-pipeline --asan-use-after-scope -S | FileCheck %s
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.15.0"
 
 %t = type { void (%t*)*, void (%t*)*, %sub, i64 }
 %sub = type { i32 }
 
 define void @foo() sanitize_address {

llvm/test/Instrumentation/AddressSanitizer/asan-detect-invalid-pointer-pair.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -asan-detect-invalid-pointer-cmp -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-detect-invalid-pointer-cmp -S \
 ; RUN:     | FileCheck %s --check-prefixes=CMP,NOSUB,ALL
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-detect-invalid-pointer-sub -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-detect-invalid-pointer-sub -S \
 ; RUN:     | FileCheck %s --check-prefixes=SUB,NOCMP,ALL
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-detect-invalid-pointer-pair -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-detect-invalid-pointer-pair -S \
 ; RUN:     | FileCheck %s --check-prefixes=CMP,SUB,ALL
 ; Support instrumentation of invalid pointer pair detection.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @mycmp(i8* %p, i8* %q) sanitize_address {
 ; ALL-LABEL: @mycmp
 ; NOCMP-NOT: call void @__sanitizer_ptr_cmp

llvm/test/Instrumentation/AddressSanitizer/asan-masked-load-store.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -asan-instrumentation-with-call-threshold=0 -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-instrumentation-with-call-threshold=0 -S \
 ; RUN:     | FileCheck %s -check-prefix=LOAD -check-prefix=STORE -check-prefix=ALL
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -S \
 ; RUN:     | FileCheck %s -check-prefix=NOLOAD -check-prefix=STORE -check-prefix=ALL
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-writes=0 -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-writes=0 -S \
 ; RUN:     | FileCheck %s -check-prefix=LOAD -check-prefix=NOSTORE -check-prefix=ALL
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -asan-instrument-writes=0 -S \
+; RUN: opt < %s -passes='asan-pipeline' -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -asan-instrument-writes=0 -S \
 ; RUN:     | FileCheck %s -check-prefix=NOLOAD -check-prefix=NOSTORE -check-prefix=ALL
 ; Support ASan instrumentation for constant-mask llvm.masked.{load,store}
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @v4f32 = global <4 x float>* zeroinitializer, align 8
 @v8i32 = global <8 x i32>* zeroinitializer, align 8
 @v4i64 = global <4 x i32*>* zeroinitializer, align 8

llvm/test/Instrumentation/AddressSanitizer/asan_address_space_attr.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Checks that we do not instrument loads and stores comming from custom address space.
 ; These result in invalid (false positive) reports.
 ; int foo(int argc, const char * argv[]) {
 ;   void *__attribute__((address_space(256))) *gs_base = (((void * __attribute__((address_space(256))) *)0));
 ;   void *somevalue = gs_base[-1];

llvm/test/Instrumentation/AddressSanitizer/byref-args.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -S | FileCheck %s
 
 ; Test that for call instructions, the byref arguments are not
 ; instrumented, as no copy is implied.
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.bar = type { %struct.foo }

llvm/test/Instrumentation/AddressSanitizer/byval-args.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -S | FileCheck %s
 ; Test that for call instructions, the by-value arguments are instrumented.
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.bar = type { %struct.foo }
 %struct.foo = type { i8*, i8*, i8* }
 define dso_local void @func2(%struct.foo* %foo) sanitize_address {

llvm/test/Instrumentation/AddressSanitizer/instrument-no-return.ll

-; RUN: opt < %s -passes='asan-function-pipeline' -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -S | FileCheck %s
 ; AddressSanitizer must insert __asan_handle_no_return
 ; before noreturn calls that aren't inserted by sanitizers.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @NormalFunc()
 declare void @NoReturnFunc() noreturn

llvm/test/Instrumentation/AddressSanitizer/local_stack_base.ll

-; RUN: opt -S -passes='asan-function-pipeline' -asan-skip-promotable-allocas=0 %s -o - | FileCheck %s
+; RUN: opt -S -passes='asan-pipeline' -asan-skip-promotable-allocas=0 %s -o - | FileCheck %s
 ; Generated from:
 ; int bar(int y) {
 ;   return y + 2;
 ; }
 
 source_filename = "/tmp/t.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.13.0"

llvm/test/Instrumentation/AddressSanitizer/stack-poisoning-byval-args.ll

 ; This check verifies that arguments passed by value get redzones.
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-realign-stack=32 -S | FileCheck %s
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-realign-stack=32 -asan-force-dynamic-shadow -S | FileCheck %s
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-realign-stack=32 -asan-mapping-scale=5 -S | FileCheck %s
-; RUN: opt < %s -passes='asan-function-pipeline' -asan-realign-stack=32 -asan-force-dynamic-shadow -asan-mapping-scale=5 -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -asan-realign-stack=32 -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -asan-realign-stack=32 -asan-force-dynamic-shadow -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -asan-realign-stack=32 -asan-mapping-scale=5 -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -asan-realign-stack=32 -asan-force-dynamic-shadow -asan-mapping-scale=5 -S | FileCheck %s
 
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.A = type { [8 x i32] }
 
 declare i32 @bar(%struct.A*)

llvm/test/Instrumentation/AddressSanitizer/str-nobuiltin.ll

 ; Test marking string functions as nobuiltin in address sanitizer.
 ;
-; RUN: opt < %s -passes='asan-function-pipeline' -S | FileCheck %s
+; RUN: opt < %s -passes='asan-pipeline' -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i8* @memchr(i8* %a, i32 %b, i64 %c)
 declare i32 @memcmp(i8* %a, i8* %b, i64 %c)
 declare i32 @strcmp(i8* %a, i8* %b)
 declare i8* @strcpy(i8* %a, i8* %b)
 declare i8* @stpcpy(i8* %a, i8* %b)

llvm/test/Instrumentation/AddressSanitizer/twice.ll

 ; Check that the address sanitizer pass can be reused
-; RUN: opt < %s -S -run-twice -passes='asan-function-pipeline'
+; RUN: opt < %s -S -run-twice -passes='asan-pipeline'
 
 define void @foo(i64* %b) nounwind uwtable sanitize_address {
   entry:
   store i64 0, i64* %b, align 1
   ret void
 }

llvm/test/Instrumentation/HWAddressSanitizer/kernel-inline.ll

 ; Test kernel inline hwasan instrumentation.
 
-; RUN: opt < %s -passes=asan-function-pipeline -asan-kernel=1 -asan-recover=1 -asan-instrumentation-with-call-threshold=10000 -S | FileCheck --check-prefixes=CHECK-INLINE %s
-; RUN: opt < %s -passes=asan-function-pipeline -asan-kernel=1 -asan-recover=1 -asan-instrumentation-with-call-threshold=0 -S | FileCheck --check-prefixes=CHECK-CALLBACK %s
+; RUN: opt < %s -passes=asan-pipeline -asan-kernel=1 -asan-recover=1 -asan-instrumentation-with-call-threshold=10000 -S | FileCheck --check-prefixes=CHECK-INLINE %s
+; RUN: opt < %s -passes=asan-pipeline -asan-kernel=1 -asan-recover=1 -asan-instrumentation-with-call-threshold=0 -S | FileCheck --check-prefixes=CHECK-CALLBACK %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @test_load(i32* %a, i64* %b, i512* %c, i80* %d) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   %tmp2 = load i64, i64* %b, align 8

llvm/test/Other/new-pm-print-pipeline.ll

 ; CHECK-12: function(early-cse<>,early-cse<memssa>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='msan-module,function(msan,msan<>,msan<recover;kernel;eager-checks;track-origins=5>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-13
 ; CHECK-13: msan-module,function(msan<track-origins=0>,msan<track-origins=0>,msan<recover;kernel;eager-checks;track-origins=5>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='module(hwasan<>,hwasan<kernel;recover>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-14
 ; CHECK-14: hwasan<>,hwasan<kernel;recover>
 
-; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(asan<>,asan<kernel>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-15
-; CHECK-15: function(asan<>,asan<kernel>)
-
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='module(loop-extract<>,loop-extract<single>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-16
 ; CHECK-16: loop-extract<>,loop-extract<single>
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(print<stack-lifetime><may>,print<stack-lifetime><must>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-17
 ; CHECK-17: function(print<stack-lifetime><may>,print<stack-lifetime><must>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(simplifycfg<bonus-inst-threshold=5;forward-switch-cond;switch-to-lookup;keep-loops;hoist-common-insts;sink-common-insts>,simplifycfg<bonus-inst-threshold=7;no-forward-switch-cond;no-switch-to-lookup;no-keep-loops;no-hoist-common-insts;no-sink-common-insts>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-18
 ; CHECK-18: function(simplifycfg<bonus-inst-threshold=5;forward-switch-cond;no-switch-range-to-icmp;switch-to-lookup;keep-loops;hoist-common-insts;sink-common-insts>,simplifycfg<bonus-inst-threshold=7;no-forward-switch-cond;no-switch-range-to-icmp;no-switch-to-lookup;no-keep-loops;no-hoist-common-insts;no-sink-common-insts>)

llvm/tools/opt/NewPMDriver.cpp

PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &MPM,
          ArrayRef<PassBuilder::PipelineElement>) {
         AddressSanitizerOptions Opts;
         if (Name == "asan-pipeline") {
           MPM.addPass(
               RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
           MPM.addPass(ModuleAddressSanitizerPass(Opts));
           return true;
-        } else if (Name == "asan-function-pipeline") {
-          MPM.addPass(
-              RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
-          MPM.addPass(
-              createModuleToFunctionPassAdaptor(AddressSanitizerPass(Opts)));
-          return true;
         }
         return false;
       });
 
 #define HANDLE_EXTENSION(Ext)                                                  \
   get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
 #include "llvm/Support/Extension.def"