Texas Instruments TMS320C2x, User Manual

Page: 131 / 250

Memory Model
6-8
6.1.7 Field/Structure Alignment
When the compiler allocates space for a structure, it allocates as many words
as are needed to hold all of the structure’s members. In an array of structures,
each structure begins on a word boundary.
All nonfield types are aligned on word boundaries. Fields are allocated as
many bits as requested. Adjacent fields are packed into adjacent bits of a word,
but they do not overlap words. If a field would overlap into the next word, the
entire field is placed into the next word. Fields are packed as they are encoun-
tered with the least significant bits of the structure word are filled first.
6.1.8 Character String Constants
In C, a character string constant is used in one of the following ways:
-
To initialize an array of characters. For example:
char s[ ] = ”abc”;
When a string is used as an initializer, it is simply treated as an initialized
array, each character being a separate initializer. For more information
about initialization, see section 6.8,
System Initialization , on page 6-31.
-
In an expression. For example:
strcpy (s, ”abc”);
When a string is used in an expression, the string itself is defined in the
.const section with the .string assembler directive, along with a unique
label that points to the string the terminating 0 byte is also included. For
example, the following lines define the string abc, and the terminating byte
(the label SL5 points to the string):
.sect .const
SL5 .string ”abc”, 0
String labels have the form SL n , where n is a number assigned by the
compiler to make the label unique. The number begins at 0 and is in-
creased by 1 for each string defined. All strings used in a source module
are defined at the end of the compiled assembly language module.
The label SL
n represents the address of the string constant. The compiler
uses this label to reference the string in the expression.
If the same string is used more than once within a source module, the
string is not duplicated in memory. All uses of an identical string constant
share a single definition of the string.
Because strings are stored in the .const section (possibly in ROM) and
shared, it is bad practice for a program to modify a string constant. The
following code is an example of incorrect string use:
const char *a = ”abc”
a[1] = ’x’; /* Incorrect! */