[interpreter]: Update BytecodeArrayBuilder register handling.

test/unittests/interpreter/bytecode-array-builder-unittest.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/interpreter/bytecode-array-builder.h"
-#include "test/cctest/cctest.h"
+#include "test/unittests/test-utils.h"
 
-using namespace v8::internal;
-using namespace v8::internal::interpreter;
+namespace v8 {
+namespace internal {
+namespace interpreter {
 
-TEST(AllBytecodesGenerated) {
-  InitializedHandleScope handle_scope;
-  BytecodeArrayBuilder builder(handle_scope.main_isolate());
+class BytecodeArrayBuilderTest : public TestWithIsolate {
+ public:
+  BytecodeArrayBuilderTest() {}
+  ~BytecodeArrayBuilderTest() override {}
+};
+
+
+TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
+  BytecodeArrayBuilder builder(isolate());
 
   builder.set_locals_count(1);
   CHECK_EQ(builder.locals_count(), 1);
 
   // Emit constant loads.
   builder.LoadLiteral(Smi::FromInt(0))
       .LoadLiteral(Smi::FromInt(8))
       .LoadUndefined()
       .LoadNull()
       .LoadTheHole()
       .LoadTrue()
       .LoadFalse();
 
   // Emit accumulator transfers.
-  builder.LoadAccumulatorWithRegister(0).StoreAccumulatorInRegister(0);
+  Register reg(0);
+  builder.LoadAccumulatorWithRegister(reg).StoreAccumulatorInRegister(reg);
 
   // Emit binary operators invocations.
-  builder.BinaryOperation(Token::Value::ADD, 0)
-      .BinaryOperation(Token::Value::SUB, 0)
-      .BinaryOperation(Token::Value::MUL, 0)
-      .BinaryOperation(Token::Value::DIV, 0);
+  builder.BinaryOperation(Token::Value::ADD, reg)
+      .BinaryOperation(Token::Value::SUB, reg)
+      .BinaryOperation(Token::Value::MUL, reg)
+      .BinaryOperation(Token::Value::DIV, reg);
 
   // Emit control flow. Return must be the last instruction.
   builder.Return();
 
   // Generate BytecodeArray.
   Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
   CHECK_EQ(the_array->frame_size(), builder.locals_count() * kPointerSize);
 
   // Build scorecard of bytecodes encountered in the BytecodeArray.
   std::vector<int> scorecard(Bytecodes::ToByte(Bytecode::kLast) + 1);
@@ skipping 12 matching lines @@
   CHECK_EQ(scorecard[Bytecodes::ToByte(final_bytecode)], 1);
 
 #define CHECK_BYTECODE_PRESENT(Name, ...)     \
   /* Check Bytecode is marked in scorecard */ \
   CHECK_GE(scorecard[Bytecodes::ToByte(Bytecode::k##Name)], 1);
   BYTECODE_LIST(CHECK_BYTECODE_PRESENT)
 #undef CHECK_BYTECODE_PRESENT
 }
 
 
-TEST(FrameSizesLookGood) {
+TEST_F(BytecodeArrayBuilderTest, FrameSizesLookGood) {
   for (int locals = 0; locals < 5; locals++) {
     for (int temps = 0; temps < 3; temps++) {
-      InitializedHandleScope handle_scope;
-      BytecodeArrayBuilder builder(handle_scope.main_isolate());
+      BytecodeArrayBuilder builder(isolate());
       builder.set_locals_count(locals);
       builder.Return();
 
       TemporaryRegisterScope temporaries(&builder);
       for (int i = 0; i < temps; i++) {
         temporaries.NewRegister();
       }
 
       Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
       int total_registers = locals + temps;
       CHECK_EQ(the_array->frame_size(), total_registers * kPointerSize);
     }
   }
 }
 
 
-TEST(TemporariesRecycled) {
-  InitializedHandleScope handle_scope;
-  BytecodeArrayBuilder builder(handle_scope.main_isolate());
+TEST_F(BytecodeArrayBuilderTest, TemporariesRecycled) {
+  BytecodeArrayBuilder builder(isolate());
   builder.set_locals_count(0);
   builder.Return();
 
   int first;
   {
     TemporaryRegisterScope temporaries(&builder);
-    first = temporaries.NewRegister();
+    first = temporaries.NewRegister().index();
     temporaries.NewRegister();
     temporaries.NewRegister();
     temporaries.NewRegister();
   }
 
   int second;
   {
     TemporaryRegisterScope temporaries(&builder);
-    second = temporaries.NewRegister();
+    second = temporaries.NewRegister().index();
   }
 
   CHECK_EQ(first, second);
 }
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8