Use the inner deoptimization frame when setting incoming arguments.

runtime/vm/flow_graph_compiler.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_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
@@ skipping 59 matching lines @@
 
   const Function& function = compiler->parsed_function().function();
   // For functions with optional arguments, all incoming arguments are copied
   // to spill slots. The deoptimization environment does not track them.
   const intptr_t incoming_arg_count =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   DeoptInfoBuilder builder(compiler->object_table(), incoming_arg_count);
 
   intptr_t slot_ix = 0;
   Environment* env = deoptimization_env_;
-  while (env != NULL) {
-    const Function& function = env->function();
-    const intptr_t fixed_parameter_count = env->fixed_parameter_count();
 
-    if (slot_ix == 0) {
-      // For the innermost environment call the virtual return builder.
-      BuildReturnAddress(&builder, function, slot_ix++);
-    } else {
-      // For any outer environment the deopt id is that of the call instruction
-      // which is recorded in the outer environment.
-      builder.AddReturnAddressAfter(function, env->deopt_id(), slot_ix++);
-    }
+  // For the innermost environment, call the virtual return builder.
+  BuildReturnAddress(&builder, env->function(), slot_ix++);
 
-    for (intptr_t i = env->Length() - 1; i >= fixed_parameter_count; i--) {
+  // For the innermost environment, set outgoing arguments and the locals.
+  for (intptr_t i = env->Length() - 1; i >= env->fixed_parameter_count(); i--) {
+    builder.AddCopy(env->LocationAt(i), *env->ValueAt(i), slot_ix++);
+  }
+
+  // PC marker and caller FP.
+  builder.AddPcMarker(env->function(), slot_ix++);
+  builder.AddCallerFp(slot_ix++);
+
+  while (env->outer() != NULL) {
+    const Environment* outer = env->outer();
+
+    // For any outer environment the deopt id is that of the call instruction
+    // which is recorded in the outer environment.
+    builder.AddReturnAddressAfter(outer->function(),
+                                  outer->deopt_id(),
+                                  slot_ix++);
+
+    // Set incoming arguments from the inner frame.

[Vyacheslav Egorov (Google), 2012/09/21 14:38:30]

Please add a comment that clarifies that values of incoming arguments can be
changed by the inner function and thus they have to be taken from the inner
frame.

[zerny-google, 2012/09/21 14:55:47]

Done.

+    for (intptr_t i = env->fixed_parameter_count() - 1; i >= 0; i--) {
       builder.AddCopy(env->LocationAt(i), *env->ValueAt(i), slot_ix++);
     }
 
+    // Set the locals, not including the outgoing arguments.

[Vyacheslav Egorov (Google), 2012/09/21 14:38:30]

I would add an assertion here that outer->Length() is bigger than
inner->fixed_parameter_count().

[zerny-google, 2012/09/21 14:55:47]

Done.

+    for (intptr_t i = outer->Length() - env->fixed_parameter_count() - 1;
+         i >= outer->fixed_parameter_count();
+         i--) {
+      builder.AddCopy(outer->LocationAt(i), *outer->ValueAt(i), slot_ix++);
+    }
+
     // PC marker and caller FP.
-    builder.AddPcMarker(function, slot_ix++);
+    builder.AddPcMarker(outer->function(), slot_ix++);
     builder.AddCallerFp(slot_ix++);
 
-    // On the outermost environment set caller PC and incoming arguments.
-    if (env->outer() == NULL) {
-      builder.AddCallerPc(slot_ix++);
-      for (intptr_t i = fixed_parameter_count - 1; i >= 0; i--) {
-        builder.AddCopy(env->LocationAt(i), *env->ValueAt(i), slot_ix++);
-      }
-    }
-
     // Iterate on the outer environment.
     env = env->outer();
   }
 
+  // For the outermost environment, set caller PC.
+  builder.AddCallerPc(slot_ix++);
+
+  // For the outermost environment, set the incoming arguments.
+  for (intptr_t i = env->fixed_parameter_count() - 1; i >= 0; i--) {
+    builder.AddCopy(env->LocationAt(i), *env->ValueAt(i), slot_ix++);
+  }
+
   const DeoptInfo& deopt_info = DeoptInfo::Handle(builder.CreateDeoptInfo());
   return deopt_info.raw();
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(Assembler* assembler,
                                      const FlowGraph& flow_graph,
                                      bool is_optimizing,
                                      bool is_leaf)
     : assembler_(assembler),
@@ skipping 753 matching lines @@
     case ABOVE:         return unsigned_left > unsigned_right;
     case ABOVE_EQUAL:   return unsigned_left >= unsigned_right;
     default:
       UNIMPLEMENTED();
       return false;
   }
 }
 
 
 }  // namespace dart