Does XC8 compiler support weak symbols?

Question

gcc has __attribute__((weak)) which allows to create a weak symbol such as a function. This allows the user to redefine a function. I would like to have the same behavior in XC8.

More info:

I am writing a driver for XC8 and I would like to delegate low level initialization to a user defined function.

I know it is possible to redefine a function: there is the putch function that is implemented in XC8's source file and which is called by the printf function. The user is allowed to reimplement putch inside his application. There are two functions with the same name, but no error is raised.

putch 's implementation in XC8's source files has a comment saying "Weak implementation. User implementation may be required", so it must be possible.

I looked at pragmas in XC8's user guide, but there is no directive related to this question.

Answer 1

A linker will only search static libraries to resolve a symbol that is not already resolved by input object files, so replacing static library functions can be done without weak linkage. Weak linkage is useful for code provided as source or object code rather then as a static library.

So if no weak linkage directive is supported, you could create a static library for the "weak" symbols and link that.

The XC8 manual documents behaviour for both the IAR compatibility directive __weak and a weak pragma, and in both cases the directives are ignored (supported only in XC16 and XC32), so you will have to use the above suggested method, which is in any case far more portable - if somewhat inconvenient.

In the case of putch() I suspect that this is not working as you believe. I would imagine that this is not a matter of weak linkage at all; in the static library containing printf() an unresolved link to putch() exists, and the linker resolves it with whatever you provide; if you were to compile and link both the Microchip implementation and yours from source code you would get a linker error; equally if you were to provide no implementation whatsoever you would get a linker error.

Answer 2

XC8 compiler does support the "weak" attribute.

The weak attribute causes the declaration to be emitted as a weak symbol. A weak symbol indicates that if a global version of the same symbol is available, that version should be used instead. When the weak attribute is applied to a reference to an external symbol, the symbol is not required for linking.

For example:

extern int __attribute__((weak)) s;

int foo(void) 
{
    if (&s)
        return s;
    return 0;   /* possibly some other value */
}

In the above program, if s is not defined by some other module, the program will still link but s will not be given an address. The conditional verifies that s has been defined (and returns its value if it has). Otherwise '0' is returned. There are many uses for this feature, mostly to provide generic code that can link with an optional library.

A variable can also be qualified with the "weak" attribute.

For example:

char __attribute__((weak)) input;
char input __attribute__((weak));