addr2line

https://docs.rs/addr2line/0.26.1/addr2line/
Admin
addr2line is a cross-platform Rust library for retrieving debug information from files with DWARF...
Tokens:22,569
Snippets:215
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### FallibleIterator enumerate() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns an iterator that yields pairs of (index, element). The index starts at 0.

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

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

### Get Raw Function Name

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FunctionName.html

Retrieves the raw, unmangled name of the function. This is useful when demangling is not desired or applicable.

```rust
pub fn raw_name(&self) -> Result<Cow<'_, str>, Error>
```

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

### Get Symbol Name

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Retrieves the name of the symbol. This method is part of the Symbol struct implementation.

```rust
pub fn name(&self) -> &'a str
```

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

### Loader::new

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Loader.html

Loads the DWARF data for an executable file and creates a Context.

```APIDOC
## pub fn new(path: impl AsRef<Path>) -> Result<Self, Box<dyn Error>>

### Description
Load the DWARF data for an executable file and create a `Context`.

### Parameters
#### Path Parameters
- **path** (impl AsRef<Path>) - Required - The path to the executable file.

### Response
#### Success Response (Result<Self, Box<dyn Error>>)
- **Self**: A new `Loader` instance.
- **Box<dyn Error>**: An error if loading fails.
```

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

### Loader::new_with_sup

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Loader.html

Loads DWARF data for an executable, optionally using a supplementary object file.

```APIDOC
## pub fn new_with_sup( path: impl AsRef<Path>, sup_path: Option<impl AsRef<Path>>, ) -> Result<Self, Box<dyn Error>>

### Description
Load the DWARF data for an executable file and create a `Context`. Optionally also use a supplementary object file.

### Parameters
#### Path Parameters
- **path** (impl AsRef<Path>) - Required - The path to the executable file.
- **sup_path** (Option<impl AsRef<Path>>) - Optional - The path to a supplementary object file.

### Response
#### Success Response (Result<Self, Box<dyn Error>>)
- **Self**: A new `Loader` instance.
- **Box<dyn Error>**: An error if loading fails.
```

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

### Get Symbol Address

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Retrieves the address associated with the symbol. This method is part of the Symbol struct implementation.

```rust
pub fn address(&self) -> u64
```

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

### Context Construction

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Methods for creating a new Context instance. Constructing a Context can be costly, so reuse is encouraged.

```APIDOC
## pub fn from_sections

### Description
Construct a new `Context` from DWARF sections.
This method does not support using a supplementary object file.

### Parameters
#### Path Parameters
- **debug_abbrev** (DebugAbbrev<R>) - Required - Description
- **debug_addr** (DebugAddr<R>) - Required - Description
- **debug_aranges** (DebugAranges<R>) - Required - Description
- **debug_info** (DebugInfo<R>) - Required - Description
- **debug_line** (DebugLine<R>) - Required - Description
- **debug_line_str** (DebugLineStr<R>) - Required - Description
- **debug_ranges** (DebugRanges<R>) - Required - Description
- **debug_rnglists** (DebugRngLists<R>) - Required - Description
- **debug_str** (DebugStr<R>) - Required - Description
- **debug_str_offsets** (DebugStrOffsets<R>) - Required - Description
- **default_section** (R) - Required - Description

### Returns
- Result<Self, Error>
```

```APIDOC
## pub fn from_dwarf

### Description
Construct a new `Context` from an existing `gimli::Dwarf` object.

### Parameters
#### Path Parameters
- **sections** (Dwarf<R>) - Required - Description

### Returns
- Result<Context<R>, Error>
```

```APIDOC
## pub fn from_arc_dwarf

### Description
Construct a new `Context` from an existing `gimli::Dwarf` object.

### Parameters
#### Path Parameters
- **sections** (Arc<Dwarf<R>>) - Required - Description

### Returns
- Result<Context<R>, Error>
```

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

### Looping with LookupResult

Source: https://docs.rs/addr2line/0.26.1/addr2line/enum.LookupResult.html

Demonstrates how to use the LookupResult enum in a loop to handle split DWARF loading and obtain the final output.

```rust
  const ADDRESS: u64 = 0xdeadbeef;
  let mut r = ctx.find_frames(ADDRESS);
  let result = loop {
    match r {
      LookupResult::Output(result) => break result,
      LookupResult::Load { load, continuation } => {
        let dwo = do_split_dwarf_load(load);
        r = continuation.resume(dwo);
      }
    }
  };

```

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

### take

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>
where Self: Sized,
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner. Read more
1.0.0 · Source
```

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

### Get Demangled Function Name

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FunctionName.html

Retrieves the demangled name of the function, if applicable. This provides a more human-readable name for C++ and other languages with name mangling.

```rust
pub fn demangle(&self) -> Result<Cow<'_, str>, Error>
```

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

### into

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

```APIDOC
#### fn into(self) -> U
```

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

### partition

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Consumes an iterator, creating two collections from it.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)
where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
Consumes an iterator, creating two collections from it. Read more
Source
```

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

### Construct Context from DWARF sections

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Use this method to create a new Context from DWARF sections. It does not support supplementary object files.

```rust
pub fn from_sections(
    debug_abbrev: DebugAbbrev<R>,
    debug_addr: DebugAddr<R>,
    debug_aranges: DebugAranges<R>,
    debug_info: DebugInfo<R>,
    debug_line: DebugLine<R>,
    debug_line_str: DebugLineStr<R>,
    debug_ranges: DebugRanges<R>,
    debug_rnglists: DebugRngLists<R>,
    debug_str: DebugStr<R>,
    debug_str_offsets: DebugStrOffsets<R>,
    default_section: R,
) -> Result<Self, Error>
```

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

### Construct Context from gimli::Dwarf object

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Create a new Context from an existing gimli::Dwarf object. This is a convenient way to initialize the context if you already have a parsed Dwarf object.

```rust
pub fn from_dwarf(sections: Dwarf<R>) -> Result<Context<R>, Error>
```

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

### by_ref

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates a “by reference” adapter for this instance of `Iterator`.

```APIDOC
## fn by_ref(&mut self) -> &mut Self
where Self: Sized,
Creates a “by reference” adapter for this instance of `Iterator`. Read more
1.0.0 · Source
```

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

### Split DWARF Preloading

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Method for preloading split DWARF units to optimize subsequent lookups.

```APIDOC
## pub fn preload_units

### Description
Preload units for `probe`. The iterator returns pairs of `SplitDwarfLoad`s containing the information needed to locate and load split DWARF for `probe` and a matching callback to invoke once that data is available. If this method is called, and all of the returned closures are invoked, addr2line guarantees that any future API call for the address `probe` will not require the loading of any split DWARF.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address for which to preload units.

### Returns
- impl Iterator<Item = (SplitDwarfLoad<R>, impl FnOnce(Option<Arc<Dwarf<R>>>) -> Result<(), Error> + '_)>
```

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

### product

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Iterates over the entire iterator, multiplying all the elements.

```APIDOC
## fn product<P>(self) -> P
where Self: Sized, P: Product<Self::Item>,

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

### Returns
The product of the elements.
```

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

### min

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Returns the minimal element of the iterator.

```APIDOC
## min(self) -> Result<Option<Self::Item>, Self::Error>

### Description
Returns the minimal element of the iterator.

### Constraints
`Self::Item` must implement `Ord`.

### Returns
`Ok(Some(element))` containing the minimal element, `Ok(None)` if the iterator is empty, or an error if the iterator fails.
```

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

### Skip All Loads Implementation

Source: https://docs.rs/addr2line/0.26.1/addr2line/enum.LookupResult.html

Provides a method to skip all split DWARF loads and obtain a potentially less accurate result with available data.

```rust
pub fn skip_all_loads(self) -> L::Output
```

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

### Resume Method Signature

Source: https://docs.rs/addr2line/0.26.1/addr2line/trait.LookupContinuation.html

The signature for the resume method, which is called after loading split DWARF data. It takes an optional Arc<Dwarf<Self::Buf>> and returns a LookupResult.

```rust
fn resume(self, input: Option<Arc<Dwarf<Self::Buf>>>) -> LookupResult<Self>
```

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

### skip_all_loads

Source: https://docs.rs/addr2line/0.26.1/addr2line/enum.LookupResult.html

Allows callers that do not handle split DWARF to fast-forward to the end result. The produced result may be less accurate if split DWARF data is not properly handled.

```APIDOC
## impl<L: LookupContinuation> LookupResult<L>

### pub fn skip_all_loads(self) -> L::Output
Callers that do not handle split DWARF can call `skip_all_loads` to fast-forward to the end result. This result is produced with the data that is available and may be less accurate than the the results that would be produced if the caller did properly support split DWARF.
```

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

### inspect

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Does something with each element of an iterator, passing the value on.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),
Does something with each element of an iterator, passing the value on. Read more
1.0.0 · Source
```

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

### map_windows

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,
🔬This is a nightly-only experimental API. (`iter_map_windows`)
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well. Read more
1.0.0 · Source
```

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

### impl<I> IntoIterator for I

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Provides methods for creating standard iterators.

```APIDOC
#### type Item = <I as Iterator>::Item
The type of the elements being iterated over.

#### type IntoIter = I
Which kind of iterator are we turning this into?

#### fn into_iter(self) -> I
Creates an iterator from a value.
```

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

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

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Provides methods for fallible type conversions.

```APIDOC
#### 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.
```

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

### partial_cmp

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Lexicographically compares the elements of this iterator to that of another, returning an Option<Ordering>.

```APIDOC
## partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>

### Description
Lexicographically compares the elements of this iterator to that of another. This comparison may return `None` if elements are not comparable.

### Parameters
- `other`: Another iterator that can be converted into a `FallibleIterator` with the same error type.

### Constraints
`Self::Item` must implement `PartialOrd` with respect to the item type of `I`.

### Returns
`Ok(Some(Ordering))` indicating the comparison result, `Ok(None)` if elements are not comparable, or an error if the iterators fail.
```

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

### impl<I> IteratorExt for I

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Extension methods for iterators.

```APIDOC
#### fn transpose_into_fallible<T, E>(self) -> Convert<I>
where I: Iterator<Item = Result<T, E>>,
Convert an iterator of `Result`s into `FallibleIterator` by transposition.

#### fn into_fallible<T>(self) -> IntoFallible<I>
where I: Iterator<Item = T>,
Convert an iterator of anything into `FallibleIterator` by wrapping into `Result<T, Infallible>` where `Infallible` is an error that can never actually happen.
```

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

### Preload split DWARF units

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Preloads units for a given probe address, returning information needed to load split DWARF data and a callback to process it. This ensures subsequent lookups for the same address do not require further DWARF loading.

```rust
pub fn preload_units(
    &self,
    probe: u64,
) -> impl Iterator<Item = (SplitDwarfLoad<R>, impl FnOnce(Option<Arc<Dwarf<R>>>) -> Result<(), Error> + '_)>
```

```rust
const ADDRESS: u64 = 0xdeadbeef;
  ctx.preload_units(ADDRESS).for_each(|(load, callback)| {
    let dwo = do_split_dwarf_load(load);
    callback(dwo);
  });

  let frames_iter = match ctx.find_frames(ADDRESS) {
    LookupResult::Output(result) => result,
    LookupResult::Load { .. } => unreachable!("addr2line promised we wouldn't get here"),
  };

  // ...
```

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

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

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Provides methods for fallible type conversions.

```APIDOC
#### 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.
```

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

### inspect

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns an iterator which passes each element to a closure before returning it.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>

### Description
Returns an iterator which passes each element to a closure before returning it.

### Parameters
- `f`: A closure that takes a reference to an item and returns a Result.

### Returns
An `Inspect` iterator.
```

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

### Loader::find_location_range

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Loader.html

Returns source file and lines for a range of addresses.

```APIDOC
## pub fn find_location_range( &self, probe_low: u64, probe_high: u64, ) -> Result<LocationRangeIter<'_, impl Reader + '_>, Box<dyn Error>>

### Description
Return source file and lines for a range of addresses. This calls `Context::find_location_range` with the given range.

### Parameters
#### Path Parameters
- **probe_low** (u64) - Required - The lower bound of the address range.
- **probe_high** (u64) - Required - The upper bound of the address range.

### Response
#### Success Response (Result<LocationRangeIter<'_, impl Reader + '_>, Box<dyn Error>>)
- **LocationRangeIter<'_, impl Reader + '_>**: An iterator over `Location`s within the specified range.
- **Box<dyn Error>**: An error if the lookup fails.
```

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

### Address Lookup Methods

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Methods for finding source code information associated with memory addresses.

```APIDOC
## pub fn find_dwarf_and_unit

### Description
Find the DWARF unit corresponding to the given virtual memory address.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address to probe.

### Returns
- LookupResult<impl LookupContinuation<Output = Option<UnitRef<'_, R>>, Buf = R>>
```

```APIDOC
## pub fn find_location

### Description
Find the source file and line corresponding to the given virtual memory address.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address to find the location for.

### Returns
- Result<Option<Location<'_>>, Error>
```

```APIDOC
## pub fn find_location_range

### Description
Return source file and lines for a range of addresses. For each location it also returns the address and size of the range of the underlying instructions.

### Parameters
#### Path Parameters
- **probe_low** (u64) - Required - The lower bound of the address range.
- **probe_high** (u64) - Required - The upper bound of the address range.

### Returns
- Result<LocationRangeIter<'_, R>, Error>
```

```APIDOC
## pub fn find_frames

### Description
Return an iterator for the function frames corresponding to the given virtual memory address. If the probe address is not for an inline function then only one frame is returned. If the probe address is for an inline function then the first frame corresponds to the innermost inline function. Subsequent frames contain the caller and call location, until an non-inline caller is reached.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address to find frames for.

### Returns
- LookupResult<impl LookupContinuation<Output = Result<FrameIter<'_, R>, Error>, Buf = R>>
```

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

### by_ref

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Borrow an iterator rather than consuming it.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Borrow an iterator rather than consuming it.

### Returns
A mutable reference to the iterator itself.
```

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

### find

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns the first element of the iterator that matches a predicate.

```APIDOC
## fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>

### Description
Returns the first element of the iterator that matches a predicate.

### Type Parameters
- `F`: A closure that takes a reference to an item and returns a `Result<bool, Self::Error>`.

### Parameters
- `f`: The predicate closure.

### Returns
A `Result` containing `Some(element)` if found, `None` if not found, or an error.
```

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

### Struct Location

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Location.html

Represents a source location, including the file name, line number, and column number.

```APIDOC
## Struct Location

### Description
A source location.

### Fields
- `file`: Option<&'a str> - The file name.
- `line`: Option<u32> - The line number.
- `column`: Option<u32> - The column number. A value of `Some(0)` indicates the left edge.
```

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

### Comparison Methods for FrameIter

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

These methods allow for lexicographical comparison of FrameIter instances with other fallible iterators.

```APIDOC
## fn le<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically less than or equal to those of another.

### Method Signature
`le<I>(self, other: I) -> Result<bool, Self::Error>`

### Type Constraints
`where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>`
```

```APIDOC
## fn gt<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically greater than those of another.

### Method Signature
`gt<I>(self, other: I) -> Result<bool, Self::Error>`

### Type Constraints
`where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>`
```

```APIDOC
## fn ge<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically greater than or equal to those of another.

### Method Signature
`ge<I>(self, other: I) -> Result<bool, Self::Error>`

### Type Constraints
`where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>, Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>`
```

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

### From Trait Implementation

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Provides the `from` method, which returns the argument unchanged.

```rust
fn from(t: T) -> T
```

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

### fold

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Folds every element into an accumulator by applying an operation, returning the final result.

```APIDOC
## fn fold<B, F>(self, init: B, f: F) -> B
where Self: Sized, F: FnMut(B, Self::Item) -> B,

### Description
Folds every element into an accumulator by applying an operation, returning the final result.

### Parameters
- `init`: The initial value of the accumulator.
- `f`: A mutable closure that takes the accumulator and an item, returning the updated accumulator.
```

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

### enumerate

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator which gives the current iteration count as well as the next value.

```APIDOC
## fn enumerate(self) -> Enumerate<Self>
where Self: Sized,
Creates an iterator which gives the current iteration count as well as the next value. Read more
1.0.0 · Source
```

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

### partition

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Transforms the iterator into two collections, partitioning elements by a closure.

```APIDOC
## fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>

### Description
Transforms the iterator into two collections, partitioning elements by a closure.

### Type Parameters
- `B`: The type of the collections to create, which must implement `Default` and `Extend`.
- `F`: A closure that takes a reference to an item and returns a `Result<bool, Self::Error>`.

### Returns
A `Result` containing a tuple of two collections `(B, B)` or an error.
```

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

### Find source location for an address

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Finds the source file and line number for a given virtual memory address. This is a primary function for address translation.

```rust
pub fn find_location(&self, probe: u64) -> Result<Option<Location<'_>>, Error>
```

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

### Find source locations for an address range

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Returns an iterator over source file and line information for a range of addresses. It also provides the address and size of the underlying instruction ranges.

```rust
pub fn find_location_range(
    &self,
    probe_low: u64,
    probe_high: u64,
) -> Result<LocationRangeIter<'_, R>, Error>
```

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

### LocationRangeIter Core Methods

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Core methods for the LocationRangeIter implementation.

```APIDOC
## type Item = (u64, u64, Location<'ctx>)

### Description
The type of the elements being iterated over, representing a location range and associated data.
```

```APIDOC
## fn next(&mut self) -> Option<Self::Item>

### Description
Advances the iterator and returns the next location range. Returns `None` if the iterator is exhausted.

### Returns
An `Option` containing the next `Item` or `None`.
```

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

### Description
Advances the iterator and returns an array containing the next `N` values. This is a nightly-only experimental API.

### Type Parameters
- `N`: The size of the chunk to retrieve.

### Returns
A `Result` containing an array of `N` items, or an error if the iterator could not produce the chunk.
```

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

### Description
Returns the lower and upper bounds of the remaining number of elements in the iterator.

### Returns
A tuple `(lower_bound, upper_bound_option)`.
```

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

### Description
Consumes the iterator, counting the number of elements it yields and returning the total count.

### Returns
The total number of elements iterated.
```

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

### Description
Consumes the iterator and returns the last element yielded. Returns `None` if the iterator was empty.

### Returns
An `Option` containing the last `Item` or `None`.
```

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

### Description
Advances the iterator by `n` elements. This is a nightly-only experimental API.

### Parameters
- `n`: The number of elements to advance by.

### Returns
A `Result` indicating success or the number of elements that could not be advanced.
```

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

### Description
Returns the `n`th element of the iterator (0-indexed). Consumes elements up to `n`.

### Parameters
- `n`: The index of the element to retrieve.

### Returns
An `Option` containing the `n`th `Item` or `None` if `n` is out of bounds.
```

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

### Description
Creates an iterator that yields elements from the original iterator at a specified `step` interval.

### Parameters
- `step`: The interval between elements to yield.

### Returns
A new `StepBy` iterator.
```

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

### Description
Creates an iterator that yields elements from this iterator followed by elements from another iterator.

### Parameters
- `other`: Another iterator or iterable to chain.

### Returns
A new `Chain` iterator.
```

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

### Description
Creates an iterator that yields pairs of elements, one from each of the two zipped iterators. The iteration stops when the shorter iterator is exhausted.

### Parameters
- `other`: Another iterator or iterable to zip with.

### Returns
A new `Zip` iterator.
```

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

### Description
Creates a new iterator that places a copy of `separator` between each element of the original iterator. This is a nightly-only experimental API.

### Parameters
- `separator`: The item to insert between elements.

### Returns
A new `Intersperse` iterator.
```

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

### Description
Creates a new iterator that places an item generated by the `separator` closure between each element of the original iterator. This is a nightly-only experimental API.

### Parameters
- `separator`: A closure that generates the item to insert between elements.

### Returns
A new `IntersperseWith` iterator.
```

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

### Description
Creates an iterator that applies a closure `f` to each element yielded by the original iterator.

### Parameters
- `f`: A closure that transforms each element.

### Returns
A new `Map` iterator.
```

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

### Description
Applies a closure `f` to each element yielded by the iterator, consuming the iterator in the process.

### Parameters
- `f`: A closure that processes each element.
```

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

### Loader::find_location

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Loader.html

Finds the source file and line for a given virtual memory address.

```APIDOC
## pub fn find_location( &self, probe: u64, ) -> Result<Option<Location<'_>>, Box<dyn Error>>

### Description
Find the source file and line corresponding to the given virtual memory address. This calls `Context::find_location` with the given address.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address to look up.

### Response
#### Success Response (Result<Option<Location<'_>>, Box<dyn Error>>)
- **Option<Location<'_>>**: An `Option` containing the `Location` if found, otherwise `None`.
- **Box<dyn Error>**: An error if the lookup fails.
```

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

### copied

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator which copies all of its elements.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>
where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

### Description
Creates an iterator which copies all of its elements.

### Returns
A new iterator that yields copied elements.
```

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

### FrameIter next() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Advances the FrameIter iterator and returns the next Frame. This method is part of the core FrameIter functionality.

```rust
pub fn next(&mut self) -> Result<Option<Frame<'ctx, R>>, Error>
```

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

### FallibleIterator zip() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns an iterator that yields pairs of elements from this iterator and another. Iteration stops when either iterator is exhausted. The other iterator must be convertible into a FallibleIterator.

```rust
fn zip<I>( self, o: I, ) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>
where Self: Sized, I: IntoFallibleIterator<Error = Self::Error>,
```

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

### skip

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator that skips the first `n` elements.

```APIDOC
## fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,
Creates an iterator that skips the first `n` elements. Read more
1.0.0 · Source
```

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

### take_while

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator that yields elements based on a predicate.

```APIDOC
## fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate. Read more
1.57.0 · Source
```

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

### Construct Context from Arc<gimli::Dwarf>

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Create a new Context from an existing gimli::Dwarf object wrapped in an Arc. This is useful for sharing the Dwarf object across multiple contexts.

```rust
pub fn from_arc_dwarf(sections: Arc<Dwarf<R>>) -> Result<Context<R>, Error>
```

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

### Into Trait Implementation

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Provides the `into` method, which calls `U::from(self)` for type conversion.

```rust
fn into(self) -> U
```

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

### min_by

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns the element that gives the minimum value with respect to the function.

```APIDOC
## fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>

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

### Type Parameters
- `F`: A closure that takes two references to items and returns a `Result<Ordering, Self::Error>`.

### Parameters
- `f`: The comparison closure.

### Returns
A `Result` containing `Some(element)` with the minimum value, `None` if the iterator is empty, or an error.
```

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

### scan

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator.

```APIDOC
## fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator. Read more
1.0.0 · Source
```

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

### any

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Determines if any element of this iterator matches a predicate.

```APIDOC
## fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>

### Description
Determines if any element of this iterator matches a predicate.

### Type Parameters
- `F`: A closure that takes an item and returns a `Result<bool, Self::Error>`.

### Parameters
- `f`: The predicate closure.

### Returns
A `Result` containing `true` if any element matches the predicate, `false` otherwise, or an error.
```

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

### Loader::find_symbol_info

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Loader.html

Finds the symbol table entry for a given virtual memory address and returns detailed symbol information.

```APIDOC
## pub fn find_symbol_info(&self, probe: u64) -> Option<Symbol<'_>>

### Description
Find the symbol table entry corresponding to the given virtual memory address. Return the symbol name.

### Parameters
#### Path Parameters
- **probe** (u64) - Required - The virtual memory address to look up.

### Response
#### Success Response (Option<Symbol<'_>>)
- **Option<Symbol<'_>>**: The `Symbol` information if found, otherwise `None`.
```

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

### Iterator Adaptors

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Methods for transforming or consuming the iterator.

```APIDOC
## fn iterator(self) -> Iterator<Self>

### Description
Returns a normal (non-fallible) iterator over `Result<Item, Error>`.

### Returns
A standard iterator.
```

```APIDOC
## fn map_err<B, F>(self, f: F) -> MapErr<Self, F>

### Description
Returns an iterator which applies a transform to the errors of the underlying iterator.

### Parameters
- `f`: A closure that transforms errors.

### Returns
A new iterator with transformed errors.
```

```APIDOC
## fn unwrap<T>(self) -> Unwrap<Self>

### Description
Returns an iterator which unwraps all of its elements. This operation will panic if any element is an error.

### Type Parameters
- `T`: The type of the unwrapped elements.

### Returns
A new iterator that yields unwrapped elements.
```

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

### cloned

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns an iterator which clones all of its elements.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>

### Description
Returns an iterator which clones all of its elements.

### Type Parameters
- `T`: The type of the elements, which must be cloneable.

### Returns
A `Cloned` iterator.
```

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

### all

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Determines if all elements of this iterator match a predicate.

```APIDOC
## fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>

### Description
Determines if all elements of this iterator match a predicate.

### Type Parameters
- `F`: A closure that takes an item and returns a `Result<bool, Self::Error>`.

### Parameters
- `f`: The predicate closure.

### Returns
A `Result` containing `true` if all elements match the predicate, `false` otherwise, or an error.
```

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

### unzip

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Converts an iterator of pairs into a pair of containers.

```APIDOC
## fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>

### Description
Converts an iterator of pairs into a pair of containers.

### Type Parameters
- `A`, `B`: The types of the elements in the pair.
- `FromA`, `FromB`: The types of the containers, which must implement `Default` and `Extend`.

### Returns
A `Result` containing a tuple of two containers `(FromA, FromB)` or an error.
```

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

### collect

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Transforms the iterator into a collection.

```APIDOC
## fn collect<T>(self) -> Result<T, Self::Error>

### Description
Transforms the iterator into a collection.

### Type Parameters
- `T`: The type of the collection to create, which must implement `FromIterator`.

### Returns
A `Result` containing the collection `T` or an error.
```

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

### FallibleIterator step_by() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns a new iterator that steps by the specified amount. This is a convenience method for controlling iteration frequency.

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

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

### peekable

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator which can use the `peek` and `peek_mut` methods to look at the next element of the iterator without consuming it.

```APIDOC
## fn peekable(self) -> Peekable<Self>
where Self: Sized,
Creates an iterator which can use the `peek` and `peek_mut` methods to look at the next element of the iterator without consuming it. See their documentation for more information. Read more
1.0.0 · Source
```

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

### impl FunctionName<R>

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FunctionName.html

Implementations for the FunctionName struct, providing methods to access function names.

```APIDOC
## impl<R: Reader> FunctionName<R>

### raw_name

#### Description
The raw name of this function before demangling.

#### Returns
- `Result<Cow<'_, str>, Error>` - The raw function name.
```

```APIDOC
## impl<R: Reader> FunctionName<R>

### demangle

#### Description
The name of this function after demangling (if applicable).

#### Returns
- `Result<Cow<'_, str>, Error>` - The demangled function name.
```

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

### FallibleIterator take() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns an iterator that yields only the first `n` elements. This is useful for limiting the number of items processed.

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

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

### fuse

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator which ends after the first `None`.

```APIDOC
## fn fuse(self) -> Fuse<Self>
where Self: Sized,
Creates an iterator which ends after the first `None`. Read more
1.0.0 · Source
```

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

### Symbol::address

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Retrieves the address of the symbol.

```APIDOC
## Symbol::address

```rust
pub fn address(&self) -> u64
```

### Description
Get the symbol address.
```

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

### Ordering Comparisons

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Determines the lexicographical ordering (less than, less or equal, greater than, greater or equal) between this Iterator and another.

```APIDOC
## fn lt<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Determines if the elements of this `Iterator` are lexicographically less than those of another. Read more
```

```APIDOC
## fn le<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Determines if the elements of this `Iterator` are lexicographically less or equal to those of another. Read more
```

```APIDOC
## fn gt<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Determines if the elements of this `Iterator` are lexicographically greater than those of another. Read more
```

```APIDOC
## fn ge<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Determines if the elements of this `Iterator` are lexicographically greater than or equal to those of another. Read more
```

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

### partial_cmp

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Lexicographically compares the elements of this iterator to that of another.

```APIDOC
## fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>

### Description
Lexicographically compares the elements of this iterator to that of another.

### Type Parameters
- `I`: The type of the other iterator, which must be convertible into a fallible iterator.

### Parameters
- `other`: The other iterator to compare against.

### Returns
A `Result` containing `Some(Ordering)` if comparison is possible, `None` if iterators have different lengths and comparison is not fully defined, or an error.
```

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

### Find DWARF unit for an address

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Context.html

Finds the DWARF unit corresponding to a given virtual memory address. This is a prerequisite for other lookup operations.

```rust
pub fn find_dwarf_and_unit(
    &self,
    probe: u64,
) -> LookupResult<impl LookupContinuation<Output = Option<UnitRef<'_, R>>, Buf = R>>
```

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

### TryInto Trait Implementation

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Provides the `try_into` method for fallible conversions.

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

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

### Symbol Struct

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Represents information from a symbol table entry.

```APIDOC
## Struct Symbol

```rust
pub struct Symbol<'a> { /* private fields */ }
```

### Description
Information from a symbol table entry.
```

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

### FallibleIterator size_hint() Method

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Returns bounds on the remaining length of the iterator. This is useful for pre-allocating or estimating iteration cost.

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

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

### Comparison Methods

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Methods for comparing elements of LocationRangeIter with another iterator.

```APIDOC
## fn ne<I>(self, other: I) -> Result<bool, Self::Error>

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

### Parameters
- `other`: An iterator to compare against.

### Returns
A `Result` containing a boolean indicating inequality, or an error if one occurred during iteration.
```

```APIDOC
## fn lt<I>(self, other: I) -> Result<bool, Self::Error>

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

### Parameters
- `other`: An iterator to compare against.

### Returns
A `Result` containing a boolean indicating if this iterator's elements are lexicographically less than the other's, or an error.
```

```APIDOC
## fn le<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically less than or equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
A `Result` containing a boolean indicating if this iterator's elements are lexicographically less than or equal to the other's, or an error.
```

```APIDOC
## fn gt<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically greater than those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
A `Result` containing a boolean indicating if this iterator's elements are lexicographically greater than the other's, or an error.
```

```APIDOC
## fn ge<I>(self, other: I) -> Result<bool, Self::Error>

### Description
Determines if the elements of this iterator are lexicographically greater than or equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
A `Result` containing a boolean indicating if this iterator's elements are lexicographically greater than or equal to the other's, or an error.
```

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

### FunctionName Struct

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FunctionName.html

Represents a function name, potentially with associated language information.

```APIDOC
## Struct FunctionName

### Description
A function name.

### Fields
- `name: R` - The name of the function.
- `language: Option<DwLang>` - The language of the compilation unit containing this function.
```

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

### TryFrom Trait Implementation

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.Symbol.html

Provides the `try_from` method for fallible conversions.

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

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

### Iterator Conversion and Transformation

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.FrameIter.html

Methods for converting FrameIter into different iterator types or transforming their elements and errors.

```APIDOC
## fn iterator(self) -> Iterator<Self>

### Description
Returns a normal (non-fallible) iterator over `Result<Item, Error>`.

### Method Signature
`iterator(self) -> Iterator<Self>`

### Type Constraints
`where Self: Sized`
```

```APIDOC
## fn map_err<B, F>(self, f: F) -> MapErr<Self, F>

### Description
Returns an iterator which applies a transform to the errors of the underlying iterator.

### Method Signature
`map_err<B, F>(self, f: F) -> MapErr<Self, F>`

### Type Constraints
`where F: FnMut(Self::Error) -> B, Self: Sized`
```

```APIDOC
## fn unwrap<T>(self) -> Unwrap<Self>

### Description
Returns an iterator which unwraps all of its elements.

### Method Signature
`unwrap<T>(self) -> Unwrap<Self>`

### Type Constraints
`where Self: Sized + FallibleIterator<Item = T>, Self::Error: Debug`
```

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

### skip_while

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Creates an iterator that `skip`s elements based on a predicate.

```APIDOC
## fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates an iterator that `skip`s elements based on a predicate. Read more
1.0.0 · Source
```

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

### cmp

Source: https://docs.rs/addr2line/0.26.1/addr2line/struct.LocationRangeIter.html

Lexicographically compares the elements of this iterator to that of another.

```APIDOC
## cmp<I>(self, other: I) -> Result<Ordering, Self::Error>

### Description
Lexicographically compares the elements of this iterator to that of another.

### Parameters
- `other`: Another iterator that can be converted into a `FallibleIterator` with the same item type and error type.

### Constraints
`Self::Item` must implement `Ord`.

### Returns
`Ok(Ordering)` indicating the comparison result (`Less`, `Equal`, `Greater`), or an error if the iterators fail.
```
Tokens:
Raw