[Interpreter] Avoid accessing Isolate from during bytecode generation.

src/interpreter/bytecode-array-writer.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-array-writer.h"
 
 #include "src/api.h"
 #include "src/interpreter/bytecode-label.h"
 #include "src/interpreter/bytecode-register.h"
 #include "src/interpreter/constant-array-builder.h"
 #include "src/log.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 STATIC_CONST_MEMBER_DEFINITION const size_t
     BytecodeArrayWriter::kMaxSizeOfPackedBytecode;
 
 BytecodeArrayWriter::BytecodeArrayWriter(
-    Isolate* isolate, Zone* zone, ConstantArrayBuilder* constant_array_builder,
+    Zone* zone, ConstantArrayBuilder* constant_array_builder,
     SourcePositionTableBuilder::RecordingMode source_position_mode)
-    : isolate_(isolate),
-      bytecodes_(zone),
+    : bytecodes_(zone),
       max_register_count_(0),
       unbound_jumps_(0),
       source_position_table_builder_(zone, source_position_mode),
       constant_array_builder_(constant_array_builder) {}
 
 // override
 BytecodeArrayWriter::~BytecodeArrayWriter() {}
 
 // override
 Handle<BytecodeArray> BytecodeArrayWriter::ToBytecodeArray(
-    int fixed_register_count, int parameter_count,
+    Isolate* isolate, int fixed_register_count, int parameter_count,
     Handle<FixedArray> handler_table) {
   DCHECK_EQ(0, unbound_jumps_);
 
   int bytecode_size = static_cast<int>(bytecodes()->size());
 
   // All locals need a frame slot for the debugger, but may not be
   // present in generated code.
   int frame_size_for_locals = fixed_register_count * kPointerSize;
   int frame_size_used = max_register_count() * kPointerSize;
   int frame_size = std::max(frame_size_for_locals, frame_size_used);
-  Handle<FixedArray> constant_pool = constant_array_builder()->ToFixedArray();
-  Handle<BytecodeArray> bytecode_array = isolate_->factory()->NewBytecodeArray(
+  Handle<FixedArray> constant_pool =
+      constant_array_builder()->ToFixedArray(isolate);
+  Handle<BytecodeArray> bytecode_array = isolate->factory()->NewBytecodeArray(
       bytecode_size, &bytecodes()->front(), frame_size, parameter_count,
       constant_pool);
   bytecode_array->set_handler_table(*handler_table);
   Handle<ByteArray> source_position_table =
       source_position_table_builder()->ToSourcePositionTable(
-          isolate(), Handle<AbstractCode>::cast(bytecode_array));
+          isolate, Handle<AbstractCode>::cast(bytecode_array));
   bytecode_array->set_source_position_table(*source_position_table);
   return bytecode_array;
 }
 
 // override
 void BytecodeArrayWriter::Write(BytecodeNode* node) {
   DCHECK(!Bytecodes::IsJump(node->bytecode()));
   UpdateSourcePositionTable(node);
   EmitBytecode(node);
 }
@@ skipping 319 matching lines @@
         node->set_bytecode(node->bytecode(), k32BitJumpPlaceholder);
         break;
     }
   }
   EmitBytecode(node);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8