Symbol assignment by the linker using the SIZE operator or the "." symbol.

Dennis Boyer

I am using linker generated copy tables to overlay code sections in program memory. Some code input sections are needed in more than one program memory overlay for an application. Since each input section can only be allocated once, the table() operator is applied to each output code section, allocated as a UNION member, to generate copy tables. Combinations of these tables are then copied into program memory at run time to form the application overlay. The output section within the copy table is offset from the overlay run address by predefined holes to allow the tables to be copied over each other without overwriting the program section in the previously loaded copy table (only fill is overwritten).

Presently, the size of the offset (hole) in each table has a hard coded value in the linker file. An example linker file and portion of the application code showing the order in which tables are copied are shown below.

==============
Linker example
==============
sizeOfApp1 = 1cf0h; /* Should not use these hardcoded values. */ 
sizeOfApp2 = 0110h; /* Should not use these hardcoded values. */
SECTIONS
{
  UNION:
  {
    App1Objects:  align(4)                 /*  1st Application */
    {
       Text11.obj(.text) 
        ...
       Text1N.obj(.text) 
    } load=FLASH, table(_App1_copy_table) 
 
    App2Objects:  align(4), fill = 0000h                /*  2nd Application */
    {
       . += sizeOfApp1; /* Offset for this table */
       Text21.obj(.text) /* Linked in after the hole */
        ...
       Text2N.obj(.text) 
    } load=FLASH, table(_App2_copy_table) 
 
    App3Objects:  align(4), fill = 0000h                /*  3rd Application */
    {
       . += sizeOfApp1; /* Offset for this table */
       . += sizeOfApp2; /* Offset for this table */
       Text31.obj(.text) /* Linked in after the hole */
        ...
       Text3N.obj(.text) 
    } load=FLASH, table(_App3_copy_table) 
  } run=SARAM                              /* Run Address in SARAM (Overlayed) */

============
Code example
============
if (externalTables)
{
   copy_in( &App3_copy_table); /* copy in the high memory section in ovly first */
   copy_in(&App2_copy_table); /* copy in the lower memory sections in the overlay */
   copy_in(&App1_copy_table);
}

The offset symbols would require less maintenance as the input sections grow if they were instead set by the linker using either the SIZE operator for each output section(UNION member) and the "." symbol to create a hole for the offset in the SECTIONS directive.

Attempts to use these options caused the linker to generate either a warning that the symbol is being redefined (and not assigned a new value) or an error that the symbol is used before it is assigned a value.

First, is there another or better way to allocate an input section to be used in more than one program memory overlay ?

Second, can the symbols (sizeOfApp1 and sizeOfApp2 shown above) be assigned a value in the linker file using either the SIZE operator or the "." symbol and be used to create a hole within the output sections of the UNION in the SECTIONS directive?

over 14 years ago

0 George Mock over 14 years ago

TI__Guru**** 250440 points

Dennis Boyer said:
Some code input sections are needed in more than one program memory overlay for an application.

You can't do that. Every function symbol can be assigned exactly one run address. Once assigned, the function must always execute at that address. There is no method by which the same symbol for a function can have one value during the first part of system execution, and a different value during a subsequent part of system execution.

But despite your description, it doesn't look like you are doing that. Consider this ...

SECTIONS
{
    AppObjects:  align(4)
    {
       Text11.obj(.text) 
        ...
       Text1N.obj(.text) 
       Text21.obj(.text)
        ...
       Text2N.obj(.text) 
       Text31.obj(.text)
        ...
       Text3N.obj(.text) 
    } run=SARAM, load=FLASH, table(_App_copy_table)
}

The three copy_in calls would be replaced by one. Doesn't this have the same result?

Thanks and regards,

-George

0 Dennis Boyer over 14 years ago in reply to George Mock

Prodigy 50 points

Thanks George.

Your solution would be much simpler. I guess I should have mentioned that I am using the overlays to free up program memory. The application will not need all the copy tables in program memory at any time.

The input sections are allocated only once. Each union member generates only one copy table.

Thanks again,

Dennis

Code Composer Studio™︎

Code Composer Studio forum

Symbol assignment by the linker using the SIZE operator or the "." symbol.