regalloc2

https://docs.rs/regalloc2/latest/regalloc2/
Admin
regalloc2 is a Rust register allocator that performs optimal register allocation with support for...
Tokens:42,357
Snippets:362
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get Instruction from ProgPoint

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Retrieves the instruction associated with this ProgPoint.

```rust
pub fn inst(self) -> Inst
```

--------------------------------

### Get Next ProgPoint

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Calculates the next program point. For an 'After' position, it moves to the 'Before' of the next instruction. For a 'Before' position, it moves to the 'After' of the same instruction.

```rust
pub fn next(self) -> ProgPoint
```

--------------------------------

### Get Position from ProgPoint

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Retrieves the position (Before or After) relative to the instruction for this ProgPoint.

```rust
pub fn pos(self) -> InstPosition
```

--------------------------------

### Get Previous ProgPoint

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Calculates the previous program point, which is the inverse operation of `.next()`.

```rust
pub fn prev(self) -> ProgPoint
```

--------------------------------

### Create a fixed register definition Operand at the start

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Operand.html

Similar to `reg_fixed_def`, but specifies the definition occurs at `OperandPos::Early`.

```rust
pub fn reg_fixed_def_at_start(vreg: VReg, preg: PReg) -> Self
```

--------------------------------

### Create a register definition Operand at the start

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Operand.html

Creates an Operand for a VReg definition that occurs early at the 'before' point, ensuring it does not conflict with any instruction inputs. The register allocator guarantees this operand remains live throughout the instruction.

```rust
pub fn reg_def_at_start(vreg: VReg) -> Self
```

--------------------------------

### GET /allow_multiple_vreg_defs

Source: https://docs.rs/regalloc2/latest/regalloc2/trait.Function.html

Checks if the allocator allows a single instruction to define a vreg multiple times.

```APIDOC
## GET /allow_multiple_vreg_defs

### Description
Returns whether the allocator permits multiple definitions of the same vreg within a single instruction. If enabled, all definitions are treated as having the same allocation.

### Method
GET

### Endpoint
/allow_multiple_vreg_defs

### Response
#### Success Response (200)
- **result** (bool) - True if multiple vreg definitions are allowed.
```

--------------------------------

### Get Next Block

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Returns the next Block in sequence. This assumes a linear ordering or a specific graph structure.

```rust
pub fn next(self) -> Block

```

--------------------------------

### Get Previous Block

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Returns the previous Block in sequence. This assumes a linear ordering or a specific graph structure.

```rust
pub fn prev(self) -> Block

```

--------------------------------

### Function run_with_ctx

Source: https://docs.rs/regalloc2/latest/regalloc2/fn.run_with_ctx.html

Runs the allocator with a reusable context. The return value points to `ctx.output` which can be alternatively `std::mem::take`n.

```APIDOC
## Function run_with_ctx

### Description
Run the allocator with reusable context. Return value points to `ctx.output` that can be alternatively `std::mem::take`n.

### Signature
```rust
pub fn run_with_ctx<'a, F: Function>(
    func: &F,
    env: &MachineEnv,
    options: &RegallocOptions,
    ctx: &'a mut Ctx,
) -> Result<&'a Output, RegAllocError>
```

### Parameters

*   **func** (*&F*) - The function to allocate registers for.
*   **env** (*&MachineEnv*) - The machine environment.
*   **options** (*&RegallocOptions*) - Allocation options.
*   **ctx** (*&'a mut Ctx*) - The mutable context for allocation.

### Return Value

*   **Result<&'a Output, RegAllocError>** - A Result containing a reference to the output or a RegAllocError.
```

--------------------------------

### GET /multi_spillslot_named_by_last_slot

Source: https://docs.rs/regalloc2/latest/regalloc2/trait.Function.html

Determines the naming convention for multi-slot spillslots.

```APIDOC
## GET /multi_spillslot_named_by_last_slot

### Description
Checks whether a multi-slot spillslot should be identified by its first or last slot number, typically depending on stack growth direction.

### Method
GET

### Endpoint
/multi_spillslot_named_by_last_slot

### Response
#### Success Response (200)
- **result** (bool) - True if the last slot is used for naming, false otherwise.
```

--------------------------------

### fn try_into

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.MachineEnv.html

Documentation for the try_into conversion method.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from the current type to the target type U.

### Parameters
- **self** (T) - Required - The instance to be converted.

### Response
- **Result<U, <U as TryFrom<T>>::Error>** - Returns the converted type U or an error if the conversion fails.
```

--------------------------------

### Create ProgPoint with Instruction and Position

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Creates a new ProgPoint at a specific instruction and position (Before or After).

```rust
pub fn new(inst: Inst, pos: InstPosition) -> Self
```

--------------------------------

### ProgPoint Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Methods for creating, navigating, and converting ProgPoint instances.

```APIDOC
## ProgPoint Methods

### Description
Methods to manage program points, which represent a location either before or after a specific instruction.

### Methods
- **new(inst: Inst, pos: InstPosition) -> Self**: Create a new ProgPoint before or after the given instruction.
- **before(inst: Inst) -> Self**: Create a new ProgPoint before the given instruction.
- **after(inst: Inst) -> Self**: Create a new ProgPoint after the given instruction.
- **inst() -> Inst**: Get the instruction associated with this ProgPoint.
- **pos() -> InstPosition**: Get the position (Before or After) relative to the instruction.
- **next() -> ProgPoint**: Get the next program point.
- **prev() -> ProgPoint**: Get the previous program point.
- **to_index() -> u32**: Convert to a raw 32-bit encoding.
- **from_index(index: u32) -> Self**: Construct from a raw 32-bit encoding.
- **invalid() -> Self**: Create an invalid ProgPoint.
```

--------------------------------

### GET /debug_value_labels

Source: https://docs.rs/regalloc2/latest/regalloc2/trait.Function.html

Retrieves the VRegs and associated ranges for generating value-location metadata for debugging.

```APIDOC
## GET /debug_value_labels

### Description
Returns a slice of tuples containing VRegs and instruction ranges for which value-location metadata should be generated. The ranges represent program points just before the specified instructions.

### Method
GET

### Endpoint
/debug_value_labels

### Response
#### Success Response (200)
- **result** ([(VReg, Inst, Inst, u32)]) - A sorted slice of tuples containing (vreg, inclusive_start, exclusive_end, label).
```

--------------------------------

### Prepare Checker Instructions

Source: https://docs.rs/regalloc2/latest/regalloc2/checker/struct.Checker.html

Builds the list of checker instructions based on the provided function and allocation results. This method should be called before running the checker.

```rust
pub fn prepare(&mut self, out: &Output)
```

--------------------------------

### Min/Max and Aggregation Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.OutputIter.html

Methods for finding extreme values and calculating sums or products.

```APIDOC
## max_by_key

### Description
Returns the element that gives the maximum value from the specified function.

## max_by

### Description
Returns the element that gives the maximum value with respect to the specified comparison function.

## min_by_key

### Description
Returns the element that gives the minimum value from the specified function.

## min_by

### Description
Returns the element that gives the minimum value with respect to the specified comparison function.

## sum

### Description
Sums the elements of an iterator.

## product

### Description
Iterates over the entire iterator, multiplying all the elements.
```

--------------------------------

### Get Type ID

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Retrieves the `TypeId` of the Block type. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId

```

--------------------------------

### Create ProgPoint After Instruction

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Creates a new ProgPoint positioned after the given instruction.

```rust
pub fn after(inst: Inst) -> Self
```

--------------------------------

### Create New Checker

Source: https://docs.rs/regalloc2/latest/regalloc2/checker/struct.Checker.html

Creates a new `Checker` instance for a given function and machine environment. It initializes CFG info immediately. The client must add abstract instructions before running the checker.

```rust
pub fn new(f: &'a F, machine_env: &'a MachineEnv) -> Checker<'a, F>
```

--------------------------------

### Get Invalid ProgPoint

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Returns an invalid ProgPoint. This might be used for error states or uninitialized values.

```rust
pub fn invalid() -> Self
```

--------------------------------

### TryFrom and TryInto Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.PRegSetIter.html

Implementations for `TryFrom` and `TryInto` traits, enabling fallible conversions.

```APIDOC
## `impl<T, U> TryFrom<U> for T where U: Into<T>`

### `type Error = Infallible`

The type returned in the event of a conversion error.

### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

Performs the conversion.

## `impl<T, U> TryInto<U> for T where U: TryFrom<T>`

### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

Performs the conversion.
```

--------------------------------

### Get Minimum of Two Blocks

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Returns the minimum of two Blocks. This is a convenience method from the `Ord` trait.

```rust
fn min(self, other: Self) -> Self
where Self: Sized,

```

--------------------------------

### Create ProgPoint Before Instruction

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Creates a new ProgPoint positioned before the given instruction.

```rust
pub fn before(inst: Inst) -> Self
```

--------------------------------

### Get Maximum of Two Blocks

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Returns the maximum of two Blocks. This is a convenience method from the `Ord` trait.

```rust
fn max(self, other: Self) -> Self
where Self: Sized,

```

--------------------------------

### From Implementation for MachineEnv

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.MachineEnv.html

Provides a conversion from a reference to MachineEnv into a PRegSet.

```APIDOC
### impl From<&MachineEnv> for PRegSet

#### fn from(env: &MachineEnv) -> Self
Converts to this type from the input type.
```

--------------------------------

### Get Raw u32 Value

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Retrieves the underlying u32 representation of the Block. Use this for low-level operations or serialization.

```rust
pub fn raw_u32(self) -> u32

```

--------------------------------

### run

Source: https://docs.rs/regalloc2/latest/regalloc2/index.html

Executes the register allocation process on a provided function representation.

```APIDOC
## run

### Description
Run the register allocator on the provided function.

### Method
Function

### Parameters
- **func** (Function) - Required - The function representation implementing the Function trait.
- **opts** (RegallocOptions) - Required - Configuration options for the allocator.

### Response
- **Output** - The result of the register allocation, containing allocations and edits.
```

--------------------------------

### to_owned and clone_into

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.InstPosition.html

These methods handle creating owned data from borrowed data and replacing owned data with borrowed data, typically through cloning.

```APIDOC
## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning.

### Method
N/A (Method on a trait)

### Endpoint
N/A

## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
N/A (Method on a trait)

### Endpoint
N/A
```

--------------------------------

### Get Minimum of Two ProgPoints

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Implements the `min` method for the `Ord` trait, returning the lesser of two ProgPoint values.

```rust
fn min(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### Allocation Struct Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Allocation.html

Methods for creating, inspecting, and converting Allocation instances.

```APIDOC
## Allocation Methods

### Description
Methods to interact with the Allocation struct, which represents the end result of register allocation for an operand.

### Methods
- **none() -> Allocation**: Get the "none" allocation.
- **reg(preg: PReg) -> Allocation**: Create an allocation into a register.
- **stack(slot: SpillSlot) -> Allocation**: Create an allocation into a spillslot.
- **kind(self) -> AllocationKind**: Get the allocation's kind (none, register, or stack).
- **is_none(self) -> bool**: Check if the allocation is "none".
- **is_some(self) -> bool**: Check if the allocation is not "none".
- **is_reg(self) -> bool**: Check if the allocation is a register.
- **is_stack(self) -> bool**: Check if the allocation is on the stack.
- **index(self) -> usize**: Get the index of the spillslot or register.
- **as_reg(self) -> Option<PReg>**: Get the allocation as a physical register.
- **as_stack(self) -> Option<SpillSlot>**: Get the allocation as a spillslot.
- **bits(self) -> u32**: Get the raw bits for the packed encoding.
- **from_bits(bits: u32) -> Self**: Construct an allocation from its packed encoding.
```

--------------------------------

### Get Maximum of Two ProgPoints

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Implements the `max` method for the `Ord` trait, returning the greater of two ProgPoint values.

```rust
fn max(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### Inst Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Inst.html

Provides methods for creating, manipulating, and querying the state of an Inst.

```APIDOC
## impl Inst

### Methods
* `pub fn new(i: usize) -> Self` - Creates a new Inst from a usize index.
* `pub fn index(self) -> usize` - Returns the usize index of the Inst.
* `pub fn invalid() -> Self` - Creates an invalid Inst.
* `pub fn is_invalid(self) -> bool` - Checks if the Inst is invalid.
* `pub fn is_valid(self) -> bool` - Checks if the Inst is valid.
* `pub fn next(self) -> Inst` - Returns the next Inst.
* `pub fn prev(self) -> Inst` - Returns the previous Inst.
* `pub fn raw_u32(self) -> u32` - Returns the raw u32 value of the Inst.
```

--------------------------------

### Get Block Index

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Retrieves the usize index of the Block. This method is useful for converting the Block back to its underlying index representation.

```rust
pub fn index(self) -> usize

```

--------------------------------

### Output Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Output.html

Available implementations for the Output struct, including methods and trait implementations.

```APIDOC
## Implementations

### impl Output

#### pub fn inst_allocs(&self, inst: Inst) -> &[Allocation]
Get the allocations assigned to a given instruction.

#### pub fn block_insts_and_edits(&self, func: &impl Function, block: Block) -> OutputIter<'_>
Returns an iterator over the instructions and edits in a block, in order.

### impl Clone for Output

#### fn clone(&self) -> Output
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### impl Debug for Output

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

### impl Default for Output

#### fn default() -> Output
Returns the “default value” for a type.

### Auto Trait Implementations
- Freeze
- RefUnwindSafe
- Send
- Sync
- Unpin
- UnsafeUnpin
- UnwindSafe

### Blanket Implementations
- impl<T> Any for T
- impl<T> Borrow<T> for T
- impl<T> BorrowMut<T> for T
- impl<T> CloneToUninit for T
- impl<T> From<T> for T
- impl<T, U> Into<U> for T
- impl<T> ToOwned for T
- impl<T, U> TryFrom<U> for T
- impl<T, U> TryInto<U> for T
```

--------------------------------

### Create a New Block

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Creates a new Block instance from a usize index. Ensure the index is within valid bounds if necessary.

```rust
pub fn new(i: usize) -> Self

```

--------------------------------

### Iterator enumerate() Method

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.SetBitsIter.html

Creates a new iterator that yields pairs of (index, element), where 'index' is the iteration count starting from 0. This is useful when the position of an element is needed.

```rust
fn enumerate(self) -> Enumerate<Self>
where Self: Sized,
```

--------------------------------

### Clone To Uninit Block (Nightly)

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Block.html

Nightly-only experimental API to perform copy-assignment from `self` to an uninitialized memory location `dest`.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)

```

--------------------------------

### run_with_ctx

Source: https://docs.rs/regalloc2/latest/regalloc2/index.html

Executes the register allocation process using a reusable context to improve performance.

```APIDOC
## run_with_ctx

### Description
Run the allocator with a reusable context object.

### Method
Function

### Parameters
- **ctx** (Ctx) - Required - A reusable context object for the allocator.
- **func** (Function) - Required - The function representation implementing the Function trait.
- **opts** (RegallocOptions) - Required - Configuration options for the allocator.

### Response
- **Output** - The result of the register allocation.
```

--------------------------------

### Run the register allocator

Source: https://docs.rs/regalloc2/latest/regalloc2/fn.run.html

The run function executes the register allocation process based on the provided function, machine environment, and options.

```rust
pub fn run<F: Function>(
    func: &F,
    env: &MachineEnv,
    options: &RegallocOptions,
) -> Result<Output, RegAllocError>
```

--------------------------------

### InstRange Struct

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.InstRange.html

Documentation for the InstRange struct, including its constructor and methods.

```APIDOC
## Struct InstRange

### Summary
```rust
pub struct InstRange(/* private fields */);
```

### Implementations

#### `impl InstRange`

- `pub fn new(from: Inst, to: Inst) -> Self`
- `pub fn first(self) -> Inst`
- `pub fn last(self) -> Inst`
- `pub fn rest(self) -> InstRange`
- `pub fn len(self) -> usize`
- `pub fn iter(self) -> impl DoubleEndedIterator<Item = Inst>`
```

--------------------------------

### Run register allocation with reusable context

Source: https://docs.rs/regalloc2/latest/regalloc2/fn.run_with_ctx.html

Executes the allocator using a provided context. The returned output reference points to the context's internal output, which can be retrieved using std::mem::take.

```rust
pub fn run_with_ctx<'a, F: Function>(
    func: &F,
    env: &MachineEnv,
    options: &RegallocOptions,
    ctx: &'a mut Ctx,
) -> Result<&'a Output, RegAllocError>
```

--------------------------------

### IndexSet Trait Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.IndexSet.html

Documentation for the standard traits implemented by IndexSet.

```APIDOC
### impl Clone for IndexSet

#### fn clone(&self) -> IndexSet
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### impl Debug for IndexSet

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

### Auto Trait Implementations

- !Freeze for IndexSet
- !RefUnwindSafe for IndexSet
- Send for IndexSet
- !Sync for IndexSet
- Unpin for IndexSet
- UnsafeUnpin for IndexSet
- UnwindSafe for IndexSet

### Blanket Implementations

- impl<T> Any for T
- impl<T> Borrow<T> for T
- impl<T> BorrowMut<T> for T
- impl<T> CloneToUninit for T (Nightly-only experimental)
- impl<T> From<T> for T
- impl<T, U> Into<U> for T
- impl<T> ToOwned for T
- impl<T, U> TryFrom<U> for T
- impl<T, U> TryInto<U> for T
```

--------------------------------

### PReg Trait Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.PReg.html

Overview of the core trait implementations for the PReg type.

```APIDOC
## PReg Trait Implementations

### Description
The PReg type implements several standard marker and safety traits to ensure compatibility with concurrent and safe Rust patterns.

### Implemented Traits
- **Freeze**
- **RefUnwindSafe**
- **Send**
- **Sync**
- **Unpin**
- **UnsafeUnpin**
- **UnwindSafe**
```

--------------------------------

### Construct ProgPoint from Index

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Constructs a ProgPoint from its raw 32-bit unsigned integer encoding.

```rust
pub fn from_index(index: u32) -> Self
```

--------------------------------

### Operand Creation

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Operand.html

Methods for creating Operand instances with different constraints.

```APIDOC
## Operand Creation

### `any_def(vreg: VReg) -> Self`

Create an `Operand` that designates a def of a vreg and places no constraints on its location (i.e., it can be allocated into either a register or on the stack).

### `fixed_nonallocatable(preg: PReg) -> Self`

Create an `Operand` that always results in an assignment to the given fixed `preg`, _without_ tracking liveranges in that `preg`. Must only be used for non-allocatable registers.

### `from_bits(bits: u64) -> Self`

Construct an `Operand` from the raw 64-bit encoding returned from `bits()`.
```

--------------------------------

### Iterator Implementations for SetBitsIter

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.SetBitsIter.html

This section details the implementations of the Iterator trait for the SetBitsIter struct, including methods for advancing the iterator, retrieving elements, and various adapter methods.

```APIDOC
## Trait Implementations

### impl Iterator for SetBitsIter

#### type Item = usize

The type of the elements being iterated over. In this case, it yields `usize` values representing bit indices.

#### fn next(&mut self) -> Option<usize>

Advances the iterator and returns the next value (the index of the next set bit) as an `Option<usize>`. Returns `None` if there are no more set bits.

#### fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

*Nightly-only experimental API.*
Advances the iterator and returns an array containing the next `N` values. This method is part of the `iter_next_chunk` feature.

#### fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator, providing a lower bound and an optional upper bound for the number of elements yet to be yielded.

#### fn count(self) -> usize

Consumes the iterator, counting the total number of elements it yields and returning that count as a `usize`.

#### fn last(self) -> Option<Self::Item>

Consumes the iterator and returns the last element yielded. Returns `None` if the iterator is empty.

#### fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

*Nightly-only experimental API.*
Advances the iterator by `n` elements. Returns `Ok(())` if successful, or `Err(NonZero<usize>)` indicating the number of elements by which the iterator could not be advanced.

#### fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the `n`th element of the iterator (0-indexed). Consumes elements up to and including the `n`th element. Returns `None` if `n` is out of bounds.

#### fn step_by(self, step: usize) -> StepBy<Self>

Creates a new iterator that yields elements from the original iterator, but only every `step` elements. The first element is always yielded.

#### fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

Creates a new iterator that yields elements from this iterator first, followed by elements from the `other` iterator. The `other` must be convertible into an iterator of the same item type.

#### fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIterator>

Creates a new iterator that yields pairs of elements, taking one element from this iterator and one from the `other` iterator at each step. The iteration stops when either iterator is exhausted.

#### fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

*Nightly-only experimental API.*
Creates a new iterator that inserts a `separator` value between adjacent elements of the original iterator. The `separator` is cloned for each insertion.

#### fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

*Nightly-only experimental API.*
Creates a new iterator that inserts elements generated by the `separator` closure between adjacent elements of the original iterator.

#### fn map<B, F>(self, f: F) -> Map<Self, F>

Creates a new iterator that applies the closure `f` to each element yielded by the original iterator, yielding the results of the closure.

#### fn for_each<F>(self, f: F)

Applies the closure `f` to each element yielded by the iterator. This method consumes the iterator.

#### fn filter<P>(self, predicate: P) -> Filter<Self, P>

Creates a new iterator that yields only the elements for which the `predicate` closure returns `true`.

#### fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

Creates a new iterator that applies the closure `f` to each element. If the closure returns `Some(value)`, that `value` is yielded. If it returns `None`, the element is skipped.

#### fn enumerate(self) -> Enumerate<Self>

Creates a new iterator that yields pairs of `(index, element)`, where `index` is the iteration count (starting from 0).

#### fn peekable(self) -> Peekable<Self>

Creates a new iterator that allows peeking at the next element without consuming it, using `peek()` and `peek_mut()` methods.

#### fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

Creates a new iterator that skips elements as long as the `predicate` closure returns `true`. Once the predicate returns `false`, all subsequent elements are yielded.

#### fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

Creates a new iterator that yields elements as long as the `predicate` closure returns `true`. Once the predicate returns `false`, the iteration stops.

#### fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

Creates a new iterator that yields elements based on a predicate and also maps them. The iterator stops when the predicate returns `None`.

#### fn skip(self, n: usize) -> Skip<Self>

Creates a new iterator that skips the first `n` elements from the original iterator.

#### fn take(self, n: usize) -> Take<Self>

Creates a new iterator that yields at most the first `n` elements from the original iterator. If the original iterator yields fewer than `n` elements, all of them are yielded.
```

--------------------------------

### equivalent

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.SpillSlot.html

Checks if a value is equivalent to a given key.

```APIDOC
## fn equivalent(&self, key: &K) -> bool

### Description
Checks if this value is equivalent to the given key.

### Method
N/A (Method within a trait implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (bool)
- **true**: if the value is equivalent to the key.
- **false**: if the value is not equivalent to the key.

#### Response Example
N/A
```

--------------------------------

### Implement CloneToUninit for T

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.Algorithm.html

An experimental nightly-only API for cloning a value into uninitialized memory. Requires the type T to implement Clone.

```rust
impl<T> CloneToUninit for T
where T: Clone,
```

--------------------------------

### Comparison Methods for PRegSet

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.PRegSet.html

Methods for comparing PRegSet instances using partial ordering and standard comparison operators.

```APIDOC
## fn partial_cmp(&self, other: &PRegSet) -> Option<Ordering>

### Description
Returns an ordering between self and other values if one exists.

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

### Description
Tests less than (for self and other) and is used by the < operator.

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

### Description
Tests less than or equal to (for self and other) and is used by the <= operator.

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

### Description
Tests greater than (for self and other) and is used by the > operator.

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

### Description
Tests greater than or equal to (for self and other) and is used by the >= operator.
```

--------------------------------

### ProgPoint StructuralPartialEq Implementation

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Indicates that ProgPoint implements `StructuralPartialEq`, used for structural equality checks.

```rust
impl StructuralPartialEq for ProgPoint
```

--------------------------------

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.Edit.html

Provides an experimental, nightly-only `clone_to_uninit` method for types implementing `Clone`, enabling unsafe copying to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Debug Implementation for MachineEnv

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.MachineEnv.html

Provides a Debug implementation for formatting MachineEnv instances.

```APIDOC
### impl Debug for MachineEnv

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

--------------------------------

### Output Struct

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Output.html

Details of the `Output` struct, its fields, and their descriptions.

```APIDOC
## Struct Output

### Description
The output of the register allocator.

### Fields
- **num_spillslots** (usize) - How many spillslots are needed in the frame?
- **edits** (Vec<(ProgPoint, Edit)>) - Edits (insertions or removals). Guaranteed to be sorted by program point.
- **allocs** (Vec<Allocation>) - Allocations for each operand. Mapping from instruction to allocations provided by `inst_alloc_offsets` below.
- **inst_alloc_offsets** (Vec<u32>) - Allocation offset in `allocs` for each instruction.
- **debug_locations** (Vec<(u32, ProgPoint, ProgPoint, Allocation)>) - Debug info: a labeled value (as applied to vregs by `Function::debug_value_labels()` on the input side) is located in the given allocation from the first program point (inclusive) to the second (exclusive). Guaranteed to be sorted by label and program point, and the ranges are guaranteed to be disjoint.
- **stats** (Stats) - Internal stats from the allocator.
```

--------------------------------

### TryInto Conversion for MachineEnv

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.MachineEnv.html

Attempts to convert MachineEnv into another type, returning an error if the conversion fails.

```rust
type Error = <U as TryFrom<T>>::Error
```

--------------------------------

### Clone Implementation for MachineEnv

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.MachineEnv.html

Provides methods for cloning a MachineEnv instance.

```APIDOC
### impl Clone for MachineEnv

#### fn clone(&self) -> MachineEnv
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### Define index macro syntax

Source: https://docs.rs/regalloc2/latest/regalloc2/macro.define_index.html

Syntax definition for the define_index macro.

```rust
macro_rules! define_index {
    ($ix:ident, $storage:ident, $elem:ident) => { ... };
    ($ix:ident) => { ... };
}
```

--------------------------------

### InstRange Blanket Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.InstRange.html

Details on blanket implementations applicable to InstRange.

```APIDOC
## Blanket Implementations for InstRange

### `impl<T> Any for T`

- `fn type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`

- `fn borrow(&self) -> &T`: Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

- `fn borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.

### `impl<T> CloneToUninit for T` (Nightly-only)

- `unsafe fn clone_to_uninit(&self, dest: *mut u8)`: Performs copy-assignment from `self` to `dest`.

### `impl<T> From<T> for T`

- `fn from(t: T) -> T`: Returns the argument unchanged.

### `impl<T, U> Into<U> for T`

- `fn into(self) -> U`: Calls `U::from(self)`.

### `impl<T> ToOwned for T`

- `type Owned = T`
- `fn to_owned(&self) -> T`: Creates owned data from borrowed data, usually by cloning.
- `fn clone_into(&self, target: &mut T)`: Uses borrowed data to replace owned data, usually by cloning.

### `impl<T, U> TryFrom<U> for T`

- `type Error = Infallible`
- `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

### `impl<T, U> TryInto<U> for T`

- `type Error = <U as TryFrom<T>>::Error`
- `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

--------------------------------

### Trait Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Overview of standard trait implementations for generic types within the project.

```APIDOC
## Equivalent<K>

### Description
Checks if a value is equivalent to a given key.

### Methods
- **equivalent(&self, key: &K) -> bool**: Returns true if the value is equivalent to the key.

## From<T> and Into<U>

### Description
Standard conversion traits for type transformation.

### Methods
- **from(t: T) -> T**: Returns the argument unchanged.
- **into(self) -> U**: Performs conversion using the From implementation.

## ToOwned

### Description
Trait for creating owned data from borrowed data.

### Methods
- **to_owned(&self) -> T**: Creates owned data from borrowed data.
- **clone_into(&mut self, target: &mut T)**: Replaces owned data using borrowed data.

## TryFrom<U> and TryInto<U>

### Description
Fallible conversion traits.

### Methods
- **try_from(value: U) -> Result<T, Error>**: Attempts to convert U into T.
- **try_into(self) -> Result<U, Error>**: Attempts to convert self into U.
```

--------------------------------

### Checker Blanket Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/checker/struct.Checker.html

Documentation for blanket implementations available for the Checker struct.

```APIDOC
### impl<T> Any for T
where T: 'static + ?Sized,
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
where T: ?Sized,
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
where T: ?Sized,
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
where U: From<T>,
#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T, U> TryFrom<U> for T
where U: Into<T>,
#### type Error = Infallible
The type returned in the event of a conversion error.
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### Function: run

Source: https://docs.rs/regalloc2/latest/regalloc2/fn.run.html

The run function is the primary interface for executing the register allocator on a provided function.

```APIDOC
## run

### Description
Runs the register allocator on the provided function using the specified environment and options.

### Signature
`pub fn run<F: Function>(func: &F, env: &MachineEnv, options: &RegallocOptions) -> Result<Output, RegAllocError>`

### Parameters
- **func** (&F) - Required - The function to perform register allocation on.
- **env** (&MachineEnv) - Required - The machine environment configuration.
- **options** (&RegallocOptions) - Required - Configuration options for the allocator.

### Response
- **Result<Output, RegAllocError>** - Returns an Output object on success, or a RegAllocError if the allocation fails.
```

--------------------------------

### TryInto Trait Implementation

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.OperandConstraint.html

This section details the TryInto trait, its associated Error type, and the primary method for performing conversions.

```APIDOC
## impl<T, U> TryInto<U> for T
where U: TryFrom<T>

### Description
Provides a fallible conversion from type `T` into type `U`.

### Associated Types
#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error. This is determined by the `Error` type associated with the `TryFrom` trait implementation for `U`.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion. This method attempts to convert `self` (of type `T`) into type `U`. It returns `Ok(U)` if the conversion is successful, or `Err(Error)` if the conversion fails.
```

--------------------------------

### IndexSet Struct and Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.IndexSet.html

Details the IndexSet struct and its core methods for managing sets of indices.

```APIDOC
## Struct IndexSet

### Summary
```rust
pub struct IndexSet { /* private fields */ }
```

A conceptually infinite-length set of indices that allows union and efficient iteration over elements.

### Implementations

#### pub fn new() -> Self
Creates a new, empty IndexSet.

#### pub fn set(&mut self, idx: usize, val: bool)
Sets the value for a given index. If `val` is true, the index is added to the set; otherwise, it is removed.

#### pub fn assign(&mut self, other: &Self)
Assigns the contents of another IndexSet to this one.

#### pub fn get(&self, idx: usize) -> bool
Returns true if the index is present in the set, false otherwise.

#### pub fn union_with(&mut self, other: &Self) -> bool
Performs a union operation with another IndexSet. Returns true if the set was modified.

#### pub fn iter<'a>(&'a self) -> impl Iterator<Item = usize> + 'a
Returns an iterator over the indices present in the set.
```

--------------------------------

### CloneToUninit Trait (Nightly Only)

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Operand.html

The CloneToUninit trait is an experimental, nightly-only API that performs copy-assignment from self to a mutable pointer.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Endpoint
N/A (Trait method)

### Parameters
- `dest` (*mut u8) - Description: A mutable pointer to the destination memory.

### Request Body
None

### Response
None

### Response Example
None
```

--------------------------------

### Error Trait Provide Method (Nightly)

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.RegAllocError.html

Provides type-based access to error context, intended for error reporting. This is an experimental API.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### ProgPoint Sync Implementation

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Indicates that ProgPoint implements the `Sync` trait, meaning it can be safely shared between threads.

```rust
impl Sync for ProgPoint
```

--------------------------------

### TryInto::try_into

Source: https://docs.rs/regalloc2/latest/regalloc2/checker/enum.CheckerError.html

Performs a fallible conversion from one type to another.

```APIDOC
## try_into

### Description
Performs the conversion from type T to type U.

### Method
Function

### Parameters
- **self** (T) - Required - The source value to convert.

### Response
- **Result<U, Error>** - Returns the converted value U on success, or the associated Error type on failure.
```

--------------------------------

### Implement Default for Algorithm

Source: https://docs.rs/regalloc2/latest/regalloc2/enum.Algorithm.html

Provides a default value for the Algorithm enum. This is useful when an initial or fallback algorithm is needed.

```rust
impl Default for Algorithm
```

--------------------------------

### ProgPoint UnsafeUnpin Implementation

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Indicates that ProgPoint implements `UnsafeUnpin`, a more specialized version of `Unpin`.

```rust
impl UnsafeUnpin for ProgPoint
```

--------------------------------

### Iterator Comparison Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.PRegSetIter.html

Methods to compare iterators for inequality, less than, less than or equal to, greater than, and greater than or equal to.

```APIDOC
## Iterator Comparison Methods

### `ne<I>(self, other: I) -> bool`

Determines if the elements of this `Iterator` are not equal to those of another.

### `lt<I>(self, other: I) -> bool`

Determines if the elements of this `Iterator` are lexicographically less than those of another.

### `le<I>(self, other: I) -> bool`

Determines if the elements of this `Iterator` are lexicographically less or equal to those of another.

### `gt<I>(self, other: I) -> bool`

Determines if the elements of this `Iterator` are lexicographically greater than those of another.

### `ge<I>(self, other: I) -> bool`

Determines if the elements of this `Iterator` are lexicographically greater than or equal to those of another.

### Parameters

- **other** (I): An `IntoIterator` to compare against.

### Type Constraints

- `I: IntoIterator`
- `Self::Item: PartialEq<<I as IntoIterator>::Item>` (for `ne`)
- `Self::Item: PartialOrd<<I as IntoIterator>::Item>` (for `lt`, `le`, `gt`, `ge`)
- `Self: Sized`
```

--------------------------------

### Iterator step_by() Method

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.SetBitsIter.html

Creates a new iterator that yields elements from the original iterator, but only every 'step' elements. The first element is always yielded.

```rust
fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,
```

--------------------------------

### ProgPoint RefUnwindSafe Implementation

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.ProgPoint.html

Indicates that ProgPoint implements `RefUnwindSafe`, relevant for exception safety when references are involved.

```rust
impl RefUnwindSafe for ProgPoint
```

--------------------------------

### Iterator take() Method

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.SetBitsIter.html

Creates a new iterator that yields at most the first 'n' elements from the original iterator. If the original iterator ends before 'n' elements are yielded, it stops early.

```rust
fn take(self, n: usize) -> Take<Self>
where Self: Sized,
```

--------------------------------

### Comparison Methods

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.OutputIter.html

Methods for comparing iterators lexicographically or checking for equality.

```APIDOC
## cmp_by

### Description
Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. Nightly-only experimental API.

## partial_cmp

### Description
Lexicographically compares the PartialOrd elements of this Iterator with those of another.

## eq

### Description
Determines if the elements of this Iterator are equal to those of another.

## lt

### Description
Determines if the elements of this Iterator are lexicographically less than those of another.
```

--------------------------------

### Inst Trait Implementations

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Inst.html

Details the standard Rust traits implemented by the Inst struct.

```APIDOC
## Trait Implementations for Inst

### `Clone`
* `fn clone(&self) -> Inst` - Returns a duplicate of the value.
* `fn clone_from(&mut self, source: &Self)` - Performs copy-assignment from `source`.

### `Debug`
* `fn fmt(&self, f: &mut Formatter<'_>) -> Result` - Formats the value using the given formatter.

### `Hash`
* `fn hash<__H: Hasher>(&self, state: &mut __H)` - Feeds this value into the given `Hasher`.
* `fn hash_slice<H>(data: &[Self], state: &mut H)` - Feeds a slice of this type into the given `Hasher`.

### `Ord`
* `fn cmp(&self, other: &Inst) -> Ordering` - Compares `self` and `other`.
* `fn max(self, other: Self) -> Self` - Returns the maximum of two values.
* `fn min(self, other: Self) -> Self` - Returns the minimum of two values.
* `fn clamp(self, min: Self, max: Self) -> Self` - Restricts a value to a certain interval.

### `PartialEq`
* `fn eq(&self, other: &Inst) -> bool` - Tests for equality.
* `fn ne(&self, other: &Rhs) -> bool` - Tests for inequality.

### `PartialOrd`
* `fn partial_cmp(&self, other: &Inst) -> Option<Ordering>` - Returns an ordering between `self` and `other` if one exists.
* `fn lt(&self, other: &Rhs) -> bool` - Tests less than.
* `fn le(&self, other: &Rhs) -> bool` - Tests less than or equal to.
* `fn gt(&self, other: &Rhs) -> bool` - Tests greater than.
* `fn ge(&self, other: &Rhs) -> bool` - Tests greater than or equal to.

### `Copy`
(Implicitly implemented as `u32` is `Copy`)

### `Eq`
(Derived from `PartialEq`)

### `StructuralPartialEq`
(Derived)

### Auto Trait Implementations
* `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, `UnsafeUnpin`, `UnwindSafe`
```

--------------------------------

### Create an any use Operand

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.Operand.html

Creates an Operand for a VReg use with no location constraints, allowing allocation to either a register or the stack.

```rust
pub fn any_use(vreg: VReg) -> Self
```

--------------------------------

### Default RegallocOptions

Source: https://docs.rs/regalloc2/latest/regalloc2/struct.RegallocOptions.html

Provides the default configuration for RegallocOptions. This is useful when no specific customization is needed.

```rust
fn default() -> RegallocOptions
```

--------------------------------

### Iterator next_chunk() Method (Nightly)

Source: https://docs.rs/regalloc2/latest/regalloc2/indexset/struct.SetBitsIter.html

This is a nightly-only experimental API. It advances the iterator and returns an array containing the next N values. Requires the 'iter_next_chunk' feature.

```rust
fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,
```
Tokens:
Raw