[interpreter] VisitForTest for bytecode generator

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 427 matching lines @@
     generator_->set_execution_result(this);
   }
 
   virtual ~ExpressionResultScope() {
     generator_->set_execution_result(outer_);
     DCHECK(result_identified() || generator_->HasStackOverflow());
   }
 
   bool IsEffect() const { return kind_ == Expression::kEffect; }
   bool IsValue() const { return kind_ == Expression::kValue; }
+  bool IsTest() const { return kind_ == Expression::kTest; }
 
   virtual void SetResultInAccumulator() = 0;
   virtual void SetResultInRegister(Register reg) = 0;
 
  protected:
   ExpressionResultScope* outer() const { return outer_; }
   BytecodeArrayBuilder* builder() const { return generator_->builder(); }
   BytecodeGenerator* generator() const { return generator_; }
   const RegisterAllocationScope* allocator() const { return &allocator_; }
 
@@ skipping 70 matching lines @@
     if (generator()->HasStackOverflow() && !result_identified()) {
       SetResultInAccumulator();
     }
     return result_register_;
   }
 
  private:
   Register result_register_;
 };
 
+enum class BytecodeGenerator::ControlFallthrough { THEN, ELSE, NONE };

[rmcilroy, 2016/08/12 11:15:25]

Just define this in the header. Also, enum class uses "kConstant" notation
(i.e., kThen, kElse, kNone)

[klaasb, 2016/08/12 16:00:12]

Done.

+
+// Scoped class used for generating multiple jumps to the same location
+class BytecodeGenerator::BytecodeLabels {

[rmcilroy, 2016/08/12 11:15:26]

How about moving this to bytecode-label.h/cc?

[klaasb, 2016/08/12 16:00:12]

Done.

+ public:
+  BytecodeLabels() = default;
+
+  BytecodeLabel* New() {
+    labels_.emplace_back();
+    return &labels_.back();
+  }
+
+  void Bind(BytecodeArrayBuilder* builder) {
+    for (auto label : labels_) {
+      builder->Bind(&label);
+    }
+  }
+
+ private:
+  std::vector<BytecodeLabel> labels_;

[rmcilroy, 2016/08/12 11:15:25]

use ZoneVector (which means you will need to pass the zone to the constructor).

[klaasb, 2016/08/12 16:00:13]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(BytecodeLabels);
+};
+
+// Scoped class used when the result of the current expression to be
+// evaluated is only tested with jumps to two branches.
+class BytecodeGenerator::ControlResultScope final
+    : public ExpressionResultScope {
+ public:
+  ControlResultScope(BytecodeGenerator* generator, BytecodeLabels* then_labels,
+                     BytecodeLabels* else_labels,
+                     ControlFallthrough fallthrough)
+      : ExpressionResultScope(generator, Expression::kTest),
+        then_labels_(then_labels),
+        else_labels_(else_labels),
+        fallthrough_(fallthrough),
+        has_result_(true) {}
+
+  virtual void SetResultInAccumulator() {
+    DCHECK(has_result_);

[rmcilroy, 2016/08/12 11:15:26]

No need for these DCHECKS - the set_result_identified will DCHECK if it is
called twice.

[klaasb, 2016/08/12 16:00:12]

Done.

+    set_result_identified();
+  }
+
+  virtual void SetResultInRegister(Register reg) {
+    DCHECK(has_result_);
+    builder()->LoadAccumulatorWithRegister(reg);
+    set_result_identified();
+  }
+
+  // Used when code special cases for ControlResultScope and consumes any
+  // possible value by testing and jumping to a then/else label.
+  void SetNoResult() {

[rmcilroy, 2016/08/12 11:15:25]

How about SetResultConsumedByTest

[klaasb, 2016/08/12 16:00:12]

Done.

+    DCHECK(has_result_);
+    has_result_ = false;
+    set_result_identified();
+  }
+
+  bool HasResultValue() { return has_result_; }

[rmcilroy, 2016/08/12 11:15:26]

ResultConsumedByTest() (and invert the boolean)

[klaasb, 2016/08/12 16:00:13]

Done.

+
+  BytecodeLabel* NewThenLabel() { return then_labels_->New(); }
+  BytecodeLabel* NewElseLabel() { return else_labels_->New(); }
+
+  BytecodeLabels* ThenLabels() { return then_labels_; }
+  BytecodeLabels* ElseLabels() { return else_labels_; }
+
+  ControlFallthrough Fallthrough() { return fallthrough_; }
+  ControlFallthrough InvertedFallthrough() {

[rmcilroy, 2016/08/12 11:15:26]

These are all getters, so lowercase - then_labels, else_labels, fallthrough and
inverted_fallthrough. Also add "const" to all of them.

[klaasb, 2016/08/12 16:00:12]

Done.

+    switch (fallthrough_) {
+      case ControlFallthrough::THEN:
+        return ControlFallthrough::ELSE;
+      case ControlFallthrough::ELSE:
+        return ControlFallthrough::THEN;
+      default:
+        return ControlFallthrough::NONE;
+    }
+  }
+
+ private:
+  BytecodeLabels* then_labels_;
+  BytecodeLabels* else_labels_;
+  ControlFallthrough fallthrough_;
+  bool has_result_;
+
+  DISALLOW_COPY_AND_ASSIGN(ControlResultScope);
+};
+
 // Used to build a list of global declaration initial value pairs.
 class BytecodeGenerator::GlobalDeclarationsBuilder final : public ZoneObject {
  public:
   GlobalDeclarationsBuilder(Isolate* isolate, Zone* zone)
       : isolate_(isolate),
         declarations_(0, zone),
         constant_pool_entry_(0),
         has_constant_pool_entry_(false) {}
 
   void AddFunctionDeclaration(FeedbackVectorSlot slot, FunctionLiteral* func) {
@@ skipping 424 matching lines @@
 void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   builder()->SetStatementPosition(stmt);
   VisitForEffect(stmt->expression());
 }
 
 void BytecodeGenerator::VisitEmptyStatement(EmptyStatement* stmt) {
 }
 
 void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) {
   builder()->SetStatementPosition(stmt);
-  BytecodeLabel else_label, end_label;
+  BytecodeLabel end_label;

[rmcilroy, 2016/08/12 11:15:26]

nit - move end_label into inner else branch too.

[klaasb, 2016/08/12 16:00:12]

Done.

   if (stmt->condition()->ToBooleanIsTrue()) {
     // Generate then block unconditionally as always true.
     Visit(stmt->then_statement());
   } else if (stmt->condition()->ToBooleanIsFalse()) {
     // Generate else block unconditionally if it exists.
     if (stmt->HasElseStatement()) {
       Visit(stmt->else_statement());
     }
   } else {
     // TODO(oth): If then statement is BreakStatement or
     // ContinueStatement we can reduce number of generated
     // jump/jump_ifs here. See BasicLoops test.
-    VisitForAccumulatorValue(stmt->condition());
-    builder()->JumpIfFalse(&else_label);
+    BytecodeLabels then_labels;

[rmcilroy, 2016/08/12 11:15:26]

nit - BytecodeLabels then_labels, else_labels;

[klaasb, 2016/08/12 16:00:12]

Done.

+    BytecodeLabels else_labels;
+    VisitForControl(stmt->condition(), &then_labels, &else_labels,
+                    ControlFallthrough::THEN);
+
+    then_labels.Bind(builder());
     Visit(stmt->then_statement());
+
     if (stmt->HasElseStatement()) {
       builder()->Jump(&end_label);
-      builder()->Bind(&else_label);
+    }
+    else_labels.Bind(builder());
+    if (stmt->HasElseStatement()) {

[rmcilroy, 2016/08/12 11:15:26]

could you keep the if/else form:

if (stmt->HasElseStatement()) {
  builder()->Jump(&end_label);
  else_labels.Bind(builder());
  Visit(stmt->else_statement());
} else {
  else_labels.Bind(builder());
}

[klaasb, 2016/08/12 16:00:12]

Done.

       Visit(stmt->else_statement());
-    } else {
-      builder()->Bind(&else_label);
     }
     builder()->Bind(&end_label);
   }
 }
 
 void BytecodeGenerator::VisitSloppyBlockFunctionStatement(
     SloppyBlockFunctionStatement* stmt) {
   Visit(stmt->statement());
 }
 
@@ skipping 88 matching lines @@
   if (stmt->cond()->ToBooleanIsFalse()) {
     VisitIterationBody(stmt, &loop_builder);
   } else if (stmt->cond()->ToBooleanIsTrue()) {
     VisitIterationHeader(stmt, &loop_builder);
     VisitIterationBody(stmt, &loop_builder);
     loop_builder.JumpToHeader();
   } else {
     VisitIterationHeader(stmt, &loop_builder);
     VisitIterationBody(stmt, &loop_builder);
     builder()->SetExpressionAsStatementPosition(stmt->cond());
+    // TODO(klaasb) VisitForControl for loop conditions
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.JumpToHeaderIfTrue();
   }
   loop_builder.EndLoop();
 }
 
 void BytecodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
   if (stmt->cond()->ToBooleanIsFalse()) {
     // If the condition is false there is no need to generate the loop.
     return;
   }
 
   LoopBuilder loop_builder(builder());
   VisitIterationHeader(stmt, &loop_builder);
   if (!stmt->cond()->ToBooleanIsTrue()) {
     builder()->SetExpressionAsStatementPosition(stmt->cond());
+    // TODO(klaasb) VisitForControl for loop conditions
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.BreakIfFalse();
   }
   VisitIterationBody(stmt, &loop_builder);
   loop_builder.JumpToHeader();
   loop_builder.EndLoop();
 }
 
 void BytecodeGenerator::VisitForStatement(ForStatement* stmt) {
   if (stmt->init() != nullptr) {
     Visit(stmt->init());
   }
   if (stmt->cond() && stmt->cond()->ToBooleanIsFalse()) {
     // If the condition is known to be false there is no need to generate
     // body, next or condition blocks. Init block should be generated.
     return;
   }
 
   LoopBuilder loop_builder(builder());
   VisitIterationHeader(stmt, &loop_builder);
   if (stmt->cond() && !stmt->cond()->ToBooleanIsTrue()) {
     builder()->SetExpressionAsStatementPosition(stmt->cond());
+    // TODO(klaasb) VisitForControl for loop conditions
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.BreakIfFalse();
   }
   VisitIterationBody(stmt, &loop_builder);
   if (stmt->next() != nullptr) {
     builder()->SetStatementPosition(stmt->next());
     Visit(stmt->next());
   }
   loop_builder.JumpToHeader();
   loop_builder.EndLoop();
@@ skipping 398 matching lines @@
   native_function_literals_.push_back(std::make_pair(expr, entry));
   execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitDoExpression(DoExpression* expr) {
   VisitBlock(expr->block());
   VisitVariableProxy(expr->result());
 }
 
 void BytecodeGenerator::VisitConditional(Conditional* expr) {
-  // TODO(rmcilroy): Spot easy cases where there code would not need to
-  // emit the then block or the else block, e.g. condition is
-  // obviously true/1/false/0.
+  if (expr->condition()->ToBooleanIsTrue()) {
+    // Generate then block unconditionally as always true.
+    VisitForAccumulatorValue(expr->then_expression());
+  } else if (expr->condition()->ToBooleanIsFalse()) {
+    // Generate else block unconditionally if it exists.
+    VisitForAccumulatorValue(expr->else_expression());
+  } else {
+    BytecodeLabel end_label;
+    BytecodeLabels then_labels;
+    BytecodeLabels else_labels;

[rmcilroy, 2016/08/12 11:15:26]

nit - BytecodeLabels then_labels, else_labels;

[klaasb, 2016/08/12 16:00:12]

Done.

 
-  BytecodeLabel else_label, end_label;
+    VisitForControl(expr->condition(), &then_labels, &else_labels,
+                    ControlFallthrough::THEN);
 
-  VisitForAccumulatorValue(expr->condition());
-  builder()->JumpIfFalse(&else_label);
+    then_labels.Bind(builder());
+    VisitForAccumulatorValue(expr->then_expression());
+    builder()->Jump(&end_label);
 
-  VisitForAccumulatorValue(expr->then_expression());
-  builder()->Jump(&end_label);
-
-  builder()->Bind(&else_label);
-  VisitForAccumulatorValue(expr->else_expression());
-  builder()->Bind(&end_label);
+    else_labels.Bind(builder());
+    VisitForAccumulatorValue(expr->else_expression());
+    builder()->Bind(&end_label);
+  }
 
   execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitLiteral(Literal* expr) {
   if (!execution_result()->IsEffect()) {
     const AstValue* raw_value = expr->raw_value();
     if (raw_value->IsSmi()) {
       builder()->LoadLiteral(raw_value->AsSmi());
     } else if (raw_value->IsUndefined()) {
@@ skipping 268 matching lines @@
 }
 
 void BytecodeGenerator::VisitVariableLoad(Variable* variable,
                                           FeedbackVectorSlot slot,
                                           TypeofMode typeof_mode) {
   switch (variable->location()) {
     case VariableLocation::LOCAL: {
       Register source(Register(variable->index()));
       builder()->LoadAccumulatorWithRegister(source);
       BuildHoleCheckForVariableLoad(variable);
+      // this will generate a new register when within a RegisterResultScope

[rmcilroy, 2016/08/12 11:15:26]

Thanks for updating this. How about:

We need to load the variable into the accumulator, even when in a
VisitForRegisterScope, in order to avoid register aliasing if subsequent 
expressions assign to the same variable.

[klaasb, 2016/08/12 16:00:12]

Done.

+      // which is needed when expressions assign to variables as side-effect
       execution_result()->SetResultInAccumulator();
       break;
     }
     case VariableLocation::PARAMETER: {
       // The parameter indices are shifted by 1 (receiver is variable
       // index -1 but is parameter index 0 in BytecodeArrayBuilder).
       Register source = builder()->Parameter(variable->index() + 1);
       builder()->LoadAccumulatorWithRegister(source);
       BuildHoleCheckForVariableLoad(variable);
+      // this will generate a new register when within a RegisterResultScope

[rmcilroy, 2016/08/12 11:15:25]

ditto

[klaasb, 2016/08/12 16:00:12]

Done.

+      // which is needed when expressions assign to variables as side-effect
       execution_result()->SetResultInAccumulator();
       break;
     }
     case VariableLocation::GLOBAL:
     case VariableLocation::UNALLOCATED: {
       builder()->LoadGlobal(feedback_index(slot), typeof_mode);
       execution_result()->SetResultInAccumulator();
       break;
     }
     case VariableLocation::CONTEXT: {
@@ skipping 839 matching lines @@
     VisitVariableLoadForAccumulatorValue(
         proxy->var(), proxy->VariableFeedbackSlot(), INSIDE_TYPEOF);
   } else {
     VisitForAccumulatorValue(expr->expression());
   }
   builder()->TypeOf();
   execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitNot(UnaryOperation* expr) {
-  VisitForAccumulatorValue(expr->expression());
-  builder()->LogicalNot();
-  execution_result()->SetResultInAccumulator();
+  if (execution_result()->IsTest()) {

[rmcilroy, 2016/08/12 11:15:26]

Could you also add the IsEffect shortcut here (just VisitForEffect the value).

[klaasb, 2016/08/12 16:00:12]

Done.

+    ControlResultScope* control_result =
+        static_cast<ControlResultScope*>(execution_result());

[rmcilroy, 2016/08/12 11:15:26]

Could you add an AsTest() function with DCHECKS to ExecutionResult. Also, this
should be reinterpreter_cast<...>

[klaasb, 2016/08/12 16:00:12]

Done.

+    VisitForControl(expr->expression(), control_result->ElseLabels(),

[rmcilroy, 2016/08/12 11:15:26]

nit - comment that you are swapping the control flow.

[klaasb, 2016/08/12 16:00:12]

Done.

+                    control_result->ThenLabels(),
+                    control_result->InvertedFallthrough());
+    control_result->SetNoResult();
+  } else {
+    VisitForAccumulatorValue(expr->expression());
+    builder()->LogicalNot();
+    execution_result()->SetResultInAccumulator();
+  }
 }
 
 void BytecodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::Value::NOT:
       VisitNot(expr);
       break;
     case Token::Value::TYPEOF:
       VisitTypeOf(expr);
       break;
@@ skipping 258 matching lines @@
 
 void BytecodeGenerator::VisitCommaExpression(BinaryOperation* binop) {
   VisitForEffect(binop->left());
   Visit(binop->right());
 }
 
 void BytecodeGenerator::VisitLogicalOrExpression(BinaryOperation* binop) {
   Expression* left = binop->left();
   Expression* right = binop->right();
 
-  // Short-circuit evaluation- If it is known that left is always true,
-  // no need to visit right
-  if (left->ToBooleanIsTrue()) {
-    VisitForAccumulatorValue(left);
+  if (execution_result()->IsTest()) {
+    ControlResultScope* control_result =
+        static_cast<ControlResultScope*>(execution_result());
+
+    if (left->ToBooleanIsTrue()) {

[rmcilroy, 2016/08/12 11:15:26]

I think you could do:
 if (left->ToBooleanIsTrue() || right->ToBooleanIsTrue) {
   builder()->Jump(control_result->NewThenLabel());
 } else if (left->ToBooleanIsFalse() && right->ToBooleanIsFalse()) {
   builder()->Jump(control_result->NewElseLabel());
 ...

[klaasb, 2016/08/12 16:00:12]

Done.

+      builder()->Jump(control_result->NewThenLabel());
+    } else {
+      BytecodeLabels test_right;
+      VisitForControl(left, control_result->ThenLabels(), &test_right,
+                      ControlFallthrough::ELSE);
+      test_right.Bind(builder());
+      VisitForControl(right, control_result->ThenLabels(),
+                      control_result->ElseLabels(),
+                      control_result->Fallthrough());
+    }
+    control_result->SetNoResult();
   } else {
-    BytecodeLabel end_label;
-    VisitForAccumulatorValue(left);
-    builder()->JumpIfTrue(&end_label);
-    VisitForAccumulatorValue(right);
-    builder()->Bind(&end_label);
+    // Short-circuit evaluation- If it is known that left is always true,
+    // no need to visit right

[rmcilroy, 2016/08/12 11:15:26]

Just remove this comment (ditto below)

[klaasb, 2016/08/12 16:00:13]

Done.

+    if (left->ToBooleanIsTrue()) {
+      VisitForAccumulatorValue(left);
+    } else {

[rmcilroy, 2016/08/12 11:15:25]

I know this isn't your code, but we should also be able to do:
else if (left->ToBooleanIsFalse()) {
  VisitForAccumulatorValue(right);
}

[klaasb, 2016/08/12 16:00:12]

Done.

+      BytecodeLabel end_label;
+      VisitForAccumulatorValue(left);
+      builder()->JumpIfTrue(&end_label);
+      VisitForAccumulatorValue(right);
+      builder()->Bind(&end_label);
+    }
+    execution_result()->SetResultInAccumulator();
   }
-  execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitLogicalAndExpression(BinaryOperation* binop) {
   Expression* left = binop->left();
   Expression* right = binop->right();
 
-  // Short-circuit evaluation- If it is known that left is always false,
-  // no need to visit right
-  if (left->ToBooleanIsFalse()) {
-    VisitForAccumulatorValue(left);
+  if (execution_result()->IsTest()) {
+    ControlResultScope* control_result =
+        static_cast<ControlResultScope*>(execution_result());
+
+    if (left->ToBooleanIsFalse()) {

[rmcilroy, 2016/08/12 11:15:26]

Same suggestion (for AND) as above for OR.

[klaasb, 2016/08/12 16:00:12]

Done.

+      builder()->Jump(control_result->NewElseLabel());
+    } else {
+      BytecodeLabels test_right;
+      VisitForControl(left, &test_right, control_result->ElseLabels(),
+                      ControlFallthrough::THEN);
+      test_right.Bind(builder());
+      VisitForControl(right, control_result->ThenLabels(),
+                      control_result->ElseLabels(),
+                      control_result->Fallthrough());
+    }
+    control_result->SetNoResult();
   } else {
-    BytecodeLabel end_label;
-    VisitForAccumulatorValue(left);
-    builder()->JumpIfFalse(&end_label);
-    VisitForAccumulatorValue(right);
-    builder()->Bind(&end_label);
+    // Short-circuit evaluation- If it is known that left is always false,
+    // no need to visit right

[rmcilroy, 2016/08/12 11:15:26]

ditto

[klaasb, 2016/08/12 16:00:12]

Done.

+    if (left->ToBooleanIsFalse()) {

[rmcilroy, 2016/08/12 11:15:25]

Same suggestion as above.

[klaasb, 2016/08/12 16:00:12]

Done.

+      VisitForAccumulatorValue(left);
+    } else {
+      BytecodeLabel end_label;
+      VisitForAccumulatorValue(left);
+      builder()->JumpIfFalse(&end_label);
+      VisitForAccumulatorValue(right);
+      builder()->Bind(&end_label);
+    }
+    execution_result()->SetResultInAccumulator();
   }
-  execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitRewritableExpression(RewritableExpression* expr) {
   Visit(expr->expression());
 }
 
 void BytecodeGenerator::VisitNewLocalFunctionContext() {
   AccumulatorResultScope accumulator_execution_result(this);
   Scope* scope = this->scope();
 
@@ skipping 221 matching lines @@
 
 // Visits the expression |expr| and stores the expression result in
 // |destination|.
 void BytecodeGenerator::VisitForRegisterValue(Expression* expr,
                                               Register destination) {
   AccumulatorResultScope register_scope(this);
   Visit(expr);
   builder()->StoreAccumulatorInRegister(destination);
 }
 
+// Visits the expression |expr| for testing its boolean value and jumping to the
+// |then| or |other| label depending on value and short-circuit semantics
+void BytecodeGenerator::VisitForControl(Expression* expr,
+                                        BytecodeLabels* then_labels,
+                                        BytecodeLabels* else_labels,
+                                        ControlFallthrough fallthrough) {
+  bool has_result;
+  {
+    // to make sure that all temporary registers are returned before generating

[rmcilroy, 2016/08/12 11:15:26]

/s/to/To

[klaasb, 2016/08/12 16:00:12]

Done.

+    // jumps below, we assure that the result scope is deleted before
+    // otherwise dead registers might be materialized

[rmcilroy, 2016/08/12 11:15:26]

fullstop

[klaasb, 2016/08/12 16:00:11]

Done.

+    ControlResultScope control_result(this, then_labels, else_labels,
+                                      fallthrough);
+    Visit(expr);
+    has_result = control_result.HasResultValue();
+  }
+  if (has_result) {
+    switch (fallthrough) {
+      case ControlFallthrough::THEN:
+        builder()->JumpIfFalse(else_labels->New());
+        break;
+      case ControlFallthrough::ELSE:
+        builder()->JumpIfTrue(then_labels->New());
+        break;
+      default:

[rmcilroy, 2016/08/12 11:15:26]

Make this explicitly case ControlFallthrough::kNone

[klaasb, 2016/08/12 16:00:12]

Done.

+        builder()->JumpIfTrue(then_labels->New());
+        builder()->Jump(else_labels->New());
+    }
+  }
+}
+
 void BytecodeGenerator::VisitInScope(Statement* stmt, Scope* scope) {
   ContextScope context_scope(this, scope);
   DCHECK(scope->declarations()->is_empty());
   Visit(stmt);
 }
 
 LanguageMode BytecodeGenerator::language_mode() const {
   return execution_context()->scope()->language_mode();
 }
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return TypeFeedbackVector::GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8