Hands-On: Memory Layout Analysis

# Excerpt from a GCC linker .map file for Aurix TC397
# Generated by: gcc -Wl,-Map=output.map

# Memory regions (from linker script)
Memory Configuration

Name             Origin             Length             Attributes
PFLASH           0x0080000000       0x00800000         xr    # 8 MB flash
LMU_RAM          0x0070000000       0x00100000         xrw   # 1 MB shared RAM
DSPR0            0x0050000000       0x00040000         xrw   # 256 kB core-local

# Section layout: .text (code) in PFlash
.text            0x0080000100  0x0001A234
 .text.Can_Init  0x0080000100      0x0084  build/can.o
 .text.Adc_Read  0x0080000184      0x0030  build/adc.o
 .text.App_Main  0x00800001B4      0x01C0  build/app.o

# .bss (uninitialised data) in LMU_RAM
.bss             0x0070001000  0x00002800
 .bss.g_canBuf   0x0070001000      0x0400  build/can.o
 g_canBuf        0x0070001000
 .bss.g_adcData  0x0070001400      0x0100  build/adc.o

# Key: look for unusually large symbols; check for unexpected sections

# Useful grep patterns:
# grep -E '^\s+0x[0-9a-f]+\s+0x[0-9a-f]{4,}' output.map  # large allocations
# grep 'fill' output.map                                    # padding/fill gaps

#!/bin/bash
# Analyse ELF file for memory usage and symbol sizes

ELF="build/app.elf"

# 1. Section sizes: .text (flash), .data (flash+RAM), .bss (RAM only)
echo "=== Section sizes ==="
arm-none-eabi-size $ELF
# Output: text   data    bss    dec    hex
#         98304   1024   4096  103424  193C0

# 2. Top 20 largest symbols by size
echo "=== Top 20 largest symbols ==="
arm-none-eabi-nm --print-size --size-sort --radix=d $ELF | tail -20
# T = text (code); D = data; B = bss; R = rodata (flash const)

# 3. Find all global (non-static) variables — potential MISRA Rule 8.7 violations
echo "=== External symbols (check for unnecessary globals) ==="
arm-none-eabi-nm $ELF | grep ' [BD] ' | sort

# 4. Check for sections not in linker script (unplaced sections → may go to default region)
echo "=== All sections ==="
arm-none-eabi-objdump -h $ELF | grep -E '^\s+[0-9]'

# 5. Disassemble a specific function
echo "=== Disassemble Can_Init ==="
arm-none-eabi-objdump -d --source $ELF | grep -A 30 ":

/* Exercise: calculate sizeof each struct; find the one with most padding */
/* Then reorder to minimise padding */
#include 
#include 

/* Struct A: original order — calculate sizeof */
typedef struct {
    uint8_t  flags;       /* 1 byte */
    uint32_t timestamp;   /* 4 bytes — but needs 4-byte alignment */
    uint8_t  channel;     /* 1 byte */
    uint16_t value;       /* 2 bytes — needs 2-byte alignment */
    uint8_t  checksum;    /* 1 byte */
} EventRecord_A_t;
/* sizeof = ? (answer: 1 + 3pad + 4 + 1 + 1pad + 2 + 1 + 3pad = 16) */

/* Struct B: reordered for minimal padding */
typedef struct {
    uint32_t timestamp;   /* 4 bytes, offset 0 */
    uint16_t value;       /* 2 bytes, offset 4 */
    uint8_t  flags;       /* 1 byte,  offset 6 */
    uint8_t  channel;     /* 1 byte,  offset 7 */
    uint8_t  checksum;    /* 1 byte,  offset 8 */
    /* 3 bytes padding to align to 4 */
} EventRecord_B_t;
/* sizeof = ? (answer: 4 + 2 + 1 + 1 + 1 + 3pad = 12) — saved 4 bytes */

_Static_assert(sizeof(EventRecord_A_t) == 16u, "A should be 16");
_Static_assert(sizeof(EventRecord_B_t) == 12u, "B should be 12");
/* Saving 4 bytes × 1024 event log entries = 4 kB RAM saved */

#!/bin/bash
# Analyse stack usage per function using GCC -fstack-usage flag
# Compile with: gcc -fstack-usage source.c

# 1. Build with stack usage reporting
arm-none-eabi-gcc -O2 -fstack-usage -c app.c -o app.o
# Generates: app.su file with per-function stack frame sizes

# 2. Parse .su files: format is "file:line:col function_name frame_size type"
# type: static (known at compile time), dynamic (variable-length arrays), unbounded
echo "=== Functions with largest stack frames ==="
sort -k3 -rn *.su | head -20
# Example output:
# app.c:45:12 ParseCanMessage 128 static
# can.c:22:8  Can_Receive      64 static
# app.c:88:4  ProcessSensor    256 dynamic  <-- WARNING: VLA or alloca

# 3. Generate call-graph stack analysis with GCC -Wstack-usage
arm-none-eabi-gcc -Wstack-usage=256 app.c  # warn if frame > 256 bytes

# 4. Total stack depth: requires call-graph traversal
# Tool: arm-none-eabi-gcc -fdump-rtl-expand + custom analysis script
# Commercial: LDRA, Polyspace (for certified WCSS calculation)