optimizer: improve SROA performance (#43488)

Essentially this commit reduces the runtime count # of domtree construction.
The key observation is that SROA of mutable allocations isn't often successful.
More specifically, during the sysimg build, `sroa_mutables!` is called
`5776` times, and actual SROA happened only for `126` cases out of those cases.
(, which means we should be able to avoid domtree construction in `5650`/`5776` cases).

Author: aviatesk

base/compiler/ssair/passes.jl

@@ -820,11 +820,8 @@ function sroa_pass!(ir::IRCode)
 end
 
 function sroa_mutables!(ir::IRCode, defuses::IdDict{Int, Tuple{SPCSet, SSADefUse}}, used_ssas::Vector{Int})
-    # Compute domtree, needed below, now that we have finished compacting the IR.
-    # This needs to be after we iterate through the IR with `IncrementalCompact`
-    # because removing dead blocks can invalidate the domtree.
-    @timeit "domtree 2" domtree = construct_domtree(ir.cfg.blocks)
-
+    # initialization of domtree is delayed to avoid the expensive computation in many cases
+    local domtree = nothing
     for (idx, (intermediaries, defuse)) in defuses
         intermediaries = collect(intermediaries)
         # Check if there are any uses we did not account for. If so, the variable
@@ -885,16 +882,26 @@ function sroa_mutables!(ir::IRCode, defuses::IdDict{Int, Tuple{SPCSet, SSADefUse
             isempty(du.uses) && continue
             push!(du.defs, newidx)
             ldu = compute_live_ins(ir.cfg, du)
-            phiblocks = isempty(ldu.live_in_bbs) ? Int[] : iterated_dominance_frontier(ir.cfg, ldu, domtree)
+            if isempty(ldu.live_in_bbs)
+                phiblocks = Int[]
+            else
+                domtree === nothing && (@timeit "domtree 2" domtree = construct_domtree(ir.cfg.blocks))
+                phiblocks = iterated_dominance_frontier(ir.cfg, ldu, domtree)
+            end
             allblocks = sort(vcat(phiblocks, ldu.def_bbs))
             blocks[fidx] = phiblocks, allblocks
             if fidx + 1 > length(defexpr.args)
                 for use in du.uses
+                    domtree === nothing && (@timeit "domtree 2" domtree = construct_domtree(ir.cfg.blocks))
                     has_safe_def(ir, domtree, allblocks, du, newidx, use) || @goto skip
                 end
             end
         end
-        # Everything accounted for. Go field by field and perform idf
+        # Everything accounted for. Go field by field and perform idf:
+        # Compute domtree now, needed below, now that we have finished compacting the IR.
+        # This needs to be after we iterate through the IR with `IncrementalCompact`
+        # because removing dead blocks can invalidate the domtree.
+        domtree === nothing && (@timeit "domtree 2" domtree = construct_domtree(ir.cfg.blocks))
         preserve_uses = isempty(defuse.ccall_preserve_uses) ? nothing :
             IdDict{Int, Vector{Any}}((idx=>Any[] for idx in SPCSet(defuse.ccall_preserve_uses)))
         for fidx in 1:ndefuse