Methods of placing functions and data at specific addresses

To place code and data at specific addresses without a scatter file:

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

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

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

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

3. Compile and link the sources:

   armclang --target=arm-arm-none-eabi -march=armv8-a -c function.c
   armclang --target=arm-arm-none-eabi -march=armv8-a -c 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.

In this example, __attribute__((section(".ARM.__AT_0x5000"))) specifies that the global variable gValue is to be placed at the absolute address 0x5000. gValue is placed in the execution region ER$$.ARM.__AT_0x5000 and load region LR$$.ARM.__AT_0x5000.

The memory map shows:

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

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

    Base Addr    Size         Type   Attr      Idx    E Section Name        Object

    0x00005000   0x00000004   Data   RO           18    .ARM.__AT_0x5000  main.o

To modify your source code to place code and data in a specific section using a scatter file:

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(void)
   {
       gSquared=sqr(3);
       printf("Value squared is: %d\n", gSquared);
       return 0;
   }

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:

   armclang --target=arm-arm-none-eabi -march=armv8-a -c function.c
   armclang --target=arm-arm-none-eabi -march=armv8-a -c 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.

In this example, __attribute__((section("foo"))) specifies that the global variable gSquared is to be placed in a section called foo. The scatter file specifies that the section foo is to be placed in the ER3 execution region.

The memory map shows:

  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
…

To modify your source code to place code and data at a specific address using a scatter file:

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(void)
   {
       int squared;
       squared=sqr(gValue);
       printf("Value squared is: %d\n", squared);
       return 0;
   }

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:

   armclang --target=arm-arm-none-eabi -march=armv8-a -c function.c
   armclang --target=arm-arm-none-eabi -march=armv8-a -c 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.

The memory map shows that the variable is placed in the ER2 execution region at address 0x10000:

…
    Execution Region ER2 (Base: 0x00002a54, Size: 0x0000d5b0, Max: 0xffffffff, ABSOLUTE)

    Base Addr    Size         Type   Attr      Idx    E Section Name        Object

    0x00002a54   0x0000001c   Code   RO            4    .text.sqr           function.o
    0x00002a70   0x0000d590   PAD
    0x00010000   0x00000004   Data   RO            9    .ARM.__at_0x10000   main.o