Share a few more equal switch branches

[chambart]

I was surprised to find that in the example:

type t =
  | Immutable of { cell : int }
  | Mutable of { mutable cell : int }

let cell = function
  | Immutable { cell } -> cell
  | Mutable { cell } -> cell

The match branches where not shared. This comes from a small difference between the generated code in both branches:

(let (cell/1209 =a (field 0 param/1215)) cell/1209)
(let (cell/1210 =o (field 0 param/1215)) cell/1210)

The first one being substituted by Lambda.make_key to

(field 0 param/1215)

while the other remain unchanged.

This small change simplify (let (x =o exp) x) into x to enable sharing in this kind of patterns.

CC @maranget

[gasche]

One justification for this optimization is that it is already implemented in simplif.ml.

[damiendoligez]

IIUC the two branches of your example will have to be different for the parallel runtime.
/cc @kayceesrk @stedolan

[stedolan]

Sharing these two branches is possible in the parallel runtime, but would require some effort. With the current sharing logic, @damiendoligez is correct that the two branches would generate different code and not be shared. The optimisation of turning (let (x =o exp) x) into x seems like a good one, and should cause no problems with the parallel runtime, but it won't apply in this example without more complicated sharing logic.

The load operations are different for mutable and immutable fields (a read barrier is applied to mutable loads), but it is always safe to use the mutable version even when not required. Perhaps a better way to think about the operations is that one is the general case of loading a field, and the other is the special optimised case for fields known immutable.

So, in theory, these could be shared, by allowing the compiler to combine an immutable load and a mutable load into a mutable load. It would be a complex tradeoff to share them: lowering code size at the expense of an extra barrier in the immutable case.