Using GCC to Cross Compile for ARM Cortex M3

Cross compiling with GCC for the ARM Cortex M3 allows developers to build code on a host system like Linux or Windows and generate binary files that can run on the target Cortex M3 platform. This provides efficiency and flexibility during development. The key steps are installing a Cortex M3 toolchain, setting up the development environment, configuring GCC for cross compiling, and linking to target libraries.

Installing the ARM Cortex M3 GCC Toolchain

To cross compile C and C++ code for the Cortex M3, you need a version of the GCC compiler and other tools that support generating code for that architecture. Here are some options for installing a GCC toolchain:

• Download the pre-built GNU toolchain for ARM Cortex M from the ARM Developer website. This provides a simple all-in-one installer for Windows, Linux and Mac.
• Install GCC for ARM using your Linux distribution’s package manager, like apt-get on Ubuntu. Packages like gcc-arm-none-eabi provide a toolchain.
• Build GCC and binutils from source configured for Cortex M3. This is more complex but allows customization options.

The key components in the toolchain include:

• GCC compiler itself to generate ARM object files.
• Linker, objcopy and other binutils for managing output.
• Debugger like GDB to provide debugging capability.
• Runtime libraries used by programs.

Having all of these tools targeting Cortex M3 means you can build for that target from your desktop environment.

Setting Up Your Development Environment

With the toolchain installed, the next step is configuring your development environment. This means setting up the compiler and tools so they are accessible from the command line on your system. Here are some methods to do this:

• Add the toolchain binaries to your PATH. Then they will be directly accessible.
• Create a shell script to invoke the compiler and tools with their full path.
• Define environment variables like CC to point to the cross compiler.
• Use an IDE like Eclipse with a plugin that handles toolchain integration.

You need to test compiling a simple program to validate the tools are configured correctly before proceeding further. Resolving any issues at this stage avoids problems later.

Configuring GCC and Compilation Settings

GCC needs to be configured to cross compile for the right target architecture. This is done by specifying command line options. Some key options include:

• -mcpu to specify the Cortex M3 CPU.
• -mthumb to generate Thumb instruction set code.
• -mfloat-abi to control floating point ABI.
• -mfpu to select floating point hardware options.

For example: gcc -mcpu=cortex-m3 -mthumb -mfloat-abi=soft main.c

This will compile main.c for a Cortex M3 target using Thumb instructions. Other useful options control optimization level, debugging information, include directories and linking parameters.

You can set these options each time when invoking GCC. For convenience, they can be stored in environment variables like CFLAGS, or specified in a Makefile.

Linking Target Libraries

When cross compiling for Cortex M3, you need to link your code against libraries that provide support functions and runtime execution environment. Commonly used libraries include:

• CMSIS libraries provide standard APIs for Cortex M devices.
• Newlib for C standard library functions.
• Startup code to initialize the target device.

These libraries will be part of the toolchain or need to be provided separately. To link them when compiling: gcc main.c -L<library path> -l<library name>

For example, to link the standard C library: gcc main.c -L/opt/toolchain/arm-none-eabi/lib/ -lc

Linker scripts define how code and data are organized in memory. A predefined linker script for Cortex M3 handles this for you.

Putting It All Together: A Build Example

Once the toolchain is installed and environment configured, cross compiling a simple C program can look like: arm-none-eabi-gcc -mcpu=cortex-m3 -mthumb -O1 -ffunction-sections \ -fdata-sections -g -MMD -c main.c -o main.o arm-none-eabi-gcc main.o -o main.elf -T linker_script.ld \ -nostartfiles -nostdlib -lc -lnosys -lm arm-none-eabi-objcopy -O binary main.elf main.bin

This compiles main.c to main.o, links with the provided linker script and libraries to build main.elf, and generates a final main.bin binary file.

Debugging with GDB

GDB can be used to debug code remotely on a target board using the gdbserver stub functionality. For remote debugging:

1. Build code with debugging symbols.
2. Run gdbserver on target board.
3. Connect to gdbserver from GDB on host.
4. Set breakpoints and inspect variables.

For example, on the target board: gdbserver localhost:1234

Then from the host development system: arm-none-eabi-gdb main.elf target remote localhost:1234

GDB will connect to gdbserver, allowing full debugging of code running on the remote target.

Troubleshooting Cross Compilation Issues

Here are some common issues faced when getting started with cross compiling for Cortex M3 and how to resolve them:

• Compiler not found – Ensure compiler is in PATH or adjust build scripts.
• Invalid architecture – Double check -mcpu and other GCC options match the target.
• Unsupported instruction – Use -mthumb to force Thumb mode if needed.
• Cannot find libraries – Linker can’t locate libraries, add directory to -L flags.
• Unsupported library call – Remove dependency or reimplement for target environment.
• Linker errors – Fix issues with missing symbols, or incorrect sections.
• Runtime crashes – Use debugger to analyze crash location and fix bugs.

With the right tools installed and environment set up, cross compiling C and C++ for the popular Cortex M3 is straightforward. Configuring GCC and debugging with GDB helps produce robust firmware to run on this embedded target.