[interpreter] Filter expression positions at source.

src/interpreter/bytecode-array-builder.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-builder.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-writer.h"
 #include "src/interpreter/bytecode-label.h"
 #include "src/interpreter/bytecode-peephole-optimizer.h"
@@ skipping 61 matching lines @@
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK(return_seen_in_block_);
   DCHECK(!bytecode_generated_);
   bytecode_generated_ = true;
 
   Handle<FixedArray> handler_table = handler_table_builder()->ToHandlerTable();
   return pipeline_->ToBytecodeArray(fixed_register_count(), parameter_count(),
                                     handler_table);
 }
 
+namespace {
+
+static bool ExpressionPositionIsNeeded(Bytecode bytecode) {
+  // An expression position is always needed if filtering is turned
+  // off. Otherwise an expression is only needed if the bytecode has
+  // external side effects.
+  return !FLAG_ignition_filter_expression_positions ||
+         !Bytecodes::IsWithoutExternalSideEffects(bytecode);
+}
+
+}  // namespace
+
 void BytecodeArrayBuilder::AttachSourceInfo(BytecodeNode* node) {
   if (latest_source_info_.is_valid()) {
-    node->source_info().Update(latest_source_info_);
-    latest_source_info_.set_invalid();
+    // Statement positions need to be emitted immediately.  Expression
+    // positions can be pushed back until a bytecode is found that can
+    // throw. Hence we only invalidate the existing source position
+    // information if it is used.
+    if (latest_source_info_.is_statement() ||
+        ExpressionPositionIsNeeded(node->bytecode())) {
+      node->source_info() = latest_source_info_;
+      latest_source_info_.set_invalid();
+    }
   }
 }
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
   BytecodeNode node(bytecode);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
@@ skipping 397 matching lines @@
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotHole(
     BytecodeLabel* label) {
   return OutputJump(Bytecode::kJumpIfNotHole, label);
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StackCheck(int position) {
   if (position != RelocInfo::kNoPosition) {
     // We need to attach a non-breakable source position to a stack check,
     // so we simply add it as expression position.
-    latest_source_info_.Update({position, false});
+    latest_source_info_ = {position, false};
   }
   Output(Bytecode::kStackCheck);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Throw() {
   Output(Bytecode::kThrow);
   return *this;
 }
 
@@ skipping 201 matching lines @@
   latest_source_info_.Update({return_position_, true});
 }
 
 void BytecodeArrayBuilder::SetStatementPosition(Statement* stmt) {
   if (stmt->position() == RelocInfo::kNoPosition) return;
   latest_source_info_.Update({stmt->position(), true});
 }
 
 void BytecodeArrayBuilder::SetExpressionPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
+  if (latest_source_info_.is_expression()) {
+    // Ensure the current expression position is overwritten with the
+    // latest value.
+    //
+    // TODO(oth): Clean-up BytecodeSourceInfo to have three states and
+    // simplify the update logic, taking care to ensure position
+    // information is not lost.
+    latest_source_info_.set_invalid();
+  }
   latest_source_info_.Update({expr->position(), false});
 }
 
 void BytecodeArrayBuilder::SetExpressionAsStatementPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
   latest_source_info_.Update({expr->position(), true});
 }
 
 bool BytecodeArrayBuilder::TemporaryRegisterIsLive(Register reg) const {
   return temporary_register_allocator()->RegisterIsLive(reg);
@@ skipping 283 matching lines @@
 }
 
 uint32_t BytecodeArrayBuilder::UnsignedOperand(size_t value) {
   DCHECK_LE(value, kMaxUInt32);
   return static_cast<uint32_t>(value);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8