Struct Patchable 

pub struct Patchable {
    pub total: u32,
    pub before: u32,
}

How much room at the top of every function is reserved for somebody to write over later, which -fpatchable-function-entry= asks for.

Room rather than instructions. What goes there is a run of the shortest instruction the machine has that does nothing, and the point of them is that they are never executed for long: a tracer or a live patcher overwrites them with a jump or a call once the program is running, and what it needs from the compiler is a known address, a known number of bytes, and a promise that nothing in the function jumps into the middle of them.

Two numbers because the room can be on either side of the function’s own label, and the two sides are not the same thing. Room after the label is room inside the function, which is what a patcher that redirects a call into the function wants. Room in front of the label is outside it, so what goes there is reached only by something that already knows the address, and a patcher that wants somewhere to put a whole instruction it can reach from the first one needs it.

The address recorded for the function is the start of the room, which is the front of the part before the label when there is one and the front of the part after it when there is not.

Fields

total: u32

How many bytes in total, which is the first number and the one a command line must give.

before: u32

How many of them go in front of the function’s own label, which is the second number and is zero on a command line that gave one number.

Implementations

impl Patchable

pub const fn any(self) -> bool

Whether any room at all was asked for, which is what decides whether a function gets a record.

=0 is a command line that asked for none, and gcc accepts it and writes nothing, so the question is about the number rather than about whether the flag was written.

pub const fn after(self) -> u32

How many bytes go after the function’s own label, which is the rest of them.

Trait Implementations

impl Clone for Patchable

fn clone(&self) -> Patchable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Patchable

impl Debug for Patchable

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

Formats the value using the given formatter.

impl Default for Patchable

fn default() -> Patchable

Returns the “default value” for a type.

impl Display for Patchable

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

Written the way it was asked for, which is one number when the second is zero.

Not because the two forms mean different things, they do not, but because that is the form a command line reaching for this feature writes and reading back what was written is what --print-config is for.

impl Eq for Patchable

impl FromStr for Patchable

fn from_str(s: &str) -> Result<Self, ()>

Parses the part after -fpatchable-function-entry=, which is a number or two of them.

A second number larger than the first is refused rather than clamped, because it asks for more room in front of the label than there is room at all and there is no reading of that a caller meant. So is a third, and so is anything that is not a number, which is what gcc does with each of them.

type Err = ()

The associated error which can be returned from parsing.

impl Hash for Patchable

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 Ord for Patchable

fn cmp(&self, other: &Patchable) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Patchable

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Patchable

fn partial_cmp(&self, other: &Patchable) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Patchable