[ARM]__weak 的用法

debug的时候，忽然发现这个函数没有函数实现的地方，只有函数的调用和声明。

仔细看了看这个函数的定义，前面居然有一个__weak,得，查查看看__weak是干什么的吧。

走后面是从ARM网站搜到的，偶也！

读完之后呢，大概总结两点：

1. 带__weak的函数，不一定非得有函数实现。有就最好了，当non-weak一样处理。如果没有函数实现，请看第二点。

2. 如果没有函数实现体，linker会把这个函数处理成nop或者BL到下一条语句。

 

真的是这样吗？得自己动手看看才行，实践出真知嘛！罗德巴赫伺候！！！

看到了吧，那个高亮的2039行有两个nop出现，到底是不是我们那个函数呢？去代码看看喽！

果然，2039行正是我们那个朝思暮想的函数。

好啦，到此为止，休息一会！

------------------------------------------------------------------------------------------------------------------------------

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

How does __weak work?

Applies to: DS-5, RealView Development Suite (RVDS)

Answer

The ARM compilation tools support the concept of "weak" references and definitions.  These can provide additional flexibility in the way the linker includes various (typically library) functions and variables in a build.

Weak references

If the linker can not resolve normal (non-weak) references to symbols included in the link, it will attempt to do so by finding the symbol in a library, and report an error if it can not.  Once such a reference has been resolved, the section it is resolved to is marked as used, so will not later be removed by the linker as an unused section.  Each non-weak reference must be resolved by exactly one definition (if there are multiple definitions, the linker will also report an error). 

Function or variable declarations in C source files can be marked with the__weak qualifier.  As with extern, this qualifier tells the compiler that a function or variable is declared in another compilation unit (source file).  As the definition of this function/variable may not be available to compiler, it creates a (weak) reference to be resolved by the linker.

The compiler will not load an object from a library in order to resolve a weak reference.  It will only be able to resolve the weak reference if the definition will be included in the image for other reasons.  The weak reference will not cause the linker to mark the section containing the definition as used, so it may be removed by the linker as unused.  The definition may already exist in the image for several reasons:

1. The symbol is strongly referenced somewhere else in the code.
2. The symbol definition exists in the same ELF section as a symbol definition that is included for any of these reasons^*.
3. The symbol definition is in a section that has been specified using --keep, or contains an ENTRY point.
4. The symbol definition is in an object file included in the link (not a libary unless the object within the library has been explicitly included on the link line), and the--no_remove option is used.

In summary, a weak reference will be resolved if the definition is already included in the image, but will not affect whether or not that definition is included.

An unresolved weak function call will be replaced either with a NOP (no-operation instruction), or a BL (Branch with link instruction) to the following instruction - effectively the function call just does not happen.

Example usage:

A library contains a function foo(), that will be called in some builds of an application but not in others.  If it is used,init_foo() must be called first.  Weak references can be used to "automate" the call toinit_foo().

The library can define init_foo() and foo() in the the same ELF section^*.  The application initialisation code should call init_foo()weakly.  Now if the application includes foo() for any reason, it will also includeinit_foo() and this will be called from the initialisation code.  In any builds that do not includefoo(), the call to init_foo()will be removed by the linker.

In this scenario, there is no need to rebuild the initialisation code between builds that includefoo() and don't include foo().  There is also no possibility of accidentally building an application with a version of the initialisation code that does not callinit_foo(), and other parts of the application that callfoo().

foo.c (typically built into a library):

void init_foo()
{
  // Some initialisation code
}

void foo()
{
  // A function that is included in some builds
  // and requires init_foo() to be called first.
}

init.c:

__weak void init_foo(void);

int main(void)
{
  init_foo();
  // Rest of code that may make calls foo() directly or indirectly.
}

Weak references can also be generated by the assembler:

init.s:

      IMPORT init_foo WEAK

      AREA init, CODE, readonly

      BL init_foo

      ;Rest of code

      END

Weak Definitions

A function definition (or EXPORTed label in assembler) can also be marked as weak, as can a variable definition.  In this case, a weak symbol definition is created in the object file.

A weak definition can be used to resolve any reference to that symbol in the same way as a normal definition.  However, if another (non-weak) definition of that symbol exists in the build, the linker will use that definition instead of the weak definition, and not produce an error due to multiply-defined symbols.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

------------------------------------------------------------------------------------------------------------------------------