Make rewind work on DBC

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, 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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 1086 matching lines @@
     HANDLE_EXCEPTION;                                                          \
   }
 
 #define INVOKE_NATIVE_WRAPPER(Func, Args)                                      \
   if (!InvokeNativeWrapper(thread, this, Func, &Args)) {                       \
     HANDLE_EXCEPTION;                                                          \
   }
 
 #define LOAD_CONSTANT(index) (pp->data()[(index)].raw_obj_)
 
+DART_FORCE_INLINE bool Simulator::Deoptimize(Thread* thread,

[Cutch, 2017/03/07 00:22:29]

Maybe add a comment that says "Returns false if the call
DRT_DeoptimizeMaterialize fails"

[turnidge, 2017/03/08 19:24:08]

Done.

+                                             RawObjectPool** pp,
+                                             uint32_t** pc,
+                                             RawObject*** FP,
+                                             RawObject*** SP,
+                                             bool is_lazy) {
+  // Note: frame translation will take care of preserving result at the
+  // top of the stack. See CompilerDeoptInfo::CreateDeoptInfo.
+
+  // Make sure we preserve SP[0] when entering synthetic frame below.
+  (*SP)++;
+
+  // Leaf runtime function DeoptimizeCopyFrame expects a Dart frame.
+  // The code in this frame may not cause GC.
+  // DeoptimizeCopyFrame and DeoptimizeFillFrame are leaf runtime calls.
+  EnterSyntheticFrame(FP, SP, *pc - (is_lazy ? 1 : 0));
+  const intptr_t frame_size_in_bytes =
+      DLRT_DeoptimizeCopyFrame(reinterpret_cast<uword>(*FP), is_lazy ? 1 : 0);
+  LeaveSyntheticFrame(FP, SP);
+
+  *SP = *FP + (frame_size_in_bytes / kWordSize);
+  EnterSyntheticFrame(FP, SP, *pc - (is_lazy ? 1 : 0));
+  DLRT_DeoptimizeFillFrame(reinterpret_cast<uword>(*FP));
+
+  // We are now inside a valid frame.
+  {
+    *++(*SP) = 0;  // Space for the result: number of materialization args.
+    Exit(thread, *FP, *SP + 1, /*pc=*/0);
+    NativeArguments native_args(thread, 0, *SP, *SP);
+    if (!InvokeRuntime(thread, this, DRT_DeoptimizeMaterialize, native_args)) {
+      return false;
+    }
+  }
+  const intptr_t materialization_arg_count =
+      Smi::Value(RAW_CAST(Smi, *(*SP)--)) / kWordSize;
+
+  // Restore caller PC.
+  *pc = SavedCallerPC(*FP);
+  pc_ = reinterpret_cast<uword>(*pc);  // For the profiler.
+
+  // Check if it is a fake PC marking the entry frame.
+  ASSERT((reinterpret_cast<uword>(*pc) & 2) == 0);
+
+  // Restore SP, FP and PP.
+  // Unoptimized frame SP is one below FrameArguments(...) because
+  // FrameArguments(...) returns a pointer to the first argument.
+  *SP = FrameArguments(*FP, materialization_arg_count) - 1;
+  *FP = SavedCallerFP(*FP);
+
+  // Restore pp.
+  *pp = SimulatorHelpers::FrameCode(*FP)->ptr()->object_pool_->ptr();
+
+  return true;
+}
+
+
 RawObject* Simulator::Call(const Code& code,
                            const Array& arguments_descriptor,
                            const Array& arguments,
                            Thread* thread) {
   // Dispatch used to interpret bytecode. Contains addresses of
   // labels of bytecode handlers. Handlers themselves are defined below.
   static const void* dispatch[] = {
 #define TARGET(name, fmt, fmta, fmtb, fmtc) &&bc##name,
       BYTECODES_LIST(TARGET)
 #undef TARGET
@@ skipping 2449 matching lines @@
     BYTECODE(LoadIndexedTwoByteString, A_B_C);
     RawTwoByteString* array = RAW_CAST(TwoByteString, FP[rB]);
     RawSmi* index = RAW_CAST(Smi, FP[rC]);
     ASSERT(SimulatorHelpers::CheckIndex(index, array->ptr()->length_));
     FP[rA] = Smi::New(array->ptr()->data()[Smi::Value(index)]);
     DISPATCH();
   }
 
   {
     BYTECODE(Deopt, A_D);
-
-    // Note: frame translation will take care of preserving result at the
-    // top of the stack. See CompilerDeoptInfo::CreateDeoptInfo.
     const bool is_lazy = rD == 0;
-
-    // Make sure we preserve SP[0] when entering synthetic frame below.
-    SP++;
-
-    // Leaf runtime function DeoptimizeCopyFrame expects a Dart frame.
-    // The code in this frame may not cause GC.
-    // DeoptimizeCopyFrame and DeoptimizeFillFrame are leaf runtime calls.
-    EnterSyntheticFrame(&FP, &SP, pc - (is_lazy ? 1 : 0));
-    const intptr_t frame_size_in_bytes =
-        DLRT_DeoptimizeCopyFrame(reinterpret_cast<uword>(FP), is_lazy ? 1 : 0);
-    LeaveSyntheticFrame(&FP, &SP);
-
-    SP = FP + (frame_size_in_bytes / kWordSize);
-    EnterSyntheticFrame(&FP, &SP, pc - (is_lazy ? 1 : 0));
-    DLRT_DeoptimizeFillFrame(reinterpret_cast<uword>(FP));
-
-    // We are now inside a valid frame.
-    {
-      *++SP = 0;  // Space for the result: number of materialization args.
-      Exit(thread, FP, SP + 1, /*pc=*/0);
-      NativeArguments native_args(thread, 0, SP, SP);
-      INVOKE_RUNTIME(DRT_DeoptimizeMaterialize, native_args);
+    if (!Deoptimize(thread, &pp, &pc, &FP, &SP, is_lazy)) {
+      HANDLE_EXCEPTION;
     }
-    const intptr_t materialization_arg_count =
-        Smi::Value(RAW_CAST(Smi, *SP--)) / kWordSize;
-
-    // Restore caller PC.
-    pc = SavedCallerPC(FP);
-    pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
-
-    // Check if it is a fake PC marking the entry frame.
-    ASSERT((reinterpret_cast<uword>(pc) & 2) == 0);
-
-    // Restore SP, FP and PP.
-    // Unoptimized frame SP is one below FrameArguments(...) because
-    // FrameArguments(...) returns a pointer to the first argument.
-    SP = FrameArguments(FP, materialization_arg_count) - 1;
-    FP = SavedCallerFP(FP);
-    pp = SimulatorHelpers::FrameCode(FP)->ptr()->object_pool_->ptr();
-
     DISPATCH();
   }
 
+  {
+    BYTECODE(DeoptRewind, 0);
+    pc = reinterpret_cast<uint32_t*>(thread->resume_pc());
+    if (!Deoptimize(thread, &pp, &pc, &FP, &SP, false /* eager */)) {
+      HANDLE_EXCEPTION;
+    }
+    {
+      Exit(thread, FP, SP + 1, pc);
+      NativeArguments args(thread, 0, NULL, NULL);
+      INVOKE_RUNTIME(DRT_RewindPostDeopt, args);
+    }
+    UNREACHABLE();  // DRT_RewindPostDeopt does not exit normally.
+    DISPATCH();
+  }
+
   {
     BYTECODE(Nop, 0);
     DISPATCH();
   }
 
   {
     BYTECODE(Trap, 0);
     UNIMPLEMENTED();
     DISPATCH();
   }
@@ skipping 59 matching lines @@
     DISPATCH();
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
 void Simulator::JumpToFrame(uword pc, uword sp, uword fp, Thread* thread) {
   // Walk over all setjmp buffers (simulated --> C++ transitions)
-  // and try to find the setjmp associated with the simulated stack pointer.
+  // and try to find the setjmp associated with the simulated frame pointer.
   SimulatorSetjmpBuffer* buf = last_setjmp_buffer();
   while ((buf->link() != NULL) && (buf->link()->fp() > fp)) {
     buf = buf->link();
   }
   ASSERT(buf != NULL);
   ASSERT(last_setjmp_buffer() == buf);
 
   // The C++ caller has not cleaned up the stack memory of C++ frames.
   // Prepare for unwinding frames by destroying all the stack resources
   // in the previous C++ frames.
   StackResource::Unwind(thread);
 
   // Set the tag.
   thread->set_vm_tag(VMTag::kDartTagId);
   // Clear top exit frame.
   thread->set_top_exit_frame_info(0);
 
   fp_ = reinterpret_cast<RawObject**>(fp);
 
   if (pc == StubCode::RunExceptionHandler_entry()->EntryPoint()) {
     // The RunExceptionHandler stub is a placeholder.  We implement
     // its behavior here.
     RawObject* raw_exception = thread->active_exception();
     RawObject* raw_stacktrace = thread->active_stacktrace();
     ASSERT(raw_exception != Object::null());
     special_[kExceptionSpecialIndex] = raw_exception;
     special_[kStackTraceSpecialIndex] = raw_stacktrace;
     pc_ = thread->resume_pc();
-  } else if (pc == StubCode::DeoptForRewind_entry()->EntryPoint()) {
-    // The DeoptForRewind stub is a placeholder.  We will eventually
-    // implement its behavior here.
-    //
-    // TODO(turnidge): Refactor the Deopt bytecode so that we can use
-    // the implementation here too.  The deopt pc is stored in
-    // Thread::resume_pc().  After invoking deoptimization, we usually
-    // call into Debugger::RewindPostDeopt(), but I need to figure out
-    // if that makes any sense (it would JumpToFrame during a
-    // JumpToFrame, which seems wrong).
-    UNIMPLEMENTED();
   } else {
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC