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

runtime/vm/code_generator_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 320 matching lines @@
   ExternalLabel target_label("InlineCache", label_address);
 
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall,
                        node_id,
                        token_index);
   __ addl(ESP, Immediate(num_arguments * kWordSize));
 }
 
 
-// Call to generate entry code:
-// - compute frame size and setup frame.
-// - allocate local variables on stack.
-// - optionally check if number of arguments match.
-// - initialize all non-argument locals to null.
-//
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of last argument (arg n-1).
 //   ESP + 4*n : address of first argument (arg 0).
 //   EDX : arguments descriptor array.
 void CodeGenerator::GenerateEntryCode() {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   const Function& function = parsed_function_.function();
+
+  // 1. Compute the frame size and enter the frame (reserving local space
+  // for copied incoming and default arguments and stack-allocated local
+  // variables).
+  //
+  // TODO(regis): We may give up reserving space on stack for args/locals
+  // because pushes of initial values may be more effective than moves.
   LocalScope* scope = parsed_function_.node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
-  const int num_params = num_fixed_params + num_opt_params;
-  int first_param_index;
-  int first_local_index;
-  int num_copied_params;
-  // Assign indices to parameters and locals.
-  if (num_params == num_fixed_params) {
-    // No need to copy incoming arguments.
-    // The body of the function will access parameter i at fp[1 + num_fixed - i]
-    // and local variable j at fp[-1 - j].
-    first_param_index = 1 + num_params;
-    first_local_index = -1;
-    num_copied_params = 0;
-  } else {
-    // The body of the function will access copied parameter i at fp[-1 - i]
-    // and local j at fp[-1 - num_params - j].
-    first_param_index = -1;
-    first_local_index = -1 - num_params;
-    num_copied_params = num_params;
-    ASSERT(num_copied_params > 0);
-  }
-
-  // Allocate parameters and local variables, either in the local frame or in
-  // the context(s).
-  LocalScope* context_owner = NULL;  // No context needed so far.
-  int first_free_frame_index =
-      scope->AllocateVariables(first_param_index,
-                               num_params,
-                               first_local_index,
-                               scope,  // Initial loop owner.
-                               &context_owner);
-  // Frame indices are relative to the frame pointer and are decreasing.
-  ASSERT(first_free_frame_index <= first_local_index);
-  const int num_locals = first_local_index - first_free_frame_index;
-
-  // Reserve local space for copied incoming and default arguments and locals.
-  // TODO(regis): We may give up reserving space on stack for args/locals
-  // because pushes of initial values may be more effective than moves.
-  set_locals_space_size((num_copied_params + num_locals) * kWordSize);
+  const int num_copied_params = parsed_function_.copied_parameter_count();
+  const int stack_slot_count =
+      num_copied_params + parsed_function_.stack_local_count();
+  set_locals_space_size(stack_slot_count * kWordSize);
   __ EnterFrame(locals_space_size());
 
-  // We check the number of passed arguments when we have to copy them due to
-  // the presence of optional named parameters.
-  // No such checking code is generated if only fixed parameters are declared,
-  // unless we are debug mode or unless we are compiling a closure.
+  // 2. Optionally check if the number of arguments matches.  We check the
+  // number of passed arguments when we have to copy them due to the
+  // presence of optional named parameters.  No such checking code is
+  // generated if only fixed parameters are declared, unless we are in debug
+  // mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #if defined(DEBUG)
     const bool check_arguments = true;  // Always check arguments in debug mode.
 #else
     // The number of arguments passed to closure functions must always be
     // checked here, because no resolving stub (normally responsible for the
     // check) is involved in closure calls.
     const bool check_arguments = function.IsClosureFunction();
 #endif
     if (check_arguments) {
@@ skipping 12 matching lines @@
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(AstNode::kNoId,
                             0,
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
-    ASSERT(first_param_index == -1);
+    ASSERT(parsed_function_.first_parameter_index() == -1);
     // Copy positional arguments.
     // Check that no fewer than num_fixed_params positional arguments are passed
     // in and that no more than num_params arguments are passed in.
     // Passed argument i at fp[1 + argc - i] copied to fp[-1 - i].
+    const int num_params = num_fixed_params + num_opt_params;
 
     // Total number of args is the first Smi in args descriptor array (EDX).
     __ movl(EBX, FieldAddress(EDX, Array::data_offset()));
     // Check that num_args <= num_params.
     Label wrong_num_arguments;
     __ cmpl(EBX, Immediate(Smi::RawValue(num_params)));
     __ j(GREATER, &wrong_num_arguments);
     // Number of positional args is the second Smi in descriptor array (EDX).
     __ movl(ECX, FieldAddress(EDX, Array::data_offset() + (1 * kWordSize)));
     // Check that num_pos_args >= num_fixed_params.
@@ skipping 145 matching lines @@
     Label null_args_loop, null_args_loop_condition;
     __ jmp(&null_args_loop_condition, Assembler::kNearJump);
     const Address original_argument_addr(EBP, ECX, TIMES_4, 2 * kWordSize);
     __ Bind(&null_args_loop);
     __ movl(original_argument_addr, raw_null);
     __ Bind(&null_args_loop_condition);
     __ decl(ECX);
     __ j(POSITIVE, &null_args_loop, Assembler::kNearJump);
   }
 
-  // Initialize locals.
+  // 3. Initialize (non-argument) stack-allocated locals to null.
+  //
   // TODO(regis): For now, always unroll the init loop. Decide later above
-  // which threshold to implement a loop.
-  // Consider emitting pushes instead of moves.
-  for (int index = first_local_index; index > first_free_frame_index; index--) {
-    if (index == first_local_index) {
+  // which threshold to implement a loop.  Consider emitting pushes instead
+  // of moves.
+  const int base = parsed_function_.first_stack_local_index();
+  for (int index = 0; index < parsed_function_.stack_local_count(); ++index) {
+    if (index == 0) {
       __ movl(EAX, raw_null);
     }
-    __ movl(Address(EBP, index * kWordSize), EAX);
+    __ movl(Address(EBP, (base - index) * kWordSize), EAX);
   }
 
-  // Generate stack overflow check.
+  // 4. Generate the stack overflow check.
   __ cmpl(ESP,
           Address::Absolute(Isolate::Current()->stack_limit_address()));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow);
   GenerateCallRuntime(AstNode::kNoId,
                       0,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
@@ skipping 132 matching lines @@
                            node->dst_name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
   if (function.IsNonImplicitClosureFunction()) {
-    const int current_context_level = state()->context_level();
-    const ContextScope& context_scope = ContextScope::ZoneHandle(
-        node->scope()->PreserveOuterScope(current_context_level));
-    ASSERT(!function.HasCode());
-    ASSERT(function.context_scope() == ContextScope::null());
-    function.set_context_scope(context_scope);
-  } else {
-    ASSERT(function.context_scope() != ContextScope::null());
-    if (function.IsImplicitInstanceClosureFunction()) {
-      node->receiver()->Visit(this);
+    // The context scope may have already been set by the new non-optimizing
+    // compiler.  If it was not, set it here.
+    if (function.context_scope() == ContextScope::null()) {
+      const int current_context_level = state()->context_level();
+      const ContextScope& context_scope = ContextScope::ZoneHandle(
+          node->scope()->PreserveOuterScope(current_context_level));
+      ASSERT(!function.HasCode());
+      function.set_context_scope(context_scope);
     }
+  } else if (function.IsImplicitInstanceClosureFunction()) {
+    node->receiver()->Visit(this);
   }
+  ASSERT(function.context_scope() != ContextScope::null());
+
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     GenerateInstantiatorTypeArguments(node->token_index());
   }
   const Code& stub = Code::Handle(
@@ skipping 1894 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32