T0b1/regalloc2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename OperandPolicy to OperandConstraint as per feedback from @julian-seward1.

Browse Source
This commit is contained in:
Chris Fallin
2021-08-12 11:17:52 -07:00
parent c9e8a87cea
commit 84285c26fb
8 changed files with 107 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/checker.rs
View File

@@ -17,7 +17,7 @@
//! conceptually generates a symbolic value "Vn" when storing to (or
//! modifying) a virtual register.
//!
//! Operand policies (fixed register, register, any) are also checked
//! Operand constraints (fixed register, register, any) are also checked
//! at each operand.
//!
//! The dataflow analysis state at each program point is:
@@ -67,7 +67,7 @@
use crate::{
Allocation, AllocationKind, Block, Edit, Function, Inst, InstPosition, Operand, OperandKind,
OperandPolicy, OperandPos, Output, PReg, ProgPoint, SpillSlot, VReg,
OperandConstraint, OperandPos, Output, PReg, ProgPoint, SpillSlot, VReg,
};
use std::collections::{HashMap, HashSet, VecDeque};
@@ -106,7 +106,7 @@ pub enum CheckerError {
alloc: Allocation,
actual: VReg,
},
PolicyViolated {
ConstraintViolated {
inst: Inst,
op: Operand,
alloc: Allocation,
@@ -266,7 +266,7 @@ impl CheckerState {
_ => {}
}
self.check_policy(inst, op, alloc, allocs)?;
self.check_constraint(inst, op, alloc, allocs)?;
Ok(())
}
@@ -287,14 +287,14 @@ impl CheckerState {
// happens early.
let has_reused_input = operands
.iter()
.any(|op| matches!(op.policy(), OperandPolicy::Reuse(_)));
.any(|op| matches!(op.constraint(), OperandConstraint::Reuse(_)));
if has_reused_input && pos == InstPosition::After {
return Ok(());
}
// For each operand, check (i) that the allocation
// contains the expected vreg, and (ii) that it meets
// the requirements of the OperandPolicy.
// the requirements of the OperandConstraint.
for (op, alloc) in operands.iter().zip(allocs.iter()) {
let is_here = match (op.pos(), pos) {
(OperandPos::Before, InstPosition::Before) => true,
@@ -413,31 +413,31 @@ impl CheckerState {
}
}
fn check_policy(
fn check_constraint(
&self,
inst: Inst,
op: Operand,
alloc: Allocation,
allocs: &[Allocation],
) -> Result<(), CheckerError> {
match op.policy() {
OperandPolicy::Any => {}
OperandPolicy::Reg => {
match op.constraint() {
OperandConstraint::Any => {}
OperandConstraint::Reg => {
if alloc.kind() != AllocationKind::Reg {
return Err(CheckerError::AllocationIsNotReg { inst, op, alloc });
}
}
OperandPolicy::Stack => {
OperandConstraint::Stack => {
if alloc.kind() != AllocationKind::Stack {
return Err(CheckerError::AllocationIsNotStack { inst, op, alloc });
}
}
OperandPolicy::FixedReg(preg) => {
OperandConstraint::FixedReg(preg) => {
if alloc != Allocation::reg(preg) {
return Err(CheckerError::AllocationIsNotFixedReg { inst, op, alloc });
}
}
OperandPolicy::Reuse(idx) => {
OperandConstraint::Reuse(idx) => {
if alloc.kind() != AllocationKind::Reg {
return Err(CheckerError::AllocationIsNotReg { inst, op, alloc });
}

20
src/fuzzing/func.rs
View File

@@ -5,7 +5,7 @@
use crate::{
domtree, postorder, Allocation, Block, Function, Inst, InstRange, MachineEnv, Operand,
OperandKind, OperandPolicy, OperandPos, PReg, RegClass, VReg,
OperandKind, OperandConstraint, OperandPos, PReg, RegClass, VReg,
};
use arbitrary::Result as ArbitraryResult;
@@ -230,9 +230,9 @@ impl FuncBuilder {
}
}
impl Arbitrary for OperandPolicy {
impl Arbitrary for OperandConstraint {
fn arbitrary(u: &mut Unstructured) -> ArbitraryResult<Self> {
Ok(*u.choose(&[OperandPolicy::Any, OperandPolicy::Reg])?)
Ok(*u.choose(&[OperandConstraint::Any, OperandConstraint::Reg])?)
}
}
@@ -401,13 +401,13 @@ impl Func {
let mut avail = block_params[block].clone();
let mut remaining_nonlocal_uses = u.int_in_range(0..=3)?;
while let Some(vreg) = vregs_by_block_to_be_defined[block].pop() {
let def_policy = OperandPolicy::arbitrary(u)?;
let def_constraint = OperandConstraint::arbitrary(u)?;
let def_pos = if bool::arbitrary(u)? {
OperandPos::Before
} else {
OperandPos::After
};
let mut operands = vec![Operand::new(vreg, def_policy, OperandKind::Def, def_pos)];
let mut operands = vec![Operand::new(vreg, def_constraint, OperandKind::Def, def_pos)];
let mut allocations = vec![Allocation::none()];
for _ in 0..u.int_in_range(0..=3)? {
let vreg = if avail.len() > 0
@@ -433,10 +433,10 @@ impl Func {
} else {
break;
};
let use_policy = OperandPolicy::arbitrary(u)?;
let use_constraint = OperandConstraint::arbitrary(u)?;
operands.push(Operand::new(
vreg,
use_policy,
use_constraint,
OperandKind::Use,
OperandPos::Before,
));
@@ -450,14 +450,14 @@ impl Func {
let reused = u.int_in_range(1..=(operands.len() - 1))?;
operands[0] = Operand::new(
op.vreg(),
OperandPolicy::Reuse(reused),
OperandConstraint::Reuse(reused),
op.kind(),
OperandPos::After,
);
// Make sure reused input is a Reg.
let op = operands[reused];
operands[reused] =
Operand::new(op.vreg(), OperandPolicy::Reg, op.kind(), OperandPos::Before);
Operand::new(op.vreg(), OperandConstraint::Reg, op.kind(), OperandPos::Before);
} else if opts.fixed_regs && bool::arbitrary(u)? {
let mut fixed = vec![];
for _ in 0..u.int_in_range(0..=operands.len() - 1)? {
@@ -471,7 +471,7 @@ impl Func {
let op = operands[i];
operands[i] = Operand::new(
op.vreg(),
OperandPolicy::FixedReg(fixed_reg),
OperandConstraint::FixedReg(fixed_reg),
op.kind(),
op.pos(),
);

60
src/ion/liveranges.rs
View File

@@ -20,7 +20,7 @@ use super::{
};
use crate::bitvec::BitVec;
use crate::{
Allocation, Block, Function, Inst, InstPosition, Operand, OperandKind, OperandPolicy,
Allocation, Block, Function, Inst, InstPosition, Operand, OperandKind, OperandConstraint,
OperandPos, PReg, ProgPoint, RegAllocError, VReg,
};
use fxhash::FxHashSet;
@@ -29,19 +29,19 @@ use std::collections::{HashSet, VecDeque};
use std::convert::TryFrom;
#[inline(always)]
pub fn spill_weight_from_policy(policy: OperandPolicy, loop_depth: usize, is_def: bool) -> u32 {
pub fn spill_weight_from_constraint(constraint: OperandConstraint, loop_depth: usize, is_def: bool) -> u32 {
// A bonus of 1000 for one loop level, 4000 for two loop levels,
// 16000 for three loop levels, etc. Avoids exponentiation.
// Bound `loop_depth` at 2 so that `hot_bonus` is at most 16000.
let loop_depth = std::cmp::min(2, loop_depth);
let hot_bonus = 1000 * (1 << (2 * loop_depth));
let def_bonus = if is_def { 2000 } else { 0 };
let policy_bonus = match policy {
OperandPolicy::Any => 1000,
OperandPolicy::Reg | OperandPolicy::FixedReg(_) => 2000,
let constraint_bonus = match constraint {
OperandConstraint::Any => 1000,
OperandConstraint::Reg | OperandConstraint::FixedReg(_) => 2000,
_ => 0,
};
hot_bonus + def_bonus + policy_bonus
hot_bonus + def_bonus + constraint_bonus
}
impl<'a, F: Function> Env<'a, F> {
@@ -184,11 +184,11 @@ impl<'a, F: Function> Env<'a, F> {
pub fn insert_use_into_liverange(&mut self, into: LiveRangeIndex, mut u: Use) {
let operand = u.operand;
let policy = operand.policy();
let constraint = operand.constraint();
let block = self.cfginfo.insn_block[u.pos.inst().index()];
let loop_depth = self.cfginfo.approx_loop_depth[block.index()] as usize;
let weight =
spill_weight_from_policy(policy, loop_depth, operand.kind() != OperandKind::Use);
spill_weight_from_constraint(constraint, loop_depth, operand.kind() != OperandKind::Use);
u.weight = u16::try_from(weight).expect("weight too large for u16 field");
log::debug!(
@@ -415,7 +415,7 @@ impl<'a, F: Function> Env<'a, F> {
// proper interference wrt other inputs.
let mut reused_input = None;
for op in self.func.inst_operands(inst) {
if let OperandPolicy::Reuse(i) = op.policy() {
if let OperandConstraint::Reuse(i) = op.constraint() {
reused_input = Some(i);
break;
}
@@ -465,12 +465,12 @@ impl<'a, F: Function> Env<'a, F> {
);
}
let src_preg = match src.policy() {
OperandPolicy::FixedReg(r) => r,
let src_preg = match src.constraint() {
OperandConstraint::FixedReg(r) => r,
_ => unreachable!(),
};
let dst_preg = match dst.policy() {
OperandPolicy::FixedReg(r) => r,
let dst_preg = match dst.constraint() {
OperandConstraint::FixedReg(r) => r,
_ => unreachable!(),
};
self.insert_move(
@@ -484,7 +484,7 @@ impl<'a, F: Function> Env<'a, F> {
// If exactly one of source and dest (but not
// both) is a pinned-vreg, convert this into a
// ghost use on the other vreg with a FixedReg
// policy.
// constraint.
else if self.vregs[src.vreg().vreg()].is_pinned
|| self.vregs[dst.vreg().vreg()].is_pinned
{
@@ -513,20 +513,20 @@ impl<'a, F: Function> Env<'a, F> {
ProgPoint::after(inst),
)
};
let policy = OperandPolicy::FixedReg(preg);
let operand = Operand::new(vreg, policy, kind, pos);
let constraint = OperandConstraint::FixedReg(preg);
let operand = Operand::new(vreg, constraint, kind, pos);
log::debug!(
concat!(
" -> preg {:?} vreg {:?} kind {:?} ",
"pos {:?} progpoint {:?} policy {:?} operand {:?}"
"pos {:?} progpoint {:?} constraint {:?} operand {:?}"
),
preg,
vreg,
kind,
pos,
progpoint,
policy,
constraint,
operand
);
@@ -701,23 +701,23 @@ impl<'a, F: Function> Env<'a, F> {
// positions of After and Before respectively
// (see note below), and to have Any
// constraints if they were originally Reg.
let src_policy = match src.policy() {
OperandPolicy::Reg => OperandPolicy::Any,
let src_constraint = match src.constraint() {
OperandConstraint::Reg => OperandConstraint::Any,
x => x,
};
let dst_policy = match dst.policy() {
OperandPolicy::Reg => OperandPolicy::Any,
let dst_constraint = match dst.constraint() {
OperandConstraint::Reg => OperandConstraint::Any,
x => x,
};
let src = Operand::new(
src.vreg(),
src_policy,
src_constraint,
OperandKind::Use,
OperandPos::After,
);
let dst = Operand::new(
dst.vreg(),
dst_policy,
dst_constraint,
OperandKind::Def,
OperandPos::Before,
);
@@ -728,9 +728,9 @@ impl<'a, F: Function> Env<'a, F> {
format!(
" prog-move v{} ({:?}) -> v{} ({:?})",
src.vreg().vreg(),
src_policy,
src_constraint,
dst.vreg().vreg(),
dst_policy,
dst_constraint,
),
);
}
@@ -1049,7 +1049,7 @@ impl<'a, F: Function> Env<'a, F> {
let pos = ProgPoint::before(self.safepoints[safepoint_idx]);
let operand = Operand::new(
self.vreg_regs[vreg.index()],
OperandPolicy::Stack,
OperandConstraint::Stack,
OperandKind::Use,
OperandPos::Before,
);
@@ -1116,7 +1116,7 @@ impl<'a, F: Function> Env<'a, F> {
}
last_point = Some(pos);
if let OperandPolicy::FixedReg(preg) = op.policy() {
if let OperandConstraint::FixedReg(preg) = op.constraint() {
let vreg_idx = VRegIndex::new(op.vreg().vreg());
let preg_idx = PRegIndex::new(preg.index());
log::debug!(
@@ -1129,11 +1129,11 @@ impl<'a, F: Function> Env<'a, F> {
{
let orig_preg = first_preg[idx];
if orig_preg != preg_idx {
log::debug!(" -> duplicate; switching to policy Reg");
log::debug!(" -> duplicate; switching to constraint Reg");
fixups.push((pos, orig_preg, preg_idx, slot));
*op = Operand::new(
op.vreg(),
OperandPolicy::Reg,
OperandConstraint::Reg,
op.kind(),
op.pos(),
);

10
src/ion/merge.rs
View File

@@ -17,7 +17,7 @@ use super::{
Env, LiveBundleIndex, LiveRangeIndex, LiveRangeKey, Requirement, SpillSet, SpillSetIndex,
SpillSlotIndex, VRegIndex,
};
use crate::{Function, Inst, OperandPolicy, PReg};
use crate::{Function, Inst, OperandConstraint, PReg};
use smallvec::smallvec;
impl<'a, F: Function> Env<'a, F> {
@@ -269,10 +269,10 @@ impl<'a, F: Function> Env<'a, F> {
let mut stack = false;
for entry in &self.bundles[bundle.index()].ranges {
for u in &self.ranges[entry.index.index()].uses {
if let OperandPolicy::FixedReg(_) = u.operand.policy() {
if let OperandConstraint::FixedReg(_) = u.operand.constraint() {
fixed = true;
}
if let OperandPolicy::Stack = u.operand.policy() {
if let OperandConstraint::Stack = u.operand.constraint() {
stack = true;
}
if fixed && stack {
@@ -306,10 +306,10 @@ impl<'a, F: Function> Env<'a, F> {
for inst in 0..self.func.insts() {
let inst = Inst::new(inst);
// Attempt to merge Reuse-policy operand outputs with the
// Attempt to merge Reuse-constraint operand outputs with the
// corresponding inputs.
for op in self.func.inst_operands(inst) {
if let OperandPolicy::Reuse(reuse_idx) = op.policy() {
if let OperandConstraint::Reuse(reuse_idx) = op.constraint() {
let src_vreg = op.vreg();
let dst_vreg = self.func.inst_operands(inst)[reuse_idx].vreg();
if self.vregs[src_vreg.vreg()].is_pinned

6
src/ion/moves.rs
View File

@@ -20,7 +20,7 @@ use super::{
use crate::moves::ParallelMoves;
use crate::{
Allocation, Block, Edit, Function, Inst, InstPosition, OperandKind, OperandPolicy, OperandPos,
Allocation, Block, Edit, Function, Inst, InstPosition, OperandKind, OperandConstraint, OperandPos,
ProgPoint, RegClass, VReg,
};
use log::debug;
@@ -489,7 +489,7 @@ impl<'a, F: Function> Env<'a, F> {
if slot != SLOT_NONE {
self.set_alloc(inst, slot as usize, alloc);
}
if let OperandPolicy::Reuse(_) = operand.policy() {
if let OperandConstraint::Reuse(_) = operand.constraint() {
reuse_input_insts.push(inst);
}
}
@@ -755,7 +755,7 @@ impl<'a, F: Function> Env<'a, F> {
let mut input_reused: SmallVec<[usize; 4]> = smallvec![];
for output_idx in 0..self.func.inst_operands(inst).len() {
let operand = self.func.inst_operands(inst)[output_idx];
if let OperandPolicy::Reuse(input_idx) = operand.policy() {
if let OperandConstraint::Reuse(input_idx) = operand.constraint() {
debug_assert!(!input_reused.contains(&input_idx));
debug_assert_eq!(operand.pos(), OperandPos::After);
input_reused.push(input_idx);

16
src/ion/process.rs
View File

@@ -14,12 +14,12 @@
//! Main allocation loop that processes bundles.
use super::{
spill_weight_from_policy, CodeRange, Env, LiveBundleIndex, LiveBundleVec, LiveRangeFlag,
spill_weight_from_constraint, CodeRange, Env, LiveBundleIndex, LiveBundleVec, LiveRangeFlag,
LiveRangeIndex, LiveRangeKey, LiveRangeList, LiveRangeListEntry, PRegIndex, RegTraversalIter,
Requirement, UseList,
};
use crate::{
Allocation, Function, Inst, InstPosition, OperandKind, OperandPolicy, PReg, ProgPoint,
Allocation, Function, Inst, InstPosition, OperandKind, OperandConstraint, PReg, ProgPoint,
RegAllocError,
};
use fxhash::FxHashSet;
@@ -273,11 +273,11 @@ impl<'a, F: Function> Env<'a, F> {
} else {
for u in &first_range_data.uses {
log::debug!(" -> use: {:?}", u);
if let OperandPolicy::FixedReg(_) = u.operand.policy() {
if let OperandConstraint::FixedReg(_) = u.operand.constraint() {
log::debug!(" -> fixed use at {:?}: {:?}", u.pos, u.operand);
fixed = true;
}
if let OperandPolicy::Stack = u.operand.policy() {
if let OperandConstraint::Stack = u.operand.constraint() {
log::debug!(" -> stack use at {:?}: {:?}", u.pos, u.operand);
stack = true;
}
@@ -886,8 +886,8 @@ impl<'a, F: Function> Env<'a, F> {
let loop_depth = self.cfginfo.approx_loop_depth
[self.cfginfo.insn_block[first_conflict_point.inst().index()].index()];
let move_cost = spill_weight_from_policy(
OperandPolicy::Reg,
let move_cost = spill_weight_from_constraint(
OperandConstraint::Reg,
loop_depth as usize,
/* is_def = */ true,
);
@@ -905,8 +905,8 @@ impl<'a, F: Function> Env<'a, F> {
let loop_depth = self.cfginfo.approx_loop_depth
[self.cfginfo.insn_block[point.inst().index()].index()];
let move_cost = spill_weight_from_policy(
OperandPolicy::Reg,
let move_cost = spill_weight_from_constraint(
OperandConstraint::Reg,
loop_depth as usize,
/* is_def = */ true,
);

10
src/ion/requirement.rs
View File

@@ -1,7 +1,7 @@
//! Requirements computation.
use super::{Env, LiveBundleIndex};
use crate::{Function, Operand, OperandPolicy, PReg, RegClass};
use crate::{Function, Operand, OperandConstraint, PReg, RegClass};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Requirement {
@@ -64,10 +64,10 @@ impl Requirement {
}
#[inline(always)]
pub fn from_operand(op: Operand) -> Requirement {
match op.policy() {
OperandPolicy::FixedReg(preg) => Requirement::Fixed(preg),
OperandPolicy::Reg | OperandPolicy::Reuse(_) => Requirement::Register(op.class()),
OperandPolicy::Stack => Requirement::Stack(op.class()),
match op.constraint() {
OperandConstraint::FixedReg(preg) => Requirement::Fixed(preg),
OperandConstraint::Reg | OperandConstraint::Reuse(_) => Requirement::Register(op.class()),
OperandConstraint::Stack => Requirement::Stack(op.class()),
_ => Requirement::Any(op.class()),
}
}

66
src/lib.rs
View File

@@ -210,34 +210,34 @@ impl std::fmt::Display for SpillSlot {
}
/// An `Operand` encodes everything about a mention of a register in
/// an instruction: virtual register number, and any constraint/policy
/// that applies to the register at this program point.
/// an instruction: virtual register number, and any constraint that
/// applies to the register at this program point.
///
/// An Operand may be a use or def (this corresponds to `LUse` and
/// `LAllocation` in Ion).
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Operand {
/// Bit-pack into 32 bits. Note that `policy` overlaps with `kind`
/// Bit-pack into 32 bits. Note that `constraint` overlaps with `kind`
/// in `Allocation` and we use mutually disjoint tag-value ranges
/// so that clients, if they wish, can track just one `u32` per
/// register slot and edit it in-place after allocation.
///
/// policy:3 kind:2 pos:1 class:1 preg:5 vreg:20
/// constraint:3 kind:2 pos:1 class:1 preg:5 vreg:20
bits: u32,
}
impl Operand {
#[inline(always)]
pub fn new(vreg: VReg, policy: OperandPolicy, kind: OperandKind, pos: OperandPos) -> Self {
let (preg_field, policy_field): (u32, u32) = match policy {
OperandPolicy::Any => (0, 0),
OperandPolicy::Reg => (0, 1),
OperandPolicy::Stack => (0, 2),
OperandPolicy::FixedReg(preg) => {
pub fn new(vreg: VReg, constraint: OperandConstraint, kind: OperandKind, pos: OperandPos) -> Self {
let (preg_field, constraint_field): (u32, u32) = match constraint {
OperandConstraint::Any => (0, 0),
OperandConstraint::Reg => (0, 1),
OperandConstraint::Stack => (0, 2),
OperandConstraint::FixedReg(preg) => {
assert_eq!(preg.class(), vreg.class());
(preg.hw_enc() as u32, 3)
}
OperandPolicy::Reuse(which) => {
OperandConstraint::Reuse(which) => {
assert!(which <= PReg::MAX);
(which as u32, 4)
}
@@ -251,7 +251,7 @@ impl Operand {
| (class_field << 25)
| (pos_field << 26)
| (kind_field << 27)
| (policy_field << 29),
| (constraint_field << 29),
}
}
@@ -259,7 +259,7 @@ impl Operand {
pub fn reg_use(vreg: VReg) -> Self {
Operand::new(
vreg,
OperandPolicy::Reg,
OperandConstraint::Reg,
OperandKind::Use,
OperandPos::Before,
)
@@ -268,7 +268,7 @@ impl Operand {
pub fn reg_use_at_end(vreg: VReg) -> Self {
Operand::new(
vreg,
OperandPolicy::Reg,
OperandConstraint::Reg,
OperandKind::Use,
OperandPos::After,
)
@@ -277,7 +277,7 @@ impl Operand {
pub fn reg_def(vreg: VReg) -> Self {
Operand::new(
vreg,
OperandPolicy::Reg,
OperandConstraint::Reg,
OperandKind::Def,
OperandPos::After,
)
@@ -286,7 +286,7 @@ impl Operand {
pub fn reg_def_at_start(vreg: VReg) -> Self {
Operand::new(
vreg,
OperandPolicy::Reg,
OperandConstraint::Reg,
OperandKind::Def,
OperandPos::Before,
)
@@ -295,7 +295,7 @@ impl Operand {
pub fn reg_temp(vreg: VReg) -> Self {
Operand::new(
vreg,
OperandPolicy::Reg,
OperandConstraint::Reg,
OperandKind::Def,
OperandPos::Before,
)
@@ -304,7 +304,7 @@ impl Operand {
pub fn reg_reuse_def(vreg: VReg, idx: usize) -> Self {
Operand::new(
vreg,
OperandPolicy::Reuse(idx),
OperandConstraint::Reuse(idx),
OperandKind::Def,
OperandPos::After,
)
@@ -313,7 +313,7 @@ impl Operand {
pub fn reg_fixed_use(vreg: VReg, preg: PReg) -> Self {
Operand::new(
vreg,
OperandPolicy::FixedReg(preg),
OperandConstraint::FixedReg(preg),
OperandKind::Use,
OperandPos::Before,
)
@@ -322,7 +322,7 @@ impl Operand {
pub fn reg_fixed_def(vreg: VReg, preg: PReg) -> Self {
Operand::new(
vreg,
OperandPolicy::FixedReg(preg),
OperandConstraint::FixedReg(preg),
OperandKind::Def,
OperandPos::After,
)
@@ -366,15 +366,15 @@ impl Operand {
}
#[inline(always)]
pub fn policy(self) -> OperandPolicy {
let policy_field = (self.bits >> 29) & 7;
pub fn constraint(self) -> OperandConstraint {
let constraint_field = (self.bits >> 29) & 7;
let preg_field = ((self.bits >> 20) as usize) & PReg::MAX;
match policy_field {
0 => OperandPolicy::Any,
1 => OperandPolicy::Reg,
2 => OperandPolicy::Stack,
3 => OperandPolicy::FixedReg(PReg::new(preg_field, self.class())),
4 => OperandPolicy::Reuse(preg_field),
match constraint_field {
0 => OperandConstraint::Any,
1 => OperandConstraint::Reg,
2 => OperandConstraint::Stack,
3 => OperandConstraint::FixedReg(PReg::new(preg_field, self.class())),
4 => OperandConstraint::Reuse(preg_field),
_ => unreachable!(),
}
}
@@ -409,13 +409,13 @@ impl std::fmt::Display for Operand {
RegClass::Int => "i",
RegClass::Float => "f",
},
self.policy()
self.constraint()
)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OperandPolicy {
pub enum OperandConstraint {
/// Any location is fine (register or stack slot).
Any,
/// Operand must be in a register. Register is read-only for Uses.
@@ -428,7 +428,7 @@ pub enum OperandPolicy {
Reuse(usize),
}
impl std::fmt::Display for OperandPolicy {
impl std::fmt::Display for OperandConstraint {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::Any => write!(f, "any"),
@@ -458,7 +458,7 @@ pub enum OperandPos {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Allocation {
/// Bit-pack in 32 bits. Note that `kind` overlaps with the
/// `policy` field in `Operand`, and we are careful to use
/// `constraint` field in `Operand`, and we are careful to use
/// disjoint ranges of values in this field for each type. We also
/// leave the def-or-use bit (`kind` for `Operand`) unused here so
/// that we can use it below in `OperandOrAllocation` to record
@@ -570,7 +570,7 @@ impl Allocation {
}
// N.B.: These values must be *disjoint* with the values used to
// encode `OperandPolicy`, because they share a 3-bit field.
// encode `OperandConstraint`, because they share a 3-bit field.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum AllocationKind {