Copyright (C) 1994, 1995 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 also 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.
The primary purpose of the GNU assembler is to assemble the output of other programs--notably compilers. When you have to hand-code specialized routines in assembly, that means the GNU assembler is an unfriendly processor: it has no directives for macros, conditionals, or many other conveniences that you might expect.
In some cases you can simply use the C preprocessor, or a generalized preprocessor like M4; but this can be awkward, since none of these things are designed with assembly in mind.
GASP fills this need. It is expressly designed to provide the facilities you need with hand-coded assembly code. Implementing it as a preprocessor, rather than part of the assembler, allows the maximum flexibility: you can use it with hand-coded assembly, without paying a penalty of added complexity in the assembler you use for compiler output.
Here is a small example to give the flavor of GASP. This input to GASP
.MACRO saveregs from=8 to=14 count .ASSIGNA \from ! save r\from..r\to .AWHILE \&count LE \to mov r\&count,@-sp count .ASSIGNA \&count + 1 .AENDW .ENDM saveregs from=12 bar: mov #H'dead+10,r0 foo .SDATAC "hello"<10> .END
generates this assembly program:
! save r12..r14 mov r12,@-sp mov r13,@-sp mov r14,@-sp bar: mov #57005+10,r0 foo: .byte 6,104,101,108,108,111,10
The simplest way to use GASP is to run it as a filter and assemble its output. In Unix and its ilk, you can do this, for example:
$ gasp prog.asm | as -o prog.o
Naturally, there are also a few command-line options to allow you to request variations on this basic theme. Here is the full set of possibilities for the GASP command line.
gasp [ -a | --alternate ] [ -c char | --commentchar char ] [ -d | --debug ] [ -h | --help ] [ -M | --mri ] [ -o outfile | --output outfile ] [ -p | --print ] [ -s | --copysource ] [ -u | --unreasonable ] [ -v | --version ] infile ...
infile ...
.END
. See section Miscellaneous commands.
-a
--alternate
-c 'char'
--commentchar 'char'
-d
--debug
strings size s : nGASP displays these statistics on the standard error stream, when done preprocessing.
-h
--help
-M
--mri
ASM68K
assembler.
-o outfile
--output outfile
-p
--print
-s
--copysource
-u
--unreasonable
-v
--version
GASP commands have a straightforward syntax that fits in well with assembly conventions. In general, a command extends for a line, and may have up to three fields: an optional label, the command itself, and optional arguments to the command. You can write commands in upper or lower case, though this manual shows them in upper case. See section Details of the GASP syntax, for more information.
The conditional-assembly directives allow you to include or exclude portions of an assembly depending on how a pair of expressions, or a pair of strings, compare.
The overall structure of conditionals is familiar from many other
contexts. .AIF
marks the start of a conditional, and precedes
assembly for the case when the condition is true. An optional
.AELSE
precedes assembly for the converse case, and an
.AENDI
marks the end of the condition.
You may nest conditionals up to a depth of 100; GASP rejects nesting beyond that, because it may indicate a bug in your macro structure.
Conditionals are primarily useful inside macro definitions, where you often need different effects depending on argument values. See section Defining your own directives, for details about defining macros.
.AIF expra cmp exprb
.AIF "stra" cmp "strb"
.AIF
preprocessor command. You may compare either two strings, or two
expressions.
When you compare strings, only two conditional cmp comparison
operators are available: `EQ' (true if stra and strb
are identical), and `NE' (the opposite).
When you compare two expressions, both expressions must be
absolute (see section Arithmetic expressions in GASP). You
can use these cmp comparison operators with expressions:
EQ
NE
LT
LE
GT
GE
.AELSE
.AIF
and
.AENDI
).
.AENDI
Two preprocessor directives allow you to repeatedly issue copies of the same block of assembly code.
.AREPEAT aexp
.AENDR
.AREPEAT
and .AENDR
. Specify the number of
copies as aexp (which must be an absolute expression). For
example, this repeats two assembly statements three times in succession:
.AREPEAT 3 rotcl r2 div1 r0,r1 .AENDR
.AWHILE expra cmp exprb
.AENDW
.AWHILE stra cmp strb
.AENDW
.AWHILE
.
.AENDW
marks the end of the repeated block. The conditional
comparison works exactly the same way as for .AIF
, with the same
comparison operators (see section Conditional assembly).
Since the terms of the comparison must be absolute expression,
.AWHILE
is primarily useful within macros. See section Defining your own directives.
You can use the .EXITM
preprocessor directive to break out of
loops early (as well as to break out of macros). See section Defining your own directives.
You can use variables in GASP to represent strings, registers, or the results of expressions.
You must distinguish two kinds of variables:
.EQU
or .ASSIGN
. To evaluate this
kind of variable in your assembly output, simply mention its name. For
example, these two lines define and use a variable `eg':
eg .EQU FLIP-64 ... mov.l eg,r0Do not use this kind of variable in conditional expressions or while loops; GASP only evaluates these variables when writing assembly output.
.ASSIGNC
or .ASSIGNA
. To evaluate this
kind of variable, write `\&' before the variable name; for example,
opcit .ASSIGNA 47 ... .AWHILE \&opcit GT 0 ... .AENDWGASP treats macro arguments almost the same way, but to evaluate them you use the prefix `\' rather than `\&'. See section Defining your own directives.
pvar .EQU expr
pvar .ASSIGN expr
.EQU
, save that you may not redefine
pvar using .ASSIGN
once it has a value.
pvar .ASSIGNA aexpr
.ASSIGNA
at any time.
pvar .ASSIGNC "str"
.ASSIGNC
at any time.
pvar .REG (register)
.REG
to define a variable that represents a register. In
particular, register is not evaluated as an expression.
You may use .REG
at will to redefine register variables.
All these directives accept the variable name in the "label" position, that is at the left margin. You may specify a colon after the variable name if you wish; the first example above could have started `eg:' with the same effect.
The commands .MACRO
and .ENDM
allow you to define macros
that generate assembly output. You can use these macros with a syntax
similar to built-in GASP or assembler directives. For example,
this definition specifies a macro SUM
that adds together a range of
consecutive registers:
.MACRO SUM FROM=0, TO=9 ! \FROM \TO mov r\FROM,r10 COUNT .ASSIGNA \FROM+1 .AWHILE \&COUNT LE \TO add r\&COUNT,r10 COUNT .ASSIGNA \&COUNT+1 .AENDW .ENDM
With that definition, `SUM 0,5' generates this assembly output:
! 0 5 mov r0,r10 add r1,r10 add r2,r10 add r3,r10 add r4,r10 add r5,r10
.MACRO macname
.MACRO macname macargs ...
.MACRO
statements:
.MACRO COMM
COMM
, which takes no
arguments.
.MACRO PLUS1 P, P1
.MACRO PLUS1 P P1
PLUS1
,
which takes two arguments; within the macro definition, write
`\P' or `\P1' to evaluate the arguments.
.MACRO RESERVE_STR P1=0 P2
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).
name .MACRO
name .MACRO ( macargs ... )
.ENDM
.EXITM
.AREPEAT
loop, or
.AWHILE
loop.
\@
LOCAL name [ , ... ]
LOCAL
is only available if you select "alternate
macro syntax" with `-a' or `--alternate'. See section Alternate macro syntax.
Generate a string replacement for each of the name arguments, and
replace any instances of name in each macro expansion. The
replacement string is unique in the assembly, and different for each
separate macro expansion. LOCAL
allows you to write macros that
define symbols, without fear of conflict between separate macro expansions.
In assembly code, you often need to specify working areas of memory; depending on the application, you may want to initialize such memory or not. GASP provides preprocessor directives to help you avoid repetitive coding for both purposes.
You can use labels as usual to mark the data areas.
These are the GASP directives for initialized data, and the standard GNU assembler directives they expand to:
.DATA expr, expr, ...
.DATA.B expr, expr, ...
.DATA.W expr, expr, ...
.DATA.L expr, expr, ...
as
directive (labelled with lab). The unqualified
.DATA
emits `.long'; .DATA.B
emits `.byte';
.DATA.W
emits `.short'; and .DATA.L
emits
`.long'.
For example, `foo .DATA 1,2,3' emits `foo: .long 1,2,3'.
.DATAB repeat, expr
.DATAB.B repeat, expr
.DATAB.W repeat, expr
.DATAB.L repeat, expr
as
emit repeat copies of the value of the expression
expr (using the as
directive .fill
).
`.DATAB.B' repeats one-byte values; `.DATAB.W' repeats
two-byte values; and `.DATAB.L' repeats four-byte values.
`.DATAB' without a suffix repeats four-byte values, just like
`.DATAB.L'.
repeat must be an absolute expression with a positive value.
.SDATA "str" ...
.SDATA
concatenates multiple
arguments, making it easy to switch between string representations. You
can use commas to separate the individual arguments for clarity, if you
choose.
.SDATAB repeat, "str" ...
.SDATA
.
.SDATAZ "str" ...
.SDATA
, except that
.SDATAZ
writes a zero byte at the end of the string.
.SDATAC "str" ...
.SDATA
, except that
GASP precedes the string with a leading one-byte count. For
example, `.SDATAC "HI"' generates `.byte 2,72,73'. Since the
count field is only one byte, you can only use .SDATAC
for
strings less than 256 bytes in length.
Use the .RES
, .SRES
, .SRESC
, and .SRESZ
directives to reserve memory and leave it uninitialized. GASP
resolves these directives to appropriate calls of the GNU
as
.space
directive.
.RES count
.RES.B count
.RES.W count
.RES.L count
.RES.B
reserves
count bytes, .RES.W
reserves count pairs of bytes,
and .RES.L
reserves count quartets. .RES
without a
suffix is equivalent to .RES.L
.
.SRES count
.SRES.B count
.SRES.W count
.SRES.L count
.SRES
is a synonym for `.RES'.
.SRESC count
.SRESC.B count
.SRESC.W count
.SRESC.L count
.SRES
, but reserves space for count+1
elements.
.SRESZ count
.SRESZ.B count
.SRESZ.W count
.SRESZ.L count
.SRES
, but reserves space for count+1
elements.
The GASP listing-control directives correspond to
related GNU as
directives.
.PRINT LIST
.PRINT NOLIST
as
directive
.list
or .nolist
, according to its argument. See section `.list
' in Using as, for details on how these directives
interact.
.FORM LIN=ln
.FORM COL=cols
.FORM LIN=ln COL=cols
.FORM
do not carry over as defaults.) Emits the .psize
assembler directive.
.HEADING string
.PAGE
.ALTERNATE
.ORG
.ORG
.
.RADIX s
.RADIX B
.RADIX Q
.RADIX D
.RADIX H
.EXPORT name
.GLOBAL name
.PROGRAM
.END
.INCLUDE "str"
.INCLUDE
directive does. GASP imposes a maximum
limit of 30 stacked include files, as a sanity check.
.ALIGN size
Since GASP is meant to work with assembly code, its statement syntax has no surprises for the assembly programmer.
Whitespace (blanks or tabs; not newline) is partially significant, in that it delimits up to three fields in a line. The amount of whitespace does not matter; you may line up fields in separate lines if you wish, but GASP does not require that.
The first field, an optional label, must be flush left in a line (with no leading whitespace) if it appears at all. You may use a colon after the label if you wish; GASP neither requires the colon nor objects to it (but will not include it as part of the label name).
The second field, which must appear after some whitespace, contains a GASP or assembly directive.
Any further fields on a line are arguments to the directive; you can separate them from one another using either commas or whitespace.
GASP recognizes a few special markers: to delimit comments, to continue a statement on the next line, to separate symbols from other characters, and to copy text to the output literally. (One other special marker, `\@', works only within macro definitions; see section Defining your own directives.)
The trailing part of any GASP source line may be a comment. A comment begins with the first unquoted comment character (`!' by default), or an escaped or doubled comment character (`\!' or `!!' by default), and extends to the end of a line. You can specify what comment character to use with the `-c' option (see section Command Line Options). The two kinds of comment markers lead to slightly different treatment:
!
.ASSIGNA
or
.ASSIGNC
) present. For example, a macro that begins like this
.MACRO SUM FROM=0, TO=9 ! \FROM \TOissues as the first line of output a comment that records the values you used to call the macro.
\!
!!
To continue a statement on the next line of the file, begin the second line with the character `+'.
Occasionally you may want to prevent GASP from preprocessing some particular bit of text. To copy literally from the GASP source to its output, place `\(' before the string to copy, and `)' at the end. For example, write `\(\!)' if you need the characters `\!' in your assembly output.
To separate a preprocessor variable from text to appear
immediately after its value, write a single quote ('
). For
example, `.SDATA "\P'1"' writes a string built by concatenating the
value of P
and the digit `1'. (You cannot achieve this by
writing just `\P1', since `P1' is itself a valid name for a
preprocessor variable.)
There are two ways of writing string constants in GASP: as
literal text, and by numeric byte value. Specify a string literal
between double quotes ("str"
). Specify an individual
numeric byte value as an absolute expression between angle brackets
(<expr>
. Directives that output strings allow you to
specify any number of either kind of value, in whatever order is
convenient, and concatenate the result. (Alternate syntax mode
introduces a number of alternative string notations; see section Alternate macro syntax.)
You can write numeric constants either in a specific base, or in
whatever base is currently selected (either 10, or selected by the most
recent .RADIX
).
To write a number in a specific base, use the pattern
s'ddd
: a base specifier character s, followed
by a single quote followed by digits ddd. The base specifier
character matches those you can specify with .RADIX
: `B' for
base 2, `Q' for base 8, `D' for base 10, and `H' for base
16. (You can write this character in lower case if you prefer.)
GASP recognizes symbol names that start with any alphabetic character, `_', or `$', and continue with any of the same characters or with digits. Label names follow the same rules.
There are two kinds of expressions, depending on their result: absolute expressions, which resolve to a constant (that is, they do not involve any values unknown to GASP), and relocatable expressions, which must reduce to the form
addsym+const-subsym
where addsym and subsym are assembly symbols of unknown value, and const is a constant.
Arithmetic for GASP expressions follows very similar rules to C. You can use parentheses to change precedence; otherwise, arithmetic primitives have decreasing precedence in the order of the following list.
+
(identity), -
(arithmetic opposite), or
~
(bitwise negation). The argument must be an absolute
expression.
*
(multiplication) and /
(division). Both arguments
must be absolute expressions.
+
(addition) and -
(subtraction). At least one argument
must be absolute.
&
(bitwise and). Both arguments must be absolute.
|
(bitwise or) and ~
(bitwise exclusive or; ^
in
C). Both arguments must be absolute.
You can use these primitives to manipulate strings (in the argument field of GASP statements):
.LEN("str")
"str"
, as an absolute
expression. For example, `.RES.B .LEN("sample")' reserves six
bytes of memory.
.INSTR("string", "seg", ix)
2
.
The result is -1
if seg does not occur in string
after position ix.
.SUBSTR("string",start,len)
If you specify `-a' or `--alternate' on the GASP command
line, the preprocessor uses somewhat different syntax. This syntax is
reminiscent of the syntax of Phar Lap macro assembler, but it
is not meant to be a full emulation of Phar Lap or similar
assemblers. In particular, GASP does not support directives such
as DB
and IRP
, even in alternate syntax mode.
In particular, `-a' (or `--alternate') elicits these differences:
LOCAL
, is available. See section Defining your own directives, for an explanation of how to use
LOCAL
.
"string"
:
'string'
<string>
Jump to: ! - + - - - . - ; - \ - a - b - c - d - e - f - g - i - l - m - n - p - r - s - t - w
!
default comment char
;
as comment char
This document was generated on 17 March 1999 using the texi2html translator version 1.52.