Make all tests pass ASAN.

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/native_symbol.h"
@@ skipping 1657 matching lines @@
 #if defined(TARGET_OS_WINDOWS)
     // If the fp is at the beginning of a page, it may be unsafe to access
     // the pc marker, because we are reading it from a different thread on
     // Windows. The marker is below fp and the previous page may be a guard
     // page.
     const intptr_t kPageMask = VirtualMemory::PageSize() - 1;
     if ((sample->fp() & kPageMask) == 0) {
       return;
     }
 #endif
-    const uword pc_marker = *(fp + kPcMarkerSlotFromFp);
-    sample->set_pc_marker(pc_marker);
+    uword* pc_marker_ptr = fp + kPcMarkerSlotFromFp;
+    // MSan/ASan are unaware of frames initialized by generated code.
+    MSAN_UNPOISON(pc_marker_ptr, kWordSize);
+    ASAN_UNPOISON(pc_marker_ptr, kWordSize);
+    sample->set_pc_marker(*pc_marker_ptr);
   }
 }
 
 
 // Given an exit frame, walk the Dart stack.
 class ProfilerDartExitStackWalker : public ValueObject {
  public:
   ProfilerDartExitStackWalker(Isolate* isolate, Sample* sample)
       : sample_(sample),
         frame_iterator_(isolate) {
@@ skipping 229 matching lines @@
       }
 
       // Move the lower bound up.
       lower_bound_ = reinterpret_cast<uword>(fp);
     }
   }
 
  private:
   uword* CallerPC(uword* fp) const {
     ASSERT(fp != NULL);
-    return reinterpret_cast<uword*>(*(fp + kSavedCallerPcSlotFromFp));
+    uword* caller_pc_ptr = fp + kSavedCallerPcSlotFromFp;
+    // This may actually be uninitialized, by design (see class comment above).
+    MSAN_UNPOISON(caller_pc_ptr, kWordSize);
+    ASAN_UNPOISON(caller_pc_ptr, kWordSize);
+    return reinterpret_cast<uword*>(*caller_pc_ptr);
   }
 
   uword* CallerFP(uword* fp) const {
     ASSERT(fp != NULL);
     uword* caller_fp_ptr = fp + kSavedCallerFpSlotFromFp;
     // This may actually be uninitialized, by design (see class comment above).
     MSAN_UNPOISON(caller_fp_ptr, kWordSize);
+    ASAN_UNPOISON(caller_fp_ptr, kWordSize);
     return reinterpret_cast<uword*>(*caller_fp_ptr);
   }
 
   bool ValidFramePointer(uword* fp) const {
     if (fp == NULL) {
       return false;
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     bool r = (cursor >= lower_bound_) && (cursor < stack_upper_);
@@ skipping 56 matching lines @@
 
   if (StubCode::InJumpToExceptionHandlerStub(state.pc)) {
     // The JumpToExceptionHandler stub manually adjusts the stack pointer,
     // frame pointer, and some isolate state before jumping to a catch entry.
     // It is not safe to walk the stack when executing this stub.
     return;
   }
 
   uword stack_lower = 0;
   uword stack_upper = 0;
-  isolate->GetProfilerStackBounds(&stack_lower, &stack_upper);
-  if ((stack_lower == 0) || (stack_upper == 0)) {
+  if (!isolate->GetProfilerStackBounds(&stack_lower, &stack_upper) ||
+      (stack_lower == 0) || (stack_upper == 0)) {
     // Could not get stack boundary.
     return;
   }
 
   if (sp > stack_lower) {
     // The stack pointer gives us a tighter lower bound.
     stack_lower = sp;
   }
 
   if (stack_lower >= stack_upper) {
@@ skipping 85 matching lines @@
                                             state.pc,
                                             state.fp,
                                             sp);
       stackWalker.walk();
 #endif
     }
   }
 }
 
 }  // namespace dart