hwasan: Remove dead code. NFCI.

[merge_guards_bot]

Unit tests: pass. 61933 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[eugenis]

LGTM, thank you!

compiler-rt/lib/hwasan/hwasan.h

 }
 
 namespace __hwasan {
 
 extern int hwasan_inited;
 extern bool hwasan_init_is_running;
 extern int hwasan_report_count;
 
-bool ProtectRange(uptr beg, uptr end);
 bool InitShadow();
 void InitPrctl();
 void InitThreads();
 void MadviseShadow();
-char *GetProcSelfMaps();
 void InitializeInterceptors();
 
 void HwasanAllocatorInit();
-void HwasanAllocatorThreadFinish();
 
 void *hwasan_malloc(uptr size, StackTrace *stack);
 void *hwasan_calloc(uptr nmemb, uptr size, StackTrace *stack);
 void *hwasan_realloc(void *ptr, uptr size, StackTrace *stack);
 void *hwasan_reallocarray(void *ptr, uptr nmemb, uptr size, StackTrace *stack);
 void *hwasan_valloc(uptr size, StackTrace *stack);
 void *hwasan_pvalloc(uptr size, StackTrace *stack);
 void *hwasan_aligned_alloc(uptr alignment, uptr size, StackTrace *stack);
 void *hwasan_memalign(uptr alignment, uptr size, StackTrace *stack);
 int hwasan_posix_memalign(void **memptr, uptr alignment, uptr size,
                         StackTrace *stack);
 void hwasan_free(void *ptr, StackTrace *stack);
 
-void InstallTrapHandler();
 void InstallAtExitHandler();
 
-void EnterSymbolizer();
-void ExitSymbolizer();
-bool IsInSymbolizer();
-
-struct SymbolizerScope {
-  SymbolizerScope() { EnterSymbolizer(); }
-  ~SymbolizerScope() { ExitSymbolizer(); }
-};
-
-// Returns a "chained" origin id, pointing to the given stack trace followed by
-// the previous origin id.
-u32 ChainOrigin(u32 id, StackTrace *stack);
-
-const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
-
 #define GET_MALLOC_STACK_TRACE                                            \
   BufferedStackTrace stack;                                               \
   if (hwasan_inited)                                                      \
     stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),         \
                  nullptr, common_flags()->fast_unwind_on_malloc,          \
                  common_flags()->malloc_context_size)
 
 #define GET_FATAL_STACK_TRACE_PC_BP(pc, bp)              \
   BufferedStackTrace stack;                              \
   if (hwasan_inited)                                     \
     stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal)
 
 #define GET_FATAL_STACK_TRACE_HERE \
   GET_FATAL_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
 
 #define PRINT_CURRENT_STACK_CHECK() \
   {                                 \
     GET_FATAL_STACK_TRACE_HERE;     \
     stack.Print();                  \
   }
 
-class ScopedThreadLocalStateBackup {
- public:
-  ScopedThreadLocalStateBackup() { Backup(); }
-  ~ScopedThreadLocalStateBackup() { Restore(); }
-  void Backup();
-  void Restore();
- private:
-  u64 va_arg_overflow_size_tls;
-};
-
 void HwasanTSDInit();
 void HwasanTSDThreadInit();
 
 void HwasanOnDeadlySignal(int signo, void *info, void *context);
 
 void UpdateMemoryUsage();
 
 void AppendToErrorMessageBuffer(const char *buffer);

compiler-rt/lib/hwasan/hwasan.cpp

 #include "ubsan/ubsan_init.h"
 
 // ACHTUNG! No system header includes in this file.
 
 using namespace __sanitizer;
 
 namespace __hwasan {
 
-void EnterSymbolizer() {
-  Thread *t = GetCurrentThread();
-  CHECK(t);
-  t->EnterSymbolizer();
-}
-void ExitSymbolizer() {
-  Thread *t = GetCurrentThread();
-  CHECK(t);
-  t->LeaveSymbolizer();
-}
-bool IsInSymbolizer() {
-  Thread *t = GetCurrentThread();
-  return t && t->InSymbolizer();
-}
-
 static Flags hwasan_flags;
 
 Flags *flags() {
   return &hwasan_flags;
 }
 
 int hwasan_inited = 0;
 int hwasan_instrumentation_inited = 0;

 void __sanitizer::BufferedStackTrace::UnwindImpl(
     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
   Thread *t = GetCurrentThread();
   if (!t) {
     // the thread is still being created.
     size = 0;
     return;
   }
-  if (!StackTrace::WillUseFastUnwind(request_fast)) {
-    // Block reports from our interceptors during _Unwind_Backtrace.
-    SymbolizerScope sym_scope;
-    return Unwind(max_depth, pc, bp, context, 0, 0, request_fast);
-  }
-  if (StackTrace::WillUseFastUnwind(request_fast))
-    Unwind(max_depth, pc, bp, nullptr, t->stack_top(), t->stack_bottom(), true);
-  else
-    Unwind(max_depth, pc, 0, context, 0, 0, false);
+  Unwind(max_depth, pc, bp, context, t->stack_top(), t->stack_bottom(),
+         request_fast);
 }
 
 struct hwasan_global {
   s32 gv_relptr;
   u32 info;
 };
 
 static void InitGlobals(const hwasan_global *begin, const hwasan_global *end) {
void __hwasan_init() {
   SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
   // This may call libc -> needs initialized shadow.
   AndroidLogInit();
 
   InitializeInterceptors();
   InstallDeadlySignalHandlers(HwasanOnDeadlySignal);
   InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
 
-  Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
-
   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 
   HwasanTSDInit();
   HwasanTSDThreadInit();
 
   HwasanAllocatorInit();
 
 #if HWASAN_CONTAINS_UBSAN

compiler-rt/lib/hwasan/hwasan_thread.h

public:
   uptr tls_begin() { return tls_begin_; }
   uptr tls_end() { return tls_end_; }
   bool IsMainThread() { return unique_id_ == 0; }
 
   bool AddrIsInStack(uptr addr) {
     return addr >= stack_bottom_ && addr < stack_top_;
   }
 
-  bool InSignalHandler() { return in_signal_handler_; }
-  void EnterSignalHandler() { in_signal_handler_++; }
-  void LeaveSignalHandler() { in_signal_handler_--; }
-
-  bool InSymbolizer() { return in_symbolizer_; }
-  void EnterSymbolizer() { in_symbolizer_++; }
-  void LeaveSymbolizer() { in_symbolizer_--; }
-
   AllocatorCache *allocator_cache() { return &allocator_cache_; }
   HeapAllocationsRingBuffer *heap_allocations() { return heap_allocations_; }
   StackAllocationsRingBuffer *stack_allocations() { return stack_allocations_; }
 
   tag_t GenerateRandomTag();
 
   void DisableTagging() { tagging_disabled_++; }
   void EnableTagging() { tagging_disabled_--; }
-  bool TaggingIsDisabled() const { return tagging_disabled_; }
 
   u64 unique_id() const { return unique_id_; }
   void Announce() {
     if (announced_) return;
     announced_ = true;
     Print("Thread: ");
   }
 
   uptr &vfork_spill() { return vfork_spill_; }
 
  private:
   // NOTE: There is no Thread constructor. It is allocated
   // via mmap() and *must* be valid in zero-initialized state.
   void ClearShadowForThreadStackAndTLS();
   void Print(const char *prefix);
   uptr vfork_spill_;
   uptr stack_top_;
   uptr stack_bottom_;
   uptr tls_begin_;
   uptr tls_end_;
 
-  unsigned in_signal_handler_;
-  unsigned in_symbolizer_;
-
   u32 random_state_;
   u32 random_buffer_;
 
   AllocatorCache allocator_cache_;
   HeapAllocationsRingBuffer *heap_allocations_;
   StackAllocationsRingBuffer *stack_allocations_;
 
-  static void InsertIntoThreadList(Thread *t);
-  static void RemoveFromThreadList(Thread *t);
   Thread *next_;  // All live threads form a linked list.
 
   u64 unique_id_;  // counting from zero.
 
   u32 tagging_disabled_;  // if non-zero, malloc uses zero tag in this thread.
 
   bool announced_;