Fast-codegen: Adding support for try/catch and throw.

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 439 matching lines @@
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
-  UNREACHABLE();
+  Comment cmnt(masm_, "[ TryCatchStatement");
+  SetStatementPosition(stmt);
+
+  Label setup_try_handler, catch_entry, done;

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

This isn't as complicated as TryFinally, but I miss the nice big comment
explaining what's going on here.

+
+  __ Call(&setup_try_handler);

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

You called this 'try_handler_setup' in TryFinally :)

+  // Try handler code, exception in result register.
+
+  // Store exception in local .catch variable before executing catch block.
+  {
+    // The catch variable is *always* a variable proxy for a local variable.
+    Variable* catch_var = stmt->catch_var()->AsVariableProxy()->AsVariable();
+    ASSERT_NOT_NULL(catch_var);
+    ASSERT_EQ(Variable::TEMPORARY, catch_var->mode());

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

I think this is true, but the code doesn't depend on it.

+    Slot* variable_slot = catch_var->rewrite()->AsSlot();

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

No need for catch_var->rewrite()->AsSlot(), catch_var->slot() will do the same
thing.  (Using rewrite() just makes it a bit harder to get rid of rewrites.  I
thinking getting rid of rewrites would be a good thing.)

+    ASSERT_NOT_NULL(variable_slot);
+    ASSERT_EQ(Slot::LOCAL, variable_slot->type());
+    StoreToFrameField(SlotOffset(variable_slot), result_register());
+  }
+
+  Visit(stmt->catch_block());
+  __ jmp(&done);
+
+  // Try block code. Sets up the exception handler chain.
+  __ bind(&setup_try_handler);
+  {
+    TryCatch try_block(this, &catch_entry);
+    __ PushTryHandler(IN_JAVASCRIPT, TRY_CATCH_HANDLER);
+    Visit(stmt->try_block());
+    __ PopTryHandler();
+  }
+  __ bind(&done);
 }
 
 
 void FastCodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
+  Comment cmnt(masm_, "[ TryFinallyStatement");
+  SetStatementPosition(stmt);
   // Try finally is compiled by setting up a try-handler on the stack while
   // executing the try body, and removing it again afterwards.
   //
   // The try-finally construct can enter the finally block in three ways:
   // 1. By exiting the try-block normally. This removes the try-handler and
   //      calls the finally block code before continuing.
   // 2. By exiting the try-block with a function-local control flow transfer
   //    (break/continue/return). The site of the, e.g., break removes the
   //    try handler and calls the finally block code before continuing
   //    its outward control transfer.
@@ skipping 15 matching lines @@
   // Jump to try-handler setup and try-block code. Use call to put try-handler
   // address on stack.
   __ Call(&try_handler_setup);
   // Try handler code. Return address of call is pushed on handler stack.
   {
     // This code is only executed during stack-handler traversal when an
     // exception is thrown. The execption is in the result register, which
     // is retained by the finally block.
     // Call the finally block and then rethrow the exception.
     __ Call(&finally_entry);
-    ThrowException();
+    __ push(result_register());
+    __ CallRuntime(Runtime::kReThrow, 1);
   }
 
   __ bind(&finally_entry);
   {
     // Finally block implementation.
+    Finally finally_block(this);
     EnterFinallyBlock();
-    Finally finally_block(this);
     Visit(stmt->finally_block());
     ExitFinallyBlock();  // Return to the calling code.
   }
 
   __ bind(&try_handler_setup);
   {
     // Setup try handler (stack pointer registers).
+    TryFinally try_block(this, &finally_entry);
     __ PushTryHandler(IN_JAVASCRIPT, TRY_FINALLY_HANDLER);
-    TryFinally try_block(this, &finally_entry);
-    VisitStatements(stmt->try_block()->statements());
+    Visit(stmt->try_block());
     __ 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");
@@ skipping 130 matching lines @@
       EmitNamedPropertyAssignment(expr);
       break;
     case KEYED_PROPERTY:
       EmitKeyedPropertyAssignment(expr);
       break;
   }
 }
 
 
 void FastCodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* expr) {
-  UNREACHABLE();
+  // Call runtime routine to allocate the catch extension object and
+  // assign the exception value to the catch variable.
+  Comment cmnt(masm_, "[ CatchExtensionObject");
+
+  // Push key string.
+  Move(Expression::kValue, expr->key());

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

Seems just as simple to compile the key and variable.

Visit(expr->key());
Visit(expr->value());

(Asserting they have the right expreession context to be sure).

+
+  // Push .catch variable content.
+  Variable* exception_variable = expr->value()->AsVariable();
+  // The variable is always a temporary local.
+  ASSERT_NOT_NULL(exception_variable);
+  ASSERT_EQ(Variable::TEMPORARY, exception_variable->mode());
+  Slot* variable_slot = exception_variable->rewrite()->AsSlot();
+  ASSERT_NOT_NULL(variable_slot);
+  ASSERT_EQ(Slot::LOCAL, variable_slot->type());
+  // Use result register as scratch register (if necessary).
+  Move(Expression::kValue, variable_slot, result_register());
+
+  // Create catch extension object.
+  __ CallRuntime(Runtime::kCreateCatchExtensionObject, 2);
+
+  __ push(result_register());
 }
 
 
 void FastCodeGenerator::VisitThrow(Throw* expr) {
-  UNREACHABLE();
+  Comment cmnt(masm_, "[ Throw");
+  Visit(expr->exception());

[Kevin Millikin (Chromium), 2009/12/17 14:36:16]

Might assert the expression context is value.

+  // Exception is on stack.
+  __ CallRuntime(Runtime::kThrow, 1);
+  // Never returns here.
 }
 
 
 int FastCodeGenerator::TryFinally::Exit(int stack_depth) {
   // The macros used here must preserve the result register.
   __ Drop(stack_depth);
   __ PopTryHandler();
   __ Call(finally_entry_);
   return 0;
 }
 
 
 int FastCodeGenerator::TryCatch::Exit(int stack_depth) {
   // The macros used here must preserve the result register.
   __ Drop(stack_depth);
   __ PopTryHandler();
   return 0;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal