Compile and simulate first dart function on arm generated from ast.

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 938 matching lines @@
   } else {
     // Same effect on exclusive access state as an LDREX.
     SetExclusiveAccess(reinterpret_cast<uword>(address));
   }
   return value;
 }
 
 
 // Returns the top of the stack area to enable checking for stack pointer
 // validity.
-uintptr_t Simulator::StackTop() const {
+uword Simulator::StackTop() const {
   // To be safe in potential stack underflows we leave some buffer above and
   // set the stack top.
-  return reinterpret_cast<uintptr_t>(stack_) +
+  return reinterpret_cast<uword>(stack_) +
       (Isolate::GetSpecifiedStackSize() + Isolate::kStackSizeBuffer);
 }
 
 
 // Unsupported instructions use Format to print an error and stop execution.
 void Simulator::Format(Instr* instr, const char* format) {
   OS::Print("Simulator found unsupported instruction:\n 0x%p: %s\n",
             instr,
             format);
   UNIMPLEMENTED();
@@ skipping 411 matching lines @@
 // Handle execution based on instruction types.
 
 // Instruction types 0 and 1 are both rolled into one function because they
 // only differ in the handling of the shifter_operand.
 void Simulator::DecodeType01(Instr* instr) {
   if (!instr->IsDataProcessing()) {
     // miscellaneous, multiply, sync primitives, extra loads and stores.
     if (instr->IsMiscellaneous()) {
       switch (instr->Bits(4, 3)) {
         case 1: {
-          ASSERT(instr->Bits(21, 2) == 0x3);
-          // Format(instr, "clz'cond 'rd, 'rm");
-          Register rm = instr->RmField();
-          Register rd = instr->RdField();
-          int32_t rm_val = get_register(rm);
-          int32_t rd_val = 0;
-          if (rm_val != 0) {
-            while (rm_val > 0) {
-              rd_val++;
-              rm_val <<= 1;
+          if (instr->Bits(21, 2) == 0x3) {
+            // Format(instr, "clz'cond 'rd, 'rm");
+            Register rm = instr->RmField();
+            Register rd = instr->RdField();
+            int32_t rm_val = get_register(rm);
+            int32_t rd_val = 0;
+            if (rm_val != 0) {
+              while (rm_val > 0) {
+                rd_val++;
+                rm_val <<= 1;
+              }
+            } else {
+              rd_val = 32;
             }
+            set_register(rd, rd_val);
           } else {
-            rd_val = 32;
+            ASSERT(instr->Bits(21, 2) == 0x1);
+            // Format(instr, "bx'cond 'rm");
+            Register rm = instr->RmField();
+            int32_t rm_val = get_register(rm);
+            set_pc(rm_val);
           }
-          set_register(rd, rd_val);
           break;
         }
         case 3: {
           ASSERT(instr->Bits(21, 2) == 0x1);
           // Format(instr, "blx'cond 'rm");
           Register rm = instr->RmField();
           int32_t rm_val = get_register(rm);
           intptr_t pc = get_pc();
           set_register(LR, pc + Instr::kInstrSize);
           set_pc(rm_val);
           break;
         }
         case 7: {
           if (instr->Bits(21, 2) == 0x1) {
-            // Format(instr, "bkpt #'imm12_4");
+            // Format(instr, "bkpt'cond #'imm12_4");
             SimulatorDebugger dbg(this);
             set_pc(get_pc() + Instr::kInstrSize);
             char buffer[32];
             snprintf(buffer, sizeof(buffer), "bkpt #0x%x", instr->BkptField());
             dbg.Stop(instr, buffer);
           } else {
              // Format(instr, "smc'cond");
             UNIMPLEMENTED();
           }
           break;
@@ skipping 1232 matching lines @@
   int32_t r4_val = get_register(R4);
   int32_t r5_val = get_register(R5);
   int32_t r6_val = get_register(R6);
   int32_t r7_val = get_register(R7);
   int32_t r8_val = get_register(R8);
   int32_t r9_val = get_register(R9);
   int32_t r10_val = get_register(R10);
   int32_t r11_val = get_register(R11);
 
   // Setup the callee-saved registers with a known value. To be able to check
-  // that they are preserved properly across JS execution.
+  // that they are preserved properly across dart execution.
   int32_t callee_saved_value = icount_;
   set_register(R4, callee_saved_value);
   set_register(R5, callee_saved_value);
   set_register(R6, callee_saved_value);
   set_register(R7, callee_saved_value);
   set_register(R8, callee_saved_value);
   set_register(R9, callee_saved_value);
   set_register(R10, callee_saved_value);
   set_register(R11, callee_saved_value);
 
@@ skipping 46 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