Second codegen test passing on ARM (simulated).

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 117 matching lines @@
 SimulatorDebugger::~SimulatorDebugger() {
 }
 
 
 void SimulatorDebugger::Stop(Instr* instr, const char* message) {
   OS::Print("Simulator hit %s\n", message);
   Debug();
 }
 
 
-static Register LookupCoreRegisterByName(const char* name) {
+static Register LookupCpuRegisterByName(const char* name) {
   static const char* kNames[] = {
       "r0",  "r1",  "r2",  "r3",
       "r4",  "r5",  "r6",  "r7",
       "r8",  "r9",  "r10", "r11",
       "r12", "r13", "r14", "r15",
       "pc",  "lr",  "sp",  "ip",
-      "fp",  "sl"
+      "fp",  "pp",  "ctx"
   };
   static const Register kRegisters[] = {
       R0,  R1,  R2,  R3,
       R4,  R5,  R6,  R7,
       R8,  R9,  R10, R11,
       R12, R13, R14, R15,
       PC,  LR,  SP,  IP,
-      FP,  R10
+      FP,  R10, R9
   };
   ASSERT(ARRAY_SIZE(kNames) == ARRAY_SIZE(kRegisters));
   for (unsigned i = 0; i < ARRAY_SIZE(kNames); i++) {
     if (strcmp(kNames[i], name) == 0) {
       return kRegisters[i];
     }
   }
   return kNoRegister;
 }
 
@@ skipping 12 matching lines @@
   int reg_nr = -1;
   bool ok = SScanF(name, "d%d", &reg_nr);
   if (ok && (0 <= reg_nr) && (reg_nr < kNumberOfDRegisters)) {
     return static_cast<DRegister>(reg_nr);
   }
   return kNoDRegister;
 }
 
 
 bool SimulatorDebugger::GetValue(char* desc, uint32_t* value) {
-  Register reg = LookupCoreRegisterByName(desc);
+  Register reg = LookupCpuRegisterByName(desc);
   if (reg != kNoRegister) {
     if (reg == PC) {
       *value = sim_->get_pc();
     } else {
       *value = sim_->get_register(reg);
     }
     return true;
   }
   if ((desc[0] == '*')) {
     uint32_t addr;
@@ skipping 467 matching lines @@
 // execute it with the simulator.  We do that by redirecting the external
 // reference to a svc (supervisor call) instruction that is handled by
 // the simulator.  We write the original destination of the jump just at a known
 // offset from the svc instruction so the simulator knows what to call.
 class Redirection {
  public:
   uword address_of_svc_instruction() {
     return reinterpret_cast<uword>(&svc_instruction_);
   }
 
-  void* external_function() const { return external_function_; }
+  uword external_function() const { return external_function_; }
 
   uint32_t argument_count() const { return argument_count_; }
 
-  static Redirection* Get(void* external_function, uint32_t argument_count) {
+  static Redirection* Get(uword external_function, uint32_t argument_count) {
     Redirection* current;
     for (current = list_; current != NULL; current = current->next_) {
       if (current->external_function_ == external_function) return current;
     }
     return new Redirection(external_function, argument_count);
   }
 
   static Redirection* FromSvcInstruction(Instr* svc_instruction) {
     char* addr_of_svc = reinterpret_cast<char*>(svc_instruction);
     char* addr_of_redirection =
         addr_of_svc - OFFSET_OF(Redirection, svc_instruction_);
     return reinterpret_cast<Redirection*>(addr_of_redirection);
   }
 
  private:
   static const int32_t kRedirectSvcInstruction =
     ((AL << kConditionShift) | (0xf << 24) | kRedirectionSvcCode);
-  Redirection(void* external_function, uint32_t argument_count)
+  Redirection(uword external_function, uint32_t argument_count)
       : external_function_(external_function),
         argument_count_(argument_count),
         svc_instruction_(kRedirectSvcInstruction),
         next_(list_) {
     list_ = this;
   }
 
-  void* external_function_;
+  uword external_function_;
   const uint32_t argument_count_;
   uint32_t svc_instruction_;
   Redirection* next_;
   static Redirection* list_;
 };
 
 
 Redirection* Redirection::list_ = NULL;
 
 
-uword Simulator::RedirectExternalReference(void* function,
+uword Simulator::RedirectExternalReference(uword function,
                                            uint32_t argument_count) {
   Redirection* redirection = Redirection::Get(function, argument_count);
   return redirection->address_of_svc_instruction();
 }
 
 
 // Get the active Simulator for the current isolate.
 Simulator* Simulator::Current() {
   Simulator* simulator = Isolate::Current()->simulator();
   if (simulator == NULL) {
@@ skipping 583 matching lines @@
       if (!setjmp(buffer.buffer_)) {
         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));
 
         int32_t saved_lr = get_register(LR);
         Redirection* redirection = Redirection::FromSvcInstruction(instr);
-        intptr_t external =
-            reinterpret_cast<intptr_t>(redirection->external_function());
+        uword external = redirection->external_function();
         SimulatorRuntimeCall target =
             reinterpret_cast<SimulatorRuntimeCall>(external);
         if (FLAG_trace_sim) {
           PrintExternalCallTrace(external, arguments);
         }
         target(arguments);
 
         // Zap caller-saved registers, since the actual runtime call could have
         // used them.
         set_register(R2, icount_);
@@ skipping 1409 matching lines @@
   // isolate->ChangeStateToGeneratedCode();
   set_register(kExceptionObjectReg, bit_cast<int32_t>(object.raw()));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM