Interpreter tester should accept metadata instead of a vector

test/cctest/interpreter/test-interpreter.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 <tuple>
 
 #include "src/v8.h"
 
 #include "src/execution.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-label.h"
 #include "src/interpreter/interpreter.h"
 #include "src/objects-inl.h"
 #include "src/unicode-cache.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/interpreter/interpreter-tester.h"
 #include "test/cctest/test-feedback-vector.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
+static int GetIndex(FeedbackVectorSlot slot) {
+  return TypeFeedbackVector::GetIndex(slot);
+}
 
 TEST(InterpreterReturn) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Handle<Object> undefined_value = isolate->factory()->undefined_value();
 
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 0);
   builder.Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
@@ skipping 230 matching lines @@
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kShiftOperators); o++) {
         HandleAndZoneScope handles;
         Isolate* isolate = handles.main_isolate();
         Factory* factory = isolate->factory();
         Zone zone(isolate->allocator(), ZONE_NAME);
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
-            .BinaryOperation(kShiftOperators[o], reg, vector->GetIndex(slot))
+            .BinaryOperation(kShiftOperators[o], reg, GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kShiftOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
 
 TEST(InterpreterBinaryOpsSmi) {
   int lhs_inputs[] = {3266, 1024, 0, -17, -18000};
   int rhs_inputs[] = {3266, 5, 4, 3, 2, 1, -1, -2};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
         Isolate* isolate = handles.main_isolate();
         Factory* factory = isolate->factory();
         Zone zone(isolate->allocator(), ZONE_NAME);
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
-            .BinaryOperation(kArithmeticOperators[o], reg,
-                             vector->GetIndex(slot))
+            .BinaryOperation(kArithmeticOperators[o], reg, GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
 
 TEST(InterpreterBinaryOpsHeapNumber) {
   double lhs_inputs[] = {3266.101, 1024.12, 0.01, -17.99, -18000.833, 9.1e17};
   double rhs_inputs[] = {3266.101, 5.999, 4.778, 3.331,  2.643,
                          1.1,      -1.8,  -2.9,  8.3e-27};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
         Isolate* isolate = handles.main_isolate();
         Factory* factory = isolate->factory();
         Zone zone(isolate->allocator(), ZONE_NAME);
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         Register reg(0);
         double lhs = lhs_inputs[l];
         double rhs = rhs_inputs[r];
         builder.LoadLiteral(factory->NewNumber(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(factory->NewNumber(rhs))
-            .BinaryOperation(kArithmeticOperators[o], reg,
-                             vector->GetIndex(slot))
+            .BinaryOperation(kArithmeticOperators[o], reg, GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
@@ skipping 37 matching lines @@
        factory->NewStringFromStaticChars("-1.112.56"),
        BinaryOperationFeedback::kAny},
       {factory->NewStringFromStaticChars(""), factory->NewHeapNumber(2.5),
        factory->NewStringFromStaticChars("2.5"), BinaryOperationFeedback::kAny},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
     FeedbackVectorSpec feedback_spec(&zone);
     FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
-    Handle<i::TypeFeedbackVector> vector =
-        NewTypeFeedbackVector(isolate, &feedback_spec);
+    Handle<i::TypeFeedbackMetadata> metadata =
+        NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
     Register reg(0);
     builder.LoadLiteral(test_cases[i].lhs)
         .StoreAccumulatorInRegister(reg)
         .LoadLiteral(test_cases[i].rhs)
-        .BinaryOperation(Token::Value::ADD, reg, vector->GetIndex(slot))
+        .BinaryOperation(Token::Value::ADD, reg, GetIndex(slot))
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*test_cases[i].expected_value));
 
-    Object* feedback = vector->Get(slot);
+    Object* feedback = callable.vector()->Get(slot);
     CHECK(feedback->IsSmi());
     CHECK_EQ(test_cases[i].expected_feedback,
              static_cast<Smi*>(feedback)->value());
   }
 }
 
 
 TEST(InterpreterParameter1) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
@@ skipping 25 matching lines @@
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot4 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot5 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot6 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   builder.LoadAccumulatorWithRegister(builder.Parameter(0))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(1),
-                       vector->GetIndex(slot))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(2),
-                       vector->GetIndex(slot1))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(3),
-                       vector->GetIndex(slot2))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(4),
-                       vector->GetIndex(slot3))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(5),
-                       vector->GetIndex(slot4))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(6),
-                       vector->GetIndex(slot5))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(7),
-                       vector->GetIndex(slot6))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(1), GetIndex(slot))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(2), GetIndex(slot1))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(3), GetIndex(slot2))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(4), GetIndex(slot3))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(5), GetIndex(slot4))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(6), GetIndex(slot5))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(7), GetIndex(slot6))
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   typedef Handle<Object> H;
   auto callable = tester.GetCallable<H, H, H, H, H, H, H, H>();
 
   Handle<Smi> arg1 = Handle<Smi>(Smi::FromInt(1), handles.main_isolate());
   Handle<Smi> arg2 = Handle<Smi>(Smi::FromInt(2), handles.main_isolate());
   Handle<Smi> arg3 = Handle<Smi>(Smi::FromInt(3), handles.main_isolate());
   Handle<Smi> arg4 = Handle<Smi>(Smi::FromInt(4), handles.main_isolate());
   Handle<Smi> arg5 = Handle<Smi>(Smi::FromInt(5), handles.main_isolate());
   Handle<Smi> arg6 = Handle<Smi>(Smi::FromInt(6), handles.main_isolate());
   Handle<Smi> arg7 = Handle<Smi>(Smi::FromInt(7), handles.main_isolate());
@@ skipping 125 matching lines @@
       {Token::Value::MOD, Handle<Smi>(Smi::FromInt(3), isolate),
        isolate->factory()->NewStringFromAsciiChecked("-2"),
        Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny}};
 
   for (const BinaryOpExpectation& test_case : kTestCases) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
     i::FeedbackVectorSpec feedback_spec(&zone);
     i::FeedbackVectorSlot slot0 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-    Handle<i::TypeFeedbackVector> vector =
-        i::NewTypeFeedbackVector(isolate, &feedback_spec);
+    Handle<i::TypeFeedbackMetadata> metadata =
+        i::NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
     Register reg(0);
     builder.LoadLiteral(test_case.arg1)
         .StoreAccumulatorInRegister(reg)
         .LoadLiteral(test_case.arg2)
-        .BinaryOperation(test_case.op, reg, vector->GetIndex(slot0))
+        .BinaryOperation(test_case.op, reg, GetIndex(slot0))
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<>();
 
     Handle<Object> return_val = callable().ToHandleChecked();
-    Object* feedback0 = vector->Get(slot0);
+    Object* feedback0 = callable.vector()->Get(slot0);
     CHECK(feedback0->IsSmi());
     CHECK_EQ(test_case.feedback, static_cast<Smi*>(feedback0)->value());
     CHECK(Object::Equals(test_case.result, return_val).ToChecked());
   }
 }
 
 TEST(InterpreterBinaryOpSmiTypeFeedback) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Zone zone(isolate->allocator(), ZONE_NAME);
@@ skipping 67 matching lines @@
        Handle<Smi>(Smi::kZero, isolate), BinaryOperationFeedback::kNumber},
       {Token::Value::SAR, isolate->factory()->NewStringFromAsciiChecked("2"), 1,
        Handle<Smi>(Smi::FromInt(1), isolate), BinaryOperationFeedback::kAny}};
 
   for (const BinaryOpExpectation& test_case : kTestCases) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
     i::FeedbackVectorSpec feedback_spec(&zone);
     i::FeedbackVectorSlot slot0 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-    Handle<i::TypeFeedbackVector> vector =
-        i::NewTypeFeedbackVector(isolate, &feedback_spec);
+    Handle<i::TypeFeedbackMetadata> metadata =
+        i::NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
     Register reg(0);
     builder.LoadLiteral(test_case.arg1)
         .StoreAccumulatorInRegister(reg)
         .LoadLiteral(Smi::FromInt(test_case.arg2))
-        .BinaryOperation(test_case.op, reg, vector->GetIndex(slot0))
+        .BinaryOperation(test_case.op, reg, GetIndex(slot0))
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<>();
 
     Handle<Object> return_val = callable().ToHandleChecked();
-    Object* feedback0 = vector->Get(slot0);
+    Object* feedback0 = callable.vector()->Get(slot0);
     CHECK(feedback0->IsSmi());
     CHECK_EQ(test_case.feedback, static_cast<Smi*>(feedback0)->value());
     CHECK(Object::Equals(test_case.result, return_val).ToChecked());
   }
 }
 
 TEST(InterpreterUnaryOpFeedback) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Zone zone(isolate->allocator(), ZONE_NAME);
@@ skipping 16 matching lines @@
       {Token::Value::SUB, smi_one, smi_min, number, str}};
   for (TestCase const& test_case : kTestCases) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 4, 0, 0);
 
     i::FeedbackVectorSpec feedback_spec(&zone);
     i::FeedbackVectorSlot slot0 = feedback_spec.AddInterpreterBinaryOpICSlot();
     i::FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
     i::FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
     i::FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-    Handle<i::TypeFeedbackVector> vector =
-        i::NewTypeFeedbackVector(isolate, &feedback_spec);
+    Handle<i::TypeFeedbackMetadata> metadata =
+        i::NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
     builder.LoadAccumulatorWithRegister(builder.Parameter(0))
-        .CountOperation(test_case.op, vector->GetIndex(slot0))
+        .CountOperation(test_case.op, GetIndex(slot0))
         .LoadAccumulatorWithRegister(builder.Parameter(1))
-        .CountOperation(test_case.op, vector->GetIndex(slot1))
+        .CountOperation(test_case.op, GetIndex(slot1))
         .LoadAccumulatorWithRegister(builder.Parameter(2))
-        .CountOperation(test_case.op, vector->GetIndex(slot2))
+        .CountOperation(test_case.op, GetIndex(slot2))
         .LoadAccumulatorWithRegister(builder.Parameter(3))
-        .CountOperation(test_case.op, vector->GetIndex(slot3))
+        .CountOperation(test_case.op, GetIndex(slot3))
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     typedef Handle<Object> H;
     auto callable = tester.GetCallable<H, H, H, H>();
 
     Handle<Object> return_val =
         callable(test_case.smi_feedback_value,
                  test_case.smi_to_number_feedback_value,
                  test_case.number_feedback_value, test_case.any_feedback_value)
             .ToHandleChecked();
     USE(return_val);
-    Object* feedback0 = vector->Get(slot0);
+    Object* feedback0 = callable.vector()->Get(slot0);
     CHECK(feedback0->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kSignedSmall,
              static_cast<Smi*>(feedback0)->value());
 
-    Object* feedback1 = vector->Get(slot1);
+    Object* feedback1 = callable.vector()->Get(slot1);
     CHECK(feedback1->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kNumber,
              static_cast<Smi*>(feedback1)->value());
 
-    Object* feedback2 = vector->Get(slot2);
+    Object* feedback2 = callable.vector()->Get(slot2);
     CHECK(feedback2->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kNumber,
              static_cast<Smi*>(feedback2)->value());
 
-    Object* feedback3 = vector->Get(slot3);
+    Object* feedback3 = callable.vector()->Get(slot3);
     CHECK(feedback3->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kAny,
              static_cast<Smi*>(feedback3)->value());
   }
 }
 
 TEST(InterpreterBitwiseTypeFeedback) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Zone zone(isolate->allocator(), ZONE_NAME);
   const Token::Value kBitwiseBinaryOperators[] = {
       Token::Value::BIT_OR, Token::Value::BIT_XOR, Token::Value::BIT_AND,
       Token::Value::SHL,    Token::Value::SHR,     Token::Value::SAR};
 
   for (Token::Value op : kBitwiseBinaryOperators) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 4, 0, 0);
 
     i::FeedbackVectorSpec feedback_spec(&zone);
     i::FeedbackVectorSlot slot0 = feedback_spec.AddInterpreterBinaryOpICSlot();
     i::FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
     i::FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-    Handle<i::TypeFeedbackVector> vector =
-        i::NewTypeFeedbackVector(isolate, &feedback_spec);
+    Handle<i::TypeFeedbackMetadata> metadata =
+        i::NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
     builder.LoadAccumulatorWithRegister(builder.Parameter(0))
-        .BinaryOperation(op, builder.Parameter(1), vector->GetIndex(slot0))
-        .BinaryOperation(op, builder.Parameter(2), vector->GetIndex(slot1))
-        .BinaryOperation(op, builder.Parameter(3), vector->GetIndex(slot2))
+        .BinaryOperation(op, builder.Parameter(1), GetIndex(slot0))
+        .BinaryOperation(op, builder.Parameter(2), GetIndex(slot1))
+        .BinaryOperation(op, builder.Parameter(3), GetIndex(slot2))
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     typedef Handle<Object> H;
     auto callable = tester.GetCallable<H, H, H, H>();
 
     Handle<Smi> arg1 = Handle<Smi>(Smi::FromInt(2), isolate);
     Handle<Smi> arg2 = Handle<Smi>(Smi::FromInt(2), isolate);
     Handle<HeapNumber> arg3 = isolate->factory()->NewHeapNumber(2.2);
     Handle<String> arg4 = isolate->factory()->NewStringFromAsciiChecked("2");
 
     Handle<Object> return_val =
         callable(arg1, arg2, arg3, arg4).ToHandleChecked();
     USE(return_val);
-    Object* feedback0 = vector->Get(slot0);
+    Object* feedback0 = callable.vector()->Get(slot0);
     CHECK(feedback0->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kSignedSmall,
              static_cast<Smi*>(feedback0)->value());
 
-    Object* feedback1 = vector->Get(slot1);
+    Object* feedback1 = callable.vector()->Get(slot1);
     CHECK(feedback1->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kNumber,
              static_cast<Smi*>(feedback1)->value());
 
-    Object* feedback2 = vector->Get(slot2);
+    Object* feedback2 = callable.vector()->Get(slot2);
     CHECK(feedback2->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kAny,
              static_cast<Smi*>(feedback2)->value());
   }
 }
 
 TEST(InterpreterParameter1Assign) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 0);
@@ skipping 114 matching lines @@
 
 TEST(InterpreterLoadNamedProperty) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 0);
 
-  builder.LoadNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot))
+  builder.LoadNamedProperty(builder.Parameter(0), name, GetIndex(slot))
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<Handle<Object>>();
 
   Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
   // Test IC miss.
   Handle<Object> return_val = callable(object).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
 
   // Test transition to monomorphic IC.
   return_val = callable(object).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
@@ skipping 20 matching lines @@
 
 TEST(InterpreterLoadKeyedProperty) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddKeyedLoadICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Handle<i::String> key = factory->NewStringFromAsciiChecked("key");
   key = factory->string_table()->LookupString(isolate, key);
 
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
   builder.LoadLiteral(key)
-      .LoadKeyedProperty(builder.Parameter(0), vector->GetIndex(slot))
+      .LoadKeyedProperty(builder.Parameter(0), GetIndex(slot))
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<Handle<Object>>();
 
   Handle<Object> object = InterpreterTester::NewObject("({ key : 123 })");
   // Test IC miss.
   Handle<Object> return_val = callable(object).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
 
   // Test transition to monomorphic IC.
   return_val = callable(object).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
 
   // Test transition to megamorphic IC.
   Handle<Object> object3 =
       InterpreterTester::NewObject("({ key : 789, val2 : 123 })");
   return_val = callable(object3).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(789));
 }
 
 
 TEST(InterpreterStoreNamedProperty) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 0);
 
   builder.LoadLiteral(Smi::FromInt(999))
-      .StoreNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot),
-                          STRICT)
+      .StoreNamedProperty(builder.Parameter(0), name, GetIndex(slot), STRICT)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<Handle<Object>>();
   Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
   // Test IC miss.
   Handle<Object> result;
   callable(object).ToHandleChecked();
   CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
   CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
 
   // Test transition to monomorphic IC.
   callable(object).ToHandleChecked();
@@ skipping 24 matching lines @@
 
 TEST(InterpreterStoreKeyedProperty) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddKeyedStoreICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
 
   builder.LoadLiteral(name)
       .StoreAccumulatorInRegister(Register(0))
       .LoadLiteral(Smi::FromInt(999))
-      .StoreKeyedProperty(builder.Parameter(0), Register(0),
-                          vector->GetIndex(slot), i::SLOPPY)
+      .StoreKeyedProperty(builder.Parameter(0), Register(0), GetIndex(slot),
+                          i::SLOPPY)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<Handle<Object>>();
   Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
   // Test IC miss.
   Handle<Object> result;
   callable(object).ToHandleChecked();
   CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
   CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
 
   // Test transition to monomorphic IC.
   callable(object).ToHandleChecked();
@@ skipping 11 matching lines @@
 static void TestInterpreterCall(TailCallMode tail_call_mode) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
   FeedbackVectorSlot call_slot = feedback_spec.AddCallICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
-  int slot_index = vector->GetIndex(slot);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
+  int slot_index = GetIndex(slot);
   int call_slot_index = -1;
-  call_slot_index = vector->GetIndex(call_slot);
+  call_slot_index = GetIndex(call_slot);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("func");
   name = factory->string_table()->LookupString(isolate, name);
 
   // Check with no args.
   {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
     Register reg = builder.register_allocator()->NewRegister();
     RegisterList args = builder.register_allocator()->NewRegisterList(1);
     builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
         .StoreAccumulatorInRegister(reg)
         .MoveRegister(builder.Parameter(0), args[0]);
 
     builder.Call(reg, args, call_slot_index, Call::GLOBAL_CALL, tail_call_mode);
 
     builder.Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() { this.func = function() { return 0x265; }})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0x265));
   }
 
   // Check that receiver is passed properly.
   {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
     Register reg = builder.register_allocator()->NewRegister();
     RegisterList args = builder.register_allocator()->NewRegisterList(1);
     builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
         .StoreAccumulatorInRegister(reg)
         .MoveRegister(builder.Parameter(0), args[0]);
     builder.Call(reg, args, call_slot_index, Call::GLOBAL_CALL, tail_call_mode);
     builder.Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() {"
         "  this.val = 1234;"
         "  this.func = function() { return this.val; };"
         "})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(1234));
   }
@@ skipping 12 matching lines @@
         .StoreAccumulatorInRegister(args[1])
         .LoadLiteral(Smi::FromInt(11))
         .StoreAccumulatorInRegister(args[2]);
 
     builder.Call(reg, args, call_slot_index, Call::GLOBAL_CALL, tail_call_mode);
 
     builder.Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() { "
         "  this.func = function(a, b) { return a - b; }"
         "})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK(return_val->SameValue(Smi::FromInt(40)));
   }
 
@@ skipping 27 matching lines @@
         .StoreAccumulatorInRegister(args[9])
         .LoadLiteral(factory->NewStringFromAsciiChecked("j"))
         .StoreAccumulatorInRegister(args[10]);
 
     builder.Call(reg, args, call_slot_index, Call::GLOBAL_CALL, tail_call_mode);
 
     builder.Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-    InterpreterTester tester(isolate, bytecode_array, vector);
+    InterpreterTester tester(isolate, bytecode_array, metadata);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() { "
         "  this.prefix = \"prefix_\";"
         "  this.func = function(a, b, c, d, e, f, g, h, i, j) {"
         "      return this.prefix + a + b + c + d + e + f + g + h + i + j;"
         "  }"
         "})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
@@ skipping 32 matching lines @@
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Zone zone(isolate->allocator(), ZONE_NAME);
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 2);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[3];
 
   builder.LoadLiteral(Smi::kZero)
       .StoreAccumulatorInRegister(reg)
       .Jump(&label[1]);
   SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
-  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot))
-      .Jump(&label[2]);
+  IncrementRegister(builder, reg, 1, scratch, GetIndex(slot)).Jump(&label[2]);
   SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot1))
+  IncrementRegister(builder, reg, 2, scratch, GetIndex(slot1))
       .JumpLoop(&label[0], 0);
   SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
-  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot2))
+  IncrementRegister(builder, reg, 4, scratch, GetIndex(slot2))
       .LoadAccumulatorWithRegister(reg)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 
 TEST(InterpreterConditionalJumps) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Zone zone(isolate->allocator(), ZONE_NAME);
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 2);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot4 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
   builder.LoadLiteral(Smi::kZero)
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
-  IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
+  IncrementRegister(builder, reg, 1024, scratch, GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
-  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
+  IncrementRegister(builder, reg, 1, scratch, GetIndex(slot1))
       .LoadTrue()
       .JumpIfTrue(&label[1]);
-  IncrementRegister(builder, reg, 2048, scratch, vector->GetIndex(slot2))
+  IncrementRegister(builder, reg, 2048, scratch, GetIndex(slot2))
       .Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot3))
+  IncrementRegister(builder, reg, 2, scratch, GetIndex(slot3))
       .LoadFalse()
       .JumpIfTrue(&done1);
-  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot4))
+  IncrementRegister(builder, reg, 4, scratch, GetIndex(slot4))
       .LoadAccumulatorWithRegister(reg)
       .Bind(&done)
       .Bind(&done1)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 TEST(InterpreterConditionalJumps2) {
   // TODO(oth): Add tests for all conditional jumps near and far.
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Zone zone(isolate->allocator(), ZONE_NAME);
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 2);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot1 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot3 = feedback_spec.AddInterpreterBinaryOpICSlot();
   FeedbackVectorSlot slot4 = feedback_spec.AddInterpreterBinaryOpICSlot();
 
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
   builder.LoadLiteral(Smi::kZero)
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
-  IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
+  IncrementRegister(builder, reg, 1024, scratch, GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
-  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
+  IncrementRegister(builder, reg, 1, scratch, GetIndex(slot1))
       .LoadTrue()
       .JumpIfTrue(&label[1]);
-  IncrementRegister(builder, reg, 2048, scratch, vector->GetIndex(slot2))
+  IncrementRegister(builder, reg, 2048, scratch, GetIndex(slot2))
       .Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot3))
+  IncrementRegister(builder, reg, 2, scratch, GetIndex(slot3))
       .LoadFalse()
       .JumpIfTrue(&done1);
-  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot4))
+  IncrementRegister(builder, reg, 4, scratch, GetIndex(slot4))
       .LoadAccumulatorWithRegister(reg)
       .Bind(&done)
       .Bind(&done1)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 TEST(InterpreterJumpConstantWith16BitOperand) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 257);
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddInterpreterBinaryOpICSlot();
-  Handle<i::TypeFeedbackVector> vector =
-      NewTypeFeedbackVector(isolate, &feedback_spec);
+  Handle<i::TypeFeedbackMetadata> metadata =
+      NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
   Register reg(0), scratch(256);
   BytecodeLabel done, fake;
 
   builder.LoadLiteral(Smi::kZero);
   builder.StoreAccumulatorInRegister(reg);
   // Consume all 8-bit operands
   for (int i = 1; i <= 256; i++) {
     builder.LoadLiteral(isolate->factory()->NewNumber(i));
-    builder.BinaryOperation(Token::Value::ADD, reg, vector->GetIndex(slot));
+    builder.BinaryOperation(Token::Value::ADD, reg, GetIndex(slot));
     builder.StoreAccumulatorInRegister(reg);
   }
   builder.Jump(&done);
 
   // Emit more than 16-bit immediate operands worth of code to jump over.
   builder.Bind(&fake);
   for (int i = 0; i < 6600; i++) {
     builder.LoadLiteral(Smi::kZero);  // 1-byte
     builder.BinaryOperation(Token::Value::ADD, scratch,
-                            vector->GetIndex(slot));      // 6-bytes
+                            GetIndex(slot));              // 6-bytes
     builder.StoreAccumulatorInRegister(scratch);          // 4-bytes
     builder.MoveRegister(scratch, reg);                   // 6-bytes
   }
   builder.Bind(&done);
   builder.LoadAccumulatorWithRegister(reg);
   builder.Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
   BytecodeArrayIterator iterator(bytecode_array);
 
   bool found_16bit_constant_jump = false;
   while (!iterator.done()) {
     if (iterator.current_bytecode() == Bytecode::kJumpConstant &&
         iterator.current_operand_scale() == OperandScale::kDouble) {
       found_16bit_constant_jump = true;
       break;
     }
     iterator.Advance();
   }
   CHECK(found_16bit_constant_jump);
 
-  InterpreterTester tester(isolate, bytecode_array, vector);
+  InterpreterTester tester(isolate, bytecode_array, metadata);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 256.0 / 2 * (1 + 256));
 }
 
 TEST(InterpreterJumpWith32BitOperand) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
   Register reg(0);
@@ skipping 82 matching lines @@
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         HandleAndZoneScope handles;
         Isolate* isolate = handles.main_isolate();
         Zone zone(isolate->allocator(), ZONE_NAME);
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 1);
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterCompareICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         Register r0(0);
         builder.LoadLiteral(Smi::FromInt(inputs[i]))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(Smi::FromInt(inputs[j]))
-            .CompareOperation(comparison, r0, vector->GetIndex(slot))
+            .CompareOperation(comparison, r0, GetIndex(slot))
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         CHECK(return_value->IsBoolean());
         CHECK_EQ(return_value->BooleanValue(),
                  CompareC(comparison, inputs[i], inputs[j]));
-        Object* feedback = vector->Get(slot);
+        Object* feedback = callable.vector()->Get(slot);
         CHECK(feedback->IsSmi());
         CHECK_EQ(CompareOperationFeedback::kSignedSmall,
                  static_cast<Smi*>(feedback)->value());
       }
     }
   }
 }
 
 
 TEST(InterpreterHeapNumberComparisons) {
   double inputs[] = {std::numeric_limits<double>::min(),
                      std::numeric_limits<double>::max(),
                      -0.001,
                      0.01,
                      0.1000001,
                      1e99,
                      -1e-99};
   for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         HandleAndZoneScope handles;
         Isolate* isolate = handles.main_isolate();
         Factory* factory = isolate->factory();
         Zone zone(isolate->allocator(), ZONE_NAME);
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 1);
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterCompareICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         Register r0(0);
         builder.LoadLiteral(factory->NewHeapNumber(inputs[i]))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(factory->NewHeapNumber(inputs[j]))
-            .CompareOperation(comparison, r0, vector->GetIndex(slot))
+            .CompareOperation(comparison, r0, GetIndex(slot))
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         CHECK(return_value->IsBoolean());
         CHECK_EQ(return_value->BooleanValue(),
                  CompareC(comparison, inputs[i], inputs[j]));
-        Object* feedback = vector->Get(slot);
+        Object* feedback = callable.vector()->Get(slot);
         CHECK(feedback->IsSmi());
         CHECK_EQ(CompareOperationFeedback::kNumber,
                  static_cast<Smi*>(feedback)->value());
       }
     }
   }
 }
 
 
 TEST(InterpreterStringComparisons) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Factory* factory = isolate->factory();
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   std::string inputs[] = {"A", "abc", "z", "", "Foo!", "Foo"};
 
   for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         CanonicalHandleScope canonical(isolate);
         const char* lhs = inputs[i].c_str();
         const char* rhs = inputs[j].c_str();
 
         FeedbackVectorSpec feedback_spec(&zone);
         FeedbackVectorSlot slot = feedback_spec.AddInterpreterCompareICSlot();
-        Handle<i::TypeFeedbackVector> vector =
-            NewTypeFeedbackVector(isolate, &feedback_spec);
+        Handle<i::TypeFeedbackMetadata> metadata =
+            NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
         BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 1);
         Register r0(0);
         builder.LoadLiteral(factory->InternalizeUtf8String(lhs))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(factory->InternalizeUtf8String(rhs))
-            .CompareOperation(comparison, r0, vector->GetIndex(slot))
+            .CompareOperation(comparison, r0, GetIndex(slot))
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-        InterpreterTester tester(isolate, bytecode_array, vector);
+        InterpreterTester tester(isolate, bytecode_array, metadata);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         CHECK(return_value->IsBoolean());
         CHECK_EQ(return_value->BooleanValue(),
                  CompareC(comparison, inputs[i], inputs[j]));
-        Object* feedback = vector->Get(slot);
+        Object* feedback = callable.vector()->Get(slot);
         CHECK(feedback->IsSmi());
         int const expected_feedback =
             Token::IsOrderedRelationalCompareOp(comparison)
                 ? CompareOperationFeedback::kString
                 : CompareOperationFeedback::kInternalizedString;
         CHECK_EQ(expected_feedback, static_cast<Smi*>(feedback)->value());
       }
     }
   }
 }
@@ skipping 20 matching lines @@
           double rhs = StringToDouble(&unicode_cache, rhs_cstr,
                                       ConversionFlags::NO_FLAGS);
           HandleAndZoneScope handles;
           Isolate* isolate = handles.main_isolate();
           Factory* factory = isolate->factory();
           BytecodeArrayBuilder builder(isolate, handles.main_zone(), 0, 0, 1);
           Zone zone(isolate->allocator(), ZONE_NAME);
 
           FeedbackVectorSpec feedback_spec(&zone);
           FeedbackVectorSlot slot = feedback_spec.AddInterpreterCompareICSlot();
-          Handle<i::TypeFeedbackVector> vector =
-              NewTypeFeedbackVector(isolate, &feedback_spec);
+          Handle<i::TypeFeedbackMetadata> metadata =
+              NewTypeFeedbackMetadata(isolate, &feedback_spec);
 
           Register r0(0);
           if (pass == 0) {
             // Comparison with HeapNumber on the lhs and String on the rhs
             builder.LoadLiteral(factory->NewNumber(lhs))
                 .StoreAccumulatorInRegister(r0)
                 .LoadLiteral(factory->NewStringFromAsciiChecked(rhs_cstr))
-                .CompareOperation(comparison, r0, vector->GetIndex(slot))
+                .CompareOperation(comparison, r0, GetIndex(slot))
                 .Return();
           } else {
             // Comparison with HeapNumber on the rhs and String on the lhs
             builder.LoadLiteral(factory->NewStringFromAsciiChecked(lhs_cstr))
                 .StoreAccumulatorInRegister(r0)
                 .LoadLiteral(factory->NewNumber(rhs))
-                .CompareOperation(comparison, r0, vector->GetIndex(slot))
+                .CompareOperation(comparison, r0, GetIndex(slot))
                 .Return();
           }
 
           Handle<BytecodeArray> bytecode_array =
               builder.ToBytecodeArray(isolate);
-          InterpreterTester tester(isolate, bytecode_array, vector);
+          InterpreterTester tester(isolate, bytecode_array, metadata);
           auto callable = tester.GetCallable<>();
           Handle<Object> return_value = callable().ToHandleChecked();
           CHECK(return_value->IsBoolean());
           CHECK_EQ(return_value->BooleanValue(),
                    CompareC(comparison, lhs, rhs, true));
-          Object* feedback = vector->Get(slot);
+          Object* feedback = callable.vector()->Get(slot);
           CHECK(feedback->IsSmi());
           // kNumber | kString gets converted to CompareOperationHint::kAny.
           int expected_feedback = CompareOperationFeedback::kNumber |
                                   CompareOperationFeedback::kString;
           CHECK_EQ(expected_feedback, static_cast<Smi*>(feedback)->value());
         }
       }
     }
   }
 }
@@ skipping 2936 matching lines @@
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*tests[i].second));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8