[turbofan] Keep the next bytecode liveness when analysing

src/compiler/bytecode-analysis.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/compiler/bytecode-analysis.h"
 
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-array-reverse-iterator.h"
 #include "src/objects-inl.h"
 
@@ skipping 91 matching lines @@
         }
       }
       default:
         DCHECK(!Bytecodes::IsRegisterInputOperandType(operand_types[i]));
         break;
     }
   }
 }
 
 void UpdateOutLiveness(Bytecode bytecode, BitVector& out_liveness,
+                       BitVector* next_bytecode_in_liveness,
                        const BytecodeArrayAccessor& accessor,
                        const BytecodeLivenessMap& liveness_map) {
   int current_offset = accessor.current_offset();
   const Handle<BytecodeArray>& bytecode_array = accessor.bytecode_array();
 
   // Update from jump target (if any). Skip loops, we update these manually in
   // the liveness iterations.
   if (Bytecodes::IsForwardJump(bytecode)) {
     int target_offset = accessor.GetJumpTargetOffset();
     out_liveness.Union(*liveness_map.GetInLiveness(target_offset));
   }
 
-  // Update from next bytecode (unless this is an unconditional jump).
-  if (!Bytecodes::IsUnconditionalJump(bytecode)) {
-    int next_offset = current_offset + accessor.current_bytecode_size();
-    if (next_offset < bytecode_array->length()) {
-      out_liveness.Union(*liveness_map.GetInLiveness(next_offset));
-    }
+  // Update from next bytecode (unless there isn't one or this is an
+  // unconditional jump).
+  if (next_bytecode_in_liveness != nullptr &&
+      !Bytecodes::IsUnconditionalJump(bytecode)) {
+    out_liveness.Union(*next_bytecode_in_liveness);
   }
 
   // Update from exception handler (if any).
   if (!interpreter::Bytecodes::IsWithoutExternalSideEffects(bytecode)) {
     int handler_context;
     // TODO(leszeks): We should look up this range only once per entry.
     HandlerTable* table = HandlerTable::cast(bytecode_array->handler_table());
     int handler_offset =
         table->LookupRange(current_offset, &handler_context, nullptr);
 
     if (handler_offset != -1) {
       out_liveness.Union(*liveness_map.GetInLiveness(handler_offset));
       out_liveness.Add(handler_context);
     }
   }
 }
 
 }  // namespace
 
 void BytecodeAnalysis::Analyze() {
   loop_stack_.push(-1);
 
+  BitVector* next_bytecode_in_liveness = nullptr;
+
   // The last JumpLoop that we haven't done a guaranteed valid liveness pass
   // over. See the below wall of text for a more thorough explanation.
   int last_invalid_jumploop_offset = -1;
 
   BytecodeArrayReverseIterator iterator(bytecode_array(), zone());
   for (; !iterator.done(); iterator.Advance()) {
     Bytecode bytecode = iterator.current_bytecode();
     int current_offset = iterator.current_offset();
 
     if (bytecode == Bytecode::kJumpLoop) {
       PushLoop(iterator.GetJumpTargetOffset(), current_offset);
 
       // Save the last offset so that we can do another pass later.
       if (last_invalid_jumploop_offset == -1) {
         last_invalid_jumploop_offset = current_offset;
       }
     } else if (current_offset == loop_stack_.top()) {
       loop_stack_.pop();
     }
 
     if (do_liveness_analysis_) {
       // The liveness vector had bits for the liveness of the registers, and one
       // more bit for the liveness of the accumulator.
       Liveness& liveness = liveness_map_.InitializeLiveness(
           current_offset, bytecode_array()->register_count() + 1, zone());
 
-      UpdateOutLiveness(bytecode, *liveness.out, iterator, liveness_map_);
+      UpdateOutLiveness(bytecode, *liveness.out, next_bytecode_in_liveness,
+                        iterator, liveness_map_);
       liveness.in->CopyFrom(*liveness.out);
       UpdateInLiveness(bytecode, *liveness.in, iterator);
+
+      next_bytecode_in_liveness = liveness.in;
     }
   }
 
   DCHECK_EQ(loop_stack_.size(), 1u);
   DCHECK_EQ(loop_stack_.top(), -1);
 
   if (!do_liveness_analysis_) return;
 
   // At this point, every bytecode has a valid in and out liveness, except for
   // propagating liveness across back edges (i.e. JumpLoop). Subsequent liveness
@@ skipping 38 matching lines @@
 
       int header_offset = iterator.GetJumpTargetOffset();
       int end_offset = iterator.current_offset();
 
       Liveness& header_liveness = liveness_map_.GetLiveness(header_offset);
       Liveness& end_liveness = liveness_map_.GetLiveness(end_offset);
 
       if (end_liveness.out->UnionIsChanged(*header_liveness.in)) {
         // Only update the loop body if the loop end liveness changed.
         end_liveness.in->CopyFrom(*end_liveness.out);
+        next_bytecode_in_liveness = end_liveness.in;
 
         // Advance into the loop body.
         iterator.Advance();
         for (; iterator.current_offset() > header_offset; iterator.Advance()) {
           bytecode = iterator.current_bytecode();
           if (bytecode == Bytecode::kJumpLoop) {
             // We can't validate this loop at the moment because we can't
             // guarantee that its header is valid yet. Save it for later.
             if (last_invalid_jumploop_offset == -1) {
               last_invalid_jumploop_offset = iterator.current_offset();
             }
           }
 
           int current_offset = iterator.current_offset();
           Liveness& liveness = liveness_map_.GetLiveness(current_offset);
 
-          UpdateOutLiveness(bytecode, *liveness.out, iterator, liveness_map_);
+          UpdateOutLiveness(bytecode, *liveness.out, next_bytecode_in_liveness,
+                            iterator, liveness_map_);
           liveness.in->CopyFrom(*liveness.out);
           UpdateInLiveness(bytecode, *liveness.in, iterator);
+
+          next_bytecode_in_liveness = liveness.in;
         }
         // Now we are at the loop header. Since the in-liveness of the header
         // can't change, we need only to update the out-liveness.
         bytecode = iterator.current_bytecode();
-        UpdateOutLiveness(bytecode, *header_liveness.out, iterator,
-                          liveness_map_);
+        UpdateOutLiveness(bytecode, *header_liveness.out,
+                          next_bytecode_in_liveness, iterator, liveness_map_);
       }
 
       // Keep the iterator going so that we can find other loops.
     }
   }
 
   DCHECK(LivenessIsValid());
 }
 
 void BytecodeAnalysis::PushLoop(int loop_header, int loop_end) {
@@ skipping 90 matching lines @@
 
 #if DEBUG
 bool BytecodeAnalysis::LivenessIsValid() {
   BytecodeArrayReverseIterator iterator(bytecode_array(), zone());
 
   BitVector previous_liveness(bytecode_array()->register_count() + 1, zone());
 
   int invalid_offset = -1;
   int which_invalid = -1;
 
+  BitVector* next_bytecode_in_liveness = nullptr;
+
   // Ensure that there are no liveness changes if we iterate one more time.
   for (iterator.Reset(); !iterator.done(); iterator.Advance()) {
     Bytecode bytecode = iterator.current_bytecode();
 
     int current_offset = iterator.current_offset();
 
     Liveness& liveness = liveness_map_.GetLiveness(current_offset);
 
     previous_liveness.CopyFrom(*liveness.out);
 
-    UpdateOutLiveness(bytecode, *liveness.out, iterator, liveness_map_);
+    UpdateOutLiveness(bytecode, *liveness.out, next_bytecode_in_liveness,
+                      iterator, liveness_map_);
     // UpdateOutLiveness skips kJumpLoop, so we update it manually.
     if (bytecode == Bytecode::kJumpLoop) {
       int target_offset = iterator.GetJumpTargetOffset();
       liveness.out->Union(*liveness_map_.GetInLiveness(target_offset));
     }
 
     if (!liveness.out->Equals(previous_liveness)) {
       // Reset the invalid liveness.
       liveness.out->CopyFrom(previous_liveness);
       invalid_offset = current_offset;
       which_invalid = 1;
       break;
     }
 
     previous_liveness.CopyFrom(*liveness.in);
 
     liveness.in->CopyFrom(*liveness.out);
     UpdateInLiveness(bytecode, *liveness.in, iterator);
 
     if (!liveness.in->Equals(previous_liveness)) {
       // Reset the invalid liveness.
       liveness.in->CopyFrom(previous_liveness);
       invalid_offset = current_offset;
       which_invalid = 0;
       break;
     }
+
+    next_bytecode_in_liveness = liveness.in;
   }
 
   if (invalid_offset != -1) {
     OFStream of(stderr);
     of << "Invalid liveness:" << std::endl;
 
     // Dump the bytecode, annotated with the liveness and marking loops.
 
     int loop_indent = 0;
 
@@ skipping 57 matching lines @@
     }
   }
 
   return invalid_offset == -1;
 }
 #endif
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8