[NFC] Introduce a `LateInitialize()` method to `SymbolizerTool` that is called during the LateInitialize stage of the sanitizer runtimes.

[delcypher]

Summary

This is implemented by adding a Symbolizer::LateInitializeTools()
method that iterates over the registered tools and calls the
LateInitialize() method on them.

Symbolizer::LateInitializeTools() is now called from the various
Symbolizer::LateInitialize() implementations.

The default implementation of SymbolizerTool::LateInitialize()
does nothing so this change should be NFC.

This change allows SymbolizerTool implementations to perform
any initialization that they need to perform at the
LateInitialize stage of a sanitizer runtime init.

rdar://problem/58789439

[delcypher]

• Update radar number

[delcypher]

• Symbolizer::LateInitializeTools() should be private.

[delcypher]

Tweak comments.

[delcypher]

@vitalybuka Thanks for the review.

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h

private:
   EndSymbolizationHook end_hook_;
   class SymbolizerScope {
    public:
     explicit SymbolizerScope(const Symbolizer *sym);
     ~SymbolizerScope();
    private:
     const Symbolizer *sym_;
   };
+
+  // Calls `LateInitialize()` on all items in `tools_`.
+  void LateInitializeTools();
 };
 
 #ifdef SANITIZER_WINDOWS
 void InitializeDbgHelpIfNeeded();
 #endif
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_H

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp

if (sym_->start_hook_)
     sym_->start_hook_();
 }
 
 Symbolizer::SymbolizerScope::~SymbolizerScope() {
   if (sym_->end_hook_)
     sym_->end_hook_();
 }
 
+void Symbolizer::LateInitializeTools() {
+  for (auto &tool : tools_) {
+    tool.LateInitialize();
+  }
+}
+
 }  // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h

public:
   }
 
   virtual void Flush() {}
 
   // Return nullptr to fallback to the default platform-specific demangler.
   virtual const char *Demangle(const char *name) {
     return nullptr;
   }
+
+  // Called during the LateInitialize phase of Sanitizer initialization.
+  // Usually this is a safe place to call code that might need to use user
+  // memory allocators.
+  virtual void LateInitialize() {}
 };
 
 // SymbolizerProcess encapsulates communication between the tool and
 // external symbolizer program, running in a different subprocess.
 // SymbolizerProcess may not be used from two threads simultaneously.
 class SymbolizerProcess {
  public:
   explicit SymbolizerProcess(const char *path, bool use_posix_spawn = false);

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp

void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
                  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(); }
+void Symbolizer::LateInitialize() {
+  Symbolizer::GetOrInit()->LateInitializeTools();
+}
 
 void StartReportDeadlySignal() {}
 void ReportDeadlySignal(const SignalContext &sig, u32 tid,
                         UnwindSignalStackCallbackType unwind,
                         const void *unwind_context) {}
 
 #if SANITIZER_CAN_SLOW_UNWIND
 struct UnwindTraceArg {

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

 Symbolizer *Symbolizer::PlatformInit() {
   IntrusiveList<SymbolizerTool> list;
   list.clear();
   ChooseSymbolizerTools(&list, &symbolizer_allocator_);
   return new(symbolizer_allocator_) Symbolizer(list);
 }
 
 void Symbolizer::LateInitialize() {
-  Symbolizer::GetOrInit();
+  Symbolizer::GetOrInit()->LateInitializeTools();
   InitializeSwiftDemangler();
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_POSIX

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp

Symbolizer *Symbolizer::PlatformInit() {
   IntrusiveList<SymbolizerTool> list;
   list.clear();
   ChooseSymbolizerTools(&list, &symbolizer_allocator_);
 
   return new(symbolizer_allocator_) Symbolizer(list);
 }
 
 void Symbolizer::LateInitialize() {
-  Symbolizer::GetOrInit();
+  Symbolizer::GetOrInit()->LateInitializeTools();
 }
 
 }  // namespace __sanitizer
 
 #endif  // _WIN32