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 ...
.END. See section Miscellaneous commands.
strings size s : nGASP displays these statistics on the standard error stream, when done preprocessing.
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
.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"
.AIFpreprocessor 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:
Two preprocessor directives allow you to repeatedly issue copies of the same block of assembly code.
.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
.AWHILE stra cmp strb
.AENDWmarks 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,
.AWHILEis 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:
.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.
.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
.ASSIGNonce it has a value.
pvar .ASSIGNA aexpr
.ASSIGNAat any time.
pvar .ASSIGNC "str"
.ASSIGNCat any time.
pvar .REG (register)
.REGto define a variable that represents a register. In particular, register is not evaluated as an expression. You may use
.REGat 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.
.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
.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 macargs ...
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 ( macargs ... )
LOCAL name [ , ... ]
LOCALis 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.
LOCALallows 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, ...
asdirective (labelled with lab). The unqualified
.DATA.Wemits `.short'; and
.DATA.Lemits `.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
asemit repeat copies of the value of the expression expr (using the
.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" ...
.SDATAconcatenates 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" ...
.SDATAZ "str" ...
.SDATA, except that
.SDATAZwrites 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
.SDATACfor strings less than 256 bytes in length.
directives to reserve memory and leave it uninitialized. GASP
resolves these directives to appropriate calls of the GNU
.RES.Breserves count bytes,
.RES.Wreserves count pairs of bytes, and
.RES.Lreserves count quartets.
.RESwithout a suffix is equivalent to
.SRESis a synonym for `.RES'.
.SRES, but reserves space for
.SRES, but reserves space for
The GASP listing-control directives correspond to
.nolist, according to its argument. See section `
.list' in Using as, for details on how these directives interact.
.FORM LIN=ln COL=cols
.FORMdo not carry over as defaults.) Emits the
.INCLUDEdirective does. GASP imposes a maximum limit of 30 stacked include files, as a sanity check.
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:
.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 (
example, `.SDATA "\P'1"' writes a string built by concatenating the
P and the digit `1'. (You cannot achieve this by
writing just `\P1', since `P1' is itself a valid name for a
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
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
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.
-(arithmetic opposite), or
~(bitwise negation). The argument must be an absolute expression.
/(division). Both arguments must be absolute expressions.
-(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):
"str", as an absolute expression. For example, `.RES.B .LEN("sample")' reserves six bytes of memory.
.INSTR("string", "seg", ix)
2. The result is
-1if seg does not occur in string after position ix.
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
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
!default comment char
;as comment char
This document was generated on 16 September 1996 using the texi2html translator version 1.51.