[sanitizer_common][test] Enable tests on SPARC

[ro]

Summary

Unfortunately, the sanitizer_common tests are disabled on many targets that are supported by sanitizer_common, making it easy to miss issues with that support. This patch enables SPARC testing.

Beside the enabling proper, the patch fixes (together with D91607) the failures of the symbolize_pc.cpp and symbolize_pc_inline.cpp tests. Those tests PASS when compiled with gcc, which happens because clang incorrectly doesn't implement a non-default __builtin_extract_return_addr on several targets, SPARC included.

Because __builtin_extract_return_addr(__builtin_return_addr(0)) is quite a mouthful and I'm uncertain if the code needs to compile with msvc which appparently has it's own _ReturnAddres, I've introduced __sanitizer_return_addr to hide the difference and complexity. Because on 32-bit SPARC __builtin_extract_return_addr differs when the calling funtion returns a struct, I've added a testcase for that.

There are a couple more tests failing on SPARC that I will deal with separately.

Tested on sparcv9-sun-solaris2.11, amd64-pc-solaris2.11, and x86_64-pc-linux-gnu.

[vitalybuka]

compiler-rt/include/sanitizer/common_interface_defs.h

214–222

gcc also supports __builtin_extract_return_addr

[ro]

Handle new symbolize_pc_demangle.cpp

I hadn't applied this yet, hoping to get D91607. In the meantime, a new affected testcase came up, handled in this version. I hope that's still ok.

compiler-rt/include/sanitizer/common_interface_defs.h

 // Inlined frames can be removed with 'symbolize_inline_frames=0'.
 // The format syntax is described in
 // lib/sanitizer_common/sanitizer_stacktrace_printer.h.
 void __sanitizer_symbolize_pc(void *pc, const char *fmt, char *out_buf,
                               size_t out_buf_size);
 // Same as __sanitizer_symbolize_pc, but for data section (i.e. globals).
 void __sanitizer_symbolize_global(void *data_ptr, const char *fmt,
                                   char *out_buf, size_t out_buf_size);
+// Determine the return address.
+#if !defined(_MSC_VER) || defined(__clang__)
+#define __sanitizer_return_address()                                           \
+  __builtin_extract_return_addr(__builtin_return_address(0))
+#else
+extern "C" void *_ReturnAddress(void);
+#pragma intrinsic(_ReturnAddress)
+#define __sanitizer_return_address() _ReturnAddress()
+#endif
 
 /// Sets the callback to be called immediately before death on error.
 ///
 /// Passing 0 will unset the callback.
 ///
 /// \param callback User-provided callback.
 void __sanitizer_set_death_callback(void (*callback)(void));
 

compiler-rt/lib/sanitizer_common/tests/CMakeLists.txt

 include(CompilerRTCompile)
 
 clang_compiler_add_cxx_check()
 
 # FIXME: use SANITIZER_COMMON_SUPPORTED_ARCH here
-filter_available_targets(SANITIZER_UNITTEST_SUPPORTED_ARCH x86_64 i386 mips64 mips64el riscv64)
+filter_available_targets(SANITIZER_UNITTEST_SUPPORTED_ARCH x86_64 i386 mips64 mips64el riscv64 sparcv9 sparc)
 if(APPLE)
   darwin_filter_host_archs(SANITIZER_UNITTEST_SUPPORTED_ARCH SANITIZER_UNITTEST_SUPPORTED_ARCH)
 endif()
 
 set(SANITIZER_UNITTESTS
   sanitizer_addrhashmap_test.cpp
   sanitizer_allocator_test.cpp
   sanitizer_atomic_test.cpp

compiler-rt/test/sanitizer_common/TestCases/symbolize_pc.cpp

 // RUN: %clangxx -O0 %s -o %t
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/ %run %t 2>&1 | FileCheck %s
 //
 // Tests __sanitizer_symbolize_pc.
 #include <stdio.h>
 #include <sanitizer/common_interface_defs.h>
 
 int GLOBAL_VAR_ABC;
 
 void SymbolizeSmallBuffer() {
   char data[] = "abcdef";
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", data, 0);
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", data, 0);
   printf("UNCHANGED '%s'\n", data);
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", data, 1);
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", data, 1);
   printf("EMPTY '%s'\n", data);
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", data,
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", data,
                            sizeof(data));
   printf("PARTIAL '%s'\n", data);
 }
 
 void SymbolizeCaller() {
   char data[100];
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", data,
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", data,
                            sizeof(data));
   printf("FIRST_FORMAT %s\n", data);
-  __sanitizer_symbolize_pc(__builtin_return_address(0),
+  __sanitizer_symbolize_pc(__sanitizer_return_address(),
                            "FUNC:%f LINE:%l FILE:%s", data, sizeof(data));
   printf("SECOND_FORMAT %s\n", data);
-  __sanitizer_symbolize_pc(__builtin_return_address(0),
+  __sanitizer_symbolize_pc(__sanitizer_return_address(),
                            "LOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
                            "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
                            "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
                            "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
                            "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONG"
-                          "FUNC:%f LINE:%l FILE:%s", data, sizeof(data));
+                           "FUNC:%f LINE:%l FILE:%s",
+                           data, sizeof(data));
   printf("LONG_FORMAT %s\n", data);
 }
 
+struct s {
+  int i;
+};
+
+struct s SymbolizeSRet() {
+  char data[100];
+  __sanitizer_symbolize_pc(__sanitizer_return_address(),
+                           "FUNC:%f LINE:%l FILE:%s", data, sizeof(data));
+  printf("SRET: %s\n", data);
+  struct s s = {1};
+  return s;
+}
+
 void SymbolizeData() {
   char data[100];
   __sanitizer_symbolize_global(&GLOBAL_VAR_ABC, "%g %s:%l", data, sizeof(data));
   printf("GLOBAL: %s\n", data);
 }
 
 int main() {
   // CHECK: UNCHANGED 'abcdef'
   // CHECK: EMPTY ''
   // CHECK: PARTIAL '0x{{.*}}'
   SymbolizeSmallBuffer();
 
   // CHECK: FIRST_FORMAT 0x{{.*}} in main symbolize_pc.cpp:[[@LINE+2]]
   // CHECK: SECOND_FORMAT FUNC:main LINE:[[@LINE+1]] FILE:symbolize_pc.cpp
   SymbolizeCaller();
 
+  struct s s;
+  // CHECK: SRET: FUNC:main LINE:[[@LINE+1]] FILE:symbolize_pc.cpp
+  s = SymbolizeSRet();
+
   // CHECK: GLOBAL: GLOBAL_VAR_ABC
   SymbolizeData();
 }

compiler-rt/test/sanitizer_common/TestCases/symbolize_pc_demangle.cpp

 // RUN: %clangxx -O1 -fno-omit-frame-pointer %s -o %t
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/ %run %t 2>&1 | FileCheck %s
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/:demangle=0 %run %t 2>&1 | FileCheck %s --check-prefixes=NODEMANGLE
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/:demangle=1 %run %t 2>&1 | FileCheck %s
 
 // XFAIL: darwin
 
 #include <sanitizer/common_interface_defs.h>
 #include <stdio.h>
 #include <string.h>
 
 char buffer[10000];
 
 __attribute__((noinline)) static void Symbolize() {
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", buffer,
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", buffer,
                            sizeof(buffer));
   for (char *p = buffer; strlen(p); p += strlen(p) + 1)
     printf("%s\n", p);
 }
 
 struct Symbolizer {
   __attribute__((noinline)) ~Symbolizer() { Symbolize(); }
 };
 
 // NODEMANGLE: in _ZN10SymbolizerD2Ev
 // CHECK: in Symbolizer::~Symbolizer
 int main() {
   Symbolizer();
   return 0;
 }

compiler-rt/test/sanitizer_common/TestCases/symbolize_pc_inline.cpp

 // RUN: %clangxx -O3  %s -o %t
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/ %run %t 2>&1 | FileCheck %s
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/:symbolize_inline_frames=0 %run %t 2>&1 | FileCheck %s --check-prefixes=NOINLINE
 // RUN: %env_tool_opts=strip_path_prefix=/TestCases/:symbolize_inline_frames=1 %run %t 2>&1 | FileCheck %s
 
 // XFAIL: darwin
 
 #include <sanitizer/common_interface_defs.h>
 #include <stdio.h>
 #include <string.h>
 
 char buffer[10000];
 
 __attribute__((noinline)) static void Symbolize() {
-  __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", buffer,
+  __sanitizer_symbolize_pc(__sanitizer_return_address(), "%p %F %L", buffer,
                            sizeof(buffer));
   for (char *p = buffer; strlen(p); p += strlen(p) + 1)
     printf("%s\n", p);
 }
 
 // NOINLINE: {{0x[0-9a-f]+}} in main symbolize_pc_inline.cpp:[[@LINE+2]]
 // CHECK: [[ADDR:0x[0-9a-f]+]] in C2 symbolize_pc_inline.cpp:[[@LINE+1]]
 static inline void C2() { Symbolize(); }