github/amigaos-binutils
2
0
Fork 0
mirror of https://frontier.innolan.net/github/amigaos-binutils.git synced 2025-11-21 20:11:31 +00:00
Code Releases Activity
Files
fd791101b615a785ecc0f20423e2f9d25b8996bb
amigaos-binutils/gas/doc/as.info-9
Jens Maus 7d10307602 - importing initial 2.14 binutiles vendor version.
2006-03-15 23:16:57 +00:00

1321 lines
48 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This is as.info, produced by makeinfo version 4.3 from as.texinfo.
START-INFO-DIR-ENTRY
* As: (as). The GNU assembler.
* Gas: (as). The GNU assembler.
END-INFO-DIR-ENTRY
This file documents the GNU Assembler "as".
Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 2001, 2002
Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts. A copy of the license is included in the section entitled "GNU
Free Documentation License".

File: as.info, Node: SH64 Opcodes, Prev: SH64 Directives, Up: SH64-Dependent
Opcodes
-------
For detailed information on the SH64 machine instruction set, see
`SuperH 64 bit RISC Series Architecture Manual' (SuperH, Inc.).
`as' implements all the standard SH64 opcodes. In addition, the
following pseudo-opcodes may be expanded into one or more alternate
opcodes:
`movi'
If the value doesn't fit into a standard `movi' opcode, `as' will
replace the `movi' with a sequence of `movi' and `shori' opcodes.
`pt'
This expands to a sequence of `movi' and `shori' opcode, followed
by a `ptrel' opcode, or to a `pta' or `ptb' opcode, depending on
the label referenced.

File: as.info, Node: Sparc-Dependent, Next: TIC54X-Dependent, Prev: PPC-Dependent, Up: Machine Dependencies
SPARC Dependent Features
========================
* Menu:
* Sparc-Opts:: Options
* Sparc-Aligned-Data:: Option to enforce aligned data
* Sparc-Float:: Floating Point
* Sparc-Directives:: Sparc Machine Directives

File: as.info, Node: Sparc-Opts, Next: Sparc-Aligned-Data, Up: Sparc-Dependent
Options
-------
The SPARC chip family includes several successive levels, using the
same core instruction set, but including a few additional instructions
at each level. There are exceptions to this however. For details on
what instructions each variant supports, please see the chip's
architecture reference manual.
By default, `as' assumes the core instruction set (SPARC v6), but
"bumps" the architecture level as needed: it switches to successively
higher architectures as it encounters instructions that only exist in
the higher levels.
If not configured for SPARC v9 (`sparc64-*-*') GAS will not bump
passed sparclite by default, an option must be passed to enable the v9
instructions.
GAS treats sparclite as being compatible with v8, unless an
architecture is explicitly requested. SPARC v9 is always incompatible
with sparclite.
`-Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite'
`-Av8plus | -Av8plusa | -Av9 | -Av9a'
Use one of the `-A' options to select one of the SPARC
architectures explicitly. If you select an architecture
explicitly, `as' reports a fatal error if it encounters an
instruction or feature requiring an incompatible or higher level.
`-Av8plus' and `-Av8plusa' select a 32 bit environment.
`-Av9' and `-Av9a' select a 64 bit environment and are not
available unless GAS is explicitly configured with 64 bit
environment support.
`-Av8plusa' and `-Av9a' enable the SPARC V9 instruction set with
UltraSPARC extensions.
`-xarch=v8plus | -xarch=v8plusa'
For compatibility with the Solaris v9 assembler. These options are
equivalent to -Av8plus and -Av8plusa, respectively.
`-bump'
Warn whenever it is necessary to switch to another level. If an
architecture level is explicitly requested, GAS will not issue
warnings until that level is reached, and will then bump the level
as required (except between incompatible levels).
`-32 | -64'
Select the word size, either 32 bits or 64 bits. These options
are only available with the ELF object file format, and require
that the necessary BFD support has been included.

File: as.info, Node: Sparc-Aligned-Data, Next: Sparc-Float, Prev: Sparc-Opts, Up: Sparc-Dependent
Enforcing aligned data
----------------------
SPARC GAS normally permits data to be misaligned. For example, it
permits the `.long' pseudo-op to be used on a byte boundary. However,
the native SunOS and Solaris assemblers issue an error when they see
misaligned data.
You can use the `--enforce-aligned-data' option to make SPARC GAS
also issue an error about misaligned data, just as the SunOS and Solaris
assemblers do.
The `--enforce-aligned-data' option is not the default because gcc
issues misaligned data pseudo-ops when it initializes certain packed
data structures (structures defined using the `packed' attribute). You
may have to assemble with GAS in order to initialize packed data
structures in your own code.

File: as.info, Node: Sparc-Float, Next: Sparc-Directives, Prev: Sparc-Aligned-Data, Up: Sparc-Dependent
Floating Point
--------------
The Sparc uses IEEE floating-point numbers.

File: as.info, Node: Sparc-Directives, Prev: Sparc-Float, Up: Sparc-Dependent
Sparc Machine Directives
------------------------
The Sparc version of `as' supports the following additional machine
directives:
`.align'
This must be followed by the desired alignment in bytes.
`.common'
This must be followed by a symbol name, a positive number, and
`"bss"'. This behaves somewhat like `.comm', but the syntax is
different.
`.half'
This is functionally identical to `.short'.
`.nword'
On the Sparc, the `.nword' directive produces native word sized
value, ie. if assembling with -32 it is equivalent to `.word', if
assembling with -64 it is equivalent to `.xword'.
`.proc'
This directive is ignored. Any text following it on the same line
is also ignored.
`.register'
This directive declares use of a global application or system
register. It must be followed by a register name %g2, %g3, %g6 or
%g7, comma and the symbol name for that register. If symbol name
is `#scratch', it is a scratch register, if it is `#ignore', it
just suppresses any errors about using undeclared global register,
but does not emit any information about it into the object file.
This can be useful e.g. if you save the register before use and
restore it after.
`.reserve'
This must be followed by a symbol name, a positive number, and
`"bss"'. This behaves somewhat like `.lcomm', but the syntax is
different.
`.seg'
This must be followed by `"text"', `"data"', or `"data1"'. It
behaves like `.text', `.data', or `.data 1'.
`.skip'
This is functionally identical to the `.space' directive.
`.word'
On the Sparc, the `.word' directive produces 32 bit values,
instead of the 16 bit values it produces on many other machines.
`.xword'
On the Sparc V9 processor, the `.xword' directive produces 64 bit
values.

File: as.info, Node: TIC54X-Dependent, Next: V850-Dependent, Prev: Sparc-Dependent, Up: Machine Dependencies
TIC54X Dependent Features
=========================
* Menu:
* TIC54X-Opts:: Command-line Options
* TIC54X-Block:: Blocking
* TIC54X-Env:: Environment Settings
* TIC54X-Constants:: Constants Syntax
* TIC54X-Subsyms:: String Substitution
* TIC54X-Locals:: Local Label Syntax
* TIC54X-Builtins:: Builtin Assembler Math Functions
* TIC54X-Ext:: Extended Addressing Support
* TIC54X-Directives:: Directives
* TIC54X-Macros:: Macro Features
* TIC54X-MMRegs:: Memory-mapped Registers

File: as.info, Node: TIC54X-Opts, Next: TIC54X-Block, Up: TIC54X-Dependent
Options
-------
The TMS320C54x version of `as' has a few machine-dependent options.
You can use the `-mfar-mode' option to enable extended addressing
mode. All addresses will be assumed to be > 16 bits, and the
appropriate relocation types will be used. This option is equivalent
to using the `.far_mode' directive in the assembly code. If you do not
use the `-mfar-mode' option, all references will be assumed to be 16
bits. This option may be abbreviated to `-mf'.
You can use the `-mcpu' option to specify a particular CPU. This
option is equivalent to using the `.version' directive in the assembly
code. For recognized CPU codes, see *Note `.version':
TIC54X-Directives. The default CPU version is `542'.
You can use the `-merrors-to-file' option to redirect error output
to a file (this provided for those deficient environments which don't
provide adequate output redirection). This option may be abbreviated to
`-me'.

File: as.info, Node: TIC54X-Block, Next: TIC54X-Env, Prev: TIC54X-Opts, Up: TIC54X-Dependent
Blocking
--------
A blocked section or memory block is guaranteed not to cross the
blocking boundary (usually a page, or 128 words) if it is smaller than
the blocking size, or to start on a page boundary if it is larger than
the blocking size.

File: as.info, Node: TIC54X-Env, Next: TIC54X-Constants, Prev: TIC54X-Block, Up: TIC54X-Dependent
Environment Settings
--------------------
`C54XDSP_DIR' and `A_DIR' are semicolon-separated paths which are
added to the list of directories normally searched for source and
include files. `C54XDSP_DIR' will override `A_DIR'.

File: as.info, Node: TIC54X-Constants, Next: TIC54X-Subsyms, Prev: TIC54X-Env, Up: TIC54X-Dependent
Constants Syntax
----------------
The TIC54X version of `as' allows the following additional constant
formats, using a suffix to indicate the radix:
Binary `000000B, 011000b'
Octal `10Q, 224q'
Hexadecimal `45h, 0FH'

File: as.info, Node: TIC54X-Subsyms, Next: TIC54X-Locals, Prev: TIC54X-Constants, Up: TIC54X-Dependent
String Substitution
-------------------
A subset of allowable symbols (which we'll call subsyms) may be
assigned arbitrary string values. This is roughly equivalent to C
preprocessor #define macros. When `as' encounters one of these
symbols, the symbol is replaced in the input stream by its string value.
Subsym names *must* begin with a letter.
Subsyms may be defined using the `.asg' and `.eval' directives
(*Note `.asg': TIC54X-Directives, *Note `.eval': TIC54X-Directives.
Expansion is recursive until a previously encountered symbol is
seen, at which point substitution stops.
In this example, x is replaced with SYM2; SYM2 is replaced with
SYM1, and SYM1 is replaced with x. At this point, x has already been
encountered and the substitution stops.
.asg "x",SYM1
.asg "SYM1",SYM2
.asg "SYM2",x
add x,a ; final code assembled is "add x, a"
Macro parameters are converted to subsyms; a side effect of this is
the normal `as' '\ARG' dereferencing syntax is unnecessary. Subsyms
defined within a macro will have global scope, unless the `.var'
directive is used to identify the subsym as a local macro variable
*note `.var': TIC54X-Directives..
Substitution may be forced in situations where replacement might be
ambiguous by placing colons on either side of the subsym. The following
code:
.eval "10",x
LAB:X: add #x, a
When assembled becomes:
LAB10 add #10, a
Smaller parts of the string assigned to a subsym may be accessed with
the following syntax:
``:SYMBOL(CHAR_INDEX):''
Evaluates to a single-character string, the character at
CHAR_INDEX.
``:SYMBOL(START,LENGTH):''
Evaluates to a substring of SYMBOL beginning at START with length
LENGTH.

File: as.info, Node: TIC54X-Locals, Next: TIC54X-Builtins, Prev: TIC54X-Subsyms, Up: TIC54X-Dependent
Local Labels
------------
Local labels may be defined in two ways:
* $N, where N is a decimal number between 0 and 9
* LABEL?, where LABEL is any legal symbol name.
Local labels thus defined may be redefined or automatically
generated. The scope of a local label is based on when it may be
undefined or reset. This happens when one of the following situations
is encountered:
* .newblock directive *note `.newblock': TIC54X-Directives.
* The current section is changed (.sect, .text, or .data)
* Entering or leaving an included file
* The macro scope where the label was defined is exited

File: as.info, Node: TIC54X-Builtins, Next: TIC54X-Ext, Prev: TIC54X-Locals, Up: TIC54X-Dependent
Math Builtins
-------------
The following built-in functions may be used to generate a
floating-point value. All return a floating-point value except `$cvi',
`$int', and `$sgn', which return an integer value.
``$acos(EXPR)''
Returns the floating point arccosine of EXPR.
``$asin(EXPR)''
Returns the floating point arcsine of EXPR.
``$atan(EXPR)''
Returns the floating point arctangent of EXPR.
``$atan2(EXPR1,EXPR2)''
Returns the floating point arctangent of EXPR1 / EXPR2.
``$ceil(EXPR)''
Returns the smallest integer not less than EXPR as floating point.
``$cosh(EXPR)''
Returns the floating point hyperbolic cosine of EXPR.
``$cos(EXPR)''
Returns the floating point cosine of EXPR.
``$cvf(EXPR)''
Returns the integer value EXPR converted to floating-point.
``$cvi(EXPR)''
Returns the floating point value EXPR converted to integer.
``$exp(EXPR)''
Returns the floating point value e ^ EXPR.
``$fabs(EXPR)''
Returns the floating point absolute value of EXPR.
``$floor(EXPR)''
Returns the largest integer that is not greater than EXPR as
floating point.
``$fmod(EXPR1,EXPR2)''
Returns the floating point remainder of EXPR1 / EXPR2.
``$int(EXPR)''
Returns 1 if EXPR evaluates to an integer, zero otherwise.
``$ldexp(EXPR1,EXPR2)''
Returns the floating point value EXPR1 * 2 ^ EXPR2.
``$log10(EXPR)''
Returns the base 10 logarithm of EXPR.
``$log(EXPR)''
Returns the natural logarithm of EXPR.
``$max(EXPR1,EXPR2)''
Returns the floating point maximum of EXPR1 and EXPR2.
``$min(EXPR1,EXPR2)''
Returns the floating point minimum of EXPR1 and EXPR2.
``$pow(EXPR1,EXPR2)''
Returns the floating point value EXPR1 ^ EXPR2.
``$round(EXPR)''
Returns the nearest integer to EXPR as a floating point number.
``$sgn(EXPR)''
Returns -1, 0, or 1 based on the sign of EXPR.
``$sin(EXPR)''
Returns the floating point sine of EXPR.
``$sinh(EXPR)''
Returns the floating point hyperbolic sine of EXPR.
``$sqrt(EXPR)''
Returns the floating point square root of EXPR.
``$tan(EXPR)''
Returns the floating point tangent of EXPR.
``$tanh(EXPR)''
Returns the floating point hyperbolic tangent of EXPR.
``$trunc(EXPR)''
Returns the integer value of EXPR truncated towards zero as
floating point.

File: as.info, Node: TIC54X-Ext, Next: TIC54X-Directives, Prev: TIC54X-Builtins, Up: TIC54X-Dependent
Extended Addressing
-------------------
The `LDX' pseudo-op is provided for loading the extended addressing
bits of a label or address. For example, if an address `_label' resides
in extended program memory, the value of `_label' may be loaded as
follows:
ldx #_label,16,a ; loads extended bits of _label
or #_label,a ; loads lower 16 bits of _label
bacc a ; full address is in accumulator A

File: as.info, Node: TIC54X-Directives, Next: TIC54X-Macros, Prev: TIC54X-Ext, Up: TIC54X-Dependent
Directives
----------
`.align [SIZE]'
`.even'
Align the section program counter on the next boundary, based on
SIZE. SIZE may be any power of 2. `.even' is equivalent to
`.align' with a SIZE of 2.
`1'
Align SPC to word boundary
`2'
Align SPC to longword boundary (same as .even)
`128'
Align SPC to page boundary
`.asg STRING, NAME'
Assign NAME the string STRING. String replacement is performed on
STRING before assignment.
`.eval STRING, NAME'
Evaluate the contents of string STRING and assign the result as a
string to the subsym NAME. String replacement is performed on
STRING before assignment.
`.bss SYMBOL, SIZE [, [BLOCKING_FLAG] [,ALIGNMENT_FLAG]]'
Reserve space for SYMBOL in the .bss section. SIZE is in words.
If present, BLOCKING_FLAG indicates the allocated space should be
aligned on a page boundary if it would otherwise cross a page
boundary. If present, ALIGNMENT_FLAG causes the assembler to
allocate SIZE on a long word boundary.
`.byte VALUE [,...,VALUE_N]'
`.ubyte VALUE [,...,VALUE_N]'
`.char VALUE [,...,VALUE_N]'
`.uchar VALUE [,...,VALUE_N]'
Place one or more bytes into consecutive words of the current
section. The upper 8 bits of each word is zero-filled. If a
label is used, it points to the word allocated for the first byte
encountered.
`.clink ["SECTION_NAME"]'
Set STYP_CLINK flag for this section, which indicates to the
linker that if no symbols from this section are referenced, the
section should not be included in the link. If SECTION_NAME is
omitted, the current section is used.
`.c_mode'
TBD.
`.copy "FILENAME" | FILENAME'
`.include "FILENAME" | FILENAME'
Read source statements from FILENAME. The normal include search
path is used. Normally .copy will cause statements from the
included file to be printed in the assembly listing and .include
will not, but this distinction is not currently implemented.
`.data'
Begin assembling code into the .data section.
`.double VALUE [,...,VALUE_N]'
`.ldouble VALUE [,...,VALUE_N]'
`.float VALUE [,...,VALUE_N]'
`.xfloat VALUE [,...,VALUE_N]'
Place an IEEE single-precision floating-point representation of
one or more floating-point values into the current section. All
but `.xfloat' align the result on a longword boundary. Values are
stored most-significant word first.
`.drlist'
`.drnolist'
Control printing of directives to the listing file. Ignored.
`.emsg STRING'
`.mmsg STRING'
`.wmsg STRING'
Emit a user-defined error, message, or warning, respectively.
`.far_mode'
Use extended addressing when assembling statements. This should
appear only once per file, and is equivalent to the -mfar-mode
option *note `-mfar-mode': TIC54X-Opts..
`.fclist'
`.fcnolist'
Control printing of false conditional blocks to the listing file.
`.field VALUE [,SIZE]'
Initialize a bitfield of SIZE bits in the current section. If
VALUE is relocatable, then SIZE must be 16. SIZE defaults to 16
bits. If VALUE does not fit into SIZE bits, the value will be
truncated. Successive `.field' directives will pack starting at
the current word, filling the most significant bits first, and
aligning to the start of the next word if the field size does not
fit into the space remaining in the current word. A `.align'
directive with an operand of 1 will force the next `.field'
directive to begin packing into a new word. If a label is used, it
points to the word that contains the specified field.
`.global SYMBOL [,...,SYMBOL_N]'
`.def SYMBOL [,...,SYMBOL_N]'
`.ref SYMBOL [,...,SYMBOL_N]'
`.def' nominally identifies a symbol defined in the current file
and availalbe to other files. `.ref' identifies a symbol used in
the current file but defined elsewhere. Both map to the standard
`.global' directive.
`.half VALUE [,...,VALUE_N]'
`.uhalf VALUE [,...,VALUE_N]'
`.short VALUE [,...,VALUE_N]'
`.ushort VALUE [,...,VALUE_N]'
`.int VALUE [,...,VALUE_N]'
`.uint VALUE [,...,VALUE_N]'
`.word VALUE [,...,VALUE_N]'
`.uword VALUE [,...,VALUE_N]'
Place one or more values into consecutive words of the current
section. If a label is used, it points to the word allocated for
the first value encountered.
`.label SYMBOL'
Define a special SYMBOL to refer to the load time address of the
current section program counter.
`.length'
`.width'
Set the page length and width of the output listing file. Ignored.
`.list'
`.nolist'
Control whether the source listing is printed. Ignored.
`.long VALUE [,...,VALUE_N]'
`.ulong VALUE [,...,VALUE_N]'
`.xlong VALUE [,...,VALUE_N]'
Place one or more 32-bit values into consecutive words in the
current section. The most significant word is stored first.
`.long' and `.ulong' align the result on a longword boundary;
`xlong' does not.
`.loop [COUNT]'
`.break [CONDITION]'
`.endloop'
Repeatedly assemble a block of code. `.loop' begins the block, and
`.endloop' marks its termination. COUNT defaults to 1024, and
indicates the number of times the block should be repeated.
`.break' terminates the loop so that assembly begins after the
`.endloop' directive. The optional CONDITION will cause the loop
to terminate only if it evaluates to zero.
`MACRO_NAME .macro [PARAM1][,...PARAM_N]'
`[.mexit]'
`.endm'
See the section on macros for more explanation (*Note
TIC54X-Macros::.
`.mlib "FILENAME" | FILENAME'
Load the macro library FILENAME. FILENAME must be an archived
library (BFD ar-compatible) of text files, expected to contain
only macro definitions. The standard include search path is used.
`.mlist'
`.mnolist'
Control whether to include macro and loop block expansions in the
listing output. Ignored.
`.mmregs'
Define global symbolic names for the 'c54x registers. Supposedly
equivalent to executing `.set' directives for each register with
its memory-mapped value, but in reality is provided only for
compatibility and does nothing.
`.newblock'
This directive resets any TIC54X local labels currently defined.
Normal `as' local labels are unaffected.
`.option OPTION_LIST'
Set listing options. Ignored.
`.sblock "SECTION_NAME" | SECTION_NAME [,"NAME_N" | NAME_N]'
Designate SECTION_NAME for blocking. Blocking guarantees that a
section will start on a page boundary (128 words) if it would
otherwise cross a page boundary. Only initialized sections may be
designated with this directive. See also *Note TIC54X-Block::.
`.sect "SECTION_NAME"'
Define a named initialized section and make it the current section.
`SYMBOL .set "VALUE"'
`SYMBOL .equ "VALUE"'
Equate a constant VALUE to a SYMBOL, which is placed in the symbol
table. SYMBOL may not be previously defined.
`.space SIZE_IN_BITS'
`.bes SIZE_IN_BITS'
Reserve the given number of bits in the current section and
zero-fill them. If a label is used with `.space', it points to the
*first* word reserved. With `.bes', the label points to the
*last* word reserved.
`.sslist'
`.ssnolist'
Controls the inclusion of subsym replacement in the listing
output. Ignored.
`.string "STRING" [,...,"STRING_N"]'
`.pstring "STRING" [,...,"STRING_N"]'
Place 8-bit characters from STRING into the current section.
`.string' zero-fills the upper 8 bits of each word, while
`.pstring' puts two characters into each word, filling the
most-significant bits first. Unused space is zero-filled. If a
label is used, it points to the first word initialized.
`[STAG] .struct [OFFSET]'
`[NAME_1] element [COUNT_1]'
`[NAME_2] element [COUNT_2]'
`[TNAME] .tag STAGX [TCOUNT]'
`...'
`[NAME_N] element [COUNT_N]'
`[SSIZE] .endstruct'
`LABEL .tag [STAG]'
Assign symbolic offsets to the elements of a structure. STAG
defines a symbol to use to reference the structure. OFFSET
indicates a starting value to use for the first element
encountered; otherwise it defaults to zero. Each element can have
a named offset, NAME, which is a symbol assigned the value of the
element's offset into the structure. If STAG is missing, these
become global symbols. COUNT adjusts the offset that many times,
as if `element' were an array. `element' may be one of `.byte',
`.word', `.long', `.float', or any equivalent of those, and the
structure offset is adjusted accordingly. `.field' and `.string'
are also allowed; the size of `.field' is one bit, and `.string'
is considered to be one word in size. Only element descriptors,
structure/union tags, `.align' and conditional assembly directives
are allowed within `.struct'/`.endstruct'. `.align' aligns member
offsets to word boundaries only. SSIZE, if provided, will always
be assigned the size of the structure.
The `.tag' directive, in addition to being used to define a
structure/union element within a structure, may be used to apply a
structure to a symbol. Once applied to LABEL, the individual
structure elements may be applied to LABEL to produce the desired
offsets using LABEL as the structure base.
`.tab'
Set the tab size in the output listing. Ignored.
`[UTAG] .union'
`[NAME_1] element [COUNT_1]'
`[NAME_2] element [COUNT_2]'
`[TNAME] .tag UTAGX[,TCOUNT]'
`...'
`[NAME_N] element [COUNT_N]'
`[USIZE] .endstruct'
`LABEL .tag [UTAG]'
Similar to `.struct', but the offset after each element is reset to
zero, and the USIZE is set to the maximum of all defined elements.
Starting offset for the union is always zero.
`[SYMBOL] .usect "SECTION_NAME", SIZE, [,[BLOCKING_FLAG] [,ALIGNMENT_FLAG]]'
Reserve space for variables in a named, uninitialized section
(similar to .bss). `.usect' allows definitions sections
independent of .bss. SYMBOL points to the first location reserved
by this allocation. The symbol may be used as a variable name.
SIZE is the allocated size in words. BLOCKING_FLAG indicates
whether to block this section on a page boundary (128 words)
(*note TIC54X-Block::). ALIGNMENT FLAG indicates whether the
section should be longword-aligned.
`.var SYM[,..., SYM_N]'
Define a subsym to be a local variable within a macro. See *Note
TIC54X-Macros::.
`.version VERSION'
Set which processor to build instructions for. Though the
following values are accepted, the op is ignored.
`541'
`542'
`543'
`545'
`545LP'
`546LP'
`548'
`549'

File: as.info, Node: TIC54X-Macros, Next: TIC54X-MMRegs, Prev: TIC54X-Directives, Up: TIC54X-Dependent
Macros
------
Macros do not require explicit dereferencing of arguments (i.e.
\ARG).
During macro expansion, the macro parameters are converted to
subsyms. If the number of arguments passed the macro invocation
exceeds the number of parameters defined, the last parameter is
assigned the string equivalent of all remaining arguments. If fewer
arguments are given than parameters, the missing parameters are
assigned empty strings. To include a comma in an argument, you must
enclose the argument in quotes.
The following built-in subsym functions allow examination of the
string value of subsyms (or ordinary strings). The arguments are
strings unless otherwise indicated (subsyms passed as args will be
replaced by the strings they represent).
``$symlen(STR)''
Returns the length of STR.
``$symcmp(STR1,STR2)''
Returns 0 if STR1 == STR2, non-zero otherwise.
``$firstch(STR,CH)''
Returns index of the first occurrence of character constant CH in
STR.
``$lastch(STR,CH)''
Returns index of the last occurrence of character constant CH in
STR.
``$isdefed(SYMBOL)''
Returns zero if the symbol SYMBOL is not in the symbol table,
non-zero otherwise.
``$ismember(SYMBOL,LIST)''
Assign the first member of comma-separated string LIST to SYMBOL;
LIST is reassigned the remainder of the list. Returns zero if
LIST is a null string. Both arguments must be subsyms.
``$iscons(EXPR)''
Returns 1 if string EXPR is binary, 2 if octal, 3 if hexadecimal,
4 if a character, 5 if decimal, and zero if not an integer.
``$isname(NAME)''
Returns 1 if NAME is a valid symbol name, zero otherwise.
``$isreg(REG)''
Returns 1 if REG is a valid predefined register name (AR0-AR7
only).
``$structsz(STAG)''
Returns the size of the structure or union represented by STAG.
``$structacc(STAG)''
Returns the reference point of the structure or union represented
by STAG. Always returns zero.

File: as.info, Node: TIC54X-MMRegs, Prev: TIC54X-Macros, Up: TIC54X-Dependent
Memory-mapped Registers
-----------------------
The following symbols are recognized as memory-mapped registers:

File: as.info, Node: Z8000-Dependent, Next: Vax-Dependent, Prev: Xtensa-Dependent, Up: Machine Dependencies
Z8000 Dependent Features
========================
The Z8000 as supports both members of the Z8000 family: the
unsegmented Z8002, with 16 bit addresses, and the segmented Z8001 with
24 bit addresses.
When the assembler is in unsegmented mode (specified with the
`unsegm' directive), an address takes up one word (16 bit) sized
register. When the assembler is in segmented mode (specified with the
`segm' directive), a 24-bit address takes up a long (32 bit) register.
*Note Assembler Directives for the Z8000: Z8000 Directives, for a list
of other Z8000 specific assembler directives.
* Menu:
* Z8000 Options:: No special command-line options for Z8000
* Z8000 Syntax:: Assembler syntax for the Z8000
* Z8000 Directives:: Special directives for the Z8000
* Z8000 Opcodes:: Opcodes

File: as.info, Node: Z8000 Options, Next: Z8000 Syntax, Up: Z8000-Dependent
Options
-------
`as' has no additional command-line options for the Zilog Z8000
family.

File: as.info, Node: Z8000 Syntax, Next: Z8000 Directives, Prev: Z8000 Options, Up: Z8000-Dependent
Syntax
------
* Menu:
* Z8000-Chars:: Special Characters
* Z8000-Regs:: Register Names
* Z8000-Addressing:: Addressing Modes

File: as.info, Node: Z8000-Chars, Next: Z8000-Regs, Up: Z8000 Syntax
Special Characters
..................
`!' is the line comment character.
You can use `;' instead of a newline to separate statements.

File: as.info, Node: Z8000-Regs, Next: Z8000-Addressing, Prev: Z8000-Chars, Up: Z8000 Syntax
Register Names
..............
The Z8000 has sixteen 16 bit registers, numbered 0 to 15. You can
refer to different sized groups of registers by register number, with
the prefix `r' for 16 bit registers, `rr' for 32 bit registers and `rq'
for 64 bit registers. You can also refer to the contents of the first
eight (of the sixteen 16 bit registers) by bytes. They are named `rNh'
and `rNl'.
_byte registers_
r0l r0h r1h r1l r2h r2l r3h r3l
r4h r4l r5h r5l r6h r6l r7h r7l
_word registers_
r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15
_long word registers_
rr0 rr2 rr4 rr6 rr8 rr10 rr12 rr14
_quad word registers_
rq0 rq4 rq8 rq12

File: as.info, Node: Z8000-Addressing, Prev: Z8000-Regs, Up: Z8000 Syntax
Addressing Modes
................
as understands the following addressing modes for the Z8000:
`rN'
Register direct
`@rN'
Indirect register
`ADDR'
Direct: the 16 bit or 24 bit address (depending on whether the
assembler is in segmented or unsegmented mode) of the operand is
in the instruction.
`address(rN)'
Indexed: the 16 or 24 bit address is added to the 16 bit register
to produce the final address in memory of the operand.
`rN(#IMM)'
Base Address: the 16 or 24 bit register is added to the 16 bit sign
extended immediate displacement to produce the final address in
memory of the operand.
`rN(rM)'
Base Index: the 16 or 24 bit register rN is added to the sign
extended 16 bit index register rM to produce the final address in
memory of the operand.
`#XX'
Immediate data XX.

File: as.info, Node: Z8000 Directives, Next: Z8000 Opcodes, Prev: Z8000 Syntax, Up: Z8000-Dependent
Assembler Directives for the Z8000
----------------------------------
The Z8000 port of as includes these additional assembler directives,
for compatibility with other Z8000 assemblers. As shown, these do not
begin with `.' (unlike the ordinary as directives).
`segm'
Generates code for the segmented Z8001.
`unsegm'
Generates code for the unsegmented Z8002.
`name'
Synonym for `.file'
`global'
Synonym for `.global'
`wval'
Synonym for `.word'
`lval'
Synonym for `.long'
`bval'
Synonym for `.byte'
`sval'
Assemble a string. `sval' expects one string literal, delimited by
single quotes. It assembles each byte of the string into
consecutive addresses. You can use the escape sequence `%XX'
(where XX represents a two-digit hexadecimal number) to represent
the character whose ASCII value is XX. Use this feature to
describe single quote and other characters that may not appear in
string literals as themselves. For example, the C statement
`char *a = "he said \"it's 50% off\"";' is represented in Z8000
assembly language (shown with the assembler output in hex at the
left) as
68652073 sval 'he said %22it%27s 50%25 off%22%00'
61696420
22697427
73203530
25206F66
662200
`rsect'
synonym for `.section'
`block'
synonym for `.space'
`even'
special case of `.align'; aligns output to even byte boundary.

File: as.info, Node: Z8000 Opcodes, Prev: Z8000 Directives, Up: Z8000-Dependent
Opcodes
-------
For detailed information on the Z8000 machine instruction set, see
`Z8000 Technical Manual'.
The following table summarizes the opcodes and their arguments:
rs 16 bit source register
rd 16 bit destination register
rbs 8 bit source register
rbd 8 bit destination register
rrs 32 bit source register
rrd 32 bit destination register
rqs 64 bit source register
rqd 64 bit destination register
addr 16/24 bit address
imm immediate data
adc rd,rs clrb addr cpsir @rd,@rs,rr,cc
adcb rbd,rbs clrb addr(rd) cpsirb @rd,@rs,rr,cc
add rd,@rs clrb rbd dab rbd
add rd,addr com @rd dbjnz rbd,disp7
add rd,addr(rs) com addr dec @rd,imm4m1
add rd,imm16 com addr(rd) dec addr(rd),imm4m1
add rd,rs com rd dec addr,imm4m1
addb rbd,@rs comb @rd dec rd,imm4m1
addb rbd,addr comb addr decb @rd,imm4m1
addb rbd,addr(rs) comb addr(rd) decb addr(rd),imm4m1
addb rbd,imm8 comb rbd decb addr,imm4m1
addb rbd,rbs comflg flags decb rbd,imm4m1
addl rrd,@rs cp @rd,imm16 di i2
addl rrd,addr cp addr(rd),imm16 div rrd,@rs
addl rrd,addr(rs) cp addr,imm16 div rrd,addr
addl rrd,imm32 cp rd,@rs div rrd,addr(rs)
addl rrd,rrs cp rd,addr div rrd,imm16
and rd,@rs cp rd,addr(rs) div rrd,rs
and rd,addr cp rd,imm16 divl rqd,@rs
and rd,addr(rs) cp rd,rs divl rqd,addr
and rd,imm16 cpb @rd,imm8 divl rqd,addr(rs)
and rd,rs cpb addr(rd),imm8 divl rqd,imm32
andb rbd,@rs cpb addr,imm8 divl rqd,rrs
andb rbd,addr cpb rbd,@rs djnz rd,disp7
andb rbd,addr(rs) cpb rbd,addr ei i2
andb rbd,imm8 cpb rbd,addr(rs) ex rd,@rs
andb rbd,rbs cpb rbd,imm8 ex rd,addr
bit @rd,imm4 cpb rbd,rbs ex rd,addr(rs)
bit addr(rd),imm4 cpd rd,@rs,rr,cc ex rd,rs
bit addr,imm4 cpdb rbd,@rs,rr,cc exb rbd,@rs
bit rd,imm4 cpdr rd,@rs,rr,cc exb rbd,addr
bit rd,rs cpdrb rbd,@rs,rr,cc exb rbd,addr(rs)
bitb @rd,imm4 cpi rd,@rs,rr,cc exb rbd,rbs
bitb addr(rd),imm4 cpib rbd,@rs,rr,cc ext0e imm8
bitb addr,imm4 cpir rd,@rs,rr,cc ext0f imm8
bitb rbd,imm4 cpirb rbd,@rs,rr,cc ext8e imm8
bitb rbd,rs cpl rrd,@rs ext8f imm8
bpt cpl rrd,addr exts rrd
call @rd cpl rrd,addr(rs) extsb rd
call addr cpl rrd,imm32 extsl rqd
call addr(rd) cpl rrd,rrs halt
calr disp12 cpsd @rd,@rs,rr,cc in rd,@rs
clr @rd cpsdb @rd,@rs,rr,cc in rd,imm16
clr addr cpsdr @rd,@rs,rr,cc inb rbd,@rs
clr addr(rd) cpsdrb @rd,@rs,rr,cc inb rbd,imm16
clr rd cpsi @rd,@rs,rr,cc inc @rd,imm4m1
clrb @rd cpsib @rd,@rs,rr,cc inc addr(rd),imm4m1
inc addr,imm4m1 ldb rbd,rs(rx) mult rrd,addr(rs)
inc rd,imm4m1 ldb rd(imm16),rbs mult rrd,imm16
incb @rd,imm4m1 ldb rd(rx),rbs mult rrd,rs
incb addr(rd),imm4m1 ldctl ctrl,rs multl rqd,@rs
incb addr,imm4m1 ldctl rd,ctrl multl rqd,addr
incb rbd,imm4m1 ldd @rs,@rd,rr multl rqd,addr(rs)
ind @rd,@rs,ra lddb @rs,@rd,rr multl rqd,imm32
indb @rd,@rs,rba lddr @rs,@rd,rr multl rqd,rrs
inib @rd,@rs,ra lddrb @rs,@rd,rr neg @rd
inibr @rd,@rs,ra ldi @rd,@rs,rr neg addr
iret ldib @rd,@rs,rr neg addr(rd)
jp cc,@rd ldir @rd,@rs,rr neg rd
jp cc,addr ldirb @rd,@rs,rr negb @rd
jp cc,addr(rd) ldk rd,imm4 negb addr
jr cc,disp8 ldl @rd,rrs negb addr(rd)
ld @rd,imm16 ldl addr(rd),rrs negb rbd
ld @rd,rs ldl addr,rrs nop
ld addr(rd),imm16 ldl rd(imm16),rrs or rd,@rs
ld addr(rd),rs ldl rd(rx),rrs or rd,addr
ld addr,imm16 ldl rrd,@rs or rd,addr(rs)
ld addr,rs ldl rrd,addr or rd,imm16
ld rd(imm16),rs ldl rrd,addr(rs) or rd,rs
ld rd(rx),rs ldl rrd,imm32 orb rbd,@rs
ld rd,@rs ldl rrd,rrs orb rbd,addr
ld rd,addr ldl rrd,rs(imm16) orb rbd,addr(rs)
ld rd,addr(rs) ldl rrd,rs(rx) orb rbd,imm8
ld rd,imm16 ldm @rd,rs,n orb rbd,rbs
ld rd,rs ldm addr(rd),rs,n out @rd,rs
ld rd,rs(imm16) ldm addr,rs,n out imm16,rs
ld rd,rs(rx) ldm rd,@rs,n outb @rd,rbs
lda rd,addr ldm rd,addr(rs),n outb imm16,rbs
lda rd,addr(rs) ldm rd,addr,n outd @rd,@rs,ra
lda rd,rs(imm16) ldps @rs outdb @rd,@rs,rba
lda rd,rs(rx) ldps addr outib @rd,@rs,ra
ldar rd,disp16 ldps addr(rs) outibr @rd,@rs,ra
ldb @rd,imm8 ldr disp16,rs pop @rd,@rs
ldb @rd,rbs ldr rd,disp16 pop addr(rd),@rs
ldb addr(rd),imm8 ldrb disp16,rbs pop addr,@rs
ldb addr(rd),rbs ldrb rbd,disp16 pop rd,@rs
ldb addr,imm8 ldrl disp16,rrs popl @rd,@rs
ldb addr,rbs ldrl rrd,disp16 popl addr(rd),@rs
ldb rbd,@rs mbit popl addr,@rs
ldb rbd,addr mreq rd popl rrd,@rs
ldb rbd,addr(rs) mres push @rd,@rs
ldb rbd,imm8 mset push @rd,addr
ldb rbd,rbs mult rrd,@rs push @rd,addr(rs)
ldb rbd,rs(imm16) mult rrd,addr push @rd,imm16
push @rd,rs set addr,imm4 subl rrd,imm32
pushl @rd,@rs set rd,imm4 subl rrd,rrs
pushl @rd,addr set rd,rs tcc cc,rd
pushl @rd,addr(rs) setb @rd,imm4 tccb cc,rbd
pushl @rd,rrs setb addr(rd),imm4 test @rd
res @rd,imm4 setb addr,imm4 test addr
res addr(rd),imm4 setb rbd,imm4 test addr(rd)
res addr,imm4 setb rbd,rs test rd
res rd,imm4 setflg imm4 testb @rd
res rd,rs sinb rbd,imm16 testb addr
resb @rd,imm4 sinb rd,imm16 testb addr(rd)
resb addr(rd),imm4 sind @rd,@rs,ra testb rbd
resb addr,imm4 sindb @rd,@rs,rba testl @rd
resb rbd,imm4 sinib @rd,@rs,ra testl addr
resb rbd,rs sinibr @rd,@rs,ra testl addr(rd)
resflg imm4 sla rd,imm8 testl rrd
ret cc slab rbd,imm8 trdb @rd,@rs,rba
rl rd,imm1or2 slal rrd,imm8 trdrb @rd,@rs,rba
rlb rbd,imm1or2 sll rd,imm8 trib @rd,@rs,rbr
rlc rd,imm1or2 sllb rbd,imm8 trirb @rd,@rs,rbr
rlcb rbd,imm1or2 slll rrd,imm8 trtdrb @ra,@rb,rbr
rldb rbb,rba sout imm16,rs trtib @ra,@rb,rr
rr rd,imm1or2 soutb imm16,rbs trtirb @ra,@rb,rbr
rrb rbd,imm1or2 soutd @rd,@rs,ra trtrb @ra,@rb,rbr
rrc rd,imm1or2 soutdb @rd,@rs,rba tset @rd
rrcb rbd,imm1or2 soutib @rd,@rs,ra tset addr
rrdb rbb,rba soutibr @rd,@rs,ra tset addr(rd)
rsvd36 sra rd,imm8 tset rd
rsvd38 srab rbd,imm8 tsetb @rd
rsvd78 sral rrd,imm8 tsetb addr
rsvd7e srl rd,imm8 tsetb addr(rd)
rsvd9d srlb rbd,imm8 tsetb rbd
rsvd9f srll rrd,imm8 xor rd,@rs
rsvdb9 sub rd,@rs xor rd,addr
rsvdbf sub rd,addr xor rd,addr(rs)
sbc rd,rs sub rd,addr(rs) xor rd,imm16
sbcb rbd,rbs sub rd,imm16 xor rd,rs
sc imm8 sub rd,rs xorb rbd,@rs
sda rd,rs subb rbd,@rs xorb rbd,addr
sdab rbd,rs subb rbd,addr xorb rbd,addr(rs)
sdal rrd,rs subb rbd,addr(rs) xorb rbd,imm8
sdl rd,rs subb rbd,imm8 xorb rbd,rbs
sdlb rbd,rs subb rbd,rbs xorb rbd,rbs
sdll rrd,rs subl rrd,@rs
set @rd,imm4 subl rrd,addr
set addr(rd),imm4 subl rrd,addr(rs)

File: as.info, Node: Vax-Dependent, Prev: Z8000-Dependent, Up: Machine Dependencies
VAX Dependent Features
======================
* Menu:
* VAX-Opts:: VAX Command-Line Options
* VAX-float:: VAX Floating Point
* VAX-directives:: Vax Machine Directives
* VAX-opcodes:: VAX Opcodes
* VAX-branch:: VAX Branch Improvement
* VAX-operands:: VAX Operands
* VAX-no:: Not Supported on VAX

File: as.info, Node: VAX-Opts, Next: VAX-float, Up: Vax-Dependent
VAX Command-Line Options
------------------------
The Vax version of `as' accepts any of the following options, gives
a warning message that the option was ignored and proceeds. These
options are for compatibility with scripts designed for other people's
assemblers.
``-D' (Debug)'
``-S' (Symbol Table)'
``-T' (Token Trace)'
These are obsolete options used to debug old assemblers.
``-d' (Displacement size for JUMPs)'
This option expects a number following the `-d'. Like options
that expect filenames, the number may immediately follow the `-d'
(old standard) or constitute the whole of the command line
argument that follows `-d' (GNU standard).
``-V' (Virtualize Interpass Temporary File)'
Some other assemblers use a temporary file. This option commanded
them to keep the information in active memory rather than in a
disk file. `as' always does this, so this option is redundant.
``-J' (JUMPify Longer Branches)'
Many 32-bit computers permit a variety of branch instructions to
do the same job. Some of these instructions are short (and fast)
but have a limited range; others are long (and slow) but can
branch anywhere in virtual memory. Often there are 3 flavors of
branch: short, medium and long. Some other assemblers would emit
short and medium branches, unless told by this option to emit
short and long branches.
``-t' (Temporary File Directory)'
Some other assemblers may use a temporary file, and this option
takes a filename being the directory to site the temporary file.
Since `as' does not use a temporary disk file, this option makes
no difference. `-t' needs exactly one filename.
The Vax version of the assembler accepts additional options when
compiled for VMS:
`-h N'
External symbol or section (used for global variables) names are
not case sensitive on VAX/VMS and always mapped to upper case.
This is contrary to the C language definition which explicitly
distinguishes upper and lower case. To implement a standard
conforming C compiler, names must be changed (mapped) to preserve
the case information. The default mapping is to convert all lower
case characters to uppercase and adding an underscore followed by
a 6 digit hex value, representing a 24 digit binary value. The
one digits in the binary value represent which characters are
uppercase in the original symbol name.
The `-h N' option determines how we map names. This takes several
values. No `-h' switch at all allows case hacking as described
above. A value of zero (`-h0') implies names should be upper
case, and inhibits the case hack. A value of 2 (`-h2') implies
names should be all lower case, with no case hack. A value of 3
(`-h3') implies that case should be preserved. The value 1 is
unused. The `-H' option directs `as' to display every mapped
symbol during assembly.
Symbols whose names include a dollar sign `$' are exceptions to the
general name mapping. These symbols are normally only used to
reference VMS library names. Such symbols are always mapped to
upper case.
`-+'
The `-+' option causes `as' to truncate any symbol name larger
than 31 characters. The `-+' option also prevents some code
following the `_main' symbol normally added to make the object
file compatible with Vax-11 "C".
`-1'
This option is ignored for backward compatibility with `as'
version 1.x.
`-H'
The `-H' option causes `as' to print every symbol which was
changed by case mapping.

File: as.info, Node: VAX-float, Next: VAX-directives, Prev: VAX-Opts, Up: Vax-Dependent
VAX Floating Point
------------------
Conversion of flonums to floating point is correct, and compatible
with previous assemblers. Rounding is towards zero if the remainder is
exactly half the least significant bit.
`D', `F', `G' and `H' floating point formats are understood.
Immediate floating literals (_e.g._ `S`$6.9') are rendered
correctly. Again, rounding is towards zero in the boundary case.
The `.float' directive produces `f' format numbers. The `.double'
directive produces `d' format numbers.

File: as.info, Node: VAX-directives, Next: VAX-opcodes, Prev: VAX-float, Up: Vax-Dependent
Vax Machine Directives
----------------------
The Vax version of the assembler supports four directives for
generating Vax floating point constants. They are described in the
table below.
`.dfloat'
This expects zero or more flonums, separated by commas, and
assembles Vax `d' format 64-bit floating point constants.
`.ffloat'
This expects zero or more flonums, separated by commas, and
assembles Vax `f' format 32-bit floating point constants.
`.gfloat'
This expects zero or more flonums, separated by commas, and
assembles Vax `g' format 64-bit floating point constants.
`.hfloat'
This expects zero or more flonums, separated by commas, and
assembles Vax `h' format 128-bit floating point constants.

File: as.info, Node: VAX-opcodes, Next: VAX-branch, Prev: VAX-directives, Up: Vax-Dependent
VAX Opcodes
-----------
All DEC mnemonics are supported. Beware that `case...' instructions
have exactly 3 operands. The dispatch table that follows the `case...'
instruction should be made with `.word' statements. This is compatible
with all unix assemblers we know of.
View Git Blame Copy Permalink