A start on allowing non-local control flow, for exceptions, try-finally, and ...

src/x64/fast-codegen-x64.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 56 matching lines @@
         __ PushRoot(Heap::kUndefinedValueRootIndex);
       }
     } else {
       __ LoadRoot(rdx, Heap::kUndefinedValueRootIndex);
       for (int i = 0; i < locals_count; i++) {
         __ push(rdx);
       }
     }
   }
 
+  // The current stack contains the context, function, and locals.
+  // Keep track of the current height above the frame pointer, excluding
+  // the expression stack.
+  scope_stack_height_ = 2 + fun->scope()->num_stack_slots();
+  return_stack_height_ = scope_stack_height_;
+
   bool function_in_register = true;
 
   Variable* arguments = fun->scope()->arguments()->AsVariable();
   if (arguments != NULL) {
     // Function uses arguments object.
     Comment cmnt(masm_, "[ Allocate arguments object");
     __ push(rdi);
     // The receiver is just before the parameters on the caller's stack.
     __ lea(rdx, Operand(rbp, StandardFrameConstants::kCallerSPOffset +
                                  fun->num_parameters() * kPointerSize));
@@ skipping 62 matching lines @@
   { Comment cmnt(masm_, "[ return <undefined>;");
     // Emit a 'return undefined' in case control fell off the end of the body.
     __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
     EmitReturnSequence(function_->end_position());
   }
 }
 
 
 void FastCodeGenerator::EmitReturnSequence(int position) {
   Comment cmnt(masm_, "[ Return sequence");
-  if (return_label_.is_bound()) {
-    __ jmp(&return_label_);
-  } else {
-    __ bind(&return_label_);
+  if (return_label_ != &function_return_) {  // Shadowed return
+    if (scope_stack_height_ > return_stack_height_) {
+      __ addq(rsp, Immediate(
+          (scope_stack_height_ - return_stack_height_) * kPointerSize));}
+    else {
+      ASSERT(scope_stack_height_ == return_stack_height_);
+    }
+    __ jmp(return_label_);
+  } else if (return_label_->is_bound()) {  // Don't adjust stack for real return.
+    __ jmp(return_label_);
+  } else {  // Emit actual return sequence
+    __ bind(return_label_);
     if (FLAG_trace) {
       __ push(rax);
       __ CallRuntime(Runtime::kTraceExit, 1);
     }
 #ifdef DEBUG
     // Add a label for checking the size of the code used for returning.
     Label check_exit_codesize;
     masm_->bind(&check_exit_codesize);
 #endif
     CodeGenerator::RecordPositions(masm_, position);
@@ skipping 1375 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal