Delay get_tuple_element instructions until they are needed

When matching tuples, the pattern matching compiler would generate
code that would fetch all elements of the tuple that will ultimately
be used, *before* testing that (for example) the first element is the
correct record tag. For example:

  is_tuple Fail {x,0}
  test_arity Fail {x,0} 3
  get_tuple_element {x,0} 0 {x,1}
  get_tuple_element {x,0} 1 {x,2}
  get_tuple_element {x,0} 2 {x,3}
  is_eq_exact Fail {x,1} some_tag

If {x,2} and {x,3} are not used at label Fail, we can re-arrange the
code like this:

  is_tuple Fail {x,0}
  test_arity Fail {x,0} 3
  get_tuple_element {x,0} 0 {x,1}
  is_eq_exact Fail {x,1} some_tag
  get_tuple_element {x,0} 1 {x,2}
  get_tuple_element {x,0} 2 {x,3}

Doing that may be beneficial in two ways.

If the branch is taken, we have eliminated the execution of two
unnecessary instructions.

Even if the branch is never or rarely taken, there is the possibility
for more optimizations following the is_eq_exact instructions.
For example, imagine that the code looks like this:

  get_tuple_element {x,0} 1 {x,2}
  get_tuple_element {x,0} 2 {x,3}
  move {x,2} {y,0}
  move {x,3} {y,1}

Assuming that {x,2} and {x,3} have no further uses in the code
that follows, that can be rewritten to:

  get_tuple_element {x,0} 1 {y,0}
  get_tuple_element {x,0} 2 {y,1}

When should we perform this optimization?

At the very latest, it must be done before opt_blocks/1 in
beam_block which does the elimination of unnecessary moves.
Actually, we want do the optimization before the blocks have
been established, since moving instructions out of one block
into another is cumbersome.

Therefore, we will do the optimization in a new pass that is
run before beam_block. A new pass will make debugging easier,
and beam_block already has a fair number of sub passes.

0 files changed, 0 insertions, 0 deletions