Revert "Inlining of static calls with trivial function bodies."

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 22 matching lines @@
   : parsed_function_(parsed_function),
     copied_parameter_count_(parsed_function.copied_parameter_count()),
     // All parameters are copied if any parameter is.
     non_copied_parameter_count_((copied_parameter_count_ == 0)
         ? parsed_function.function().num_fixed_parameters()
         : 0),
     stack_local_count_(parsed_function.stack_local_count()),
     context_level_(0),
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
     try_index_(CatchClauseNode::kInvalidTryIndex),
-    graph_entry_(NULL),
-    inlining_context_(kNotInlining),
-    exits_(NULL) { }
+    graph_entry_(NULL) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(TargetEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
@@ skipping 278 matching lines @@
   }
   ReturnValue(Bind(computation));
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
-void EffectGraphVisitor::InlineBailout(const char* reason) {
-  if (owner()->InInliningContext()) owner()->Bailout(reason);
-}
-
-
 // <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 (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) {
-    InlineBailout("EffectGraphVisitor::VisitReturnNode (type check)");
     const Function& function = owner()->parsed_function().function();
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kConstImplicitGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
@@ skipping 14 matching lines @@
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
-  ReturnInstr* return_instr = new ReturnInstr(node->token_pos(), return_value);
-  AddReturnExit(return_instr);
-  AddInstruction(return_instr);
+  AddInstruction(new ReturnInstr(node->token_pos(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnComputation(new ConstantComp(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is Dynamic or if the compile type of the value is a subtype
 // of the destination type.
 bool EffectGraphVisitor::CanSkipTypeCheck(intptr_t token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
-  InlineBailout("EffectGraphVisitor::CanSkipTypeCheck");
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // If the destination type is malformed, a dynamic type error must be thrown
   // at run time.
   if (dst_type.IsMalformed()) {
     return false;
   }
 
   // Any type is more specific than the Dynamic type and than the Object type.
@@ skipping 27 matching lines @@
                                      eliminated);
   }
   return eliminated;
 }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitAssignableNode");
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitAssignableNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->expr()->token_pos(),
                                    for_value.value(),
                                    node->type(),
                                    node->dst_name()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitBinaryOpNode");
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(),
                               temp_index(),
                               node->left()->token_pos());
     node->left()->Visit(&for_left);
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
@@ skipping 25 matching lines @@
                                                 node->kind(),
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 2);
   ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitBinaryOpNode");
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
@@ skipping 40 matching lines @@
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
-  InlineBailout("EffectGraphVisitor::VisitBinaryOpNode");
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, NULL);
   } else {
     // Preserve instantiator.
     const LocalVariable& expr_temp =
         *owner()->parsed_function().expression_temp_var();
     instantiator = Bind(BuildStoreLocal(expr_temp, instantiator));
     Value* loaded = Bind(BuildLoadLocal(expr_temp));
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
-  InlineBailout("EffectGraphVisitor::BuildNullValue");
   return Bind(new ConstantComp(Object::ZoneHandle()));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
-  InlineBailout("EffectGraphVisitor::BuildAssertAssignable");
   // 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);
   }
   return new AssertAssignableComp(token_pos,
                                   value,
                                   instantiator,
                                   instantiator_type_arguments,
                                   dst_type,
                                   dst_name);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
-  InlineBailout("EffectGraphVisitor::BuildAssignableValue");
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
     return value;
   }
   return Bind(BuildAssertAssignable(token_pos, value, dst_type, dst_name));
 }
 
 
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
-  InlineBailout("EffectGraphVisitor::BuildTypeTest");
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
-  InlineBailout("EffectGraphVisitor::BuildTypeCast");
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastExceptionDstName));
   if (!CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
     Do(BuildAssertAssignable(
         node->token_pos(), for_value.value(), type, dst_name));
   }
 }
 
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
-  InlineBailout("ValueGraphVisitor::BuildTypeTest");
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
@@ skipping 46 matching lines @@
                          for_left_value.value(),
                          instantiator,
                          instantiator_type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
-  InlineBailout("ValueGraphVisitor::BuildTypeCast");
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastExceptionDstName));
   ReturnValue(BuildAssignableValue(node->token_pos(),
                                    for_value.value(),
                                    type,
                                    dst_name));
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitComparisonNode");
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
     return;
   }
   if (Token::IsTypeCastOperator(node->kind())) {
     BuildTypeCast(node);
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
@@ skipping 48 matching lines @@
   Append(for_right_value);
   RelationalOpComp* comp = new RelationalOpComp(node->token_pos(),
                                                 node->kind(),
                                                 for_left_value.value(),
                                                 for_right_value.value());
   ReturnComputation(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitUnaryOpNode");
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       value =
           Bind(new AssertBooleanComp(node->operand()->token_pos(), value));
     }
@@ skipping 15 matching lines @@
     name = Symbols::New(Token::Str(node->kind()));
   }
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), name, node->kind(),
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitConditionalExprNode");
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitConditionalExprNode");
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   for_true.Do(BuildStoreLocal(
       *owner()->parsed_function().expression_temp_var(), for_true.value()));
@@ skipping 24 matching lines @@
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
 }
 
 
 void EffectGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitSwitchNode");
   EffectGraphVisitor switch_body(owner(), temp_index());
   node->body()->Visit(&switch_body);
   Append(switch_body);
   if ((node->label() != NULL) && (node->label()->join_for_break() != NULL)) {
     if (is_open()) Goto(node->label()->join_for_break());
     exit_ = node->label()->join_for_break();
   }
   // No continue label allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
@@ skipping 15 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");
   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 79 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");
   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 CheckStackOverflowComp(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");
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
       new CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
@@ skipping 35 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");
   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 CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
@@ skipping 52 matching lines @@
       exit_ = loop_exit;
     } else {
       loop_exit->Goto(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
-  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 34 matching lines @@
       node->label()->set_join_for_continue(
           new JoinEntryInstr(owner()->try_index()));
     }
     jump_target = node->label()->join_for_continue();
   }
   Goto(jump_target);
 }
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitArgumentListNode");
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitArrayNode");
   // Translate the array elements and collect their values.
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     arguments->Add(PushArgument(for_value.value()));
   }
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   CreateArrayComp* create = new CreateArrayComp(node->token_pos(),
                                                 arguments,
                                                 node->type(),
                                                 element_type);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitClosureNode");
   const Function& function = node->function();
 
   Value* receiver = NULL;
   if (function.IsNonImplicitClosureFunction()) {
     // The context scope may have already been set by the non-optimizing
     // compiler.  If it was not, set it here.
     if (function.context_scope() == ContextScope::null()) {
       const ContextScope& context_scope = ContextScope::ZoneHandle(
           node->scope()->PreserveOuterScope(owner()->context_level()));
       ASSERT(!function.HasCode());
@@ skipping 29 matching lines @@
   }
   PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
   ReturnComputation(new CreateClosureComp(node, arguments));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
-  InlineBailout("EffectGraphVisitor::TranslateArgumentList");
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     values->Add(for_argument.value());
   }
 }
 
 
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
-  InlineBailout("EffectGraphVisitor::BuildPushArguments");
   for (intptr_t i = 0; i < node.length(); ++i) {
     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");
   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);
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStaticCallNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallComp* call =
       new StaticCallComp(node->token_pos(),
                          node->function(),
                          node->arguments()->names(),
                          arguments);
   ReturnComputation(call);
 }
 
 
 ClosureCallComp* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
-  InlineBailout("EffectGraphVisitor::BuildClosureCall");
   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);
 
   // Save context around the call.
   BuildStoreContext(*owner()->parsed_function().expression_temp_var());
   return new ClosureCallComp(node, arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitClosureCallNode");
   Do(BuildClosureCall(node));
   // Restore context from saved location.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitClosureCallNode");
   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");
   Value* context = Bind(new CurrentContextComp());
   Value* clone = Bind(new CloneContextComp(node->token_pos(), context));
   ReturnComputation(new StoreContextComp(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
-  InlineBailout("EffectGraphVisitor::BuildObjectAllocation");
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Computation* allocate_comp = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
@@ skipping 22 matching lines @@
 
     allocate_comp = new AllocateObjectComp(node, allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
-  InlineBailout("EffectGraphVisitor::BuildConstructorCall");
   Value* ctor_arg = Bind(
       new ConstantComp(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);
   Do(new StaticCallComp(node->token_pos(),
                         node->constructor(),
                         node->arguments()->names(),
                         arguments));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitConstructorCallNode");
   if (node->constructor().IsFactory()) {
     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);
     StaticCallComp* call =
@@ skipping 10 matching lines @@
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator() {
-  InlineBailout("EffectGraphVisitor::BuildInstantiator");
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     return NULL;
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
   ASSERT(owner()->parsed_function().instantiator() != NULL);
   ValueGraphVisitor for_instantiator(owner(), temp_index());
   owner()->parsed_function().instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   return for_instantiator.value();
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_pos, Value* instantiator) {
-  InlineBailout("EffectGraphVisitor::BuildInstantiatorTypeArguments");
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
@@ skipping 30 matching lines @@
   return Bind(new LoadVMFieldComp(
       instantiator,
       type_arguments_instance_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
-  InlineBailout("EffectGraphVisitor::BuildInstantiatedTypeArguments");
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new ConstantComp(type_arguments));
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
   return Bind(new InstantiateTypeArgumentsComp(token_pos,
                                                type_arguments,
                                                instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     Value** type_arguments,
     Value** instantiator,
     ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
-  InlineBailout("EffectGraphVisitor::BuildConstructorTypeArguments");
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
     Value* type_arguments_val = Bind(new ConstantComp(node->type_arguments()));
     if (call_arguments != NULL) {
       ASSERT(type_arguments == NULL);
       call_arguments->Add(PushArgument(type_arguments_val));
     } else {
       ASSERT(type_arguments != NULL);
@@ skipping 59 matching lines @@
     ASSERT(instantiator == NULL);
     call_arguments->Add(PushArgument(instantiator_val));
   } else {
     ASSERT(instantiator != NULL);
     *instantiator = instantiator_val;
   }
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitConstructorCallNode");
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Value* allocate = BuildObjectAllocation(node);
   Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
       allocate);
   Value* allocated_value = Bind(store_allocated);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
   Computation* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitConstructorCallNode");
   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()));
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
-  InlineBailout("EffectGraphVisitor::BuildInstanceSetterArguments");
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(
         BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                         for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, false);  // Value not used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
                                                 name,
                                                 Token::kSET,
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 1);  // Checked argument count.
   ReturnComputation(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, true);  // Value used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallComp(node->token_pos(),
                           name,
                           Token::kSET,
                           arguments,
                           Array::ZoneHandle(),
                           1));  // Checked argument count.
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStaticGetterNode");
   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());
   }
   StaticCallComp* call = new StaticCallComp(node->token_pos(),
                                             getter_function,
                                             Array::ZoneHandle(),  // No names.
                                             arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
-  InlineBailout("EffectGraphVisitor::BuildStaticSetter");
   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 29 matching lines @@
     Do(call);
     ReturnComputation(
          BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
   } else {
     ReturnComputation(call);
   }
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStaticSetterNode");
   BuildStaticSetter(node, false);  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitStaticSetterNode");
   BuildStaticSetter(node, true);  // Result needed.
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
   NativeCallComp* native_call = new NativeCallComp(node);
   ReturnComputation(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitPrimaryNode");
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitLoadLocalNode");
   if (node->HasPseudo()) {
     EffectGraphVisitor for_pseudo(owner(), temp_index());
     node->pseudo()->Visit(&for_pseudo);
     Append(for_pseudo);
   }
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitLoadLocalNode");
   EffectGraphVisitor::VisitLoadLocalNode(node);
   Computation* load = BuildLoadLocal(node->local());
   ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStoreLocalNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
   Computation* store = BuildStoreLocal(node->local(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadInstanceFieldComp* load = new LoadInstanceFieldComp(
       node->field(), for_instance.value());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStoreInstanceFieldNode");
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       node->field(), for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 // StoreInstanceFieldNode does not return result.
 void ValueGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitStoreInstanceFieldNode");
   UNIMPLEMENTED();
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitLoadStaticFieldNode");
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStoreStaticFieldNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitLoadIndexedNode");
   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)));
   InstanceCallComp* load = new InstanceCallComp(node->token_pos(),
                                                 name,
                                                 Token::kINDEX,
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 checked_argument_count);
   ReturnComputation(load);
 }
 
 
 Computation* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
-  InlineBailout("EffectGraphVisitor::BuildStoreIndexedValues");
   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 24 matching lines @@
   if (result_is_needed) {
     Do(store);
     return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
   } else {
     return store;
   }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitStoreIndexedNode");
   ReturnComputation(BuildStoreIndexedValues(node,
                                             false));  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  InlineBailout("ValueGraphVisitor::VisitStoreIndexedNode");
   ReturnComputation(BuildStoreIndexedValues(node,
                                             true));  // Result is needed.
 }
 
 
 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");
   Value* context = Bind(new CurrentContextComp());
   Value* parent = Bind(
       new LoadVMFieldComp(context,
                           Context::parent_offset(),
                           Type::ZoneHandle()));  // Not an instance, no type.
   Do(new StoreContextComp(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 (captured vars)");
     // 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 AllocateContextComp(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,
     // save it in a pre-allocated variable and restore it on exit.
@@ skipping 38 matching lines @@
           Value* null_constant =
               Bind(new ConstantComp(Object::ZoneHandle()));
           Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
-    InlineBailout("EffectGraphVisitor::VisitSequenceNode (type check)");
     const Function& function = owner()->parsed_function().function();
     const int num_params = function.NumberOfParameters();
     int pos = 0;
     if (function.IsConstructor()) {
       // Skip type checking of receiver and phase for constructor functions.
       pos = 2;
     } else if (function.IsFactory() || function.IsDynamicFunction()) {
       // Skip type checking of type arguments for factory functions.
       // Skip type checking of receiver for instance functions.
       pos = 1;
@@ skipping 53 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");
   // 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 CatchEntryComp(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");
   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 37 matching lines @@
   // Generate code for the finally block if one exists.
   if ((node->finally_block() != NULL) && is_open()) {
     EffectGraphVisitor for_finally_block(owner(), temp_index());
     node->finally_block()->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
-  InlineBailout("EffectGraphVisitor::BuildThrowNode");
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
     instr = new ThrowInstr(node->token_pos());
   } else {
     ValueGraphVisitor for_stack_trace(owner(), temp_index());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
     instr = new ReThrowInstr(node->token_pos());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
-  InlineBailout("EffectGraphVisitor::VisitThrowNode");
   BuildThrowNode(node);
   CloseFragment();
 }
 
 
 // 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) {
-  InlineBailout("ValueGraphVisitor::VisitThrowNode");
   BuildThrowNode(node);
   ReturnComputation(new ConstantComp(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  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 31 matching lines @@
   // stack check on entry for leaf routines).
   for_effect.Do(new CheckStackOverflowComp(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());
   return new FlowGraph(*this, graph_entry_);
 }
 
 
-FlowGraph* FlowGraphBuilder::BuildGraphForInlining(InliningContext context) {
-  ASSERT(inlining_context_ == kNotInlining);
-  inlining_context_ = context;
-  exits_ = new ZoneGrowableArray<ReturnInstr*>();
-  TargetEntryInstr* normal_entry = new TargetEntryInstr(
-      CatchClauseNode::kInvalidTryIndex);
-  graph_entry_ = new GraphEntryInstr(normal_entry);
-  EffectGraphVisitor for_effect(this, 0);
-  parsed_function().node_sequence()->Visit(&for_effect);
-  AppendFragment(normal_entry, for_effect);
-  ASSERT(!for_effect.is_open());
-  FlowGraph* graph = new FlowGraph(*this, graph_entry_);
-  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