Detect when limits prevent allocation

In `Env::process_bundle`, we check if allocation _must_ fail and return
a `RegAllocError::TooManyLiveRegs`. This change extends the current
logic to understand how limit constraints affect this calculation.

Author: abrown

src/ion/process.rs

@@ -1036,7 +1036,7 @@ impl<'a, F: Function> Env<'a, F> {
 
             let fixed_preg = match req {
                 Requirement::FixedReg(preg) | Requirement::FixedStack(preg) => Some(preg),
-                Requirement::Register => None,
+                Requirement::Register | Requirement::Limit(..) => None,
                 Requirement::Stack => {
                     // If we must be on the stack, mark our spillset
                     // as required immediately.
@@ -1200,7 +1200,7 @@ impl<'a, F: Function> Env<'a, F> {
                     || lowest_cost_evict_conflict_cost.is_none()
                     || lowest_cost_evict_conflict_cost.unwrap() >= our_spill_weight)
             {
-                if let Requirement::Register = req {
+                if matches!(req, Requirement::Register | Requirement::Limit(_)) {
                     // Check if this is a too-many-live-registers situation.
                     let range = self.ctx.bundles[bundle].ranges[0].range;
                     trace!("checking for too many live regs");
@@ -1240,6 +1240,15 @@ impl<'a, F: Function> Env<'a, F> {
                                 fixed_assigned += 1;
                             }
                         }
+
+                        // We also need to discard any registers that do not fit
+                        // under the limit--we cannot allocate to them.
+                        if let Requirement::Limit(limit) = req {
+                            if preg.hw_enc() >= limit as usize {
+                                continue;
+                            }
+                        }
+
                         total_regs += 1;
                     }
                     trace!(