[ignition/turbofan] Wrap bytecode liveness bitvectors

src/compiler/bytecode-graph-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/compiler/bytecode-graph-builder.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compilation-info.h"
 #include "src/compiler/compiler-source-position-table.h"
@@ skipping 37 matching lines @@
 
   // Effect dependency tracked by this environment.
   Node* GetEffectDependency() { return effect_dependency_; }
   void UpdateEffectDependency(Node* dependency) {
     effect_dependency_ = dependency;
   }
 
   // Preserve a checkpoint of the environment for the IR graph. Any
   // further mutation of the environment will not affect checkpoints.
   Node* Checkpoint(BailoutId bytecode_offset, OutputFrameStateCombine combine,
-                   bool owner_has_exception, const BitVector* liveness);
+                   bool owner_has_exception,
+                   const BytecodeLivenessState* liveness);
 
   // Control dependency tracked by this environment.
   Node* GetControlDependency() const { return control_dependency_; }
   void UpdateControlDependency(Node* dependency) {
     control_dependency_ = dependency;
   }
 
   Node* Context() const { return context_; }
   void SetContext(Node* new_context) { context_ = new_context; }
 
@@ skipping 333 matching lines @@
 }
 
 void BytecodeGraphBuilder::Environment::UpdateStateValuesWithCache(
     Node** state_values, Node** values, int count) {
   *state_values = builder_->state_values_cache_.GetNodeForValues(
       values, static_cast<size_t>(count));
 }
 
 Node* BytecodeGraphBuilder::Environment::Checkpoint(
     BailoutId bailout_id, OutputFrameStateCombine combine,
-    bool owner_has_exception, const BitVector* liveness) {
+    bool owner_has_exception, const BytecodeLivenessState* liveness) {
   UpdateStateValues(&parameters_state_values_, &values()->at(0),
                     parameter_count());
 
   if (liveness) {
     Node* optimized_out = builder()->jsgraph()->OptimizedOutConstant();
 
     for (int i = 0; i < register_count(); ++i) {
-      state_value_working_area_[i] = liveness->Contains(i)
+      state_value_working_area_[i] = liveness->RegisterIsLive(i)
                                          ? values()->at(register_base() + i)
                                          : optimized_out;
     }
 
-    Node* accumulator_value = liveness->Contains(register_count())
+    Node* accumulator_value = liveness->AccumulatorIsLive()
                                   ? values()->at(accumulator_base())
                                   : optimized_out;
 
     UpdateStateValuesWithCache(&registers_state_values_,
                                state_value_working_area_.data(),
                                register_count());
 
     UpdateStateValues(&accumulator_state_values_, &accumulator_value, 1);
   } else {
     UpdateStateValuesWithCache(&registers_state_values_,
@@ skipping 126 matching lines @@
 void BytecodeGraphBuilder::PrepareEagerCheckpoint() {
   if (environment()->GetEffectDependency()->opcode() != IrOpcode::kCheckpoint) {
     // Create an explicit checkpoint node for before the operation. This only
     // needs to happen if we aren't effect-dominated by a {Checkpoint} already.
     Node* node = NewNode(common()->Checkpoint());
     DCHECK_EQ(1, OperatorProperties::GetFrameStateInputCount(node->op()));
     DCHECK_EQ(IrOpcode::kDead,
               NodeProperties::GetFrameStateInput(node)->opcode());
     BailoutId bailout_id(bytecode_iterator().current_offset());
 
-    const BitVector* liveness_before = bytecode_analysis()->GetInLivenessFor(
-        bytecode_iterator().current_offset());
+    const BytecodeLivenessState* liveness_before =
+        bytecode_analysis()->GetInLivenessFor(
+            bytecode_iterator().current_offset());
 
     Node* frame_state_before = environment()->Checkpoint(
         bailout_id, OutputFrameStateCombine::Ignore(), false, liveness_before);
     NodeProperties::ReplaceFrameStateInput(node, frame_state_before);
   }
 }
 
 void BytecodeGraphBuilder::PrepareFrameState(Node* node,
                                              OutputFrameStateCombine combine) {
   if (OperatorProperties::HasFrameStateInput(node->op())) {
     // Add the frame state for after the operation. The node in question has
     // already been created and had a {Dead} frame state input up until now.
     DCHECK_EQ(1, OperatorProperties::GetFrameStateInputCount(node->op()));
     DCHECK_EQ(IrOpcode::kDead,
               NodeProperties::GetFrameStateInput(node)->opcode());
     BailoutId bailout_id(bytecode_iterator().current_offset());
     bool has_exception = NodeProperties::IsExceptionalCall(node);
 
-    const BitVector* liveness_after = bytecode_analysis()->GetOutLivenessFor(
-        bytecode_iterator().current_offset());
+    const BytecodeLivenessState* liveness_after =
+        bytecode_analysis()->GetOutLivenessFor(
+            bytecode_iterator().current_offset());
 
     Node* frame_state_after = environment()->Checkpoint(
         bailout_id, combine, has_exception, liveness_after);
     NodeProperties::ReplaceFrameStateInput(node, frame_state_after);
   }
 }
 
 void BytecodeGraphBuilder::VisitBytecodes(bool stack_check) {
   BytecodeAnalysis bytecode_analysis(bytecode_array(), local_zone(),
                                      FLAG_analyze_environment_liveness);
@@ skipping 1598 matching lines @@
         it->source_position().ScriptOffset(), start_position_.InliningId()));
     it->Advance();
   } else {
     DCHECK_GT(it->code_offset(), offset);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8