Revert "Deoptimization support in inlined code."

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 48 matching lines @@
   } else {
     exit()->set_next(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
   temp_index_ = other_fragment.temp_index();
 }
 
 
 Value* EffectGraphVisitor::Bind(Definition* definition) {
   ASSERT(is_open());
+  ASSERT(!owner()->InInliningContext() || !definition->CanDeoptimize());
   DeallocateTempIndex(definition->InputCount());
   definition->set_use_kind(Definition::kValue);
   definition->set_temp_index(AllocateTempIndex());
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->set_next(definition);
   }
   exit_ = definition;
   return new Value(definition);
 }
 
 
 void EffectGraphVisitor::Do(Definition* definition) {
   ASSERT(is_open());
+  ASSERT(!owner()->InInliningContext() || !definition->CanDeoptimize());
   DeallocateTempIndex(definition->InputCount());
   definition->set_use_kind(Definition::kEffect);
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->set_next(definition);
   }
   exit_ = definition;
 }
 
@@ skipping 314 matching lines @@
       MergeBranchWithNegate(neg);
       return;
     }
   }
   ReturnValue(Bind(definition));
 }
 
 
 // Special handling for AND/OR.
 void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
+  InlineBailout("TestGraphVisitor::VisitBinaryOpNode");
+
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     TestGraphVisitor for_left(owner(),
                               temp_index(),
                               node->left()->token_pos());
     node->left()->Visit(&for_left);
 
     TestGraphVisitor for_right(owner(),
                                temp_index(),
@@ skipping 32 matching lines @@
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
-    InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
+    InlineBailout("EffectGraphVisitor::VisitReturnNode (finally)");
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const Function& function = owner()->parsed_function().function();
     const bool is_implicit_dynamic_getter =
@@ skipping 136 matching lines @@
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
+  InlineBailout("EffectGraphVisitor::VisitBinaryOpNode (deopt)");
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
 
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
@@ skipping 26 matching lines @@
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
+      InlineBailout("ValueGraphVisitor::VisitBinaryOpNode (type check)");
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
     Value* constant_true = for_right.Bind(new ConstantInstr(bool_true));
     Value* compare =
         for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
                                               right_value,
                                               constant_true));
     for_right.Do(BuildStoreExprTemp(compare));
@@ skipping 49 matching lines @@
   return Bind(new ConstantInstr(Object::ZoneHandle()));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
+  InlineBailout("EffectGraphVisitor::BuildAssertAssignable (deopt)");
   // Build the type check computation.
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(token_pos,
                             &instantiator,
                             &instantiator_type_arguments);
@@ skipping 77 matching lines @@
     } else {
       if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
         result = new ConstantInstr(negate_result ? bool_false : bool_true);
       } else {
         result = new ConstantInstr(negate_result ? bool_true : bool_false);
       }
     }
     ReturnDefinition(result);
     return;
   }
+  InlineBailout("ValueGraphVisitor::BuildTypeTest (deopt)");
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(node->token_pos(),
                             &instantiator,
                             &instantiator_type_arguments);
   }
-  // TODO(zerny): Remove this when issues 5216 and 5217 are fixed.
-  InlineBailout("instance of");
   InstanceOfInstr* instance_of =
       new InstanceOfInstr(node->token_pos(),
                           for_left_value.value(),
                           instantiator,
                           instantiator_type_arguments,
                           node->right()->AsTypeNode()->type(),
                           (node->kind() == Token::kISNOT));
   ReturnDefinition(instance_of);
 }
 
@@ skipping 33 matching lines @@
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     StrictCompareInstr* comp = new StrictCompareInstr(
         node->kind(), for_left_value.value(), for_right_value.value());
     ReturnDefinition(comp);
     return;
   }
+  InlineBailout("EffectGraphVisitor::VisitComparisonNode (deopt)");
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     if (FLAG_enable_type_checks) {
       EqualityCompareInstr* comp = new EqualityCompareInstr(
@@ skipping 41 matching lines @@
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       value =
           Bind(new AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
+  InlineBailout("EffectGraphVisitor::VisitUnaryOpNode (deopt)");
 
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   InstanceCallInstr* call = (node->kind() == Token::kSUB)
       ? new InstanceCallInstr(node->token_pos(),
@@ skipping 99 matching lines @@
 //   e) true-target-0 -> case-statements-join
 //   f) true-target-1 -> case-statements-join
 //   g) case-statements-join
 //   h) [ case-statements ] -> exit-join
 //   i) exit-target -> exit-join
 //   j) exit-join
 //
 // Note: The specification of switch/case is under discussion and may change
 // drastically.
 void EffectGraphVisitor::VisitCaseNode(CaseNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitCaseNode (control)");
+  InlineBailout("EffectGraphVisitor::VisitCaseNode");
   const intptr_t len = node->case_expressions()->length();
   // Create case statements instructions.
   EffectGraphVisitor for_case_statements(owner(), temp_index());
   // Compute start of statements fragment.
   JoinEntryInstr* statement_start = NULL;
   if ((node->label() != NULL) && node->label()->is_continue_target()) {
     // Since a labeled jump continue statement occur in a different case node,
     // allocate JoinNode here and use it as statement start.
     statement_start = node->label()->join_for_continue();
     if (statement_start == NULL) {
@@ skipping 72 matching lines @@
 //                         body:      <Sequence> }
 // The fragment is composed as follows:
 // a) loop-join
 // b) [ test ] -> (body-entry-target, loop-exit-target)
 // c) body-entry-target
 // d) [ body ] -> (continue-join)
 // e) continue-join -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitWhileNode (control)");
+  InlineBailout("EffectGraphVisitor::VisitWhileNode");
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
@@ skipping 17 matching lines @@
 
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitDoWhileNode (control)");
+  InlineBailout("EffectGraphVisitor::VisitDoWhileNode");
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
@@ skipping 30 matching lines @@
 // a) [ initializer ]
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ]
 // f) continue-join (optional)
 // g) [ increment ] -> (loop-join)
 // h) loop-exit-target
 // i) break-join
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitForNode (control)");
+  InlineBailout("EffectGraphVisitor::VisitForNode");
   EffectGraphVisitor for_initializer(owner(), temp_index());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   // Compose body to set any jump labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
@@ skipping 51 matching lines @@
       exit_ = for_test.CreateFalseSuccessor();
     } else {
       for_test.IfFalseGoto(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitJumpNode (control)");
+  InlineBailout("EffectGraphVisitor::VisitJumpNode");
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   // Unchain the context(s) up to the outer context level of the scope which
   // contains the destination label.
   SourceLabel* label = node->label();
@@ skipping 144 matching lines @@
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitInstanceCallNode (deopt)");
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->length() + 1);
   arguments->Add(push_receiver);
 
   BuildPushArguments(*node->arguments(), arguments);
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
   ReturnDefinition(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitStaticCallNode (deopt)");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call =
       new StaticCallInstr(node->token_pos(),
                           node->function(),
                           node->arguments()->names(),
                           arguments);
   ReturnDefinition(call);
 }
 
 
 ClosureCallInstr* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
+  InlineBailout("EffectGraphVisitor::BuildClosureCall (deopt)");
   ValueGraphVisitor for_closure(owner(), temp_index());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
   PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
@@ skipping 12 matching lines @@
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
   ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitCloneContextNode (context)");
+  InlineBailout("EffectGraphVisitor::VisitCloneContextNode (deopt)");
   Value* context = Bind(new CurrentContextInstr());
   Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
   ReturnDefinition(new StoreContextInstr(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
@@ skipping 10 matching lines @@
                                                NULL)) {
     Value* type_arguments = NULL;
     Value* instantiator = NULL;
     BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
 
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
+    InlineBailout("EffectGraphVisitor::BuildObjectAllocation (deopt)");
     allocate_comp = new AllocateObjectWithBoundsCheckInstr(node,
                                                            type_arguments,
                                                            instantiator);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
 
     if (requires_type_arguments) {
       BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
     }
 
     allocate_comp = new AllocateObjectInstr(node, allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
+  InlineBailout("EffectGraphVisitor::BuildConstructorCall (deopt)");
   Value* ctor_arg = Bind(
       new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
@@ skipping 22 matching lines @@
         }
       }
     }
   }
   return kDynamicCid;   // Result cid not known.
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
+  InlineBailout("EffectGraphVisitor::VisitConstructorCallNode (deopt)");
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     StaticCallInstr* call =
         new StaticCallInstr(node->token_pos(),
@@ skipping 77 matching lines @@
     instantiator = BuildInstantiator();
   }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its AbstractTypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already an AbstractTypeArguments object.
   intptr_t type_arguments_instance_field_offset =
       instantiator_class.type_arguments_instance_field_offset();
   ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
 
+  InlineBailout("EffectGraphVisitor::BuildInstantiatorTypeArguments (deopt)");
   return Bind(new LoadFieldInstr(
       instantiator,
       type_arguments_instance_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new ConstantInstr(type_arguments));
   }
+  InlineBailout("EffectGraphVisitor::BuildInstantiatedTypeArguments (deopt)");
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
   return Bind(new InstantiateTypeArgumentsInstr(token_pos,
                                                 type_arguments,
                                                 instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
@@ skipping 99 matching lines @@
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
   Definition* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitInstanceGetterNode (deopt)");
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(
@@ skipping 20 matching lines @@
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitInstanceSetterNode (deopt)");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kSET,
                                                   arguments,
                                                   Array::ZoneHandle(),
                                                   2);  // Checked arg count.
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
+  InlineBailout("ValueGraphVisitor::VisitInstanceSetterNode (deopt)");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallInstr(node->token_pos(),
                            name,
                            Token::kSET,
                            arguments,
                            Array::ZoneHandle(),
                            2));  // Checked argument count.
   ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitStaticGetterNode (deopt)");
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     getter_function =
     Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     ASSERT(!getter_function.IsNull());
     ASSERT(node->receiver() != NULL);
     ValueGraphVisitor receiver_value(owner(), temp_index());
     node->receiver()->Visit(&receiver_value);
     Append(receiver_value);
     arguments->Add(PushArgument(receiver_value.value()));
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
     ASSERT(!getter_function.IsNull());
   }
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
+  InlineBailout("EffectGraphVisitor::VisitStaticSetter (deopt)");
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
   // Unlike a static getter, a super getter has a receiver parameter.
   const bool is_super_setter = (node->receiver() != NULL);
   const Function& setter_function =
       Function::ZoneHandle(is_super_setter
           ? Resolver::ResolveDynamicAnyArgs(node->cls(), setter_name)
           : node->cls().LookupStaticFunction(setter_name));
@@ skipping 188 matching lines @@
   ReturnDefinition(BuildStoreStaticField(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
+  InlineBailout("EffectGraphVisitor::VisitLoadIndexedNode (deopt)");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
   InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kINDEX,
                                                   arguments,
                                                   Array::ZoneHandle(),
                                                   checked_argument_count);
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
+  InlineBailout("EffectGraphVisitor::BuildStoreIndexedValues (deopt)");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
@@ skipping 38 matching lines @@
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
-  InlineBailout("EffectGraphVisitor::UnchainContext (context)");
+  InlineBailout("EffectGraphVisitor::UnchainContext (deopt)");
   Value* context = Bind(new CurrentContextInstr());
   Value* parent = Bind(
       new LoadFieldInstr(context,
                          Context::parent_offset(),
                          Type::ZoneHandle()));  // Not an instance, no type.
   Do(new StoreContextInstr(parent));
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
-    InlineBailout("EffectGraphVisitor::VisitSequenceNode (context)");
+    InlineBailout("EffectGraphVisitor::VisitSequenceNode (deopt)");
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
     Value* allocated_context =
         Bind(new AllocateContextInstr(node->token_pos(),
                                       num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
@@ skipping 117 matching lines @@
   }
 
   // The outermost function sequence cannot contain a label.
   ASSERT((node->label() == NULL) ||
          (node != owner()->parsed_function().node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
+  InlineBailout("EffectGraphVisitor::VisitCatchClauseNode");
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
   Do(new CatchEntryInstr(node->exception_var(), node->stacktrace_var()));
   BuildLoadContext(node->context_var());
 
   EffectGraphVisitor for_catch(owner(), temp_index());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
+  InlineBailout("EffectGraphVisitor::VisitTryCatchNode");
   intptr_t old_try_index = owner()->try_index();
   intptr_t try_index = owner()->AllocateTryIndex();
   owner()->set_try_index(try_index);
 
   // Preserve CTX into local variable '%saved_context'.
   BuildStoreContext(node->context_var());
 
   EffectGraphVisitor for_try_block(owner(), temp_index());
   node->try_block()->Visit(&for_try_block);
 
@@ skipping 71 matching lines @@
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   ReturnDefinition(new ConstantInstr(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode (exception)");
+  InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode");
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
   }
   BuildLoadContext(node->context_var());
 
   JoinEntryInstr* finally_entry = new JoinEntryInstr(owner()->try_index());
@@ skipping 24 matching lines @@
   // Set the inlining context.
   ASSERT(inlining_context_ == kNotInlining);
   inlining_context_ = context;
   if (InInliningContext()) exits_ = new ZoneGrowableArray<ReturnInstr*>();
   // Compilation can be nested, preserve the computation-id.
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry = new TargetEntryInstr(
       CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
-  if (InInliningContext()) {
-    exits_ = new ZoneGrowableArray<ReturnInstr*>();
-  }
   // TODO(kmillikin): We can eliminate stack checks in some cases (e.g., the
   // stack check on entry for leaf routines).
   for_effect.Do(new CheckStackOverflowInstr(function.token_pos()));
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   FlowGraph* graph = new FlowGraph(*this, graph_entry_);
   if (InInliningContext()) graph->set_exits(exits_);
   return graph;
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder 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 = Isolate::Current()->current_zone()->Alloc<char>(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);
 }
 
 
 }  // namespace dart