[turbofan] Respect catch prediction provided by parser.

src/compiler/ast-graph-builder.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/ast-graph-builder.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
@@ skipping 338 matching lines @@
 
  private:
   BreakableStatement* target_;
   LoopBuilder* control_;
 };
 
 
 // Control scope implementation for a TryCatchStatement.
 class AstGraphBuilder::ControlScopeForCatch : public ControlScope {
  public:
-  ControlScopeForCatch(AstGraphBuilder* owner, TryCatchBuilder* control)
-      : ControlScope(owner), control_(control) {
+  ControlScopeForCatch(AstGraphBuilder* owner, TryCatchStatement* stmt,
+                       TryCatchBuilder* control)
+      : ControlScope(owner),
+        control_(control),
+        outer_prediction_(owner->try_catch_prediction_) {
     builder()->try_nesting_level_++;  // Increment nesting.
-    builder()->try_catch_nesting_level_++;
+    builder()->try_catch_prediction_ = stmt->catch_predicted();
   }
   ~ControlScopeForCatch() {
     builder()->try_nesting_level_--;  // Decrement nesting.
-    builder()->try_catch_nesting_level_--;
+    builder()->try_catch_prediction_ = outer_prediction_;
   }
 
  protected:
   bool Execute(Command cmd, Statement* target, Node* value) override {
     switch (cmd) {
       case CMD_THROW:
         control_->Throw(value);
         return true;
       case CMD_BREAK:
       case CMD_CONTINUE:
       case CMD_RETURN:
         break;
     }
     return false;
   }
 
  private:
   TryCatchBuilder* control_;
+  bool outer_prediction_;
 };
 
 
 // Control scope implementation for a TryFinallyStatement.
 class AstGraphBuilder::ControlScopeForFinally : public ControlScope {
  public:
-  ControlScopeForFinally(AstGraphBuilder* owner, DeferredCommands* commands,
-                         TryFinallyBuilder* control)
-      : ControlScope(owner), commands_(commands), control_(control) {
+  ControlScopeForFinally(AstGraphBuilder* owner, TryFinallyStatement* stmt,
+                         DeferredCommands* commands, TryFinallyBuilder* control)
+      : ControlScope(owner),
+        commands_(commands),
+        control_(control),
+        outer_prediction_(owner->try_catch_prediction_) {
     builder()->try_nesting_level_++;  // Increment nesting.
+    builder()->try_catch_prediction_ = stmt->catch_predicted();
   }
   ~ControlScopeForFinally() {
     builder()->try_nesting_level_--;  // Decrement nesting.
+    builder()->try_catch_prediction_ = outer_prediction_;
   }
 
  protected:
   bool Execute(Command cmd, Statement* target, Node* value) override {
     Node* token = commands_->RecordCommand(cmd, target, value);
     control_->LeaveTry(token, value);
     return true;
   }
 
  private:
   DeferredCommands* commands_;
   TryFinallyBuilder* control_;
+  bool outer_prediction_;
 };
 
 
 // Helper for generating before and after frame states.
 class AstGraphBuilder::FrameStateBeforeAndAfter {
  public:
   FrameStateBeforeAndAfter(AstGraphBuilder* builder, BailoutId id_before)
       : builder_(builder), frame_state_before_(nullptr) {
     frame_state_before_ = id_before == BailoutId::None()
                               ? builder_->GetEmptyFrameState()
@@ skipping 36 matching lines @@
                 NodeProperties::GetFrameStateInput(node, 1)->opcode());
       NodeProperties::ReplaceFrameStateInput(node, 1, frame_state_before_);
     }
   }
 
  private:
   AstGraphBuilder* builder_;
   Node* frame_state_before_;
 };
 
-
 AstGraphBuilder::AstGraphBuilder(Zone* local_zone, CompilationInfo* info,
                                  JSGraph* jsgraph, LoopAssignmentAnalysis* loop,
                                  TypeHintAnalysis* type_hint_analysis)
     : isolate_(info->isolate()),
       local_zone_(local_zone),
       info_(info),
       jsgraph_(jsgraph),
       environment_(nullptr),
       ast_context_(nullptr),
       globals_(0, local_zone),
       execution_control_(nullptr),
       execution_context_(nullptr),
-      try_catch_nesting_level_(0),
       try_nesting_level_(0),
+      try_catch_prediction_(false),
       input_buffer_size_(0),
       input_buffer_(nullptr),
       exit_controls_(local_zone),
       loop_assignment_analysis_(loop),
       type_hint_analysis_(type_hint_analysis),
       state_values_cache_(jsgraph),
       liveness_analyzer_(static_cast<size_t>(info->scope()->num_stack_slots()),
                          local_zone),
       frame_state_function_info_(common()->CreateFrameStateFunctionInfo(
           FrameStateType::kJavaScriptFunction, info->num_parameters() + 1,
@@ skipping 985 matching lines @@
 }
 
 
 void AstGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
   TryCatchBuilder try_control(this);
 
   // Evaluate the try-block inside a control scope. This simulates a handler
   // that is intercepting 'throw' control commands.
   try_control.BeginTry();
   {
-    ControlScopeForCatch scope(this, &try_control);
+    ControlScopeForCatch scope(this, stmt, &try_control);
     STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
     environment()->Push(current_context());
     Visit(stmt->try_block());
     environment()->Pop();
   }
   try_control.EndTry();
 
   // If requested, clear message object as we enter the catch block.
   if (stmt->clear_pending_message()) {
     Node* the_hole = jsgraph()->TheHoleConstant();
@@ skipping 25 matching lines @@
   //    (i.e. through break/continue/return statements).
   // 3. By exiting the try-block with a thrown exception.
   Node* fallthrough_result = jsgraph()->TheHoleConstant();
   ControlScope::DeferredCommands* commands =
       new (local_zone()) ControlScope::DeferredCommands(this);
 
   // Evaluate the try-block inside a control scope. This simulates a handler
   // that is intercepting all control commands.
   try_control.BeginTry();
   {
-    ControlScopeForFinally scope(this, commands, &try_control);
+    ControlScopeForFinally scope(this, stmt, commands, &try_control);
     STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
     environment()->Push(current_context());
     Visit(stmt->try_block());
     environment()->Pop();
   }
   try_control.EndTry(commands->GetFallThroughToken(), fallthrough_result);
 
   // The result value semantics depend on how the block was entered:
   //  - ReturnStatement: It represents the return value being returned.
   //  - ThrowStatement: It represents the exception being thrown.
@@ skipping 2586 matching lines @@
       if (NodeProperties::IsControl(result)) {
         environment_->UpdateControlDependency(result);
       }
       // Update the current effect dependency for effect-producing nodes.
       if (result->op()->EffectOutputCount() > 0) {
         environment_->UpdateEffectDependency(result);
       }
       // Add implicit exception continuation for throwing nodes.
       if (!result->op()->HasProperty(Operator::kNoThrow) && inside_try_scope) {
         // Conservative prediction whether caught locally.
-        IfExceptionHint hint = try_catch_nesting_level_ > 0
+        IfExceptionHint hint = try_catch_prediction_
                                    ? IfExceptionHint::kLocallyCaught
                                    : IfExceptionHint::kLocallyUncaught;
         // Copy the environment for the success continuation.
         Environment* success_env = environment()->CopyForConditional();
         const Operator* op = common()->IfException(hint);
         Node* effect = environment()->GetEffectDependency();
         Node* on_exception = graph()->NewNode(op, effect, result);
         environment_->UpdateControlDependency(on_exception);
         environment_->UpdateEffectDependency(on_exception);
         execution_control()->ThrowValue(on_exception);
@@ skipping 219 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8