Adds arm64 double arithmetic instructions.

runtime/vm/stub_code_arm64.cc

 // Copyright (c) 2014, 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_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 381 matching lines @@
   __ Pop(R4);
   // Remove the stub frame.
   __ LeaveStubFrame();
   // Jump to the dart function.
   __ LoadFieldFromOffset(R0, R0, Code::instructions_offset());
   __ AddImmediate(R0, R0, Instructions::HeaderSize() - kHeapObjectTag, kNoPP);
   __ br(R0);
 }
 
 
+// Input parameters:
+//   R2: smi-tagged argument count, may be zero.
+//   FP[kParamEndSlotFromFp + 1]: last argument.
+static void PushArgumentsArray(Assembler* assembler) {
+  // Allocate array to store arguments of caller.
+  __ LoadObject(R1, Object::null_object(), PP);
+  // R1: null element type for raw Array.
+  // R2: smi-tagged argument count, may be zero.
+  __ BranchLink(&StubCode::AllocateArrayLabel(), PP);
+  // R0: newly allocated array.
+  // R2: smi-tagged argument count, may be zero (was preserved by the stub).
+  __ Push(R0);  // Array is in R0 and on top of stack.
+  __ add(R1, FP, Operand(R2, LSL, 2));
+  __ AddImmediate(R1, R1, kParamEndSlotFromFp * kWordSize, PP);
+  __ AddImmediate(R3, R0, Array::data_offset() - kHeapObjectTag, PP);
+  // R1: address of first argument on stack.
+  // R3: address of first argument in array.
+
+  Label loop, loop_exit;
+  __ CompareRegisters(R2, ZR);
+  __ b(&loop_exit, LE);
+  __ Bind(&loop);
+  __ ldr(R7, Address(R1));
+  __ AddImmediate(R1, R1, -kWordSize, PP);
+  __ AddImmediate(R3, R3, kWordSize, PP);
+  __ AddImmediateSetFlags(R2, R2, -Smi::RawValue(1), PP);
+  __ str(R7, Address(R3, -kWordSize));
+  __ b(&loop, GE);
+  __ Bind(&loop_exit);
+}
+
+
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
                            uword saved_registers_address);
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, uword last_fp);
 
 
 // Used by eager and lazy deoptimization. Preserve result in RAX if necessary.
 // This stub translates optimized frame into unoptimized frame. The optimized
 // frame can contain values in registers and on stack, the unoptimized
@@ skipping 759 matching lines @@
   __ CallRuntime(kAllocateObjectRuntimeEntry, 2);  // Allocate object.
   __ Drop(2);  // Pop arguments.
   __ Pop(R0);  // Pop result (newly allocated object).
   // R0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame();
   __ ret();
 }
 
 
+// Called for invoking "dynamic noSuchMethod(Invocation invocation)" function
+// from the entry code of a dart function after an error in passed argument
+// name or number is detected.
+// Input parameters:
+//  LR : return address.
+//  SP : address of last argument.
+//  R5: inline cache data object.
+//  R4: arguments descriptor array.
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
-  __ Stop("GenerateCallNoSuchMethodFunctionStub");
+  __ EnterStubFrame(true);
+
+  // Load the receiver.
+  __ LoadFieldFromOffset(R2, R4, ArgumentsDescriptor::count_offset());
+  __ add(TMP, FP, Operand(R2, LSL, 2));  // R2 is Smi.
+  __ LoadFromOffset(R6, TMP, kParamEndSlotFromFp * kWordSize);
+
+  // Push space for the return value.
+  // Push the receiver.
+  // Push IC data object.
+  // Push arguments descriptor array.
+  __ PushObject(Object::null_object(), PP);
+  __ Push(R6);
+  __ Push(R5);
+  __ Push(R4);
+
+  // R2: Smi-tagged arguments array length.
+  PushArgumentsArray(assembler);
+
+  __ CallRuntime(kInvokeNoSuchMethodFunctionRuntimeEntry, 4);
+  // Remove arguments.
+  __ Drop(4);
+  __ Pop(R0);  // Get result into R0.
+  __ LeaveStubFrame();
+  __ ret();
 }
 
 
 //  R6: function object.
 //  R5: inline cache data object.
 // Cannot use function object from ICData as it may be the inlined
 // function and not the top-scope function.
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
   Register ic_reg = R5;
   Register func_reg = R6;
@@ skipping 646 matching lines @@
   const Register right = R0;
   __ LoadFromOffset(left, SP, 1 * kWordSize);
   __ LoadFromOffset(right, SP, 0 * kWordSize);
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64