Fix false-positive ASAN detection with the stack profiler on win64

base/profiler/native_stack_sampler_win.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/profiler/native_stack_sampler.h"
 
 #include <objbase.h>
 #include <windows.h>
 #include <stddef.h>
 #include <winternl.h>
@@ skipping 301 matching lines @@
 // IMPORTANT NOTE: No allocations from the default heap may occur in the
 // ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
 // other logging statements. Otherwise this code can deadlock on heap locks in
 // the default heap acquired by the target thread before it was suspended.
 void SuspendThreadAndRecordStack(
     HANDLE thread_handle,
     const void* base_address,
     void* stack_copy_buffer,
     size_t stack_copy_buffer_size,
     std::vector<RecordedFrame>* stack,
-    NativeStackSamplerTestDelegate* test_delegate) {
+    NativeStackSamplerTestDelegate* test_delegate) NO_SANITIZE("address") {
   DCHECK(stack->empty());
 
   CONTEXT thread_context = {0};
   thread_context.ContextFlags = CONTEXT_FULL;
   // The stack bounds are saved to uintptr_ts for use outside
   // ScopedSuspendThread, as the thread's memory is not safe to dereference
   // beyond that point.
   const uintptr_t top = reinterpret_cast<uintptr_t>(base_address);
   uintptr_t bottom = 0u;
 
@@ skipping 13 matching lines @@
 
     if ((top - bottom) > stack_copy_buffer_size)
       return;
 
     // Dereferencing a pointer in the guard page in a thread that doesn't own
     // the stack results in a STATUS_GUARD_PAGE_VIOLATION exception and a crash.
     // This occurs very rarely, but reliably over the population.
     if (PointsToGuardPage(bottom))
       return;
 
-    std::memcpy(stack_copy_buffer, reinterpret_cast<const void*>(bottom),

[Mark Mentovai, 2016/11/15 16:52:04]

Can we keep this if !defined(ADDRESS_SANITIZER)? Standard libraries often
optimize memcpy in ways that compilers don’t for simple byte-at-a-time loops.

[etienneb, 2016/11/15 16:55:41]

I'm not against it. Typically we try to avoid ifdef and duplicate code.
But, It's true that compilers may optimize memcpy and the stack profiler may be
CPU sensitive.

-                top - bottom);
+    // The following loop is an inlined version of memcpy. The code must be
+    // inlined to avoid instrumentation when using ASAN (memory sanitizer). The
+    // stack profiler is generating false positive when walking the stack.
+    for (size_t pos = 0; pos < top - bottom; ++pos)
+      reinterpret_cast<char*>(stack_copy_buffer)[pos] =
+          reinterpret_cast<const char*>(bottom)[pos];
   }
 
   if (test_delegate)
     test_delegate->OnPreStackWalk();
 
   RewritePointersToStackMemory(top, bottom, &thread_context, stack_copy_buffer);
 
   RecordStack(&thread_context, stack);
 }
 
@@ skipping 10 matching lines @@
       std::vector<StackSamplingProfiler::Module>* modules) override;
   void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
   void ProfileRecordingStopped() override;
 
  private:
   enum {
     // Intended to hold the largest stack used by Chrome. The default Win32
     // reserved stack size is 1 MB and Chrome Windows threads currently always
     // use the default, but this allows for expansion if it occurs. The size
     // beyond the actual stack size consists of unallocated virtual memory pages
-    // so carries little cost (just a bit of wated address space).
+    // so carries little cost (just a bit of wasted address space).
     kStackCopyBufferSize = 2 * 1024 * 1024
   };
 
   // Attempts to query the module filename, base address, and id for
   // |module_handle|, and store them in |module|. Returns true if it succeeded.
   static bool GetModuleForHandle(HMODULE module_handle,
                                  StackSamplingProfiler::Module* module);
 
   // Gets the index for the Module corresponding to |module_handle| in
   // |modules|, adding it if it's not already present. Returns
@@ skipping 133 matching lines @@
 
   if (thread_handle) {
     return std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
         win::ScopedHandle(thread_handle), test_delegate));
   }
 #endif
   return std::unique_ptr<NativeStackSampler>();
 }
 
 }  // namespace base