Fix MSAN error on arm64 bot.

src/frames.cc

 // Copyright 2012 the V8 project 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 "src/frames.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/ast/scopeinfo.h"
@@ skipping 286 matching lines @@
       SingletonFor(frame->GetCallerState(&state)) != NULL;
 }
 
 
 bool SafeStackFrameIterator::IsValidExitFrame(Address fp) const {
   if (!IsValidStackAddress(fp)) return false;
   Address sp = ExitFrame::ComputeStackPointer(fp);
   if (!IsValidStackAddress(sp)) return false;
   StackFrame::State state;
   ExitFrame::FillState(fp, sp, &state);
-  return *state.pc_address != NULL;
+  MSAN_MEMORY_IS_INITIALIZED(state.pc_address, sizeof(state.pc_address));
+  return *state.pc_address != nullptr;
 }
 
 
 void SafeStackFrameIterator::Advance() {
   while (true) {
     AdvanceOneFrame();
     if (done()) break;
     ExternalCallbackScope* last_callback_scope = NULL;
     while (external_callback_scope_ != NULL &&
            external_callback_scope_->scope_address() < frame_->fp()) {
@@ skipping 89 matching lines @@
          (pc >= interpreter_bytecode_dispatch->instruction_start() &&
           pc < interpreter_bytecode_dispatch->instruction_end()) ||
          (pc >= interpreter_baseline_on_return->instruction_start() &&
           pc < interpreter_baseline_on_return->instruction_end());
 }
 
 StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
                                          State* state) {
   DCHECK(state->fp != NULL);
 
-#if defined(USE_SIMULATOR)
   MSAN_MEMORY_IS_INITIALIZED(
       state->fp + CommonFrameConstants::kContextOrFrameTypeOffset,
       kPointerSize);
-#endif
   Object* marker = Memory::Object_at(
       state->fp + CommonFrameConstants::kContextOrFrameTypeOffset);
   if (!iterator->can_access_heap_objects_) {
     // TODO(titzer): "can_access_heap_objects" is kind of bogus. It really
     // means that we are being called from the profiler, which can interrupt
     // the VM with a signal at any arbitrary instruction, with essentially
     // anything on the stack. So basically none of these checks are 100%
     // reliable.
-#if defined(USE_SIMULATOR)
     MSAN_MEMORY_IS_INITIALIZED(
         state->fp + StandardFrameConstants::kFunctionOffset, kPointerSize);
-#endif
     Object* maybe_function =
         Memory::Object_at(state->fp + StandardFrameConstants::kFunctionOffset);
     if (!marker->IsSmi()) {
       if (maybe_function->IsSmi()) {
         return NONE;
       } else if (FLAG_ignition && IsInterpreterFramePc(iterator->isolate(),
                                                        *(state->pc_address))) {
         return INTERPRETED;
       } else {
         return JAVA_SCRIPT;
@@ skipping 156 matching lines @@
 
 StackFrame::Type ExitFrame::GetStateForFramePointer(Address fp, State* state) {
   if (fp == 0) return NONE;
   Address sp = ComputeStackPointer(fp);
   FillState(fp, sp, state);
   DCHECK(*state->pc_address != NULL);
   return EXIT;
 }
 
 Address ExitFrame::ComputeStackPointer(Address fp) {
-#if defined(USE_SIMULATOR)
   MSAN_MEMORY_IS_INITIALIZED(fp + ExitFrameConstants::kSPOffset, kPointerSize);
-#endif
   return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
 }
 
 void ExitFrame::FillState(Address fp, Address sp, State* state) {
   state->sp = sp;
   state->fp = fp;
   state->pc_address = ResolveReturnAddressLocation(
       reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
   // The constant pool recorded in the exit frame is not associated
   // with the pc in this state (the return address into a C entry
@@ skipping 1173 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8