Enum SectionKind 

#[non_exhaustive]
pub enum SectionKind {
    Text,
    Data,
    ReadOnlyData,
    Bss,
    Note,
    InitArray,
    FiniArray,
    PreinitArray,
    Other,
}

What a section holds. The kind decides how a format stores the section (an ELF section type, a COFF characteristic, a Mach-O section type) and which SectionFlags it may carry.

Kind	Contents	Required flags	Forbidden flags
Text	machine code	ALLOC, EXEC	TLS
Data	writable initialized data	ALLOC, WRITE	EXEC
ReadOnlyData	constants	ALLOC	WRITE, EXEC, TLS
Bss	zero-filled space, no bytes in the file	ALLOC	EXEC, MERGE, STRINGS
Note	vendor notes		WRITE, EXEC, TLS, MERGE, STRINGS
InitArray, FiniArray, PreinitArray	pointers to constructors or destructors	ALLOC, WRITE	EXEC, TLS, MERGE, STRINGS
Other	data not loaded at run time (comments, metadata)		ALLOC, WRITE, EXEC, TLS

The rule for the first four rows is what makes a kind recoverable from a file: with ALLOC, EXEC means code, else WRITE means data, else read-only data, and without ALLOC the section is Other.

Examples

use object_lang::{SectionFlags, SectionKind};

assert_eq!(SectionKind::Text.default_flags(), SectionFlags::ALLOC | SectionFlags::EXEC);
assert!(SectionKind::Bss.is_uninitialized());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text

Executable machine code (.text).

Data

Writable, initialized data (.data; with TLS, .tdata).

ReadOnlyData

Read-only data (.rodata).

Bss

Zero-initialized space that takes no room in the file (.bss; with TLS, .tbss). Its size is set with with_bss_size or reserve.

Note

Notes for the loader or tools (SHT_NOTE in ELF).

InitArray

Pointers to functions run before main (.init_array).

FiniArray

Pointers to functions run at exit (.fini_array).

PreinitArray

Pointers to functions run before shared-library initializers (.preinit_array).

Other

Data that is not loaded at run time: comments, tool metadata, debug information.

Implementations

impl SectionKind

pub const fn default_flags(self) -> SectionFlags

The flags Section::new gives a section of this kind: the required flags in the table above.

Examples

use object_lang::{SectionFlags, SectionKind};

assert_eq!(SectionKind::Data.default_flags(), SectionFlags::ALLOC | SectionFlags::WRITE);
assert_eq!(SectionKind::Other.default_flags(), SectionFlags::empty());

pub const fn is_uninitialized(self) -> bool

Whether sections of this kind hold no bytes, only a size (Bss).

Examples

use object_lang::SectionKind;

assert!(SectionKind::Bss.is_uninitialized());
assert!(!SectionKind::Data.is_uninitialized());

pub const fn allows(self, flags: SectionFlags) -> bool

Whether flags are allowed on a section of this kind (the table on SectionKind).

Examples

use object_lang::{SectionFlags, SectionKind};

assert!(SectionKind::Data.allows(SectionFlags::ALLOC | SectionFlags::WRITE | SectionFlags::TLS));
assert!(!SectionKind::ReadOnlyData.allows(SectionFlags::ALLOC | SectionFlags::WRITE));

Trait Implementations

impl Clone for SectionKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SectionKind

impl Debug for SectionKind

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

Formats the value using the given formatter.

impl Eq for SectionKind

impl Hash for SectionKind

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SectionKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SectionKind