[sanitizer_common] Fuchsia-specific symbolizer

[mcgrathr]

Summary

Fuchsia doesn't support built-in symbolization per se at all.
Instead, it always emits a Fuchsia-standard "symbolizer markup"
format that makes it possible for a post-processing filter to
massage the logs into symbolized format. Hence, it does not
support user-specified formatting options for backtraces or other
symbolization.

[vitalybuka]

lib/sanitizer_common/sanitizer_stacktrace_printer.cc

125

How about having implementation of RenderFrame and RenderData in sanitizer_symbolizer_fuchsia.cc?

#if !FUCHSIA
void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,

const AddressInfo &info, bool vs_style,
const char *strip_path_prefix, const char *strip_func_prefix) {

...

}

void RenderData(InternalScopedString *buffer, const char *format,
....
}
#endif

[mcgrathr]

RenderData and RenderFrame in sanitizer_symbolizer_fuchsia.cc

[vitalybuka]

lib/sanitizer_common/sanitizer_stacktrace_printer.cc

20

I don't think this comment is necessary

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

33

Regular array is shorter

const char kFormatDemangle[] =

48

Why not just override PlatformInit?

[mcgrathr]

lib/sanitizer_common/sanitizer_stacktrace_printer.cc

20

You really prefer few comments???

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

33

constexpr is correct for this use. The compiler should know that it's just a vanilla string constant and doesn't need to be an independent link-time object.

48

Because then GetOrInit would be the only thing from sanitizer_symbolizer_libcdep.cc actually used and it's cleaner to #if out the entire file.
I'd be happy to move the generic GetOrInit from sanitizer_symbolizer_libcdep.cc to sanitizer_symbolizer.cc if you prefer that.

[vitalybuka]

lib/sanitizer_common/sanitizer_stacktrace_printer.cc

20

Unless comment explains something obvious.

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

33

lgtm

48

I am OK to keep it as is

[alekseyshl]

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

48

Please do move GetOrInit to sanitizer_symbolizer.cc and implement PlatformInit and exclude sanitizer_symbolizer_libcdep.cc from Fuchsia build, that #if-ing the entire file is ugly.

[mcgrathr]

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

48

I've moved GetOrInit and implemented PlatformInit.

I didn't change to cmake conditionalization instead of #if around the whole file because that would be inconsistent with the rest of the source code, which uses #if around the whole file for other cases like this one.

[mcgrathr]

I've moved GetOrInit and implemented PlatformInit.

This is rebased and ready to land after D36031 lands.
Please land it for me!

Thanks,
Roland

[vitalybuka]

ninja check-sanitizer

fails Sanitizer-x86_64-Test-Nolibc test
llvm/projects/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cc:27: error: undefined reference to '__sanitizer::Symbolizer::PlatformInit()'

[mcgrathr]

Moved GetOrInit back to sanitizer_symbolizer_libcdep.cc, hoisted up out of #if !SANITIZER_FUCHSIA.

lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_SOURCES_NOTERMINATION
   sanitizer_procmaps_linux.cc
   sanitizer_procmaps_mac.cc
   sanitizer_stackdepot.cc
   sanitizer_stacktrace.cc
   sanitizer_stacktrace_printer.cc
   sanitizer_stoptheworld_mac.cc
   sanitizer_suppressions.cc
   sanitizer_symbolizer.cc
+  sanitizer_symbolizer_fuchsia.cc
   sanitizer_symbolizer_libbacktrace.cc
   sanitizer_symbolizer_mac.cc
   sanitizer_symbolizer_win.cc
   sanitizer_tls_get_addr.cc
   sanitizer_thread_registry.cc
   sanitizer_win.cc)
 
 if(UNIX AND NOT APPLE)

lib/sanitizer_common/sanitizer_stacktrace_printer.cc

 //===-- sanitizer_common.cc -----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between sanitizers' run-time libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_file.h"
+#include "sanitizer_fuchsia.h"
 
 namespace __sanitizer {
 
+// sanitizer_symbolizer_fuchsia.cc implements these differently for Fuchsia.
+#if !SANITIZER_FUCHSIA
+
 static const char *StripFunctionName(const char *function, const char *prefix) {
   if (!function) return nullptr;
   if (!prefix) return function;
   uptr prefix_len = internal_strlen(prefix);
   if (0 == internal_strncmp(function, prefix, prefix_len))
     return function + prefix_len;
   return function;
 }
for (const char *p = format; *p != '\0'; p++) {
     default:
       Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
              *p);
       Die();
     }
   }
 }
 
 void RenderData(InternalScopedString *buffer, const char *format,
                 const DataInfo *DI, const char *strip_path_prefix) {
   for (const char *p = format; *p != '\0'; p++) {
     if (*p != '%') {
       buffer->append("%c", *p);
       continue;
     }
     p++;
     switch (*p) {
switch (*p) {
       default:
         Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
                *p);
         Die();
     }
   }
 }
 
+#endif  // !SANITIZER_FUCHSIA
+
 void RenderSourceLocation(InternalScopedString *buffer, const char *file,
                           int line, int column, bool vs_style,
                           const char *strip_path_prefix) {
   if (vs_style && line > 0) {
     buffer->append("%s(%d", StripPathPrefix(file, strip_path_prefix), line);
     if (column > 0)
       buffer->append(",%d", column);
     buffer->append(")");

lib/sanitizer_common/sanitizer_symbolizer.cc

 #include "sanitizer_platform.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_symbolizer_internal.h"
 
 namespace __sanitizer {
 
+Symbolizer *Symbolizer::GetOrInit() {
+  SpinMutexLock l(&init_mu_);
+  if (symbolizer_)
+    return symbolizer_;
+  symbolizer_ = PlatformInit();
+  CHECK(symbolizer_);
+  return symbolizer_;
+}
+
 AddressInfo::AddressInfo() {
   internal_memset(this, 0, sizeof(AddressInfo));
   function_offset = kUnknown;
 }
 
 void AddressInfo::Clear() {
   InternalFree(module);
   InternalFree(function);

lib/sanitizer_common/sanitizer_symbolizer_fuchsia.cc

+//===-- sanitizer_symbolizer_fuchsia.cc -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Implementation of Fuchsia-specific symbolizer.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_FUCHSIA
+
+#include "sanitizer_fuchsia.h"
+#include "sanitizer_symbolizer.h"
+
+namespace __sanitizer {
+
+// For Fuchsia we don't do any actual symbolization per se.
+// Instead, we emit text containing raw addresses and raw linkage
+// symbol names, embedded in Fuchsia's symbolization markup format.
+// Fuchsia's logging infrastructure emits enough information about
+// process memory layout that a post-processing filter can do the
+// symbolization and pretty-print the markup.
+// TODO(mcgrathr): URL to markup format document
+
+// This is used by UBSan for type names, and by ASan for global variable names.
+constexpr const char *kFormatDemangle = "{{{symbol:%s}}}";
+constexpr uptr kFormatDemangleMax = 1024;  // Arbitrary.
+
+// Function name or equivalent from PC location.
+constexpr const char *kFormatFunction = "{{{pc:%p}}}";
+constexpr uptr kFormatFunctionMax = 64; // More than big enough for 64-bit hex.
+
+// Global variable name or equivalent from data memory address.
+constexpr const char *kFormatData = "{{{data:%p}}}";
+
+// One frame in a backtrace (printed on a line by itself).
+constexpr const char *kFormatFrame = "{{{bt:%u:%p}}}";
+
+// This is used by UBSan for type names, and by ASan for global variable names.
+// It's expected to return a static buffer that will be reused on each call.
+const char *Symbolizer::Demangle(const char *name) {
+  static char buffer[kFormatDemangleMax];
+  internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
+  return buffer;
+}
+
+// This is used mostly for suppression matching.  Making it work
+// would enable "interceptor_via_lib" suppressions.  It's also used
+// once in UBSan to say "in module ..." in a message that also
+// includes an address in the module, so post-processing can already
+// pretty-print that so as to indicate the module.
+bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
+                                             uptr *module_address) {
+  return false;
+}
+
+// This is used in some places for suppression checking, which we
+// don't really support for Fuchsia.  It's also used in UBSan to
+// identify a PC location to a function name, so we always fill in
+// the function member with a string containing markup around the PC
+// value.
+// TODO(mcgrathr): Under SANITIZER_GO, it's currently used by TSan
+// to render stack frames, but that should be changed to use
+// RenderStackFrame.
+SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
+  SymbolizedStack *s = SymbolizedStack::New(addr);
+  char buffer[kFormatFunctionMax];
+  internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
+  s->info.function = internal_strdup(buffer);
+  return s;
+}
+
+// Always claim we succeeded, so that RenderDataInfo will be called.
+bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  info->Clear();
+  info->start = addr;
+  return true;
+}
+
+// We ignore the format argument to __sanitizer_symbolize_global.
+void RenderData(InternalScopedString *buffer, const char *format,
+                const DataInfo *DI, const char *strip_path_prefix) {
+  buffer->append(kFormatData, DI->start);
+}
+
+// We don't support the stack_trace_format flag at all.
+void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
+                 const AddressInfo &info, bool vs_style,
+                 const char *strip_path_prefix, const char *strip_func_prefix) {
+  buffer->append(kFormatFrame, frame_no, info.address);
+}
+
+Symbolizer *Symbolizer::PlatformInit() {
+  return new(symbolizer_allocator_) Symbolizer({});
+}
+
+void Symbolizer::LateInitialize() {
+  Symbolizer::GetOrInit();
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FUCHSIA

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

 //===-- sanitizer_symbolizer_libcdep.cc -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
+#include "sanitizer_platform.h"
+#if !SANITIZER_FUCHSIA
+
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_symbolizer_internal.h"
 
 namespace __sanitizer {
 
 const char *ExtractToken(const char *str, const char *delims, char **result) {
   uptr prefix_len = internal_strcspn(str, delims);
if (!modules_were_reloaded) {
     // It's too aggressive to reload the list of modules each time we fail
     // to find a module for a given address.
     modules_fresh_ = false;
     return FindModuleForAddress(address);
   }
   return 0;
 }
 
-Symbolizer *Symbolizer::GetOrInit() {
-  SpinMutexLock l(&init_mu_);
-  if (symbolizer_)
-    return symbolizer_;
-  symbolizer_ = PlatformInit();
-  CHECK(symbolizer_);
-  return symbolizer_;
-}
-
 // For now we assume the following protocol:
 // For each request of the form
 //   <module_name> <module_offset>
 // passed to STDIN, external symbolizer prints to STDOUT response:
 //   <function_name>
 //   <file_name>:<line_number>:<column_number>
 //   <function_name>
 //   <file_name>:<line_number>:<column_number>
bool SymbolizerProcess::WriteToSymbolizer(const char *buffer, uptr length) {
   if (!success || write_len != length) {
     Report("WARNING: Can't write to symbolizer at fd %d\n", output_fd_);
     return false;
   }
   return true;
 }
 
 }  // namespace __sanitizer
+
+#endif // !SANITIZER_FUCHSIA