Do not clear the spill slots in optimized code.

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 "lib/error.h"
@@ skipping 752 matching lines @@
     __ jmp(&all_arguments_processed, Assembler::kNearJump);
   }
 
   __ Bind(&wrong_num_arguments);
   if (StackSize() != 0) {
     // We need to unwind the space we reserved for locals and copied parameters.
     // The NoSuchMethodFunction stub does not expect to see that area on the
     // stack.
     __ addq(RSP, Immediate(StackSize() * kWordSize));
   }
+  // The calls immediately below have empty stackmaps because we have just
+  // dropped the spill slots.
+  BitmapBuilder* empty_stack_bitmap = new BitmapBuilder();
   if (function.IsClosureFunction()) {
     GenerateCallRuntime(Isolate::kNoDeoptId,
                         0,
                         CatchClauseNode::kInvalidTryIndex,
                         kClosureArgumentMismatchRuntimeEntry,
-                        NULL);
+                        empty_stack_bitmap);
   } else {
     ASSERT(!IsLeaf());
     // Invoke noSuchMethod function.
     const int kNumArgsChecked = 1;
     ICData& ic_data = ICData::ZoneHandle();
     ic_data = ICData::New(function,
                           String::Handle(function.name()),
                           Isolate::kNoDeoptId,
                           kNumArgsChecked);
     __ LoadObject(RBX, ic_data);
     // RBP - 8 : PC marker, allows easy identification of RawInstruction obj.
     // 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 (is_optimizing()) {
+      stackmap_table_builder_->AddEntry(assembler()->CodeSize(),
+                                        empty_stack_bitmap);
+    }
   }
 
   if (FLAG_trace_functions) {
     __ pushq(RAX);  // Preserve result.
     __ PushObject(Function::ZoneHandle(function.raw()));
     GenerateCallRuntime(Isolate::kNoDeoptId,
                         0,
                         CatchClauseNode::kInvalidTryIndex,
                         kTraceFunctionExitRuntimeEntry,
-                        NULL);
+                        empty_stack_bitmap);
     __ 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
@@ skipping 81 matching lines @@
 
   const int parameter_count = function.num_fixed_parameters();
   const int copied_parameter_count = parsed_function().copied_parameter_count();
   const int local_count = parsed_function().stack_local_count();
   __ Comment("Enter frame");
   if (IsLeaf()) {
     AssemblerMacros::EnterDartLeafFrame(assembler(), (StackSize() * kWordSize));
   } else {
     AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
   }
+
+  // For optimized code, keep a bitmap of the frame in order to build
+  // stackmaps for GC safepoints in the prologue.
+  BitmapBuilder* stack_bitmap = NULL;
+  if (is_optimizing()) {
+    // Spill slots are allocated but not initialized.
+    stack_bitmap = new BitmapBuilder();
+    stack_bitmap->SetLength(StackSize());
+  }
+
   // 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 (copied_parameter_count == 0) {
 #ifdef DEBUG
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
 #endif
     if (check_arguments) {
       __ Comment("Check argument count");
       // 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(Isolate::kNoDeoptId,
                             function.token_pos(),
                             CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry,
-                            NULL);
+                            stack_bitmap);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     CopyParameters();
   }
 
-  // Initialize (non-argument) stack allocated slots to null.
-  //
-  // TODO(vegorov): introduce stack maps and stop initializing all spill slots
-  // with null.
-  intptr_t uninitialized_slot_count;
-  if (is_optimizing()) {
-    GraphEntryInstr* entry = block_order_[0]->AsGraphEntry();
-    uninitialized_slot_count =
-        entry->spill_slot_count() - copied_parameter_count;
-  } else {
-    uninitialized_slot_count = local_count;
-  }
-  const intptr_t slot_base = parsed_function().first_stack_local_index();
-
-  if (uninitialized_slot_count > 0) {
+  // In unoptimized code, initialize (non-argument) stack allocated slots to
+  // null.
+  if (!is_optimizing() && (local_count > 0)) {
     __ Comment("Initialize spill slots");

[Vyacheslav Egorov (Google), 2012/08/22 13:22:08]

Initialize locals

+    const intptr_t slot_base = parsed_function().first_stack_local_index();
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ movq(RAX, raw_null);
-    for (intptr_t i = 0; i < uninitialized_slot_count; ++i) {
+    for (intptr_t i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (slot_base - i) * kWordSize), RAX);
     }
   }
 
   if (FLAG_print_scopes) {
     // Print the function scope (again) after generating the prologue in order
     // to see annotations such as allocation indices of locals.
     if (FLAG_print_ast) {
       // Second printing.
@@ skipping 31 matching lines @@
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos, try_index);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t deopt_id,
                                             intptr_t token_pos,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry,
                                             BitmapBuilder* stack_bitmap) {
   ASSERT(!IsLeaf());
+  ASSERT(!is_optimizing() || (stack_bitmap != NULL));
   __ CallRuntime(entry);
-  if (is_optimizing() && (stack_bitmap != NULL)) {
+  if (is_optimizing()) {
     stackmap_table_builder_->AddEntry(assembler()->CodeSize(), stack_bitmap);
   }
   AddCurrentDescriptor(PcDescriptors::kOther, deopt_id, token_pos, try_index);
 }
 
 
 intptr_t FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                              const ICData& ic_data,
                                              const Array& arguments_descriptor,
                                              intptr_t argument_count) {
@@ skipping 176 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64