Recalculate cached limits

When splitting bundles, we need the ability to recalculate the cached
limit.

Author: abrown

src/ion/merge.rs

@@ -391,6 +391,28 @@ impl<'a, F: Function> Env<'a, F> {
         total
     }
 
+    pub fn compute_bundle_limit(&self, bundle: LiveBundleIndex) -> Option<usize> {
+        let mut limit: Option<usize> = None;
+        for entry in &self.bundles[bundle].ranges {
+            for u in &self.ranges[entry.index].uses {
+                use OperandConstraint::*;
+                match u.operand.constraint() {
+                    Limit(current) => match limit {
+                        Some(prev) => limit = Some(prev.min(current)),
+                        None => limit = Some(current),
+                    },
+                    FixedReg(_) | Stack => {
+                        break;
+                    }
+                    Any | Reg | Reuse(_) => {
+                        continue;
+                    }
+                }
+            }
+        }
+        limit
+    }
+
     pub fn queue_bundles(&mut self) {
         for bundle in 0..self.bundles.len() {
             trace!("enqueueing bundle{}", bundle);

src/ion/process.rs

@@ -274,6 +274,7 @@ impl<'a, F: Function> Env<'a, F> {
         let first_range_data = &self.ctx.ranges[first_range];
 
         self.ctx.bundles[bundle].prio = self.compute_bundle_prio(bundle);
+        self.ctx.bundles[bundle].limit = self.compute_bundle_limit(bundle);
 
         if first_range_data.vreg.is_invalid() {
             trace!("  -> no vreg; minimal and fixed");