Support call operator in the vm.

runtime/vm/stub_code_x64.cc

 // Copyright (c) 2012, 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_X64)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
@@ skipping 547 matching lines @@
   __ cmpq(RAX, raw_null);
   __ j(EQUAL, &lookup, Assembler::kNearJump);
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RAX);
 
   __ Bind(&lookup);
   __ jmp(&StubCode::InstanceFunctionLookupLabel());
 }
 
 
-
 // Called for inline allocation of arrays.
 // Input parameters:
 //   R10 : Array length as Smi.
 //   RBX : array element type (either NULL or an instantiated type).
 // NOTE: R10 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in RAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 74 matching lines @@
       __ Bind(&done);
 
       // Get the class index and insert it into the tags.
       __ orq(RBX, Immediate(RawObject::ClassIdTag::encode(kArrayCid)));
       __ movq(FieldAddress(RAX, Array::tags_offset()), RBX);
     }
 
     // Initialize all array elements to raw_null.
     // RAX: new object start as a tagged pointer.
     // R12: new object end address.
+    // R10: Array length as Smi.
     __ leaq(RBX, FieldAddress(RAX, Array::data_offset()));
     // RBX: iterator which initially points to the start of the variable
     // data area to be initialized.
     Label done;
     Label init_loop;
     __ Bind(&init_loop);
     __ cmpq(RBX, R12);
     __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
+    // TODO(cshapiro): StoreIntoObjectNoBarrier
     __ movq(Address(RBX, 0), raw_null);
     __ addq(RBX, Immediate(kWordSize));
     __ jmp(&init_loop, Assembler::kNearJump);
     __ Bind(&done);
 
     // Done allocating and initializing the array.
     // RAX: new object.
     // R10: Array length as Smi (preserved for the caller.)
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
+  // Create a stub frame as we are pushing some objects on the stack before
+  // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushq(raw_null);  // Setup space on stack for return value.
   __ pushq(R10);  // Array length as Smi.
   __ pushq(RBX);  // Element type.
   __ CallRuntime(kAllocateArrayRuntimeEntry);
   __ popq(RAX);  // Pop element type argument.
   __ popq(R10);  // Pop array length argument.
   __ popq(RAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
@@ skipping 59 matching lines @@
   __ Bind(&function_compiled);
   // RAX: Code.
   // RBX: Function.
   // R10: Arguments descriptor array.
 
   __ movq(RBX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RBX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RBX);
 
   __ Bind(&not_closure);
-  // Call runtime to report that a closure call was attempted on a non-closure
-  // object, passing the non-closure object and its arguments array.
+  // Call runtime to attempt to resolve and invoke a call method on a
+  // non-closure object, passing the non-closure object and its arguments array,
+  // returning here.
+  // If no call method exists, throw a NoSuchMethodError.
   // R13: non-closure object.
   // R10: arguments descriptor array.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
 
-  __ pushq(raw_null);  // Setup space on stack for result from error reporting.
+  __ pushq(raw_null);  // Setup space on stack for result from call.
   __ pushq(R13);  // Non-closure object.
+  __ pushq(R10);  // Arguments descriptor.
   // Load num_args.
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ SmiUntag(R13);  // Arguments array length, including the non-closure.
-  // See stack layout below explaining "wordSize * 5" offset.
-  PushArgumentsArray(assembler, (kWordSize * 5));
+  // See stack layout below explaining "wordSize * 6" offset.
+  PushArgumentsArray(assembler, (kWordSize * 6));
 
   // Stack:
   // TOS + 0: Argument array.
-  // TOS + 1: Non-closure object.
-  // TOS + 2: Place for result from reporting the error.
-  // TOS + 3: PC marker => RawInstruction object.
-  // TOS + 4: Saved RBP of previous frame. <== RBP
-  // TOS + 5: Dart code return address
-  // TOS + 6: Last argument of caller.
+  // TOS + 1: Arguments descriptor array.
+  // TOS + 2: Non-closure object.
+  // TOS + 3: Place for result from the call.
+  // TOS + 4: PC marker => RawInstruction object.
+  // TOS + 5: Saved RBP of previous frame. <== RBP
+  // TOS + 6: Dart code return address
+  // TOS + 7: Last argument of caller.
   // ....
-  __ CallRuntime(kReportObjectNotClosureRuntimeEntry);
-  __ Stop("runtime call throws an exception");
+  __ CallRuntime(kInvokeNonClosureRuntimeEntry);
+  // Remove arguments.
+  __ popq(RAX);
+  __ popq(RAX);
+  __ popq(RAX);
+  __ popq(RAX);  // Get result into RAX.
+
+  // Remove the stub frame as we are about to return.
+  __ LeaveFrame();
+  __ ret();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RSP : points to return address.
 //   RDI : entrypoint of the Dart function to call.
 //   RSI : arguments descriptor array.
 //   RDX : pointer to the argument array.
 //   RCX : new context containing the current isolate pointer.
@@ skipping 1358 matching lines @@
   __ cmpq(left, right);
   __ Bind(&done);
   __ popq(right);
   __ popq(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64