Hi, I made a library. when i build executable using library, the map file created shows all functions/variables of library.
Can i strip the library, so that only functions used by executable are visible in map file ?
or when i build library, i can somehow achieve the same by some settings ?
thanks in advance for your time.
regards, -rajan batra
It doesn't sound like the question is about obfuscation, but about how to only link in the functions that are actually used.
The most common method for that is to split the library source code into many separate source files, so the library consists of many small object files - the linker will then only pick up the object files that are needed to fulfill any accesses to symbols within the individual object files. So the map file will then only mention symbols existing in the object files that was actually used.
It's a very long time since I last used C51 tools - you have to check if the linker has any suitable special features to extract only parts of the contents of the individual object files from the library or if it's only possible to link in full object files.
Perhaps, I keyed off the "visibility" cue.
If this is more of a dead code elimination question, then the trick with libraries is to break the objects inside into the smallest possible pieces. Some ARM/X86 tools do this using a section-per-function option for the compiler. Others do it by creating a file-per-function. Either way the goal is to allow the linker to determine the actual dependencies, and throw out everything that isn't used/required.
If the linker isn't that smart you'd need to generate your own dependency trees, and apply that knowledge to the source and librarian tools, and remove as much cruft as possible before letting the linker do it's thing.
Hi Per, looking at .map file linker is generating, i am able to see those functions/global variables which are not used by final executable.
This probably is happening because at time of linking, i am giving bank0.LIB, bank1.LIB, bank2.LIB, bank3.LIB , bank4.LIB, bank5.LIB , bank6.LIB for linking with main function code in bank7.
As per your comment, it seems like, to avoid seeing all functions in .map , Linking should have only one .LIB and final code in bank7.
Total code in .LIB will greater then bank capacity. so final compiling will give me Bank overflow error.
regards,
Hi Pier, Since i am having 7 .LIB files to be linked in to executable, MAP file created by linker will contain all functions/variables referred between 7 .LIB
As per your suggestion, i will have to make one single .LIB for final linking. Size of this One .LIB will be greater then single bank size. so in final linking,using keil, i will get warning of .LIB being greater then bank.
I am using LX51, LX51 creates single HEX format executable as output. Currently i split it into 8 banks before flashing.
If i could build final executable without assigning .LIB to any bank, i can build my code into one big .LIB .
so the question is
is it possible to build program in KEIL without assigning bank to .LIB.
regards, -rajan
No. Please read slower and think carefully about what has been said in this thread.
If you want the map file not not mention symbols that aren't used by the program, the way to do it is to make sure that the linker doesn't include any code that isn't needed.
The way to do that is _normally_ to make sure that the LIB file is a container of many small object files - each object file generated from a source file that only contains a single function.
The linker will then see the library, but will only bring in any object file that contains a required symbol. All other object files will be ignored, so any symbols in them will not be part of the resulting binary. And so will not show up in the map file.
And as also previously mentioned - some compilers happens to have a compiler switch where individual functions in a source file can be placed into individual sections inside a single object file, to allow the linker to not bring in the full object file but just extract individual sections from the object file. This is a feature that at least GCC has, but maybe other compilers/linkers can manage similarly.
Anyway - to get less symbols mentioned in the map file, you need to give the linker an ability to not include any symbols that aren't needed. So it's all a question of granularity of the blocks that the linker grabs object data from. It has nothing to do with you having one or seven libraries. It has all to do with the contents of the libraries - how small pieces each individual library file can be splitted into by the linker.
Hi Pier, I got the point. This would be uphill task for current project size. i was looking for more automated way of doing, some linker settings.