Struct SectionFlags 

pub struct SectionFlags(/* private fields */);

Attributes of a section, independent of the file format.

A small bit set: combine flags with |, test them with contains. Which combinations a section may carry depends on its SectionKind.

Examples

use object_lang::SectionFlags;

let flags = SectionFlags::ALLOC | SectionFlags::MERGE | SectionFlags::STRINGS;
assert!(flags.contains(SectionFlags::MERGE));
assert!(!flags.contains(SectionFlags::WRITE));

Implementations

impl SectionFlags

pub const ALLOC: SectionFlags

The section occupies memory when the program runs.

pub const WRITE: SectionFlags

The section is writable at run time.

pub const EXEC: SectionFlags

The section holds executable instructions.

pub const TLS: SectionFlags

The section is a thread-local storage template (.tdata, .tbss).

pub const MERGE: SectionFlags

Equal entries of entry_size bytes may be merged by the linker. Requires a non-zero entry size.

pub const STRINGS: SectionFlags

The entries are NUL-terminated strings (with MERGE, equal strings may be merged).

pub const fn empty() -> Self

No flags.

Examples

use object_lang::SectionFlags;

assert!(SectionFlags::empty().is_empty());

pub const fn contains(self, other: SectionFlags) -> bool

Whether every flag in other is set in self.

Examples

use object_lang::SectionFlags;

let rw = SectionFlags::ALLOC | SectionFlags::WRITE;
assert!(rw.contains(SectionFlags::WRITE));
assert!(!rw.contains(SectionFlags::WRITE | SectionFlags::EXEC));

pub const fn is_empty(self) -> bool

Whether no flag is set.

Examples

use object_lang::SectionFlags;

assert!(!SectionFlags::ALLOC.is_empty());

pub const fn union(self, other: SectionFlags) -> Self

self with every flag of other added.

Examples

use object_lang::SectionFlags;

assert_eq!(SectionFlags::ALLOC.union(SectionFlags::WRITE), SectionFlags::ALLOC | SectionFlags::WRITE);

pub const fn difference(self, other: SectionFlags) -> Self

self with every flag of other removed.

Examples

use object_lang::SectionFlags;

let rw = SectionFlags::ALLOC | SectionFlags::WRITE;
assert_eq!(rw.difference(SectionFlags::WRITE), SectionFlags::ALLOC);

pub const fn bits(self) -> u8

The raw bits, one per flag constant, in declaration order from bit 0.

Examples

use object_lang::SectionFlags;

assert_eq!(SectionFlags::ALLOC.bits(), 1);
assert_eq!(SectionFlags::from_bits(0b11), Some(SectionFlags::ALLOC | SectionFlags::WRITE));

pub const fn from_bits(bits: u8) -> Option<Self>

The flags with these raw bits, or None if a bit names no flag.

Examples

use object_lang::SectionFlags;

assert_eq!(SectionFlags::from_bits(0b100), Some(SectionFlags::EXEC));
assert_eq!(SectionFlags::from_bits(0x80), None);

Trait Implementations

impl BitOr for SectionFlags

type Output = SectionFlags

The resulting type after applying the | operator.

fn bitor(self, rhs: SectionFlags) -> SectionFlags

Performs the | operation.

impl BitOrAssign for SectionFlags

fn bitor_assign(&mut self, rhs: SectionFlags)

Performs the |= operation.

impl Clone for SectionFlags

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 SectionFlags

impl Debug for SectionFlags

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

Formats the value using the given formatter.

impl Default for SectionFlags

fn default() -> Self

Returns the “default value” for a type.

impl Eq for SectionFlags

impl Hash for SectionFlags

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 SectionFlags

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SectionFlags