I've been trying to figure out an issue I'm seeing and I'm scratching my head at this point.
My issue: 1. Interrupt handler (in a file that has just the interrupt handler) is not getting linked properly. the weak definition is getting used instead.
My setup: 1. Startup code where interrupt handler is getting defined (.s file) is made into a library (startup.a) This startup code has a weak definition of the interrupt vectors.
__Vectors ... DCD NVIC_IsrHandler0 ... Default_Handler PROC EXPORT NVIC_IsrHandler0 [WEAK] ... NVIC_IsrHandler0 B . ENDP ...
2. In another library (C++ code) I do the following (libIsrHandler.a)( interrupts.cpp)
extern "C" NVIC_IsrHandler0(void) { ... my isr code }
3. I link my code using --userlib libIsrHandler --userlib startup.a
4. The the output/map file I see that the weak definition is used instead.
5. Other parts of my code uses libStartup.a for other interrupt vectors
6. Within libIsrHandler, there are other C++ files that uses other ISR's which properly gets linked (since they have other functions other than interrupt handler that get referenced)
Questions/Observations: 1. How does Keil linker handle library order? I read how Keil scans libraries, but didn't find much information on how it handles ordering. In GNU it's left to right.
2. If two libraries have circular dependencies, how is this worked out by Keil? In GCC/GNU, you can list the library twice but in ARM KEIL I see warning "file input ignored... " on the second mention of library.
3. __irq keyword did not make a difference. What I'm confused about is that the ISR handlers that are in files with functions that get referenced will get linked properly. For example fileX.cpp has function Init and fileY.cpp calls Init and these files are within libIsrHandler.a, the ISR hanlders in those files will get linked properly.
4. It seems like files that has only the interrupt handler and no other functions(CPP), linker is ignoring them and picking the weak definition instead... this is odd even with __irq. infocenter.arm.com/.../BABICJBC.html mentiones ARMV7 doesn't care about __irq .
In ARMv6-M and ARMv7-M, specifying __irq does not affect the behavior of the compiled output. However, ARM recommends using __irq on exception handlers for clarity and easier software porting.
5. My understanding of how the linker works is it scans the first library, creates a symbol table, scans the next library and completes the symbol table based on the new symbols and fills any undef or weak if needed. I'm listing libIsrHandler first then startup.a . I have tried swapping the order but didn't make a difference.
Thanks.
Correction:
Interrupt Handler not getting *Linked*
Per 4, you'd need something in interrups.cpp that is imported/required by other code. This is so a library could contain multi similar files and the linker could cherry pick the one it wants, or first encounters.
Dead code elimination assumes no one NEEDS it
Use objects not libraries
Marking the function as used should keep it from being eliminated as dead code.
www.keil.com/.../armclang_ref_chr1359124978363.htm
gcc.gnu.org/.../Common-Function-Attributes.html
So is used attribute required with interrupts if they are in a separate library?
Would the ordering of how libraries are passed to the linker make a difference on this case? If not , why?
Sorry but I don't fully know the answer. The page may help (I included a small portion, but there is more fully explaining why when you had other stuff it work and why when the only thing was the function you wanted to override the isr with did not work. Just a note, this is not at all related to being interrupt functions. This is related to how weak references handled.
The linker does not load an object from a library to resolve a weak reference. It is able to resolve the weak reference only if the definition is included in the image for other reasons. The weak reference does not cause the linker to mark the section containing the definition as used, so it might be removed by the linker as unused.
www.keil.com/.../armlink_pge1362065917715.htm
Also it is not 100% clear from reading this that it will work with libraries. I use the "used" attribute on functions that are part of object files and this "fixes" the issues I have had like this.
The difference between the files that include the interrup without used keyword vs the file that don't is:
Files with interrupt included have other functions ,that are referenced in other files.
Files with interrupts not getting linked , only have the interrupt functions
Thanks for the info, will play around with used and see what happens
If you call a function in a file, then it is automatically "used". But you don't formally call an ISR.
Understood, my point was that if a file that has isr function, as well as other functions(non isr) that are getting called, the isr function will be kept and used.
However, if a file that has only isr functions , the isr functions will not get linked.