1590 lines
50 KiB
Plaintext
1590 lines
50 KiB
Plaintext
This is Info file as.info, produced by Makeinfo version 1.68 from the
|
||
input file as.texinfo.
|
||
|
||
START-INFO-DIR-ENTRY
|
||
* As: (as). The GNU assembler.
|
||
END-INFO-DIR-ENTRY
|
||
|
||
This file documents the GNU Assembler "as".
|
||
|
||
Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998 Free Software
|
||
Foundation, Inc.
|
||
|
||
Permission is granted to make and distribute verbatim copies of this
|
||
manual provided the copyright notice and this permission notice are
|
||
preserved on all copies.
|
||
|
||
Permission is granted to copy and distribute modified versions of
|
||
this manual under the conditions for verbatim copying, provided that
|
||
the entire resulting derived work is distributed under the terms of a
|
||
permission notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this
|
||
manual into another language, under the above conditions for modified
|
||
versions.
|
||
|
||
|
||
File: as.info, Node: Line, Next: Ln, Prev: Lflags, Up: Pseudo Ops
|
||
|
||
`.line LINE-NUMBER'
|
||
===================
|
||
|
||
Change the logical line number. LINE-NUMBER must be an absolute
|
||
expression. The next line has that logical line number. Therefore any
|
||
other statements on the current line (after a statement separator
|
||
character) are reported as on logical line number LINE-NUMBER - 1. One
|
||
day `as' will no longer support this directive: it is recognized only
|
||
for compatibility with existing assembler programs.
|
||
|
||
*Warning:* In the AMD29K configuration of as, this command is not
|
||
available; use the synonym `.ln' in that context.
|
||
|
||
Even though this is a directive associated with the `a.out' or
|
||
`b.out' object-code formats, `as' still recognizes it when producing
|
||
COFF output, and treats `.line' as though it were the COFF `.ln' *if*
|
||
it is found outside a `.def'/`.endef' pair.
|
||
|
||
Inside a `.def', `.line' is, instead, one of the directives used by
|
||
compilers to generate auxiliary symbol information for debugging.
|
||
|
||
|
||
File: as.info, Node: Linkonce, Next: List, Prev: Ln, Up: Pseudo Ops
|
||
|
||
`.linkonce [TYPE]'
|
||
==================
|
||
|
||
Mark the current section so that the linker only includes a single
|
||
copy of it. This may be used to include the same section in several
|
||
different object files, but ensure that the linker will only include it
|
||
once in the final output file. The `.linkonce' pseudo-op must be used
|
||
for each instance of the section. Duplicate sections are detected
|
||
based on the section name, so it should be unique.
|
||
|
||
This directive is only supported by a few object file formats; as of
|
||
this writing, the only object file format which supports it is the
|
||
Portable Executable format used on Windows NT.
|
||
|
||
The TYPE argument is optional. If specified, it must be one of the
|
||
following strings. For example:
|
||
.linkonce same_size
|
||
Not all types may be supported on all object file formats.
|
||
|
||
`discard'
|
||
Silently discard duplicate sections. This is the default.
|
||
|
||
`one_only'
|
||
Warn if there are duplicate sections, but still keep only one copy.
|
||
|
||
`same_size'
|
||
Warn if any of the duplicates have different sizes.
|
||
|
||
`same_contents'
|
||
Warn if any of the duplicates do not have exactly the same
|
||
contents.
|
||
|
||
|
||
File: as.info, Node: Ln, Next: Linkonce, Prev: Line, Up: Pseudo Ops
|
||
|
||
`.ln LINE-NUMBER'
|
||
=================
|
||
|
||
`.ln' is a synonym for `.line'.
|
||
|
||
|
||
File: as.info, Node: MRI, Next: Nolist, Prev: Macro, Up: Pseudo Ops
|
||
|
||
`.mri VAL'
|
||
==========
|
||
|
||
If VAL is non-zero, this tells `as' to enter MRI mode. If VAL is
|
||
zero, this tells `as' to exit MRI mode. This change affects code
|
||
assembled until the next `.mri' directive, or until the end of the
|
||
file. *Note MRI mode: M.
|
||
|
||
|
||
File: as.info, Node: List, Next: Long, Prev: Linkonce, Up: Pseudo Ops
|
||
|
||
`.list'
|
||
=======
|
||
|
||
Control (in conjunction with the `.nolist' directive) whether or not
|
||
assembly listings are generated. These two directives maintain an
|
||
internal counter (which is zero initially). `.list' increments the
|
||
counter, and `.nolist' decrements it. Assembly listings are generated
|
||
whenever the counter is greater than zero.
|
||
|
||
By default, listings are disabled. When you enable them (with the
|
||
`-a' command line option; *note Command-Line Options: Invoking.), the
|
||
initial value of the listing counter is one.
|
||
|
||
|
||
File: as.info, Node: Long, Next: Macro, Prev: List, Up: Pseudo Ops
|
||
|
||
`.long EXPRESSIONS'
|
||
===================
|
||
|
||
`.long' is the same as `.int', *note `.int': Int..
|
||
|
||
|
||
File: as.info, Node: Macro, Next: MRI, Prev: Long, Up: Pseudo Ops
|
||
|
||
`.macro'
|
||
========
|
||
|
||
The commands `.macro' and `.endm' allow you to define macros that
|
||
generate assembly output. For example, this definition specifies a
|
||
macro `sum' that puts a sequence of numbers into memory:
|
||
|
||
.macro sum from=0, to=5
|
||
.long \from
|
||
.if \to-\from
|
||
sum "(\from+1)",\to
|
||
.endif
|
||
.endm
|
||
|
||
With that definition, `SUM 0,5' is equivalent to this assembly input:
|
||
|
||
.long 0
|
||
.long 1
|
||
.long 2
|
||
.long 3
|
||
.long 4
|
||
.long 5
|
||
|
||
`.macro MACNAME'
|
||
`.macro MACNAME MACARGS ...'
|
||
Begin the definition of a macro called MACNAME. If your macro
|
||
definition requires arguments, specify their names after the macro
|
||
name, separated by commas or spaces. You can supply a default
|
||
value for any macro argument by following the name with `=DEFLT'.
|
||
For example, these are all valid `.macro' statements:
|
||
|
||
`.macro comm'
|
||
Begin the definition of a macro called `comm', which takes no
|
||
arguments.
|
||
|
||
`.macro plus1 p, p1'
|
||
`.macro plus1 p p1'
|
||
Either statement begins the definition of a macro called
|
||
`plus1', which takes two arguments; within the macro
|
||
definition, write `\p' or `\p1' to evaluate the arguments.
|
||
|
||
`.macro reserve_str p1=0 p2'
|
||
Begin the definition of a macro called `reserve_str', with two
|
||
arguments. The first argument has a default value, but not
|
||
the second. After the definition is complete, you can call
|
||
the macro either as `reserve_str A,B' (with `\p1' evaluating
|
||
to A and `\p2' evaluating to B), or as `reserve_str ,B' (with
|
||
`\p1' evaluating as the default, in this case `0', and `\p2'
|
||
evaluating to B).
|
||
|
||
When you call a macro, you can specify the argument values either
|
||
by position, or by keyword. For example, `sum 9,17' is equivalent
|
||
to `sum to=17, from=9'.
|
||
|
||
`.endm'
|
||
Mark the end of a macro definition.
|
||
|
||
`.exitm'
|
||
Exit early from the current macro definition.
|
||
|
||
`\@'
|
||
`as' maintains a counter of how many macros it has executed in
|
||
this pseudo-variable; you can copy that number to your output with
|
||
`\@', but *only within a macro definition*.
|
||
|
||
|
||
File: as.info, Node: Nolist, Next: Octa, Prev: MRI, Up: Pseudo Ops
|
||
|
||
`.nolist'
|
||
=========
|
||
|
||
Control (in conjunction with the `.list' directive) whether or not
|
||
assembly listings are generated. These two directives maintain an
|
||
internal counter (which is zero initially). `.list' increments the
|
||
counter, and `.nolist' decrements it. Assembly listings are generated
|
||
whenever the counter is greater than zero.
|
||
|
||
|
||
File: as.info, Node: Octa, Next: Org, Prev: Nolist, Up: Pseudo Ops
|
||
|
||
`.octa BIGNUMS'
|
||
===============
|
||
|
||
This directive expects zero or more bignums, separated by commas.
|
||
For each bignum, it emits a 16-byte integer.
|
||
|
||
The term "octa" comes from contexts in which a "word" is two bytes;
|
||
hence *octa*-word for 16 bytes.
|
||
|
||
|
||
File: as.info, Node: Org, Next: P2align, Prev: Octa, Up: Pseudo Ops
|
||
|
||
`.org NEW-LC , FILL'
|
||
====================
|
||
|
||
Advance the location counter of the current section to NEW-LC.
|
||
NEW-LC is either an absolute expression or an expression with the same
|
||
section as the current subsection. That is, you can't use `.org' to
|
||
cross sections: if NEW-LC has the wrong section, the `.org' directive
|
||
is ignored. To be compatible with former assemblers, if the section of
|
||
NEW-LC is absolute, `as' issues a warning, then pretends the section of
|
||
NEW-LC is the same as the current subsection.
|
||
|
||
`.org' may only increase the location counter, or leave it
|
||
unchanged; you cannot use `.org' to move the location counter backwards.
|
||
|
||
Because `as' tries to assemble programs in one pass, NEW-LC may not
|
||
be undefined. If you really detest this restriction we eagerly await a
|
||
chance to share your improved assembler.
|
||
|
||
Beware that the origin is relative to the start of the section, not
|
||
to the start of the subsection. This is compatible with other people's
|
||
assemblers.
|
||
|
||
When the location counter (of the current subsection) is advanced,
|
||
the intervening bytes are filled with FILL which should be an absolute
|
||
expression. If the comma and FILL are omitted, FILL defaults to zero.
|
||
|
||
|
||
File: as.info, Node: P2align, Next: Psize, Prev: Org, Up: Pseudo Ops
|
||
|
||
`.p2align[wl] ABS-EXPR, ABS-EXPR, ABS-EXPR'
|
||
===========================================
|
||
|
||
Pad the location counter (in the current subsection) to a particular
|
||
storage boundary. The first expression (which must be absolute) is the
|
||
number of low-order zero bits the location counter must have after
|
||
advancement. For example `.p2align 3' advances the location counter
|
||
until it a multiple of 8. If the location counter is already a
|
||
multiple of 8, no change is needed.
|
||
|
||
The second expression (also absolute) gives the fill value to be
|
||
stored in the padding bytes. It (and the comma) may be omitted. If it
|
||
is omitted, the padding bytes are normally zero. However, on some
|
||
systems, if the section is marked as containing code and the fill value
|
||
is omitted, the space is filled with no-op instructions.
|
||
|
||
The third expression is also absolute, and is also optional. If it
|
||
is present, it is the maximum number of bytes that should be skipped by
|
||
this alignment directive. If doing the alignment would require
|
||
skipping more bytes than the specified maximum, then the alignment is
|
||
not done at all. You can omit the fill value (the second argument)
|
||
entirely by simply using two commas after the required alignment; this
|
||
can be useful if you want the alignment to be filled with no-op
|
||
instructions when appropriate.
|
||
|
||
The `.p2alignw' and `.p2alignl' directives are variants of the
|
||
`.p2align' directive. The `.p2alignw' directive treats the fill
|
||
pattern as a two byte word value. The `.p2alignl' directives treats the
|
||
fill pattern as a four byte longword value. For example, `.p2alignw
|
||
2,0x368d' will align to a multiple of 4. If it skips two bytes, they
|
||
will be filled in with the value 0x368d (the exact placement of the
|
||
bytes depends upon the endianness of the processor). If it skips 1 or
|
||
3 bytes, the fill value is undefined.
|
||
|
||
|
||
File: as.info, Node: Psize, Next: Quad, Prev: P2align, Up: Pseudo Ops
|
||
|
||
`.psize LINES , COLUMNS'
|
||
========================
|
||
|
||
Use this directive to declare the number of lines--and, optionally,
|
||
the number of columns--to use for each page, when generating listings.
|
||
|
||
If you do not use `.psize', listings use a default line-count of 60.
|
||
You may omit the comma and COLUMNS specification; the default width is
|
||
200 columns.
|
||
|
||
`as' generates formfeeds whenever the specified number of lines is
|
||
exceeded (or whenever you explicitly request one, using `.eject').
|
||
|
||
If you specify LINES as `0', no formfeeds are generated save those
|
||
explicitly specified with `.eject'.
|
||
|
||
|
||
File: as.info, Node: Quad, Next: Rept, Prev: Psize, Up: Pseudo Ops
|
||
|
||
`.quad BIGNUMS'
|
||
===============
|
||
|
||
`.quad' expects zero or more bignums, separated by commas. For each
|
||
bignum, it emits an 8-byte integer. If the bignum won't fit in 8
|
||
bytes, it prints a warning message; and just takes the lowest order 8
|
||
bytes of the bignum.
|
||
|
||
The term "quad" comes from contexts in which a "word" is two bytes;
|
||
hence *quad*-word for 8 bytes.
|
||
|
||
|
||
File: as.info, Node: Rept, Next: Sbttl, Prev: Quad, Up: Pseudo Ops
|
||
|
||
`.rept COUNT'
|
||
=============
|
||
|
||
Repeat the sequence of lines between the `.rept' directive and the
|
||
next `.endr' directive COUNT times.
|
||
|
||
For example, assembling
|
||
|
||
.rept 3
|
||
.long 0
|
||
.endr
|
||
|
||
is equivalent to assembling
|
||
|
||
.long 0
|
||
.long 0
|
||
.long 0
|
||
|
||
|
||
File: as.info, Node: Sbttl, Next: Scl, Prev: Rept, Up: Pseudo Ops
|
||
|
||
`.sbttl "SUBHEADING"'
|
||
=====================
|
||
|
||
Use SUBHEADING as the title (third line, immediately after the title
|
||
line) when generating assembly listings.
|
||
|
||
This directive affects subsequent pages, as well as the current page
|
||
if it appears within ten lines of the top of a page.
|
||
|
||
|
||
File: as.info, Node: Scl, Next: Section, Prev: Sbttl, Up: Pseudo Ops
|
||
|
||
`.scl CLASS'
|
||
============
|
||
|
||
Set the storage-class value for a symbol. This directive may only be
|
||
used inside a `.def'/`.endef' pair. Storage class may flag whether a
|
||
symbol is static or external, or it may record further symbolic
|
||
debugging information.
|
||
|
||
The `.scl' directive is primarily associated with COFF output; when
|
||
configured to generate `b.out' output format, `as' accepts this
|
||
directive but ignores it.
|
||
|
||
|
||
File: as.info, Node: Section, Next: Set, Prev: Scl, Up: Pseudo Ops
|
||
|
||
`.section NAME'
|
||
===============
|
||
|
||
Use the `.section' directive to assemble the following code into a
|
||
section named NAME.
|
||
|
||
This directive is only supported for targets that actually support
|
||
arbitrarily named sections; on `a.out' targets, for example, it is not
|
||
accepted, even with a standard `a.out' section name.
|
||
|
||
For COFF targets, the `.section' directive is used in one of the
|
||
following ways:
|
||
.section NAME[, "FLAGS"]
|
||
.section NAME[, SUBSEGMENT]
|
||
|
||
If the optional argument is quoted, it is taken as flags to use for
|
||
the section. Each flag is a single character. The following flags are
|
||
recognized:
|
||
`b'
|
||
bss section (uninitialized data)
|
||
|
||
`n'
|
||
section is not loaded
|
||
|
||
`w'
|
||
writable section
|
||
|
||
`d'
|
||
data section
|
||
|
||
`r'
|
||
read-only section
|
||
|
||
`x'
|
||
executable section
|
||
|
||
If no flags are specified, the default flags depend upon the section
|
||
name. If the section name is not recognized, the default will be for
|
||
the section to be loaded and writable.
|
||
|
||
If the optional argument to the `.section' directive is not quoted,
|
||
it is taken as a subsegment number (*note Sub-Sections::.).
|
||
|
||
For ELF targets, the `.section' directive is used like this:
|
||
.section NAME[, "FLAGS"[, @TYPE]]
|
||
The optional FLAGS argument is a quoted string which may contain any
|
||
combintion of the following characters:
|
||
`a'
|
||
section is allocatable
|
||
|
||
`w'
|
||
section is writable
|
||
|
||
`x'
|
||
section is executable
|
||
|
||
The optional TYPE argument may contain one of the following
|
||
constants:
|
||
`@progbits'
|
||
section contains data
|
||
|
||
`@nobits'
|
||
section does not contain data (i.e., section only occupies space)
|
||
|
||
If no flags are specified, the default flags depend upon the section
|
||
name. If the section name is not recognized, the default will be for
|
||
the section to have none of the above flags: it will not be allocated
|
||
in memory, nor writable, nor executable. The section will contain data.
|
||
|
||
For ELF targets, the assembler supports another type of `.section'
|
||
directive for compatibility with the Solaris assembler:
|
||
.section "NAME"[, FLAGS...]
|
||
Note that the section name is quoted. There may be a sequence of
|
||
comma separated flags:
|
||
`#alloc'
|
||
section is allocatable
|
||
|
||
`#write'
|
||
section is writable
|
||
|
||
`#execinstr'
|
||
section is executable
|
||
|
||
|
||
File: as.info, Node: Set, Next: Short, Prev: Section, Up: Pseudo Ops
|
||
|
||
`.set SYMBOL, EXPRESSION'
|
||
=========================
|
||
|
||
Set the value of SYMBOL to EXPRESSION. This changes SYMBOL's value
|
||
and type to conform to EXPRESSION. If SYMBOL was flagged as external,
|
||
it remains flagged (*note Symbol Attributes::.).
|
||
|
||
You may `.set' a symbol many times in the same assembly.
|
||
|
||
If you `.set' a global symbol, the value stored in the object file
|
||
is the last value stored into it.
|
||
|
||
The syntax for `set' on the HPPA is `SYMBOL .set EXPRESSION'.
|
||
|
||
|
||
File: as.info, Node: Short, Next: Single, Prev: Set, Up: Pseudo Ops
|
||
|
||
`.short EXPRESSIONS'
|
||
====================
|
||
|
||
`.short' is normally the same as `.word'. *Note `.word': Word.
|
||
|
||
In some configurations, however, `.short' and `.word' generate
|
||
numbers of different lengths; *note Machine Dependencies::..
|
||
|
||
|
||
File: as.info, Node: Single, Next: Size, Prev: Short, Up: Pseudo Ops
|
||
|
||
`.single FLONUMS'
|
||
=================
|
||
|
||
This directive assembles zero or more flonums, separated by commas.
|
||
It has the same effect as `.float'. The exact kind of floating point
|
||
numbers emitted depends on how `as' is configured. *Note Machine
|
||
Dependencies::.
|
||
|
||
|
||
File: as.info, Node: Size, Next: Skip, Prev: Single, Up: Pseudo Ops
|
||
|
||
`.size'
|
||
=======
|
||
|
||
This directive is generated by compilers to include auxiliary
|
||
debugging information in the symbol table. It is only permitted inside
|
||
`.def'/`.endef' pairs.
|
||
|
||
`.size' is only meaningful when generating COFF format output; when
|
||
`as' is generating `b.out', it accepts this directive but ignores it.
|
||
|
||
|
||
File: as.info, Node: Sleb128, Next: Space, Prev: Skip, Up: Pseudo Ops
|
||
|
||
`.sleb128 EXPRESSIONS'
|
||
======================
|
||
|
||
SLEB128 stands for "signed little endian base 128." This is a
|
||
compact, variable length representation of numbers used by the DWARF
|
||
symbolic debugging format. *Note `.uleb128': Uleb128.
|
||
|
||
|
||
File: as.info, Node: Skip, Next: Sleb128, Prev: Size, Up: Pseudo Ops
|
||
|
||
`.skip SIZE , FILL'
|
||
===================
|
||
|
||
This directive emits SIZE bytes, each of value FILL. Both SIZE and
|
||
FILL are absolute expressions. If the comma and FILL are omitted, FILL
|
||
is assumed to be zero. This is the same as `.space'.
|
||
|
||
|
||
File: as.info, Node: Space, Next: Stab, Prev: Sleb128, Up: Pseudo Ops
|
||
|
||
`.space SIZE , FILL'
|
||
====================
|
||
|
||
This directive emits SIZE bytes, each of value FILL. Both SIZE and
|
||
FILL are absolute expressions. If the comma and FILL are omitted, FILL
|
||
is assumed to be zero. This is the same as `.skip'.
|
||
|
||
*Warning:* `.space' has a completely different meaning for HPPA
|
||
targets; use `.block' as a substitute. See `HP9000 Series 800
|
||
Assembly Language Reference Manual' (HP 92432-90001) for the
|
||
meaning of the `.space' directive. *Note HPPA Assembler
|
||
Directives: HPPA Directives, for a summary.
|
||
|
||
On the AMD 29K, this directive is ignored; it is accepted for
|
||
compatibility with other AMD 29K assemblers.
|
||
|
||
*Warning:* In most versions of the GNU assembler, the directive
|
||
`.space' has the effect of `.block' *Note Machine Dependencies::.
|
||
|
||
|
||
File: as.info, Node: Stab, Next: String, Prev: Space, Up: Pseudo Ops
|
||
|
||
`.stabd, .stabn, .stabs'
|
||
========================
|
||
|
||
There are three directives that begin `.stab'. All emit symbols
|
||
(*note Symbols::.), for use by symbolic debuggers. The symbols are not
|
||
entered in the `as' hash table: they cannot be referenced elsewhere in
|
||
the source file. Up to five fields are required:
|
||
|
||
STRING
|
||
This is the symbol's name. It may contain any character except
|
||
`\000', so is more general than ordinary symbol names. Some
|
||
debuggers used to code arbitrarily complex structures into symbol
|
||
names using this field.
|
||
|
||
TYPE
|
||
An absolute expression. The symbol's type is set to the low 8
|
||
bits of this expression. Any bit pattern is permitted, but `ld'
|
||
and debuggers choke on silly bit patterns.
|
||
|
||
OTHER
|
||
An absolute expression. The symbol's "other" attribute is set to
|
||
the low 8 bits of this expression.
|
||
|
||
DESC
|
||
An absolute expression. The symbol's descriptor is set to the low
|
||
16 bits of this expression.
|
||
|
||
VALUE
|
||
An absolute expression which becomes the symbol's value.
|
||
|
||
If a warning is detected while reading a `.stabd', `.stabn', or
|
||
`.stabs' statement, the symbol has probably already been created; you
|
||
get a half-formed symbol in your object file. This is compatible with
|
||
earlier assemblers!
|
||
|
||
`.stabd TYPE , OTHER , DESC'
|
||
The "name" of the symbol generated is not even an empty string.
|
||
It is a null pointer, for compatibility. Older assemblers used a
|
||
null pointer so they didn't waste space in object files with empty
|
||
strings.
|
||
|
||
The symbol's value is set to the location counter, relocatably.
|
||
When your program is linked, the value of this symbol is the
|
||
address of the location counter when the `.stabd' was assembled.
|
||
|
||
`.stabn TYPE , OTHER , DESC , VALUE'
|
||
The name of the symbol is set to the empty string `""'.
|
||
|
||
`.stabs STRING , TYPE , OTHER , DESC , VALUE'
|
||
All five fields are specified.
|
||
|
||
|
||
File: as.info, Node: String, Next: Symver, Prev: Stab, Up: Pseudo Ops
|
||
|
||
`.string' "STR"
|
||
===============
|
||
|
||
Copy the characters in STR to the object file. You may specify more
|
||
than one string to copy, separated by commas. Unless otherwise
|
||
specified for a particular machine, the assembler marks the end of each
|
||
string with a 0 byte. You can use any of the escape sequences
|
||
described in *Note Strings: Strings.
|
||
|
||
|
||
File: as.info, Node: Symver, Next: Tag, Prev: String, Up: Pseudo Ops
|
||
|
||
`.symver'
|
||
=========
|
||
|
||
Use the `.symver' directive to bind symbols to specific version nodes
|
||
within a source file. This is only supported on ELF platforms, and is
|
||
typically used when assembling files to be linked into a shared library.
|
||
There are cases where it may make sense to use this in objects to be
|
||
bound into an application itself so as to override a versioned symbol
|
||
from a shared library.
|
||
|
||
For ELF targets, the `.symver' directive is used like this:
|
||
.symver NAME, NAME2@NODENAME
|
||
In this case, the symbol NAME must exist and be defined within the
|
||
file being assembled. The `.versym' directive effectively creates a
|
||
symbol alias with the name NAME2@NODENAME, and in fact the main reason
|
||
that we just don't try and create a regular alias is that the @
|
||
character isn't permitted in symbol names. The NAME2 part of the name
|
||
is the actual name of the symbol by which it will be externally
|
||
referenced. The name NAME itself is merely a name of convenience that
|
||
is used so that it is possible to have definitions for multiple
|
||
versions of a function within a single source file, and so that the
|
||
compiler can unambiguously know which version of a function is being
|
||
mentioned. The NODENAME portion of the alias should be the name of a
|
||
node specified in the version script supplied to the linker when
|
||
building a shared library. If you are attempting to override a
|
||
versioned symbol from a shared library, then NODENAME should correspond
|
||
to the nodename of the symbol you are trying to override.
|
||
|
||
|
||
File: as.info, Node: Tag, Next: Text, Prev: Symver, Up: Pseudo Ops
|
||
|
||
`.tag STRUCTNAME'
|
||
=================
|
||
|
||
This directive is generated by compilers to include auxiliary
|
||
debugging information in the symbol table. It is only permitted inside
|
||
`.def'/`.endef' pairs. Tags are used to link structure definitions in
|
||
the symbol table with instances of those structures.
|
||
|
||
`.tag' is only used when generating COFF format output; when `as' is
|
||
generating `b.out', it accepts this directive but ignores it.
|
||
|
||
|
||
File: as.info, Node: Text, Next: Title, Prev: Tag, Up: Pseudo Ops
|
||
|
||
`.text SUBSECTION'
|
||
==================
|
||
|
||
Tells `as' to assemble the following statements onto the end of the
|
||
text subsection numbered SUBSECTION, which is an absolute expression.
|
||
If SUBSECTION is omitted, subsection number zero is used.
|
||
|
||
|
||
File: as.info, Node: Title, Next: Type, Prev: Text, Up: Pseudo Ops
|
||
|
||
`.title "HEADING"'
|
||
==================
|
||
|
||
Use HEADING as the title (second line, immediately after the source
|
||
file name and pagenumber) when generating assembly listings.
|
||
|
||
This directive affects subsequent pages, as well as the current page
|
||
if it appears within ten lines of the top of a page.
|
||
|
||
|
||
File: as.info, Node: Type, Next: Val, Prev: Title, Up: Pseudo Ops
|
||
|
||
`.type INT'
|
||
===========
|
||
|
||
This directive, permitted only within `.def'/`.endef' pairs, records
|
||
the integer INT as the type attribute of a symbol table entry.
|
||
|
||
`.type' is associated only with COFF format output; when `as' is
|
||
configured for `b.out' output, it accepts this directive but ignores it.
|
||
|
||
|
||
File: as.info, Node: Val, Next: Uleb128, Prev: Type, Up: Pseudo Ops
|
||
|
||
`.val ADDR'
|
||
===========
|
||
|
||
This directive, permitted only within `.def'/`.endef' pairs, records
|
||
the address ADDR as the value attribute of a symbol table entry.
|
||
|
||
`.val' is used only for COFF output; when `as' is configured for
|
||
`b.out', it accepts this directive but ignores it.
|
||
|
||
|
||
File: as.info, Node: Uleb128, Next: Word, Prev: Val, Up: Pseudo Ops
|
||
|
||
`.uleb128 EXPRESSIONS'
|
||
======================
|
||
|
||
ULEB128 stands for "unsigned little endian base 128." This is a
|
||
compact, variable length representation of numbers used by the DWARF
|
||
symbolic debugging format. *Note `.sleb128': Sleb128.
|
||
|
||
|
||
File: as.info, Node: Word, Next: Deprecated, Prev: Uleb128, Up: Pseudo Ops
|
||
|
||
`.word EXPRESSIONS'
|
||
===================
|
||
|
||
This directive expects zero or more EXPRESSIONS, of any section,
|
||
separated by commas.
|
||
|
||
The size of the number emitted, and its byte order, depend on what
|
||
target computer the assembly is for.
|
||
|
||
*Warning: Special Treatment to support Compilers*
|
||
|
||
Machines with a 32-bit address space, but that do less than 32-bit
|
||
addressing, require the following special treatment. If the machine of
|
||
interest to you does 32-bit addressing (or doesn't require it; *note
|
||
Machine Dependencies::.), you can ignore this issue.
|
||
|
||
In order to assemble compiler output into something that works, `as'
|
||
occasionlly does strange things to `.word' directives. Directives of
|
||
the form `.word sym1-sym2' are often emitted by compilers as part of
|
||
jump tables. Therefore, when `as' assembles a directive of the form
|
||
`.word sym1-sym2', and the difference between `sym1' and `sym2' does
|
||
not fit in 16 bits, `as' creates a "secondary jump table", immediately
|
||
before the next label. This secondary jump table is preceded by a
|
||
short-jump to the first byte after the secondary table. This
|
||
short-jump prevents the flow of control from accidentally falling into
|
||
the new table. Inside the table is a long-jump to `sym2'. The
|
||
original `.word' contains `sym1' minus the address of the long-jump to
|
||
`sym2'.
|
||
|
||
If there were several occurrences of `.word sym1-sym2' before the
|
||
secondary jump table, all of them are adjusted. If there was a `.word
|
||
sym3-sym4', that also did not fit in sixteen bits, a long-jump to
|
||
`sym4' is included in the secondary jump table, and the `.word'
|
||
directives are adjusted to contain `sym3' minus the address of the
|
||
long-jump to `sym4'; and so on, for as many entries in the original
|
||
jump table as necessary.
|
||
|
||
|
||
File: as.info, Node: Deprecated, Prev: Word, Up: Pseudo Ops
|
||
|
||
Deprecated Directives
|
||
=====================
|
||
|
||
One day these directives won't work. They are included for
|
||
compatibility with older assemblers.
|
||
.abort
|
||
|
||
.app-file
|
||
|
||
.line
|
||
|
||
File: as.info, Node: Machine Dependencies, Next: Reporting Bugs, Prev: Pseudo Ops, Up: Top
|
||
|
||
Machine Dependent Features
|
||
**************************
|
||
|
||
The machine instruction sets are (almost by definition) different on
|
||
each machine where `as' runs. Floating point representations vary as
|
||
well, and `as' often supports a few additional directives or
|
||
command-line options for compatibility with other assemblers on a
|
||
particular platform. Finally, some versions of `as' support special
|
||
pseudo-instructions for branch optimization.
|
||
|
||
This chapter discusses most of these differences, though it does not
|
||
include details on any machine's instruction set. For details on that
|
||
subject, see the hardware manufacturer's manual.
|
||
|
||
* Menu:
|
||
|
||
|
||
* AMD29K-Dependent:: AMD 29K Dependent Features
|
||
|
||
* ARC-Dependent:: ARC Dependent Features
|
||
|
||
* ARM-Dependent:: ARM Dependent Features
|
||
|
||
* D10V-Dependent:: D10V Dependent Features
|
||
|
||
* H8/300-Dependent:: Hitachi H8/300 Dependent Features
|
||
|
||
* H8/500-Dependent:: Hitachi H8/500 Dependent Features
|
||
|
||
* HPPA-Dependent:: HPPA Dependent Features
|
||
|
||
* i386-Dependent:: Intel 80386 Dependent Features
|
||
|
||
* i960-Dependent:: Intel 80960 Dependent Features
|
||
|
||
* M68K-Dependent:: M680x0 Dependent Features
|
||
|
||
* MIPS-Dependent:: MIPS Dependent Features
|
||
|
||
* SH-Dependent:: Hitachi SH Dependent Features
|
||
|
||
* Sparc-Dependent:: SPARC Dependent Features
|
||
|
||
* V850-Dependent:: V850 Dependent Features
|
||
|
||
* Z8000-Dependent:: Z8000 Dependent Features
|
||
|
||
* Vax-Dependent:: VAX Dependent Features
|
||
|
||
|
||
File: as.info, Node: ARC-Dependent, Next: ARM-Dependent, Prev: AMD29K-Dependent, Up: Machine Dependencies
|
||
|
||
ARC Dependent Features
|
||
======================
|
||
|
||
* Menu:
|
||
|
||
* ARC-Opts:: Options
|
||
* ARC-Float:: Floating Point
|
||
* ARC-Directives:: Sparc Machine Directives
|
||
|
||
|
||
File: as.info, Node: ARC-Opts, Next: ARC-Float, Up: ARC-Dependent
|
||
|
||
Options
|
||
-------
|
||
|
||
The ARC chip family includes several successive levels (or other
|
||
variants) of chip, using the same core instruction set, but including a
|
||
few additional instructions at each level.
|
||
|
||
By default, `as' assumes the core instruction set (ARC base). The
|
||
`.cpu' pseudo-op is intended to be used to select the variant.
|
||
|
||
`-mbig-endian'
|
||
`-mlittle-endian'
|
||
Any ARC configuration of `as' can select big-endian or
|
||
little-endian output at run time (unlike most other GNU development
|
||
tools, which must be configured for one or the other). Use
|
||
`-mbig-endian' to select big-endian output, and `-mlittle-endian'
|
||
for little-endian.
|
||
|
||
|
||
File: as.info, Node: ARC-Float, Next: ARC-Directives, Prev: ARC-Opts, Up: ARC-Dependent
|
||
|
||
Floating Point
|
||
--------------
|
||
|
||
The ARC cpu family currently does not have hardware floating point
|
||
support. Software floating point support is provided by `GCC' and uses
|
||
IEEE floating-point numbers.
|
||
|
||
|
||
File: as.info, Node: ARC-Directives, Prev: ARC-Float, Up: ARC-Dependent
|
||
|
||
ARC Machine Directives
|
||
----------------------
|
||
|
||
The ARC version of `as' supports the following additional machine
|
||
directives:
|
||
|
||
`.cpu'
|
||
This must be followed by the desired cpu. The ARC is intended to
|
||
be customizable, `.cpu' is used to select the desired variant
|
||
[though currently there are none].
|
||
|
||
|
||
File: as.info, Node: AMD29K-Dependent, Next: ARC-Dependent, Up: Machine Dependencies
|
||
|
||
AMD 29K Dependent Features
|
||
==========================
|
||
|
||
* Menu:
|
||
|
||
* AMD29K Options:: Options
|
||
* AMD29K Syntax:: Syntax
|
||
* AMD29K Floating Point:: Floating Point
|
||
* AMD29K Directives:: AMD 29K Machine Directives
|
||
* AMD29K Opcodes:: Opcodes
|
||
|
||
|
||
File: as.info, Node: AMD29K Options, Next: AMD29K Syntax, Up: AMD29K-Dependent
|
||
|
||
Options
|
||
-------
|
||
|
||
`as' has no additional command-line options for the AMD 29K family.
|
||
|
||
|
||
File: as.info, Node: AMD29K Syntax, Next: AMD29K Floating Point, Prev: AMD29K Options, Up: AMD29K-Dependent
|
||
|
||
Syntax
|
||
------
|
||
|
||
* Menu:
|
||
|
||
* AMD29K-Macros:: Macros
|
||
* AMD29K-Chars:: Special Characters
|
||
* AMD29K-Regs:: Register Names
|
||
|
||
|
||
File: as.info, Node: AMD29K-Macros, Next: AMD29K-Chars, Up: AMD29K Syntax
|
||
|
||
Macros
|
||
......
|
||
|
||
The macro syntax used on the AMD 29K is like that described in the
|
||
AMD 29K Family Macro Assembler Specification. Normal `as' macros
|
||
should still work.
|
||
|
||
|
||
File: as.info, Node: AMD29K-Chars, Next: AMD29K-Regs, Prev: AMD29K-Macros, Up: AMD29K Syntax
|
||
|
||
Special Characters
|
||
..................
|
||
|
||
`;' is the line comment character.
|
||
|
||
The character `?' is permitted in identifiers (but may not begin an
|
||
identifier).
|
||
|
||
|
||
File: as.info, Node: AMD29K-Regs, Prev: AMD29K-Chars, Up: AMD29K Syntax
|
||
|
||
Register Names
|
||
..............
|
||
|
||
General-purpose registers are represented by predefined symbols of
|
||
the form `GRNNN' (for global registers) or `LRNNN' (for local
|
||
registers), where NNN represents a number between `0' and `127',
|
||
written with no leading zeros. The leading letters may be in either
|
||
upper or lower case; for example, `gr13' and `LR7' are both valid
|
||
register names.
|
||
|
||
You may also refer to general-purpose registers by specifying the
|
||
register number as the result of an expression (prefixed with `%%' to
|
||
flag the expression as a register number):
|
||
%%EXPRESSION
|
||
|
||
--where EXPRESSION must be an absolute expression evaluating to a
|
||
number between `0' and `255'. The range [0, 127] refers to global
|
||
registers, and the range [128, 255] to local registers.
|
||
|
||
In addition, `as' understands the following protected
|
||
special-purpose register names for the AMD 29K family:
|
||
|
||
vab chd pc0
|
||
ops chc pc1
|
||
cps rbp pc2
|
||
cfg tmc mmu
|
||
cha tmr lru
|
||
|
||
These unprotected special-purpose register names are also recognized:
|
||
ipc alu fpe
|
||
ipa bp inte
|
||
ipb fc fps
|
||
q cr exop
|
||
|
||
|
||
File: as.info, Node: AMD29K Floating Point, Next: AMD29K Directives, Prev: AMD29K Syntax, Up: AMD29K-Dependent
|
||
|
||
Floating Point
|
||
--------------
|
||
|
||
The AMD 29K family uses IEEE floating-point numbers.
|
||
|
||
|
||
File: as.info, Node: AMD29K Directives, Next: AMD29K Opcodes, Prev: AMD29K Floating Point, Up: AMD29K-Dependent
|
||
|
||
AMD 29K Machine Directives
|
||
--------------------------
|
||
|
||
`.block SIZE , FILL'
|
||
This directive emits SIZE bytes, each of value FILL. Both SIZE
|
||
and FILL are absolute expressions. If the comma and FILL are
|
||
omitted, FILL is assumed to be zero.
|
||
|
||
In other versions of the GNU assembler, this directive is called
|
||
`.space'.
|
||
|
||
`.cputype'
|
||
This directive is ignored; it is accepted for compatibility with
|
||
other AMD 29K assemblers.
|
||
|
||
`.file'
|
||
This directive is ignored; it is accepted for compatibility with
|
||
other AMD 29K assemblers.
|
||
|
||
*Warning:* in other versions of the GNU assembler, `.file' is
|
||
used for the directive called `.app-file' in the AMD 29K
|
||
support.
|
||
|
||
`.line'
|
||
This directive is ignored; it is accepted for compatibility with
|
||
other AMD 29K assemblers.
|
||
|
||
`.sect'
|
||
This directive is ignored; it is accepted for compatibility with
|
||
other AMD 29K assemblers.
|
||
|
||
`.use SECTION NAME'
|
||
Establishes the section and subsection for the following code;
|
||
SECTION NAME may be one of `.text', `.data', `.data1', or `.lit'.
|
||
With one of the first three SECTION NAME options, `.use' is
|
||
equivalent to the machine directive SECTION NAME; the remaining
|
||
case, `.use .lit', is the same as `.data 200'.
|
||
|
||
|
||
File: as.info, Node: AMD29K Opcodes, Prev: AMD29K Directives, Up: AMD29K-Dependent
|
||
|
||
Opcodes
|
||
-------
|
||
|
||
`as' implements all the standard AMD 29K opcodes. No additional
|
||
pseudo-instructions are needed on this family.
|
||
|
||
For information on the 29K machine instruction set, see `Am29000
|
||
User's Manual', Advanced Micro Devices, Inc.
|
||
|
||
|
||
File: as.info, Node: ARM-Dependent, Next: D10V-Dependent, Prev: ARC-Dependent, Up: Machine Dependencies
|
||
|
||
ARM Dependent Features
|
||
======================
|
||
|
||
* Menu:
|
||
|
||
* ARM Options:: Options
|
||
* ARM Syntax:: Syntax
|
||
* ARM Floating Point:: Floating Point
|
||
* ARM Directives:: ARM Machine Directives
|
||
* ARM Opcodes:: Opcodes
|
||
|
||
|
||
File: as.info, Node: ARM Options, Next: ARM Syntax, Up: ARM-Dependent
|
||
|
||
Options
|
||
-------
|
||
|
||
`-marm [2|250|3|6|60|600|610|620|7|7M|7D|7DM|7DI|7DMI|70|700|700I|710|710C|7100|7500|7500FE|7TDMI|8|STRONGARM|STRONGARM110]'
|
||
This option specifies the target processor. The assembler will
|
||
issue an error message if an attempt is made to assemble an
|
||
instruction which will not execute on the target processor.
|
||
|
||
`-marmv [2|2A|3|3M|4|4T]'
|
||
This option specifies the target architecture. The assembler will
|
||
issue an error message if an attempt is made to assemble an
|
||
instruction which will not execute on the target architecture.
|
||
|
||
`-mthumb'
|
||
This option specifies that only Thumb instructions should be
|
||
assembled.
|
||
|
||
`-mall'
|
||
This option specifies that any Arm or Thumb instruction should be
|
||
assembled.
|
||
|
||
`-mfpa [10|11]'
|
||
This option specifies the floating point architecture in use on the
|
||
target processor.
|
||
|
||
`-mfpe-old'
|
||
Do not allow the assemble of floating point multiple instructions.
|
||
|
||
`-mno-fpu'
|
||
Do not allow the assembly of any floating point instructions.
|
||
|
||
`-mthumb-interwork'
|
||
This option specifies that the output generated by the assembler
|
||
should be marked as supporting interworking.
|
||
|
||
`-mapcs [26|32]'
|
||
This option specifies that the output generated by the assembler
|
||
should be marked as supporting the indicated version of the Arm
|
||
Procedure. Calling Standard.
|
||
|
||
`-EB'
|
||
This option specifies that the output generated by the assembler
|
||
should be marked as being encoded for a big-endian processor.
|
||
|
||
`-EL'
|
||
This option specifies that the output generated by the assembler
|
||
should be marked as being encoded for a little-endian processor.
|
||
|
||
|
||
File: as.info, Node: ARM Syntax, Next: ARM Floating Point, Prev: ARM Options, Up: ARM-Dependent
|
||
|
||
Syntax
|
||
------
|
||
|
||
* Menu:
|
||
|
||
* ARM-Chars:: Special Characters
|
||
* ARM-Regs:: Register Names
|
||
|
||
|
||
File: as.info, Node: ARM-Chars, Next: ARM-Regs, Up: ARM Syntax
|
||
|
||
Special Characters
|
||
..................
|
||
|
||
`;' is the line comment character.
|
||
|
||
*TODO* Explain about /data modifier on symbols.
|
||
|
||
|
||
File: as.info, Node: ARM-Regs, Prev: ARM-Chars, Up: ARM Syntax
|
||
|
||
Register Names
|
||
..............
|
||
|
||
*TODO* Explain about ARM register naming, and the predefined names.
|
||
|
||
|
||
File: as.info, Node: ARM Floating Point, Next: ARM Directives, Prev: ARM Syntax, Up: ARM-Dependent
|
||
|
||
Floating Point
|
||
--------------
|
||
|
||
The ARM family uses IEEE floating-point numbers.
|
||
|
||
|
||
File: as.info, Node: ARM Directives, Next: ARM Opcodes, Prev: ARM Floating Point, Up: ARM-Dependent
|
||
|
||
ARM Machine Directives
|
||
----------------------
|
||
|
||
`.code [16|32]'
|
||
This directive selects the instruction set being generated. The
|
||
value 16 selects Thumb, with the value 32 selecting ARM.
|
||
|
||
`.thumb'
|
||
This performs the same action as .CODE 16.
|
||
|
||
`.arm'
|
||
This performs the same action as .CODE 32.
|
||
|
||
`.force_thumb'
|
||
This directive forces the selection of Thumb instructions, even if
|
||
the target processor does not support those instructions
|
||
|
||
`.thumb_func'
|
||
This directive specifies that the following symbol is the name of a
|
||
Thumb encoded function. This information is necessary in order to
|
||
allow the assembler and linker to generate correct code for
|
||
interworking between Arm and Thumb instructions and should be used
|
||
even if interworking is not going to be performed.
|
||
|
||
|
||
File: as.info, Node: ARM Opcodes, Prev: ARM Directives, Up: ARM-Dependent
|
||
|
||
Opcodes
|
||
-------
|
||
|
||
`as' implements all the standard ARM opcodes.
|
||
|
||
*TODO* Document the pseudo-ops (adr, nop)
|
||
|
||
For information on the ARM or Thumb instruction sets, see `ARM
|
||
Software Development Toolkit Reference Manual', Advanced RISC Machines
|
||
Ltd.
|
||
|
||
|
||
File: as.info, Node: D10V-Dependent, Next: H8/300-Dependent, Prev: ARM-Dependent, Up: Machine Dependencies
|
||
|
||
D10V Dependent Features
|
||
=======================
|
||
|
||
* Menu:
|
||
|
||
* D10V-Opts:: D10V Options
|
||
* D10V-Syntax:: Syntax
|
||
* D10V-Float:: Floating Point
|
||
* D10V-Opcodes:: Opcodes
|
||
|
||
|
||
File: as.info, Node: D10V-Opts, Next: D10V-Syntax, Up: D10V-Dependent
|
||
|
||
D10V Options
|
||
------------
|
||
|
||
The Mitsubishi D10V version of `as' has a few machine dependent
|
||
options.
|
||
|
||
`-O'
|
||
The D10V can often execute two sub-instructions in parallel. When
|
||
this option is used, `as' will attempt to optimize its output by
|
||
detecting when instructions can be executed in parallel.
|
||
|
||
`--nowarnswap'
|
||
To optimize execution performance, `as' will sometimes swap the
|
||
order of instructions. Normally this generates a warning. When
|
||
this option is used, no warning will be generated when
|
||
instructions are swapped.
|
||
|
||
|
||
File: as.info, Node: D10V-Syntax, Next: D10V-Float, Prev: D10V-Opts, Up: D10V-Dependent
|
||
|
||
Syntax
|
||
------
|
||
|
||
The D10V syntax is based on the syntax in Mitsubishi's D10V
|
||
architecture manual. The differences are detailed below.
|
||
|
||
* Menu:
|
||
|
||
* D10V-Size:: Size Modifiers
|
||
* D10V-Subs:: Sub-Instructions
|
||
* D10V-Chars:: Special Characters
|
||
* D10V-Regs:: Register Names
|
||
* D10V-Addressing:: Addressing Modes
|
||
* D10V-Word:: @WORD Modifier
|
||
|
||
|
||
File: as.info, Node: D10V-Size, Next: D10V-Subs, Up: D10V-Syntax
|
||
|
||
Size Modifiers
|
||
..............
|
||
|
||
The D10V version of `as' uses the instruction names in the D10V
|
||
Architecture Manual. However, the names in the manual are sometimes
|
||
ambiguous. There are instruction names that can assemble to a short or
|
||
long form opcode. How does the assembler pick the correct form? `as'
|
||
will always pick the smallest form if it can. When dealing with a
|
||
symbol that is not defined yet when a line is being assembled, it will
|
||
always use the long form. If you need to force the assembler to use
|
||
either the short or long form of the instruction, you can append either
|
||
`.s' (short) or `.l' (long) to it. For example, if you are writing an
|
||
assembly program and you want to do a branch to a symbol that is
|
||
defined later in your program, you can write `bra.s foo'. Objdump
|
||
and GDB will always append `.s' or `.l' to instructions which have both
|
||
short and long forms.
|
||
|
||
|
||
File: as.info, Node: D10V-Subs, Next: D10V-Chars, Prev: D10V-Size, Up: D10V-Syntax
|
||
|
||
Sub-Instructions
|
||
................
|
||
|
||
The D10V assembler takes as input a series of instructions, either
|
||
one-per-line, or in the special two-per-line format described in the
|
||
next section. Some of these instructions will be short-form or
|
||
sub-instructions. These sub-instructions can be packed into a single
|
||
instruction. The assembler will do this automatically. It will also
|
||
detect when it should not pack instructions. For example, when a label
|
||
is defined, the next instruction will never be packaged with the
|
||
previous one. Whenever a branch and link instruction is called, it
|
||
will not be packaged with the next instruction so the return address
|
||
will be valid. Nops are automatically inserted when necessary.
|
||
|
||
If you do not want the assembler automatically making these
|
||
decisions, you can control the packaging and execution type (parallel
|
||
or sequential) with the special execution symbols described in the next
|
||
section.
|
||
|
||
|
||
File: as.info, Node: D10V-Chars, Next: D10V-Regs, Prev: D10V-Subs, Up: D10V-Syntax
|
||
|
||
Special Characters
|
||
..................
|
||
|
||
`;' and `#' are the line comment characters. Sub-instructions may
|
||
be executed in order, in reverse-order, or in parallel. Instructions
|
||
listed in the standard one-per-line format will be executed
|
||
sequentially. To specify the executing order, use the following
|
||
symbols:
|
||
`->'
|
||
Sequential with instruction on the left first.
|
||
|
||
`<-'
|
||
Sequential with instruction on the right first.
|
||
|
||
`||'
|
||
Parallel The D10V syntax allows either one instruction per line,
|
||
one instruction per line with the execution symbol, or two instructions
|
||
per line. For example
|
||
`abs a1 -> abs r0'
|
||
Execute these sequentially. The instruction on the right is in
|
||
the right container and is executed second.
|
||
|
||
`abs r0 <- abs a1'
|
||
Execute these reverse-sequentially. The instruction on the right
|
||
is in the right container, and is executed first.
|
||
|
||
`ld2w r2,@r8+ || mac a0,r0,r7'
|
||
Execute these in parallel.
|
||
|
||
`ld2w r2,@r8+ ||'
|
||
`mac a0,r0,r7'
|
||
Two-line format. Execute these in parallel.
|
||
|
||
`ld2w r2,@r8+'
|
||
`mac a0,r0,r7'
|
||
Two-line format. Execute these sequentially. Assembler will put
|
||
them in the proper containers.
|
||
|
||
`ld2w r2,@r8+ ->'
|
||
`mac a0,r0,r7'
|
||
Two-line format. Execute these sequentially. Same as above but
|
||
second instruction will always go into right container. Since `$'
|
||
has no special meaning, you may use it in symbol names.
|
||
|
||
|
||
File: as.info, Node: D10V-Regs, Next: D10V-Addressing, Prev: D10V-Chars, Up: D10V-Syntax
|
||
|
||
Register Names
|
||
..............
|
||
|
||
You can use the predefined symbols `r0' through `r15' to refer to
|
||
the D10V registers. You can also use `sp' as an alias for `r15'. The
|
||
accumulators are `a0' and `a1'. There are special register-pair names
|
||
that may optionally be used in opcodes that require even-numbered
|
||
registers. Register names are not case sensitive.
|
||
|
||
Register Pairs
|
||
`r0-r1'
|
||
|
||
`r2-r3'
|
||
|
||
`r4-r5'
|
||
|
||
`r6-r7'
|
||
|
||
`r8-r9'
|
||
|
||
`r10-r11'
|
||
|
||
`r12-r13'
|
||
|
||
`r14-r15'
|
||
The D10V also has predefined symbols for these control registers and
|
||
status bits:
|
||
`psw'
|
||
Processor Status Word
|
||
|
||
`bpsw'
|
||
Backup Processor Status Word
|
||
|
||
`pc'
|
||
Program Counter
|
||
|
||
`bpc'
|
||
Backup Program Counter
|
||
|
||
`rpt_c'
|
||
Repeat Count
|
||
|
||
`rpt_s'
|
||
Repeat Start address
|
||
|
||
`rpt_e'
|
||
Repeat End address
|
||
|
||
`mod_s'
|
||
Modulo Start address
|
||
|
||
`mod_e'
|
||
Modulo End address
|
||
|
||
`iba'
|
||
Instruction Break Address
|
||
|
||
`f0'
|
||
Flag 0
|
||
|
||
`f1'
|
||
Flag 1
|
||
|
||
`c'
|
||
Carry flag
|
||
|
||
|
||
File: as.info, Node: D10V-Addressing, Next: D10V-Word, Prev: D10V-Regs, Up: D10V-Syntax
|
||
|
||
Addressing Modes
|
||
................
|
||
|
||
`as' understands the following addressing modes for the D10V. `RN'
|
||
in the following refers to any of the numbered registers, but *not* the
|
||
control registers.
|
||
`RN'
|
||
Register direct
|
||
|
||
`@RN'
|
||
Register indirect
|
||
|
||
`@RN+'
|
||
Register indirect with post-increment
|
||
|
||
`@RN-'
|
||
Register indirect with post-decrement
|
||
|
||
`@-SP'
|
||
Register indirect with pre-decrement
|
||
|
||
`@(DISP, RN)'
|
||
Register indirect with displacement
|
||
|
||
`ADDR'
|
||
PC relative address (for branch or rep).
|
||
|
||
`#IMM'
|
||
Immediate data (the `#' is optional and ignored)
|
||
|
||
|
||
File: as.info, Node: D10V-Word, Prev: D10V-Addressing, Up: D10V-Syntax
|
||
|
||
@WORD Modifier
|
||
..............
|
||
|
||
Any symbol followed by `@word' will be replaced by the symbol's value
|
||
shifted right by 2. This is used in situations such as loading a
|
||
register with the address of a function (or any other code fragment).
|
||
For example, if you want to load a register with the location of the
|
||
function `main' then jump to that function, you could do it as follws:
|
||
ldi r2, main@word
|
||
jmp r2
|
||
|
||
|
||
File: as.info, Node: D10V-Float, Next: D10V-Opcodes, Prev: D10V-Syntax, Up: D10V-Dependent
|
||
|
||
Floating Point
|
||
--------------
|
||
|
||
The D10V has no hardware floating point, but the `.float' and
|
||
`.double' directives generates IEEE floating-point numbers for
|
||
compatibility with other development tools.
|
||
|
||
|
||
File: as.info, Node: D10V-Opcodes, Prev: D10V-Float, Up: D10V-Dependent
|
||
|
||
Opcodes
|
||
-------
|
||
|
||
For detailed information on the D10V machine instruction set, see
|
||
`D10V Architecture: A VLIW Microprocessor for Multimedia Applications'
|
||
(Mitsubishi Electric Corp.). `as' implements all the standard D10V
|
||
opcodes. The only changes are those described in the section on size
|
||
modifiers
|
||
|
||
|
||
File: as.info, Node: H8/300-Dependent, Next: H8/500-Dependent, Prev: D10V-Dependent, Up: Machine Dependencies
|
||
|
||
H8/300 Dependent Features
|
||
=========================
|
||
|
||
* Menu:
|
||
|
||
* H8/300 Options:: Options
|
||
* H8/300 Syntax:: Syntax
|
||
* H8/300 Floating Point:: Floating Point
|
||
* H8/300 Directives:: H8/300 Machine Directives
|
||
* H8/300 Opcodes:: Opcodes
|
||
|
||
|
||
File: as.info, Node: H8/300 Options, Next: H8/300 Syntax, Up: H8/300-Dependent
|
||
|
||
Options
|
||
-------
|
||
|
||
`as' has no additional command-line options for the Hitachi H8/300
|
||
family.
|
||
|
||
|
||
File: as.info, Node: H8/300 Syntax, Next: H8/300 Floating Point, Prev: H8/300 Options, Up: H8/300-Dependent
|
||
|
||
Syntax
|
||
------
|
||
|
||
* Menu:
|
||
|
||
* H8/300-Chars:: Special Characters
|
||
* H8/300-Regs:: Register Names
|
||
* H8/300-Addressing:: Addressing Modes
|
||
|
||
|
||
File: as.info, Node: H8/300-Chars, Next: H8/300-Regs, Up: H8/300 Syntax
|
||
|
||
Special Characters
|
||
..................
|
||
|
||
`;' is the line comment character.
|
||
|
||
`$' can be used instead of a newline to separate statements.
|
||
Therefore *you may not use `$' in symbol names* on the H8/300.
|
||
|
||
|
||
File: as.info, Node: H8/300-Regs, Next: H8/300-Addressing, Prev: H8/300-Chars, Up: H8/300 Syntax
|
||
|
||
Register Names
|
||
..............
|
||
|
||
You can use predefined symbols of the form `rNh' and `rNl' to refer
|
||
to the H8/300 registers as sixteen 8-bit general-purpose registers. N
|
||
is a digit from `0' to `7'); for instance, both `r0h' and `r7l' are
|
||
valid register names.
|
||
|
||
You can also use the eight predefined symbols `rN' to refer to the
|
||
H8/300 registers as 16-bit registers (you must use this form for
|
||
addressing).
|
||
|
||
On the H8/300H, you can also use the eight predefined symbols `erN'
|
||
(`er0' ... `er7') to refer to the 32-bit general purpose registers.
|
||
|
||
The two control registers are called `pc' (program counter; a 16-bit
|
||
register, except on the H8/300H where it is 24 bits) and `ccr'
|
||
(condition code register; an 8-bit register). `r7' is used as the
|
||
stack pointer, and can also be called `sp'.
|
||
|
||
|
||
File: as.info, Node: H8/300-Addressing, Prev: H8/300-Regs, Up: H8/300 Syntax
|
||
|
||
Addressing Modes
|
||
................
|
||
|
||
as understands the following addressing modes for the H8/300:
|
||
`rN'
|
||
Register direct
|
||
|
||
`@rN'
|
||
Register indirect
|
||
|
||
`@(D, rN)'
|
||
`@(D:16, rN)'
|
||
`@(D:24, rN)'
|
||
Register indirect: 16-bit or 24-bit displacement D from register
|
||
N. (24-bit displacements are only meaningful on the H8/300H.)
|
||
|
||
`@rN+'
|
||
Register indirect with post-increment
|
||
|
||
`@-rN'
|
||
Register indirect with pre-decrement
|
||
|
||
``@'AA'
|
||
``@'AA:8'
|
||
``@'AA:16'
|
||
``@'AA:24'
|
||
Absolute address `aa'. (The address size `:24' only makes sense
|
||
on the H8/300H.)
|
||
|
||
`#XX'
|
||
`#XX:8'
|
||
`#XX:16'
|
||
`#XX:32'
|
||
Immediate data XX. You may specify the `:8', `:16', or `:32' for
|
||
clarity, if you wish; but `as' neither requires this nor uses
|
||
it--the data size required is taken from context.
|
||
|
||
``@'`@'AA'
|
||
``@'`@'AA:8'
|
||
Memory indirect. You may specify the `:8' for clarity, if you
|
||
wish; but `as' neither requires this nor uses it.
|
||
|
||
|
||
File: as.info, Node: H8/300 Floating Point, Next: H8/300 Directives, Prev: H8/300 Syntax, Up: H8/300-Dependent
|
||
|
||
Floating Point
|
||
--------------
|
||
|
||
The H8/300 family has no hardware floating point, but the `.float'
|
||
directive generates IEEE floating-point numbers for compatibility with
|
||
other development tools.
|
||
|
||
|
||
File: as.info, Node: H8/300 Directives, Next: H8/300 Opcodes, Prev: H8/300 Floating Point, Up: H8/300-Dependent
|
||
|
||
H8/300 Machine Directives
|
||
-------------------------
|
||
|
||
`as' has only one machine-dependent directive for the H8/300:
|
||
|
||
`.h8300h'
|
||
Recognize and emit additional instructions for the H8/300H
|
||
variant, and also make `.int' emit 32-bit numbers rather than the
|
||
usual (16-bit) for the H8/300 family.
|
||
|
||
On the H8/300 family (including the H8/300H) `.word' directives
|
||
generate 16-bit numbers.
|
||
|