Struct Shape 

pub struct Shape {
    pub alloc: bool,
    pub write: bool,
    pub exec: bool,
    pub thread: bool,
    pub bits: bool,
    pub array: Option<Array>,
    pub merge: u64,
    pub strings: bool,
    pub mach: u32,
}

What a section is, which on ELF is a handful of flag letters and a type.

Held as the separate facts rather than as one of a fixed list of kinds, because the list is not fixed: a program may write .section .init.text,"ax",@progbits and mean a section this compiler has no name for, and the letters are the whole of what it said about it. The writer underneath takes a SectionKind, so Shape::kind is the one place that turns these back into one, and the cases it cannot say are written as flags directly.

Fields

alloc: bool

a: the section takes space in the loaded image. A section without this is for a debugger or a linker to read and is not in the program at run time.

write: bool

w: the program may write to it.

exec: bool

x: the processor may execute it.

thread: bool

T: one copy per thread rather than one copy per program.

bits: bool

Whether the file carries the bytes. False is @nobits, which is what .bss is.

array: Option<Array>

Which kind of table of function addresses this is, for the three ELF has a type for.

merge: u64

M: how long each entry is in a section of constants the linker may keep one copy of wherever two objects hold the same one, and zero for a section that is not one of those. gcc puts a double it loads from memory in .rodata.cst8, which is one of these.

strings: bool

S: the entries are strings ended by a zero rather than all of one length, which is where gcc puts every string literal. Only means anything beside merge.

mach: u32

The type and attributes of a Mach-O section, in the one word the format keeps them in, which is what Shape::mach works out. Zero on the other two formats, where the fields above are the whole answer, and zero is also an ordinary Mach-O section with nothing said.

Implementations

impl Shape

pub fn of(name: &str) -> Shape

What a section of this name is when the source named it and said nothing else.

.text, .data and the rest are names an assembler already knows the flags of, which is why a program may write .data on its own and why .section .data without letters is the same section rather than an unallocated one. A name nothing here knows gets the flags of an ordinary allocated writable section, which is what gas does with one.

pub fn implied(name: &str) -> Shape

The flags a section of this name has whatever letters the source gave it.

gas adds these to the letters rather than taking the letters alone, so .section .data.rel.ro.local,"a" is writable all the same. GMP names its jump tables that way, and a linker making a position independent program refuses an address it would have to fix up in a section it may not write. Only the names gas treats as a family are here, which is fewer than Shape::of knows: .init.data is not executable just because .init is.

pub fn mach( segment: &str, section: &str, kind: Option<&str>, attributes: &[&str], ) -> Result<Shape, String>

What a Mach-O section is, from its segment, its section and the type and attributes a .section directive gave after them.

The word the format keeps is the answer and the fields beside it are filled in from it, so that what reads a shape without knowing the format still sees code as code and a zero filled section as one that holds no bytes.

Errors

A type or an attribute Apple’s assembler does not take, as a sentence.

Trait Implementations

impl Clone for Shape

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 Shape

impl Debug for Shape

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

Formats the value using the given formatter.

impl Default for Shape

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Shape

impl PartialEq for Shape

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Shape