7 Scatter-loading Features

Complex memory maps

Code and data that must be placed into many distinct areas of memory require detailed instructions on where to place the sections in the memory space.

Different types of memory

Many systems contain a variety of physical memory devices such as flash, ROM, SDRAM, and fast SRAM. A scatter-loading description can match the code and data with the most appropriate type of memory. For example, interrupt code might be placed into fast SRAM to improve interrupt response time but infrequently-used configuration information might be placed into slower flash memory.

Memory-mapped peripherals

The scatter-loading description can place a data section at a precise address in the memory map so that memory mapped peripherals can be accessed.

Functions at a constant location

A function can be placed at the same location in memory even though the surrounding application has been modified and recompiled. This is useful for jump table implementation.

Using symbols to identify the heap and stack

Symbols can be defined for the heap and stack location when the application is linked. 

• Use a scatter file.
• Specify the memory map using only linker command-line options.

Figure 7-1 Simple scatter-loaded memory map

LOAD_ROM 0x0000 0x8000       ; Name of load region (LOAD_ROM),
                             ; Start address for load region (0x0000),
                             ; Maximum size of load region (0x8000)
{
     0x0000 0x8000   ; Name of first exec region (EXEC_ROM),
                             ; Start address for exec region (0x0000),
                             ; Maximum size of first exec region (0x8000)
    {
        * (+RO)              ; Place all code and RO data into
                             ; this exec region
    }
    SRAM 0x10000 0x6000      ; Name of second exec region (SRAM),
                             ; Start address of second exec region (0x10000),
                             ; Maximum size of second exec region (0x6000)
    {
        * (+RW, +ZI)         ; Place all RW and ZI data into
                             ; this exec region
    }
}

• You can create a scatter file that defines an execution region at the required address with a section description that selects only one section.
• For a specially-named section the linker can get the placement address from the section name. These specially-named sections are called __at sections.

• Place the function or data item in its own source file.
• Use __attribute__((at(address))) to place variables in a separate section at a specific address.
• Use __attribute__((section("name"))) to place functions and variables in a named section.
• Use the AREA directive from assembly language. In assembly code, the smallest locatable unit is an AREA.
• Use the --split_sections compiler option to generate one ELF section for each function in the source file.
  This option results in a small increase in code size for some functions because it reduces the potential for sharing addresses, data, and string literals between functions. However, this can help to reduce the final image size overall by enabling the linker to remove unused functions when you specify armlink --remove.

Example of how to place a variable at a specific address without scatter-loading

1. Create the source file main.c containing the following code:

   #include <stdio.h>
   extern int sqr(int n1);
   int gSquared __attribute__((at(0x5000)));  // Place at 0x5000
   int main()
   {
       gSquared=sqr(3);
       printf("Value squared is: %d\n", gSquared);
   }

2. Create the source file function.c containing the following code:

   int sqr(int n1)
   {
       return n1*n1;
   }

3. Compile and link the sources:

   armcc -c -g function.c
   armcc -c -g main.c
   armlink --map function.o main.o -o squared.axf

    

   The --map option displays the memory map of the image. Also, --autoat is the default.

…
  Load Region LR$$.ARM.__at_0x00005000 (Base: 0x00005000, Size: 0x00000000, Max: 0x00000004, ABSOLUTE)

    Execution Region ER$$.ARM.__at_0x00005000 (Base: 0x00005000, Size: 0x00000004, Max: 0x00000004, ABSOLUTE, UNINIT)

    Base Addr    Size         Type   Attr      Idx    E Section Name        Object

    0x00005000   0x00000004   Zero   RW           13    .ARM.__at_0x00005000  main.o

Example of how to place a variable in a named section with scatter-loading

1. Create the source file main.c containing the following code:

   #include <stdio.h>
   extern int sqr(int n1);
   int gSquared __attribute__((section("foo")));  // Place in section foo
   int main()
   {
       gSquared=sqr(3);
       printf("Value squared is: %d\n", gSquared);
   }

2. Create the source file function.c containing the following code:

   int sqr(int n1)
   {
       return n1*n1;
   }

    

3. Create the scatter file scatter.scat containing the following load region:

   LR1 0x0000 0x20000
   {
       ER1 0x0 0x2000
       {
           *(+RO)                ; rest of code and read-only data
       }
       ER2 0x8000 0x2000
       {
           main.o
       }
       ER3 0x10000 0x2000
       {
           function.o
           *(foo)                ; Place gSquared in ER3
       }
       ; RW and ZI data to be placed at 0x200000
       RAM 0x200000 (0x1FF00-0x2000)
       {
           *(+RW, +ZI)
       }
       ARM_LIB_STACK 0x800000 EMPTY -0x10000
       {
       }
       ARM_LIB_HEAP  +0 EMPTY 0x10000
       {
       }
   }

    

   The ARM_LIB_STACK and ARM_LIB_HEAP regions are required because the program is being linked with the semihosting libraries.
4. Compile and link the sources:

   armcc -c -g function.c
   armcc -c -g main.c
   armlink --map --scatter=scatter.scat function.o main.o -o squared.axf

    

   The --map option displays the memory map of the image. Also, --autoat is the default.

  Load Region LR1 (Base: 0x00000000, Size: 0x00001570, Max: 0x00020000, ABSOLUTE)
…
    Execution Region ER3 (Base: 0x00010000, Size: 0x00000010, Max: 0x00002000, ABSOLUTE)

    Base Addr    Size         Type   Attr      Idx    E Section Name        Object

    0x00010000   0x0000000c   Code   RO            3    .text               function.o
    0x0001000c   0x00000004   Data   RW           15    foo                 main.o
…

Example of how to place a variable at a specific address with scatter-loading

1. Create the source file main.c containing the following code:

   #include <stdio.h>
   extern int sqr(int n1);
   // Place at address 0x10000
   const int gValue __attribute__((section(".ARM.__at_0x10000"))) = 3;
   int main()
   {
       int squared;
       squared=sqr(gValue);
       printf("Value squared is: %d\n", squared);
   }

    

2. Create the source file function.c containing the following code:

   int sqr(int n1)
   {
       return n1*n1;
   }

    

3. Create the scatter file scatter.scat containing the following load region:

   LR1 0x0
   {
       ER1 0x0
       {
           *(+RO)                      ; rest of code and read-only data
       }
       ER2 +0
       {
           function.o
           *(.ARM.__at_0x10000)        ; Place gValue at 0x10000
       }
       ; RW and ZI data to be placed at 0x200000
       RAM 0x200000 (0x1FF00-0x2000)
       {
           *(+RW, +ZI)
       }
       ARM_LIB_STACK 0x800000 EMPTY -0x10000
       {
       }
       ARM_LIB_HEAP  +0 EMPTY 0x10000
       {
       }
   }

    

   The ARM_LIB_STACK and ARM_LIB_HEAP regions are required because the program is being linked with the semihosting libraries.
4. Compile and link the sources:

   armcc -c -g function.c
   armcc -c -g main.c
   armlink --no_autoat --scatter=scatter.scat --map function.o main.o -o squared.axf

    

   The --map option displays the memory map of the image.

…
    Execution Region ER2 (Base: 0x00001578, Size: 0x0000ea8c, Max: 0xffffffff, ABSOLUTE)

    Base Addr    Size         Type   Attr      Idx    E Section Name        Object

    0x00001578   0x0000000c   Code   RO            3    .text               function.o
    0x00001584   0x0000ea7c   PAD
    0x00010000   0x00000004   Data   RO           15    .ARM.__at_0x10000   main.o
…

LR 0x100
{
  ER_1 0x100 0x20
  {
     .ANY1(+RO-CODE)
  }
  ER_2 0x200 0x20
  {
     .ANY2(+RO)
  }
  ER_3 0x300 0x20
  {
     .ANY3(+RO)
  }
}

    Execution Region ER_1 (Base: 0x00000100, Size: 0x00000014, Max: 0x00000020, ABSOLUTE)
    Base Addr    Size         Type   Attr      Idx    E Section Name        Object
    0x00000100   0x00000014   Code   RO            1    sec1                sections.o
    Execution Region ER_2 (Base: 0x00000200, Size: 0x0000001c, Max: 0x00000020, ABSOLUTE)
    Base Addr    Size         Type   Attr      Idx    E Section Name        Object
    0x00000200   0x00000010   Code   RO            3    sec3                sections.o
    0x00000210   0x00000004   Code   RO            4    sec4                sections.o
    0x00000214   0x00000004   Code   RO            5    sec5                sections.o
    0x00000218   0x00000004   Code   RO            6    sec6                sections.o
    Execution Region ER_3 (Base: 0x00000300, Size: 0x00000014, Max: 0x00000020, ABSOLUTE)
    Base Addr    Size         Type   Attr      Idx    E Section Name        Object
    0x00000300   0x00000014   Code   RO            2    sec2                sections.o

• The linker places sec1 in ER_1 because ER_1 has the most specific selector. ER_1 now has 0x6 bytes remaining.
• The linker then tries to place sec2 in ER_1, because it has the most specific selector, but there is not enough space. Therefore, ER_1 is marked as full and is not considered in subsequent placement steps. The linker chooses ER_3 for sec2 because it has higher priority than ER_2.
• The linker then tries to place sec3 in ER_3. It does not fit, so ER_3 is marked as full and the linker places sec3 in ER_2.
• The linker now processes sec4. This is 0x4 bytes so it can fit in either ER_1 or ER_3. Because both of these sections have previously been marked as full, they are not considered. The linker places all remaining sections in ER_2.
• If another section sec7 of size 0x8 exists, and is processed after sec6 the example fails to link. The algorithm does not attempt to place the section in ER_1 or ER_3 because they have previously been marked as full.