Second codegen test passing on ARM (simulated).

runtime/vm/assembler_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 "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 
+#include "vm/runtime_entry.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 // TODO(regis): Enable this flag after PrintStopMessage stub is implemented.
 DEFINE_FLAG(bool, print_stop_message, false, "Print stop message.");
 
 
 // Instruction encoding bits.
 enum {
@@ skipping 1098 matching lines @@
 
 void Assembler::MarkExceptionHandler(Label* label) {
   EmitType01(AL, 1, TST, 1, PC, R0, ShifterOperand(0));
   Label l;
   b(&l);
   EmitBranch(AL, label, false);
   Bind(&l);
 }
 
 
+void Assembler::Drop(intptr_t stack_elements) {
+  ASSERT(stack_elements >= 0);
+  if (stack_elements > 0) {
+    AddImmediate(SP, SP, stack_elements * kWordSize);
+  }
+}
+
+
 void Assembler::LoadObject(Register rd, const Object& object) {
   if (object.IsNull() ||
       object.IsSmi() ||
       (object.raw() == Bool::True().raw()) ||
       (object.raw() == Bool::False().raw())) {
     // This object is never relocated; do not use object pool.
     LoadImmediate(rd, reinterpret_cast<int32_t>(object.raw()));
     return;
   }
   const int32_t offset =
@@ skipping 516 matching lines @@
 void Assembler::Ret() {
   bx(LR);
 }
 
 
 void Assembler::ReserveAlignedFrameSpace(intptr_t frame_space) {
   // Reserve space for arguments and align frame before entering
   // the C++ world.
   AddImmediate(SP, -frame_space);
   if (OS::ActivationFrameAlignment() > 0) {
-    and_(SP, SP, ShifterOperand(~(OS::ActivationFrameAlignment() - 1)));
+    bic(SP, SP, ShifterOperand(OS::ActivationFrameAlignment() - 1));
   }
 }
 
 
+void Assembler::EnterCallRuntimeFrame(intptr_t frame_space) {
+  // Preserve volatile CPU registers.
+  EnterFrame(kDartVolatileCpuRegs | (1 << FP), 0);
+
+  // Preserve all volatile FPU registers.
+  // TODO(regis): Use vstmd instruction once supported.
+  // vstmd(DB_W, SP, kDartFirstVolatileFpuReg, kDartLastVolatileFpuReg);
+
+  ReserveAlignedFrameSpace(frame_space);
+}
+
+
+void Assembler::LeaveCallRuntimeFrame() {
+  // SP might have been modified to reserve space for arguments
+  // and ensure proper alignment of the stack frame.
+  // We need to restore it before restoring registers.
+  const intptr_t kPushedRegistersSize =
+      kDartVolatileCpuRegCount * kWordSize;
+  // TODO(regis): + kDartVolatileFpuRegCount * 2 * kWordSize;
+  AddImmediate(SP, FP, -kPushedRegistersSize);
+
+  // Restore all volatile FPU registers.
+  // TODO(regis): Use vldmd instruction once supported.
+  // vldmd(IA_W, SP, kDartFirstVolatileFpuReg, kDartLastVolatileFpuReg);
+
+  // Restore volatile CPU registers.
+  LeaveFrame(kDartVolatileCpuRegs | (1 << FP));
+}
+
+
+void Assembler::CallRuntime(const RuntimeEntry& entry) {
+  entry.Call(this);
+}
+
+
 void Assembler::Stop(const char* message) {
   if (FLAG_print_stop_message) {
     PushList((1 << R0) | (1 << IP) | (1 << LR));  // Preserve R0, IP, LR.
     LoadImmediate(R0, reinterpret_cast<int32_t>(message));
     // PrintStopMessage() preserves all registers.
     BranchLink(&StubCode::PrintStopMessageLabel());  // Passing message in R0.
     PopList((1 << R0) | (1 << IP) | (1 << LR));  // Restore R0, IP, LR.
   }
   // Emit the message address before the svc instruction, so that we can
   // 'unstop' and continue execution in the simulator or jump to the next
@@ skipping 54 matching lines @@
   // Do not reuse an existing entry, since each reference may be patched
   // independently.
   object_pool_.Add(smi);
   return object_pool_.Length() - 1;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM