why my executable is bigger after linking

Question

I have a small C program which I need to run on different chips. The executable should be smaller than 32kb. For this I have several toolchains with different compilers for arm, mips etc.

The program consists of several files which each is compiled to an object file and then linked together to an executable.

When I use the system gcc (x86) my executable is 15kb big. With the arm toolchain the executable is 65kb big. With another toolchain it is 47kb.

For example for arm all objects which are included in the executable are 14kb big together.

The objects are compiled with the following options:

-march=armv7-m -mtune=cortex-m3 -mthumb -msoft-float -Os

For linking the following options are used:

-s -specs=nosys.specs -march-armv7-m

The nosys.specs library is 274 bytes big.

Why is my executable still so much bigger (65kb) when my code is only 14kb and the library 274 bytes?

Update:

After suggestions from the answer I removed all malloc and printf commands from my code and removed the unused includes. Also I added the compile flags -ffunction-sections -fdata-sections and linking flag --gc-sections , but the executable is still too big.

For experimenting I created a dummy program:

int main()
{
    return 1;
}

When I compile the program with different compilers I get very different executable sizes:

8.3 KB : gcc -Os
22 KB  : r2-gcc -Os
40 KB  : arm-gcc --specs=nosys.specs -Os
1.1 KB : avr-gcc -Os

So why is my arm-gcc executable so much bigger? The avr-gcc executable does static linking as well, I guess.

first off what file format is this, is it a raw binary image or is it like an elf or coff or exe or whatever? The file size for pretty much all formats is not necessarily a direct indicator of the actually binary that matters. for x86 vs arm there is likely some dynamic libraries vs static. — old_timer
Maybe start by looking at your linker map file output - that should give you an idea of what's being linked into the image and hogging all the memory. I could speculate, but it would be just that -- speculation... — Dan
Is your x86 build hosted? i.e. is it built to run on an full GPOS such as WIndows or Linux? A free-standing application must have all its I/O and library code statically linked, wheres a GPOS will support dynamic linking to standard and OS libraries and much of the I/O functionality will be provided by the OS. — Clifford
x86 build is hosted indeed and the other compilers do static linking (I guess). But for example why is my exec for amtel chip (avr-gcc compiler) so much smaller than arm-gcc? — mjspier

Unknown Unknown · Accepted Answer · 2016-08-26T18:15:13

Your x86 executable is probably being dynamically linked, so any standard library functions you use -- malloc, printf, string and math functions, etc -- are not included in the binary.

The ARM executable is being statically linked, so those functions must be included in your binary. This is why it's larger. To make it smaller, you may want to consider compiling with -ffunction-sections -fdata-sections, then linking with --gc-sections to discard any unused functions or data from your binary.

(The "nosys.specs library" is not a library. It's a configuration file. The real library files are elsewhere.)

why my executable is bigger after linking

2 Answers