- Fix a couple near branches that were out of reach.

vm/stub_code_x64.cc

 // Copyright (c) 2011, 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/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/ic_data.h"
@@ skipping 369 matching lines @@
   // ....
   // Total number of args is the first Smi in args descriptor array (R10).
   __ movq(RAX, FieldAddress(R10, Array::data_offset()));
   __ movq(RAX, Address(RSP, RAX, TIMES_4, kWordSize));  // Get receiver.
   __ pushq(R10);  // Preserve arguments descriptor array.
   __ pushq(RAX);  // Preserve receiver.
   __ pushq(RBX);  // Preserve ic-data array.
   // First resolve the function to get the function object.
 
   // Setup space for return value on stack by pushing smi 0.
   __ pushq(Immediate(0));

[siva, 2011/12/27 21:33:11]

Should this be
__ pushq(raw_null); ?

Not sure what the style is sometimes we push 0 sometimes raw_null...

[Ivan Posva, 2011/12/27 22:59:42]

Filed issue 995 to address this in general for both ia32 and x64.

   __ pushq(RAX);  // Push receiver.
   __ CallRuntimeFromStub(kResolveCompileInstanceFunctionRuntimeEntry);
   __ popq(RAX);  // Remove receiver pushed earlier.
   __ popq(RBX);  // Pop returned code object into RBX.
   // Pop preserved values
   __ popq(R10);  // Restore ic-data array.
   __ popq(RAX);  // Restore receiver.
   __ popq(R13);  // Restore arguments descriptor array.
 
   __ cmpq(RBX, raw_null);
@@ skipping 380 matching lines @@
   __ popq(R12);
   __ popq(RBX);
 
   // Restore the frame pointer.
   __ LeaveFrame();
 
   __ ret();
 }
 
 
+// Called for inline allocation of contexts.
+// Input:
+// RDX: number of context variables.
+// Output:
+// RAX: new allocated RawContext object.
+// RBX and RDX are destroyed.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
-  __ Unimplemented("AllocateContext stub");
+  if (false) {
+    // TODO(regis): Implement fast inline allocation of contexts.
+    __ Unimplemented("AllocateContext stub - inline allocation");
+  }
+  // Create the stub frame.
+  __ EnterFrame(0);
+  const Context& new_context = Context::ZoneHandle();
+  __ PushObject(new_context);  // Push Null context for return value.

[siva, 2011/12/27 21:33:11]

const Immediate raw_null =
      Immediate(reinterpret_cast<intptr_t>(Object::null()));
__ pushq(raw_null);

or

at other spots we seem to be using
__ pushq(Immediate(0)); for setting up the return value.

[Ivan Posva, 2011/12/27 22:59:42]

Done.

+  __ SmiTag(RDX);
+  __ pushq(RDX);

[siva, 2011/12/27 21:33:11]

// Push number of context variables argument.

[Ivan Posva, 2011/12/27 22:59:42]

Done.

+  __ CallRuntimeFromStub(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ popq(RAX);  // Pop number of context variables argument.
+  __ popq(RAX);  // Pop the new context object.
+  // RAX: new object
+  // Restore the frame pointer.
+  __ LeaveFrame();
+  __ ret();
 }
 
 
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RSP + 16 : type arguments object (only if class is parameterized).
 //   RSP + 8 : type arguments of instantiator (only if class is parameterized).
 //   RSP : points to return address.
@@ skipping 34 matching lines @@
       // InstantiatedTypeArguments object start.
     }
     // Check if the allocation fits into the remaining space.
     // RAX: potential new object start.
     // RBX: potential next object start.
     __ movq(RDI, Immediate(heap->EndAddress()));
     __ cmpq(RBX, Address(RDI, 0));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
     } else {
-      __ j(ABOVE_EQUAL, &slow_case, Assembler::kNearJump);
+      __ j(ABOVE_EQUAL, &slow_case);
     }
 
     // Successfully allocated the object(s), now update top to point to
     // next object start and initialize the object.
     __ movq(RDI, Immediate(heap->TopAddress()));
     __ movq(Address(RDI, 0), RBX);
 
     if (is_cls_parameterized) {
       // Initialize the type arguments field in the object.
       // RAX: new object start.
@@ skipping 122 matching lines @@
   __ popq(RAX);  // Pop argument (type arguments of object).
   __ popq(RAX);  // Pop argument (class of object).
   __ popq(RAX);  // Pop result (newly allocated object).
   // RAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
 
+// Called for inline allocation of closures.
+// Input parameters:
+//   If the signature class is not parameterized, the receiver, if any, will be
+//   at RSP + 4 instead of RSP + 8, since no type arguments are passed.
+//   RSP + 8 (or RSP + 4): receiver (only if implicit instance closure).
+//   RSP + 4 : type arguments object (only if signature class is parameterized).
+//   RSP : points to return address.
+// Uses RAX, RBX, RCX, RDX as temporary registers.
 void StubCode::GenerateAllocationStubForClosure(Assembler* assembler,
                                                 const Function& func) {
-  __ Unimplemented("AllocateClosure stub");
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  ASSERT(func.IsClosureFunction());
+  const bool is_implicit_static_closure =
+      func.IsImplicitStaticClosureFunction();
+  const bool is_implicit_instance_closure =
+      func.IsImplicitInstanceClosureFunction();
+  const Class& cls = Class::ZoneHandle(func.signature_class());
+  const bool has_type_arguments = cls.HasTypeArguments();
+  const intptr_t kTypeArgumentsOffset = 1 * kWordSize;
+  const intptr_t kReceiverOffset = (has_type_arguments ? 2 : 1) * kWordSize;
+  if (false) {
+    // TODO(regis): Implement inline context allocation.
+    __ Unimplemented("AllocateClosure stub - inline allocation");
+  }
+  if (has_type_arguments) {
+    __ movq(RCX, Address(RSP, kTypeArgumentsOffset));
+  }
+  if (is_implicit_instance_closure) {
+    __ movq(RAX, Address(RSP, kReceiverOffset));
+  }
+  // Create the stub frame.
+  __ EnterFrame(0);
+  const Closure& new_closure = Closure::ZoneHandle();
+  __ PushObject(new_closure);  // Push Null closure for return value.

[siva, 2011/12/27 21:33:11]

Ditto comment regarding __ pushq(raw_null);

[Ivan Posva, 2011/12/27 22:59:42]

Done.

+  __ PushObject(func);
+  if (is_implicit_static_closure) {
+    __ CallRuntimeFromStub(kAllocateImplicitStaticClosureRuntimeEntry);
+  } else {
+    if (is_implicit_instance_closure) {
+      __ pushq(RAX);  // Receiver.
+    }
+    if (has_type_arguments) {
+      __ pushq(RCX);  // Push type arguments of closure to be allocated.
+    } else {
+      __ pushq(raw_null);  // Push null type arguments.
+    }
+    if (is_implicit_instance_closure) {
+      __ CallRuntimeFromStub(kAllocateImplicitInstanceClosureRuntimeEntry);
+      __ popq(RAX);  // Pop type arguments.
+      __ popq(RAX);  // Pop receiver.
+    } else {
+      ASSERT(func.IsNonImplicitClosureFunction());
+      __ CallRuntimeFromStub(kAllocateClosureRuntimeEntry);
+      __ popq(RAX);  // Pop type arguments.
+    }
+  }
+  __ popq(RAX);  // Pop the function object.
+  __ popq(RAX);  // Pop the result.
+  // RAX: New closure object.
+  // Restore the calling frame.
+  __ LeaveFrame();
+  __ ret();
 }
 
 
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   __ Unimplemented("CallNoSuchMethodFunction stub");
 }
 
 
 // Generate inline cache check for 'num_args'.
 //  RBX: Inline cache data array.
@@ skipping 162 matching lines @@
 }
 
 
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   __ Unimplemented("BreakpointDynamic stub");
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64