Enum inkwell::module::Linkage

pub enum Linkage {
    Appending,
    AvailableExternally,
    Common,
    DLLExport,
    DLLImport,
    External,
    ExternalWeak,
    Ghost,
    Internal,
    LinkerPrivate,
    LinkerPrivateWeak,
    LinkOnceAny,
    LinkOnceODRAutoHide,
    LinkOnceODR,
    Private,
    WeakAny,
    WeakODR,
}

This enum defines how to link a global variable or function in a module. The variant documentation is mostly taken straight from LLVM’s own documentation except for some minor clarification.

It is illegal for a function declaration to have any linkage type other than external or extern_weak.

All Global Variables, Functions and Aliases can have one of the following DLL storage class: DLLImport & DLLExport.

Variants

Appending

Appending linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the LLVM, typesafe, equivalent of having the system linker append together “sections” with identical names when .o files are linked. Unfortunately this doesn’t correspond to any feature in .o files, so it can only be used for variables like llvm.global_ctors which llvm interprets specially.

AvailableExternally

Globals with AvailableExternally linkage are never emitted into the object file corresponding to the LLVM module. From the linker’s perspective, an AvailableExternally global is equivalent to an external declaration. They exist to allow inlining and other optimizations to take place given knowledge of the definition of the global, which is known to be somewhere outside the module. Globals with AvailableExternally linkage are allowed to be discarded at will, and allow inlining and other optimizations. This linkage type is only allowed on definitions, not declarations.

Common

Common linkage is most similar to “weak” linkage, but they are used for tentative definitions in C, such as “int X;” at global scope. Symbols with Common linkage are merged in the same way as weak symbols, and they may not be deleted if unreferenced. Common symbols may not have an explicit section, must have a zero initializer, and may not be marked ‘constant’. Functions and aliases may not have Common linkage.

DLLExport

DLLExport causes the compiler to provide a global pointer to a pointer in a DLL, so that it can be referenced with the dllimport attribute. On Microsoft Windows targets, the pointer name is formed by combining _imp and the function or variable name. Since this storage class exists for defining a dll interface, the compiler, assembler and linker know it is externally referenced and must refrain from deleting the symbol.

DLLImport

DLLImport causes the compiler to reference a function or variable via a global pointer to a pointer that is set up by the DLL exporting the symbol. On Microsoft Windows targets, the pointer name is formed by combining _imp and the function or variable name.

External

If none of the other identifiers are used, the global is externally visible, meaning that it participates in linkage and can be used to resolve external symbol references.

ExternalWeak

The semantics of this linkage follow the ELF object file model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference.

Ghost

FIXME: Unknown linkage type

Internal

Similar to private, but the value shows as a local symbol (STB_LOCAL in the case of ELF) in the object file. This corresponds to the notion of the ‘static’ keyword in C.

LinkerPrivate

FIXME: Unknown linkage type

LinkerPrivateWeak

FIXME: Unknown linkage type

LinkOnceAny

Globals with LinkOnceAny linkage are merged with other globals of the same name when linkage occurs. This can be used to implement some forms of inline functions, templates, or other code which must be generated in each translation unit that uses it, but where the body may be overridden with a more definitive definition later. Unreferenced LinkOnceAny globals are allowed to be discarded. Note that LinkOnceAny linkage does not actually allow the optimizer to inline the body of this function into callers because it doesn’t know if this definition of the function is the definitive definition within the program or whether it will be overridden by a stronger definition. To enable inlining and other optimizations, use LinkOnceODR linkage.

LinkOnceODRAutoHide

FIXME: Unknown linkage type

LinkOnceODR

Some languages allow differing globals to be merged, such as two functions with different semantics. Other languages, such as C++, ensure that only equivalent globals are ever merged (the “one definition rule” — “ODR”). Such languages can use the LinkOnceODR and WeakODR linkage types to indicate that the global will only be merged with equivalent globals. These linkage types are otherwise the same as their non-odr versions.

Private

Global values with Private linkage are only directly accessible by objects in the current module. In particular, linking code into a module with a private global value may cause the private to be renamed as necessary to avoid collisions. Because the symbol is private to the module, all references can be updated. This doesn’t show up in any symbol table in the object file.

WeakAny

WeakAny linkage has the same merging semantics as linkonce linkage, except that unreferenced globals with weak linkage may not be discarded. This is used for globals that are declared WeakAny in C source code.

WeakODR

Some languages allow differing globals to be merged, such as two functions with different semantics. Other languages, such as C++, ensure that only equivalent globals are ever merged (the “one definition rule” — “ODR”). Such languages can use the LinkOnceODR and WeakODR linkage types to indicate that the global will only be merged with equivalent globals. These linkage types are otherwise the same as their non-odr versions.

Trait Implementations

impl Clone for Linkage

fn clone(&self) -> Linkage

Returns a copy 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 From<LLVMLinkage> for Linkage

fn from(src: LLVMLinkage) -> Self

Converts to this type from the input type.

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 Into<LLVMLinkage> for Linkage

fn into(self) -> LLVMLinkage

Converts this type into the (usually inferred) input type.

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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Linkage

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Linkage

impl Eq for Linkage

impl StructuralPartialEq for Linkage