diff options
Diffstat (limited to '_posts/2019-07-12-arm-bare-metal-flags.md')
| -rw-r--r-- | _posts/2019-07-12-arm-bare-metal-flags.md | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/_posts/2019-07-12-arm-bare-metal-flags.md b/_posts/2019-07-12-arm-bare-metal-flags.md new file mode 100644 index 0000000..7323819 --- /dev/null +++ b/_posts/2019-07-12-arm-bare-metal-flags.md @@ -0,0 +1,360 @@ +--- +title: Bare Metal ARM - Compiler flag analysis +language: en +--- + +So... I'm doing software development for microcontrollers at work with a commercial +toolchain. I also evaluated the arm-none-eabi-gcc toolchain in the past (briefly). + +One thing that continues to confuse me is the different compiler and linker options +used in various online examples, tutorials and library Makefiles. + +What I especially wanted to know is: What happens before `main()` with each +combination of options? Do the variables get initialized (i.e. does the `.data` +section get copied from flash to RAM) and is the `.bss` section properly zeroed? + +*TL;DR: See last paragraph* + + +Some libraries, e.g. the [libopencm3 project][locm], as well as the [ARM CMSIS][cmsis] +contain explicit startup code that do these tasks. + +This post uses the latest version of the [GNU embedded toolchain for ARM][1]. +At the time of writing, that's 8‑2019‑q3‑update. + +This post will take a look at: +- using `-nostartfiles` vs. not using it +- using nano.specs vs. nosys.specs vs. not using any specs file + +I start with a simple `main()` function that should suffice to analyze what I want. +This example *won't* run on an actual Cortex-M3 microcontroller, since it lacks the vector +table. I might (read: probably not ;)) look into this in a later post. + +I'm gonna use two different variants, one `main()` function that exits/returns and one that +doesn't. Note the latter is the usual case when programming microcontrollers. + +For sake of simplicity, lets do it like this: + +~~~ c +static int zerobss; +static int globalinit = 42; + +int main() { + int localvar = 21; +#ifdef DOEXIT + return 0; +#else + while(1); +#endif +} +~~~ + +To test the effect of various options, I wrote the following bash script which loops over all +combinations: + +~~~ bash +#!/bin/bash +# make.sh + +export PATH=/opt/gcc-arm-none-eabi-8-2019-q3-update/bin/:$PATH + +COMMONFLAGS="-mcpu=cortex-m3 -mthumb " +FILES=main.c +STARTOPT=("" -nostartfiles) +SPECS=("" "-specs=nosys.specs" "-specs=nano.specs") +EXIT=("" "-DDOEXIT") +rm -f *.elf + +for f in $FILES; do + for sf in "${STARTOPT[@]}"; do + for sp in "${SPECS[@]}"; do + for ex in "${EXIT[@]}"; do + # bash substitutions, remove leading -specs= and trailing .specs + specname=${sp:7} + specname=${specname%.specs} + outfile=`basename $f .c`${sf}-${specname}-${ex:2}.elf + arm-none-eabi-gcc $ex $COMMONFLAGS $sf $sp -o $outfile $f 2>/dev/null && echo "Compiling $outfile succeeded" || echo "Compiling $outfile failed" + done + done + + done +done + +arm-none-eabi-size *.elf +~~~ + +I silenced the error output, otherwise it gets too noisy. + +First, the following combinations fail: + +~~~ +Compiling main--.elf failed +Compiling main--DOEXIT.elf failed +Compiling main-nano-.elf failed +Compiling main-nano-DOEXIT.elf failed +~~~ + +In these cases, linking fails because (shortened output) + +~~~ +x/arm-none-eabi/bin/ld: x/arm-none-eabi/lib/thumb/v7-m/nofp/libc.a(lib_a-exit.o): in function `exit': +exit.c:(.text.exit+0x16): undefined reference to `_exit' +x/arm-none-eabi/bin/ld: x/arm-none-eabi/lib/thumb/v7-m/nofp/libc_nano.a(lib_a-exit.o): in function `exit': +exit.c:(.text.exit+0x1a): undefined reference to `_exit' +~~~ + +That is, when neither `-nostartfiles` nor `-specs=nosys.specs` is specified, the function `_exit` gets +referenced without being defined. + +In every other case, the linker emits a warning, since the entry symbol is not defined: + +~~~ +cannot find entry symbol _start; defaulting to 0000000000008000 +~~~ + +So, let's look what we've got (sorted by the arm-none-eabi-size output): + +~~~ + text data bss dec hex filename + 12 4 4 20 14 main-nostartfiles--.elf + 12 4 4 20 14 main-nostartfiles-nano-.elf + 12 4 4 20 14 main-nostartfiles-nosys-.elf + 22 4 4 30 1e main-nostartfiles--DOEXIT.elf + 22 4 4 30 1e main-nostartfiles-nano-DOEXIT.elf + 22 4 4 30 1e main-nostartfiles-nosys-DOEXIT.elf + 932 1096 68 2096 830 main-nosys-.elf + 944 1096 68 2108 83c main-nosys-DOEXIT.elf +~~~ + +Looks interesting. Just using `nosys.specs` seems to add a lot of stuff. + +Let's look at the disassembly of the return vs. loop code. +Since the specs file used makes no difference, use the first file of each group: + +~~~ +$ arm-none-eabi-objdump -S -d main-nostartfiles--.elf main-nostartfiles--DOEXIT.elf + +main-nostartfiles--.elf: file format elf32-littlearm + + +Disassembly of section .text: + +00008000 <main>: +static int zerobss; +static int globalinit = 42; + +int main() { + 8000: b480 push {r7} + 8002: b083 sub sp, #12 + 8004: af00 add r7, sp, #0 + int localvar = 21; + 8006: 2315 movs r3, #21 + 8008: 607b str r3, [r7, #4] +#ifdef DOEXIT + return 0; +#else + while(1); + 800a: e7fe b.n 800a <main+0xa> + +main-nostartfiles--DOEXIT.elf: file format elf32-littlearm + + +Disassembly of section .text: + +00008000 <main>: +static int zerobss; +static int globalinit = 42; + +int main() { + 8000: b480 push {r7} + 8002: b083 sub sp, #12 + 8004: af00 add r7, sp, #0 + int localvar = 21; + 8006: 2315 movs r3, #21 + 8008: 607b str r3, [r7, #4] +#ifdef DOEXIT + return 0; + 800a: 2300 movs r3, #0 +#else + while(1); +#endif +} + 800c: 4618 mov r0, r3 + 800e: 370c adds r7, #12 + 8010: 46bd mov sp, r7 + 8012: bc80 pop {r7} + 8014: 4770 bx lr + +~~~ + +No real surprises here. However: There is no code initializing the `.bss` section, +not copying the `.data` section from flash memory to RAM (as we already could've guessed +from looking at the code size). In these cases, writing the code manually would indeed +be required. + +So, what does `nosys.specs` add? Let's just look at the symbol table of the looping example: + +~~~ +$ arm-none-eabi-objdump -t main-nosys-.elf + +main-nosys-.elf: file format elf32-littlearm + +SYMBOL TABLE: +00008000 l d .init 00000000 .init +0000800c l d .text 00000000 .text +00008388 l d .fini 00000000 .fini +00008394 l d .rodata 00000000 .rodata +00008398 l d .ARM.exidx 00000000 .ARM.exidx +000083a0 l d .eh_frame 00000000 .eh_frame +000183a4 l d .init_array 00000000 .init_array +000183ac l d .fini_array 00000000 .fini_array +000183b0 l d .data 00000000 .data +000187ec l d .bss 00000000 .bss +00000000 l d .comment 00000000 .comment +00000000 l d .debug_aranges 00000000 .debug_aranges +00000000 l d .debug_info 00000000 .debug_info +00000000 l d .debug_abbrev 00000000 .debug_abbrev +00000000 l d .debug_line 00000000 .debug_line +00000000 l d .debug_frame 00000000 .debug_frame +00000000 l d .debug_str 00000000 .debug_str +00000000 l d .ARM.attributes 00000000 .ARM.attributes +00000000 l df *ABS* 00000000 /opt/gcc-arm-none-eabi-8-2019-q3-update/bin/../lib/gcc/arm-none-eabi/8.3.1/thumb/v7-m/nofp/crti.o +00000000 l df *ABS* 00000000 /opt/gcc-arm-none-eabi-8-2019-q3-update/bin/../lib/gcc/arm-none-eabi/8.3.1/thumb/v7-m/nofp/crtn.o +00000000 l df *ABS* 00000000 exit.c +00000000 l df *ABS* 00000000 __call_atexit.c +0000802c l F .text 00000014 register_fini +00000000 l df *ABS* 00000000 crtstuff.c +000083a0 l O .eh_frame 00000000 +00008040 l F .text 00000000 __do_global_dtors_aux +000187ec l .bss 00000001 completed.8885 +000183ac l O .fini_array 00000000 __do_global_dtors_aux_fini_array_entry +00008064 l F .text 00000000 frame_dummy +000187f0 l .bss 00000018 object.8890 +000183a8 l O .init_array 00000000 __frame_dummy_init_array_entry +00000000 l df *ABS* 00000000 /opt/gcc-arm-none-eabi-8-2019-q3-update/bin/../lib/gcc/arm-none-eabi/8.3.1/../../../../arm-none-eabi/lib/thumb/v7-m/nofp/crt0.o +00000000 l df *ABS* 00000000 main.c +00018808 l .bss 00000004 zerobss +000183b4 l O .data 00000004 globalinit +00000000 l df *ABS* 00000000 impure.c +000183c0 l O .data 00000428 impure_data +00000000 l df *ABS* 00000000 init.c +00000000 l df *ABS* 00000000 memset.c +00000000 l df *ABS* 00000000 atexit.c +00000000 l df *ABS* 00000000 fini.c +00000000 l df *ABS* 00000000 lock.c +00000000 l df *ABS* 00000000 __atexit.c +00000000 l df *ABS* 00000000 _exit.c +00000000 l df *ABS* 00000000 crtstuff.c +000083a0 l O .eh_frame 00000000 __FRAME_END__ +00000000 l df *ABS* 00000000 +000183b0 l .fini_array 00000000 __fini_array_end +000183ac l .fini_array 00000000 __fini_array_start +000183ac l .init_array 00000000 __init_array_end +000183a4 l .init_array 00000000 __preinit_array_end +000183a4 l .init_array 00000000 __init_array_start +000183a4 l .init_array 00000000 __preinit_array_start +0001880c g O .bss 00000001 __lock___atexit_recursive_mutex +00018810 g O .bss 00000001 __lock___arc4random_mutex +000187e8 g O .data 00000004 __atexit_recursive_mutex +000082e0 g F .text 00000002 __retarget_lock_close +00018830 g .bss 00000000 _bss_end__ +000187ec g .bss 00000000 __bss_start__ +000183b0 g O .data 00000000 .hidden __dso_handle +00018814 g O .bss 00000001 __lock___env_recursive_mutex +00018818 g O .bss 00000001 __lock___sinit_recursive_mutex +00008394 g O .rodata 00000004 _global_impure_ptr +00008100 g F .text 00000048 __libc_init_array +00008080 g F .text 00000000 _mainCRTStartup +00008000 g F .init 00000000 _init +000082a4 g F .text 00000034 __libc_fini_array +0001881c g O .bss 00000001 __lock___malloc_recursive_mutex +000082fc g F .text 00000002 __retarget_lock_release_recursive +000082f4 g F .text 00000004 __retarget_lock_try_acquire_recursive +00018830 g .bss 00000000 __bss_end__ +000081e8 g F .text 000000b0 __call_exitprocs +00008080 g F .text 00000000 _start +000082f0 g F .text 00000004 __retarget_lock_try_acquire +00008300 g F .text 00000084 __register_exitproc +000082e4 g F .text 00000002 __retarget_lock_close_recursive +000082ec g F .text 00000002 __retarget_lock_acquire_recursive +000187ec g .bss 00000000 __bss_start +00008148 g F .text 000000a0 memset +000080f4 g F .text 0000000c main +000082dc g F .text 00000002 __retarget_lock_init_recursive +00018830 g .bss 00000000 __end__ +000082d8 g F .text 00000002 __retarget_lock_init +00008388 g F .fini 00000000 _fini +00008298 g F .text 0000000c atexit +000183b8 g O .data 00000004 _impure_ptr +000187ec g .data 00000000 _edata +00018830 g .bss 00000000 _end +00018820 g O .bss 00000001 __lock___at_quick_exit_mutex +0000800c g F .text 00000020 exit +000082e8 g F .text 00000002 __retarget_lock_acquire +000082f8 g F .text 00000002 __retarget_lock_release +00008384 g F .text 00000002 _exit +00018824 g O .bss 00000001 __lock___dd_hash_mutex +00018828 g O .bss 00000001 __lock___tz_mutex +00080000 g .comment 00000000 _stack +000183b0 g .data 00000000 __data_start +0001882c g O .bss 00000001 __lock___sfp_recursive_mutex + +~~~ + +In the list, we see `_mainCRTStartup`. This is the code which is responsible +for the tasks we want to be performed. + +We also see the `_exit` function defined (which gets referenced by the startup code). +The disassembly doesn't really surprise, it's a simple infinite loop: + +~~~ +$ arm-none-eabi-objdump --disassemble=_exit main-nosys-.elf + +main-nosys-.elf: file format elf32-littlearm + + +Disassembly of section .init: + +Disassembly of section .text: + +00008384 <_exit>: + 8384: e7fe b.n 8384 <_exit> + +Disassembly of section .fini: + +~~~ + +I'll spare you with further disassembly output, since it's pretty long. + +## Summary + +So, a quick recap: + +* *not* using `-nostartfiles` means the linker fails because `_exit` is not defined + (except when using `nosys.specs` which contains a definition for that function). + While this might sound contradicting at first, this is because the function is + referenced by the startup code. + You could simply define the function yourself, if it's the same as with the commercial + Keil compiler, the signature should be `void _exit(int)`. Hint: Look for "retargeting". +* When using `nosys.specs`, you can omit the `-nostartfiles` option, meaning `.bss` + gets initialized and data copied to ROM. + Note that the program will still not run on a microcontroller, like mentioned above, + because you need the vector table for this. + This will also require a custom linker script, which in turn + means this linker script will have to define the symbols assumed by the startup code + properly. + Hint: using `-Wl,--verbose` with gcc enables verbose linker output, which also shows + the default linker script. + +Some [StackOverflow answers][so1] also reference the option `-ffreestanding`. I found +this makes no difference with my example, however. + +In short: Yes, you need to write the startup code that initializes `.bss` and copies +`.data` from flash to RAM manually when doing bare-metal programming. + + +[1]: https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads +[locm]: https://github.com/libopencm3/libopencm3 +[cmsis]: https://github.com/ARM-software/CMSIS_5 +[so1]: https://stackoverflow.com/a/51657692 + |