[llvm] [StructurizeCFG] Order IF Else block using Heuristics (PR #139605)

[Vigneshwar Jayakumar via llvm-commits]

================
@@ -419,6 +446,58 @@ INITIALIZE_PASS_DEPENDENCY(RegionInfoPass)
 INITIALIZE_PASS_END(StructurizeCFGLegacyPass, "structurizecfg",
                     "Structurize the CFG", false, false)
 
+/// Then and Else block order in SCC is arbitrary. But based on the
+/// order, after structurization there are cases where there might be extra
----------------
VigneshwarJ wrote:

The blocks are already sorted in the topological order. But in case of if-then-else, topologically then,else or else,then is same. But based on the order, there are extra copies that leads to spill in large cases.

This is specifically seen in case where one block just copies values and other block modifies values.

``` llvm
if:
  %vec = <4 x i32> ...
  br i1 %c %then %else
then:
  %x = extractelement <4 x i32> %vec, i32 0
  %z = add i32 %x, 1
  br label %merge
else:
  %a = extractelement <4 x i32> %vec, i32 0
  br label %merge
merge:
  %phi = phi i32 [ %z, %then ], [ %a, %else ]
  store i32 %phi, ptr  %ptr
  ret void

```

After structurization and machine code , if 'then' block is ordered first
then at register coalescer
``` llvm
if:
   [v0 - v4] = ...
    cond_branch_scc then
tmp:
    v5 = 0
    branch Flow
then:
   v5 = copy v0  ; eliminated in reg coalescer
   v5 = v5 + 1  ; v5 = v0 + 1
flow:
   v6 = v5 ; eliminated
   cond_branch final
else:
   v6 = copy v0 ;  v5 = copy v0 
 ; this copy v5 = copy v0 can't be coalesced further then->flow->else live range 
final:
   store v6 ; store v5
```
but at the same time, if 'else' block is ordered first,

``` llvm
if:
   [v0 - v4] = ...
    cond_branch_scc else
tmp:
    v5 = 0
    branch Flow
else:
   v6 = copy v0 ; eliminated
flow:
   v6 = v5 
   cond_branch final
then:
   v5 = copy v0  ; eliminated in reg coalescer
   v5 = v5 + 1  ; v5 = v0 + 1 ; can be coalesced to v0 = v0 + 1
final:
   store v6 ; coalesced to  store v0
```

Theres an extra copy just due to ordering in the first case. Though then and else block won't be live at same time due to structurization, we see this.

This heuristics just sees instructions that can be lowered to copy instructions


https://github.com/llvm/llvm-project/pull/139605