Revert of [Interpreter] Optimize BytecodeArrayBuilder and BytecodeArrayWriter.

src/interpreter/bytecode-register-optimizer.cc

 // 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.
 
 #include "src/interpreter/bytecode-register-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 156 matching lines @@
 BytecodeRegisterOptimizer::RegisterInfo*
 BytecodeRegisterOptimizer::RegisterInfo::GetEquivalent() {
   return next_;
 }
 
 BytecodeRegisterOptimizer::BytecodeRegisterOptimizer(
     Zone* zone, TemporaryRegisterAllocator* register_allocator,
     int parameter_count, BytecodePipelineStage* next_stage)
     : accumulator_(Register::virtual_accumulator()),
       temporary_base_(register_allocator->allocation_base()),
-      max_register_index_(register_allocator->allocation_base() - 1),
       register_info_table_(zone),
       equivalence_id_(0),
       next_stage_(next_stage),
       flush_required_(false),
       zone_(zone) {
   register_allocator->set_observer(this);
 
   // Calculate offset so register index values can be mapped into
   // a vector of register metadata.
   if (parameter_count != 0) {
@@ skipping 14 matching lines @@
         RegisterFromRegisterInfoTableIndex(i), NextEquivalenceId(), true);
     DCHECK_EQ(register_info_table_[i]->register_value().index(),
               RegisterFromRegisterInfoTableIndex(i).index());
   }
   accumulator_info_ = GetRegisterInfo(accumulator_);
   DCHECK(accumulator_info_->register_value() == accumulator_);
 }
 
 // override
 Handle<BytecodeArray> BytecodeRegisterOptimizer::ToBytecodeArray(
-    Isolate* isolate, int register_count, int parameter_count,
+    Isolate* isolate, int fixed_register_count, int parameter_count,
     Handle<FixedArray> handler_table) {
   FlushState();
-  return next_stage_->ToBytecodeArray(isolate, max_register_index_ + 1,
+  return next_stage_->ToBytecodeArray(isolate, fixed_register_count,
                                       parameter_count, handler_table);
 }
 
 // override
 void BytecodeRegisterOptimizer::Write(BytecodeNode* node) {
-  // Jumps are handled by WriteJump.
-  DCHECK(!Bytecodes::IsJump(node->bytecode()));
   //
   // Transfers with observable registers as the destination will be
   // immediately materialized so the source position information will
   // be ordered correctly.
   //
   // Transfers without observable destination registers will initially
   // be emitted as Nop's with the source position. They may, or may
   // not, be materialized by the optimizer. However, the source
   // position is not lost and being attached to a Nop is fine as the
   // destination register is not observable in the debugger.
   //
   switch (node->bytecode()) {
     case Bytecode::kLdar: {
       DoLdar(node);
       return;
     }
     case Bytecode::kStar: {
       DoStar(node);
       return;
     }
     case Bytecode::kMov: {
       DoMov(node);
       return;
     }
     default:
       break;
   }
 
-  if (node->bytecode() == Bytecode::kDebugger ||
+  if (Bytecodes::IsJump(node->bytecode()) ||
+      node->bytecode() == Bytecode::kDebugger ||
       node->bytecode() == Bytecode::kSuspendGenerator) {
     // All state must be flushed before emitting
+    // - a jump (due to how bytecode offsets for jumps are evaluated),
     // - a call to the debugger (as it can manipulate locals and parameters),
     // - a generator suspend (as this involves saving all registers).
     FlushState();
   }
 
   PrepareOperands(node);
-  next_stage_->Write(node);
+  WriteToNextStage(node);
 }
 
 // override
 void BytecodeRegisterOptimizer::WriteJump(BytecodeNode* node,
                                           BytecodeLabel* label) {
   FlushState();
   next_stage_->WriteJump(node, label);
 }
 
 // override
@@ skipping 29 matching lines @@
           OutputRegisterTransfer(reg_info, equivalent);
         }
         equivalent->MoveToNewEquivalenceSet(NextEquivalenceId(), true);
       }
     }
   }
 
   flush_required_ = false;
 }
 
+void BytecodeRegisterOptimizer::WriteToNextStage(BytecodeNode* node) const {
+  next_stage_->Write(node);
+}
+
+void BytecodeRegisterOptimizer::WriteToNextStage(
+    BytecodeNode* node, const BytecodeSourceInfo& source_info) const {
+  if (source_info.is_valid()) {
+    node->source_info().Clone(source_info);
+  }
+  next_stage_->Write(node);
+}
+
 void BytecodeRegisterOptimizer::OutputRegisterTransfer(
     RegisterInfo* input_info, RegisterInfo* output_info,
-    BytecodeSourceInfo* source_info) {
+    const BytecodeSourceInfo& source_info) {
   Register input = input_info->register_value();
   Register output = output_info->register_value();
   DCHECK_NE(input.index(), output.index());
 
   if (input == accumulator_) {
     uint32_t operand = static_cast<uint32_t>(output.ToOperand());
-    BytecodeNode node(Bytecode::kStar, operand, source_info);
-    next_stage_->Write(&node);
+    BytecodeNode node(Bytecode::kStar, operand);
+    WriteToNextStage(&node, source_info);
   } else if (output == accumulator_) {
     uint32_t operand = static_cast<uint32_t>(input.ToOperand());
-    BytecodeNode node(Bytecode::kLdar, operand, source_info);
-    next_stage_->Write(&node);
+    BytecodeNode node(Bytecode::kLdar, operand);
+    WriteToNextStage(&node, source_info);
   } else {
     uint32_t operand0 = static_cast<uint32_t>(input.ToOperand());
     uint32_t operand1 = static_cast<uint32_t>(output.ToOperand());
-    BytecodeNode node(Bytecode::kMov, operand0, operand1, source_info);
-    next_stage_->Write(&node);
-  }
-  if (output != accumulator_) {
-    max_register_index_ = std::max(max_register_index_, output.index());
+    BytecodeNode node(Bytecode::kMov, operand0, operand1);
+    WriteToNextStage(&node, source_info);
   }
   output_info->set_materialized(true);
 }
 
 void BytecodeRegisterOptimizer::CreateMaterializedEquivalent(
     RegisterInfo* info) {
   DCHECK(info->materialized());
   RegisterInfo* unmaterialized = info->GetEquivalentToMaterialize();
   if (unmaterialized) {
     OutputRegisterTransfer(info, unmaterialized);
@@ skipping 31 matching lines @@
 void BytecodeRegisterOptimizer::AddToEquivalenceSet(
     RegisterInfo* set_member, RegisterInfo* non_set_member) {
   non_set_member->AddToEquivalenceSetOf(set_member);
   // Flushing is only required when two or more registers are placed
   // in the same equivalence set.
   flush_required_ = true;
 }
 
 void BytecodeRegisterOptimizer::RegisterTransfer(
     RegisterInfo* input_info, RegisterInfo* output_info,
-    BytecodeSourceInfo* source_info) {
+    const BytecodeSourceInfo& source_info) {
   // Materialize an alternate in the equivalence set that
   // |output_info| is leaving.
   if (output_info->materialized()) {
     CreateMaterializedEquivalent(output_info);
   }
 
   // Add |output_info| to new equivalence set.
   if (!output_info->IsInSameEquivalenceSet(input_info)) {
     AddToEquivalenceSet(input_info, output_info);
   }
 
   bool output_is_observable =
       RegisterIsObservable(output_info->register_value());
   if (output_is_observable) {
     // Force store to be emitted when register is observable.
     output_info->set_materialized(false);
     RegisterInfo* materialized_info = input_info->GetMaterializedEquivalent();
     OutputRegisterTransfer(materialized_info, output_info, source_info);
-  } else if (source_info->is_valid()) {
+  } else if (source_info.is_valid()) {
     // Emit a placeholder nop to maintain source position info.
     EmitNopForSourceInfo(source_info);
   }
 }
 
 void BytecodeRegisterOptimizer::EmitNopForSourceInfo(
-    BytecodeSourceInfo* source_info) const {
-  DCHECK(source_info->is_valid());
-  BytecodeNode nop(Bytecode::kNop, source_info);
-  next_stage_->Write(&nop);
+    const BytecodeSourceInfo& source_info) const {
+  DCHECK(source_info.is_valid());
+  BytecodeNode nop(Bytecode::kNop);
+  nop.source_info().Clone(source_info);
+  WriteToNextStage(&nop);
 }
 
-void BytecodeRegisterOptimizer::DoLdar(BytecodeNode* node) {
+void BytecodeRegisterOptimizer::DoLdar(const BytecodeNode* const node) {
   Register input = GetRegisterInputOperand(
       0, node->bytecode(), node->operands(), node->operand_count());
   RegisterInfo* input_info = GetRegisterInfo(input);
-  RegisterTransfer(input_info, accumulator_info_, node->source_info_ptr());
+  RegisterTransfer(input_info, accumulator_info_, node->source_info());
 }
 
-void BytecodeRegisterOptimizer::DoMov(BytecodeNode* node) {
+void BytecodeRegisterOptimizer::DoMov(const BytecodeNode* const node) {
   Register input = GetRegisterInputOperand(
       0, node->bytecode(), node->operands(), node->operand_count());
   RegisterInfo* input_info = GetRegisterInfo(input);
   Register output = GetRegisterOutputOperand(
       1, node->bytecode(), node->operands(), node->operand_count());
   RegisterInfo* output_info = GetOrCreateRegisterInfo(output);
-  RegisterTransfer(input_info, output_info, node->source_info_ptr());
+  RegisterTransfer(input_info, output_info, node->source_info());
 }
 
-void BytecodeRegisterOptimizer::DoStar(BytecodeNode* node) {
+void BytecodeRegisterOptimizer::DoStar(const BytecodeNode* const node) {
   Register output = GetRegisterOutputOperand(
       0, node->bytecode(), node->operands(), node->operand_count());
   RegisterInfo* output_info = GetOrCreateRegisterInfo(output);
-  RegisterTransfer(accumulator_info_, output_info, node->source_info_ptr());
+  RegisterTransfer(accumulator_info_, output_info, node->source_info());
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterOutputOperand(
     RegisterInfo* reg_info) {
   if (reg_info->materialized()) {
     CreateMaterializedEquivalent(reg_info);
   }
-  max_register_index_ =
-      std::max(max_register_index_, reg_info->register_value().index());
   reg_info->MoveToNewEquivalenceSet(NextEquivalenceId(), true);
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterRangeOutputOperand(
     Register start, int count) {
   for (int i = 0; i < count; ++i) {
     Register reg(start.index() + i);
     RegisterInfo* reg_info = GetOrCreateRegisterInfo(reg);
     PrepareRegisterOutputOperand(reg_info);
   }
@@ skipping 10 matching lines @@
   } else {
     RegisterInfo* equivalent_info =
         GetMaterializedEquivalentNotAccumulator(reg_info);
     return equivalent_info->register_value();
   }
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterInputOperand(
     BytecodeNode* const node, Register reg, int operand_index) {
   Register equivalent = GetEquivalentRegisterForInputOperand(reg);
-  node->UpdateOperand(operand_index,
-                      static_cast<uint32_t>(equivalent.ToOperand()));
+  node->operands()[operand_index] =
+      static_cast<uint32_t>(equivalent.ToOperand());
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterRangeInputOperand(Register start,
                                                                  int count) {
   for (int i = 0; i < count; ++i) {
     Register current(start.index() + i);
     RegisterInfo* input_info = GetRegisterInfo(current);
     Materialize(input_info);
   }
 }
@@ skipping 122 matching lines @@
     if (info->materialized()) {
       CreateMaterializedEquivalent(info);
     }
     info->MoveToNewEquivalenceSet(kInvalidEquivalenceId, false);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8