Expressions can be used in the following places:

Expressions follow the C-Precedence rules and are made up of the following:

All operators match their C counterparts in meaning and precedence.

Expressions are not case sensitive and parentheses can be used for clarity.

The execution address related functions can only be used when specifying a base_address or +offset value. They map to combinations of the linker defined symbols shown in Table 5.2.

ImageBase(region_name)

Image$$region_name$$Base

ImageLength(region_name)

Image$$region_name$$Length + Image$$region_name$$ZI$$Length

ImageLimit(region_name)

Image$$region_name$$Base + Image$$region_name$$Length + Image$$region_name$$ZI$$Length

See Table 4.1 for more information on region-related linker symbols.

The parameter region_name  can be either a load or an execution region name. Forward references are not allowed. The region_name can only refer to load or execution regions that have already been definedExample 5.4.

The ScatterAssert(expression) function can be used at the top level, or within a load region. It is evaluated after the link has completed and gives an error message if expression evaluates to false. Example 5.7 shows how to use the ScatterAssert function to write more complex size checks than those allowed by the max_size of the region.

The load address related functions can only be used within the ScatterAssert function. They map to the three linker defined symbol values as shown in Table 5.3.

LoadBase(region_name)

Load$$region_name$$Base

LoadLength(region_name)

Load$$region_name$$Length

LoadLimit(region_name)

Load$$region_name$$Limit

The parameter region_name can be either a load or an execution region name. Forward references are not allowed. The region_name can only refer to load or execution regions that have already been defined.

The symbol related function, defined(global_symbol_name) returns zero if global_symbol_name is not defined and nonzero if it is defined.

LR1 0x8000 (2 * 1024)
{
    ER1 +0 (1 * 1024)
    {
        *(+RO)
    }
    ER2 +0 (1 * 1024)
    {
        *(+RW +ZI)
    }
}

LR1 0x8000
{
    ER1 0x100000
    {
        *+RO
    }
}
LR2 0x100000
{
    ER2 (ImageLimit(ER1))               ; Place ER2 after ER1 has finished
    {
        *(+RW +ZI)
    }
}

LR1 0x8000
{
    ER1 (defined(version1) ? 0x8000 : 0x10000)   ; Base address is 0x8000
                                                 ; if version1 is defined
                                                 ; 0x10000 if not
    {
        *(+RO)
    }
    ER2 +0
    {
        *(+RW +ZI)
    }
}

A combination of pre-processor macros and expressions is used in Example 5.6 to copy tightly packed execution regions to execution addresses in a page-boundary. Using the ALIGN scatter loading keyword aligns the load addresses of ER2 and ER3 as well as the execution addresses

#! armcc -E
#DEFINE START_ADDRESS  0x100000
#DEFINE PAGE_ALIGNMENT 0x100000

#DEFINE MY_ALIGN(address, alignment) ((address +
(alignment-1)) AND ~(alignment-1))

LR1 0x8000
{
    ER0 +0
    {
        *(InRoot$$Sections)
    }
    ER1 START_ADDRESS
    {
        file1.o(*)
    }
    ER2 MY_ALIGN(ImageLimit(ER1), PAGE_ALIGNMENT)
    {
        file2.o(*)
    }
    ER3 MY_ALIGN(ImageLimit(ER2), PAGE_ALIGNMENT)
    {
        file3.o(*)
    }
}

LR1 0x8000
{
    ER0 +0
    {
        *(+RO)
    }
    ER1 +0
    {
        file1.o(+RW)
    }
    ER2 +0
    {
        file2.o(+RW)
    }
    ScatterAssert((LoadLength(ER1) + LoadLength(ER2)) < 0x1000)
                                         ; LoadLength is compressed size
    ScatterAssert((ImageLength(ER1) + ImageLength(ER2)) < 0x2000)
                                         ; ImageLength is uncompressed size
}
ScatterAssert(ImageLength(LR1) < 0x3000) ; Check uncompressed size of LoadRegion