[interpreter] Implement static loop depth tracking.

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/code-stubs.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-flags.h"
@@ skipping 248 matching lines @@
 // Scoped class for enabling 'break' and 'continue' in iteration
 // constructs, e.g. do...while, while..., for...
 class BytecodeGenerator::ControlScopeForIteration final
     : public BytecodeGenerator::ControlScope {
  public:
   ControlScopeForIteration(BytecodeGenerator* generator,
                            IterationStatement* statement,
                            LoopBuilder* loop_builder)
       : ControlScope(generator),
         statement_(statement),
-        loop_builder_(loop_builder) {}
+        loop_builder_(loop_builder) {
+    generator->loop_depth_++;  // Increment tracked loop depth.
+  }
+  ~ControlScopeForIteration() {
+    generator()->loop_depth_--;  // Decrement tracked loop depth.

[rmcilroy, 2016/07/26 09:28:52]

Not sure the comments are necessary, pretty self explanatory, but I'm easy
either way :).

[Michael Starzinger, 2016/07/26 09:46:02]

Done. I mostly do this to trick clang-format into not uglifying my code.

+  }
 
  protected:
   bool Execute(Command command, Statement* statement) override {
     if (statement != statement_) return false;
     switch (command) {
       case CMD_BREAK:
         loop_builder_->Break();
         return true;
       case CMD_CONTINUE:
         loop_builder_->Continue();
@@ skipping 261 matching lines @@
           info->scope()->num_stack_slots(), info->literal(),
           info->SourcePositionRecordingMode())),
       info_(info),
       scope_(info->scope()),
       globals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       register_allocator_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
-      generator_state_() {
+      generator_state_(),
+      loop_depth_(0) {
   InitializeAstVisitor(isolate()->stack_guard()->real_climit());
 }
 
 Handle<BytecodeArray> BytecodeGenerator::MakeBytecode() {
   // Initialize the incoming context.
   ContextScope incoming_context(this, scope(), false);
 
   // Initialize control scope.
   ControlScopeForTopLevel control(this);
 
@@ skipping 101 matching lines @@
     BuildIndexedJump(generator_state_, first_yield,
         stmt->yield_count(), generator_resume_points_);
     builder()->Bind(&not_resuming);
   }
 
   // Insert an explicit {OsrPoll} right after the loop header, to trigger
   // on-stack replacement when armed for the given loop nesting depth.
   if (FLAG_ignition_osr) {
     // TODO(4764): Merge this with another bytecode (e.g. {Jump} back edge).
     // TODO(4764): Investigate interaction with generators.
-    // TODO(4764): Track and pass correct loop depth.
     DCHECK_EQ(0, stmt->yield_count());
-    builder()->OsrPoll(0);
+    int level = Min(loop_depth_, AbstractCode::kMaxLoopNestingMarker - 1);
+    builder()->OsrPoll(level);
   }
 }
 
 void BytecodeGenerator::VisitGeneratorPrologue() {
   // The generator resume trampoline abuses the new.target register both to
   // indicate that this is a resume call and to pass in the generator object.
   // In ordinary calls, new.target is always undefined because generator
   // functions are non-constructable.
   Register generator_object = Register::new_target();
   BytecodeLabel regular_call;
@@ skipping 2503 matching lines @@
   return execution_context()->scope()->language_mode();
 }
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return TypeFeedbackVector::GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8