Support FrameLookup vm test on ARM, requiring among other things:

runtime/vm/simulator_arm.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 <math.h>  // for isnan.
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
@@ skipping 478 matching lines @@
   // shell when hit.
   RedoBreakpoints();
 
 #undef COMMAND_SIZE
 #undef ARG_SIZE
 
 #undef STR
 #undef XSTR
 }
 
+
 char* SimulatorDebugger::ReadLine(const char* prompt) {
   char* result = NULL;
   char line_buf[256];
   int offset = 0;
   bool keep_going = true;
   fprintf(stdout, "%s", prompt);
   fflush(stdout);
   while (keep_going) {
     if (fgets(line_buf, sizeof(line_buf), stdin) == NULL) {
       // fgets got an error. Just give up.
@@ skipping 111 matching lines @@
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ = new char[(Isolate::GetSpecifiedStackSize() +
                      Isolate::kStackSizeBuffer +
                      kSimulatorStackUnderflowSize)];
   pc_modified_ = false;
   icount_ = 0;
   break_pc_ = NULL;
   break_instr_ = 0;
   last_setjmp_buffer_ = NULL;
+  top_exit_frame_info_ = 0;
 
   // Setup architecture state.
   // All registers are initialized to zero to start with.
   for (int i = 0; i < kNumberOfCpuRegisters; i++) {
     registers_[i] = 0;
   }
   n_flag_ = false;
   z_flag_ = false;
   c_flag_ = false;
   v_flag_ = false;
@@ skipping 688 matching lines @@
     case kRedirectionSvcCode: {
       SimulatorSetjmpBuffer buffer(this);
 
       if (!setjmp(buffer.buffer_)) {
         int32_t saved_lr = get_register(LR);
         Redirection* redirection = Redirection::FromSvcInstruction(instr);
         uword external = redirection->external_function();
         if (FLAG_trace_sim) {
           OS::Print("Call to host function at 0x%"Pd"\n", external);
         }
+
+        if (redirection->call_kind() != kLeafRuntimeCall) {
+          // The top_exit_frame_info of the current isolate points to the top of
+          // the simulator stack.
+          ASSERT((StackTop() - Isolate::Current()->top_exit_frame_info()) <
+                 Isolate::GetSpecifiedStackSize());
+          // Set the top_exit_frame_info of this simulator to the native stack.
+          set_top_exit_frame_info(reinterpret_cast<uword>(&buffer));
+        }
         if (redirection->call_kind() == kRuntimeCall) {
           NativeArguments arguments;
           ASSERT(sizeof(NativeArguments) == 4*kWordSize);
           arguments.isolate_ = reinterpret_cast<Isolate*>(get_register(R0));
           arguments.argc_tag_ = get_register(R1);
           arguments.argv_ = reinterpret_cast<RawObject*(*)[]>(get_register(R2));
           arguments.retval_ = reinterpret_cast<RawObject**>(get_register(R3));
           SimulatorRuntimeCall target =
               reinterpret_cast<SimulatorRuntimeCall>(external);
           target(arguments);
           set_register(R0, icount_);  // Zap result register from void function.
         } else if (redirection->call_kind() == kLeafRuntimeCall) {
           int32_t r0 = get_register(R0);
           int32_t r1 = get_register(R1);
           int32_t r2 = get_register(R2);
           int32_t r3 = get_register(R3);
           SimulatorLeafRuntimeCall target =
               reinterpret_cast<SimulatorLeafRuntimeCall>(external);
           r0 = target(r0, r1, r2, r3);
           set_register(R0, r0);  // Set returned result from function.
         } else {
           ASSERT(redirection->call_kind() == kNativeCall);
           NativeArguments* arguments;
           arguments = reinterpret_cast<NativeArguments*>(get_register(R0));
           SimulatorNativeCall target =
               reinterpret_cast<SimulatorNativeCall>(external);
           target(arguments);
           set_register(R0, icount_);  // Zap result register from void function.
         }
+        set_top_exit_frame_info(0);
 
         // Zap caller-saved registers, since the actual runtime call could have
         // used them.
         set_register(R1, icount_);
         set_register(R2, icount_);
         set_register(R3, icount_);
         set_register(IP, icount_);
         set_register(LR, icount_);
         float zap_fvalue = static_cast<float>(icount_);
         for (int i = S0; i <= S15; i++) {
@@ skipping 1481 matching lines @@
   set_register(PC, pc);
   SimulatorSetjmpBuffer* buf = last_setjmp_buffer();
 
   // Walk over all setjmp buffers (simulated --> C++ transitions)
   // and try to find the setjmp associated with the stack pointer.
   while (buf->link() != NULL && buf->link()->sp() <= sp) {
     buf = buf->link();
   }
   ASSERT(buf != NULL);
 
-  // Clean up stack memory of C++ frames.
-  // TODO(regis): Revisit.
-  // isolate->PrepareForUnwinding(reinterpret_cast<uword>(buf));
-  // isolate->ChangeStateToGeneratedCode();
+  // The caller has already cleaned up the stack memory of C++ frames.
   set_register(kExceptionObjectReg, bit_cast<int32_t>(object.raw()));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM