[sanitizer] Remove empty Symbolizer PrepareForSandboxing

[cryptoad]

Summary

Symbolizer::PrepareForSandboxing is empty for all platforms and apparently
has been for a while (D10213). Remove it, and shuffle things around so that the
platform specific code is now in PlatformPrepareForSandboxing.

This allows to have one less symbolizer dependency in a common file, which
helps for the upcoming split.

Also remove SymbolizerPrepareForSandboxing in tsan_go which appears to not
be used anywhere.

[mcgrathr]

lgtm but I'm not authoritative.

[cryptoad]

Directly call PlatformPrepareForSandboxing from
__sanitizer_sandbox_on_notify instead of using an intermediate static
PrepareForSandboxing.

[cryptoad]

Anyone else but Roland for some comments/LGTM please?

lib/sanitizer_common/sanitizer_common.h

 char **GetArgv();
 void PrintCmdline();
 bool StackSizeIsUnlimited();
 uptr GetStackSizeLimitInBytes();
 void SetStackSizeLimitInBytes(uptr limit);
 bool AddressSpaceIsUnlimited();
 void SetAddressSpaceUnlimited();
 void AdjustStackSize(void *attr);
-void PrepareForSandboxing(__sanitizer_sandbox_arguments *args);
+void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args);
 void SetSandboxingCallback(void (*f)());
 
 void InitializeCoverage(bool enabled, const char *coverage_dir);
 
 void InitTlsSize();
 uptr GetTlsSize();
 
 // Other

lib/sanitizer_common/sanitizer_common_libcdep.cc

bool ColorizeReports() {
   if (SANITIZER_WINDOWS)
     return false;
 
   const char *flag = common_flags()->color;
   return internal_strcmp(flag, "always") == 0 ||
          (internal_strcmp(flag, "auto") == 0 && ReportSupportsColors());
 }
 
-static void (*sandboxing_callback)();
-void SetSandboxingCallback(void (*f)()) {
-  sandboxing_callback = f;
-}
-
 void ReportErrorSummary(const char *error_type, const StackTrace *stack,
                         const char *alt_tool_name) {
 #if !SANITIZER_GO
   if (!common_flags()->print_summary)
     return;
   if (stack->size == 0) {
     ReportErrorSummary(error_type);
     return;
ScopedErrorReportLock::~ScopedErrorReportLock() {
   CommonSanitizerReportMutex.Unlock();
   atomic_store_relaxed(&reporting_thread, 0);
 }
 
 void ScopedErrorReportLock::CheckLocked() {
   CommonSanitizerReportMutex.CheckLocked();
 }
 
+static void (*sandboxing_callback)();
+void SetSandboxingCallback(void (*f)()) {
+  sandboxing_callback = f;
+}
+
 }  // namespace __sanitizer
 
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify,
                              __sanitizer_sandbox_arguments *args) {
-  __sanitizer::PrepareForSandboxing(args);
+  __sanitizer::PlatformPrepareForSandboxing(args);
   if (__sanitizer::sandboxing_callback)
     __sanitizer::sandboxing_callback();
 }

lib/sanitizer_common/sanitizer_fuchsia.cc

void GetThreadStackTopAndBottom(bool, uptr *stack_top, uptr *stack_bottom) {
   CHECK_EQ(pthread_attr_getstack(&attr, &base, &size), 0);
   CHECK_EQ(pthread_attr_destroy(&attr), 0);
 
   *stack_bottom = reinterpret_cast<uptr>(base);
   *stack_top = *stack_bottom + size;
 }
 
 void MaybeReexec() {}
-void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {}
+void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {}
 void DisableCoreDumperIfNecessary() {}
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {}
 void StartReportDeadlySignal() {}
 void ReportDeadlySignal(const SignalContext &sig, u32 tid,
                         UnwindSignalStackCallbackType unwind,
                         const void *unwind_context) {}
 void SetAlternateSignalStack() {}
 void UnsetAlternateSignalStack() {}

lib/sanitizer_common/sanitizer_posix_libcdep.cc

 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_platform_limits_openbsd.h"
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_platform_limits_solaris.h"
 #include "sanitizer_posix.h"
 #include "sanitizer_procmaps.h"
-#include "sanitizer_stacktrace.h"
-#include "sanitizer_symbolizer.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   } else {
     result = (bytes_written == size);
   }
   internal_close(sock_pair[0]);
   internal_close(sock_pair[1]);
   return result;
 }
 
-void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
+void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
   // Some kinds of sandboxes may forbid filesystem access, so we won't be able
   // to read the file mappings from /proc/self/maps. Luckily, neither the
   // process will be able to load additional libraries, so it's fine to use the
   // cached mappings.
   MemoryMappingLayout::CacheMemoryMappings();
-  // Same for /proc/self/exe in the symbolizer.
-#if !SANITIZER_GO
-  Symbolizer::GetOrInit()->PrepareForSandboxing();
-#endif
 }
 
 #if SANITIZER_ANDROID || SANITIZER_GO
 int GetNamedMappingFd(const char *name, uptr size) {
   return -1;
 }
 #else
 int GetNamedMappingFd(const char *name, uptr size) {

lib/sanitizer_common/sanitizer_symbolizer.h

if (GetModuleNameAndOffsetForPC(pc, &module_name, &unused))
       return module_name;
     return nullptr;
   }
 
   // Release internal caches (if any).
   void Flush();
   // Attempts to demangle the provided C++ mangled name.
   const char *Demangle(const char *name);
-  void PrepareForSandboxing();
 
   // Allow user to install hooks that would be called before/after Symbolizer
   // does the actual file/line info fetching. Specific sanitizers may need this
   // to distinguish system library calls made in user code from calls made
   // during in-process symbolization.
   typedef void (*StartSymbolizationHook)();
   typedef void (*EndSymbolizationHook)();
   // May be called at most once.
bool FindModuleNameAndOffsetForAddress(uptr address, const char **module_name,
                                          ModuleArch *module_arch);
   ListOfModules modules_;
   ListOfModules fallback_modules_;
   // If stale, need to reload the modules before looking up addresses.
   bool modules_fresh_;
 
   // Platform-specific default demangler, must not return nullptr.
   const char *PlatformDemangle(const char *name);
-  void PlatformPrepareForSandboxing();
 
   static Symbolizer *symbolizer_;
   static StaticSpinMutex init_mu_;
 
   // Mutex locked from public methods of |Symbolizer|, so that the internals
   // (including individual symbolizer tools and platform-specific methods) are
   // always synchronized.
   BlockingMutex mu_;

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

const char *Symbolizer::Demangle(const char *name) {
   for (auto &tool : tools_) {
     SymbolizerScope sym_scope(this);
     if (const char *demangled = tool.Demangle(name))
       return demangled;
   }
   return PlatformDemangle(name);
 }
 
-void Symbolizer::PrepareForSandboxing() {
-  BlockingMutexLock l(&mu_);
-  PlatformPrepareForSandboxing();
-}
-
 bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
                                                    const char **module_name,
                                                    uptr *module_offset,
                                                    ModuleArch *module_arch) {
   const LoadedModule *module = FindModuleForAddress(address);
   if (module == nullptr)
     return false;
   *module_name = module->full_name();

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

 };
 
 #endif  // SANITIZER_SUPPORTS_WEAK_HOOKS
 
 const char *Symbolizer::PlatformDemangle(const char *name) {
   return DemangleSwiftAndCXX(name);
 }
 
-void Symbolizer::PlatformPrepareForSandboxing() {}
-
 static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
   const char *path = common_flags()->external_symbolizer_path;
   const char *binary_name = path ? StripModuleName(path) : "";
   if (path && path[0] == '\0') {
     VReport(2, "External symbolizer is explicitly disabled.\n");
     return nullptr;
   } else if (!internal_strcmp(binary_name, "llvm-symbolizer")) {
     VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path);

lib/sanitizer_common/sanitizer_symbolizer_win.cc

const char *WinSymbolizerTool::Demangle(const char *name) {
   else
     return name;
 }
 
 const char *Symbolizer::PlatformDemangle(const char *name) {
   return name;
 }
 
-void Symbolizer::PlatformPrepareForSandboxing() {
-  // Do nothing.
-}
-
 namespace {
 struct ScopedHandle {
   ScopedHandle() : h_(nullptr) {}
   explicit ScopedHandle(HANDLE h) : h_(h) {}
   ~ScopedHandle() {
     if (h_)
       ::CloseHandle(h_);
   }

lib/sanitizer_common/sanitizer_win.cc

 void DisableCoreDumperIfNecessary() {
   // Do nothing.
 }
 
 void ReExec() {
   UNIMPLEMENTED();
 }
 
-void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
-}
+void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {}
 
 bool StackSizeIsUnlimited() {
   UNIMPLEMENTED();
 }
 
 void SetStackSizeLimitInBytes(uptr limit) {
   UNIMPLEMENTED();
 }

lib/tsan/go/tsan_go.cc

 
 void __tsan_report_count(u64 *pn) {
   Lock lock(&ctx->report_mtx);
   *pn = ctx->nreported;
 }
 
 }  // extern "C"
 }  // namespace __tsan
-
-namespace __sanitizer {
-
-void SymbolizerPrepareForSandboxing() {
-  // Nothing to do here for Go.
-}
-
-}  // namespace __sanitizer