Symbols are a central concept: the programmer uses symbols to name things, the linker uses symbols to link, and the debugger uses symbols to debug.
Warning:
asdoes not place symbols in the object file in the same order they were declared. This may break some debuggers.
A label is written as a symbol immediately followed by a colon `:'. The symbol then represents the current value of the active location counter, and is, for example, a suitable instruction operand. You are warned if you use the same symbol to represent two different locations: the first definition overrides any other definitions.
On the HPPA, the usual form for a label need not be immediately followed by a
colon, but instead must start in column zero. Only one label may be defined on
a single line. To work around this, the HPPA version of as also
provides a special directive .label for defining labels more flexibly.
A symbol can be given an arbitrary value by writing a symbol, followed
by an equals sign `=', followed by an expression
(see section Expressions). This is equivalent to using the .set
directive. See section .set symbol, expression.
Symbol names begin with a letter or with one of `._'. On most
machines, you can also use $ in symbol names; exceptions are
noted in section Machine Dependent Features. That character may be followed by any
string of digits, letters, dollar signs (unless otherwise noted in
section Machine Dependent Features), and underscores.
For the AMD 29K family, `?' is also allowed in the
body of a symbol name, though not at its beginning.
Case of letters is significant: foo is a different symbol name
than Foo.
Each symbol has exactly one name. Each name in an assembly language program refers to exactly one symbol. You may use that symbol name any number of times in a program.
Local symbols help compilers and programmers use names temporarily. There are ten local symbol names, which are re-used throughout the program. You may refer to them using the names `0' `1' ... `9'. To define a local symbol, write a label of the form `N:' (where N represents any digit). To refer to the most recent previous definition of that symbol write `Nb', using the same digit as when you defined the label. To refer to the next definition of a local label, write `Nf'---where N gives you a choice of 10 forward references. The `b' stands for "backwards" and the `f' stands for "forwards".
Local symbols are not emitted by the current GNU C compiler.
There is no restriction on how you can use these labels, but remember that at any point in the assembly you can refer to at most 10 prior local labels and to at most 10 forward local labels.
Local symbol names are only a notation device. They are immediately transformed into more conventional symbol names before the assembler uses them. The symbol names stored in the symbol table, appearing in error messages and optionally emitted to the object file have these parts:
L
as and
ld forget symbols that start with `L'. These labels are
used for symbols you are never intended to see. If you use the
`-L' option then as retains these symbols in the
object file. If you also instruct ld to retain these symbols,
you may use them in debugging.
digit
C-A
ordinal number
For instance, the first 1: is named L1C-A1, the 44th
3: is named L3C-A44.
The special symbol `.' refers to the current address that
as is assembling into. Thus, the expression `melvin:
.long .' defines melvin to contain its own address.
Assigning a value to . is treated the same as a .org
directive. Thus, the expression `.=.+4' is the same as saying
`.space 4'.
Every symbol has, as well as its name, the attributes "Value" and "Type". Depending on output format, symbols can also have auxiliary attributes.
If you use a symbol without defining it, as assumes zero for
all these attributes, and probably won't warn you. This makes the
symbol an externally defined symbol, which is generally what you
would want.
The value of a symbol is (usually) 32 bits. For a symbol which labels a
location in the text, data, bss or absolute sections the value is the
number of addresses from the start of that section to the label.
Naturally for text, data and bss sections the value of a symbol changes
as ld changes section base addresses during linking. Absolute
symbols' values do not change during linking: that is why they are
called absolute.
The value of an undefined symbol is treated in a special way. If it is
0 then the symbol is not defined in this assembler source file, and
ld tries to determine its value from other files linked into the
same program. You make this kind of symbol simply by mentioning a symbol
name without defining it. A non-zero value represents a .comm
common declaration. The value is how much common storage to reserve, in
bytes (addresses). The symbol refers to the first address of the
allocated storage.
The type attribute of a symbol contains relocation (section) information, any flag settings indicating that a symbol is external, and (optionally), other information for linkers and debuggers. The exact format depends on the object-code output format in use.
a.out
This is an arbitrary 16-bit value. You may establish a symbol's
descriptor value by using a .desc statement
(see section .desc symbol, abs-expression). A descriptor value means nothing to
as.
This is an arbitrary 8-bit value. It means nothing to as.
The COFF format supports a multitude of auxiliary symbol attributes;
like the primary symbol attributes, they are set between .def and
.endef directives.
The symbol name is set with .def; the value and type,
respectively, with .val and .type.
The as directives .dim, .line, .scl,
.size, and .tag can generate auxiliary symbol table
information for COFF.
The SOM format for the HPPA supports a multitude of symbol attributes set with
the .EXPORT and .IMPORT directives.
The attributes are described in HP9000 Series 800 Assembly
Language Reference Manual (HP 92432-90001) under the IMPORT and
EXPORT assembler directive documentation.
Go to the first, previous, next, last section, table of contents.