[sanitizer] Backup errno calling symbolizer

[vitalybuka]

Summary

ScopedThread::Impl::HandleEvent checks that errno is unchanged.
As is it's reproducible only with internal symbolizer, but I see
no disadvantages in doing that for all symbolizers.

[vitalybuka]

rebase

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h

private:
   StartSymbolizationHook start_hook_;
   EndSymbolizationHook end_hook_;
   class SymbolizerScope {
    public:
     explicit SymbolizerScope(const Symbolizer *sym);
     ~SymbolizerScope();
    private:
     const Symbolizer *sym_;
+    int errno_;  // Backup errno in case symbolizer change the value.
   };
 };
 
 #ifdef SANITIZER_WINDOWS
 void InitializeDbgHelpIfNeeded();
 #endif
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_H

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp

 //===-- sanitizer_symbolizer.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
+#include <errno.h>
+
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform.h"
 #include "sanitizer_symbolizer_internal.h"
 
const char *Symbolizer::ModuleNameOwner::GetOwnedCopy(const char *str) {
   return last_match_;
 }
 
 Symbolizer::Symbolizer(IntrusiveList<SymbolizerTool> tools)
     : module_names_(&mu_), modules_(), modules_fresh_(false), tools_(tools),
       start_hook_(0), end_hook_(0) {}
 
 Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
-    : sym_(sym) {
+    : sym_(sym), errno_(errno) {
   if (sym_->start_hook_)
     sym_->start_hook_();
 }
 
 Symbolizer::SymbolizerScope::~SymbolizerScope() {
   if (sym_->end_hook_)
     sym_->end_hook_();
+  errno = errno_;
 }
 
 }  // namespace __sanitizer