[asan] Test ASan instrumentation for shadow scale value of 5

[waltl]

Summary

Add additional RUN clauses to test for -asan-mapping-scale=5 in
selective tests, with special CHECK statements where needed.

[waltl]

Change approach to only override shadow scale in compiler_rt

[waltl]

Add test for metadata_array alignment

[vitalybuka]

llvm/test/Instrumentation/AddressSanitizer/test64.ll

1

Looks to complicated. I'd prefer if you:

1. don't move files into ShadowScale3
2. Remove %opt_asan
3. remove asan_test_shadow_scale and just add additional RUN: in tests where it makes sense. E.g.:

; RUN: %opt < %s -asan -asan-module -S | FileCheck --check-prefixes=CHECK,CHECK-S3 %s
; RUN: %opt -asan-mapping-scale=5 < %s -asan -asan-module -S | FileCheck --check-prefixes=CHECK,CHECK-S5 %s

[waltl]

Address CR comments

[waltl]

llvm/test/Instrumentation/AddressSanitizer/test64.ll

1

Done. I selectively enabled some tests; it seems that the stack-poisoning/stack_layout tests are useful as well but they are harder to port, so perhaps I'll do that in a separate commit.

[vitalybuka]

lgtm

llvm/test/CMakeLists.txt

 llvm_canonicalize_cmake_booleans(
   LLVM_TOOL_LTO_BUILD
   HAVE_OCAMLOPT
   HAVE_OCAML_OUNIT
   LLVM_INCLUDE_GO_TESTS
   LLVM_USE_INTEL_JITEVENTS
   HAVE_LIBZ
   HAVE_LIBXAR
   LLVM_ENABLE_DIA_SDK
   LLVM_ENABLE_FFI
   BUILD_SHARED_LIBS
   LLVM_LINK_LLVM_DYLIB
   )
 
+set (LLVM_ASAN_TEST_SHADOW_SCALE 3)
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
   )
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
set(LLVM_TEST_DEPENDS ${LLVM_TEST_DEPENDS}
           ocaml_llvm_transform_utils
           ocaml_llvm_vectorize
         )
 endif()
 
 add_custom_target(llvm-test-depends DEPENDS ${LLVM_TEST_DEPENDS})
 set_target_properties(llvm-test-depends PROPERTIES FOLDER "Tests")
 
+# Add testsute for testing ASan instrumentation with shadow scale of
+# 5.
+set (LLVM_ASAN_TEST_SHADOW_SCALE 5)
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/ShadowScale5/lit.site.cfg.py
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+  )
+
 add_lit_testsuite(check-llvm "Running the LLVM regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}/ShadowScale5/Instrumentation/AddressSanitizer
   DEPENDS ${LLVM_TEST_DEPENDS}
   )
 set_target_properties(check-llvm PROPERTIES FOLDER "Tests")
 
 add_lit_testsuites(LLVM ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${LLVM_TEST_DEPENDS}
   )
 
 # Setup a legacy alias for 'check-llvm'. This will likely change to be an
 # alias for 'check-all' at some point in the future.
 add_custom_target(check)
 add_dependencies(check check-llvm)
 set_target_properties(check PROPERTIES FOLDER "Tests")

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/lifetime-throw.ll

 ; Test handling of llvm.lifetime intrinsics with C++ exceptions.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.ABC = type { i32 }
 
 $_ZN3ABCD2Ev = comdat any
 $_ZTS3ABC = comdat any

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/lifetime-uar-uas.ll

 ; Test handling of llvm.lifetime intrinsics in UAR/UAS modes.
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=0 -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=0 -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=0 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=1 -asan-use-after-scope=1 -S | FileCheck %s --check-prefix=CHECK-UAS
 
 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-S128"
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
 
 define i32 @basic_test() sanitize_address {
   ; CHECK-LABEL: define i32 @basic_test()

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/lifetime.ll

 ; Test handling of llvm.lifetime intrinsics.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-DEFAULT
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-NO-DYNAMIC
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-DEFAULT
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-NO-DYNAMIC
 
 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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind
 
 define void @lifetime_no_size() sanitize_address {

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/lit.local.cfg

+if config.asan_test_shadow_scale != '3':
+    config.unsupported = True

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/stack-poisoning-and-lifetime-be.ll

 ; Regular stack poisoning.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope=0 -S | FileCheck --check-prefixes=CHECK,ENTRY,EXIT %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope=0 -S | FileCheck --check-prefixes=CHECK,ENTRY,EXIT %s
 
 ; Stack poisoning with stack-use-after-scope.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope=1 -S | FileCheck --check-prefixes=CHECK,ENTRY-UAS,EXIT-UAS %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope=1 -S | FileCheck --check-prefixes=CHECK,ENTRY-UAS,EXIT-UAS %s
 
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 declare void @Foo(i8*)
 
 define void @Bar() uwtable sanitize_address {
 entry:

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/stack-poisoning-and-lifetime.ll

 ; Regular stack poisoning.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope=0 -S | FileCheck --check-prefixes=CHECK,ENTRY,EXIT %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope=0 -S | FileCheck --check-prefixes=CHECK,ENTRY,EXIT %s
 
 ; Stack poisoning with stack-use-after-scope.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope=1 -S | FileCheck --check-prefixes=CHECK,ENTRY-UAS,EXIT-UAS %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-scope=1 -S | FileCheck --check-prefixes=CHECK,ENTRY-UAS,EXIT-UAS %s
 
 target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @Foo(i8*)
 
 define void @Bar() uwtable sanitize_address {
 entry:

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/stack-poisoning.ll

-; RUN: opt < %s -asan -asan-module -asan-use-after-return -S | FileCheck --check-prefix=CHECK-UAR %s
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck --check-prefix=CHECK-PLAIN %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return -S | FileCheck --check-prefix=CHECK-UAR %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck --check-prefix=CHECK-PLAIN %s
 target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @Foo(i8*)
 
 define void @Bar() uwtable sanitize_address {
 entry:
 ; CHECK-PLAIN-LABEL: Bar

llvm/test/Instrumentation/AddressSanitizer/ShadowScale3/stack_layout.ll

 ; Test the ASan's stack layout.
 ; More tests in tests/Transforms/Utils/ASanStackFrameLayoutTest.cpp
-; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=0 -asan-use-after-scope -S \
+; RUN: %opt_asan < %s -asan -asan-module -asan-stack-dynamic-alloca=0 -asan-use-after-scope -S \
 ; RUN:     | FileCheck %s --check-prefixes=CHECK,CHECK-STATIC
-; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca=1 -asan-use-after-scope -S \
+; RUN: %opt_asan < %s -asan -asan-module -asan-stack-dynamic-alloca=1 -asan-use-after-scope -S \
 ; RUN:     | FileCheck %s --check-prefixes=CHECK,CHECK-DYNAMIC
 
 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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @Use(i8*)
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind

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

-; RUN: opt < %s -asan -S -o %t.ll
+; RUN: %opt_asan < %s -asan -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/lit.local.cfg

 if not 'X86' in config.root.targets:
     config.unsupported = True
 
+if config.asan_test_shadow_scale != '3':
+    config.unsupported = True

llvm/test/Instrumentation/AddressSanitizer/adaptive_global_redzones.ll

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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"
 
 ; Here we check that the global redzone sizes grow with the object size.
 
 @G10 = global [10 x i8] zeroinitializer, align 1
 ; CHECK: @G10 = global { [10 x i8], [54 x i8] }
 

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

-; RUN: opt < %s -asan -asan-instrumentation-with-call-threshold=0 -S \
+; RUN: %opt_asan < %s -asan -asan-instrumentation-with-call-threshold=0 -S \
 ; RUN:     | FileCheck %s -check-prefix=LOAD -check-prefix=STORE -check-prefix=ALL
-; RUN: opt < %s -asan -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -S \
+; RUN: %opt_asan < %s -asan -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 -asan -asan-instrumentation-with-call-threshold=0 -asan-instrument-writes=0 -S \
+; RUN: %opt_asan < %s -asan -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 -asan -asan-instrumentation-with-call-threshold=0 -asan-instrument-reads=0 -asan-instrument-writes=0 -S \
+; RUN: %opt_asan < %s -asan -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-vs-gvn.ll

-; RUN: opt < %s -basicaa -gvn -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -basicaa -gvn -asan -asan-module -S | FileCheck %s
 ; ASAN conflicts with load widening iff the widened load accesses data out of bounds
 ; (while the original unwidened loads do not).
 ; http://code.google.com/p/address-sanitizer/issues/detail?id=20#c1
 
 
 ; 32-bit little endian target.
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 

llvm/test/Instrumentation/AddressSanitizer/asan_address_space_attr.ll

-; RUN: opt < %s -asan -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -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/basic-msvc64.ll

 ; Test basic address sanitizer instrumentation.
 ;
-; RUN: opt -asan -asan-module -S  < %s | FileCheck %s
+; RUN: %opt_asan -asan -asan-module -S  < %s | FileCheck %s
 
 target triple = "x86_64-pc-windows-msvc"
 ; CHECK: @llvm.global_ctors = {{.*}}@asan.module_ctor
 
 define i32 @test_load(i32* %a) sanitize_address {
 ; First instrumentation in the function must be to load the dynamic shadow
 ; address into a local variable.
 ; CHECK-LABEL: @test_load

llvm/test/Instrumentation/AddressSanitizer/basic.ll

 ; Test basic address sanitizer instrumentation.
 ;
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck --check-prefixes=CHECK,CHECK-S%scale %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"
 ; CHECK: @llvm.global_ctors = {{.*}}@asan.module_ctor
 
 define i32 @test_load(i32* %a) sanitize_address {
 ; CHECK-LABEL: @test_load
 ; CHECK-NOT: load
 ; CHECK:   %[[LOAD_ADDR:[^ ]*]] = ptrtoint i32* %a to i64
-; CHECK:   lshr i64 %[[LOAD_ADDR]], 3
+; CHECK-S3:   lshr i64 %[[LOAD_ADDR]], 3
+; CHECK-S5:   lshr i64 %[[LOAD_ADDR]], 5
 ; CHECK:   {{or|add}}
 ; CHECK:   %[[LOAD_SHADOW_PTR:[^ ]*]] = inttoptr
 ; CHECK:   %[[LOAD_SHADOW:[^ ]*]] = load i8, i8* %[[LOAD_SHADOW_PTR]]
 ; CHECK:   icmp ne i8
 ; CHECK:   br i1 %{{.*}}, label %{{.*}}, label %{{.*}}!prof ![[PROF:[0-9]+]]
 ;
 ; First instrumentation block refines the shadow test.
-; CHECK:   and i64 %[[LOAD_ADDR]], 7
+; CHECK-S3:   and i64 %[[LOAD_ADDR]], 7
+; CHECK-S5:   and i64 %[[LOAD_ADDR]], 31
 ; CHECK:   add i64 %{{.*}}, 3
 ; CHECK:   trunc i64 %{{.*}} to i8
 ; CHECK:   icmp sge i8 %{{.*}}, %[[LOAD_SHADOW]]
 ; CHECK:   br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
 ;
 ; The crash block reports the error.
 ; CHECK:   call void @__asan_report_load4(i64 %[[LOAD_ADDR]])
 ; CHECK:   unreachable
 ;
 ; The actual load.
 ; CHECK:   %tmp1 = load i32, i32* %a
 ; CHECK:   ret i32 %tmp1
 
 
 
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }
 
 define void @test_store(i32* %a) sanitize_address {
 ; CHECK-LABEL: @test_store
 ; CHECK-NOT: store
 ; CHECK:   %[[STORE_ADDR:[^ ]*]] = ptrtoint i32* %a to i64
-; CHECK:   lshr i64 %[[STORE_ADDR]], 3
+; CHECK-S3:   lshr i64 %[[STORE_ADDR]], 3
+; CHECK-S5:   lshr i64 %[[STORE_ADDR]], 5
 ; CHECK:   {{or|add}}
 ; CHECK:   %[[STORE_SHADOW_PTR:[^ ]*]] = inttoptr
 ; CHECK:   %[[STORE_SHADOW:[^ ]*]] = load i8, i8* %[[STORE_SHADOW_PTR]]
 ; CHECK:   icmp ne i8
 ; CHECK:   br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
 ;
 ; First instrumentation block refines the shadow test.
-; CHECK:   and i64 %[[STORE_ADDR]], 7
+; CHECK-S3:   and i64 %[[STORE_ADDR]], 7
+; CHECK-S5:   and i64 %[[STORE_ADDR]], 31
 ; CHECK:   add i64 %{{.*}}, 3
 ; CHECK:   trunc i64 %{{.*}} to i8
 ; CHECK:   icmp sge i8 %{{.*}}, %[[STORE_SHADOW]]
 ; CHECK:   br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
 ;
 ; The crash block reports the error.
 ; CHECK:   call void @__asan_report_store4(i64 %[[STORE_ADDR]])
 ; CHECK:   unreachable

llvm/test/Instrumentation/AddressSanitizer/debug-info-global-var.ll

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 source_filename = "version.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 ; CHECK: @version = constant { [5 x i8], [59 x i8] } {{.*}}, !dbg ![[GV:.*]]
 
 @version = constant [5 x i8] c"4.00\00", align 1, !dbg !0
 
 !llvm.dbg.cu = !{!2}

llvm/test/Instrumentation/AddressSanitizer/debug_info.ll

-; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=0 -S | FileCheck %s
 
 ; Checks that llvm.dbg.declare instructions are updated 
 ; accordingly as we merge allocas.
 
 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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @_Z3zzzi(i32 %p) nounwind uwtable sanitize_address !dbg !5 {

llvm/test/Instrumentation/AddressSanitizer/debug_info_noninstrumented_alloca.ll

 ; This test checks that non-instrumented allocas stay in the first basic block.
 ; Only first-basic-block allocas are considered stack slots, and moving them
 ; breaks debug info.
 
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 define i32 @foo() sanitize_address {
 entry:
   ; Won't be instrumented because of asan-skip-promotable-allocas.
   %non_instrumented1 = alloca i32, align 4

llvm/test/Instrumentation/AddressSanitizer/debug_info_noninstrumented_alloca2.ll

 ; Make sure we don't break the IR when moving non-instrumented allocas
 
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 define i32 @foo() sanitize_address {
 entry:
   %non_instrumented1 = alloca i32, align 4
   %t = load i32, i32* %non_instrumented1, align 4

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-globals-darwin.ll

 ; This test checks that we are not instrumenting unnecessary globals
 ; (llvm.metadata and other llvm internal globals).
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 @foo_noinst = private global [19 x i8] c"scannerWithString:\00", section "__TEXT,__objc_methname,cstring_literals"
 
 ; CHECK: @foo_noinst = private global [19 x i8] c"scannerWithString:\00", section "__TEXT,__objc_methname,cstring_literals"
 

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-globals-linux.ll

 ; This test checks that we are not instrumenting unnecessary globals
 ; (llvm.metadata, init_array sections, and other llvm internal globals).
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define internal void @_ZL3foov() #0 {
 entry:
   ret void

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-internal-globals.ll

 ; This test checks that we are not instrumenting globals
 ; that we created ourselves.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @_Z3barv() uwtable sanitize_address {
 entry:
   %a = alloca i32, align 4
   call void @_Z3fooPi(i32* %a)

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-profiling-globals.ll

 ; This test checks that we don't instrument globals created by profiling passes.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 
 @__profc_test = private global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
 @__llvm_gcov_ctr = internal global [1 x i64] zeroinitializer
 
 ; CHECK-DAG: @asan.module_ctor
 ; CHECK-NOT: @__asan_gen{{.*}}__llvm_gcov_ctr
 ; CHECK-NOT: @__asan_gen{{.*}}__profc_test

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-promotable-allocas.ll

-; RUN: opt < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 define i32 @test_promotable_allocas() sanitize_address {
 entry:
 ; CHECK: %0 = alloca i32, align 4
 ; CHECK: store i32 0, i32* %0, align 4

llvm/test/Instrumentation/AddressSanitizer/do-not-instrument-sanitizers.ll

 ; This test checks that we are not instrumenting sanitizer code.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define void @__asan_default_options(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4

llvm/test/Instrumentation/AddressSanitizer/do-not-touch-comdat-global.ll

 ; This test checks that we instrument regular globals, but do not touch
 ; the COMDAT ones.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
 target triple = "i686-pc-windows-msvc"
 ; no action should be taken for these globals
 $global_noinst = comdat largest
 @aliasee = private unnamed_addr constant [2 x i8] [i8 1, i8 2], comdat($global_noinst)
 @global_noinst = unnamed_addr alias [2 x i8], [2 x i8]* @aliasee
 ; CHECK-NOT: {{asan_gen.*global_noinst}}
 ; CHECK-DAG: @global_noinst = unnamed_addr alias [2 x i8], [2 x i8]* @aliasee
 @global_inst = private constant [2 x i8] [i8 1, i8 2]
 ; CHECK-DAG: {{asan_gen.*global_inst}}
 ; CHECK: @asan.module_ctor

llvm/test/Instrumentation/AddressSanitizer/do-not-touch-odr-global.ll

 ; This test checks that we instrument regular globals, but do not touch
 ; the linkonce_odr ones.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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"
 ; no action should be taken for these globals
 @global_noinst = linkonce_odr constant [2 x i8] [i8 1, i8 2]
 @global_inst = private constant [2 x i8] [i8 1, i8 2]
 ; CHECK-NOT: {{asan_gen.*global_noinst}}
 ; CHECK: {{asan_gen.*global_inst}}
 ; CHECK: @asan.module_ctor

llvm/test/Instrumentation/AddressSanitizer/do-not-touch-threadlocal.ll

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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"
 ; no action should be taken for thread locals
 @xxx = thread_local global i32 0, align 4
 ; CHECK-NOT: {{call.*__asan_register_globals}}

llvm/test/Instrumentation/AddressSanitizer/experiment-call.ll

 ; Test optimization experiments.
 ; -asan-force-experiment flag turns all memory accesses into experiments.
-; RUN: opt < %s -asan -asan-module -asan-force-experiment=42 -asan-instrumentation-with-call-threshold=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-force-experiment=42 -asan-instrumentation-with-call-threshold=0 -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"
 
 define void @load1(i8* %p) sanitize_address {
 entry:
   %t = load i8, i8* %p, align 1
   ret void
 ; CHECK-LABEL: define void @load1

llvm/test/Instrumentation/AddressSanitizer/experiment.ll

 ; Test optimization experiments.
 ; -asan-force-experiment flag turns all memory accesses into experiments.
-; RUN: opt < %s -asan -asan-module -asan-force-experiment=42 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-force-experiment=42 -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"
 
 define void @load1(i8* %p) sanitize_address {
 entry:
   %t = load i8, i8* %p, align 1
   ret void
 ; CHECK-LABEL: define void @load1

llvm/test/Instrumentation/AddressSanitizer/force-dynamic-shadow.ll

 ; Test -asan-force-dynamic-shadow flag.
 ;
-; RUN: opt -asan -asan-module -S -asan-force-dynamic-shadow=1 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-FDS
-; RUN: opt -asan -asan-module -S -asan-force-dynamic-shadow=0 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-NDS
+; RUN: %opt_asan -asan -asan-module -S -asan-force-dynamic-shadow=1 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-FDS
+; RUN: %opt_asan -asan -asan-module -S -asan-force-dynamic-shadow=0 < %s | FileCheck %s --check-prefixes=CHECK,CHECK-NDS
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @test_load(i32* %a) sanitize_address {
 ; First instrumentation in the function must be to load the dynamic shadow
 ; address into a local variable.
 ; CHECK-LABEL: @test_load
 ; CHECK: entry:

llvm/test/Instrumentation/AddressSanitizer/freebsd.ll

-; RUN: opt < %s -asan -asan-module -S \
+; RUN: %opt_asan < %s -asan -asan-module -S \
 ; RUN:     -mtriple=i386-unknown-freebsd \
 ; RUN:     -data-layout="e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" | \
-; RUN:     FileCheck --check-prefix=CHECK-32 %s
+; RUN:     FileCheck --check-prefixes=CHECK-32,CHECK-32-S%scale %s
 
-; RUN: opt < %s -asan -asan-module -S \
+; RUN: %opt_asan < %s -asan -asan-module -S \
 ; RUN:     -mtriple=x86_64-unknown-freebsd \
 ; RUN:     -data-layout="e-m:e-i64:64-f80:128-n8:16:32:64-S128" | \
-; RUN:     FileCheck --check-prefix=CHECK-64 %s
+; RUN:     FileCheck --check-prefixes=CHECK-64,CHECK-64-S%scale %s
 
 define i32 @read_4_bytes(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }
 
 ; CHECK-32: @read_4_bytes
 ; CHECK-32-NOT: ret
 ; Check for ASAN's Offset for 32-bit (2^30 or 0x40000000)
-; CHECK-32: lshr {{.*}} 3
+; CHECK-32-S3: lshr {{.*}} 3
+; CHECK-32-S5: lshr {{.*}} 5
 ; CHECK-32-NEXT: {{1073741824}}
 ; CHECK-32: ret
 
 ; CHECK-64: @read_4_bytes
 ; CHECK-64-NOT: ret
 ; Check for ASAN's Offset for 64-bit (2^46 or 0x400000000000)
-; CHECK-64: lshr {{.*}} 3
+; CHECK-64-S3: lshr {{.*}} 3
+; CHECK-64-S5: lshr {{.*}} 5
 ; CHECK-64-NEXT: {{70368744177664}}
 ; CHECK-64: ret

llvm/test/Instrumentation/AddressSanitizer/global_cstring_darwin.ll

 ; This test checks that instrumented global C (null terminated) strings are put into a special section on Darwin.
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; Should be put into __asan_cstring section:
 @.str.1 = private unnamed_addr constant [13 x i8] c"Hello world.\00", align 1
 @.str.2 = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
 

llvm/test/Instrumentation/AddressSanitizer/global_metadata.ll

-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Globals:
 @global = global i32 0, align 4
 @dyn_init_global = global i32 0, align 4
 @blacklisted_global = global i32 0, align 4

llvm/test/Instrumentation/AddressSanitizer/global_metadata_array.ll

-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-unknown-linux-gnu -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-apple-macosx10.11.0 -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-pc-windows-msvc19.0.24215 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-unknown-linux-gnu -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-apple-macosx10.11.0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=0 -mtriple=x86_64-pc-windows-msvc19.0.24215 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Globals:
 @global = global i32 0, align 4
 @dyn_init_global = global i32 0, align 4
 @blacklisted_global = global i32 0, align 4
 @_ZZ4funcvE10static_var = internal global i32 0, align 4

llvm/test/Instrumentation/AddressSanitizer/global_metadata_darwin.ll

 ; Test that global metadata is placed in a separate section on Mach-O platforms,
 ; allowing dead stripping to be performed, and that the appropriate runtime
 ; routines are invoked.
 
-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=1 -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"
 
 @global = global [1 x i32] zeroinitializer, align 4
 
 !llvm.asan.globals = !{!0}
 

llvm/test/Instrumentation/AddressSanitizer/global_metadata_windows.ll

 ; Test that global metadata is placed in a separate section on Windows, and that
 ; it is in the same comdat group as the instrumented global. This ensures that
 ; linker dead stripping (/OPT:REF) works as intended.
 
 ; FIXME: Later we can use this to instrument linkonce odr string literals.
 
-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 
 $mystr = comdat any
 
 ; CHECK: $dead_global = comdat noduplicates
 ; CHECK: $private_str = comdat noduplicates

llvm/test/Instrumentation/AddressSanitizer/instrument-dynamic-allocas.ll

 ; Test asan internal compiler flags:
 ;   -asan-instrument-dynamic-allocas
 
-; RUN: opt < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s --check-prefix=CHECK-ALLOCA
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrument-dynamic-allocas -S | FileCheck %s --check-prefix=CHECK-ALLOCA
 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 @foo(i32 %len) sanitize_address {
 entry:
 ; CHECK-ALLOCA-LABEL: define void @foo
 ; CHECK-ALLOCA: __asan_alloca_poison
 ; CHECK-ALLOCA: __asan_allocas_unpoison

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

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck %s
 ; AddressSanitizer must insert __asan_handle_no_return
 ; before every noreturn call or invoke.
 
 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 @MyNoReturnFunc(i32) noreturn
 

llvm/test/Instrumentation/AddressSanitizer/instrument-stack.ll

 ; This test checks that we are not instrumenting direct inbound stack accesses.
-; RUN: opt < %s -asan -asan-module -asan-opt-stack -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-opt-stack -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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ;@sink = global i32* null, align 4
 
 ; Ignore direct inbounds stack access.
 define void @foo() uwtable sanitize_address {

llvm/test/Instrumentation/AddressSanitizer/instrument_global.ll

-; RUN: opt < %s -asan -asan-module -asan-globals-live-support=1 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-globals-live-support=1 -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"
 @xxx = global i32 0, align 4
 
 ; If a global is present, __asan_[un]register_globals should be called from
 ; module ctor/dtor
 
 ; CHECK: @__asan_gen_ = private constant [8 x i8] c"<stdin>\00", align 1

llvm/test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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"
 @xxx = internal global i32 0, align 4  ; With dynamic initializer.
 @XXX = global i32 0, align 4           ; With dynamic initializer.
 @yyy = internal global i32 0, align 4  ; W/o dynamic initializer.
 @YYY = global i32 0, align 4           ; W/o dynamic initializer.
 ; Clang will emit the following metadata identifying @xxx as dynamically
 ; initialized.

llvm/test/Instrumentation/AddressSanitizer/instrument_load_then_store.ll

 ; Test that AddressSanitizer instruments "(*a)++" only once.
-; RUN: opt < %s -asan -asan-module -S -asan-opt=1 | FileCheck %s -check-prefix=OPT1
-; RUN: opt < %s -asan -asan-module -S -asan-opt=0 | FileCheck %s -check-prefix=OPT0
+; RUN: %opt_asan < %s -asan -asan-module -S -asan-opt=1 | FileCheck %s -check-prefix=OPT1
+; RUN: %opt_asan < %s -asan -asan-module -S -asan-opt=0 | FileCheck %s -check-prefix=OPT0
 
 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 @IncrementMe(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   %tmp2 = add i32 %tmp1,  1
   store i32 %tmp2, i32* %a, align 4

llvm/test/Instrumentation/AddressSanitizer/instrumentation-with-call-threshold.ll

 ; Test asan internal compiler flags:
 ;   -asan-instrumentation-with-call-threshold
 ;   -asan-memory-access-callback-prefix
 
-; RUN: opt < %s -asan -asan-module -asan-instrumentation-with-call-threshold=1 -S | FileCheck %s --check-prefix=CHECK-CALL
-; RUN: opt < %s -asan -asan-module -asan-instrumentation-with-call-threshold=0 -S | FileCheck %s --check-prefix=CHECK-CALL
-; RUN: opt < %s -asan -asan-module -asan-instrumentation-with-call-threshold=0 -asan-memory-access-callback-prefix=__foo_ -S | FileCheck %s --check-prefix=CHECK-CUSTOM-PREFIX
-; RUN: opt < %s -asan -asan-module -asan-instrumentation-with-call-threshold=5 -S | FileCheck %s --check-prefix=CHECK-INLINE
-; RUN: opt < %s -asan -asan-module  -S | FileCheck %s --check-prefix=CHECK-INLINE
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrumentation-with-call-threshold=1 -S | FileCheck %s --check-prefix=CHECK-CALL
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrumentation-with-call-threshold=0 -S | FileCheck %s --check-prefix=CHECK-CALL
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrumentation-with-call-threshold=0 -asan-memory-access-callback-prefix=__foo_ -S | FileCheck %s --check-prefix=CHECK-CUSTOM-PREFIX
+; RUN: %opt_asan < %s -asan -asan-module -asan-instrumentation-with-call-threshold=5 -S | FileCheck %s --check-prefix=CHECK-INLINE
+; RUN: %opt_asan < %s -asan -asan-module  -S | FileCheck %s --check-prefix=CHECK-INLINE
 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:
 ; CHECK-CALL: call void @__asan_load4
 ; CHECK-CALL: call void @__asan_load8
 ; CHECK-CALL: call void @__asan_loadN{{.*}}i64 64)

llvm/test/Instrumentation/AddressSanitizer/keep_going.ll

 ; Test asan internal compiler flags:
 ;   -asan-recover=1
 
-; RUN: opt < %s -asan -asan-recover -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-recover -asan-module -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"
 
 define i32 @foo(i32* %p) sanitize_address {
 ; CHECK: __asan_report_load4_noabort
 ; CHECK-NOT: unreachable
   %1 = load i32, i32* %p, align 4
   ret i32 %1
 }
 

llvm/test/Instrumentation/AddressSanitizer/local_alias.ll

-; RUN: opt < %s -asan -asan-module -asan-use-private-alias=1 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-private-alias=1 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = internal global [2 x i32] zeroinitializer, align 4
 
 ; Check that we generate internal alias and odr indicator symbols for global to be protected.
 ; CHECK: @__odr_asan_gen_a = internal global i8 0, align 1

llvm/test/Instrumentation/AddressSanitizer/localescape.ll

-; RUN: opt < %s -asan -asan-module -asan-use-after-return -asan-stack-dynamic-alloca -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-use-after-return=0 -asan-stack-dynamic-alloca=0 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return -asan-stack-dynamic-alloca -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-use-after-return=0 -asan-stack-dynamic-alloca=0 -S | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 declare i32 @llvm.eh.typeid.for(i8*) #2
 declare i8* @llvm.frameaddress(i32)
 declare i8* @llvm.x86.seh.recoverfp(i8*, i8*)
 declare i8* @llvm.localrecover(i8*, i8*, i32)

llvm/test/Instrumentation/AddressSanitizer/no-globals.ll

 ; A module with no asan-instrumented globals has no asan destructor, and has an asan constructor in a comdat.
-; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -asan -asan-module -asan-with-comdat=1 -asan-globals-live-support=1 -S | FileCheck %s
+; RUN: %opt_asan -mtriple=x86_64-unknown-linux-gnu < %s -asan -asan-module -asan-with-comdat=1 -asan-globals-live-support=1 -S | FileCheck %s
 
 define void @f() {
   ret void
 }
 
 ; CHECK-NOT: @llvm.global_dtors
 ; CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 1, void ()* @asan.module_ctor, i8* bitcast (void ()* @asan.module_ctor to i8*) }]
 ; CHECK-NOT: @llvm.global_dtors
 ; CHECK: define internal void @asan.module_ctor() comdat
 ; CHECK-NOT: @llvm.global_dtors

llvm/test/Instrumentation/AddressSanitizer/ps4.ll

-; RUN: opt < %s -asan -asan-module -S -mtriple=x86_64-scei-ps4 | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S -mtriple=x86_64-scei-ps4 | FileCheck --check-prefixes=CHECK,CHECK-S%scale %s
 
 define i32 @read_4_bytes(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }
 
 ; CHECK: @read_4_bytes
 ; CHECK-NOT: ret
 ; Check for ASAN's Offset on the PS4 (2^40 or 0x10000000000)
-; CHECK: lshr {{.*}} 3
+; CHECK-S3: lshr {{.*}} 3
+; CHECK-S5: lshr {{.*}} 5
 ; CHECK-NEXT: {{1099511627776}}
 ; CHECK: ret

llvm/test/Instrumentation/AddressSanitizer/scale-offset.ll

 ; Test that the scale (-asan-mapping-scale) and offset (-asan-mapping-offset) command-line options work as expected
 ;
-; RUN: opt < %s -asan -asan-module -asan-mapping-offset 0xdeadbeef -S | FileCheck --check-prefix=CHECK-OFFSET %s
+; RUN: %opt_asan < %s -asan -asan-module -asan-mapping-offset 0xdeadbeef -S | FileCheck --check-prefixes=CHECK-OFFSET,CHECK-OFFSET-S%scale %s
 ; RUN: opt < %s -asan -asan-module -asan-mapping-scale 1 -S | FileCheck --check-prefix=CHECK-SCALE %s
 ; RUN: opt < %s -asan -asan-module -asan-mapping-offset 0xc0ffee -asan-mapping-scale 0 -S | FileCheck --check-prefix=CHECK-BOTH %s
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @read_offset(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }
 ; CHECK-OFFSET-LABEL: @read_offset
 ; CHECK-OFFSET-NOT: ret
-; CHECK-OFFSET: lshr {{.*}} 3
+; CHECK-OFFSET-S3: lshr {{.*}} 3
+; CHECK-OFFSET-S5: lshr {{.*}} 5
 ; CHECK-OFFSET-NEXT: add{{.*}}3735928559
 ; CHECK-OFFSET: ret
 
 define i32 @read_scale(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }

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

 ; This check verifies that arguments passed by value get redzones.
-; RUN: opt < %s -asan -asan-realign-stack=32 -S | FileCheck %s
-; RUN: opt < %s -asan -asan-realign-stack=32 -asan-force-dynamic-shadow -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-realign-stack=32 -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-realign-stack=32 -asan-force-dynamic-shadow -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/stack_dynamic_alloca.ll

-; RUN: opt < %s -asan -asan-module -asan-stack-dynamic-alloca \
+; RUN: %opt_asan < %s -asan -asan-module -asan-stack-dynamic-alloca \
 ; RUN:       -asan-use-after-return -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-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @Func1() sanitize_address {
 entry:
 ; CHECK-LABEL: Func1
 

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

 ; Test marking string functions as nobuiltin in address sanitizer.
 ;
-; RUN: opt < %s -asan -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -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/test64.ll

-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -S | FileCheck --check-prefixes=CHECK,CHECK-S%scale %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 i32 @read_4_bytes(i32* %a) sanitize_address {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1
 }
 ; CHECK-LABEL: @read_4_bytes
 ; CHECK-NOT: ret
-; CHECK: lshr {{.*}} 3
-; Check for ASAN's Offset for 64-bit (7fff8000)
-; CHECK-NEXT: add{{.*}}2147450880
+; CHECK-S3: lshr {{.*}} 3
+; CHECK-S5: lshr {{.*}} 5
+; Check for ASAN's Offset for 64-bit (7fff8000|7ffe0000)
+; CHECK-S3-NEXT: add{{.*}}2147450880
+; CHECK-S5-NEXT: add{{.*}}2147352576
 ; CHECK: ret
 
 define void @example_atomicrmw(i64* %ptr) nounwind uwtable sanitize_address {
 entry:
   %0 = atomicrmw add i64* %ptr, i64 1 seq_cst
   ret void
 }
 
 ; CHECK-LABEL: @example_atomicrmw
-; CHECK: lshr {{.*}} 3
+; CHECK-S3: lshr {{.*}} 3
+; CHECK-S5: lshr {{.*}} 5
 ; CHECK: __asan_report_store8
 ; CHECK-NOT: __asan_report
 ; CHECK: atomicrmw
 ; CHECK: ret
 
 define void @example_cmpxchg(i64* %ptr, i64 %compare_to, i64 %new_value) nounwind uwtable sanitize_address {
 entry:
   %0 = cmpxchg i64* %ptr, i64 %compare_to, i64 %new_value seq_cst seq_cst
   ret void
 }
 
 ; CHECK-LABEL: @example_cmpxchg
-; CHECK: lshr {{.*}} 3
+; CHECK-S3: lshr {{.*}} 3
+; CHECK-S5: lshr {{.*}} 5
 ; CHECK: __asan_report_store8
 ; CHECK-NOT: __asan_report
 ; CHECK: cmpxchg
 ; CHECK: ret

llvm/test/Instrumentation/AddressSanitizer/twice.ll

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

llvm/test/Instrumentation/AddressSanitizer/ubsan.ll

 ; ASan shouldn't instrument code added by UBSan.
 
-; RUN: opt < %s -asan -asan-module -S | FileCheck %s
+; RUN: %opt_asan < %s -asan -asan-module -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 { i32 (...)** }
 declare void @__ubsan_handle_dynamic_type_cache_miss(i8*, i64, i64) uwtable
 @__ubsan_vptr_type_cache = external global [128 x i64]
 @.src = private unnamed_addr constant [19 x i8] c"tmp/ubsan/vptr.cpp\00", align 1

llvm/test/lit.cfg.py

 # -*- Python -*-
 
 # Configuration file for the 'lit' test runner.
 
 import os
 import sys
 import re
 import platform
 import subprocess
 
 import lit.util
 import lit.formats
 from lit.llvm import llvm_config
 from lit.llvm.subst import FindTool
 from lit.llvm.subst import ToolSubst
 
-# name: The name of this test suite.
+# name: The name of this test suite.  Append shadow scale value if it
+# is non-default.
+if config.asan_test_shadow_scale != '3':
+  config.name = 'LLVM-Scale%s' % config.asan_test_shadow_scale
+else:
   config.name = 'LLVM'
 
 # testFormat: The test format to use to interpret tests.
 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files. This is overriden
 # by individual lit.local.cfg files in the test subdirectories.
 config.suffixes = ['.ll', '.c', '.cxx', '.test', '.txt', '.s', '.mir']
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
 # directories.
 config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
-# test_exec_root: The root path where tests should be run.
-config.test_exec_root = os.path.join(config.llvm_obj_root, 'test')
-
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
 
 # Propagate some variables from the host environment.
 llvm_config.with_system_environment(
     ['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP', 'ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH'])
 
 

 
 llvm_config.use_default_substitutions()
 
 # Add site-specific substitutions.
 config.substitutions.append(('%llvmshlibdir', config.llvm_shlib_dir))
 config.substitutions.append(('%shlibext', config.llvm_shlib_ext))
 config.substitutions.append(('%exeext', config.llvm_exe_ext))
 config.substitutions.append(('%host_cc', config.host_cc))
+if config.asan_shadow_scale == config.asan_test_shadow_scale:
+  config.substitutions.append(('%opt_asan', 'opt'))
+else:
+  config.substitutions.append(('%opt_asan',
+                               'opt -asan-mapping-scale %s' %
+                               config.asan_test_shadow_scale))
+config.substitutions.append(('%scale', config.asan_test_shadow_scale))
 
 
 lli_args = []
 # The target triple used by default by lli is the process target triple (some
 # triple appropriate for generating code for the current process) but because
 # we don't support COFF in MCJIT well enough for the tests, force ELF format on
 # Windows.  FIXME: the process target triple should be used here, but this is
 # difficult to obtain on Windows.

llvm/test/lit.site.cfg.py.in

 config.have_libxar = @HAVE_LIBXAR@
 config.have_dia_sdk = @LLVM_ENABLE_DIA_SDK@
 config.enable_ffi = @LLVM_ENABLE_FFI@
 config.build_shared_libs = @BUILD_SHARED_LIBS@
 config.link_llvm_dylib = @LLVM_LINK_LLVM_DYLIB@
 config.llvm_libxml2_enabled = "@LLVM_LIBXML2_ENABLED@"
 config.llvm_host_triple = '@LLVM_HOST_TRIPLE@'
 config.host_arch = "@HOST_ARCH@"
+config.asan_shadow_scale = "@LLVM_ASAN_SHADOW_SCALE@"
+config.asan_test_shadow_scale = "@LLVM_ASAN_TEST_SHADOW_SCALE@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
 except KeyError:
     e = sys.exc_info()[1]
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 @LIT_SITE_CFG_IN_FOOTER@
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLVM_SOURCE_DIR@/test/lit.cfg.py")