Do not record source positions for non-JS or native script code.

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 86 matching lines @@
     entry->code_offset = tmp;
   } else {
     entry->is_statement = false;
     entry->code_offset = -(tmp + 1);
   }
   DecodeInt(bytes, index, &entry->source_position);
 }
 
 }  // namespace
 
-SourcePositionTableBuilder::SourcePositionTableBuilder(Isolate* isolate,
-                                                       Zone* zone)
+SourcePositionTableBuilder::SourcePositionTableBuilder(
+    Isolate* isolate, Zone* zone,
+    SourcePositionTableBuilder::RecordingMode mode)
     : isolate_(isolate),
+      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_));
 }
 
 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();
+  DCHECK(!Omit());
 
   Handle<ByteArray> table = isolate_->factory()->NewByteArray(
       static_cast<int>(bytes_.size()), TENURED);
 
   MemCopy(table->GetDataStartAddress(), &*bytes_.begin(), bytes_.size());
 
 #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);
   }
   DCHECK(raw == raw_entries_.end());
+  // No additional source positions after creating the table.
+  mode_ = OMIT_SOURCE_POSITIONS;
 #endif
-
   return table;
 }
 
 SourcePositionTableIterator::SourcePositionTableIterator(ByteArray* byte_array)
     : table_(byte_array), index_(0), current_() {
   Advance();
 }
 
 void SourcePositionTableIterator::Advance() {
   DCHECK(!done());
   DCHECK(index_ >= 0 && index_ <= table_->length());
   if (index_ == table_->length()) {
     index_ = kDone;
   } else {
     PositionTableEntry tmp;
     DecodeEntry(table_, &index_, &tmp);
     AddAndSetEntry(current_, tmp);
   }
 }
 
 }  // namespace internal
 }  // namespace v8