Absolutely! You can define custom symbols in an ARM Scatter file and reference them directly in your C code—this is actually a common trick for controlling memory layouts and passing configuration from the linker script (Scatter file) to your application. Let me break down how to do it step by step, with practical examples.

Step 1: Define Custom Symbols in Your Scatter File #

There are two main ways to create custom symbols in an ARM Scatter file, depending on what you need:

Approach 1: Use DEFINE for Fixed Values #

The DEFINE keyword lets you create symbols that hold constant values (like memory base addresses, sizes, or configuration flags). Here’s an example:

; MyScatterFile.scat
LOAD_REGION 0x08000000 0x10000
{
    EXEC_REGION 0x08000000 0x10000
    {
        *.o (RESET, +First)
        *.o (+RO)
    }
}

; Custom symbols defined here
DEFINE CUSTOM_RAM_BASE = 0x20000000;
DEFINE CUSTOM_RAM_SIZE = 0x8000;
DEFINE DEBUG_MODE_ENABLED = 0x1;

Approach 2: Mark Memory Region Boundaries #

You can also create symbols that point to the start/end of a custom memory region. ARM’s scatter file syntax automatically generates __region_<region_name>_start__ and __region_<region_name>_end__ for every defined region—you can reassign these to more readable names if you want:

LOAD_REGION 0x08000000 0x10000
{
    EXEC_REGION 0x08000000 0x10000
    {
        *.o (RESET, +First)
        *.o (+RO)
    }

    ; Define a custom RAM region
    CUSTOM_RAM_REGION 0x20000000 0x8000
    {
        ; Dummy section to anchor the region (no actual code needed here)
        *(.custom_ram_markers)
    }
}

; Assign readable names to the auto-generated region symbols
DEFINE CUSTOM_RAM_START = __region_CUSTOM_RAM_REGION_start__;
DEFINE CUSTOM_RAM_END = __region_CUSTOM_RAM_REGION_end__;

Step 2: Reference the Symbols in C Code #

To use these symbols in your C source, declare them as external global variables (or constants) using extern. The linker will resolve them during the link phase.

Example 1: Using DEFINEd Constants #

// main.c
#include <stdint.h>

// Declare symbols from the scatter file
extern const uint32_t CUSTOM_RAM_BASE;
extern const uint32_t CUSTOM_RAM_SIZE;
extern const uint32_t DEBUG_MODE_ENABLED;

int main(void) {
    // Use the custom RAM base address
    uint32_t* custom_ram_ptr = (uint32_t*)&CUSTOM_RAM_BASE;
    
    // Check if debug mode is enabled
    if (DEBUG_MODE_ENABLED) {
        // Run debug-specific initialization
    }

    while(1);
}

Example 2: Using Memory Region Boundaries #

// main.c
#include <stdint.h>

// Declare region start/end symbols
extern const uint32_t CUSTOM_RAM_START;
extern const uint32_t CUSTOM_RAM_END;

int main(void) {
    // Calculate the size of the custom RAM region
    uint32_t custom_ram_size = (uint32_t)&CUSTOM_RAM_END - (uint32_t)&CUSTOM_RAM_START;
    
    // Initialize the custom RAM to zero
    uint8_t* ram_ptr = (uint8_t*)&CUSTOM_RAM_START;
    for (uint32_t i = 0; i < custom_ram_size; i++) {
        ram_ptr[i] = 0x00;
    }

    while(1);
}

Key Things to Keep in Mind #

• Avoid Name Conflicts: Use a consistent prefix (like CUSTOM_) for your symbols to avoid clashing with linker-generated or your own code’s variables.
• Type Safety: Always declare symbols as uint32_t (or the appropriate width for your target) to prevent type mismatches. Using const is a good practice for read-only values.
• Verify with Linker Maps: Check your linker output map file to confirm that symbols are assigned the correct addresses/values.
• Dummy Sections: If you’re defining a region without existing code/data sections, add a dummy section (like .custom_ram_markers) to ensure the linker recognizes the region and generates the start/end symbols.

内容的提问来源于stack exchange，提问作者Three