[interpreter] Ensure optimizations preserve source positions.

src/interpreter/bytecode-peephole-optimizer.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-peephole-optimizer.h"
 
 #include "src/interpreter/constant-array-builder.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 
@@ skipping 155 matching lines @@
   //
   return (!last_.source_info().is_valid() ||
           !current->source_info().is_valid());
 }
 
 namespace {
 
 void TransformLdaStarToLdrLdar(Bytecode new_bytecode, BytecodeNode* const last,
                                BytecodeNode* const current) {
   DCHECK_EQ(current->bytecode(), Bytecode::kStar);
+
   //
   // An example transformation here would be:
   //
   //   LdaGlobal i0, i1  ____\  LdrGlobal i0, i1, R
   //   Star R            ====/  Ldar R
   //
   // which loads a global value into both a register and the
   // accumulator. However, in the second form the Ldar can often be
   // peephole optimized away unlike the Star in the first form.
   //
   last->Transform(new_bytecode, current->operand(0), current->operand_scale());
   current->set_bytecode(Bytecode::kLdar, current->operand(0),
                         current->operand_scale());
-
-  // If there was a source position on |current| transfer it to the
-  // updated |last| to maintain the debugger's causal view. ie. if an
-  // expression position LdrGlobal is the bytecode that could throw
-  // and if a statement position it needs to be placed before the
-  // store to R occurs.
-  last->source_info().Update(current->source_info());
-  current->source_info().set_invalid();
 }
 
 }  // namespace
 
-bool BytecodePeepholeOptimizer::ChangeLdaToLdr(BytecodeNode* const current) {
-  if (current->bytecode() == Bytecode::kStar) {
+bool BytecodePeepholeOptimizer::TransformLastAndCurrentBytecodes(
+    BytecodeNode* const current) {
+  if (current->bytecode() == Bytecode::kStar &&
+      !current->source_info().is_statement()) {
+    // Note: If the Star is tagged with a statement position, we can't
+    // perform this transform as the store to the register will
+    // have the wrong ordering for stepping in the debugger.
     switch (last_.bytecode()) {
       case Bytecode::kLdaNamedProperty:
         TransformLdaStarToLdrLdar(Bytecode::kLdrNamedProperty, &last_, current);
         return true;
       case Bytecode::kLdaKeyedProperty:
         TransformLdaStarToLdrLdar(Bytecode::kLdrKeyedProperty, &last_, current);
         return true;
       case Bytecode::kLdaGlobal:
         TransformLdaStarToLdrLdar(Bytecode::kLdrGlobal, &last_, current);
         return true;
@@ skipping 32 matching lines @@
                     Bytecodes::WritesBooleanToAccumulator(last_.bytecode());
   if (can_remove) {
     // Logical-nots are emitted in ToBoolean form by the bytecode array
     // builder, The ToBoolean element can be removed if the previous bytecode
     // put a boolean value in the accumulator.
     current->set_bytecode(Bytecode::kLogicalNot);
   }
   return can_remove;
 }
 
-bool BytecodePeepholeOptimizer::TransformLastAndCurrentBytecodes(
+bool BytecodePeepholeOptimizer::TransformCurrentBytecode(
     BytecodeNode* const current) {
   return RemoveToBooleanFromJump(current) ||
-         RemoveToBooleanFromLogicalNot(current) || ChangeLdaToLdr(current);
+         RemoveToBooleanFromLogicalNot(current);
 }
 
 bool BytecodePeepholeOptimizer::CanElideLast(
     const BytecodeNode* const current) const {
   if (last_.bytecode() == Bytecode::kNop) {
     // Nop are placeholders for holding source position information.
     return true;
   } else if (Bytecodes::IsAccumulatorLoadWithoutEffects(current->bytecode()) &&
              Bytecodes::IsAccumulatorLoadWithoutEffects(last_.bytecode())) {
     // The accumulator is invisible to the debugger. If there is a sequence of
     // consecutive accumulator loads (that don't have side effects) then only
     // the final load is potentially visible.
     return true;
   } else if (Bytecodes::GetAccumulatorUse(current->bytecode()) ==
                  AccumulatorUse::kWrite &&
              Bytecodes::IsAccumulatorLoadWithoutEffects(last_.bytecode())) {
     // The current instruction clobbers the accumulator without reading it. The
     // load in the last instruction can be elided as it has no effect.
     return true;
   } else {
     return false;
   }
 }
 
 BytecodeNode* BytecodePeepholeOptimizer::Optimize(BytecodeNode* current) {
   TryToRemoveLastExpressionPosition(current);
 
-  if (TransformLastAndCurrentBytecodes(current)) {
+  if (TransformCurrentBytecode(current) ||
+      TransformLastAndCurrentBytecodes(current)) {
     return current;
   }
 
   if (CanElideCurrent(current)) {
     if (current->source_info().is_valid()) {
       // Preserve the source information by replacing the current bytecode
       // with a no op bytecode.
       current->set_bytecode(Bytecode::kNop);
     } else {
       current = nullptr;
@@ skipping 20 matching lines @@
       next_stage_->Write(&last_);
       InvalidateLast();
     }
   }
   return current;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8