[Interpreter] Don't try to eliminate dead-code in bytecode-array-builder

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-peephole-optimizer.h"
 #include "src/interpreter/bytecode-register-optimizer.h"
 #include "src/interpreter/interpreter-intrinsics.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone,
                                            int parameter_count,
                                            int context_count, int locals_count,
                                            FunctionLiteral* literal)
     : isolate_(isolate),
       zone_(zone),
       bytecode_generated_(false),
       constant_array_builder_(isolate, zone),
       handler_table_builder_(isolate, zone),
       source_position_table_builder_(isolate, zone),
-      exit_seen_in_block_(false),
+      return_seen_in_block_(false),
       unbound_jumps_(0),
       parameter_count_(parameter_count),
       local_register_count_(locals_count),
       context_register_count_(context_count),
       temporary_allocator_(zone, fixed_register_count()),
       bytecode_array_writer_(zone, &source_position_table_builder_),
       pipeline_(&bytecode_array_writer_) {
   DCHECK_GE(parameter_count_, 0);
   DCHECK_GE(context_register_count_, 0);
   DCHECK_GE(local_register_count_, 0);
@@ skipping 34 matching lines @@
 
 
 bool BytecodeArrayBuilder::RegisterIsParameterOrLocal(Register reg) const {
   return reg.is_parameter() || reg.index() < locals_count();
 }
 
 
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(0, unbound_jumps_);
   DCHECK_EQ(bytecode_generated_, false);
-  DCHECK(exit_seen_in_block_);
+  DCHECK(return_seen_in_block_);
 
   pipeline()->FlushBasicBlock();
   const ZoneVector<uint8_t>* bytecodes = bytecode_array_writer()->bytecodes();
 
   int bytecode_size = static_cast<int>(bytecodes->size());
 
   // All locals need a frame slot for the debugger, but may not be
   // present in generated code.
   int frame_size_for_locals = fixed_register_count() * kPointerSize;
   int frame_size_used = bytecode_array_writer()->GetMaximumFrameSizeUsed();
@@ skipping 17 matching lines @@
 }
 
 void BytecodeArrayBuilder::AttachSourceInfo(BytecodeNode* node) {
   if (latest_source_info_.is_valid()) {
     node->source_info().Update(latest_source_info_);
     latest_source_info_.set_invalid();
   }
 }
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
-
   BytecodeNode node(bytecode);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
                                         OperandScale operand_scale,
                                         uint32_t operand0, uint32_t operand1,
                                         uint32_t operand2, uint32_t operand3) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
   DCHECK(OperandIsValid(bytecode, operand_scale, 0, operand0));
   DCHECK(OperandIsValid(bytecode, operand_scale, 1, operand1));
   DCHECK(OperandIsValid(bytecode, operand_scale, 2, operand2));
   DCHECK(OperandIsValid(bytecode, operand_scale, 3, operand3));
   BytecodeNode node(bytecode, operand0, operand1, operand2, operand3,
                     operand_scale);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
                                         OperandScale operand_scale,
                                         uint32_t operand0, uint32_t operand1,
                                         uint32_t operand2) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
   DCHECK(OperandIsValid(bytecode, operand_scale, 0, operand0));
   DCHECK(OperandIsValid(bytecode, operand_scale, 1, operand1));
   DCHECK(OperandIsValid(bytecode, operand_scale, 2, operand2));
   BytecodeNode node(bytecode, operand0, operand1, operand2, operand_scale);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
                                         OperandScale operand_scale,
                                         uint32_t operand0, uint32_t operand1) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
   DCHECK(OperandIsValid(bytecode, operand_scale, 0, operand0));
   DCHECK(OperandIsValid(bytecode, operand_scale, 1, operand1));
   BytecodeNode node(bytecode, operand0, operand1, operand_scale);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
                                         OperandScale operand_scale,
                                         uint32_t operand0) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
   DCHECK(OperandIsValid(bytecode, operand_scale, 0, operand0));
   BytecodeNode node(bytecode, operand0, operand_scale);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,
                                                             Register reg) {
   OperandScale operand_scale =
       Bytecodes::OperandSizesToScale(reg.SizeOfOperand());
@@ skipping 474 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
   unbound_jumps_--;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::OutputJump(Bytecode jump_bytecode,
                                                        BytecodeLabel* label) {
-  // Don't emit dead code.
-  if (exit_seen_in_block_) return *this;
-
   if (label->is_bound()) {
     // Label has been bound already so this is a backwards jump.
     size_t current_offset = pipeline()->FlushForOffset();
     CHECK_GE(current_offset, label->offset());
     CHECK_LE(current_offset, static_cast<size_t>(kMaxInt));
     size_t abs_delta = current_offset - label->offset();
     int delta = -static_cast<int>(abs_delta);
     OperandSize operand_size = Bytecodes::SizeForSignedOperand(delta);
     if (operand_size > OperandSize::kByte) {
       // Adjust for scaling byte prefix for wide jump offset.
@@ skipping 65 matching lines @@
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotHole(
     BytecodeLabel* label) {
   return OutputJump(Bytecode::kJumpIfNotHole, label);
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Throw() {
   Output(Bytecode::kThrow);
-  exit_seen_in_block_ = true;
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ReThrow() {
   Output(Bytecode::kReThrow);
-  exit_seen_in_block_ = true;
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Return() {
   Output(Bytecode::kReturn);
-  exit_seen_in_block_ = true;
+  return_seen_in_block_ = true;
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Debugger() {
   Output(Bytecode::kDebugger);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare(
     Register cache_info_triple) {
@@ skipping 74 matching lines @@
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkTryEnd(int handler_id) {
   size_t offset = pipeline()->FlushForOffset();
   handler_table_builder()->SetTryRegionEnd(handler_id, offset);
   return *this;
 }
 
 
 void BytecodeArrayBuilder::LeaveBasicBlock() {
-  exit_seen_in_block_ = false;
   pipeline()->FlushBasicBlock();
+  return_seen_in_block_ = false;
 }
 
 void BytecodeArrayBuilder::EnsureReturn() {
-  if (!exit_seen_in_block_) {
+  if (!return_seen_in_block_) {
     LoadUndefined();
     SetReturnPosition();
     Return();
   }
-  DCHECK(exit_seen_in_block_);
+  DCHECK(return_seen_in_block_);
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
                                                  Register receiver_args,
                                                  size_t receiver_args_count,
                                                  int feedback_slot,
                                                  TailCallMode tail_call_mode) {
   Bytecode bytecode = BytecodeForCall(tail_call_mode);
   OperandScale operand_scale = Bytecodes::OperandSizesToScale(
       callable.SizeOfOperand(), receiver_args.SizeOfOperand(),
@@ skipping 80 matching lines @@
                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;
-  if (exit_seen_in_block_) return;
   latest_source_info_.Update({return_position_, true});
 }
 
 void BytecodeArrayBuilder::SetStatementPosition(Statement* stmt) {
   if (stmt->position() == RelocInfo::kNoPosition) return;
-  if (exit_seen_in_block_) return;
   latest_source_info_.Update({stmt->position(), true});
 }
 
 void BytecodeArrayBuilder::SetExpressionPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
-  if (exit_seen_in_block_) return;
   latest_source_info_.Update({expr->position(), false});
 }
 
 void BytecodeArrayBuilder::SetExpressionAsStatementPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
-  if (exit_seen_in_block_) return;
   latest_source_info_.Update({expr->position(), true});
 }
 
 bool BytecodeArrayBuilder::TemporaryRegisterIsLive(Register reg) const {
   return temporary_register_allocator()->RegisterIsLive(reg);
 }
 
 bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode,
                                           OperandScale operand_scale,
                                           int operand_index,
@@ skipping 286 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