Revert "Remove the OperandConstraint::Stack variant (#185)"

cfallin · cfallin · commit 6a3a61593ad2 · 2025-07-21T20:17:41.000-07:00
This reverts commit abdc3d6.
diff --git a/doc/ION.md b/doc/ION.md
@@ -442,11 +442,14 @@ other):
 
 ```plain
 
-                         Any(rc)
-                        /       \
-              FixedReg(reg)   FixedStack(reg)
-                        \       /
-                         Conflict
+        ___Unknown_____
+        |      |      |
+        |      |      |
+        | ____Any(rc) |
+        |/     |      |
+   Stack(rc)  FixedReg(reg)
+         \    /
+        Conflict
 ```
 
 Once we have the Requirement for a bundle, we can decide what to do.
diff --git a/src/checker.rs b/src/checker.rs
@@ -640,6 +640,17 @@ impl CheckerState {
                 }
                 return Err(CheckerError::AllocationIsNotReg { inst, op, alloc });
             }
+            OperandConstraint::Stack => {
+                if alloc.kind() != AllocationKind::Stack {
+                    // Accept pregs that represent a fixed stack slot.
+                    if let Some(preg) = alloc.as_reg() {
+                        if checker.machine_env.fixed_stack_slots.contains(&preg) {
+                            return Ok(());
+                        }
+                    }
+                    return Err(CheckerError::AllocationIsNotStack { inst, op, alloc });
+                }
+            }
             OperandConstraint::FixedReg(preg) => {
                 if alloc != Allocation::reg(preg) {
                     return Err(CheckerError::AllocationIsNotFixedReg { inst, op, alloc });
diff --git a/src/ion/data_structures.rs b/src/ion/data_structures.rs
@@ -205,7 +205,7 @@ pub struct LiveBundle {
     pub spill_weight_and_props: u32,
 }
 
-pub const BUNDLE_MAX_SPILL_WEIGHT: u32 = (1 << 29) - 1;
+pub const BUNDLE_MAX_SPILL_WEIGHT: u32 = (1 << 28) - 1;
 pub const MINIMAL_FIXED_BUNDLE_SPILL_WEIGHT: u32 = BUNDLE_MAX_SPILL_WEIGHT;
 pub const MINIMAL_BUNDLE_SPILL_WEIGHT: u32 = BUNDLE_MAX_SPILL_WEIGHT - 1;
 pub const BUNDLE_MAX_NORMAL_SPILL_WEIGHT: u32 = BUNDLE_MAX_SPILL_WEIGHT - 2;
@@ -218,12 +218,14 @@ impl LiveBundle {
         minimal: bool,
         fixed: bool,
         fixed_def: bool,
+        stack: bool,
     ) {
         debug_assert!(spill_weight <= BUNDLE_MAX_SPILL_WEIGHT);
         self.spill_weight_and_props = spill_weight
             | (if minimal { 1 << 31 } else { 0 })
             | (if fixed { 1 << 30 } else { 0 })
-            | (if fixed_def { 1 << 29 } else { 0 });
+            | (if fixed_def { 1 << 29 } else { 0 })
+            | (if stack { 1 << 28 } else { 0 });
     }
 
     #[inline(always)]
diff --git a/src/ion/liveranges.rs b/src/ion/liveranges.rs
@@ -824,6 +824,10 @@ impl<'a, F: Function> Env<'a, F> {
                                     first_reg_slot.get_or_insert(u.slot);
                                 }
                             }
+                            // Maybe this could be supported in this future...
+                            OperandConstraint::Stack => panic!(
+                                "multiple uses of vreg with a Stack constraint are not supported"
+                            ),
                         }
                     }
 
diff --git a/src/ion/merge.rs b/src/ion/merge.rs
@@ -282,6 +282,7 @@ impl<'a, F: Function> Env<'a, F> {
 
             let mut fixed = false;
             let mut fixed_def = false;
+            let mut stack = false;
             for entry in &self.bundles[bundle].ranges {
                 for u in &self.ranges[entry.index].uses {
                     if let OperandConstraint::FixedReg(_) = u.operand.constraint() {
@@ -290,7 +291,10 @@ impl<'a, F: Function> Env<'a, F> {
                             fixed_def = true;
                         }
                     }
-                    if fixed && fixed_def {
+                    if let OperandConstraint::Stack = u.operand.constraint() {
+                        stack = true;
+                    }
+                    if fixed && stack && fixed_def {
                         break;
                     }
                 }
@@ -301,6 +305,9 @@ impl<'a, F: Function> Env<'a, F> {
             if fixed_def {
                 self.bundles[bundle].set_cached_fixed_def();
             }
+            if stack {
+                self.bundles[bundle].set_cached_stack();
+            }
 
             // Create a spillslot for this bundle.
             let reg = self.vreg(vreg);
diff --git a/src/ion/process.rs b/src/ion/process.rs
@@ -267,6 +267,7 @@ impl<'a, F: Function> Env<'a, F> {
         let minimal;
         let mut fixed = false;
         let mut fixed_def = false;
+        let mut stack = false;
         let bundledata = &self.ctx.bundles[bundle];
         let num_ranges = bundledata.ranges.len();
         let first_range = bundledata.ranges[0].index;
@@ -288,7 +289,12 @@ impl<'a, F: Function> Env<'a, F> {
                         trace!("  -> is fixed def");
                         fixed_def = true;
                     }
-
+                }
+                if let OperandConstraint::Stack = u.operand.constraint() {
+                    trace!("  -> stack operand at {:?}: {:?}", u.pos, u.operand);
+                    stack = true;
+                }
+                if stack && fixed {
                     break;
                 }
             }
@@ -351,6 +357,7 @@ impl<'a, F: Function> Env<'a, F> {
             minimal,
             fixed,
             fixed_def,
+            stack,
         );
     }
 
@@ -1036,6 +1043,12 @@ impl<'a, F: Function> Env<'a, F> {
             let fixed_preg = match req {
                 Requirement::FixedReg(preg) | Requirement::FixedStack(preg) => Some(preg),
                 Requirement::Register => None,
+                Requirement::Stack => {
+                    // If we must be on the stack, mark our spillset
+                    // as required immediately.
+                    self.spillsets[self.bundles[bundle].spillset].required = true;
+                    return Ok(());
+                }
 
                 Requirement::Any => {
                     self.ctx.spilled_bundles.push(bundle);
diff --git a/src/ion/requirement.rs b/src/ion/requirement.rs
@@ -61,6 +61,7 @@ pub enum Requirement {
     FixedReg(PReg),
     FixedStack(PReg),
     Register,
+    Stack,
     Any,
 }
 impl Requirement {
@@ -69,10 +70,15 @@ impl Requirement {
         match (self, other) {
             (other, Requirement::Any) | (Requirement::Any, other) => Ok(other),
             (Requirement::Register, Requirement::Register) => Ok(self),
+            (Requirement::Stack, Requirement::Stack) => Ok(self),
             (Requirement::Register, Requirement::FixedReg(preg))
             | (Requirement::FixedReg(preg), Requirement::Register) => {
                 Ok(Requirement::FixedReg(preg))
             }
+            (Requirement::Stack, Requirement::FixedStack(preg))
+            | (Requirement::FixedStack(preg), Requirement::Stack) => {
+                Ok(Requirement::FixedStack(preg))
+            }
             (Requirement::FixedReg(a), Requirement::FixedReg(b)) if a == b => Ok(self),
             (Requirement::FixedStack(a), Requirement::FixedStack(b)) if a == b => Ok(self),
             _ => Err(RequirementConflict),
@@ -82,7 +88,7 @@ impl Requirement {
     #[inline(always)]
     pub fn is_stack(self) -> bool {
         match self {
-            Requirement::FixedStack(..) => true,
+            Requirement::Stack | Requirement::FixedStack(..) => true,
             Requirement::Register | Requirement::FixedReg(..) => false,
             Requirement::Any => false,
         }
@@ -92,7 +98,7 @@ impl Requirement {
     pub fn is_reg(self) -> bool {
         match self {
             Requirement::Register | Requirement::FixedReg(..) => true,
-            Requirement::FixedStack(..) => false,
+            Requirement::Stack | Requirement::FixedStack(..) => false,
             Requirement::Any => false,
         }
     }
@@ -110,6 +116,7 @@ impl<'a, F: Function> Env<'a, F> {
                 }
             }
             OperandConstraint::Reg | OperandConstraint::Reuse(_) => Requirement::Register,
+            OperandConstraint::Stack => Requirement::Stack,
             OperandConstraint::Any => Requirement::Any,
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -528,6 +528,8 @@ pub enum OperandConstraint {
     Any,
     /// Operand must be in a register. Register is read-only for Uses.
     Reg,
+    /// Operand must be on the stack.
+    Stack,
     /// Operand must be in a fixed register.
     FixedReg(PReg),
     /// On defs only: reuse a use's register.
@@ -539,6 +541,7 @@ impl core::fmt::Display for OperandConstraint {
         match self {
             Self::Any => write!(f, "any"),
             Self::Reg => write!(f, "reg"),
+            Self::Stack => write!(f, "stack"),
             Self::FixedReg(preg) => write!(f, "fixed({})", preg),
             Self::Reuse(idx) => write!(f, "reuse({})", idx),
         }
@@ -634,6 +637,7 @@ impl Operand {
         let constraint_field = match constraint {
             OperandConstraint::Any => 0,
             OperandConstraint::Reg => 1,
+            OperandConstraint::Stack => 2,
             OperandConstraint::FixedReg(preg) => {
                 debug_assert_eq!(preg.class(), vreg.class());
                 0b1000000 | preg.hw_enc() as u32
@@ -906,6 +910,7 @@ impl Operand {
             match constraint_field {
                 0 => OperandConstraint::Any,
                 1 => OperandConstraint::Reg,
+                2 => OperandConstraint::Stack,
                 _ => unreachable!(),
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -824,6 +824,10 @@ impl<'a, F: Function> Env<'a, F> {`
`824`	`824`	`first_reg_slot.get_or_insert(u.slot);`
`825`	`825`	`}`
`826`	`826`	`}`
	`827`	`+ // Maybe this could be supported in this future...`
	`828`	`+ OperandConstraint::Stack => panic!(`
	`829`	`+ "multiple uses of vreg with a Stack constraint are not supported"`
	`830`	`+ ),`
`827`	`831`	`}`
`828`	`832`	`}`
`829`	`833`
Original file line number	Diff line number	Diff line change
`@@ -282,6 +282,7 @@ impl<'a, F: Function> Env<'a, F> {`
`282`	`282`
`283`	`283`	`let mut fixed = false;`
`284`	`284`	`let mut fixed_def = false;`
	`285`	`+ let mut stack = false;`
`285`	`286`	`for entry in &self.bundles[bundle].ranges {`
`286`	`287`	`for u in &self.ranges[entry.index].uses {`
`287`	`288`	`if let OperandConstraint::FixedReg(_) = u.operand.constraint() {`
`@@ -290,7 +291,10 @@ impl<'a, F: Function> Env<'a, F> {`
`290`	`291`	`fixed_def = true;`
`291`	`292`	`}`
`292`	`293`	`}`
`293`		`- if fixed && fixed_def {`
	`294`	`+ if let OperandConstraint::Stack = u.operand.constraint() {`
	`295`	`+ stack = true;`
	`296`	`+ }`
	`297`	`+ if fixed && stack && fixed_def {`
`294`	`298`	`break;`
`295`	`299`	`}`
`296`	`300`	`}`
`@@ -301,6 +305,9 @@ impl<'a, F: Function> Env<'a, F> {`
`301`	`305`	`if fixed_def {`
`302`	`306`	`self.bundles[bundle].set_cached_fixed_def();`
`303`	`307`	`}`
	`308`	`+ if stack {`
	`309`	`+ self.bundles[bundle].set_cached_stack();`
	`310`	`+ }`
`304`	`311`
`305`	`312`	`// Create a spillslot for this bundle.`
`306`	`313`	`let reg = self.vreg(vreg);`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ pub enum Requirement {`
`61`	`61`	`FixedReg(PReg),`
`62`	`62`	`FixedStack(PReg),`
`63`	`63`	`Register,`
	`64`	`+ Stack,`
`64`	`65`	`Any,`
`65`	`66`	`}`
`66`	`67`	`impl Requirement {`
`@@ -69,10 +70,15 @@ impl Requirement {`
`69`	`70`	`match (self, other) {`
`70`	`71`	`(other, Requirement::Any) \| (Requirement::Any, other) => Ok(other),`
`71`	`72`	`(Requirement::Register, Requirement::Register) => Ok(self),`
	`73`	`+ (Requirement::Stack, Requirement::Stack) => Ok(self),`
`72`	`74`	`(Requirement::Register, Requirement::FixedReg(preg))`
`73`	`75`	`\| (Requirement::FixedReg(preg), Requirement::Register) => {`
`74`	`76`	`Ok(Requirement::FixedReg(preg))`
`75`	`77`	`}`
	`78`	`+ (Requirement::Stack, Requirement::FixedStack(preg))`
	`79`	`+ \| (Requirement::FixedStack(preg), Requirement::Stack) => {`
	`80`	`+ Ok(Requirement::FixedStack(preg))`
	`81`	`+ }`
`76`	`82`	`(Requirement::FixedReg(a), Requirement::FixedReg(b)) if a == b => Ok(self),`
`77`	`83`	`(Requirement::FixedStack(a), Requirement::FixedStack(b)) if a == b => Ok(self),`
`78`	`84`	`_ => Err(RequirementConflict),`
`@@ -82,7 +88,7 @@ impl Requirement {`
`82`	`88`	`#[inline(always)]`
`83`	`89`	`pub fn is_stack(self) -> bool {`
`84`	`90`	`match self {`
`85`		`- Requirement::FixedStack(..) => true,`
	`91`	`+ Requirement::Stack \| Requirement::FixedStack(..) => true,`
`86`	`92`	`Requirement::Register \| Requirement::FixedReg(..) => false,`
`87`	`93`	`Requirement::Any => false,`
`88`	`94`	`}`
`@@ -92,7 +98,7 @@ impl Requirement {`
`92`	`98`	`pub fn is_reg(self) -> bool {`
`93`	`99`	`match self {`
`94`	`100`	`Requirement::Register \| Requirement::FixedReg(..) => true,`
`95`		`- Requirement::FixedStack(..) => false,`
	`101`	`+ Requirement::Stack \| Requirement::FixedStack(..) => false,`
`96`	`102`	`Requirement::Any => false,`
`97`	`103`	`}`
`98`	`104`	`}`
`@@ -110,6 +116,7 @@ impl<'a, F: Function> Env<'a, F> {`
`110`	`116`	`}`
`111`	`117`	`}`
`112`	`118`	`OperandConstraint::Reg \| OperandConstraint::Reuse(_) => Requirement::Register,`
	`119`	`+ OperandConstraint::Stack => Requirement::Stack,`
`113`	`120`	`OperandConstraint::Any => Requirement::Any,`
`114`	`121`	`}`
`115`	`122`	`}`