[sanitizer] Allow BackgroundThread to not depend on StackDepot

[cryptoad]

Summary

Still pursuing the ultimate goal of splitting the Symbolizer code from
RTSanitizerCommon core, allow BackgroundThread to work even when not linked
with sanitizer_stackdepot.cc. There is no reason this function should pull in
the whole StackDepot if symbolization is not supported.

Currently this has no functional change as the depot is always linked anyway.

[cryptoad]

I had to change from a weak default implementation to a weak definition
otherwise Android would fail with:

==19013==AddressSanitizer: libc interceptors initialized
|| `[0xb27a8000, 0xbfffffff]` || HighMem    ||
|| `[0xb0c9d000, 0xb27a7fff]` || HighShadow ||
|| `[0xadc9d000, 0xb0c9cfff]` || ShadowGap  ||
|| `[0x9a7a8000, 0xadc9cfff]` || LowShadow  ||
|| `[0x00000000, 0x9a7a7fff]` || LowMem     ||
MemToShadow(shadow): 0xadc9d000 0xb033b9ff 0xb093ba00 0xb0c9cfff
redzone=16
max_redzone=2048
quarantine_size_mb=10M
thread_local_quarantine_size_kb=64K
malloc_context_size=30
SHADOW_SCALE: 3
SHADOW_GRANULARITY: 8
SHADOW_OFFSET: 0x9a7a8000
==19013==Installed the sigaction for signal 11
==19013==Installed the sigaction for signal 7
==19013==Installed the sigaction for signal 8
==19013==T0: stack [0xbf157000,0xbf957000) size 0x800000; local=0xbf953808
==19013==AddressSanitizer Init done
stack corruption detected (-fstack-protector)
Aborted

lib/sanitizer_common/sanitizer_common_libcdep.cc

 
 #include "sanitizer_common.h"
 
 #include "sanitizer_allocator_interface.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_report_decorator.h"
-#include "sanitizer_stackdepot.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"
 
 #if SANITIZER_POSIX
 #include "sanitizer_posix.h"
 #include <sys/mman.h>
 #endif
 

 
 static void (*SoftRssLimitExceededCallback)(bool exceeded);
 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) {
   CHECK_EQ(SoftRssLimitExceededCallback, nullptr);
   SoftRssLimitExceededCallback = Callback;
 }
 
 #if SANITIZER_LINUX && !SANITIZER_GO
+// Weak definition for when sanitizer_stackdepot is not linked in.
+SANITIZER_WEAK_ATTRIBUTE StackDepotStats *StackDepotGetStats();
+
 void BackgroundThread(void *arg) {
   uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb;
   uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb;
   bool heap_profile = common_flags()->heap_profile;
   uptr prev_reported_rss = 0;
   uptr prev_reported_stack_depot_size = 0;
   bool reached_soft_rss_limit = false;
   uptr rss_during_last_reported_profile = 0;
   while (true) {
     SleepForMillis(100);
     uptr current_rss_mb = GetRSS() >> 20;
     if (Verbosity()) {
       // If RSS has grown 10% since last time, print some information.
       if (prev_reported_rss * 11 / 10 < current_rss_mb) {
         Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
         prev_reported_rss = current_rss_mb;
       }
+      if (&StackDepotGetStats) {
         // If stack depot has grown 10% since last time, print it too.
         StackDepotStats *stack_depot_stats = StackDepotGetStats();
         if (prev_reported_stack_depot_size * 11 / 10 <
             stack_depot_stats->allocated) {
           Printf("%s: StackDepot: %zd ids; %zdM allocated\n",
                  SanitizerToolName,
                  stack_depot_stats->n_uniq_ids,
                  stack_depot_stats->allocated >> 20);
           prev_reported_stack_depot_size = stack_depot_stats->allocated;
         }
       }
+    }
     // Check RSS against the limit.
     if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) {
       Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n",
              SanitizerToolName, hard_rss_limit_mb, current_rss_mb);
       DumpProcessMap();
       Die();
     }
     if (soft_rss_limit_mb) {