Optional arguments in new 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 338 matching lines @@
 //   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();
   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;
+  const int num_copied_params = parsed_function_.copied_parameter_count();
+  const int stack_slot_count = parsed_function_.local_count();
+  set_locals_space_size(stack_slot_count * kWordSize);
 
   // 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);
   __ 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.
   if (num_copied_params == 0) {
+    ASSERT(num_opt_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) {
       // Check that num_fixed <= argc <= num_params.
       Label argc_in_range;
       // Total number of args is the first Smi in args descriptor array (EDX).
       __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
-      if (num_opt_params == 0) {
-        __ cmpl(EAX, Immediate(Smi::RawValue(num_fixed_params)));
-        __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
-      } else {
-        __ subl(EAX, Immediate(Smi::RawValue(num_fixed_params)));
-        __ cmpl(EAX, Immediate(Smi::RawValue(num_opt_params)));
-        __ j(BELOW_EQUAL, &argc_in_range, Assembler::kNearJump);
-      }
+      __ cmpl(EAX, Immediate(Smi::RawValue(num_fixed_params)));
+      __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       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 149 matching lines @@
     __ movl(original_argument_addr, raw_null);
     __ Bind(&null_args_loop_condition);
     __ decl(ECX);
     __ j(POSITIVE, &null_args_loop, Assembler::kNearJump);
   }
 
   // Initialize locals.
   // 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) {
+  const int base = parsed_function_.first_local_index();

[Kevin Millikin (Google), 2012/03/13 12:31:08]

I think with your change to make local_count() include the number of copied
parameters, you will want something like:

const int base = parsed_function_.first_local_index();
const int count =
  parsed_function_.local_count() - parsed_function_.copied_parameter_count();
for (int index = 0; index < count; ++index) ...

Otherwise we're needlessly initializing above the stack pointer (with an
unrolled loop!).

[srdjan, 2012/03/13 16:57:00]

Excluding num_copied_parameters from stack_local_count.

+  for (int index = 0; index < parsed_function_.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.
   __ cmpl(ESP,
           Address::Absolute(Isolate::Current()->stack_limit_address()));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow);
   GenerateCallRuntime(AstNode::kNoId,
                       0,
                       kStackOverflowRuntimeEntry);
@@ skipping 134 matching lines @@
                            node->type(),
                            node->dst_name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
-  if (function.IsNonImplicitClosureFunction()) {
+  if (function.IsNonImplicitClosureFunction() &&
+      (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());
-    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);
     }
   }
+  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