Avoid accessing Isolate in source position logging.

src/source-position-table.cc

 // Copyright 2016 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/source-position-table.h"
 
 #include "src/log.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 
@@ skipping 87 matching lines @@
   } else {
     entry->is_statement = false;
     entry->code_offset = -(tmp + 1);
   }
   DecodeInt(bytes, index, &entry->source_position);
 }
 
 }  // namespace
 
 SourcePositionTableBuilder::SourcePositionTableBuilder(
-    Isolate* isolate, Zone* zone,
-    SourcePositionTableBuilder::RecordingMode mode)
-    : isolate_(isolate),
-      mode_(mode),
+    Zone* zone, SourcePositionTableBuilder::RecordingMode mode)
+    : mode_(mode),
       bytes_(zone),
 #ifdef ENABLE_SLOW_DCHECKS
       raw_entries_(zone),
 #endif
-      previous_(),
-      jit_handler_data_(nullptr) {
-  if (Omit()) return;
-  LOG_CODE_EVENT(isolate_, CodeStartLinePosInfoRecordEvent(&jit_handler_data_));
-}
-
-void SourcePositionTableBuilder::EndJitLogging(AbstractCode* code) {
-  if (Omit()) return;
-  LOG_CODE_EVENT(isolate_,
-                 CodeEndLinePosInfoRecordEvent(code, jit_handler_data_));
+      previous_() {
 }
 
 void SourcePositionTableBuilder::AddPosition(size_t code_offset,
                                              int source_position,
                                              bool is_statement) {
   if (Omit()) return;
   int offset = static_cast<int>(code_offset);
   AddEntry({offset, source_position, is_statement});
 }
 
 void SourcePositionTableBuilder::AddEntry(const PositionTableEntry& entry) {
   PositionTableEntry tmp(entry);
   SubtractFromEntry(tmp, previous_);
   EncodeEntry(bytes_, tmp);
   previous_ = entry;
-
-  if (entry.is_statement) {
-    LOG_CODE_EVENT(isolate_, CodeLinePosInfoAddStatementPositionEvent(
-                                 jit_handler_data_, entry.code_offset,
-                                 entry.source_position));
-  }
-  LOG_CODE_EVENT(isolate_, CodeLinePosInfoAddPositionEvent(
-                               jit_handler_data_, entry.code_offset,
-                               entry.source_position));
-
 #ifdef ENABLE_SLOW_DCHECKS
   raw_entries_.push_back(entry);
 #endif
 }
 
-Handle<ByteArray> SourcePositionTableBuilder::ToSourcePositionTable() {
-  if (bytes_.empty()) return isolate_->factory()->empty_byte_array();
+Handle<ByteArray> SourcePositionTableBuilder::ToSourcePositionTable(
+    Isolate* isolate, Handle<AbstractCode> code) {
+  if (bytes_.empty()) return isolate->factory()->empty_byte_array();
   DCHECK(!Omit());
 
-  Handle<ByteArray> table = isolate_->factory()->NewByteArray(
+  Handle<ByteArray> table = isolate->factory()->NewByteArray(
       static_cast<int>(bytes_.size()), TENURED);
 
   MemCopy(table->GetDataStartAddress(), &*bytes_.begin(), bytes_.size());
 
+  LOG_CODE_EVENT(isolate, CodeLinePosInfoRecordEvent(*code, *table));
+
 #ifdef ENABLE_SLOW_DCHECKS
   // Brute force testing: Record all positions and decode
   // the entire table to verify they are identical.
   auto raw = raw_entries_.begin();
   for (SourcePositionTableIterator encoded(*table); !encoded.done();
        encoded.Advance(), raw++) {
     DCHECK(raw != raw_entries_.end());
     DCHECK_EQ(encoded.code_offset(), raw->code_offset);
     DCHECK_EQ(encoded.source_position(), raw->source_position);
     DCHECK_EQ(encoded.is_statement(), raw->is_statement);
@@ skipping 17 matching lines @@
     index_ = kDone;
   } else {
     PositionTableEntry tmp;
     DecodeEntry(table_, &index_, &tmp);
     AddAndSetEntry(current_, tmp);
   }
 }
 
 }  // namespace internal
 }  // namespace v8