[vm] Fix liveness calculation to correctly account for try-catch flow.

Ensure that liveness analysis as part of register allocation takes into account try-catch implicit data flow.

Fixes #60017
TEST=nested_try_throw_environment_test

Change-Id: I6013942f8f4b78655938765e11859008c28cb9e2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/408421
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Aprelev <[email protected]>

Author: aam

runtime/vm/compiler/backend/flow_graph.cc

@@ -709,15 +709,16 @@ bool FlowGraph::VerifyRedefinitions() {
   return true;
 }
 
-LivenessAnalysis::LivenessAnalysis(
-    intptr_t variable_count,
-    const GrowableArray<BlockEntryInstr*>& postorder)
+LivenessAnalysis::LivenessAnalysis(const FlowGraph* flow_graph,
+                                   const intptr_t variable_count)
     : zone_(Thread::Current()->zone()),
+      flow_graph_(flow_graph),
       variable_count_(variable_count),
-      postorder_(postorder),
-      live_out_(postorder.length()),
-      kill_(postorder.length()),
-      live_in_(postorder.length()) {}
+      postorder_(flow_graph->postorder()),
+      live_out_(postorder_.length()),
+      kill_(postorder_.length()),
+      live_in_(postorder_.length()),
+      does_block_have_throw(zone_, postorder_.length()) {}
 
 bool LivenessAnalysis::UpdateLiveOut(const BlockEntryInstr& block) {
   BitVector* live_out = live_out_[block.postorder_number()];
@@ -731,14 +732,29 @@ bool LivenessAnalysis::UpdateLiveOut(const BlockEntryInstr& block) {
       changed = true;
     }
   }
-  return changed;
+  return changed || block.InsideTryBlock();
 }
 
 bool LivenessAnalysis::UpdateLiveIn(const BlockEntryInstr& block) {
   BitVector* live_out = live_out_[block.postorder_number()];
   BitVector* kill = kill_[block.postorder_number()];
   BitVector* live_in = live_in_[block.postorder_number()];
-  return live_in->KillAndAdd(kill, live_out);
+  bool changed = live_in->KillAndAdd(kill, live_out);
+
+  // if [block] contains [Throw] instruction, then make sure corresponding
+  // [catch_block] live_in is also part of this [block] live_in.
+  if (block.InsideTryBlock()) {
+    if (does_block_have_throw.Contains(block.postorder_number())) {
+      BitVector* live_in = live_in_[block.postorder_number()];
+      CatchBlockEntryInstr* catch_block =
+          flow_graph_->GetCatchBlockByTryIndex(block.try_index());
+      auto catch_live_in = live_in_[catch_block->postorder_number()];
+      if (live_in->AddAll(catch_live_in)) {
+        changed = true;
+      }
+    }
+  }
+  return changed;
 }
 
 void LivenessAnalysis::ComputeLiveInAndLiveOutSets() {
@@ -803,9 +819,8 @@ void LivenessAnalysis::Dump() {
 // Computes liveness information for local variables.
 class VariableLivenessAnalysis : public LivenessAnalysis {
  public:
-  explicit VariableLivenessAnalysis(FlowGraph* flow_graph)
-      : LivenessAnalysis(flow_graph->variable_count(), flow_graph->postorder()),
-        flow_graph_(flow_graph),
+  explicit VariableLivenessAnalysis(const FlowGraph* flow_graph)
+      : LivenessAnalysis(flow_graph, flow_graph->variable_count()),
         assigned_vars_() {}
 
   // For every block (in preorder) compute and return set of variables that
@@ -879,10 +894,7 @@ class VariableLivenessAnalysis : public LivenessAnalysis {
 
  private:
   virtual void ComputeInitialSets();
-  virtual bool UpdateLiveOut(const BlockEntryInstr& block);
-  virtual bool UpdateLiveIn(const BlockEntryInstr& block);
 
-  const FlowGraph* flow_graph_;
   GrowableArray<BitVector*> assigned_vars_;
 };
 
@@ -902,6 +914,10 @@ void VariableLivenessAnalysis::ComputeInitialSets() {
     for (BackwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
 
+      if (current->MayThrow()) {
+        does_block_have_throw.Add(i);
+      }
+
       LoadLocalInstr* load = current->AsLoadLocal();
       if (load != nullptr) {
         const intptr_t index = flow_graph_->EnvIndex(&load->local());
@@ -965,24 +981,6 @@ void VariableLivenessAnalysis::ComputeInitialSets() {
   }
 }
 
-bool VariableLivenessAnalysis::UpdateLiveIn(const BlockEntryInstr& block) {
-  bool changed = LivenessAnalysis::UpdateLiveIn(block);
-  if (block.InsideTryBlock()) {
-    BitVector* live_in = live_in_[block.postorder_number()];
-    CatchBlockEntryInstr* catch_block =
-        flow_graph_->GetCatchBlockByTryIndex(block.try_index());
-    auto catch_live_in = live_in_[catch_block->postorder_number()];
-    if (live_in->AddAll(catch_live_in)) {
-      changed = true;
-    }
-  }
-  return changed;
-}
-
-bool VariableLivenessAnalysis::UpdateLiveOut(const BlockEntryInstr& block) {
-  return LivenessAnalysis::UpdateLiveOut(block) || block.InsideTryBlock();
-}
-
 void FlowGraph::ComputeSSA(
     ZoneGrowableArray<Definition*>* inlining_parameters) {
   GrowableArray<BitVector*> dominance_frontier;

runtime/vm/compiler/backend/flow_graph.h

@@ -803,8 +803,7 @@ class FlowGraph : public ZoneAllocated {
 
 class LivenessAnalysis : public ValueObject {
  public:
-  LivenessAnalysis(intptr_t variable_count,
-                   const GrowableArray<BlockEntryInstr*>& postorder);
+  LivenessAnalysis(const FlowGraph* flow_graph, const intptr_t variable_count);
 
   void Analyze();
 
@@ -835,18 +834,20 @@ class LivenessAnalysis : public ValueObject {
 
  protected:
   // Compute initial values for live-out, kill and live-in sets.
+  //
+  // It's also responsible for populating [does_block_have_throw] set.
   virtual void ComputeInitialSets() = 0;
 
   // Update live-out set for the given block: live-out should contain
   // all values that are live-in for block's successors.
   // Returns true if live-out set was changed.
-  virtual bool UpdateLiveOut(const BlockEntryInstr& instr);
+  bool UpdateLiveOut(const BlockEntryInstr& instr);
 
   // Update live-in set for the given block: live-in should contain
   // all values that are live-out from the block and are not defined
   // by this block.
   // Returns true if live-in set was changed.
-  virtual bool UpdateLiveIn(const BlockEntryInstr& instr);
+  bool UpdateLiveIn(const BlockEntryInstr& instr);
 
   // Perform fix-point iteration updating live-out and live-in sets
   // for blocks until they stop changing.
@@ -856,6 +857,8 @@ class LivenessAnalysis : public ValueObject {
 
   Zone* zone_;
 
+  const FlowGraph* flow_graph_;
+
   const intptr_t variable_count_;
 
   const GrowableArray<BlockEntryInstr*>& postorder_;
@@ -873,6 +876,10 @@ class LivenessAnalysis : public ValueObject {
   // Live-in sets for each block.  They contain indices of variables
   // that are used by this block or its successors.
   GrowableArray<BitVector*> live_in_;
+
+  // Given block's postoroder index indicates whether block has any
+  // instructions that throw.
+  BitVector does_block_have_throw;
 };
 
 class DefinitionWorklist : public ValueObject {

runtime/vm/compiler/backend/linearscan.cc

@@ -95,7 +95,7 @@ FlowGraphAllocator::FlowGraphAllocator(const FlowGraph& flow_graph,
       instructions_(),
       block_entries_(),
       extra_loop_info_(),
-      liveness_(flow_graph),
+      liveness_(&flow_graph),
       vreg_count_(flow_graph.max_vreg()),
       live_ranges_(flow_graph.max_vreg()),
       unallocated_cpu_(),
@@ -180,6 +180,10 @@ void SSALivenessAnalysis::ComputeInitialSets() {
     for (BackwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
 
+      if (current->MayThrow()) {
+        does_block_have_throw.Add(i);
+      }
+
       // Initialize location summary for instruction.
       current->InitializeLocationSummary(zone(), true);  // opt
 

runtime/vm/compiler/backend/linearscan.h

@@ -38,9 +38,9 @@ class ReachingDefs : public ValueObject {
 
 class SSALivenessAnalysis : public LivenessAnalysis {
  public:
-  explicit SSALivenessAnalysis(const FlowGraph& flow_graph)
-      : LivenessAnalysis(flow_graph.max_vreg(), flow_graph.postorder()),
-        graph_entry_(flow_graph.graph_entry()) {}
+  explicit SSALivenessAnalysis(const FlowGraph* flow_graph)
+      : LivenessAnalysis(flow_graph, flow_graph->max_vreg()),
+        graph_entry_(flow_graph->graph_entry()) {}
 
  private:
   // Compute initial values for live-out, kill and live-in sets.

runtime/vm/compiler/backend/redundancy_elimination.cc

@@ -3115,7 +3115,7 @@ class StoreOptimizer : public LivenessAnalysis {
   StoreOptimizer(FlowGraph* graph,
                  AliasedSet* aliased_set,
                  PointerSet<Place>* map)
-      : LivenessAnalysis(aliased_set->max_place_id(), graph->postorder()),
+      : LivenessAnalysis(graph, aliased_set->max_place_id()),
         graph_(graph),
         map_(map),
         aliased_set_(aliased_set),