Struct RegSet 

pub struct RegSet(/* private fields */);

A set of physical registers: 128 bits, one per PReg index.

Used for class membership, allocatable sets, callee- and caller-saved sets, and per-instruction clobbers. Every operation is a few word operations; iteration yields registers in index order.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, RCX, RDX};

let set = RegSet::EMPTY.with(RAX).with(RDX);
assert!(set.contains(RDX));
assert!(!set.contains(RCX));
assert_eq!(set.iter().collect::<Vec<_>>(), [RAX, RDX]);
assert_eq!(set.len(), 2);

Implementations

impl RegSet

pub const EMPTY: RegSet

The empty set.

pub const fn of(regs: &[PReg]) -> RegSet

The set holding exactly the registers in regs.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{R11, RCX};

let set = RegSet::of(&[RCX, R11]);
assert!(set.contains(R11));

pub const fn with(self, reg: PReg) -> RegSet

The set with reg added.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::RBX;

assert!(RegSet::EMPTY.with(RBX).contains(RBX));

pub const fn without(self, reg: PReg) -> RegSet

The set with reg removed.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::RBX;

assert!(RegSet::of(&[RBX]).without(RBX).is_empty());

pub const fn contains(self, reg: PReg) -> bool

Whether reg is in the set.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, RBX};

assert!(RegSet::of(&[RAX]).contains(RAX));
assert!(!RegSet::of(&[RAX]).contains(RBX));

pub const fn union(self, other: RegSet) -> RegSet

The registers in either set.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, RBX};

assert_eq!(RegSet::of(&[RAX]).union(RegSet::of(&[RBX])).len(), 2);

pub const fn intersect(self, other: RegSet) -> RegSet

The registers in both sets.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, RBX};

let a = RegSet::of(&[RAX, RBX]);
assert_eq!(a.intersect(RegSet::of(&[RBX])), RegSet::of(&[RBX]));

pub const fn difference(self, other: RegSet) -> RegSet

The registers in self but not in other.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, RBX};

let a = RegSet::of(&[RAX, RBX]);
assert_eq!(a.difference(RegSet::of(&[RAX])), RegSet::of(&[RBX]));

pub const fn is_empty(self) -> bool

Whether the set is empty.

Examples

use backend_lang::RegSet;

assert!(RegSet::EMPTY.is_empty());

pub const fn len(self) -> usize

The number of registers in the set.

Examples

use backend_lang::x86_64::{self, GPR};

assert_eq!(x86_64::TARGET.class(GPR).regs().len(), 16);

pub const fn first(self) -> Option<PReg>

The lowest-numbered register in the set.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RCX, R9};

assert_eq!(RegSet::of(&[R9, RCX]).first(), Some(RCX));
assert_eq!(RegSet::EMPTY.first(), None);

pub fn iter(self) -> RegSetIter

The registers in the set, in index order.

Examples

use backend_lang::RegSet;
use backend_lang::x86_64::{RAX, R15};

let v: Vec<_> = RegSet::of(&[R15, RAX]).iter().collect();
assert_eq!(v, [RAX, R15]);

Trait Implementations

impl Clone for RegSet

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RegSet

impl Debug for RegSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RegSet

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RegSet

impl FromIterator<PReg> for RegSet

fn from_iter<I: IntoIterator<Item = PReg>>(iter: I) -> RegSet

Creates a value from an iterator.

impl Hash for RegSet

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RegSet

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RegSet