[Interpreter] Pops the context to the correct level on return.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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.
 
 #include "src/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 54 matching lines @@
 
     ContextScope* previous = this;
     for (int i = depth; i > 0; --i) {
       previous = previous->outer_;
     }
     return previous;
   }
 
   Scope* scope() const { return scope_; }
   Register reg() const { return register_; }
+  bool ShouldPopContext() { return should_pop_context_; }
 
  private:
   const BytecodeArrayBuilder* builder() const { return generator_->builder(); }
 
   void set_register(Register reg) { register_ = reg; }
 
   BytecodeGenerator* generator_;
   Scope* scope_;
   ContextScope* outer_;
   Register register_;
@@ skipping 271 matching lines @@
  private:
   TryFinallyBuilder* try_finally_builder_;
   DeferredCommands* commands_;
 };
 
 
 void BytecodeGenerator::ControlScope::PerformCommand(Command command,
                                                      Statement* statement) {
   ControlScope* current = this;
   ContextScope* context = generator()->execution_context();
+  // Do not pop if it is the outermost context.
+  if (context != current->context() && context->ShouldPopContext()) {

[mythria, 2016/03/15 09:49:11]

I am still not very sure about the check for context->ShouldPopContext(). If we
pop the outermost context before we return debugger could have problems. I will
add a test case that would cause it to fail.  I might be handling this at the
wrong place, please let me know if this is incorrect to handle it here. If we
need a check for ShouldPopContext do I also need it in the do loop where we pop
the context? I dont think it is correct to conditionally pop there because we go
to the outerscope only if the current control scope did not handle the command.

+    generator()->builder()->PopContext(current->context()->reg());
+  }
   do {
-    if (current->context() != context) {
-      // Pop context to the expected depth for break and continue. For return
-      // and throw it is not required to pop. Debugger expects that the
-      // context is not popped on return. So do not pop on return.
-      // TODO(rmcilroy): Only emit a single context pop.
-      if (command == CMD_BREAK || command == CMD_CONTINUE) {
-        generator()->builder()->PopContext(current->context()->reg());
-      }
-      context = current->context();
-    }
     if (current->Execute(command, statement)) {
       return;
     }
     current = current->outer();
+    if (current->context() != context) {
+      // Pop context to the expected depth.
+      // TODO(rmcilroy): Only emit a single context pop.
+      generator()->builder()->PopContext(current->context()->reg());
+    }
   } while (current != nullptr);
   UNREACHABLE();
 }
 
 
 class BytecodeGenerator::RegisterAllocationScope {
  public:
   explicit RegisterAllocationScope(BytecodeGenerator* generator)
       : generator_(generator),
         outer_(generator->register_allocator()),
@@ skipping 2766 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8