[turbofan] Also inline into try blocks.

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/ast-numbering.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
+#include "src/compiler/all-nodes.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/type-hint-analyzer.h"
 #include "src/isolate-inl.h"
@@ skipping 43 matching lines @@
     // Both, {JSCallFunction} and {JSCallConstruct}, have two extra inputs:
     //  - JSCallConstruct: Includes target function and new target.
     //  - JSCallFunction: Includes target function and receiver.
     return call_->op()->ValueInputCount() - 2;
   }
 
  private:
   Node* call_;
 };
 
-
 Reduction JSInliner::InlineCall(Node* call, Node* new_target, Node* context,
-                                Node* frame_state, Node* start, Node* end) {
+                                Node* frame_state, Node* start, Node* end,
+                                Node* exceptionTarget,
+                                NodeVector uncaught_subcalls) {
   // The scheduler is smart enough to place our code; we just ensure {control}
   // becomes the control input of the start of the inlinee, and {effect} becomes
   // the effect input of the start of the inlinee.
   Node* control = NodeProperties::GetControlInput(call);
   Node* effect = NodeProperties::GetEffectInput(call);
 
   int const inlinee_new_target_index =
       static_cast<int>(start->op()->ValueOutputCount()) - 3;
   int const inlinee_arity_index =
       static_cast<int>(start->op()->ValueOutputCount()) - 2;
@@ skipping 36 matching lines @@
           edge.UpdateTo(control);
         } else if (NodeProperties::IsFrameStateEdge(edge)) {
           edge.UpdateTo(frame_state);
         } else {
           UNREACHABLE();
         }
         break;
     }
   }
 
+  if (exceptionTarget != nullptr) {
+    // Link uncaught calls in the inlinee to {exceptionTarget}
+    int subcall_count = static_cast<int>(uncaught_subcalls.size());
+    if (uncaught_subcalls.size() > 0) {
+      TRACE(
+          "Inlinee contains %d calls without IfException; "
+          "linking to existing IfException\n",
+          subcall_count);
+    }
+    NodeVector on_exception_nodes(local_zone_);
+    for (Node* subcall : uncaught_subcalls) {
+      const Operator* op = common()->IfException();

[Jarin, 2016/08/05 14:04:48]

Nit: no need for separate variable, just inline into the NewNode call below.

[bgeron, 2016/08/08 09:30:06]

Done.

+
+      Node* on_exception = graph()->NewNode(op, subcall, subcall);
+      on_exception_nodes.push_back(on_exception);
+    }
+
+    DCHECK_EQ(subcall_count, static_cast<int>(on_exception_nodes.size()));
+    if (subcall_count > 0) {
+      Node* control_output =
+          graph()->NewNode(common()->Merge(subcall_count), subcall_count,
+                           &on_exception_nodes.front());
+      NodeVector values_effects(local_zone_);
+      values_effects = on_exception_nodes;
+      values_effects.push_back(control_output);
+      Node* value_output = graph()->NewNode(
+          common()->Phi(MachineRepresentation::kTagged, subcall_count),
+          subcall_count + 1, &values_effects.front());
+      Node* effect_output =
+          graph()->NewNode(common()->EffectPhi(subcall_count),
+                           subcall_count + 1, &values_effects.front());
+      ReplaceWithValue(exceptionTarget, value_output, effect_output,
+                       control_output);
+    } else {
+      ReplaceWithValue(exceptionTarget, exceptionTarget, exceptionTarget,
+                       jsgraph()->Dead());
+    }
+  }
+
   NodeVector values(local_zone_);
   NodeVector effects(local_zone_);
   NodeVector controls(local_zone_);
   for (Node* const input : end->inputs()) {
     switch (input->opcode()) {
       case IrOpcode::kReturn:
         values.push_back(NodeProperties::GetValueInput(input, 0));
         effects.push_back(NodeProperties::GetEffectInput(input));
         controls.push_back(NodeProperties::GetControlInput(input));
         break;
@@ skipping 119 matching lines @@
   // calls whenever the target is a constant function object, as follows:
   //  - JSCallFunction(target:constant, receiver, args...)
   //  - JSCallConstruct(target:constant, args..., new.target)
   HeapObjectMatcher match(node->InputAt(0));
   if (!match.HasValue() || !match.Value()->IsJSFunction()) return NoChange();
   Handle<JSFunction> function = Handle<JSFunction>::cast(match.Value());
 
   return ReduceJSCall(node, function);
 }
 
-
 Reduction JSInliner::ReduceJSCall(Node* node, Handle<JSFunction> function) {
   DCHECK(IrOpcode::IsInlineeOpcode(node->opcode()));
   JSCallAccessor call(node);
   Handle<SharedFunctionInfo> shared_info(function->shared());
 
   // Function must be inlineable.
   if (!shared_info->IsInlineable()) {
     TRACE("Not inlining %s into %s because callee is not inlineable\n",
           shared_info->DebugName()->ToCString().get(),
           info_->shared_info()->DebugName()->ToCString().get());
@@ skipping 53 matching lines @@
     Handle<SharedFunctionInfo> frame_shared_info;
     if (frame_info.shared_info().ToHandle(&frame_shared_info) &&
         *frame_shared_info == *shared_info) {
       TRACE("Not inlining %s into %s because call is recursive\n",
             shared_info->DebugName()->ToCString().get(),
             info_->shared_info()->DebugName()->ToCString().get());
       return NoChange();
     }
   }
 
-  // TODO(turbofan): Inlining into a try-block is not yet supported.
-  if (NodeProperties::IsExceptionalCall(node)) {
-    TRACE("Not inlining %s into %s because of surrounding try-block\n",
-          shared_info->DebugName()->ToCString().get(),
-          info_->shared_info()->DebugName()->ToCString().get());
-    return NoChange();
+  // Find the IfException node, if any.
+  Node* exceptionTarget = nullptr;

[Jarin, 2016/08/05 14:04:48]

exceptionTarget -> exception_target

[bgeron, 2016/08/08 09:30:06]

Done.

+  for (Edge edge : node->use_edges()) {
+    if (NodeProperties::IsControlEdge(edge) &&
+        edge.from()->opcode() == IrOpcode::kIfException) {
+      DCHECK_NULL(exceptionTarget);
+      exceptionTarget = edge.from();
+    }
+  }
+
+  NodeVector uncaught_subcalls(local_zone_);
+
+  if (exceptionTarget != nullptr) {
+    TRACE(
+        "Inlining %s into %s regardless of surrounding try-block to catcher "
+        "#%d:%s\n",
+        shared_info->DebugName()->ToCString().get(),
+        info_->shared_info()->DebugName()->ToCString().get(),
+        exceptionTarget->id(), exceptionTarget->op()->mnemonic());
   }
 
   Zone zone(info_->isolate()->allocator());
   ParseInfo parse_info(&zone, function);
   CompilationInfo info(&parse_info, function);
   if (info_->is_deoptimization_enabled()) info.MarkAsDeoptimizationEnabled();
   if (info_->is_type_feedback_enabled()) info.MarkAsTypeFeedbackEnabled();
 
   if (!Compiler::ParseAndAnalyze(info.parse_info())) {
     TRACE("Not inlining %s into %s because parsing failed\n",
@@ skipping 46 matching lines @@
     Graph::SubgraphScope scope(graph());
     AstGraphBuilder graph_builder(&zone, &info, jsgraph(), loop_assignment,
                                   type_hint_analysis);
     graph_builder.CreateGraph(false);
 
     // Extract the inlinee start/end nodes.
     start = graph()->start();
     end = graph()->end();
   }
 
+  // Find all uncaught calls in the inlinee.
+  AllNodes inlined_nodes(local_zone_, end, graph());
+  for (Node* subcall : inlined_nodes.live) {
+    if (subcall->opcode() == IrOpcode::kJSCallFunction ||
+        subcall->opcode() == IrOpcode::kJSCallConstruct ||
+        subcall->opcode() == IrOpcode::kJSCallRuntime) {

[Jarin, 2016/08/05 14:04:48]

As discussed offline, you need a more general way:

I suggest looking for nodes that do not have NoThrow property, and then taking
the ones that have an IfSuccess use, but no IfException use.

[bgeron, 2016/08/08 09:30:06]

Done.

+      bool hasIfException = false;
+      for (Node* use : subcall->uses()) {
+        if (use->opcode() == IrOpcode::kIfException) {
+          hasIfException = true;
+          std::ostringstream s;
+          s << "found exception node #" << use->id();

[Jarin, 2016/08/05 14:04:48]

Remove the logging.

[bgeron, 2016/08/08 09:30:06]

Done.

+          break;
+        }
+      }
+      if (!hasIfException) {
+        uncaught_subcalls.push_back(subcall);
+      }
+    }
+  }
+
   Node* frame_state = call.frame_state();
   Node* new_target = jsgraph()->UndefinedConstant();
 
   // Inline {JSCallConstruct} requires some additional magic.
   if (node->opcode() == IrOpcode::kJSCallConstruct) {
     // Insert nodes around the call that model the behavior required for a
     // constructor dispatch (allocate implicit receiver and check return value).
     // This models the behavior usually accomplished by our {JSConstructStub}.
     // Note that the context has to be the callers context (input to call node).
     Node* receiver = jsgraph()->UndefinedConstant();  // Implicit receiver.
@@ skipping 78 matching lines @@
   // arguments count and context) have to match the number of arguments passed
   // to the call.
   int parameter_count = info.literal()->parameter_count();
   DCHECK_EQ(parameter_count, start->op()->ValueOutputCount() - 5);
   if (call.formal_arguments() != parameter_count) {
     frame_state = CreateArtificialFrameState(
         node, frame_state, call.formal_arguments(),
         FrameStateType::kArgumentsAdaptor, shared_info);
   }
 
-  return InlineCall(node, new_target, context, frame_state, start, end);
+  return InlineCall(node, new_target, context, frame_state, start, end,
+                    exceptionTarget, uncaught_subcalls);
 }
 
 Graph* JSInliner::graph() const { return jsgraph()->graph(); }
 
 JSOperatorBuilder* JSInliner::javascript() const {
   return jsgraph()->javascript();
 }
 
 CommonOperatorBuilder* JSInliner::common() const { return jsgraph()->common(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8