[interpreter] Minor clean-up of BytecodeSourceInfo.

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 81 matching lines @@
 }  // namespace
 
 void BytecodeArrayBuilder::AttachSourceInfo(BytecodeNode* node) {
   if (latest_source_info_.is_valid()) {
     // 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_;
+      node->source_info().MakeInvalidEqualTo(latest_source_info_);
       latest_source_info_.set_invalid();
     }
   }
 }
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t operand0,
                                   uint32_t operand1, uint32_t operand2,
                                   uint32_t operand3) {
   DCHECK(OperandsAreValid(bytecode, 4, operand0, operand1, operand2, operand3));
   BytecodeNode node(bytecode, operand0, operand1, operand2, operand3);
@@ skipping 320 matching lines @@
   return OutputJump(Bytecode::kJumpIfUndefined, label);
 }
 
 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_ = {position, false};
+    // We need to attach a non-breakable source position to a stack
+    // check, so we simply add it as expression position. There can be
+    // a prior statement position from constructs like:
+    //
+    //    do var x;  while (false);
+    //
+    // A Nop could be inserted for empty statements, but since no code
+    // is associated with these positions, they are ignored for now.

[rmcilroy, 2016/06/20 11:21:39]

/s/they are ignored for now/instead we force the stack check's expression
position which eliminates the empty statement's position/ (or something similar)

[oth, 2016/06/21 10:05:46]

Done.

+    latest_source_info_.ForceExpressionPosition(position);
   }
   Output(Bytecode::kStackCheck);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Throw() {
   Output(Bytecode::kThrow);
   return *this;
 }
 
@@ skipping 152 matching lines @@
   Output(BytecodeForDelete(language_mode), RegisterOperand(object));
   return *this;
 }
 
 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   return constant_array_builder()->Insert(object);
 }
 
 void BytecodeArrayBuilder::SetReturnPosition() {
   if (return_position_ == RelocInfo::kNoPosition) return;
-  latest_source_info_.Update({return_position_, true});
+  latest_source_info_.MakeStatementPosition(return_position_);
 }
 
 void BytecodeArrayBuilder::SetStatementPosition(Statement* stmt) {
   if (stmt->position() == RelocInfo::kNoPosition) return;
-  latest_source_info_.Update({stmt->position(), true});
+  latest_source_info_.MakeStatementPosition(stmt->position());
 }
 
 void BytecodeArrayBuilder::SetExpressionPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
-  if (latest_source_info_.is_expression()) {
+  if (!latest_source_info_.is_statement()) {
     // 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_.MakeExpressionPosition(expr->position());
   }
-  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});
+  latest_source_info_.MakeStatementPosition(expr->position());
 }
 
 bool BytecodeArrayBuilder::TemporaryRegisterIsLive(Register reg) const {
   return temporary_register_allocator()->RegisterIsLive(reg);
 }
 
 bool BytecodeArrayBuilder::RegisterIsValid(Register reg) const {
   if (!reg.is_valid()) {
     return false;
   }
@@ skipping 264 matching lines @@
       return Bytecode::kTailCall;
     default:
       UNREACHABLE();
   }
   return Bytecode::kIllegal;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8