This keyword instructs the compiler to export symbols weakly.
The __weak keyword can be applied to function and variable declarations,
and to function definitions.
Usage
Functions and variable declarations
For declarations, this storage class specifies an extern
object declaration that, even if not present, does not cause the linker to fault an
unresolved reference.
For example:
__weak void f(void);
...
f(); // call f weakly
If the reference to a missing weak function is made from code that compiles to a
branch or branch link instruction, then either:
The reference is resolved as branching to the next instruction. This
effectively makes the branch a NOP.
The branch is replaced by a NOP instruction.
Function definitions
Functions defined with __weak export their symbols weakly. A
weakly defined function behaves like a normally defined function unless a nonweakly
defined function of the same name is linked into the same image. If both a nonweakly
defined function and a weakly defined function exist in the same image then all calls
to the function resolve to call the nonweak function. If multiple weak definitions are
available, the linker generates an error message, unless the linker option
--muldefweak is used. In this case, the linker chooses one for use
by all calls.
Functions declared with __weak and then defined without
__weak behave as nonweak functions.
Restrictions
There are restrictions when you qualify function and variable declarations, and function
definitions, with __weak.
Functions and variable declarations
A function or variable cannot be used both weakly and nonweakly in the same
compilation. For example, the following code uses f() weakly from
g() and h():
It is not possible to use a function or variable weakly from the same compilation
that defines the function or variable. The following code uses f()
nonweakly from h():
The linker does not load the function or variable from a library unless another
compilation uses the function or variable nonweakly. If the reference remains
unresolved, its value is assumed to be NULL. Unresolved references,
however, are not NULL if the reference is from code to a
position-independent section or to a missing __weak
function.
Function definitions
Weakly defined functions cannot be inlined.
Example
__weak const int c; // assume 'c' is not present in final link
const int *f1() { return &c; } // '&c' returns non-NULL if
// compiled and linked /ropi
__weak int i; // assume 'i' is not present in final link
int *f2() { return &i; } // '&i' returns non-NULL if
// compiled and linked /rwpi
__weak void f(void); // assume 'f' is not present in final link
typedef void (*FP)(void);
FP g() { return f; } // 'g' returns non-NULL if
// compiled and linked /ropi
Arm’s Privacy Policy has been updated. By continuing to use our site, you consent to Arm’s Privacy Policy. Please review our Privacy Policy to learn more about our collection, use and transfers of your data.