[vm,compiler] Fix loop computation in case of try blocks

If catch block is included into the loop, we should also include
the whole try body as there are implicit control flow edges between
each block in a try body and corresponding catch block.

If try body is not included, analysis of loop invariant loads
could miss conflicting stores and may conclude that certain loads are
loop invariant although they are not.

TEST=runtime/tests/vm/dart/regress_63336_test.dart
Fixes https://github.com/dart-lang/sdk/issues/63336

Change-Id: I9d6b73e24554ee3bfbcc722fa59634ea90b00abb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/501560
Reviewed-by: Slava Egorov <vegorov@google.com>
Commit-Queue: Alexander Markov <alexmarkov@google.com>

pkg/cfg/lib/ir/loops.dart

@@ -61,6 +61,15 @@ class Loop {
           workList.add(pred);
         }
       }
+      if (block is CatchBlock) {
+        // Blocks from the try body are implicit predecessors of a catch block.
+        for (final pred in block.graph.reversePostorder) {
+          if (pred.exceptionHandler == block && !contains(pred)) {
+            add(pred);
+            workList.add(pred);
+          }
+        }
+      }
     }
   }
 

pkg/cfg/testcases/loops.dart

@@ -41,4 +41,26 @@ void irreducible(int i) {
   }
 }
 
+int var63 = 28;
+int var68 = 44;
+
+void withTryBlock() {
+  var n = 43;
+  while (--n > 0) {
+    try {
+      var63++;
+      // Terminate block without reaching a loop backedge,
+      // so try body won't be included into the loop body
+      // through explicit predecessors of the backedge.
+      throw 'bye';
+    } on StackOverflowError {
+      rethrow;
+    } catch (_) {
+      // Load from 'var63' is considered loop invariant if
+      // loop body doesn't include try block body.
+      var68 = var63;
+    }
+  }
+}
+
 void main() {}

pkg/cfg/testcases/loops.dart.expect

@@ -111,8 +111,53 @@ B14 = TargetBlock() idom:B8
 B34 = JoinBlock(B14, B29) idom:B0
   Return(v38)
 
+--- withTryBlock
+B0 = EntryBlock() dominates:(B3)
+  v1 = Constant(43)
+  v6 = Constant(1)
+  v9 = Constant(0)
+  v20 = Constant("bye")
+  v22 = Constant(null)
+  v42 = Constant(-1)
+  Goto(B3)
+B3 = JoinBlock(B0, B28) idom:B0 dominates:(B12, B11) loop-header (depth:1 body:(B3, B11, B15, B28, B14) back-edges:(B28))
+  v41 = Phi(v1, v43)
+  v43 = BinaryIntOp +(v41, v42)
+  v10 = Comparison int >(v43, v9)
+  Branch(v10, true: B11, false: B12)
+B11 = TargetBlock() idom:B3 dominates:(B15, B14) in-loop:B3
+  TryEntry(try-body: B14, catch-block: B15)
+B14 = TargetBlock() exception-handler:B15 idom:B11 in-loop:B3
+  v17 = LoadStaticField(var63)
+  v18 = BinaryIntOp +(v17, v6)
+  StoreStaticField(var63, v18)
+  Throw(v20)
+B15 = CatchBlock() idom:B11 dominates:(B28, B27) in-loop:B3
+  v23 = Parameter(#exception)
+  v24 = Parameter(#stackTrace)
+  v26 = TypeTest(v23, StackOverflowError)
+  Branch(v26, true: B27, false: B28)
+B27 = TargetBlock() idom:B15
+  Throw(v23, v24)
+B28 = TargetBlock() idom:B15 in-loop:B3
+  v35 = LoadStaticField(var63)
+  StoreStaticField(var68, v35)
+  Goto(B3)
+B12 = TargetBlock() idom:B3
+  Return(v22)
+
 --- main
 B0 = EntryBlock()
   v1 = Constant(null)
   Return(v1)
 
+--- field-init var63
+B0 = EntryBlock()
+  v1 = Constant(28)
+  Return(v1)
+
+--- field-init var68
+B0 = EntryBlock()
+  v1 = Constant(44)
+  Return(v1)
+