How do I place a group of functions or variables in a specific section?

http://supp.iar.com/Support/?Note=27498

EWARM v5.xx (and newer)

The placement of a few functions in a specific section is done with the ...

#pragma location="FUNCTIONS"
void h(void);

... but this becomes impractical when there are many functions to place.

So the ILINK linker of EWARM 5.xx can place all functions from a file into a specific section.

Placing many functions

•	Collect these functions in one (or more) source files.
•	Remove any #pragma location you have earlier added.
•	Edit the .icf file with a line the holds the keyword "object" as exemplified below. For more information, please see the chapter Section-selectors in the EWARM_DevelopmentGuide.pdf file.

Example
The link to the right holds an edited variant of "Tutor 1", where ILINK will place all code from the file Utilities.c at address 0x7000000 and higher.

The change made to the "Tutor 1", is the addition of these files to the .icf file:

define symbol __EXAMPLE_start__ = 0x7000000;
define symbol __EXAMPLE_end__   = 0x700FFFF;
define region EXAMPLE_region   = mem:[from __EXAMPLE_start__   to __EXAMPLE_end__];
place in EXAMPLE_region   { readonly object Utilities.o};

EWARM v6.70 (and newer)

Two new pragma directives have been added in v6.70 ...

#pragma default_variable_attributes

... and ...

#pragma default_function_attributes

... to set default placement and attributes for variable/function declarations and definitions.

This means that you can override multiple declarations and definitions by using a single #pragma.

Example

Below is an example of how to use these new pragmas:

/* Place following functions in section MY_FUNC */
#pragma default_function_attributes = @ "MY_FUNC"
 
int fun1(int x)
{
  return x + ;
}
 
int fun2(int x)
{
  return x - ;
}
 
/* Stop placing functions in section MY_FUNC */
#pragma default_function_attributes =
 
int fun3(int x)
{
  return x + x;
}
 
/* Place following data in section MY_DATA */
#pragma default_variable_attributes = @ "MY_DATA"
 
int data1;
int data2;
 
/* Stop placing data in section MY_DATA */
#pragma default_variable_attributes =
 
int data3;
 
int main()
{
  data1 = fun1();
  data2 = fun2();
  data3 = fun3();
 
  return data1 + data2 + data3;
}

#pragma location

Syntax

#pragma location={address|register|NAME}

Parameters

Description Use this pragma directive to specify:

address The absolute address of the global or static variable or function for which you want an absolute location.

NAME A user-defined section name; cannot be a section name predefined for use by the compiler and linker.

Description

Use this pragma directive to specify:

The location—the absolute address—of the global or static variable whose declaration follows the pragma directive.

The variables must be declared __no_init.

An identifier specifying a register. The variable defined after the pragma directive is placed in the register.

The variable must be declared as __no_init and have file scope.

A string specifying a section for placing either a variable or function whose declaration follows the pragma directive.

Do not place variables that would normally be in different sections

(for example, variables declared as __no_init and variables declared as const) in the same named section.

#pragma location=0xFFFF0400
__no_init volatile char PORT1;
/* PORT1 is located at address 0xFFFF0400 */
 
#pragma location=R8
__no_init int TASK;
/* TASK is placed in R8 */
 
#pragma location="FLASH"
char PORT2;
/* PORT2 is located in section FLASH */
 
/* A better way is to use a corresponding mechanism */
#define FLASH _Pragma("location=\"FLASH\"")
FLASH int i; /* i is placed in the FLASH section */

Controlling data and function placement in memory

The compiler provides different mechanisms for controlling placement of functions and data objects in memory.

To use memory efficiently, you should be familiar with these mechanisms to know

which one is best suited for different situations. You can use:

The @ operator and the #pragma location directive for absolute placement

Use the @ operator or the #pragma location directive to place individual global and static variables at absolute addresses.

This is useful for individual data objects that must be located at a fixed address to conform to external requirements,

for example to populate interrupt vectors or other hardware tables.

Note that it is not possible to use this notation for absolute placement of individual functions.

The @ operator and the #pragma location directive for section placement

Use the @ operator or the #pragma location directive to place groups of functions or global and static variables in named sections,

without having explicit control of each object.

The sections can, for example, be placed in specific areas of memory, or initialized or copied in controlled ways using the section begin and end operators.

This is also useful if you want an interface between separately linked units, for example an application project and a boot loader project.

Use named sections when absolute control over the placement of individual variables is not needed, or not useful.

The @ operator and the #pragma location directive for register placement

Use the @ operator or the #pragma location directive to place individual global and static variables in registers.

The variables must be declared __no_init. This is useful for individual data objects that must be located in a specific register.

The --section option

Use the --section option to place functions and/or data objects in named sections, which is useful, for example,

if you want to direct them to different fast or slow memories. For more information, see --section, page 266.

--section OldName=NewName

Description The compiler places functions and data objects into named sections which are referred to by the IAR ILINK Linker.

Use this option to change the name of the section OldName to NewName.

This is useful if you want to place your code or data in different address ranges and you find the @ notation,

alternatively the #pragma location directive, insufficient.

Note that any changes to the section names require corresponding modifications in the linker configuration file.

To place functions in the section MyText, use:
--section .text=MyText

At compile time, data and functions are placed in different sections, see Modules and sections, page 68.

At link time, one of the most important functions of the linker is to assign load addresses to the various sections used by the application.

All sections, except for the sections holding absolute located data, are automatically allocated to memory according to the specifications

in the linker configuration file, see Placing code and data—the linker configuration file, page 70.

Placing code and data—the linker configuration file

The placement of sections in memory is performed by the IAR ILINK Linker. It uses the linker configuration file

where you can define how ILINK should treat each section and how they should be placed into the available memories.

A typical linker configuration file contains definitions of:

● Available addressable memories
● Populated regions of those memories
● How to treat input sections
● Created sections
● How to place sections into the available regions.

The file consists of a sequence of declarative directives. This means that the linking process will be governed by all directives at the same time.

To use the same source code with different derivatives, just rebuild the code with the appropriate configuration file.