[turbofan] Support inlining of unguarded loops.

src/compiler/js-inlining.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/js-inlining.h"
 
 #include "src/ast.h"
 #include "src/ast-numbering.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/all-nodes.h"
@@ skipping 61 matching lines @@
   // Return the effect output of the graph,
   // that is the effect input of the return statement of the inlinee.
   Node* effect_output() {
     return NodeProperties::GetEffectInput(unique_return());
   }
   // Return the value output of the graph,
   // that is the value input of the return statement of the inlinee.
   Node* value_output() {
     return NodeProperties::GetValueInput(unique_return(), 0);
   }
+  // Return the control output of the graph,
+  // that is the control input of the return statement of the inlinee.
+  Node* control_output() {
+    return NodeProperties::GetControlInput(unique_return(), 0);
+  }
   // Return the unique return statement of the graph.
   Node* unique_return() {
     Node* unique_return = NodeProperties::GetControlInput(end_);
     DCHECK_EQ(IrOpcode::kReturn, unique_return->opcode());
     return unique_return;
   }
 
   // Counts JSFunction, Receiver, arguments, context but not effect, control.
   size_t total_parameters() { return start_->op()->ValueOutputCount(); }
 
@@ skipping 164 matching lines @@
           edge.UpdateTo(context);
         } else if (NodeProperties::IsControlEdge(edge)) {
           edge.UpdateTo(control);
         } else {
           UNREACHABLE();
         }
         break;
     }
   }
 
-  NodeProperties::ReplaceWithValue(call, value_output(), effect_output());
+  for (Edge edge : call->use_edges()) {
+    if (NodeProperties::IsControlEdge(edge)) {
+      // TODO(turbofan): Handle kIfException uses.
+      DCHECK_EQ(IrOpcode::kIfSuccess, edge.from()->opcode());
+      edge.from()->ReplaceUses(control_output());
+      edge.UpdateTo(nullptr);
+    } else if (NodeProperties::IsEffectEdge(edge)) {
+      edge.UpdateTo(effect_output());
+    } else {
+      edge.UpdateTo(value_output());
+    }
+  }
+
   return Reducer::Replace(value_output());
 }
 
 }  // namespace
 
 
 void JSInliner::AddClosureToFrameState(Node* frame_state,
                                        Handle<JSFunction> jsfunction) {
   FrameStateCallInfo call_info = OpParameter<FrameStateCallInfo>(frame_state);
   const Operator* op = jsgraph_->common()->FrameState(
@@ skipping 28 matching lines @@
 
 Reduction JSInliner::Reduce(Node* node) {
   if (node->opcode() != IrOpcode::kJSCallFunction) return NoChange();
 
   JSCallFunctionAccessor call(node);
   HeapObjectMatcher<JSFunction> match(call.jsfunction());
   if (!match.HasValue()) return NoChange();
 
   Handle<JSFunction> function = match.Value().handle();
 
-  if (function->shared()->native()) {
-    if (FLAG_trace_turbo_inlining) {
-      SmartArrayPointer<char> name =
-          function->shared()->DebugName()->ToCString();
-      PrintF("Not Inlining %s into %s because inlinee is native\n", name.get(),
-             info_->shared_info()->DebugName()->ToCString().get());
-    }
-    return NoChange();
-  }
-
   CompilationInfoWithZone info(function);
 
   if (!Compiler::ParseAndAnalyze(&info)) return NoChange();
   if (!Compiler::EnsureDeoptimizationSupport(&info)) return NoChange();
 
   if (info.scope()->arguments() != NULL && is_sloppy(info.language_mode())) {
     // For now do not inline functions that use their arguments array.
     SmartArrayPointer<char> name = function->shared()->DebugName()->ToCString();
     if (FLAG_trace_turbo_inlining) {
       PrintF(
@@ skipping 38 matching lines @@
       }
     }
   }
 
   return inlinee.InlineAtCall(jsgraph_, node);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8