[sanitizer] Move internal_symbolizer "inline" option

[vitalybuka]

Summary

This option is per process anyway. I'd like to add more options, but
having them as parameters of __sanitizer_symbolize_code looks
inconvenient.

[browneee]

Test case that exercises __sanitizer_symbolize_set_inline_frames?

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

116

Demangle should be InlineFrames ?

[vitalybuka]

update

[vitalybuka]

fix internal symbolizer

[browneee]

LGTM but would like a test case added.

[vitalybuka]

In D116201#3208282, @browneee wrote:

LGTM but would like a test case added.

The flag is already covered by compiler-rt/test/sanitizer_common/TestCases/symbolize_pc_inline.cpp The patch is almost NFC, it just changes how we pass the flag into internal symbolizer. Almost, because we change sanitizer_common_interface_posix.
We don't run/build for any tests by default.
https://lab.llvm.org/buildbot/#/builders/37/builds/9407 "test standalone compiler-rt with symbolizer" runs all tests with internal symbolizer, including symbolize_pc_inline.cpp. It should be able to catch "Demangle" issue you spotted.

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_inline_frames)

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

private:
   static const uptr dummy_address_ =
       FIRST_32_SECOND_64(UINT32_MAX, UINT64_MAX);
 };
 
 #  if SANITIZER_SUPPORTS_WEAK_HOOKS
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_code(const char *ModuleName, u64 ModuleOffset,
-                           char *Buffer, int MaxLength,
-                           bool SymbolizeInlineFrames);
+                           char *Buffer, int MaxLength);
 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_inline_frames(bool InlineFrames);
 }  // extern "C"
 
 class InternalSymbolizer final : public SymbolizerTool {
  public:
   static InternalSymbolizer *get(LowLevelAllocator *alloc) {
+    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;
   }
 
   bool SymbolizePC(uptr addr, SymbolizedStack *stack) override {
     bool result = __sanitizer_symbolize_code(
-        stack->info.module, stack->info.module_offset, buffer_, kBufferSize,
-        common_flags()->symbolize_inline_frames);
+        stack->info.module, stack->info.module_offset, buffer_, kBufferSize);
     if (result)
       ParseSymbolizePCOutput(buffer_, stack);
     return result;
   }
 
   bool SymbolizeData(uptr addr, DataInfo *info) override {
     bool result = __sanitizer_symbolize_data(info->module, info->module_offset,
                                              buffer_, kBufferSize);

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 InlineFrames = true;
+
 static llvm::symbolize::LLVMSymbolizer *getDefaultSymbolizer() {
-  static llvm::symbolize::LLVMSymbolizer *DefaultSymbolizer =
-      new llvm::symbolize::LLVMSymbolizer();
-  return DefaultSymbolizer;
+  if (Symbolizer)
+    return Symbolizer;
+  llvm::symbolize::LLVMSymbolizer::Options Opts;
+  Symbolizer = new llvm::symbolize::LLVMSymbolizer(Opts);
+  return Symbolizer;
 }
 
 static llvm::symbolize::PrinterConfig getDefaultPrinterConfig() {
   llvm::symbolize::PrinterConfig Config;
   Config.Pretty = false;
   Config.Verbose = false;
   Config.PrintFunctions = true;
   Config.PrintAddress = false;
   Config.SourceContextLines = 0;
   return Config;
 }
 
 namespace __sanitizer {
 int internal_snprintf(char *buffer, unsigned long length, const char *format,
                       ...);
 }  // namespace __sanitizer
 
 extern "C" {
 
 typedef uint64_t u64;
 
 bool __sanitizer_symbolize_code(const char *ModuleName, uint64_t ModuleOffset,
-                                char *Buffer, int MaxLength,
-                                bool SymbolizeInlineFrames) {
+                                char *Buffer, int MaxLength) {
   std::string Result;
   {
     llvm::raw_string_ostream OS(Result);
     llvm::symbolize::PrinterConfig Config = getDefaultPrinterConfig();
     llvm::symbolize::Request Request{ModuleName, ModuleOffset};
     auto Printer =
         std::make_unique<llvm::symbolize::LLVMPrinter>(OS, OS, Config);
 
     // TODO: it is neccessary to set proper SectionIndex here.
     // object::SectionedAddress::UndefSection works for only absolute addresses.
-    if (SymbolizeInlineFrames) {
+    if (InlineFrames) {
       auto ResOrErr = getDefaultSymbolizer()->symbolizeInlinedCode(
           ModuleName,
           {ModuleOffset, llvm::object::SectionedAddress::UndefSection});
       Printer->print(Request,
                      ResOrErr ? ResOrErr.get() : llvm::DIInliningInfo());
     } else {
       auto ResOrErr = getDefaultSymbolizer()->symbolizeCode(
           ModuleName,
auto ResOrErr = getDefaultSymbolizer()->symbolizeData(
         ModuleName,
         {ModuleOffset, llvm::object::SectionedAddress::UndefSection});
     Printer->print(Request, ResOrErr ? ResOrErr.get() : llvm::DIGlobal());
   }
   return __sanitizer::internal_snprintf(Buffer, MaxLength, "%s",
                                         Result.c_str()) < MaxLength;
 }
 
-void __sanitizer_symbolize_flush() { getDefaultSymbolizer()->flush(); }
+void __sanitizer_symbolize_flush() {
+  if (Symbolizer)
+    Symbolizer->flush();
+}
 
 int __sanitizer_symbolize_demangle(const char *Name, char *Buffer,
                                    int MaxLength) {
   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_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.
 // LLVM libraries have some global objects destroyed during exit,
 // so if the test process triggers any bugs after that, the symbolizer crashes.
 // An example stack trace of such crash:
 //
 // #1  __cxa_throw

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_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 \
                         $LLVM_BUILD/lib/libLLVMObject.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_inline_frames T
 __strdup U
 __udivdi3 U
 __umoddi3 U
 _exit U
 abort U
 access U
 bcmp U
 calloc 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_inline_frames