Reapply "Deoptimization support in inlined code."

runtime/vm/flow_graph.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/flow_graph.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 496 matching lines @@
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
     start_env.Add(param);
   }
 
   // All locals are initialized with #null.  Use the global definition, uses
   // will be created in the Environment constructor.
   while (start_env.length() < variable_count()) {
     start_env.Add(graph_entry_->constant_null());
   }
   graph_entry_->set_start_env(
-      Environment::From(start_env, num_non_copied_params_, NULL));
+      Environment::From(start_env,
+                        num_non_copied_params_,
+                        parsed_function_.function()));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   GrowableArray<Definition*> env(variable_count());
   env.AddArray(start_env);
   RenameRecursive(normal_entry, &env, live_phis);
 }
 
 
 void FlowGraph::RenameRecursive(BlockEntryInstr* block_entry,
@@ skipping 12 matching lines @@
       }
     }
   }
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instruction. First, each instruction
     // gets a full copy of the environment. Later we optimize this by
     // eliminating unnecessary environments.
-    current->set_env(
-        Environment::From(*env, num_non_copied_params_, NULL));
+    current->set_env(Environment::From(*env,
+                                       num_non_copied_params_,
+                                       parsed_function_.function()));
+    if (current->CanDeoptimize()) {
+      current->env()->set_deopt_id(current->deopt_id());
+    }
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
@@ skipping 209 matching lines @@
   // TODO(zerny): Implement support for callee graphs with control flow.
   ASSERT(callee_graph->preorder().length() == 2);
 
   // Adjust the SSA temp index by the callee graph's index.
   current_ssa_temp_index_ = callee_graph->max_virtual_register_number();
 
   BlockEntryInstr* caller_entry = GetBlockEntry(call);
   TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
   ZoneGrowableArray<ReturnInstr*>* callee_exits = callee_graph->exits();
 
+  // 0. Attach the outer environment on each instruction in the callee graph.
+  for (ForwardInstructionIterator it(callee_entry); !it.Done(); it.Advance()) {
+    Instruction* instr = it.Current();
+    if (instr->CanDeoptimize()) call->env()->DeepCopyToOuter(instr);
+  }
+
   // 1. Insert the callee graph into the caller graph.
   if (callee_exits->is_empty()) {
     // If no normal exits exist, inline and truncate the block after inlining.
     Link(call->previous(), callee_entry->next());
     caller_entry->set_last_instruction(callee_entry->last_instruction());
   } else if (callee_exits->length() == 1) {
     ReturnInstr* exit = (*callee_exits)[0];
     // TODO(zerny): Support one exit graph containing control flow.
     ASSERT(callee_entry == GetBlockEntry(exit));
     // For just one exit, replace the uses and remove the call from the graph.
     call->ReplaceUsesWith(exit->value()->definition());
     Link(call->previous(), callee_entry->next());
     Link(exit->previous(), call->next());
   } else {
     // TODO(zerny): Support multiple exits.
     UNREACHABLE();
   }
 
   // TODO(zerny): Adjust pre/post orders.
   // TODO(zerny): Update dominator tree.
 }
 
 
 }  // namespace dart