[asan, myriad] Reset shadow memory during exit

[waltl]

Summary

Reset shadow memory during exit. Also update a cut-and-paste comment,
and do some minor refactoring of InitializeShadowMemory.

[waltl]

Only reset if needed.

compiler-rt/trunk/lib/asan/asan_rtems.cc

 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 
 #include <pthread.h>
 #include <stdlib.h>
 
 namespace __asan {
 
-void InitializeShadowMemory() {
-  kHighMemEnd = 0;
-  kMidMemBeg =  0;
-  kMidMemEnd =  0;
-
+static void ResetShadowMemory() {
   uptr shadow_start = SHADOW_OFFSET;
   uptr shadow_end = MEM_TO_SHADOW(kMyriadMemoryEnd32);
-  uptr shadow_size = shadow_end - shadow_start;
   uptr gap_start = MEM_TO_SHADOW(shadow_start);
   uptr gap_end = MEM_TO_SHADOW(shadow_end);
 
-  REAL(memset)((void *)shadow_start, 0, shadow_size);
+  REAL(memset)((void *)shadow_start, 0, shadow_end - shadow_start);
   REAL(memset)((void *)gap_start, kAsanShadowGap, gap_end - gap_start);
 }
 
+void InitializeShadowMemory() {
+  kHighMemEnd = 0;
+  kMidMemBeg =  0;
+  kMidMemEnd =  0;
+
+  ResetShadowMemory();
+}
+
 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
   UNIMPLEMENTED();
 }
 
 void AsanCheckDynamicRTPrereqs() {}
 void AsanCheckIncompatibleRT() {}
 void InitializeAsanInterceptors() {}
 void InitializePlatformInterceptors() {}
 void InitializePlatformExceptionHandlers() {}
 
 // RTEMS only support static linking; it sufficies to return with no
 // error.
 void *AsanDoesNotSupportStaticLinkage() { return nullptr; }
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   UNIMPLEMENTED();
 }
 
 void EarlyInit() {
   // Provide early initialization of shadow memory so that
   // instrumented code running before full initialzation will not
   // report spurious errors.
-  InitializeShadowMemory();
+  ResetShadowMemory();
 }
 
 // Main thread information.  Initialized in CreateMainThread() and
 // used by ThreadStartHook().
 static uptr MainThreadSelf;
 static AsanThread *MainThread;
 
 // We can use a plain thread_local variable for TSD.
static AsanThread *CreateAsanThread(StackTrace *stack, u32 parent_tid,
   // range beforehand, so we can do most of the setup right now.
   const AsanThread::InitOptions options = {stack_bottom, stack_size,
                                            tls_bottom, tls_size};
   thread->Init(&options);
   return thread;
 }
 
 // This gets the same arguments passed to Init by CreateAsanThread, above.
-// We're in the creator thread before the new thread is actually started,
-// but its stack address range is already known.  We don't bother tracking
-// the static TLS address range because the system itself already uses an
-// ASan-aware allocator for that.
+// We're in the creator thread before the new thread is actually started, but
+// its stack and tls address range are already known.
 void AsanThread::SetThreadStackAndTls(const AsanThread::InitOptions *options) {
   DCHECK_NE(GetCurrentThread(), this);
   DCHECK_NE(GetCurrentThread(), nullptr);
   CHECK_NE(options->stack_bottom, 0);
   CHECK_NE(options->stack_size, 0);
   stack_bottom_ = options->stack_bottom;
   stack_top_ = options->stack_bottom + options->stack_size;
   tls_begin_ = options->tls_bottom;
static void ThreadExitHook(void *hook, uptr os_id) {
   if (thread)
     AsanThread::TSDDtor(thread->context());
 }
 
 static void HandleExit() {
   // Disable ASan by setting it to uninitialized.  Also reset the
   // shadow memory to avoid reporting errors after the run-time has
   // been desroyed.
+  if (asan_inited) {
     asan_inited = false;
-  //  InitializeShadowMemory();
+    ResetShadowMemory();
+  }
 }
 
 }  // namespace __asan
 
 // These are declared (in extern "C") by <some_path/sanitizer.h>.
 // The system runtime will call our definitions directly.
 
 extern "C" {