Fast-codegen: Implementing try/finally on top of nesting context.

src/fast-codegen.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 471 matching lines @@
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
-  UNREACHABLE();
+  // The try-finally construct can enter the finally block in three ways:

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

Consider some judicious code generator comments, to possibly help a reader
understand the generated code.

+  // 1. By exiting the try-block normally,
+  // 2. by exiting the try-block with a function-local control flow transfer
+  //    (break/continue/return), or
+  // 3. by exiting the try-block with a thrown exception.
+  //
+  // Normal exit and local control flow removes the try-handler before calling
+  // the fially block through finally_entry label.

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

"fially" ==> "finally"

[Lasse Reichstein, 2009/12/16 08:43:30]

Fixed

+  // Throwing an exception follows the try-handler chain, which consumes
+  // the try handler, and then enters the finally block through the
+  // finally_entry label.
+  // The finally block must assume a return address on top of the stack
+  // and a value in the result register (rax/eax/r0), both of which must

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

Probably should note that the value may be the return value or an exception
value.

[Lasse Reichstein, 2009/12/16 08:43:30]

Done

+  // be preserved. The return address isn't GC-safe, so it should be
+  // cooked before GC.
+  Label finally_entry;
+  Label try_handler_setup;
+
+  // Jump to try-handler setup and try-block code. Use call to put try-handler
+  // address on stack.
+  __ Call(&try_handler_setup);
+
+  // This code is only executed during stack-handler traversal when an
+  // exception is thrown.
+  // Call the finally block and then rethrow the exception.
+  __ Call(&finally_entry);
+  ThrowException();
+
+  {
+    // Finally block implementation.
+    __ bind(&finally_entry);
+    Finally finally_block(this);
+    EnterFinallyBlock();
+    Visit(stmt->finally_block());

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

Isn't it OK to VisitStatements the body of this block?  (We do in the optimizing
backend.)  The difference would only be breaks targeting the block, right?

We should do the same thing for the try and finally blocks (unless there's a
reason), otherwise the reader will wonder.

[Lasse Reichstein, 2009/12/16 08:43:30]

It should be ok (you can't label the blocks, so there is no reason to visit the
blocks themselves). Will change.

+    ReturnFromFinallyBlock();  // Performs a return to the calling code.

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

Can we call this ExitFinallyBlock, to parallel EnterFinallyBlock and because
"return" is ambiguous?

[Lasse Reichstein, 2009/12/16 08:43:30]

Fixed.
(The point was that it actually did a return at the end, so it was named to show
that control didn't fall through. I'll just use a comment).

+  }
+
+  __ bind(&try_handler_setup);
+  {
+    // Setup try handler (stack pointer registers).
+    __ PushTryHandler(IN_JAVASCRIPT, TRY_FINALLY_HANDLER);

[Kevin Millikin (Chromium), 2009/12/10 13:51:12]

It seems nicer to properly nest the Push/Pop of the handler with the nesting
stack:

{
  TryFinally try_block(this);
  __ PushTryHandler(...);
  /* ... */
  __ PopTryHandler();
}

[Lasse Reichstein, 2009/12/16 08:43:30]

Done

+    TryFinally try_block(this, &finally_entry);
+    VisitStatements(stmt->try_block()->statements());
+    __ PopTryHandler();
+  }
+  // Execute the finally block on the way out.
+  __ Call(&finally_entry);
 }
 
 
 void FastCodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Comment cmnt(masm_, "[ DebuggerStatement");
   SetStatementPosition(stmt);
   __ CallRuntime(Runtime::kDebugBreak, 0);
   // Ignore the return value.
 #endif
@@ skipping 117 matching lines @@
 }
 
 
 int FastCodeGenerator::TryCatch::Exit(int stack_depth) {
   __ Drop(stack_depth);
   __ PopTryHandler();
   return 0;
 }
 
 
+int FastCodeGenerator::TryFinally::Exit(int stack_depth) {
+  __ Drop(stack_depth);
+  __ PopTryHandler();
+  __ Call(finally_entry_);
+  return 0;
+}
+
+
+int FastCodeGenerator::TryCatch::Exit(int stack_depth) {
+  __ Drop(stack_depth);
+  __ PopTryHandler();
+  return 0;
+}
+
+
 #undef __
 
 
 } }  // namespace v8::internal