Use source position table for unoptimized code.

test/cctest/interpreter/source-position-matcher.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 "test/cctest/interpreter/source-position-matcher.h"
 
 #include "src/objects-inl.h"
 #include "src/objects.h"
 
 namespace v8 {
@@ skipping 69 matching lines @@
       return false;
     }
 
     if (HasNewExpressionPositionsInOptimized(&original_expression_entries,
                                              &optimized_expression_entries)) {
       return false;
     }
 
     StripUnneededExpressionPositions(original_bytecode,
                                      &original_expression_entries,
-                                     original.bytecode_offset());
+                                     original.code_offset());
     StripUnneededExpressionPositions(optimized_bytecode,
                                      &optimized_expression_entries,
-                                     optimized.bytecode_offset());
+                                     optimized.code_offset());
 
     if (!CompareExpressionPositions(&original_expression_entries,
                                     &optimized_expression_entries)) {
       // Message logged in CompareExpressionPositions().
       return false;
     }
 
     // Check original and optimized have matching source positions.
     if (original.source_position() != optimized.source_position()) {
       return false;
     }
 
-    if (original.bytecode_offset() < last_original_bytecode_offset) {
+    if (original.code_offset() < last_original_bytecode_offset) {
       return false;
     }
-    last_original_bytecode_offset = original.bytecode_offset();
+    last_original_bytecode_offset = original.code_offset();
 
-    if (optimized.bytecode_offset() < last_optimized_bytecode_offset) {
+    if (optimized.code_offset() < last_optimized_bytecode_offset) {
       return false;
     }
-    last_optimized_bytecode_offset = optimized.bytecode_offset();
+    last_optimized_bytecode_offset = optimized.code_offset();
 
     // TODO(oth): Can we compare statement positions are semantically
     // equivalent? e.g. before a bytecode that has debugger observable
     // effects. This is likely non-trivial.
   }
 
   return true;
 }
 
 bool SourcePositionMatcher::HasNewExpressionPositionsInOptimized(
@@ skipping 38 matching lines @@
 void SourcePositionMatcher::StripUnneededExpressionPositions(
     Handle<BytecodeArray> bytecode_array,
     std::vector<PositionTableEntry>* expression_positions,
     int next_statement_bytecode_offset) {
   size_t j = 0;
   for (size_t i = 0; i < expression_positions->size(); ++i) {
     CHECK(expression_positions->at(i).source_position > 0 &&
           !expression_positions->at(i).is_statement);
     int bytecode_end = (i == expression_positions->size() - 1)
                            ? next_statement_bytecode_offset
-                           : expression_positions->at(i + 1).bytecode_offset;
+                           : expression_positions->at(i + 1).code_offset;
     if (ExpressionPositionIsNeeded(bytecode_array,
-                                   expression_positions->at(i).bytecode_offset,
+                                   expression_positions->at(i).code_offset,
                                    bytecode_end)) {
       expression_positions->at(j++) = expression_positions->at(i);
     }
   }
   expression_positions->resize(j);
 }
 
 void SourcePositionMatcher::AdvanceBytecodeIterator(
     BytecodeArrayIterator* iterator, int bytecode_offset) {
   while (iterator->current_offset() != bytecode_offset) {
@@ skipping 20 matching lines @@
 
 void SourcePositionMatcher::MoveToNextStatement(
     SourcePositionTableIterator* iterator,
     std::vector<PositionTableEntry>* positions) {
   iterator->Advance();
   positions->clear();
   while (!iterator->done()) {
     if (iterator->is_statement()) {
       break;
     }
-    positions->push_back({iterator->bytecode_offset(),
-                          iterator->source_position(),
+    positions->push_back({iterator->code_offset(), iterator->source_position(),
                           iterator->is_statement()});
     iterator->Advance();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8