Fast codegen: Working break and continue.

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 18 matching lines @@
 
 #include "codegen-inl.h"
 #include "compiler.h"
 #include "fast-codegen.h"
 #include "stub-cache.h"
 #include "debug.h"
 
 namespace v8 {
 namespace internal {
 
-#define __ ACCESS_MASM(masm_)
+#define __ ACCESS_MASM(masm())
 
 Handle<Code> FastCodeGenerator::MakeCode(FunctionLiteral* fun,
                                          Handle<Script> script,
                                          bool is_eval) {
   CodeGenerator::MakeCodePrologue(fun);
   const int kInitialBufferSize = 4 * KB;
   MacroAssembler masm(NULL, kInitialBufferSize);
   FastCodeGenerator cgen(&masm, script, is_eval);
   cgen.Generate(fun);
   if (cgen.HasStackOverflow()) {
@@ skipping 175 matching lines @@
 
   __ bind(&eval_right);
   Visit(expr->right());
 
   __ bind(&done);
 }
 
 
 void FastCodeGenerator::VisitBlock(Block* stmt) {
   Comment cmnt(masm_, "[ Block");
+  Label end_of_block;
+  Breakable nested_statement(this, stmt, &end_of_block);

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

If the label is part of the state of the Breakable, you could write

Breakable nested_statement(this, stmt);

   SetStatementPosition(stmt);
   VisitStatements(stmt->statements());
+  __ bind(&end_of_block);

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

And

__ bind(nested_statement.break_target());

 }
 
 
 void FastCodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   Comment cmnt(masm_, "[ ExpressionStatement");
   SetStatementPosition(stmt);
   Visit(stmt->expression());
 }
 
 
@@ skipping 24 matching lines @@
   __ jmp(&done);
 
   __ bind(&else_part);
   Visit(stmt->else_statement());
 
   __ bind(&done);
 }
 
 
 void FastCodeGenerator::VisitContinueStatement(ContinueStatement* stmt) {
-  UNREACHABLE();
+  NestedStatement* current = nesting_stack_;

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

Might be nice to have a codegen comment "[ ContinueStatement" here (and below
for BreakStatement).

[Lasse Reichstein, 2009/12/10 13:55:32]

Fixed

+  int stack_depth = 0;
+  while (!current->IsContinueTarget(stmt->target())) {
+    stack_depth = current->Exit(stack_depth);
+    current = current->outer();
+  }
+  __ Drop(stack_depth);
+
+  Iteration* loop = current->AsIteration();
+  __ jmp(loop->continue_target());
 }
 
 
 void FastCodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
-  UNREACHABLE();
+  NestedStatement* current = nesting_stack_;
+  int stack_depth = 0;
+  while (!current->IsBreakTarget(stmt->target())) {
+    stack_depth = current->Exit(stack_depth);
+    current = current->outer();
+  }
+  __ Drop(stack_depth);
+
+  Breakable* target = current->AsBreakable();
+  __ jmp(target->break_target());
 }
 
 
+void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
+  Comment cmnt(masm_, "[ ReturnStatement");
+  Expression* expr = stmt->expression();
+  // Complete the statement based on the type of the subexpression.
+  if (expr->AsLiteral() != NULL) {
+    __ Move(result_register(), expr->AsLiteral()->handle());
+  } else {
+    ASSERT_EQ(Expression::kValue, expr->context());
+    Visit(expr);
+    __ pop(result_register());
+  }
+
+  // Exit all nested statements.
+  NestedStatement* current = nesting_stack_;
+  int stack_depth = 0;
+  while (current != NULL) {
+    stack_depth = current->Exit(stack_depth);
+    current = current->outer();
+  }
+  __ Drop(stack_depth);
+
+  EmitReturnSequence(stmt->statement_pos());
+}
+
+
+
+
 void FastCodeGenerator::VisitWithEnterStatement(WithEnterStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitWithExitStatement(WithExitStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitSwitchStatement(SwitchStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitDoWhileStatement(DoWhileStatement* stmt) {
   Comment cmnt(masm_, "[ DoWhileStatement");
+  Label body, test, exit, stack_limit_hit, stack_check_success;

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

exit and test could be fields of the Iteration.

+
   increment_loop_depth();

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

Another comment: it seems nicer to properly nest the increment/decrement of loop
depth with the nesting stack, eg:

Iteration loop_statement(this, stmt);
increment_loop_depth();
/* ... */
decrement_loop_depth();

Or else:

increment_loop_depth();
{
  Iteration loop_statement(this, stmt);
  /* ... */
}
decrement_loop-depth();

[Lasse Reichstein, 2009/12/10 13:55:32]

Fixed

-  Label body, exit, stack_limit_hit, stack_check_success;
 
   __ bind(&body);
+  Iteration loop_statement(this, stmt, &exit, &test);
   Visit(stmt->body());
 
   // Check stack before looping.
   __ StackLimitCheck(&stack_limit_hit);
   __ bind(&stack_check_success);
 
   // We are not in an expression context because we have been compiling
   // statements.  Set up a test expression context for the condition.
+  __ bind(&test);

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

__ bind(loop_statement.continue_target());

   ASSERT_EQ(NULL, true_label_);
   ASSERT_EQ(NULL, false_label_);
   true_label_ = &body;
   false_label_ = &exit;
   ASSERT(stmt->cond()->context() == Expression::kTest);
   Visit(stmt->cond());
   true_label_ = NULL;
   false_label_ = NULL;
 
   __ bind(&stack_limit_hit);
   StackCheckStub stack_stub;
   __ CallStub(&stack_stub);
   __ jmp(&stack_check_success);
 
   __ bind(&exit);

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

__ bind(loop_statement.break_target());

 
   decrement_loop_depth();
 }
 
 
 void FastCodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
   Comment cmnt(masm_, "[ WhileStatement");
+  Label test, body, exit, stack_limit_hit, stack_check_success;
+
   increment_loop_depth();
-  Label test, body, exit, stack_limit_hit, stack_check_success;
 
   // Emit the test at the bottom of the loop.
   __ jmp(&test);
 
   __ bind(&body);
+  Iteration loop_stamt(this, stmt, &exit, &test);

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

loop_statement?  loop_stmt?

[Lasse Reichstein, 2009/12/10 13:55:32]

Odd typo. Fixed.

   Visit(stmt->body());
 
   __ bind(&test);
   // Check stack before looping.
   __ StackLimitCheck(&stack_limit_hit);
   __ bind(&stack_check_success);
 
   // We are not in an expression context because we have been compiling
   // statements.  Set up a test expression context for the condition.
   ASSERT_EQ(NULL, true_label_);
   ASSERT_EQ(NULL, false_label_);
   true_label_ = &body;
   false_label_ = &exit;
   ASSERT(stmt->cond()->context() == Expression::kTest);
   Visit(stmt->cond());
   true_label_ = NULL;
   false_label_ = NULL;
 
   __ bind(&stack_limit_hit);
   StackCheckStub stack_stub;
   __ CallStub(&stack_stub);
   __ jmp(&stack_check_success);
 
   __ bind(&exit);
-
   decrement_loop_depth();
 }
 
 
 void FastCodeGenerator::VisitForStatement(ForStatement* stmt) {
   Comment cmnt(masm_, "[ ForStatement");
-  Label test, body, exit, stack_limit_hit, stack_check_success;
+  Label test, body, next, exit, stack_limit_hit, stack_check_success;
   if (stmt->init() != NULL) Visit(stmt->init());
 
   increment_loop_depth();
+
   // Emit the test at the bottom of the loop (even if empty).
   __ jmp(&test);
+
   __ bind(&body);
+  Iteration loop_stamt(this, stmt, &exit, &next);

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

loop_statement?

   Visit(stmt->body());
 
   // Check stack before looping.
   __ StackLimitCheck(&stack_limit_hit);
   __ bind(&stack_check_success);
 
+  __ bind(&next);
+
   if (stmt->next() != NULL) Visit(stmt->next());
 
   __ bind(&test);
 
   if (stmt->cond() == NULL) {
     // For an empty test jump to the top of the loop.
     __ jmp(&body);
   } else {
     // We are not in an expression context because we have been compiling
     // statements.  Set up a test expression context for the condition.
     ASSERT_EQ(NULL, true_label_);
     ASSERT_EQ(NULL, false_label_);
 
     true_label_ = &body;
     false_label_ = &exit;
     ASSERT(stmt->cond()->context() == Expression::kTest);
     Visit(stmt->cond());
     true_label_ = NULL;
     false_label_ = NULL;
   }
 
   __ bind(&stack_limit_hit);
   StackCheckStub stack_stub;
   __ CallStub(&stack_stub);
   __ jmp(&stack_check_success);
 
   __ bind(&exit);
+
   decrement_loop_depth();
 }
 
 
 void FastCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
@@ skipping 118 matching lines @@
 void FastCodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* expr) {
   UNREACHABLE();
 }
 
 
 void FastCodeGenerator::VisitThrow(Throw* expr) {
   UNREACHABLE();
 }
 
 
+int FastCodeGenerator::TryFinally::Exit(int stack_depth) {
+  __ Drop(stack_depth);

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

Good.  I much prefer adjusting the stack pointer to point to the handler rather
than loading the stack pointer from the global handler.

+  __ PopTryHandler();
+  __ Call(finally_entry_);
+  return 0;
+}
+
+
+int FastCodeGenerator::TryCatch::Exit(int stack_depth) {
+  __ Drop(stack_depth);
+  __ PopTryHandler();
+  return 0;
+}
+
+
 #undef __
 
 
 } }  // namespace v8::internal