First stab at try-catch and try-finally in TurboFan.

src/compiler/ast-graph-builder.h

 // 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.
 
 #ifndef V8_COMPILER_AST_GRAPH_BUILDER_H_
 #define V8_COMPILER_AST_GRAPH_BUILDER_H_
 
 #include "src/v8.h"
 
 #include "src/ast.h"
 #include "src/compiler/graph-builder.h"
 #include "src/compiler/js-graph.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class ControlBuilder;
 class Graph;
 class LoopAssignmentAnalysis;
 class LoopBuilder;
+class TryCatchBuilder;
+class TryFinallyBuilder;
 
 // The AstGraphBuilder produces a high-level IR graph, based on an
 // underlying AST. The produced graph can either be compiled into a
 // stand-alone function or be wired into another graph for the purposes
 // of function inlining.
 class AstGraphBuilder : public StructuredGraphBuilder, public AstVisitor {
  public:
   AstGraphBuilder(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph,
                   LoopAssignmentAnalysis* loop_assignment = NULL);
 
   // Creates a graph by visiting the entire AST.
   bool CreateGraph();
 
  protected:
   class AstContext;
   class AstEffectContext;
   class AstValueContext;
   class AstTestContext;
-  class BreakableScope;
   class ContextScope;

[titzer, 2015/02/02 09:47:29]

Do this class and its subclasses really need to be nested in the graph builder?

[Michael Starzinger, 2015/02/02 14:47:41]

Acknowledged. As discussed offline, it gives access to protected members of
AstGraphBuilder. Otherwise all the ControlScope classes would either need to be
friends or we would need to make a ton of methods on AstGraphBuilder public.
Let's refactor this in one go for all nested classes later.

+  class ControlScope;
+  class ControlScopeForBreakable;
+  class ControlScopeForIteration;
+  class ControlScopeForCatch;
+  class ControlScopeForFinally;
   class Environment;
 
   Environment* environment() {
     return reinterpret_cast<Environment*>(
         StructuredGraphBuilder::environment());
   }
 
   AstContext* ast_context() const { return ast_context_; }
-  BreakableScope* breakable() const { return breakable_; }
+  ControlScope* execution_control() const { return execution_control_; }
   ContextScope* execution_context() const { return execution_context_; }
 
   void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
-  void set_breakable(BreakableScope* brk) { breakable_ = brk; }
+  void set_execution_control(ControlScope* ctrl) { execution_control_ = ctrl; }
   void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
 
   // Support for control flow builders. The concrete type of the environment
   // depends on the graph builder, but environments themselves are not virtual.
   typedef StructuredGraphBuilder::Environment BaseEnvironment;
   BaseEnvironment* CopyEnvironment(BaseEnvironment* env) OVERRIDE;
 
   // Getters for values in the activation record.
   Node* GetFunctionClosure();
   Node* GetFunctionContext();
@@ skipping 38 matching lines @@
 
   // Builders for error reporting at runtime.
   Node* BuildThrowReferenceError(Variable* var, BailoutId bailout_id);
   Node* BuildThrowConstAssignError(BailoutId bailout_id);
 
   // Builders for dynamic hole-checks at runtime.
   Node* BuildHoleCheckSilent(Node* value, Node* for_hole, Node* not_hole);
   Node* BuildHoleCheckThrow(Node* value, Variable* var, Node* not_hole,
                             BailoutId bailout_id);
 
+  // Builders for non-local control flow.
+  Node* BuildReturn(Node* return_value);
+  Node* BuildThrow(Node* exception_value);
+
   // Builders for binary operations.
   Node* BuildBinaryOp(Node* left, Node* right, Token::Value op);
 
   // Builder for stack-check guards.
   Node* BuildStackCheck();
 
   bool IsOsrLoopEntry(IterationStatement* stmt);
 
 #define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
 
   // Visiting functions for AST nodes make this an AstVisitor.
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   // Visiting function for declarations list is overridden.
   void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
 
  private:
   CompilationInfo* info_;
   AstContext* ast_context_;
   JSGraph* jsgraph_;
 
   // List of global declarations for functions and variables.
   ZoneVector<Handle<Object>> globals_;
 
-  // Stack of breakable statements entered by the visitor.
-  BreakableScope* breakable_;
+  // Stack of control scopes currently entered by the visitor.
+  ControlScope* execution_control_;
 
   // Stack of context objects pushed onto the chain by the visitor.
   ContextScope* execution_context_;
 
   // Nodes representing values in the activation record.
   SetOncePointer<Node> function_closure_;
   SetOncePointer<Node> function_context_;
 
   // The node representing the OSR entry into the loop, if any.
   SetOncePointer<Node> osr_loop_entry_;
@@ skipping 232 matching lines @@
 class AstGraphBuilder::AstTestContext FINAL : public AstContext {
  public:
   explicit AstTestContext(AstGraphBuilder* owner)
       : AstContext(owner, Expression::kTest) {}
   ~AstTestContext() FINAL;
   void ProduceValue(Node* value) FINAL;
   Node* ConsumeValue() FINAL;
 };
 
 
-// Scoped class tracking breakable statements entered by the visitor. Allows to
-// properly 'break' and 'continue' iteration statements as well as to 'break'
-// from blocks within switch statements.
-class AstGraphBuilder::BreakableScope BASE_EMBEDDED {
+// Scoped class tracking control statements entered by the visitor. There are
+// different types of statements participating in this stack to properly track
+// local as well as non-local control flow:
+//  - IterationStatement : Allows proper 'break' and 'continue' behavior.
+//  - BreakableStatement : Allows 'break' from block and switch statements.
+//  - TryCatchStatement  : Intercepts 'throw' and implicit exceptional edges.
+//  - TryFinallyStatement: Intercepts 'break', 'continue', 'throw' and 'return'.
+class AstGraphBuilder::ControlScope BASE_EMBEDDED {
  public:
-  BreakableScope(AstGraphBuilder* owner, BreakableStatement* target,
-                 ControlBuilder* control, int drop_extra)
+  ControlScope(AstGraphBuilder* owner, int drop_extra)

[titzer, 2015/02/02 09:47:29]

{owner} is a bad name. Would prefer the more verbose {ast_graph_builder} (and
hopefully in the future simply {graph_builder}) to make this more clear.

{drop_extra} should be named {expr_stack_delta} or something similar to make it
more clear.

[Michael Starzinger, 2015/02/02 14:47:41]

Done. As discussed offline, used {builder} instead of {owner} and {stack_delta}
instead of {drop_extra}

       : owner_(owner),
-        target_(target),
-        next_(owner->breakable()),
-        control_(control),
+        next_(owner->execution_control()),
         drop_extra_(drop_extra) {
-    owner_->set_breakable(this);  // Push.
+    owner_->set_execution_control(this);  // Push.
   }
 
-  ~BreakableScope() {
-    owner_->set_breakable(next_);  // Pop.
+  virtual ~ControlScope() {
+    owner_->set_execution_control(next_);  // Pop.
   }
 
   // Either 'break' or 'continue' the target statement.
   void BreakTarget(BreakableStatement* target);
   void ContinueTarget(BreakableStatement* target);
 
+  // Either 'return' or 'throw' the given value.
+  void ReturnValue(Node* return_value);
+  void ThrowValue(Node* exception_value);
+
+  class DeferredCommands;
+
+ protected:
+  enum Command { CMD_BREAK, CMD_CONTINUE, CMD_RETURN, CMD_THROW };
+
+  // Performs one of the above commands on this stack of control scopes. This
+  // walks through the stack giving each scope a chance to execute or defer the
+  // given command by overriding the {Execute} method appropriately. Note that
+  // this also drops extra operands from the environment for each skipped scope.
+  void PerformCommand(Command cmd, Statement* stmt, Node* value);

[titzer, 2015/02/02 09:47:29]

{stmt} is called {target} in all the subclasses.

[Michael Starzinger, 2015/02/02 14:47:41]

Done. Here and in the occurrences below.

+
+  // Interface to execute a given command in this scope. Returning {true} here
+  // indicates successful execution whereas {false} requests to skip scope.
+  virtual bool Execute(Command cmd, Statement* stmt, Node* value);
+
+  Environment* environment() { return owner_->environment(); }
+  AstGraphBuilder* owner() const { return owner_; }
+  int drop_extra() const { return drop_extra_; }
+
  private:
   AstGraphBuilder* owner_;
-  BreakableStatement* target_;
-  BreakableScope* next_;
-  ControlBuilder* control_;
+  ControlScope* next_;
   int drop_extra_;
-
-  // Find the correct scope for the target statement. Note that this also drops
-  // extra operands from the environment for each scope skipped along the way.
-  BreakableScope* FindBreakable(BreakableStatement* target);
 };
 
 
+// Control scope implementation for a BreakableStatement.
+class AstGraphBuilder::ControlScopeForBreakable : public ControlScope {
+ public:
+  ControlScopeForBreakable(AstGraphBuilder* owner, BreakableStatement* target,
+                           ControlBuilder* control)
+      : ControlScope(owner, 0), target_(target), control_(control) {}
+
+ protected:
+  virtual bool Execute(Command cmd, Statement* stmt, Node* value) OVERRIDE;
+
+ private:
+  BreakableStatement* target_;
+  ControlBuilder* control_;
+};
+
+
+// Control scope implementation for an IterationStatement.
+class AstGraphBuilder::ControlScopeForIteration : public ControlScope {
+ public:
+  ControlScopeForIteration(AstGraphBuilder* owner, IterationStatement* target,
+                           LoopBuilder* control, int drop_extra)
+      : ControlScope(owner, drop_extra), target_(target), control_(control) {}
+
+ protected:
+  virtual bool Execute(Command cmd, Statement* stmt, Node* value) OVERRIDE;
+
+ private:
+  BreakableStatement* target_;
+  LoopBuilder* control_;
+};
+
+
+// Control scope implementation for a TryCatchStatement.
+class AstGraphBuilder::ControlScopeForCatch : public ControlScope {
+ public:
+  ControlScopeForCatch(AstGraphBuilder* owner, TryCatchBuilder* control)
+      : ControlScope(owner, 0), control_(control) {}
+
+ protected:
+  virtual bool Execute(Command cmd, Statement* stmt, Node* value) OVERRIDE;
+
+ private:
+  TryCatchBuilder* control_;
+};
+
+
+// Control scope implementation for a TryFinallyStatement.
+class AstGraphBuilder::ControlScopeForFinally : public ControlScope {
+ public:
+  ControlScopeForFinally(AstGraphBuilder* owner, DeferredCommands* commands,
+                         TryFinallyBuilder* control)
+      : ControlScope(owner, 0), commands_(commands), control_(control) {}
+
+ protected:
+  virtual bool Execute(Command cmd, Statement* stmt, Node* value) OVERRIDE;
+
+ private:
+  DeferredCommands* commands_;
+  TryFinallyBuilder* control_;
+};
+
+
 // Scoped class tracking context objects created by the visitor. Represents
 // mutations of the context chain within the function body and allows to
 // change the current {scope} and {context} during visitation.
 class AstGraphBuilder::ContextScope BASE_EMBEDDED {
  public:
   ContextScope(AstGraphBuilder* owner, Scope* scope, Node* context)
       : owner_(owner),
         next_(owner->execution_context()),
         outer_(owner->current_context()),
         scope_(scope) {
@@ skipping 18 matching lines @@
 
 Scope* AstGraphBuilder::current_scope() const {
   return execution_context_->scope();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_