[sanitizer] Add common "demangle" flag

[browneee]

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp

286–287

Consider adding
CHECK(i <= kArgVMax);

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

222–223

Consider adding
CHECK(i <= kArgVMax);

Still fits, but getting close.

[vitalybuka]

fix internal symbolizer

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

222–223

Added checks here 9fe0d67c9a72488a8d51bdbff52916a91bc06914 as it's not related to the patch.

Ouch! I didn't realize that this so small.
Increased constant here: a7ebf2010ebb76c32f59b95ecd7a403c382add92

compiler-rt/lib/sanitizer_common/sanitizer_common_interface_posix.inc

 //===-- sanitizer_common_interface_posix.inc ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // Sanitizer Common interface list only available for Posix systems.
 //===----------------------------------------------------------------------===//
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_code)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_data)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_demangle)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_flush)
+INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_set_demangle)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_set_inline_frames)

compiler-rt/lib/sanitizer_common/sanitizer_flags.inc

COMMON_FLAG(
     "Disable core dumping. By default, disable_coredump=1 on 64-bit to avoid"
     " dumping a 16T+ core file. Ignored on OSes that don't dump core by"
     " default and for sanitizers that don't reserve lots of virtual memory.")
 COMMON_FLAG(bool, use_madv_dontdump, true,
           "If set, instructs kernel to not store the (huge) shadow "
           "in core file.")
 COMMON_FLAG(bool, symbolize_inline_frames, true,
             "Print inlined frames in stacktraces. Defaults to true.")
+COMMON_FLAG(bool, demangle, true, "Print demangled symbols.")
 COMMON_FLAG(bool, symbolize_vs_style, false,
             "Print file locations in Visual Studio style (e.g: "
             " file(10,42): ...")
 COMMON_FLAG(int, dedup_token_length, 0,
             "If positive, after printing a stack trace also print a short "
             "string token based on this number of frames that will simplify "
             "deduplication of the reports. "
             "Example: 'DEDUP_TOKEN: foo-bar-main'. Default is 0.")

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp

 #elif defined(__s390x__)
     const char* const kSymbolizerArch = "--default-arch=s390x";
 #elif defined(__s390__)
     const char* const kSymbolizerArch = "--default-arch=s390";
 #else
     const char* const kSymbolizerArch = "--default-arch=unknown";
 #endif
 
+    const char *const demangle_flag =
+        common_flags()->demangle ? "--demangle" : "--no-demangle";
     const char *const inline_flag =
         common_flags()->symbolize_inline_frames ? "--inlines" : "--no-inlines";
     int i = 0;
     argv[i++] = path_to_binary;
+    argv[i++] = demangle_flag;
     argv[i++] = inline_flag;
     argv[i++] = kSymbolizerArch;
     argv[i++] = nullptr;
     CHECK_LE(i, kArgVMax);
   }
 };
 
 LLVMSymbolizer::LLVMSymbolizer(const char *path, LowLevelAllocator *allocator)
     : symbolizer_process_(new(*allocator) LLVMSymbolizerProcess(path)) {}
 
 // Parse a <file>:<line>[:<column>] buffer. The file path may contain colons on
 // Windows, so extract tokens from the right hand side first. The column info is

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

public:
 
   const char *module_name() const { return module_name_; }
 
  private:
   void GetArgV(const char *path_to_binary,
                const char *(&argv)[kArgVMax]) const override {
     int i = 0;
     argv[i++] = path_to_binary;
+    if (common_flags()->demangle)
+      argv[i++] = "-C";
     if (common_flags()->symbolize_inline_frames)
       argv[i++] = "-i";
-    argv[i++] = "-Cfe";
+    argv[i++] = "-fe";
     argv[i++] = module_name_;
     argv[i++] = nullptr;
     CHECK_LE(i, kArgVMax);
   }
 
   bool ReachedEndOfOutput(const char *buffer, uptr length) const override;
 
   bool ReadFromSymbolizer(char *buffer, uptr max_length) override {
     if (!SymbolizerProcess::ReadFromSymbolizer(buffer, max_length))
       return false;
     // The returned buffer is empty when output is valid, but exceeds

 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_data(const char *ModuleName, u64 ModuleOffset,
                            char *Buffer, int MaxLength);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_symbolize_flush();
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE int
 __sanitizer_symbolize_demangle(const char *Name, char *Buffer, int MaxLength);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
+__sanitizer_symbolize_set_demangle(bool Demangle);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_set_inline_frames(bool InlineFrames);
 }  // extern "C"
 
 class InternalSymbolizer final : public SymbolizerTool {
  public:
   static InternalSymbolizer *get(LowLevelAllocator *alloc) {
+    if (__sanitizer_symbolize_set_demangle)
+      CHECK(__sanitizer_symbolize_set_demangle(common_flags()->demangle));
     if (__sanitizer_symbolize_set_inline_frames)
       CHECK(__sanitizer_symbolize_set_inline_frames(
           common_flags()->symbolize_inline_frames));
     if (__sanitizer_symbolize_code && __sanitizer_symbolize_data)
       return new (*alloc) InternalSymbolizer();
     return 0;
   }
 

compiler-rt/lib/sanitizer_common/symbolizer/sanitizer_symbolize.cpp

 #include <stdio.h>
 
 #include <string>
 
 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 
 static llvm::symbolize::LLVMSymbolizer *Symbolizer = nullptr;
+static bool Demangle = true;
 static bool InlineFrames = true;
 
 static llvm::symbolize::LLVMSymbolizer *getDefaultSymbolizer() {
   if (Symbolizer)
     return Symbolizer;
   llvm::symbolize::LLVMSymbolizer::Options Opts;
+  Opts.Demangle = Demangle;
   Symbolizer = new llvm::symbolize::LLVMSymbolizer(Opts);
   return Symbolizer;
 }
 
 static llvm::symbolize::PrinterConfig getDefaultPrinterConfig() {
   llvm::symbolize::PrinterConfig Config;
   Config.Pretty = false;
   Config.Verbose = false;
int __sanitizer_symbolize_demangle(const char *Name, char *Buffer,
   std::string Result =
       llvm::symbolize::LLVMSymbolizer::DemangleName(Name, nullptr);
   return __sanitizer::internal_snprintf(Buffer, MaxLength, "%s",
                                         Result.c_str()) < MaxLength
              ? static_cast<int>(Result.size() + 1)
              : 0;
 }
 
+bool __sanitizer_symbolize_set_demangle(bool Value) {
+  // Must be called before LLVMSymbolizer created.
+  if (Symbolizer)
+    return false;
+  Demangle = Value;
+  return true;
+}
+
 bool __sanitizer_symbolize_set_inline_frames(bool Value) {
   InlineFrames = Value;
   return true;
 }
 
 // Override __cxa_atexit and ignore callbacks.
 // This prevents crashes in a configuration when the symbolizer
 // is built into sanitizer runtime and consequently into the test process.

compiler-rt/lib/sanitizer_common/symbolizer/scripts/build_symbolizer.sh

 SYMBOLIZER_FLAGS="$LLVM_FLAGS -I${LLVM_SRC}/include -I${LLVM_BUILD}/include -std=c++14"
 $CXX $SYMBOLIZER_FLAGS ${SRC_DIR}/sanitizer_symbolize.cpp ${SRC_DIR}/sanitizer_wrappers.cpp -c
 $AR rc symbolizer.a sanitizer_symbolize.o sanitizer_wrappers.o
 
 SYMBOLIZER_API_LIST=__sanitizer_symbolize_code
 SYMBOLIZER_API_LIST+=,__sanitizer_symbolize_data
 SYMBOLIZER_API_LIST+=,__sanitizer_symbolize_flush
 SYMBOLIZER_API_LIST+=,__sanitizer_symbolize_demangle
+SYMBOLIZER_API_LIST+=,__sanitizer_symbolize_set_demangle
 SYMBOLIZER_API_LIST+=,__sanitizer_symbolize_set_inline_frames
 
 LIBCXX_ARCHIVE_DIR=$(dirname $(find $LIBCXX_BUILD -name libc++.a | head -n1))
 
 # Merge all the object files together and copy the resulting library back.
 $SCRIPT_DIR/ar_to_bc.sh $LIBCXX_ARCHIVE_DIR/libc++.a \
                         $LIBCXX_ARCHIVE_DIR/libc++abi.a \
                         $LLVM_BUILD/lib/libLLVMSymbolize.a \

compiler-rt/lib/sanitizer_common/symbolizer/scripts/global_symbols.txt

 __isinf U
 __isoc99_sscanf U
 __isoc99_vsscanf U
 __moddi3 U
 __sanitizer_symbolize_code T
 __sanitizer_symbolize_data T
 __sanitizer_symbolize_demangle T
 __sanitizer_symbolize_flush T
+__sanitizer_symbolize_set_demangle T
 __sanitizer_symbolize_set_inline_frames T
 __strdup U
 __udivdi3 U
 __umoddi3 U
 _exit U
 abort U
 access U
 bcmp U

compiler-rt/lib/sanitizer_common/weak_symbols.txt

 ___sanitizer_free_hook
 ___sanitizer_malloc_hook
 ___sanitizer_report_error_summary
 ___sanitizer_sandbox_on_notify
 ___sanitizer_symbolize_code
 ___sanitizer_symbolize_data
 ___sanitizer_symbolize_demangle
 ___sanitizer_symbolize_flush
+___sanitizer_symbolize_set_demangle
 ___sanitizer_symbolize_set_inline_frames

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,
+                           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;
+}