Support allocating and calling closures in the new non-optimizing compiler.

runtime/vm/flow_graph_compiler_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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 12 matching lines @@
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     const ParsedFunction& parsed_function,
     const GrowableArray<BlockEntryInstr*>* blocks)
     : assembler_(assembler),
       parsed_function_(parsed_function),
       blocks_(blocks),
       block_info_(blocks->length()),
       current_block_(NULL),
-      pc_descriptors_list_(new CodeGenerator::DescriptorList()),
-      stack_local_count_(0) {
+      pc_descriptors_list_(new CodeGenerator::DescriptorList()) {
   for (int i = 0; i < blocks->length(); ++i) {
     block_info_.Add(new BlockInfo());
   }
 }
 
 
 FlowGraphCompiler::~FlowGraphCompiler() {
   // BlockInfos are zone-allocated, so their destructors are not called.
   // Verify the labels explicitly here.
   for (int i = 0; i < block_info_.length(); ++i) {
@@ skipping 113 matching lines @@
     default:
       UNIMPLEMENTED();
   }
   ExternalLabel target_label("InlineCache", label_address);
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall, node_id, token_index);
   __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
+void FlowGraphCompiler::VisitCurrentContext(CurrentContextComp* comp) {
+  __ movq(RAX, CTX);
+}
+
+
+void FlowGraphCompiler::VisitClosureCall(ClosureCallComp* comp) {
+  ASSERT(comp->context()->IsTemp());
+  ASSERT(VerifyCallComputation(comp));
+  // The arguments to the stub include the closure.  The arguments
+  // descriptor describes the closure's arguments (and so does not include
+  // the closure).
+  int argument_count = comp->ArgumentCount();
+  const Array& arguments_descriptor =
+      CodeGenerator::ArgumentsDescriptor(argument_count - 1,
+                                         comp->argument_names());
+  __ LoadObject(R10, arguments_descriptor);
+
+  GenerateCall(comp->token_index(),
+               &StubCode::CallClosureFunctionLabel(),
+               PcDescriptors::kOther);
+  __ addq(RSP, Immediate(argument_count * kWordSize));
+  __ popq(CTX);
+}
+
+
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
   ASSERT(VerifyCallComputation(comp));
   EmitInstanceCall(comp->node_id(),
                    comp->token_index(),
                    comp->function_name(),
                    comp->ArgumentCount(),
                    comp->argument_names(),
                    comp->checked_argument_count());
 }
 
@@ skipping 357 matching lines @@
     if (comp->ElementAt(i)->IsTemp()) {
       __ popq(Address(RCX, i * kWordSize));
     } else {
       LoadValue(RDX, comp->ElementAt(i));
       __ movq(Address(RCX, i * kWordSize), RDX);
     }
   }
 }
 
 
+void FlowGraphCompiler::VisitCreateClosure(CreateClosureComp* comp) {
+  const Function& function = comp->function();
+  const Code& stub = Code::Handle(
+      StubCode::GetAllocationStubForClosure(function));
+  const ExternalLabel label(function.ToCString(), stub.EntryPoint());
+  GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
+
+  const Class& cls = Class::Handle(function.signature_class());
+  if (cls.HasTypeArguments()) {
+    __ popq(RCX);  // Discard type arguments.
+  }
+  if (function.IsImplicitInstanceClosureFunction()) {
+    __ popq(RCX);  // Discard receiver.
+  }
+}
+
+
 void FlowGraphCompiler::VisitBlocks(
     const GrowableArray<BlockEntryInstr*>& blocks) {
   for (intptr_t i = blocks.length() - 1; i >= 0; --i) {
     // Compile the block entry.
     current_block_ = blocks[i];
     Instruction* instr = current_block()->Accept(this);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
@@ skipping 54 matching lines @@
 }
 
 
 void FlowGraphCompiler::VisitReturn(ReturnInstr* instr) {
   LoadValue(RAX, instr->value());
 
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
   __ movq(R10, RBP);
   __ subq(R10, RSP);
-  __ cmpq(R10, Immediate(stack_local_count() * kWordSize));
+  __ cmpq(R10, Immediate(parsed_function_.stack_local_count() * kWordSize));
   Label stack_ok;
   __ j(EQUAL, &stack_ok, Assembler::kNearJump);
   __ Stop("Exit stack size does not match the entry stack size.");
   __ Bind(&stack_ok);
 #endif  // DEBUG.
 
   if (FLAG_trace_functions) {
     __ pushq(RAX);  // Preserve result.
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
@@ skipping 39 matching lines @@
   if (negated) {
     __ j(EQUAL, &block_info_[instr->true_successor()->block_number()]->label);
   } else {
     __ j(NOT_EQUAL,
          &block_info_[instr->false_successor()->block_number()]->label);
   }
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
+  // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
   const Function& function = parsed_function_.function();
-  if ((function.num_optional_parameters() != 0)) {
-    Bailout("function has optional parameters");
-  }
-  LocalScope* scope = parsed_function_.node_sequence()->scope();
-  LocalScope* context_owner = NULL;
+
+  // We don't implement copied parameters yet and should have bailed out
+  // from the graph builder.
+  ASSERT(function.num_optional_parameters() == 0);
   const int parameter_count = function.num_fixed_parameters();
-  const int first_parameter_index = 1 + parameter_count;
-  const int first_local_index = -1;
-  int first_free_frame_index =
-      scope->AllocateVariables(first_parameter_index,
-                               parameter_count,
-                               first_local_index,
-                               scope,
-                               &context_owner);
-  set_stack_local_count(first_local_index - first_free_frame_index);
-
-  // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
-  __ EnterFrame(stack_local_count() * kWordSize);
+  const int local_count = parsed_function_.stack_local_count();
+  __ EnterFrame(local_count * kWordSize);
 #ifdef DEBUG
   const bool check_arguments = true;
 #else
   const bool check_arguments = function.IsClosureFunction();
 #endif
   if (check_arguments) {
     // Check that num_fixed <= argc <= num_params.
     Label argc_in_range;
     // Total number of args is the first Smi in args descriptor array (R10).
     __ movq(RAX, FieldAddress(R10, Array::data_offset()));
     __ cmpq(RAX, Immediate(Smi::RawValue(parameter_count)));
     __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
     if (function.IsClosureFunction()) {
       GenerateCallRuntime(AstNode::kNoId,
                           function.token_index(),
                           kClosureArgumentMismatchRuntimeEntry);
     } else {
       __ Stop("Wrong number of arguments");
     }
     __ Bind(&argc_in_range);
   }
 
   // Initialize locals to null.
-  if (stack_local_count() > 0) {
+  if (local_count > 0) {
     __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(Object::null())));
-    for (int i = 0; i < stack_local_count(); ++i) {
+    const int base = parsed_function_.first_stack_local_index();
+    for (int i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
-      __ movq(Address(RBP, (first_local_index - i) * kWordSize), RAX);
+      __ movq(Address(RBP, (base - i) * kWordSize), RAX);
     }
   }
 
   // Generate stack overflow check.
   __ movq(TMP, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(TMP, 0));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow, Assembler::kNearJump);
   GenerateCallRuntime(AstNode::kNoId,
                       function.token_index(),
@@ skipping 72 matching lines @@
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   // We don't compile exception handlers yet.
   code.set_exception_handlers(
       ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64