Deoptimization support in inlined code.

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 27 matching lines @@
 }
 
 
 void CompilerDeoptInfoWithStub::BuildReturnAddress(DeoptInfoBuilder* builder,
                                                    const Function& function,
                                                    intptr_t slot_ix) {
   builder->AddReturnAddressBefore(function, deopt_id(), slot_ix);
 }
 
 
+// Assign locations to outgoing arguments, i.e., values pushed above spill slots
+// with PushArgument.  Recursively allocates from outer most to inner most

[Kevin Millikin (Google), 2012/09/18 11:01:55]

"outer most" ==> "outermost", "inner most" ==> "innermost".

[zerny-google, 2012/09/18 11:53:07]

Done.

+// environment.
+void CompilerDeoptInfo::AllocateIncommingParametersRecusive(
+    Environment* env,
+    intptr_t* stack_height) {
+  if (env == NULL) return;
+  AllocateIncommingParametersRecusive(env->outer(), stack_height);
+  for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
+    if (it.CurrentLocation().IsInvalid()) {
+      ASSERT(it.CurrentValue()->definition()->IsPushArgument());
+      it.SetCurrentLocation(Location::StackSlot((*stack_height)++));
+    }
+  }
+}
+
+
 RawDeoptInfo* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler) {
   if (deoptimization_env_ == NULL) return DeoptInfo::null();
+
+  intptr_t stack_height = compiler->StackSize();
+  AllocateIncommingParametersRecusive(deoptimization_env_, &stack_height);
+
   const Function& function = compiler->parsed_function().function();
-  // For functions with optional arguments, all incoming are copied to local
-  // area below FP, deoptimization environment does not track them.
-  const intptr_t num_args =
+  const intptr_t num_incoming_args =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
-  const intptr_t fixed_parameter_count =
-      deoptimization_env_->fixed_parameter_count();
-  DeoptInfoBuilder builder(compiler->object_table(), num_args);
+  DeoptInfoBuilder builder(compiler->object_table(), num_incoming_args);
 
   intptr_t slot_ix = 0;
-  BuildReturnAddress(&builder, function, slot_ix++);
+  Environment* env = deoptimization_env_;
+  while (env != NULL) {
+    const Function& function = env->function();
 
-  // Assign locations to values pushed above spill slots with PushArgument.
-  intptr_t height = compiler->StackSize();
-  for (intptr_t i = 0; i < deoptimization_env_->Length(); i++) {
-    if (deoptimization_env_->LocationAt(i).IsInvalid()) {
-      ASSERT(deoptimization_env_->ValueAt(i)->definition()->IsPushArgument());
-      *deoptimization_env_->LocationSlotAt(i) = Location::StackSlot(height++);
+    // For functions with optional arguments, all incoming are copied to local

[Kevin Millikin (Google), 2012/09/18 11:01:55]

Hmm.  I would say they're "above" the frame pointer on the stack (e.g., at a
lower address).  I tend to avoid above and below, so you could say they are
copied to spill slots.

I don't understand the part about tracking in the deoptimization environment. 
They are tracked, as part of the spill slots, right?

[zerny-google, 2012/09/18 11:53:07]

Also, the this comment is for num_incoming_args (renamed incoming_args_count).

+    // area below FP, deoptimization environment does not track them.
+    const intptr_t fixed_parameter_count = env->fixed_parameter_count();
+
+    if (slot_ix == 0) {
+      // For the inner-most environment call the virutal return builder.

[Kevin Millikin (Google), 2012/09/18 11:01:55]

"virutal" ==> "virtual".

[zerny-google, 2012/09/18 11:53:07]

Done.

+      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 (intptr_t i = deoptimization_env_->Length() - 1;
-       i >= fixed_parameter_count;
-       i--) {
-    builder.AddCopy(deoptimization_env_->LocationAt(i),
-                    *deoptimization_env_->ValueAt(i),
-                    slot_ix++);
-  }
+    for (intptr_t i = env->Length() - 1; i >= fixed_parameter_count; i--) {
+      builder.AddCopy(env->LocationAt(i), *env->ValueAt(i), slot_ix++);
+    }
 
-  // PC marker, caller-fp, caller-pc.
-  builder.AddPcMarker(function, slot_ix++);
-  builder.AddCallerFp(slot_ix++);
-  builder.AddCallerPc(slot_ix++);
-  // Incoming arguments.
-  for (intptr_t i = fixed_parameter_count - 1; i >= 0; i--) {
-    builder.AddCopy(deoptimization_env_->LocationAt(i),
-                    *deoptimization_env_->ValueAt(i),
-                    slot_ix++);
+    // PC marker and caller FP.
+    builder.AddPcMarker(function, slot_ix++);
+    builder.AddCallerFp(slot_ix++);
+
+    // On the outer-most 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();
   }
 
   const DeoptInfo& deopt_info = DeoptInfo::Handle(builder.CreateDeoptInfo());
   return deopt_info.raw();
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(Assembler* assembler,
                                      const FlowGraph& flow_graph,
                                      bool is_optimizing,
@@ skipping 237 matching lines @@
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
   ASSERT(pc_descriptors_list_ != NULL);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
-  descriptors.Verify(parsed_function_.function().is_optimizable());
+  if (!is_optimizing_) descriptors.Verify(parsed_function_.function());
   code.set_pc_descriptors(descriptors);
 }
 
 
 void FlowGraphCompiler::FinalizeDeoptInfo(const Code& code) {
   const Array& array =
       Array::Handle(Array::New(deopt_infos_.length(), Heap::kOld));
   DeoptInfo& info = DeoptInfo::Handle();
   for (intptr_t i = 0; i < deopt_infos_.length(); i++) {
     info = deopt_infos_[i]->CreateDeoptInfo(this);
@@ skipping 497 matching lines @@
     case ABOVE:         return unsigned_left > unsigned_right;
     case ABOVE_EQUAL:   return unsigned_left >= unsigned_right;
     default:
       UNIMPLEMENTED();
       return false;
   }
 }
 
 
 }  // namespace dart