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

Eliminating dead code in the bytecode array builder doesn't play nice
with the register elimination optimizer. We should move it to it's own
stage in the optimization pipeline, however doing so would require
refactoring of how we deal with jumps, so for now just remove the dead
code elimination optimization.

BUG=chromium:616064

Review-Url: https://codereview.chromium.org/2030583002
Cr-Commit-Position: refs/heads/master@{#36660}

src/interpreter/bytecode-array-builder.cc

@@ -24,7 +24,7 @@ BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone,
       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),
@@ -79,7 +79,7 @@ bool BytecodeArrayBuilder::RegisterIsParameterOrLocal(Register reg) const {
 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();
@@ -117,9 +117,6 @@ void BytecodeArrayBuilder::AttachSourceInfo(BytecodeNode* node) {
 }
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
-  // Don't output dead code.
-  if (exit_seen_in_block_) return;
-
   BytecodeNode node(bytecode);
   AttachSourceInfo(&node);
   pipeline()->Write(&node);
@@ -129,8 +126,6 @@ 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));
@@ -145,8 +140,6 @@ 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));
@@ -158,8 +151,6 @@ void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
 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);
@@ -170,8 +161,6 @@ void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode,
 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);
@@ -666,9 +655,6 @@ void BytecodeArrayBuilder::PatchJump(size_t jump_target, size_t jump_location) {
 
 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();
@@ -754,21 +740,19 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::JumpIfNotHole(
 
 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;
 }
 
@@ -863,17 +847,17 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::MarkTryEnd(int handler_id) {
 
 
 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,
@@ -974,25 +958,21 @@ size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> 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});
 }
 

src/interpreter/bytecode-array-builder.h

@@ -361,7 +361,7 @@ class BytecodeArrayBuilder final : public ZoneObject {
   ConstantArrayBuilder constant_array_builder_;
   HandlerTableBuilder handler_table_builder_;
   SourcePositionTableBuilder source_position_table_builder_;
-  bool exit_seen_in_block_;
+  bool return_seen_in_block_;
   int unbound_jumps_;
   int parameter_count_;
   int local_register_count_;

src/interpreter/bytecode-peephole-optimizer.h

@@ -22,6 +22,7 @@ class BytecodePeepholeOptimizer final : public BytecodePipelineStage,
   BytecodePeepholeOptimizer(ConstantArrayBuilder* constant_array_builder,
                             BytecodePipelineStage* next_stage);
 
+  // BytecodePipelineStage interface.
   void Write(BytecodeNode* node) override;
   size_t FlushForOffset() override;
   void FlushBasicBlock() override;

src/interpreter/bytecode-register-optimizer.cc

@@ -8,6 +8,8 @@ namespace v8 {
 namespace internal {
 namespace interpreter {
 
+const uint32_t BytecodeRegisterOptimizer::kInvalidEquivalenceId;
+
 // A class for tracking the state of a register. This class tracks
 // which equivalence set a register is a member of and also whether a
 // register is materialized in the bytecode stream.
@@ -68,6 +70,7 @@ class BytecodeRegisterOptimizer::RegisterInfo final : public ZoneObject {
 
 void BytecodeRegisterOptimizer::RegisterInfo::AddToEquivalenceSetOf(
     RegisterInfo* info) {
+  DCHECK_NE(kInvalidEquivalenceId, info->equivalence_id());
   // Fix old list
   next_->prev_ = prev_;
   prev_->next_ = next_;

src/interpreter/bytecode-register-optimizer.h

@@ -31,7 +31,7 @@ class BytecodeRegisterOptimizer final : public BytecodePipelineStage,
   void Write(BytecodeNode* node) override;
 
  private:
-  const uint32_t kInvalidEquivalenceId = kMaxUInt32;
+  static const uint32_t kInvalidEquivalenceId = kMaxUInt32;
 
   class RegisterInfo;
 

test/cctest/interpreter/bytecode_expectations/ContextVariables.golden

@@ -105,7 +105,7 @@ snippet: "
 "
 frame size: 4
 parameter count: 1
-bytecode array length: 46
+bytecode array length: 48
 bytecodes: [
                 B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
                 B(PushContext), R(0),
@@ -126,6 +126,7 @@ bytecodes: [
   /*   72 S> */ B(CreateClosure), U8(1), U8(0),
                 B(PopContext), R(0),
   /*  104 S> */ B(Return),
+                B(PopContext), R(1),
 ]
 constant pool: [
   InstanceType::FIXED_ARRAY_TYPE,

test/cctest/interpreter/bytecode_expectations/IfConditions.golden

@@ -150,14 +150,15 @@ snippet: "
 "
 frame size: 0
 parameter count: 2
-bytecode array length: 18
+bytecode array length: 20
 bytecodes: [
   /*   10 E> */ B(StackCheck),
   /*   18 S> */ B(LdaZero),
   /*   24 E> */ B(TestLessThanOrEqual), R(arg0),
-                B(JumpIfFalse), U8(7),
+                B(JumpIfFalse), U8(9),
   /*   36 S> */ B(Wide), B(LdaSmi), U16(200),
   /*   80 S> */ B(Return),
+                B(Jump), U8(7),
   /*   63 S> */ B(Wide), B(LdaSmi), U16(-200),
   /*   80 S> */ B(Return),
                 B(LdaUndefined),
@@ -262,7 +263,7 @@ snippet: "
 "
 frame size: 2
 parameter count: 2
-bytecode array length: 537
+bytecode array length: 539
 bytecodes: [
   /*   10 E> */ B(StackCheck),
   /*   24 S> */ B(LdaZero),
@@ -530,6 +531,7 @@ bytecodes: [
                 B(Mov), R(1), R(0),
   /* 1081 S> */ B(Wide), B(LdaSmi), U16(200),
   /* 1117 S> */ B(Return),
+                B(Jump), U8(7),
   /* 1102 S> */ B(Wide), B(LdaSmi), U16(-200),
   /* 1117 S> */ B(Return),
                 B(LdaUndefined),
@@ -617,7 +619,7 @@ snippet: "
 "
 frame size: 2
 parameter count: 1
-bytecode array length: 535
+bytecode array length: 537
 bytecodes: [
   /*   10 E> */ B(StackCheck),
   /*   25 S> */ B(LdaZero),
@@ -884,6 +886,7 @@ bytecodes: [
                 B(Mov), R(1), R(0),
   /* 1076 S> */ B(Wide), B(LdaSmi), U16(200),
   /* 1112 S> */ B(Return),
+                B(Jump), U8(7),
   /* 1097 S> */ B(Wide), B(LdaSmi), U16(-200),
   /* 1112 S> */ B(Return),
                 B(LdaUndefined),
@@ -985,14 +988,15 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 14
+bytecode array length: 16
 bytecodes: [
   /*   10 E> */ B(StackCheck),
   /*   25 S> */ B(LdaZero),
                 B(Star), R(0),
-  /*   30 S> */ B(JumpIfToBooleanFalse), U8(5),
+  /*   30 S> */ B(JumpIfToBooleanFalse), U8(7),
   /*   43 S> */ B(LdaSmi), U8(20),
   /*   85 S> */ B(Return),
+                B(Jump), U8(5),
   /*   69 S> */ B(LdaSmi), U8(-20),
   /*   85 S> */ B(Return),
                 B(LdaUndefined),

test/cctest/interpreter/bytecode_expectations/Throw.golden

@@ -13,11 +13,13 @@ snippet: "
 "
 frame size: 0
 parameter count: 1
-bytecode array length: 4
+bytecode array length: 6
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   34 S> */ B(LdaSmi), U8(1),
   /*   34 E> */ B(Throw),
+                B(LdaUndefined),
+  /*   43 S> */ B(Return),
 ]
 constant pool: [
 ]
@@ -30,11 +32,13 @@ snippet: "
 "
 frame size: 0
 parameter count: 1
-bytecode array length: 4
+bytecode array length: 6
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   34 S> */ B(LdaConstant), U8(0),
   /*   34 E> */ B(Throw),
+                B(LdaUndefined),
+  /*   49 S> */ B(Return),
 ]
 constant pool: [
   "Error",

test/cctest/interpreter/bytecode_expectations/TryCatch.golden

@@ -13,12 +13,13 @@ snippet: "
 "
 frame size: 5
 parameter count: 1
-bytecode array length: 39
+bytecode array length: 43
 bytecodes: [
   /*   30 E> */ B(StackCheck),
                 B(Mov), R(context), R(1),
   /*   40 S> */ B(LdaSmi), U8(1),
   /*   75 S> */ B(Return),
+                B(Jump), U8(34),
                 B(Star), R(3),
                 B(LdaConstant), U8(0),
                 B(Star), R(2),
@@ -31,6 +32,7 @@ bytecodes: [
   /*   63 S> */ B(LdaSmi), U8(2),
                 B(PopContext), R(0),
   /*   75 S> */ B(Return),
+                B(PopContext), R(0),
                 B(LdaUndefined),
   /*   75 S> */ B(Return),
 ]
@@ -38,7 +40,7 @@ constant pool: [
   "e",
 ]
 handlers: [
-  [4, 7, 7],
+  [4, 7, 9],
 ]
 
 ---

test/cctest/interpreter/bytecode_expectations/WithStatement.golden

@@ -13,7 +13,7 @@ snippet: "
 "
 frame size: 4
 parameter count: 1
-bytecode array length: 25
+bytecode array length: 27
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
@@ -26,6 +26,7 @@ bytecodes: [
   /*   50 S> */ B(LdaLookupSlot), U8(1),
                 B(PopContext), R(0),
   /*   62 S> */ B(Return),
+                B(PopContext), R(0),
 ]
 constant pool: [
   InstanceType::FIXED_ARRAY_TYPE,

test/mjsunit/ignition/regress-616064.js

+// 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.
+
+// Flags: --ignition
+
+function foo() {
+  if (this.Worker) {
+    function __f_0() { this.s = a; }
+    function __f_1() {
+      this.l = __f_0;
+    }
+
+    with ( 'source' , Object ) throw function __f_0(__f_0) {
+      return Worker.__f_0(-2147483648, __f_0);
+    };
+
+    var __v_9 = new Worker('');
+    __f_1 = {s: Math.s, __f_1: true};
+  }
+}
+
+try {
+  foo();
+} catch(e) {
+}