Struct RelocationBlock 

pub struct RelocationBlock<'a> {
    pub rva: u32,
    pub size: u32,
    pub bytes: &'a [u8],
}

Represents a PE (Portable Executable) base relocation block.

In the PE format, base relocations are organized into blocks, where each block corresponds to a contiguous range of memory that needs to be relocated. The relocations within a block specify offsets relative to the block’s starting address.

Unlike COFF (Common Object File Format), PE base relocations are separated by blocks. Each block begins with a RelocationBlock structure that provides information about the relocation block, including its starting RVA (Relative Virtual Address) and size in bytes.

Each block ends with an “absolute” relocation entry, which acts as a marker to indicate the end of the block. This entry has no actual relocation effect.

Fields

rva: u32

The starting RVA for the relocation block.

size: u32

The total size of the relocation block, in bytes.

bytes: &'a [u8]

The bytes of RelocationWord data within this block.

Implementations

impl RelocationBlock<'_>

pub fn words(&self) -> RelocationWordIterator<'_>

Returns iterator for RelocationWord

Trait Implementations

impl<'a> Clone for RelocationBlock<'a>

fn clone(&self) -> RelocationBlock<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for RelocationBlock<'a>

impl<'a> Debug for RelocationBlock<'a>

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

Formats the value using the given formatter.

impl<'a> Default for RelocationBlock<'a>

fn default() -> RelocationBlock<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for RelocationBlock<'a>

fn eq(&self, other: &RelocationBlock<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for RelocationBlock<'a>

impl<'a> TryFromCtx<'a, Endian> for RelocationBlock<'a>

type Error = Error

fn try_from_ctx( bytes: &'a [u8], ctx: Endian, ) -> Result<(Self, usize), Self::Error>