Optional arguments in new 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 29 matching lines @@
 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) {
     ASSERT(!block_info_[i]->label.IsLinked());
     ASSERT(!block_info_[i]->label.HasNear());
   }
 }
 
 
+intptr_t FlowGraphCompiler::StackSize() const {
+  return parsed_function_.stack_local_count() +
+      parsed_function_.copied_parameter_count();
+}
+
+
 void FlowGraphCompiler::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphCompiler Bailout: %s %s.";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
@@ skipping 590 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(parsed_function_.stack_local_count() * kWordSize));
+  __ cmpq(R10, Immediate(StackSize() * 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 38 matching lines @@
   __ cmpq(RAX, RDX);
   if (negated) {
     __ j(EQUAL, &block_info_[instr->true_successor()->block_number()]->label);
   } else {
     __ j(NOT_EQUAL,
          &block_info_[instr->false_successor()->block_number()]->label);
   }
 }
 
 
+// Coped from CodeGenerator::CopyParameters (CodeGenerator will be deprecated).
+void FlowGraphCompiler::CopyParameters() {
+  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();
+  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 (R10).
+  __ movq(RBX, FieldAddress(R10, Array::data_offset()));
+  // Check that num_args <= num_params.
+  Label wrong_num_arguments;
+  __ cmpq(RBX, Immediate(Smi::RawValue(num_params)));
+  __ j(GREATER, &wrong_num_arguments);
+  // Number of positional args is the second Smi in descriptor array (R10).
+  __ movq(RCX, FieldAddress(R10, Array::data_offset() + (1 * kWordSize)));
+  // Check that num_pos_args >= num_fixed_params.
+  __ cmpq(RCX, Immediate(Smi::RawValue(num_fixed_params)));
+  __ j(LESS, &wrong_num_arguments);
+  // Since RBX and RCX are Smi, use TIMES_4 instead of TIMES_8.
+  // Let RBX point to the last passed positional argument, i.e. to
+  // fp[1 + num_args - (num_pos_args - 1)].
+  __ subq(RBX, RCX);
+  __ leaq(RBX, Address(RBP, RBX, TIMES_4, 2 * kWordSize));
+  // Let RDI point to the last copied positional argument, i.e. to
+  // fp[-1 - (num_pos_args - 1)].
+  __ SmiUntag(RCX);
+  __ movq(RAX, RCX);
+  __ negq(RAX);
+  __ leaq(RDI, Address(RBP, RAX, TIMES_8, 0));
+  Label loop, loop_condition;
+  __ jmp(&loop_condition, Assembler::kNearJump);
+  // We do not use the final allocation index of the variable here, i.e.
+  // scope->VariableAt(i)->index(), because captured variables still need
+  // to be copied to the context that is not yet allocated.
+  const Address argument_addr(RBX, RCX, TIMES_8, 0);
+  const Address copy_addr(RDI, RCX, TIMES_8, 0);
+  __ Bind(&loop);
+  __ movq(RAX, argument_addr);
+  __ movq(copy_addr, RAX);
+  __ Bind(&loop_condition);
+  __ decq(RCX);
+  __ j(POSITIVE, &loop, Assembler::kNearJump);
+
+  // Copy or initialize optional named arguments.
+  ASSERT(num_opt_params > 0);  // Or we would not have to copy arguments.
+  // Start by alphabetically sorting the names of the optional parameters.
+  LocalVariable** opt_param = new LocalVariable*[num_opt_params];
+  int* opt_param_position = new int[num_opt_params];
+  for (int pos = num_fixed_params; pos < num_params; pos++) {
+    LocalVariable* parameter = scope->VariableAt(pos);
+    const String& opt_param_name = parameter->name();
+    int i = pos - num_fixed_params;
+    while (--i >= 0) {
+      LocalVariable* param_i = opt_param[i];
+      const intptr_t result = opt_param_name.CompareTo(param_i->name());
+      ASSERT(result != 0);
+      if (result > 0) break;
+      opt_param[i + 1] = opt_param[i];
+      opt_param_position[i + 1] = opt_param_position[i];
+    }
+    opt_param[i + 1] = parameter;
+    opt_param_position[i + 1] = pos;
+  }
+  // Generate code handling each optional parameter in alphabetical order.
+  // Total number of args is the first Smi in args descriptor array (R10).
+  __ movq(RBX, FieldAddress(R10, Array::data_offset()));
+  // Number of positional args is the second Smi in descriptor array (R10).
+  __ movq(RCX, FieldAddress(R10, Array::data_offset() + (1 * kWordSize)));
+  __ SmiUntag(RCX);
+  // Let RBX point to the first passed argument, i.e. to fp[1 + argc - 0].
+  __ leaq(RBX, Address(RBP, RBX, TIMES_4, kWordSize));  // RBX is Smi.
+  // Let EDI point to the name/pos pair of the first named argument.
+  __ leaq(RDI, FieldAddress(R10, Array::data_offset() + (2 * kWordSize)));
+  for (int i = 0; i < num_opt_params; i++) {
+    // Handle this optional parameter only if k or fewer positional arguments
+    // have been passed, where k is the position of this optional parameter in
+    // the formal parameter list.
+    Label load_default_value, assign_optional_parameter, next_parameter;
+    const int param_pos = opt_param_position[i];
+    __ cmpq(RCX, Immediate(param_pos));
+    __ j(GREATER, &next_parameter, Assembler::kNearJump);
+    // Check if this named parameter was passed in.
+    __ movq(RAX, Address(RDI, 0));  // Load RAX with the name of the argument.
+    __ CompareObject(RAX, opt_param[i]->name());
+    __ j(NOT_EQUAL, &load_default_value, Assembler::kNearJump);
+    // Load RAX with passed-in argument at provided arg_pos, i.e. at
+    // fp[1 + argc - arg_pos].
+    __ movq(RAX, Address(RDI, kWordSize));  // RAX is arg_pos as Smi.
+    __ addq(RDI, Immediate(2 * kWordSize));  // Point to next name/pos pair.
+    __ negq(RAX);
+    Address argument_addr(RBX, RAX, TIMES_4, 0);  // RAX is a negative Smi.
+    __ movq(RAX, argument_addr);
+    __ jmp(&assign_optional_parameter, Assembler::kNearJump);
+    __ Bind(&load_default_value);
+    // Load RAX with default argument at pos.
+    const Object& value = Object::ZoneHandle(
+        parsed_function_.default_parameter_values().At(
+            param_pos - num_fixed_params));
+    __ LoadObject(RAX, value);
+    __ Bind(&assign_optional_parameter);
+    // Assign RAX to fp[-1 - param_pos].
+    // We do not use the final allocation index of the variable here, i.e.
+    // scope->VariableAt(i)->index(), because captured variables still need
+    // to be copied to the context that is not yet allocated.
+    const Address param_addr(RBP, (-1 - param_pos) * kWordSize);
+    __ movq(param_addr, RAX);
+    __ Bind(&next_parameter);
+  }
+  delete[] opt_param;
+  delete[] opt_param_position;
+  // Check that RDI now points to the null terminator in the array descriptor.
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  Label all_arguments_processed;
+  __ cmpq(Address(RDI, 0), raw_null);
+  __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
+
+  __ Bind(&wrong_num_arguments);
+  if (function.IsClosureFunction()) {
+    GenerateCallRuntime(AstNode::kNoId,
+                        0,
+                        kClosureArgumentMismatchRuntimeEntry);
+  } else {
+    // Invoke noSuchMethod function.
+    const int kNumArgsChecked = 1;
+    ICData& ic_data = ICData::ZoneHandle();
+    ic_data = ICData::New(parsed_function_.function(),
+                          String::Handle(function.name()),
+                          AstNode::kNoId,
+                          kNumArgsChecked);
+    __ LoadObject(RBX, ic_data);
+    // RBP : points to previous frame pointer.
+    // RBP + 8 : points to return address.
+    // RBP + 16 : address of last argument (arg n-1).
+    // RSP + 16 + 8*(n-1) : address of first argument (arg 0).
+    // RBX : ic-data.
+    // R10 : arguments descriptor array.
+    __ call(&StubCode::CallNoSuchMethodFunctionLabel());
+  }
+
+  if (FLAG_trace_functions) {
+    __ pushq(RAX);  // Preserve result.
+    __ PushObject(Function::ZoneHandle(function.raw()));
+    GenerateCallRuntime(AstNode::kNoId,
+                        0,
+                        kTraceFunctionExitRuntimeEntry);
+    __ popq(RAX);  // Remove argument.
+    __ popq(RAX);  // Restore result.
+  }
+  __ LeaveFrame();
+  __ ret();
+
+  __ Bind(&all_arguments_processed);
+  // Nullify originally passed arguments only after they have been copied and
+  // checked, otherwise noSuchMethod would not see their original values.
+  // This step can be skipped in case we decide that formal parameters are
+  // implicitly final, since garbage collecting the unmodified value is not
+  // an issue anymore.
+
+  // R10 : arguments descriptor array.
+  // Total number of args is the first Smi in args descriptor array (R10).
+  __ movq(RCX, FieldAddress(R10, Array::data_offset()));
+  __ SmiUntag(RCX);
+  Label null_args_loop, null_args_loop_condition;
+  __ jmp(&null_args_loop_condition, Assembler::kNearJump);
+  const Address original_argument_addr(RBP, RCX, TIMES_8, 2 * kWordSize);
+  __ Bind(&null_args_loop);
+  __ movq(original_argument_addr, raw_null);
+  __ Bind(&null_args_loop_condition);
+  __ decq(RCX);
+  __ j(POSITIVE, &null_args_loop, Assembler::kNearJump);
+}
+
+
+// TODO(srdjan): Investigate where to put the argument type checks for
+// checked mode.
 void FlowGraphCompiler::CompileGraph() {
   // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
   const Function& function = parsed_function_.function();
 
-  // 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 num_opt_params = function.num_optional_parameters();
+  const int num_copied_params = parsed_function_.copied_parameter_count();
   const int local_count = parsed_function_.stack_local_count();
-  __ EnterFrame(local_count * kWordSize);
+  __ EnterFrame(StackSize() * kWordSize);
+
+  // 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) {
 #ifdef DEBUG
-  const bool check_arguments = true;
+    const bool check_arguments = true;
 #else
-  const bool check_arguments = function.IsClosureFunction();
+    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");
+    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);
     }
-    __ Bind(&argc_in_range);
+  } else {
+    CopyParameters();
   }
 
   // Initialize locals to null.
   if (local_count > 0) {
     __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(Object::null())));
     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, (base - i) * kWordSize), RAX);
     }
@@ skipping 81 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