SoC
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
  • Arm Cortex M3
  • Contact
Reading: Resolving ld Library and Architecture Errors when Compiling for Cortex-M4
SUBSCRIBE
SoCSoC
Font ResizerAa
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Search
  • Home
  • Arm
  • Arm Cortex M0/M0+
  • Arm Cortex M4
Have an existing account? Sign In
Follow US
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
© S-O-C.ORG, All Rights Reserved.
Arm

Resolving ld Library and Architecture Errors when Compiling for Cortex-M4

David Moore
Last updated: November 8, 2023 5:19 am
David Moore 6 Min Read
Share
SHARE

When compiling code for the ARM Cortex-M4 processor, you may encounter linker errors related to incompatible libraries or architecture mismatches. This usually happens when the compiler cannot find the correct libraries or is trying to link code compiled for a different architecture. Here are some tips for resolving these ld library and architecture errors when building for Cortex-M4.

Contents
Understanding the ErrorsChecking the ToolchainCompiling for the Right ArchitectureLinking Required LibrariesUsing the Correct Linker ScriptStart from a Working ExampleConclusion

Understanding the Errors

Some common linker errors you may see include:

  • “undefined reference to `__aeabi_'” – Missing C library
  • “architecture mismatch” – Code compiled for wrong architecture
  • “ld: cannot find ” – Missing library/object file

These errors indicate that the linker is unable to find the appropriate libraries or object files to resolve all the symbols and references in your code. The reasons could include:

  • Compiler not linked with correct C library for Cortex-M4
  • Object files compiled for a different architecture (e.g. Cortex-M3)
  • Missing libraries that contain required code
  • Incorrect linker script for the target processor

To fix these, you need to make sure the compiler, object files and libraries are all consistent for Cortex-M4 and that all required libraries are linked.

Checking the Toolchain

First, verify that your compiler toolchain is set up properly for Cortex-M4. The key things to check:

  • Using a compiler that supports Cortex-M4 (e.g. arm-none-eabi-gcc)
  • Compiler installed for Cortex-M4 target (check install folder name)
  • Correct ARM architecture flags used (-mcpu, -mfloat-abi etc)
  • Linker flags reference Cortex-M4 libraries (libc, libm etc)

For example, when compiling with arm-none-eabi-gcc, the flags might look like: arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16 -c -g -O0 -fmessage-length=0 -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -fmerge-constants -fmacro-prefix-map=”../”=

And linker flags: arm-none-eabi-gcc ../memmap.ld -L../ -T ../linker.ld -nostartfiles -Xlinker –gc-sections -Wl,-Map=output.map –specs=nano.specs -o output.elf -lc -lm -lnosys -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16 -Wl,–start-group -lgcc -lc -lnosys -Wl,–end-group

Double check that the C library used is for Cortex-M4 rather than another architecture. The map file after linking can also help identify missing libraries.

Compiling for the Right Architecture

If you get “architecture mismatch” errors, it likely means some object files were compiled for a different architecture than Cortex-M4. Go through all your source files and make sure they are being compiled with the right -mcpu and architecture flags for the M4: -mcpu=cortex-m4 -mthumb -mfloat-abi=hard -mfpu=fpv4-sp-d16

If you have any pre-compiled libraries (usually .a files), check their documentation to confirm they support Cortex-M4. You may need to recompile or find a different library specifically for M4.

Linking Required Libraries

“Undefined reference” errors indicate missing libraries during linking. The Cortex-M4 requires libraries like libc, libm, libgcc among others to provide common C functions. Make sure to link all the required libraries based on your toolchain and compiler.

For gcc, you may need to link libraries like: -lc -lm -lnosys -lgcc

If you get undefined references even after linking standard libraries, you may be missing BSP or peripheral libraries provided by the chip vendor. Consult your microcontroller datasheet and vendors libs to find and link the additional required libraries.

Using the Correct Linker Script

The linker script provides key information to the linker like memory regions, symbol assignments etc. Using the wrong linker script can result in errors. Most compiler toolchains provide a linker script for the Cortex-M4. For gcc, the script is often called “cortex-m4.ld”.

Double check that the linker script matches the target processor architecture. The script should include definitions like: /* Entry Point */ ENTRY(Reset_Handler) /* Highest address of the user mode stack */ _estack = 0x20020000; /* end of RAM */ /* Generate a link error if heap and stack don’t fit into RAM */ _Min_Heap_Size = 0; /* required amount of heap */ _Min_Stack_Size = 0x400; /* required amount of stack */

These parameters are specific to Cortex-M4 and ensure the linker allocates memory correctly.

Start from a Working Example

If facing linking issues, it can help to start from a known good project setup for Cortex-M4 and slowly integrate your code into it. Many toolchains and SDKs provide example projects with correctly configured build scripts.

You can start building by porting one of those examples to your environment rather than starting completely from scratch. This allows you to isolate and fix any architecture and linker issues one step at a time.

Conclusion

Linker errors related to libraries and architecture mismatches are common when starting Cortex-M4 development. Following the tips above to check your toolchain, compiler flags, libraries and linker script can help identify and resolve these issues when building for the M4 processor.

The key is having a consistent build setup where the compiler, object files, libraries and linker script all target the intended Cortex-M4 architecture. Taking small steps and comparing against known good examples can also help isolate and fix problems in the toolchain and link process.

With the right tools and options, you should be able to eliminate tricky linker errors and successfully build, link and debug code for your Cortex-M4 platform.

Newsletter Form (#3)

More ARM insights right in your inbox

 


Share This Article
Facebook Twitter Email Copy Link Print
Previous Article ARM Cross-Compilation Tips
Next Article Deep Sleep Mode for Maximum Power Savings in Cortex-M3
Leave a comment Leave a comment

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

2k Followers Like
3k Followers Follow
10.1k Followers Pin
- Sponsored-
Ad image

You Might Also Like

Cortex-M0 Low Power Features (Explained)

The Cortex-M0 processor from ARM is designed to provide an…

11 Min Read

What is Computer architecture in Arm Cortex-M series?

The ARM Cortex-M series of processors are designed for embedded…

9 Min Read

Dynamic Interrupt Priority Changes on Cortex-M3/M4

The Cortex-M3 and Cortex-M4 microcontrollers allow for dynamic changing of…

6 Min Read

Common Vitis Configuration Mistakes when Making Cortex-M1 Projects

When working with Xilinx's Vitis tools to build projects targeting…

15 Min Read
SoCSoC
  • Looking for Something?
  • Privacy Policy
  • About Us
  • Sitemap
  • Contact Us
Welcome Back!

Sign in to your account