Move the split point to the first fixed use (#165)

Address bytecodealliance/wasmtime#7147 by
moving the bundle split point to the first fixed use found after the
suggested split point. This implementation only considers the first
liverange that contains the split point, so there's room for
improvement.

The intent with this change is to not artificially constrain the bundle
produced after the split point by leaving unconstrained uses that could
be kept above the split point. Splitting at the first fixed use after
the suggested split point should produce a less constrained upper
bundle, which will be easier to allocate.

One interesting effect from the example in the issue linked above is
that the change of split point alone does not fix the problem, as we
also trim the space around the split point into the spill bundle. Doing
this creates the same splits that we would have arrived at before, as
the second load doesn't use `v1` all and thus that region is trimmed to
the spill bundle. I addressed that by disabling trimming when the split
point is advanced, under the assumption that the point moving means that
you probably want to give the allocator another chance with both
bundles.

I'm not sure that this implementation is the right path forward
currently, as it might be better to perform the heuristic outside of the
call to `split_and_requeue_bundle`, allowing us the flexibility to make
the decision about trimming at that point.

Author: elliottt

src/ion/process.rs

@@ -397,7 +397,7 @@ impl<'a, F: Function> Env<'a, F> {
         reg_hint: PReg,
         // Do we trim the parts around the split and put them in the
         // spill bundle?
-        trim_ends_into_spill_bundle: bool,
+        mut trim_ends_into_spill_bundle: bool,
     ) {
         self.stats.splits += 1;
         trace!(
@@ -496,6 +496,31 @@ impl<'a, F: Function> Env<'a, F> {
             }
             if split_at < entry.range.to {
                 first_lr_in_new_bundle_idx = i;
+
+                // When the bundle contains a fixed constraint, we advance the split point to right
+                // before the first instruction with a fixed use present.
+                if self.bundles[bundle].cached_fixed() {
+                    for u in &self.ranges[entry.index].uses {
+                        if u.pos < split_at {
+                            continue;
+                        }
+
+                        if matches!(u.operand.constraint(), OperandConstraint::FixedReg { .. }) {
+                            split_at = ProgPoint::before(u.pos.inst());
+
+                            if split_at > entry.range.from {
+                                last_lr_in_old_bundle_idx = i;
+                            }
+
+                            trace!(" -> advancing split point to {split_at:?}");
+
+                            trim_ends_into_spill_bundle = false;
+
+                            break;
+                        }
+                    }
+                }
+
                 break;
             }
         }