|
Weak symbolA weak symbol denotes a specially annotated symbol during linking of Executable and Linkable Format (ELF) object files. By default, without any annotation, a symbol in an object file is strong. During linking, a strong symbol can override a weak symbol of the same name. In contrast, in the presence of two strong symbols by the same name, the linker resolves the symbol in favor of the first one found. This behavior allows an executable to override standard library functions, such as malloc(3). When linking a binary executable, a weakly declared symbol does not need a definition. In comparison, (by default) a declared strong symbol without a definition triggers an undefined symbol link error. Weak symbols are not mentioned by the C or C++ language standards; as such, inserting them into code is not very portable. Even if two platforms support the same or similar syntax for marking symbols as weak, the semantics may differ in subtle points, e.g. whether weak symbols during dynamic linking at runtime lose their semantics or not.[1] SyntaxThe GNU Compiler Collection and the Solaris Studio C compiler share the same syntax for annotating symbols as weak, namely a special #pragma, Pragma// function declaration
#pragma weak power2
int power2(int x);
Attribute// function declaration
int __attribute__((weak)) power2(int x);
// or
int power2(int x) __attribute__((weak));
// variable declaration;
extern int __attribute__((weak)) global_var;
Tools supportThe nm command identifies weak symbols in object files, libraries, and executables. On Linux a weak function symbol is marked with "W" if a weak default definition is available, and with "w" if it is not. Weakly defined variable symbols are marked with "V" and "v". On Solaris "nm" prints "WEAK" instead of "GLOB" for a weak symbol. ExamplesThe following examples work on Linux and Solaris with GCC and Solaris Studio. Static examplemain.c: #include <stdio.h>
#include <stdlib.h>
#include "power_slow.h"
int main(int argc, char **argv)
{
fprintf(stderr, "power3() = %d\n", power3(atoi(argv[1])));
return 0;
}
power_slow.h: #ifndef POWER2_SLOW_H
#define POWER2_SLOW_H
// alternative syntax
// #pragma weak power2
int
__attribute__((weak))
power2(int x)
// alternatively after symbol
// __attribute__((weak))
;
int power3(int x);
#endif
power_slow.c: #include <stdio.h>
#include "power_slow.h"
int power2(int x)
{
fprintf(stderr, "slow power2()\n");
return x*x;
}
int power3(int x)
{
return power2(x)*x;
}
power.c: #include <stdio.h>
int power2(int x)
{
fprintf(stderr, "fast power2()\n");
return x*x;
}
Build commands: cc -g -c -o main.o main.c cc -g -c -o power_slow.o power_slow.c cc -g -c -o power.o power.c cc main.o power_slow.o -o slow cc main.o power_slow.o power.o -o fast Output: $ ./slow 3
slow power2()
power3() = 27
$ ./fast 3
fast power2()
power3() = 27
When removing the weak attribute and re-executing the build commands, the last one fails with the following error message (on Linux): multiple definition of `power2' The second-last one still succeeds, and If there are no definition for a weak symbol function as a default implementation or as another weak symbol function definition or a strong symbol function definition in any of the object files linked together, the linking will be done successfully without any undefined symbol error for that weak symbol, but the execution may cause runtime crash. Shared exampleTaking main.c from the preceding example and adding: #ifndef NO_USER_HOOK
void user_hook(void)
{
fprintf(stderr, "main: user_hook()\n");
}
#endif
Replacing power_slow.c with: #include <stdio.h>
#include "power_slow.h"
void __attribute__((weak)) user_hook(void);
#ifdef ENABLE_DEF
void user_hook(void)
{
fprintf(stderr, "power_slow: user_hook()\n");
}
#endif
int power2(int x)
{
if (user_hook) // only needed ifndef ENABLE_DEF
user_hook();
return x*x;
}
int power3(int x)
{
return power2(x)*x;
}
Build commands: cc -g -c -o main.o main.c
cc -g -fpic -c -o power_slow.po power_slow.c
cc -shared -fpic -o libpowerslow.so power_slow.po
cc main.o -L`pwd` -Wl,-R`pwd` -lpowerslow -o main
cc -g -DENABLE_DEF -fpic -c -o power_slow.po power_slow.c
cc -shared -fpic -o libpowerslow.so power_slow.po
cc main.o -L`pwd` -Wl,-R`pwd` -lpowerslow -o main2
cc -g -DNO_USER_HOOK -c -o main.o main.c
cc -g -fpic -c -o power_slow.po power_slow.c
cc -shared -fpic -o libpowerslow.so power_slow.po
cc main.o -L`pwd` -Wl,-R`pwd` -lpowerslow -o main3
cc -g -DNO_USER_HOOK -c -o main.o main.c
cc -g -DENABLE_DEF -fpic -c -o power_slow.po power_slow.c
cc -shared -fpic -o libpowerslow.so power_slow.po
cc main.o -L`pwd` -Wl,-R`pwd` -lpowerslow -o main4
Output: $ ./main 3
main: user_hook()
power3() = 27
$ ./main2 3
main: user_hook()
power3() = 27
$ ./main3 3
power3() = 27
$ ./main4 3
power_slow: user_hook()
power3() = 27
Removing the weak attribute and re-executing the build commands does not yield build errors and leads to the same output (on Linux) for warning: the address of ‘user_hook’ will always evaluate as ‘true’ libpowerslow.so: undefined reference to `user_hook' The warning is issued by the compiler because it can statically determine that in Use casesWeak symbols can be used as a mechanism to provide default implementations of functions that can be replaced by more specialized (e.g. optimized) ones at link-time. The default implementation is then declared as weak, and, on certain targets, object files with strongly declared symbols are added to the linker command line. If a library defines a symbol as weak, a program that links that library is free to provide a strong one for, say, customization purposes. Another use case for weak symbols is the maintenance of binary backward compatibility. LimitationsOn UNIX System V descendent systems, during program runtime the dynamic linker resolves weak symbols definitions like strong ones. For example, a binary is dynamically linked against libraries libfoo.so and libbar.so. libfoo defines symbol When using constructs like #pragma weak func
void func();
void bar()
{
if (func)
func();
}
, depending on the compiler and used optimization level, the compiler may interpret the conditional as always true (because Using weak symbols in static libraries has other semantics than in shared ones, i.e. with a static library the symbol lookup stops at the first symbol – even if it is just weak and an object file with a strong symbol is also included in the library archive. On Linux, the linker option The weak function attribute is supposed to be used on function declarations. Using it on a function definition may yield unexpected results, depending on the compiler and optimization level.[11] In Solaris, the weak symbols are also used within kernel. The generic part of kernel (called Related methodsC preprocessor (CPP) conditional constructs can also be used to switch between different versions of a symbol. The difference from weak symbols is that weak symbols are interpreted by the linker. The CPP is run during the compilation of each translation unit before the C compiler. The build process (e.g. make) can be implemented in a conditional way such that just different versions of a symbol are created or different (specialized) libraries are used and linked depending on the target. See alsoReferences
|