During the discussion of #162, it appears that a call in one branch will always hindered a fast path in another branch because all the live registers will have to be reloaded after the join point. The problem is particularly patent in ocaml since there is no callee saved registers.

This request for comment implements the analogous of this existing optimisation1. Instead of pushing later spillings in the branch that needs them, it pushes earlier reloadings in the branch that destroys the registers.

With this optimization the following (dumb) function use only registers in the case x<y, and as many spilling/reloading than previously :

let fun_l (x:int) y =
  let r = if x < y then y else max x y in
  r + x + y

Deadcode elimination pass is added after the split pass because unneeded reloading can be added as in this function:

 let fun_i (x:int) y z =
  let r = if x < y then y else max x y in
  let w = max r r in
  w + r + x + y

This optimization has similar bad cases than the previous one and the interaction with the previous one (spill late) could add a lot of spilling. In this function (where fun_l is automatically inlined) x is spilled once more (in the slow path) by call to fun_l:

let fun_m x y =
  let r = fun_l x y in
  let r = fun_l r x in
  let r = fun_l r x in
  r

If the previous optimization (spill late) is deactivated there are as many spilling/reloading as before.

Does this optimization have already been considered? Do you think it can be interesting to investigate it more? with macro-benchmarks?

Regards,