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 74 matching lines @@
 void RewritePointerIfInOriginalStack(uintptr_t top, uintptr_t bottom,
                                      void* stack_copy, const void** pointer) {
   const uintptr_t value = reinterpret_cast<uintptr_t>(*pointer);
   if (value >= bottom && value < top) {
     *pointer = reinterpret_cast<const void*>(
         static_cast<unsigned char*>(stack_copy) + (value - bottom));
   }
 }
 #endif
 
+void CopyMemoryFromStack(void* to, const void* from, size_t length)
+    NO_SANITIZE("address") {
+#if defined(ADDRESS_SANITIZER)
+  // 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 < length; ++pos)
+    reinterpret_cast<char*>(to)[pos] = reinterpret_cast<const char*>(from)[pos];
+#else
+  std::memcpy(to, from, length);
+#endif
+}
+
 // Rewrites possible pointers to locations within the stack to point to the
 // corresponding locations in the copy, and rewrites the non-volatile registers
 // in |context| likewise. This is necessary to handle stack frames with dynamic
 // stack allocation, where a pointer to the beginning of the dynamic allocation
 // area is stored on the stack and/or in a non-volatile register.
 //
 // Eager rewriting of anything that looks like a pointer to the stack, as done
 // in this function, does not adversely affect the stack unwinding. The only
 // other values on the stack the unwinding depends on are return addresses,
 // which should not point within the stack memory. The rewriting is guaranteed
@@ skipping 241 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),
-                top - bottom);
+    base::CopyMemoryFromStack(

[Mike Wittman, 2016/11/17 19:32:50]

nit: no need for base::

[etienneb, 2016/11/17 19:35:03]

Done.

+        stack_copy_buffer, reinterpret_cast<const void*>(bottom), top - bottom);
   }
 
   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