VM: [DBC] Remove sp_ field from the DBC simulator

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 43 matching lines @@
   void Longjmp() {
     // "This" is now the last setjmp buffer.
     simulator_->set_last_setjmp_buffer(this);
     longjmp(buffer_, 1);
   }
 
   explicit SimulatorSetjmpBuffer(Simulator* sim) {
     simulator_ = sim;
     link_ = sim->last_setjmp_buffer();
     sim->set_last_setjmp_buffer(this);
-    sp_ = sim->sp_;
     fp_ = sim->fp_;
   }
 
   ~SimulatorSetjmpBuffer() {
     ASSERT(simulator_->last_setjmp_buffer() == this);
     simulator_->set_last_setjmp_buffer(link_);
   }
 
   SimulatorSetjmpBuffer* link() const { return link_; }
 
-  uword sp() const { return reinterpret_cast<uword>(sp_); }
   uword fp() const { return reinterpret_cast<uword>(fp_); }
 
   jmp_buf buffer_;
 
  private:
-  RawObject** sp_;
   RawObject** fp_;
   Simulator* simulator_;
   SimulatorSetjmpBuffer* link_;
 
   friend class Simulator;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(SimulatorSetjmpBuffer);
 };
 
@@ skipping 411 matching lines @@
       SimulatorHelpers::Double_greaterThan;
   intrinsics_[kDouble_greaterEqualThanIntrinsic] =
       SimulatorHelpers::Double_greaterEqualThan;
   intrinsics_[kDouble_lessThanIntrinsic] = SimulatorHelpers::Double_lessThan;
   intrinsics_[kDouble_equalIntrinsic] = SimulatorHelpers::Double_equal;
   intrinsics_[kDouble_lessEqualThanIntrinsic] =
       SimulatorHelpers::Double_lessEqualThan;
 }
 
 
-Simulator::Simulator() : stack_(NULL), fp_(NULL), sp_(NULL) {
+Simulator::Simulator() : stack_(NULL), fp_(NULL) {
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   // We allocate the stack here, the size is computed as the sum of
   // the size specified by the user and the buffer space needed for
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ = new uintptr_t[(OSThread::GetSpecifiedStackSize() +
                           OSThread::kStackSizeBuffer +
                           kSimulatorStackUnderflowSize) /
                          sizeof(uintptr_t)];
@@ skipping 50 matching lines @@
 
 
 void Simulator::Exit(Thread* thread,
                      RawObject** base,
                      RawObject** frame,
                      uint32_t* pc) {
   frame[0] = Function::null();
   frame[1] = Code::null();
   frame[2] = reinterpret_cast<RawObject*>(pc);
   frame[3] = reinterpret_cast<RawObject*>(base);
-  fp_ = sp_ = frame + kDartFrameFixedSize;
-  thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));
+  fp_ = frame + kDartFrameFixedSize;
+  thread->set_top_exit_frame_info(reinterpret_cast<uword>(fp_));
 }
 
 // TODO(vegorov): Investigate advantages of using
 // __builtin_s{add,sub,mul}_overflow() intrinsics here and below.
 // Note that they may clobber the output location even when there is overflow:
 // https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html
 DART_FORCE_INLINE static bool SignedAddWithOverflow(intptr_t lhs,
                                                     intptr_t rhs,
                                                     intptr_t* out) {
   intptr_t res = 1;
@@ skipping 457 matching lines @@
 // Exception handling helper. Gets handler FP and PC from the Simulator where
 // they were stored by Simulator::Longjmp and proceeds to execute the handler.
 // Corner case: handler PC can be a fake marker that marks entry frame, which
 // means exception was not handled in the Dart code. In this case we return
 // caught exception from Simulator::Call.
 #define HANDLE_EXCEPTION                                                       \
   do {                                                                         \
     FP = reinterpret_cast<RawObject**>(fp_);                                   \
     pc = reinterpret_cast<uint32_t*>(pc_);                                     \
     if ((reinterpret_cast<uword>(pc) & 2) != 0) { /* Entry frame? */           \
-      fp_ = sp_ = reinterpret_cast<RawObject**>(fp_[0]);                       \
-      thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));           \
+      fp_ = reinterpret_cast<RawObject**>(fp_[0]);                             \
+      thread->set_top_exit_frame_info(reinterpret_cast<uword>(fp_));           \
       thread->set_top_resource(top_resource);                                  \
       thread->set_vm_tag(vm_tag);                                              \
       return special_[kExceptionSpecialIndex];                                 \
     }                                                                          \
     pp = SimulatorHelpers::FrameCode(FP)->ptr()->object_pool_->ptr();          \
     goto DispatchAfterException;                                               \
   } while (0)
 
 // Runtime call helpers: handle invocation and potential exception after return.
 #define INVOKE_RUNTIME(Func, Args)                                             \
@@ skipping 30 matching lines @@
   RawObjectPool* pp;  // Pool Pointer.
   RawObject** FP;     // Frame Pointer.
   RawObject** SP;     // Stack Pointer.
 
   RawArray* argdesc;  // Arguments Descriptor: used to pass information between
                       // call instruction and the function entry.
 
   uint32_t op;  // Currently executing op.
   uint16_t rA;  // A component of the currently executing op.
 
-  if (sp_ == NULL) {
-    fp_ = sp_ = reinterpret_cast<RawObject**>(stack_);
+  if (fp_ == NULL) {
+    fp_ = reinterpret_cast<RawObject**>(stack_);
   }
 
   // Save current VM tag and mark thread as executing Dart code.
   const uword vm_tag = thread->vm_tag();
   thread->set_vm_tag(VMTag::kDartTagId);
 
   // Save current top stack resource and reset the list.
   StackResource* top_resource = thread->top_resource();
   thread->set_top_resource(NULL);
 
@@ skipping 1441 matching lines @@
   // Fall through to the ReturnImpl.
 
   ReturnImpl:
     // 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.
     if ((reinterpret_cast<uword>(pc) & 2) != 0) {
       const intptr_t argc = reinterpret_cast<uword>(pc) >> 2;
-      fp_ = sp_ =
-          reinterpret_cast<RawObject**>(FrameArguments(FP, argc + 1)[0]);
-      thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));
+      fp_ = reinterpret_cast<RawObject**>(FrameArguments(FP, argc + 1)[0]);
+      thread->set_top_exit_frame_info(reinterpret_cast<uword>(fp_));
       thread->set_top_resource(top_resource);
       thread->set_vm_tag(vm_tag);
       return result;
     }
 
     // Look at the caller to determine how many arguments to pop.
     const uint8_t argc = Bytecode::DecodeArgc(pc[-1]);
 
     // Restore SP, FP and PP. Push result and dispatch.
     SP = FrameArguments(FP, argc);
@@ skipping 1125 matching lines @@
   // 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);
 
-  sp_ = reinterpret_cast<RawObject**>(sp);
   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;
@@ skipping 13 matching lines @@
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC