Example 3. The MEMORY Directive

/********************************************************/
/*      Sample command file with MEMORY directive       */
/********************************************************/
file1.c.obj file2.c.obj               /*    Input files     */
--output_file=prog.out            /*    Options         */
#define BUFFER 0

MEMORY
{
   FAST_MEM (RX): origin = 0x00000000    length = 0x00001000 + BUFFER
   SLOW_MEM (RW): origin = end(FAST_MEM) length = 0x00001800 - size(FAST_MEM)
   EXT_MEM  (RX): origin = 0x10000000    length = size(FAST_MEM)

The general syntax for the MEMORY directive is:
MEMORY
{
	name 1 [(attr)] : origin = expression, length = expression [, fill = constant]
	.
	.
	name n [(attr)] : origin = expression, length = expression [, fill = constant]
}

name	names a memory range. A memory name can be one to 64 characters; valid characters include A-Z, a-z, $, ., and _. The names have no special significance to the linker; they simply identify memory ranges. Memory range names are internal to the linker and are not retained in the output file or in the symbol table. All memory ranges must have unique names and must not overlap.
attr	specifies one to four attributes associated with the named range. Attributes are optional; when used, they must be enclosed in parentheses. Attributes restrict the allocation of output sections into certain memory ranges. If you do not use any attributes, you can allocate any output section into any range with no restrictions. Any memory for which no attributes are specified (including all memory in the default model) has all four attributes. Valid attributes are:
	R	specifies that the memory can be read.
	W	specifies that the memory can be written to.
	X	specifies that the memory can contain executable code.
	I	specifies that the memory can be initialized.
origin	specifies the starting address of a memory range; enter as origin, org, or o. The value, specified in bytes, is a 64-bit integer constant expression, which can be decimal, octal, or hexadecimal.
length	specifies the length of a memory range; enter as length, len, or l. The value, specified in bytes, is a 64-bit integer constant expression, which can be decimal, octal, or hexadecimal.
fill	specifies a fill character for the memory range; enter as fill or f. Fills are optional. The value is an integer constant and can be decimal, octal, or hexadecimal. The fill value is used to fill areas of the memory range that are not allocated to a section.

NOTE

Filling Memory Ranges

If you specify fill values for large memory ranges, your output file will be very large because filling a memory range (even with 0s) causes raw data to be generated for all unallocated blocks of memory in the range.

The following example specifies a memory range with the R and W attributes and a fill constant of 0FFFFFFFFh:

MEMORY
{
	RFILE (RW) : o = 0x00000020, l = 0x00001000, f = 0xFFFFFFFF
}

You normally use the MEMORY directive in conjunction with the SECTIONS directive to control placement of output sections. For more information about the SECTIONS directive, see Section 12.5.5.