Struct Segment 

pub struct Segment {
    pub kind: SegmentKind,
    pub flags: SegmentFlags,
    pub offset: u64,
    pub virtual_address: u64,
    pub physical_address: u64,
    pub file_size: u64,
    pub memory_size: u64,
    pub align: u64,
}

Segment.

Dynamic loader maps segments into virtual address space of a program. Usually segments consists of sections, however, some segment types exist on their own.

Fields

kind: SegmentKind

Segment type.

flags: SegmentFlags

Flags.

offset: u64

In-file offset.

virtual_address: u64

Virtual address (in-memory offset).

physical_address: u64

Physical address (in-memory offset).

Usually physical address is the same as virtual address.

file_size: u64

In-file size.

memory_size: u64

In-memory size.

align: u64

Alignment.

• Offset and virtual address must have congruent values, i.e. offset % align == virtual_address % align.
• LOAD segments boundaries are expanded to the nearest page boundaries, i.e. offset is rounded down to a multiple of page size and offset + memory_size is rounded up to a multiple of page size.

Implementations

impl Segment

pub fn read_content<R: ElfRead + ElfSeek, T: BlockRead>( &self, reader: &mut R, class: Class, byte_order: ByteOrder, ) -> Result<T, Error>

Read segment contents as bytes.

pub fn write_content<W: ElfWrite + ElfSeek, T: BlockWrite + ?Sized>( &self, writer: &mut W, class: Class, byte_order: ByteOrder, content: &T, ) -> Result<(), Error>

Write segment contents.

pub fn clear_content<W: ElfWrite + ElfSeek>( &self, writer: &mut W, ) -> Result<(), Error>

Zero out the entry’s content.

pub const fn physical_address_range(&self) -> Range<u64>

Physical address range.

pub const fn virtual_address_range(&self) -> Range<u64>

Virtual address range.

pub const fn file_offset_range(&self) -> Range<u64>

In-file location of the segment.

pub fn check(&self, class: Class) -> Result<(), Error>

Check segment.

Trait Implementations

impl Debug for Segment

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

Formats the value using the given formatter.

impl EntityIo for Segment

fn read<R: ElfRead>( reader: &mut R, class: Class, byte_order: ByteOrder, ) -> Result<Self, Error>

Read the entity from the reader.

fn write<W: ElfWrite>( &self, writer: &mut W, class: Class, byte_order: ByteOrder, ) -> Result<(), Error>

Write the entity to the writer.