Struct Linkage 

pub struct Linkage {
    pub exported: bool,
    pub section: Option<String>,
    pub secflags: Option<String>,
    pub thread_local: bool,
}

Linkage of a function or data defintion (e.g. section and private/public status)

Fields

exported: bool

Specifies whether the target is going to be accessible publicly

section: Option<String>

Specifies target’s section

secflags: Option<String>

Specifies target’s section flags

thread_local: bool

Specifies whether the target is stored in thread-local storage

Implementations

impl Linkage

pub fn private() -> Linkage

Returns the default configuration for private linkage

Examples found in repository

examples/hello_world.rs (line 7)

fn generate_add_func(module: &mut Module) {
    let mut func = Function::new(
        Linkage::private(),
        "add",
        vec![
            (Type::Word, Value::Temporary("a".into())),
            (Type::Word, Value::Temporary("b".into())),
        ],
        Some(Type::Word),
    );

    func.add_block("start");
    func.assign_instr(
        Value::Temporary("c".into()),
        Type::Word,
        Instr::Add(Value::Temporary("a".into()), Value::Temporary("b".into())),
    );
    func.add_instr(Instr::Ret(Some(Value::Temporary("c".into()))));

    module.add_function(func);
}

fn generate_main_func(module: &mut Module) {
    let mut func = Function::new(Linkage::public(), "main", Vec::new(), Some(Type::Word));

    func.add_block("start");
    func.assign_instr(
        Value::Temporary("r".into()),
        Type::Word,
        Instr::Call(
            "add".into(),
            vec![(Type::Word, Value::Const(1)), (Type::Word, Value::Const(1))],
            None,
        ),
    );
    func.add_instr(Instr::Call(
        "printf".into(),
        vec![
            (Type::Long, Value::Global("fmt".into())),
            (Type::Word, Value::Temporary("r".into())),
        ],
        Some(1),
    ));
    func.add_instr(Instr::Ret(Some(Value::Const(0))));

    module.add_function(func);
}

fn generate_data(module: &mut Module) {
    let items = vec![
        (Type::Byte, DataItem::Str("One and one make %d!\\n".into())),
        (Type::Byte, DataItem::Const(0)),
    ];
    let data = DataDef::new(Linkage::private(), "fmt", None, items);
    module.add_data(data);
}

pub fn private_with_section(section: impl Into<String>) -> Linkage

Returns the configuration for private linkage with a provided section

pub fn public() -> Linkage

Returns the default configuration for public linkage

Examples found in repository

examples/hello_world.rs (line 28)

fn generate_main_func(module: &mut Module) {
    let mut func = Function::new(Linkage::public(), "main", Vec::new(), Some(Type::Word));

    func.add_block("start");
    func.assign_instr(
        Value::Temporary("r".into()),
        Type::Word,
        Instr::Call(
            "add".into(),
            vec![(Type::Word, Value::Const(1)), (Type::Word, Value::Const(1))],
            None,
        ),
    );
    func.add_instr(Instr::Call(
        "printf".into(),
        vec![
            (Type::Long, Value::Global("fmt".into())),
            (Type::Word, Value::Temporary("r".into())),
        ],
        Some(1),
    ));
    func.add_instr(Instr::Ret(Some(Value::Const(0))));

    module.add_function(func);
}

pub fn public_with_section(section: impl Into<String>) -> Linkage

Returns the configuration for public linkage with a provided section

pub fn thread_local() -> Linkage

pub fn exported_thread_local() -> Linkage

pub fn thread_local_with_section(section: impl Into<String>) -> Linkage

Trait Implementations

impl Clone for Linkage

fn clone(&self) -> Linkage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Linkage

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

Formats the value using the given formatter.

impl Default for Linkage

fn default() -> Linkage

Returns the “default value” for a type.

impl Display for Linkage

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

Formats the value using the given formatter.

impl Hash for Linkage

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 Linkage

fn cmp(&self, other: &Linkage) -> 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.

impl PartialEq for Linkage

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Linkage

fn partial_cmp(&self, other: &Linkage) -> 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 Eq for Linkage

impl StructuralPartialEq for Linkage