Microcontroller on AllThingsEmbedded

Linkers and orphaned sections

Tue, 25 Feb 2025 21:13:08 +0100

Problem statement

I recently came across a situation in a project where I had the following code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct FaultInfo final {
 uint32_t r0;
 uint32_t r1;
 // And all the other register state of a Cortex-M0+ processor
 // ...

 uint32_t crc;
};

[[gnu::section(".uninit")]] volatile FaultInfo fault_data;

I was using this static region of data to persist some fault information across reboots, to log it on the next boot after recovering from the fault.

Bare Metal C++ Register Access API

Sat, 25 Sep 2021 20:26:21 +0200

Introduction to memory-mapping

Note: This section is introductory material for those who are not yet familiar with the concept of memory-mapping. If you are already experienced with memory-mapping feel free to jump to the next section. Most likely you won’t miss anything new.

One of the most common ways of accessing peripherals from a CPU is memory-mapping. In short, this means that the address space of the CPU has some addresses that when accessed read/write peripheral’s registers. In order to access such peripherals from our code there are multiple strategies that could be used. This post will explore multiple alternatives and discuss their differences and fitness for their unique task.

Mastering the GNU linker script

Sat, 11 Apr 2020 21:25:34 +0000

Most people getting started with embedded development seem to find linker scripts just another piece of magic required to get up and running with their system. Even when they might already be familiar with memory-mapped peripherals and basic embedded concepts, the linker script and how it interacts with the GNU linker (ld) is still pretty mysterious.

Today we will go through the main functions of a linker script to try to shed some light onto their operation. We covered the basic of cross compilation in a previous post. We mentioned that the linker would be the last step in the compilation process. The job of the linker is to take all input object files and libraries (both shared and static) and generate a single executable file. Let’s start with some terminology.

Bootloaders and ARM Cortex-M microcontrollers: Design

Fri, 31 May 2019 15:37:18 +0000

Welcome to the second entry of the Bootloader series! Today we are going to be discussing the design and basic architecture of the bootloader application.

As we talked about on the last post, we are not going to be using any libraries, other than the C++ standard library in order to maximize portability and performance and limit code bloat. This means that we will be writing our own Hardware Abstraction Layer for all the peripherals and core features of the bootloader.

Bootloaders and ARM Cortex-M microcontrollers (STM32F7): Introduction

Sun, 19 May 2019 17:23:30 +0000

We are introducing a new series to the blog, containing all about bootloaders for small ARM Cortex-M microcontrollers. I hope you like it.

What is a bootloader?

A bootloader is a piece of firmware that takes care of booting the target application, as well as providing a mechanism to update the firmware on the field, where you don’t have the means to flash the device using more advanced hardware interfaces such as JTAG, SWD or ICSP.