[GWP-ASan] Migrate lit tests from old Scudo -> Standalone.

[hctim]

Summary

This removes one of the last dependencies on old Scudo, and should allow
us to delete the old Scudo soon.

[vitalybuka]

compiler-rt/lib/scudo/standalone/CMakeLists.txt

9–11

It's small but helpful for debugging. We distribute this as a lib so better have debug info and let linker strip it, as other sanitizers do.

[hctim]

Revert removal of '-g' for scudo archives/dso.

compiler-rt/lib/scudo/standalone/CMakeLists.txt

9–11

Reverted.

[hctim]

Friendly ping @cryptoad

compiler-rt/lib/scudo/CMakeLists.txt

 
 # The minimal Scudo runtime does not inlude the UBSan runtime.
 set(SCUDO_MINIMAL_OBJECT_LIBS
   RTSanitizerCommonNoTermination
   RTSanitizerCommonLibc
   RTInterception)
 
 if (COMPILER_RT_HAS_GWP_ASAN)
-  # Currently, Scudo uses the GwpAsan flag parser. This backs onto the flag
-  # parsing mechanism of sanitizer_common. Once Scudo has its own flag parsing,
-  # and parses GwpAsan options, you can remove this dependency.
-  list(APPEND SCUDO_MINIMAL_OBJECT_LIBS RTGwpAsan RTGwpAsanOptionsParser
-                                        RTGwpAsanBacktraceLibc
-                                        RTGwpAsanSegvHandler)
+  list(APPEND SCUDO_MINIMAL_OBJECT_LIBS
+       RTGwpAsan RTGwpAsanOptionsParser RTGwpAsanBacktraceLibc
   list(APPEND SCUDO_CFLAGS -DGWP_ASAN_HOOKS)
 endif()
 
 set(SCUDO_OBJECT_LIBS ${SCUDO_MINIMAL_OBJECT_LIBS})
 set(SCUDO_DYNAMIC_LIBS ${SCUDO_MINIMAL_DYNAMIC_LIBS})
 
 if (FUCHSIA)
   list(APPEND SCUDO_CFLAGS -nostdinc++)

compiler-rt/lib/scudo/standalone/CMakeLists.txt

 add_compiler_rt_component(scudo_standalone)
-if (COMPILER_RT_HAS_GWP_ASAN)
-  add_dependencies(scudo_standalone gwp_asan)
-endif()
 
 include_directories(../.. include)
 
 set(SCUDO_CFLAGS)
 
 list(APPEND SCUDO_CFLAGS
   -Werror=conversion
   -Wall
   -g
   -nostdinc++)
 
 # Remove -stdlib= which is unused when passing -nostdinc++.
 string(REGEX REPLACE "-stdlib=[a-zA-Z+]*" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 
 append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SCUDO_CFLAGS)
 
 append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SCUDO_CFLAGS)
 
 append_list_if(COMPILER_RT_HAS_WNO_PEDANTIC -Wno-pedantic SCUDO_CFLAGS)
 
 # FIXME: find cleaner way to agree with GWPAsan flags
 append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SCUDO_CFLAGS)
 
-if (COMPILER_RT_HAS_GWP_ASAN)
-  append_list_if(COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG -fno-omit-frame-pointer
-                SCUDO_CFLAGS)
-  append_list_if(COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG
-                -mno-omit-leaf-frame-pointer SCUDO_CFLAGS)
-endif() # COMPILER_RT_HAS_GWP_ASAN
-
 if(COMPILER_RT_DEBUG)
   list(APPEND SCUDO_CFLAGS -O0)
 else()
   list(APPEND SCUDO_CFLAGS -O3)
 endif()
 
 set(SCUDO_LINK_FLAGS)
 

 
 set(SCUDO_SOURCES_CXX_WRAPPERS
   wrappers_cpp.cpp
   )
 
 set(SCUDO_OBJECT_LIBS)
 
 if (COMPILER_RT_HAS_GWP_ASAN)
+  add_dependencies(scudo_standalone gwp_asan)
   list(APPEND SCUDO_OBJECT_LIBS
-       RTGwpAsan RTGwpAsanBacktraceLibc RTGwpAsanSegvHandler)
-  list(APPEND SCUDO_CFLAGS -DGWP_ASAN_HOOKS)
+       RTGwpAsan RTGwpAsanBacktraceLibc RTGwpAsanSegvHandler
+       RTGwpAsanOptionsParser)
+
+  list(APPEND SCUDO_CFLAGS -DGWP_ASAN_HOOKS -fno-omit-frame-pointer
+                           -mno-omit-leaf-frame-pointer)
 endif()
 
 set(SCUDO_LINK_LIBS)
 
 append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread SCUDO_LINK_FLAGS)
 
 append_list_if(FUCHSIA zircon SCUDO_LINK_LIBS)
 
add_compiler_rt_runtime(clang_rt.scudo_standalone
     OBJECT_LIBS ${SCUDO_OBJECT_LIBS}
     PARENT_TARGET scudo_standalone)
   add_compiler_rt_runtime(clang_rt.scudo_standalone_cxx
     STATIC
     ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES_CXX_WRAPPERS}
     ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}
-    OBJECT_LIBS ${SCUDO_OBJECT_LIBS}
     PARENT_TARGET scudo_standalone)
 
   add_compiler_rt_runtime(clang_rt.scudo_standalone
     SHARED
     ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES} ${SCUDO_SOURCES_C_WRAPPERS} ${SCUDO_SOURCES_CXX_WRAPPERS}
     ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}

compiler-rt/lib/scudo/standalone/tests/CMakeLists.txt

set(SCUDO_UNITTEST_CFLAGS
   # TODO(kostyak): find a way to make -fsized-deallocation work
   -Wno-mismatched-new-delete)
 
 if(ANDROID)
   list(APPEND SCUDO_UNITTEST_CFLAGS -fno-emulated-tls)
 endif()
 
 if (COMPILER_RT_HAS_GWP_ASAN)
-  list(APPEND SCUDO_UNITTEST_CFLAGS -DGWP_ASAN_HOOKS)
+  list(APPEND SCUDO_UNITTEST_CFLAGS -DGWP_ASAN_HOOKS -fno-omit-frame-pointer
+       -mno-omit-leaf-frame-pointer)
 endif()
 
 set(SCUDO_TEST_ARCH ${SCUDO_STANDALONE_SUPPORTED_ARCH})
 
 # gtests requires c++
 set(LINK_FLAGS ${COMPILER_RT_UNITTEST_LINK_FLAGS})
 foreach(lib ${SANITIZER_TEST_CXX_LIBRARIES})
   list(APPEND LINK_FLAGS -l${lib})

compiler-rt/test/gwp_asan/CMakeLists.txt

 set(GWP_ASAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(GWP_ASAN_LIT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 set(GWP_ASAN_TESTSUITES)
 
 set(GWP_ASAN_UNITTEST_DEPS)
 set(GWP_ASAN_TEST_DEPS
   ${SANITIZER_COMMON_LIT_TEST_DEPS}
   gwp_asan
-  scudo)
+  scudo_standalone)
 
 # Longstanding issues in the Android test runner means that compiler-rt unit
 # tests don't work on Android due to libc++ link-time issues. Looks like the
 # exported libc++ from the Android NDK is x86-64, even though it's part of the
 # ARM[64] toolchain... See similar measures for ASan and sanitizer-common that
 # disable unit tests for Android.
 if (COMPILER_RT_INCLUDE_TESTS AND COMPILER_RT_HAS_GWP_ASAN AND NOT ANDROID)
   list(APPEND GWP_ASAN_TEST_DEPS GwpAsanUnitTests)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/unit/lit.site.cfg.py.in
     ${CMAKE_CURRENT_BINARY_DIR}/unit/lit.site.cfg.py)
-  list(APPEND GWP_ASAN_TEST_DEPS ${GWP_ASAN_TEST_DEPS})
   list(APPEND GWP_ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/unit)
 endif()
 
-configure_lit_site_cfg(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
-  )
-
+if (COMPILER_RT_INCLUDE_TESTS AND COMPILER_RT_HAS_SCUDO_STANDALONE AND COMPILER_RT_HAS_GWP_ASAN)
   foreach(arch ${GWP_ASAN_SUPPORTED_ARCH})
     set(GWP_ASAN_TEST_TARGET_ARCH ${arch})
     string(TOLOWER "-${arch}" GWP_ASAN_TEST_CONFIG_SUFFIX)
     get_test_cc_for_arch(${arch} GWP_ASAN_TEST_TARGET_CC GWP_ASAN_TEST_TARGET_CFLAGS)
     string(TOUPPER ${arch} ARCH_UPPER_CASE)
     set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
 
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
     list(APPEND GWP_ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
   endforeach()
+endif()
 
 add_lit_testsuite(check-gwp_asan "Running the GWP-ASan tests"
   ${GWP_ASAN_TESTSUITES}
   DEPENDS ${GWP_ASAN_TEST_DEPS})
 set_target_properties(check-gwp_asan PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/test/gwp_asan/backtrace.c

 // REQUIRES: gwp_asan
-// RUN: %clang_gwp_asan %s -g -o %t
+// RUN: %clang_gwp_asan -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer %s -g -o %t
 // RUN: %expect_crash %t 2>&1 | FileCheck %s
 
+// Ensure we don't crash when using the unwinder when frame pointers are
+// disabled.
+// RUN: %clang_gwp_asan -fomit-frame-pointer -momit-leaf-frame-pointer %s -g -o %t
+// RUN: %expect_crash %t
+
 #include <stdlib.h>
 
 __attribute__((noinline)) void *allocate_mem() { return malloc(1); }
 
 __attribute__((noinline)) void free_mem(void *ptr) { free(ptr); }
 
 __attribute__((noinline)) void touch_mem(void *ptr) {
   volatile char sink = *((volatile char *)ptr);

compiler-rt/test/gwp_asan/lit.cfg.py

 # -*- Python -*-
 
 import os
 
 # Setup config name.
 config.name = 'GWP-ASan' + config.name_suffix
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
 # Test suffixes.
 config.suffixes = ['.c', '.cpp', '.test']
 
 # C & CXX flags.
 c_flags = ([config.target_cflags])
 
-# Android doesn't want -lrt.
-if not config.android:
-  c_flags += ["-lrt"]
+cxx_flags = (c_flags + config.cxx_mode_flags + ["-std=c++14"])
 
-cxx_flags = (c_flags + config.cxx_mode_flags + ["-std=c++11"])
+libscudo_standalone = os.path.join(
+    config.compiler_rt_libdir,
+    "libclang_rt.scudo_standalone%s.a" % config.target_suffix)
+libscudo_standalone_cxx = os.path.join(
+    config.compiler_rt_libdir,
+    "libclang_rt.scudo_standalone_cxx%s.a" % config.target_suffix)
+
+scudo_link_flags = ["-pthread", "-Wl,--whole-archive", libscudo_standalone,
+                    "-Wl,--no-whole-archive"]
+scudo_link_cxx_flags = ["-Wl,--whole-archive", libscudo_standalone_cxx,
+                        "-Wl,--no-whole-archive"]
 
-gwp_asan_flags = ["-fsanitize=scudo", "-g", "-fno-omit-frame-pointer",
-                  "-mno-omit-leaf-frame-pointer"]
+# -rdynamic is necessary for online function symbolization.
+gwp_asan_flags = ["-rdynamic"] + scudo_link_flags
 
 def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
 # Add substitutions.
 config.substitutions.append(("%clang ", build_invocation(c_flags)))
-config.substitutions.append(("%clang_gwp_asan ", build_invocation(c_flags + gwp_asan_flags)))
-config.substitutions.append(("%clangxx_gwp_asan ", build_invocation(cxx_flags + gwp_asan_flags)))
+config.substitutions.append(
+    ("%clang_gwp_asan ", build_invocation(c_flags + gwp_asan_flags)))
+config.substitutions.append((
+    "%clangxx_gwp_asan ",
+    build_invocation(cxx_flags + gwp_asan_flags + scudo_link_cxx_flags)))
 
 # Platform-specific default GWP_ASAN for lit tests. Ensure that GWP-ASan is
 # enabled and that it samples every allocation.
-default_gwp_asan_options = 'Enabled=1:SampleRate=1'
+default_gwp_asan_options = 'GWP_ASAN_Enabled=1:GWP_ASAN_SampleRate=1'
 
-config.environment['GWP_ASAN_OPTIONS'] = default_gwp_asan_options
+config.environment['SCUDO_OPTIONS'] = default_gwp_asan_options
 default_gwp_asan_options += ':'
-config.substitutions.append(('%env_gwp_asan_options=',
-                             'env GWP_ASAN_OPTIONS=' + default_gwp_asan_options))
+config.substitutions.append(('%env_scudo_options=',
+                             'env SCUDO_OPTIONS=' + default_gwp_asan_options))
 
 # GWP-ASan tests are currently supported on Linux only.
 if config.host_os not in ['Linux']:
    config.unsupported = True

compiler-rt/test/gwp_asan/repeated_alloc.cpp

 // REQUIRES: gwp_asan
 // This test ensures that normal allocation/memory access/deallocation works
 // as expected and we didn't accidentally break the supporting allocator.
 
 // RUN: %clangxx_gwp_asan %s -o %t
-// RUN: %env_gwp_asan_options=MaxSimultaneousAllocations=1 %run %t
-// RUN: %env_gwp_asan_options=MaxSimultaneousAllocations=2 %run %t
-// RUN: %env_gwp_asan_options=MaxSimultaneousAllocations=11 %run %t
-// RUN: %env_gwp_asan_options=MaxSimultaneousAllocations=12 %run %t
-// RUN: %env_gwp_asan_options=MaxSimultaneousAllocations=13 %run %t
+// RUN: %env_scudo_options=GWP_ASAN_MaxSimultaneousAllocations=1 %run %t
+// RUN: %env_scudo_options=GWP_ASAN_MaxSimultaneousAllocations=2 %run %t
+// RUN: %env_scudo_options=GWP_ASAN_MaxSimultaneousAllocations=11 %run %t
+// RUN: %env_scudo_options=GWP_ASAN_MaxSimultaneousAllocations=12 %run %t
+// RUN: %env_scudo_options=GWP_ASAN_MaxSimultaneousAllocations=13 %run %t
 
 #include <cstdlib>
 
 int main() {
   void* Pointers[16];
   for (unsigned i = 0; i < 16; ++i) {
     char *Ptr = reinterpret_cast<char*>(malloc(1 << i));
     Pointers[i] = Ptr;