Allow nested loops with shared entry

Predecessors which `entry` dominates need not be considered
side-entries.

src/jit/optimizer.cpp

@@ -1880,10 +1880,24 @@ class LoopSearch
                 if ((testNum < top->bbNum) || (testNum > bottom->bbNum))
                 {
                     // Pred is out of loop range
-                    if ((pred == head) && (block == entry))
+                    if (block == entry)
                     {
-                        // This is the single entry we expect.
-                        continue;
+                        if (pred == head)
+                        {
+                            // This is the single entry we expect.
+                            continue;
+                        }
+                        // ENTRY has some pred other than head outside the loop.  If ENTRY does not
+                        // dominate this pred, we'll consider this a side-entry and skip this loop;
+                        // otherwise the loop is still valid and this may be a (flow-wise) back-edge
+                        // of an outer loop.  For the dominance test, if `pred` is a new block, use
+                        // its unique predecessor since the dominator tree has info for that.
+                        BasicBlock* effectivePred = (pred->bbNum > oldBlockMaxNum ? pred->bbPrev : pred);
+                        if (comp->fgDominate(entry, effectivePred))
+                        {
+                            // Outer loop back-edge
+                            continue;
+                        }
                     }
 
                     // There are multiple entries to this loop, don't consider it.