4.1.19. __weak

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 non weakly defined function of the same name is linked into the same image. If both a non weakly defined function and a weakly defined function exist in the same image then all calls to the function resolve to call the non weak function. If multiple weak definitions are available, the linker chooses one for use by all calls.

Functions declared with __weak and then defined without __weak behave as non weak 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 non weakly in the same compilation. For example the following code uses f() weakly from g() and h():

void f(void);
void g()
{
    f();
}

__weak void f(void);
void h()
{
    f();
}

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() non weakly from h():

__weak void f(void);
void h()
{
    f();
}
void f() {}

The linker does not load the function or variable from a library unless another compilation uses the function or variable non weakly. 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

See also

Copyright © 2007, 2010 ARM Limited. All rights reserved.ARM DUI 0348A
Non-Confidential