hipe: Add range splitter range_split

hipe_range_split is a complex live range splitter, more sophisticated
thatn hipe_restore_reuse, but still targeted specifically at temporaries
forced onto stack by being live over call instructions.

hipe_range_split partitions the control flow graph at call instructions,
like hipe_regalloc_prepass. Splitting decisions are made on a per
partition and per temporary basis.

There are three different ways in which hipe_range_split may choose to
split a temporary in a program partition:

 * Mode1: Spill the temp before calls, and restore it after them
 * Mode2: Spill the temp after definitions, restore it after calls
 * Mode3: Spill the temp after definitions, restore it before uses

To pick which of these should be used for each temp×partiton pair,
hipe_range_split uses a cost function. The cost is simply the sum of the
cost of all expected stack accesses, and the cost for an individual
stack access is based on the probability weight of the basic block that
it resides in. This biases the range splitter so that it attempts moving
stack accesses from a functions hot path to the cold path.
hipe_bb_weights is used to compute the probability weights.

mode3 is effectively the same as what hipe_restore_reuse does. Because
of this, hipe_restore_reuse reuses the analysis pass of
hipe_restore_reuse in order to compute the minimal needed set of spills
and restores. The reason mode3 was introduced to hipe_range_split rather
than simply composing it with hipe_restore_reuse (by running both) is
that such a composition resulted in poor register allocation results due
to insufficiently strong move coalescing in the register allocator.

The cost function heuristic has a couple of tuning knobs:

 * {range_split_min_gain, Gain} (default: 1.1, range: [0.0, inf))
   The minimum proportional improvement that the cost of all stack
   accesses to a temp must display in order for that temp to be split.
 * {range_split_mode1_fudge, Factor} (default: 1.1, range: [0.0, inf))
   Costs for mode1 are multiplied by this factor in order to discourage
   it when it provides marginal benefits. The justification is that
   mode1 causes temps to be live for longest, thus leading to higher
   register pressure.
 * {range_split_weight_power, Factor} (default: 2, range: (0.0, inf))
   Adjusts how much effect the basic block weights have on the cost of a
   stack access. A stack access in a block with weight 1.0 has cost 1.0,
   a stack access in a block with weight 0.01 has cost 1/Factor.

Additionally, the option range_split_weights chooses whether the basic
block weights are used at all.

In the case that the input is very big, hipe_range_split automatically
falls back to hipe_restore_reuse only in order to keep compile times
under control. Note that this is not only because of hipe_range_split
being slow, but also due to the resulting program being slow to register
allocate, and is not as partitionable by hipe_regalloc_prepass.
hipe_restore_reuse, on the other hand, does not affect the programs
partitionability.

The hipe_range_split pass is controlled by a new option ra_range_split.
ra_range_split is added to o2, and ra_restore_reuse is disabled in o2.

1 files changed, 1 insertions, 0 deletions

diff --git a/lib/hipe/main/hipe.app.src b/lib/hipe/main/hipe.app.src
index 01499472f4..de0b255c01 100644
--- a/lib/hipe/main/hipe.app.src
+++ b/lib/hipe/main/hipe.app.src
@@ -148,6 +148,7 @@
 	     hipe_ppc_specific_fp,
 	     hipe_ppc_subst,
 	     hipe_profile,
+	     hipe_range_split,
 	     hipe_reg_worklists,
 	     hipe_regalloc_loop,
 	     hipe_regalloc_prepass,