CHAPTER 3 Macro - Assembler
Jump to navigation
Jump to search
Here we are yet again. Chapter 3 of the huge Devpac Docs typed by
the Animal house and edited by Sewer Rat for Doc Disk Number 8.
CHAPTER 3
MACRO ASSEMBLER
INTRODUCTION
GenST is a powerful, fast, full specification assembler,
available instantly from within the editor or as a stand alone
program. It converts the text typed or loaded into the editor,
optionally together with the files read from the disk, into a
binary file suitable for immediate execution or linking, or into a
memory image for immediate execution from the editor.
INVOKING THE ASSEMBLER
FROM THE EDITOR
The assembler is invoked from the editor by clicking on
Assemble from the Program menu, or by pressing Alt-A. A dialogue
box will appear which looks like this (almost),
-------------------------------------------------
Assembly Options
Program type Exec GST DRI
Symbols case Dependant Independant
Debug info None Normal Extended
List None Screen Printer Disk
Output to
None Memory max 10_k
Disk |__________________________________
Cancel Assemble
__________________________________________________
PROGRAM TYPE This lets you select between executable GST or
DRI format output. The differences between these are detailed
later.
SYMBOLS CASE This lets you select whether labels are case
dependant or not. If case Dependant is selected then Test and test
would be different labels, if the case Independant is selected
then they would be the same.
DEBUG INFO If you wish to debug your program using your
original symbols you can select Normal or Extended debug modes.
The advantage of extended debug is that up to 22 characters of
each symbol are included in the debug information, whereas normal
mode restricts symbols to eight characters.
LIST selecting Printer will divert the listing to the
current printer port, or selecting Disk will send the listing to a
file based on the source filename, but with the extension .LST.
OUTPUT TO This lets you select where the output file is to be
created. None means it is 'thrown away', ideal for syntax checking
a program; Memory means it is assemble into a buffer allowing it
to be run or debugged instantly form the editor without having to
create a disk file: Disk means a file will be created. The
selection of the name of this file can be left to the assembler,
using rules described shortly.
The first two options may be specified in the source file
using the OPT directive.
Having selected your required options you should click on the
Assemble button (or press Return) to start the assembly. At the
end of assembly you should press any key to return to the editor.
If any errors occurred the cursor will be positioned on the first
offending line.
STAND ALONE ASSEMBLER
If the .TTP version of the assembler is invoked, the one
without a command line, the programmer will be asked for one,
confirming to the rules below, or press Return to abort. At the
end of assembly there will be a pause, pressing any key will exit
the program. If a command line has been supplied the assembler
will not wait for a key as it assumes it has been run from the CLI
or batch file.
COMMAND LINE FORMAT
The command line should be the form
mainfile <-options> [-options]
The mainfile should be the name of the file requiring
assembly and if no extension is specified defaults to ,S. Options
should follow this donated by a - sign then an alphabetical
character. Allowed options are shown below together with
equivalent OPT directives :
B no binary file should be created
C case insensitive labels (OPT C-)
D debug (OPT D+)
L GST linkable code (OPT L+)
L2 DRI linkable code (OPT L2)
O specify output filename (follows immediately after O)
P specify listing filename (should follow immediately
after P) defaults to source filename with extension .LST
Q pause for key press after assembly
X extended debugging (OPT X+)
The default is to create an executable binary file with the
name based on the source file and output file type, no listing,
with no case sensitive labels. For example,
test -b
assembles test.s with no binary output file
test -om:test.prg -p
assembles test.s into a binary file m:test.prg and a listing file
to test.lst
test -L2dpprn:
assembles test.s into DRI linkable code with debug and a listing
to the parallel port. (A listing to the serial port can be
obtained by specifying AUX: as the listing name.
OUTPUT FILENAME
GenST has certain rules regarding the calculation of the
output filename, using a combination of that specified at assembly
time (either in the Disk: filename field in the dialogue box or
using the -O option on the command line) and the Output directive:
If an output filename is explicitly given at assembly time
then
name = explicit filename
else
if the Output directive has not been used then
name = source filename + .PRG, .BIN or .O
else if the Output directive specifies an extension then
name = source filename + extension in Output
else
name = name in Output
ASSEMBLY PROCESS
GenST is a two-pass assembler; during the first pass it scans
all the text in memory and from disk if required, building up a
symbol table. If syntax errors are found on the first pass
assembly these will be reported and assembly will stop at the end
of the first pass, otherwise, during the second pass the
instructions are converted into bytes, a listing may be produced
if required and a binary file can be created on the disk. During
the second pass any further errors and warnings will be shown,
together with a full listing and symbol table if required.
During assembly, any screen can be paused by pressing Ctrl-S,
pressing Ctrl-Q will resume it. Assembly may be aborted by
pressing Ctrl-C, although doing so will make any binary file being
created invalid as it will be incomplete and should not be
executed.
ASSEMBLY TO MEMORY
To reduce development time GenST can assemble programs to
memory, allowing immediate execution or debugging from the editor.
To do this a program buffer is used., the size of which is
specified in the Assembly Options dialogue box. If no debug option
is specified the size given can be just a little larger than the
output program, but if either form of debug is required a much
larger buffer may be needed.
A program running from memory is just like any other normal
GEMDOS program and should terminate using either pterm or pterm0
GEMDOS calls, foe example
clr.w -(a7)
trap #1
Programs may self-modify if required as a re-executed program
will be in its original state.
The program buffer size and current assembly options can be
made the default on re-loading the editor if Save Preferences is
used.
BINARY FILE TYPES
There are six types of binary files which may be produced by
GenST, for different types of applications. They are distinguished
by the extension on the filename:
.PRG GEM-type application i.e. one that uses windows
.TOS TOS-type application i.e. one that doesn't use windows
.TTP TOS-type application that requires a command line
.ACC desk accessory program file
.BIN non-executable file suitable for linking with GST-
format files and libraries
.O non-executable file suitable for linking with DRI-
format files and libraries
It can also assemble executable code directly to memory when
using the integrated version allowing very fast edit-assemble-
debug-run times.
The first three are double-clickable, can be run from the
Desktop and are known as executable. They differ in the
initialisation performed before the execution. With .PRG files the
screen is cleared to the Desktop's pattern, while with the other
two the screen clears to white, the flashing cursor appears and
the mouse is disabled. When you double-click a .TTP file the
Desktop will prompt you for a command line to pass to it.
.ACC files are executable but cannot be double-clicked on
from the desktop. They will only run successfully when executed by
the AES during the boot sequence of the machine
.BIN and .O files cannot be run immediately, but have to be
read into a linker, usually with other sections, and are known as
linkable object modules. There are two different linker formats on
the ST, .BIN files are GST format, .O files are DRI format. The
difference between these is discussed later in this chapter.
The above extensions are not absolute rules; for example, if
you have a TOS type program you may give it a .PRG extension and
use the Install Application function from the Desktop, but it's
usually much easier to use the normal extensions. One exception is
for programs that are to be placed in an AUTO folder so they
execute during the boot sequence. They have to be TOS type
programs, but need the extension .PRG for the boot sequence to
find them.
** Certain versions of the French ST ROM's do not recognise .TTP
files from the Desktop so they have to be renamed .TOS then
installed as TOS Takes Parameters.
TYPES OF CODE
Unlike most 8-bit operating systems, but like most 16-bit
systems, an executable program under GEMDOS will not be loaded at
a particular address but, instead, be loaded at an address
depending on the exact free memory configuration at that time.
To get around the problem of absolute addressing the ST file
format includes relocation information allowing GEMDOS to relocate
the program after it has loaded it but before running it. For
example the following program segment
move.I #string, a0
.
.
.
string dc.b 'Press any key',0
places the absolute address of string into a register, even though
at assembly time the real address of string cannot possibly be
known. Generally the programmer may treat addresses as absolute
even though the real addresses will not be known to him, while the
assembler (or linker) will look after the necessary relocation
information.
** For certain programs, normally games or cross machine
development an absolute address may be required, for this reason
the ORG directive is supported.
The syntax of the assembler will now be described.
ASSEMBLER STATEMENT FORMAT
Each line that is to be processed by the assembler should
have the following format;
Label Mnemonic Operand(s) Comment
Start move.l d0,(a0)+ store the result
Exceptions to this are comment lines, which are lines
starting with an asterisk or semi-colon, and blank lines, which
are ignored. Each field has to be separated from the others by
white space - any number or mixture of space and tab characters.
LABEL FIELD
The label should normally start at line 1, but if a label is
required to start at another position then it should be followed
immediately by a colon (:). Labels are allowed on all
instructions, but are prohibited on some assembler directives, and
absolutely required on others. A label may start with the
characters A-Z, a-z, or underline (_), and may continue with a
similar set together with the addition of the digits 0-9 and the
period (.).
Labels starting with a period are local labels, described
later. Macro names and register equate symbols may not have
periods in them, though macro names may start with a period. By
default the first 127 characters of labels are significant, though
this can be reduced if required. Labels should not be the same as
register names, or the reserved words SR, CCR or USP.
By default labels are case-sensitive though this may be
changed.
Some example legal labels are ;
test, Test, TEST, _test, _test.end, test5, _test5
Some illegal labels are;
5test, _&e, test>,
There are certain reserved symbols in GenST, denoted by
starting with two underline characters. These are __LK, __RS and
__G2.
MNEMONIC FIELDS
The mnemonic field comes after the label field and can
consist of 68000 assembler instructions, assembly directives or
macro calls. Some instructions and directives allow a size
specifier, separated from the mnemonic by a period. Allowed sizes
are .B for byte, .W for word, .L for long and .S for short. Which
size specifiers are allowed in each case depends on the particular
instruction or directive. GenST is case-sensitive to mnemonic and
directive names, so Move is the same as move and the same as mOvE,
for example.
OPERAND FIELD
For those instructions or directives which require operands,
this field contains one or more parameters, separated by commas.
GenST is case-sensitive regarding register names so they may be in
either or mixed case.
COMMENT FIELD
Any white space not within quotes found after the expected
operand(s) is treated as a delimiter before the start of the
comment, which will be ignored by the assembler.
EXAMPLES OF VALID LINES
move.l d0,(a0)+ comment is here
loop TST.W d0
lonely.label
rts
* this is a complete line of comment
; and so is this
indented: link A6,#-10 make room
a_string: dc.b 'spaces allowed in quotes' a string
EXPRESSIONS
GenST allows complex expressions and supports full operator
precedence, parenthesis and logical operators.
Expressions are in two types -absolute and relative - and the
distinction is important. Absolute expressions are constant values
which are known at assembly time. Relative expressions are program
addresses which are not known at assembly-time as the GEMDOS
loader can put the program where it likes in memory. Some
instructions and directives place restrictions on which types are
allowed and some operators cannot be used with certain type-
combinations.
OPERATORS
The operators available, in decreasing order of precedence,
are:
monadic minus (-) and plus (+)
bitwise not (~)
shift left (<<) and shift right (>>)
bitwise And (&), Or (!), and Xor (^)
multiply (*) and divide (/)
addition (+) and subtraction (-)
equality (=), less than (<), greater than (>)
The comparison operators are signed and return 0 if false or
-1 ($FFFFFFFF) if true. The shift operators take the left hand
operand and shift it the number of bits in the right hand operand
and vacated bits are filled with zeros.
This precedence can be overridden by the parentheses ( and ).
With operators of equal precedence, expressions are evaluated from
left-to-right. Spaces in expressions (other than those within
quotes as ASCII constants) are not allowed as they are taken as
the separator to the comment.
All expression evaluation is done using 32-bit signed-integer
arithmetic, with no checking of overflow.
NUMBERS
Absolute numbers may be in various forms;
decimal constants, e.g. 1029
hexadecimal constants, e.g. $12f
octal constants, e.g. @730
binary constants, e.g. %1100010
character constants, e.g. 'X'
$ is used to denote hex numbers, % for binary, @ for octal
and single ' or double quotes " for character constants.
CHARACTER CONSTANTS
Whichever quote is used to mark the start of a string must
also be used to denote its end and quotes themselves may be used
in strings delimited with the same quote character by having it
occur twice. Character constants can be upto 4 characters in
length and evaluate to right-justified longs with null-padding if
required. For example, her are some character constants and their
ASCII and hex values:
"Q" Q $00000051
"hi" hi $00006869
"Test" test $54657374
"it's" it's $6974277C
'it''s' it's $6974277C
Strings used in DC.B statements follow slightly different
justification rules, detailed with the directive later.
Symbols used in expressions will be either relative or
absolute, depending on how they were defined. Labels within the
source will be relative, while those defined using the EQU
directive will be the same type as the expression to which they
are equated.
The use of an asterisk (*) denotes the value of the program
counter at the start of the instruction or directive and is always
a relative quantity.
ALLOWED TYPE COMBINATIONS
The table below summarises for each operator the results of
the various type combinations of parameter an d which combinations
are not allowed. An R denotes a Relative result, an A denotes
absolute and a * denotes that the combination is not allowed and
will produce an error message if attempted.
A op A A op R R op A R op R
Shift operators A * * *
Bitwise operators A * * *
Multiply A * * *
Divide A * * *
Add A R R *
Subtract A * R A
Comparisons A * * A
ALLOWED TYPE COMBINATIONS
ADDRESSING MODES
The available addressing modes are shown in the table below.
Please note that GenST is case-insensitive when scanning
addressing modes, so D0 and a3 are both valid registers.
FORM MEANING EXAMPLE
Dn data register direct D3
An address register direct A5
(An) address register indirect (A1)
(An)+ address reg indirect + post-increment. (A5)+
-(An) address reg indirect + pre-increment. -(A0)
d(An) address reg indirect with displacement 20(A7)
d(An,Rn.s)address register indirect with index 4(A6,D4.L)
d.W absolute short address $0410.W
d.L absolute long address $12000.L
d(PC) program counter relative with offset NEXT(PC)
d(PC,Rn.s)program counter relative with index NEXT(PC,A2.W)
#d immediate data #26
n denotes register number from 0 to 7
d denotes a number
R denotes index register, either A or D
s denotes size, either W or L, when omitted defaults to W
When using address register indirect with index the displacement
may be omitted, for example
move.l (a3,d2.l),d0
will assemble to the same as
move.l 0(a3,d2.l),d0
SPECIAL ADDRESSING MODES
CCR condition code register
SR status register
USP user stack pointer
In addition to the above, SP can be used in place of A7 in any
addressing mode, e.g. 4(SP,D3.W)
The data and address registers can also be denoted by use of
the reserved symbols R0 through R15. R0 to R7 are equivalent to D0
to D7, R8 to R15 are equivalent to A0 to A7. This is included for
compatibility with other assemblers.
LOCAL LABELS
GenST supports local labels, that is labels which are local
to a particular area of the source code. These are denoted by
starting with a period and are attached to the last non-local
label, for example;
lenl move.l 4(sp),a0
.loop tst.b (a0)+
bne.s .loop
rts
len2 move.l 4(sp),a0
.loop tst.b -(a0)
bne.s .loop
rts
There are two labels called .loop in this code segment but the
first is attached to lenl, the second to len2.
The local labels .W and .L are not allowed to avoid confusion with
the absolute addressing syntax.
SYMBOLS AND PERIODS
Symbols which include the period character can cause problems
with GenST due to absolute short addressing.
The Motorola standard way of denoting absolute short addresses
causes problems as periods are considered to be part of a label,
best illustrated by an example:
move.l vector.w,d0
where vector is an absolute value, such as a system variable. This
would generate an undefined label error, as the label would be
scanned as vector.w. To get around this, the expression, in this
case a symbol, may be enclosed in brackets, e.g.
move.l (vector).w,d0
though the period mat still be used after numeric expressions,
e.g.
move.l $402.w,d0
** GenST version 1 also supported the use of \ instead of a
period to denote short word addressing and this is still supported
in this version, but this is not recommended due to the potential
for \W and \L to be mistaken for macro parameters.
INSTRUCTION SET
WORD ALIGNMENT
All instructions with the exception of DC.B and DS.B are
always assembled on a word boundary. Should you require a DC.B
explicitly on a word boundary, the EVEN directive should be used
before it. Although all instructions that require it are word-
aligned, labels with nothing following them are not word aligned
and can have odd values. This is best illustrated by an example;
nop this is always word aligned
dc.b 'odd'
start
tst.l (a0)+
bne.s start
The above code would not produce the required result as start
would have an odd value. To help in finding such an instructions
the assembler will produce an error if it finds an odd destination
in a BSR or BRA operand. Note that such checks are not made on any
other instructions, so it is recommended that you precede such
labels with EVEN directives if you require them to be word-
aligned. A common error is deliberately not to do this, as you
know the preceding string is an even number of bytes long. All
will be well until the day you change the string...
INSTRUCTION SET EXTENSIONS
The complete 68000 instruction set is supported and certain
shorthands are automatically accepted, detailed below. A complete
description of the instruction set including syntax and addressing
modes can be found in any 68000 reference guide or in the supplied
pocket guide.
CONDITION CODE
The altenate condition codes HS and LO are supported in Bcc, DBcc
and Scc instructions, equivalent to CC and CS, respectively.
BRANCH INSTRUCTIONS
To force a short branch use Bcc.B or Bcc.S, to force a word
branch use Bcc.W or to leave the optimiser use Bcc. Bcc.L is
supported for compatibility with GenST 1 with a warning as it is,
strictly speaking, a 68020 ibnstruction. A BRA.S to the
immediately following instruction is not allowed and is converted,
with a warning, to a NOP. A BSR.S to the immediately following
instruction is not allowed and will produce an error.
BTST INSTRUCTION
BTST is unique among bit-test instructions in supporting PC-
relative addressing modes.
CLR INSTRUCTION
CLR An is not allowed, use SUB.L An,An instead (though note
that the flags are not affected).
CMP INSTRUCTION
If the source is immediate then CMPI is used, else if the
destination is an address register then CMPA is used, else if both
addressing modes are post-incremented then CMPM is used.
DBcc INSTRUCTION
DBRA is accepted as an equivalent to DBF.
ILLEGAL INSTRUCTION
This generates the op-cope word $4AFC.
LINK INSTRUCTION
If the displacement is positive or not even a warning is given.
MOVE FROM CCR INSTRUCTION
This is a 68010 and upwards instruction, converted with a
warning to MOVE from SR.
MOVEQ INSTRUCTION
If the data is in the range 128-255 inclusive a warning will
be given. It may be disabled by specifying a long size on the
instruction.
ASSEMBLER DIRECTIVES
Certain pseudo-mnemonics are recognised by GenST. These
assembler directives, as they are called, are not (normally)
decoded into opcodes, but instead direct the assembler time. These
actions have the effect of changing the object code produced, or
the format of the listing. Directives are scanned exactly like
executable instructions and some may be preceded by a label (for
some it is obligatory) and may be followed by a comment. If you
put a label on a directive for which it is not relevant, the
result will be undefined but will usually result in the label
being ignored.
Each directive will now be described in turn. Please note
that the case of a directive name is not important, though they
generally are shown in upper case. The use of angled brackets ( <
> ) in descriptions denote optional items, ellipses ( ... )
denote repeated items.
ASSEMBLY CONTROL
END
This directive signals that no more text is to be examined on
the current pass of the assembler. It is not obligatory.
INCLUDE filename
This directive will cause source code to be taken from a file
on disk and assembled exactly as though it were present in the
text. The directive must be followed by a filename in normal
GEMDOS format.
If the filename has a space in it the name should be enclosed
in single or double quotes. A drive specifier, directory and
extension may be included as required, e.g.
include b:constants/header.s
Include directives may be nested as deeply as memory allows
and if any error occurs when trying to open the file or read it,
assembly will be aborted with a fatal error.
If no drive or path name is specified, that of the main
source file will be used when trying to open the file.
** The more memory the better, GenST will read the whole of the
file in one go if it can and not bother to re-read the file during
pass 2.
INCBIN filename
This takes a given binary file and includes it, verbatim,
into the output file. Suggested uses include screen data, sprite
date and ASCII files.
OPT option <,option>...
This allows control over various options within GenST and
each one is denoted by a single character normally followed by a +
or - sign. Multiple options may be specified, separated by commas.
The allowed options are:
OPTION C - CASE SENSITIVITY AND SIGNIFICANCE.
By default, GenST is sensitive to label case and labels are
significant to 127 characters. This can be overridden , using C-
for case-sensitivity or C+ for case-insensitivity. The significan�
ce may be specified by specifying a decimal number between the C
and the sign, for example C16+ denotes case insensitive labels
with 16 character significance. This option may be used at any
time in a program but normally only makes sense at the very
beginning of a source file.
OPTION D - DEBUGGING INFORMATION
The GEMDOS binary file format supports the inclusion of a
symbol table at the end, which may be read by debuggers such as
MONST and can be extremely useful when debugging programs. By
default this is switched off but it may be activated with D+ and
de-activated with D-. The first 8 characters only of all relative
labels are written to the file and will be upper-cased if GenST is
in case-sensitive mode. The 8 character limit is due to the DIR
standard file format and may be improved on by using the extended
debug option, described below.
OPTION L - LINKER MODE.
The default for GenST is to produce executable code but L+
will make it produce GST linkable code, L2 will make it produce
DIR linkable code, or L- will make it revert to executable. This
directive must be the very first line, in the first text file.
OPTION M - MACRO EXPANSIONS.
When an assembly listing is produced, macro calls are shown
in the same form as in the source. If you wish the instructions
within macros to be listed, use M+, while M- will disable the
option. You can use this directive as often as required.
OPTION O - OPTIMISING.
GenST is capable of optimising certain statements to faster
and smaller versions. By default all optimising is off but each
type can be abled and disabled as required. This option has
several forms:
OPT O1+ will optimise backward branches to short if within
range, can be disabled with O1-.
OPT O2+ will optimise address register indirect with
displacement addressing modes to addresss register
indirect, if the displacemant evalues to zero, and
can be disabled with O2-. For example,
move.l next(a0),d3
will be optimised to
move.l (a0),d3
If the value of next is zero.
OPT O+ will turn all optimising on.
OPT O- will turn all optimising off.
OPT O1-, OPT O2- will disable the relevant optimisation.
OPT OW- will disable the warning messages generated by each
optimisation, OW+ will enable them.
If any optimising has been done during an assembly the number
of optimisations made and bytes saved will be shown at the end of
assembly.
OPTION P - POSITION INDEPENDANT CHECKS.
With this enabled with P+ GenST will check that all code
generated is position-independant, generating errors on any lines
which require relocation. It can be disabled with P- and defaults
to off.
OPTION S - SYMBOL TABLE
When a listing is turned on a symbol table will be produced
at the end. If you wish to change this S- will disable it, while
S+ will re-enable it. If you use this directive ore than once the
last one will be taken into account.
OPTION T - TYPE CHECKING.
GenST can often spot programming errors as it checks the
types of certain expressions. For some applications or styles of
programming this can be more of a hindrance than a help. So T-
will turn checks off. T+ turning them back on. For example the
program segment
main bsr initialise
lea main(a6),a0
move.l (main).w,a0
will normally produce an error as main is a relative
expression where as the assembler expects an absolute expression
in both cases. However if this code is designed to run on another
68000 machine this may be perfectly valid, so the type checking
should be disabled.
OPTION W - WARNINGS
If you wish to disable the warnings that GenST can produce,
you can do so with W-. To re-enable them use W+. This directive
can be used as often as required.
OPTION X - EXTENDED DEBUG
This is a special version of option D which uses the HiSoft
Extended Debug format to generate debugging information with
symbols of up to 22 character significance.
OPTION SUMMARY
The defaults are shown in brackets after each options
description;
C case-sensitivity and significance (C127+)
D include debugging info, (D-)
L- produce executable code (default)
L+ produce GST linkable code
L2 produce DIR linkable code
M expand macros enlisting (M+)
O optimising control (O-)
P position independant code checks (P-)
S symbol table listing
T type checking (T+)
W warning control (W+)
X extended debug (X-)
For example - opt m+,s+,w-
will turn macro expansion on, enable the symbol table list and
turn warnings off.
<label> EVEN
This directive will force the program counter to be even,
i.e. word aligned. As GenST automatically word-aligns all
instructions (except DC.Bs and DS.Bs). It should not be required
very often but can be useful for ensuring buffers and strings are
word-aligned when required
CNOP offset,alignment
This directive will align the program counter using the given
offset and alignment. An alignment of 2 means word-aligned, an
alignment of 4 means long-word-aligned and so on. The alignment is
relative to the start of the current section. For example,
cnop 1,4
aligns the program counter a byte past the next long-word
boundary.
<label> DC.B expression<,expression> ...
<label> DC.W expression<,expression> ...
<label> DC.L expression<,expression> ...
These directives define constants in memory. They may have
one or more operands, separated by commas. The constants will be
aligned on word boundaries for DC.W and DC.L no more than 128
bytes can be generated by a single DC directive.
DC.B treats strings slightly different to those in normal
expressions. While the rules described previously about quotation
marks still applies. No padding of the bytes will occur, and the
length of any string can be upto 128 bytes.
Be very careful of spaces in any DC directives, as a space is
the delimiter before a comment. For example, the line
dc.b 1,2,3 ,4
will only generate 3 bytes - the ,4 will be taken as a comment.
<label> DS.B expression
<label> DS.W expression
<label) DS.L expression
These directives will reserve memory locations and the
contents will be initialised to zeros. If there is a label then it
will be set to the start of the area defined, which will be on a
word boundary for DS.W and DS.L directives. There is no
restriction on the size though the larger the area the longer it
will take to save to disk. For example, all of these lines will
reserve 8 bytes of space, in different ways :
ds.b 8
ds.w 4
ds.l 2
<label> DCB.B number,value
<label> DCB.W number,value
<label> DCB.L number,value
This directive allows constant blocks of data to be generated
of the size specified, number specifies how many times the value
should be repeated.
FAIL
This directive will produce the error user error. It can be
used for such things as warning the programmer if an incorrect
number of parameters have been passed to a macro.
OUTPUT filename
This directive sets the normal output filename though can be
overridden by specifying a filename at the start of assembly. If
filename starts with a period then it is used as an extension and
the output name is built up as described previously.
__G2 (reserved symbol)
This is a reserved symbol that can be used to detect whether
GenST is being used to assemble a file using the IFD conditional.
The value of this symbol depends on the version of the assembler
and is always absolute.
REPEAT LOOPS
It is often useful to be able to repeat one or more
instructions a particular number of times and the repeat loop
construct allows this.
<label> REPT expression
ENDR
Lines to be repeated should be enclosed within REPT and ENDR
directives and will be repeated the number of times specified in
the expression. If the expression is zero or negative then no code
will be generated. It is not possible to nest repeat loops. For
example
REPT 512/4 copy a sector quickly
move.l (a0)+,(a1)+
ENDR
** Program labels should not be define within repeat loops to
prevent label defined twice errors.
LISTING CONTROL
LIST
This will turn the assembly listing on during pass 2, to
whatever device was selected at the start of the assembly (or to
the screen of None was initially chosen). All subsequent lines
will be listed until an END directive is reached, the end of the
text is reached, or a Nolist directive is encountered.
Greater control over listing sections of program can be
achieved using LIST+ or LIST- directives. A counter is maintained,
the state of which dictates whether listing is on or off. A LIST+
directive adds one to the counter and a LIST- subtracts one. If
the counter is zero or positive then listing is on, if it is
negative then listing is off. The default starting value is -1
(i.e. listing off) unless a listing is specified when the
assembler was invoked, when it is set to zero. This system allows
a considerable degree of control over listing particularly for
include files. The normal LIST directive sets the counter to 0,
NOLIST sets it to -1.
NOLIST
This will turn off any listing during pass 2.
When a listing is requested onto a printer or to disk, the
output is formatted into pages, with a header at the top of every
page. The header itself consists of a line containing the program
title, date, time and page number, then a line showing the program
title, then a line showing the sub-title, then a blank line. The
date format will be printed in the form DD/MM/YY, unless the
assembler is running on a US Atari ST, then it is MM/DD/YY.
Between pages a form-feed character (ASCII FF, value 12) is
issued.
PLEN expression
This will set the page length of the assembly listing and
defaults to 60. The expression must be between 12 and 255.
LLEN expression
This will set the line width of the assembly listing and
defaults to 132. The value of the expression must be between 38
and 255.
TTL string
This will set the title printed at the top of each page to
the given string, which may be enclosed in single quotes. The
first TTL directive will set the title of the first printed page.
If no title is specified the current include file name will be
used.
SUBTTL string
Sets the subtitle printed at the top of each page to the
given string, which may be enclosed in single quotes. The first
such directive will set the sub-title of the first printed page.
SPC expression
This will output the number of blank lines given in the
expression in the assembly listing, if active.
PAGE
Causes a new page in the listing to be started.
LISTCHAR expression<,expression> ...
This will send the characters specified to the listing device
(except the screen) and is intended for doing things such as
setting condensed mode on printers. For example, on Epsons and
compatibles the line
listchar 15
will set the printer to 132-column mode.
FORMAT parameter<,parameter> ...
This allows exact control over the listed format of a line of
source code. Each parameter controls a field in the listing and
must consist of a digit from 0 to 2 inclusive followed by a + (to
enable the field) or a - (to disable it):
0 line number, in decimal
1 section name/number and program counter
2 hex data words, up to 10 words unless printer is less than 80
characters wide, when up to three words are listed.
LABEL DIRECTIVES
label EQU expression
This directive will set the value and type of the given label
to the results of the expression. It may not include forward
references, or external labels. If there is any error in the
expression, the assignment will not be made. The label is
compulsory and must not be a local label.
label = expression
Alternate form of EQU statement
label EQUR register
This directive allows a data or address register to be
referred to by a user-name, supplied as the label to this
directive. This is known as a register equate. A register equate
must be defined before it is used.
label SET expression
This is similar to EQU, but the assignment is only temporary
and can be changed with a subsequent SET directive. Forward
references cannot be used in the expression. It is especially
useful for counters within macros, for example, using a line
zcount set zcount+1
(assuming zcount is set to 0 at the start of the source). At the
start of pass 2 all SET labels are made undefined, so their values
will always be the same on both passes
label REG register-list
This allows a symbol to be used to denote a register list
within MOVEM instructions, reducing the likelihood of having the
list at the start of a routine different from the list at the end
of the routine. A label defined with REG can only be used in MOVEM
instructions.
<label> RS.B expression
<label> RS.W expression
<label> RS.L expression
These directives let you set up lists of constant labels,
which is very useful for data structures and global variables and
is best illustrated by a couple of examples
Let's assume you have a data structure which consists of a
long word, a byte and another long word, in that order. To make
your code more readable and easier to update should the structure
change, you could use lines such as
rsreset
d_next rs.l 1
d_flag rs.b 1
d_where rs.l 1
and then you could access them with lines like
move.l d_next(a0),a1
move.l d_where(a0),a2
tst.b d_flag(a0)
As another example let's assume you are referencing all your
variables off register A6 (as done in GenST and MonST) you could
define them with lines such as
onstate rs.b 1
start rs.l 1
end rs.l 1
you then could reference them with lines such as
move.b onstate(a6),d1
move.l start(a6),d0
cmp.l end(a6),d0
Each such directive uses its own internal counter, which is reset
to 0 at the beginning of each pass. Every time the assembler comes
across the directive it sets the label according to the current
value (with word alignment if it is .W or .L) then increments it
according to the size and magnitude of the directive. If the above
definitions were the first RS directives, onstate would be 0,
start would be 2 and end would b e6.
RESET
This directive will reset the internal counter as used by the RS
directive.
RSSET expression
This allows the RS counter to be set to a particular value.
__RS (reserved symbol)
This is a reserved symbol having the current value of the RS
counter.
CONDITIONAL ASSEMBLY
Conditional assembly allows the programmer to write a
comprehensive source program that can cover many conditions.
Assembly conditionals may be specified through the use of
arguments, in the case of macros, and through the definition of
symbols in EQU or SET directives. Variations in these can then
cause assembly of only those parts necessary for the specified
conditions.
There are a wide range of directives concerned with
conditional assembly. At the start of the conditional blocks there
must be one of many IF directives and at the end of each block
there must be an ENDC directive. Conditional blocks may be nested
up to 65535 levels.
Labels should not be placed on IF or ENDC directives as the
directives will be ignored by the assembler.
IFEQ expression
IFNE expression
IFGT expression
IFGE expression
IFLT expression
IFLE expression
These directives will evaluate the expression, compare it with
zero and then turn the conditional assembly on or off depending on
the result. The conditions correspond exactly to the 68000
condition codes. For example, if the label DEBUG had the value 1,
then with the following code,
IFEQ DEBUG
logon dc.b 'enter a command:'.0
ENDC
IFNE DEBUG
opt d+ labels please
logon dc.b 'Yeah, gimme man:',0
ENDC
the first conditional would turn assembly off as 1 is not EQ to 0,
while the second conditional would turn it on as 1 is NE to 0.
** IFNE corresponds to IF in assemblers with only one
conditional directive.
The expressions used in these conditional statements must
evaluate correctly.
IFD label
IFND label
These directives allow conditional control depending on
whether a label is defined or not. With IFD, assembly is switched
on if the label is defined, whereas with IFND assembly is switched
on if the label is not defined. These directives should be used
with care otherwise different object codes could be generated on
pass 1 and pass 2 which will produce incorrect code and generate
phasing errors. Both directives also work on reserved symbols.
IFC 'string1','string2'
This directive will compare two strings, each of which must be
surrounded by single quotes. If they are identical assembly is
switched on, else it i switched off. The comparison is case
sensitive.
IFNC 'string1','string2'
This directive is similar to the above, but only switches assembly
on if the strings are not identical. This may at first appear
somewhat useless, but when one or both of the parameters are macro
parameters it can b every useful, as shown in the next section.
ELSEIF
This directive toggles conditional assembly from on to off, or
vice versa.
ENDC
This directive will terminate the current level of conditional
assembly. If there are more IF's then ENDC's an error will be
reported at the end of assembly.
IIF expression instruction
This is a short form of the IFNE directive allowing a single
instruction or directive to be assembled conditionally. No ENDC
should be used with IIF directives.
MACRO OPERATIONS
GenST fully supports Motorola-style macros, which together with
conditional assembly allows you greatly to simplify assembly-
language programming and the readability of your code.
A macro is a way for a programmer to specify a whole sequence
of instructions or directives that are used together very
frequently. A macro is first defined, then its name can be used in
a macro call like a directive with up to 36 parameters.
label MACRO
This starts a macro definition and causes GenST to copy all
following lines to a macro buffer until an ENDM directive is
encountered. Macro definitions may not be nested.
ENDM
This terminates the storing of a macro definition, after a MACRO
directive.
MEXIT
This stops prematurely the current macro expansion and is best
illustrated by the INC example given later.
NARG (reserved label)
This is not a directive but a reserved symbol, Its value is the
number of parameters passed to the current macro, or 0 if used
when not within any macro. If GenST is in the case sensitive mode
then the name should be all upper-case.
Once a macro has been defined with the Macro directive it can
be invoked by using its name as a directive, followed by upto 36
parameters. In the macro itself the parameters may be referred to
by using a backslash character (\) followed by an alpha-numeric
(1-9, A-Z or a-z) which will be replaced with the relevant
parameter when expanded or with nothing if no parameter was given.
There is also the special macro parameter \0 which is the size
appended to the macro call and defaults to W if none is given. If
a macro parameter is to include spaces or commas then the
parameter should be enclosed in between < and > symbols; in this
case a > symbol may be included within the parameters by
specifying >>.
A special form of macro expansion allows the conversion of a
symbol to a decimal or hexadecimal sequence of digits, using the
syntax \<symbol> or \$<symbol>, the latter denoting hex expansion.
The symbol mast be defined and absolute at the time of expansion.
The parameter \@ can be useful for generating unique labels
with each macro call and is replaced when the macro is expanded by
the sequence _nnn where nnn is a number which increases by one
with every macro call. It may be expanded up to 5 digits for
very large assemblies.
A true \ may be included in a macro definition by specifying \\.
A macro call may be spread over more than one line,
particularly useful for macros with large numbers of parameters.
This can be done by ending a macro call with a comma then
starting the next line with an & followed by tabs or spaces then
the continuation of the parameters.
In the assembly listing the default is to show just the macro call
and not the code produced by it. However, macro expansion listings
can be switched on and off using the OPT M directive described
previously.
Macro calls may be nested as deeply as memory permits, allowing
recursion if required.
Macro names are stored in a separate symbol table to normal
symbols so will not clash with similarly named routines, and may
start with a period.
MACRO EXAMPLES
EXAMPLE 1 - CALLING THE BDOS
As the first example, the general GEMDOS calling-sequence for the
BDOS is;
put the word parameters on the stack
invoke a TRAP #1
correct the stack afterwards
A macro to follow these specifications could be,
call_gemdos MACRO
move.w #\1,-(a7) function
trap #1
lea \2(a7),a7 correct stack
ENDM
The directives are in capitals only to make them stand out: they
don't have to be. If you wanted to call this macro to use GEMDOS
function 2 (print a character) the code would be
move.w #'X',-(a7)
call_gemdos 2,4
When this macro call is expanded, \1 is replaced with 2 and \2 is
replaced with 4. \0, if it occurred in the macro, would be W as no
size is given on the call. So the above call would be assembled
as:
move.w #2,-(a7)
trap #1
lea 4(a7),a7
EXAMPLE 2 - AN INC INSTRUCTION]
The 68000 does not have the INC instruction like other processors
but the same effect can be achieved using an ADDQ #1 instruction.
A macro may be used to do this, like so:
inc MACRO
IFC '','\1'
fail missing parameter!
MEXIT
ENDC
addq.\0 #1,\1
ENDM
An example call would be
inc.1 a0
which would expand to
addq.1 #1,a0
The macro starts by comparing the first parameter with an empty
string and causing an error message to be issued using FAIL if it
is equal. The MEXIT directive is used to leave the macro without
expanding the rest of it. Assuming there is a non-null parameter,
the next line does the ADDQ instruction, using the \0 parameter to
get the correct size.
EXAMPLE 3 - A FACTORIAL MACRO
Although unlikely actually to be used as it stands, this macro
defines a label to be the factorial of a number. It shows how
recursion can work in macros. Before showing the macro, it is
useful to examine how the same thing would be done in a high level
language such as Pascal.
function factor(n:integer):integer;
begin
if n>0 then
factor:=n*factor(n-1)
else
factor:=1
end;
The macro definition for this uses the SET directive to do the
multiplication n*(n-1)*(n-2) etc. in this way
* parameter 1= label, parameter 2= 'n'
factor MACRO
IFND \1
\1 set 1 set if not yet defined
ENDC
IFGT \2
factor \1,\2-1 work out next level down
\1 set \1*(\2) n = n * factor(n-1)
ENDC
ENDM
* a sample call
factor test,3
The net result of the previous code is to set test to 3! (3
factorial). The reason the second set has (\2) instead of just \2
is that the parameter will not normally be just a simple
expression, but a list of numbers separated by minus signs, so it
could assemble to
test set test*5-1-1-1
(i.e. test*5-3) instead of the correct
test set test*(5-1-1-1)
(i.e. test *2)
EXAMPLE 4 - CONDITIONAL RETURN INSTRUCTION
The 68000 lacks the conditional return instruction found on other
processors, but macros can be defined to implement them using the
\@ parameter. For example, a return if EQ macro could look like:
rtseq MACRO
bne.s \@
rts
\@
ENDM
The \@ parameter has been used to generate a unique label every
time the macro is called, so will generate in this case labels
such as _002 and _017.
EXAMPLE 5 - NUMERIC SUBSTITUTION
Suppose you have a constant containing the version number of your
program and wish it to appear as ASCII in a message:
showname MACRO
dc.b \1,'\<version>',0
ENDM
.
.
version equ 42
showname <'Real Ale Search Program v'>
will expand to the line
dc.b Real Ale Search Program v','42',0
Note the way the string parameter is enclosed in < >s as it
contains spaces.
EXAMPLE 6 - COMPLEX MACRO CALL
Suppose your program needs a complicated table structure which can
have a varying number of fields. A macro can only be written to
using those parameters that are specified, for example:
table_entry macro
dc.b .end\0-* length byte
dc.b \1 always
IFNC '\2',''
dc,w \2,\3 2nd and 3rd together
ENDC
dc.l \4,\5,\6,\7
IFNC '\8',''
dc.b '\8' text
ENDC
dc.b \9
.end\@ dc.b 0
ENDM
* a sample call
table_entry &42,,,t1,t2,t3,t4,
& <Enter Name:>,%0110
This is a non-trivial example of how macros can make a
programmer's life so much easier when dealing with complex data
structures. In this case the table consists of a length byte,
calculated in the macro using \@, two optional words, four longs,
an optional string, a byte, then a zero byte. The code produced in
this example would be :
dc.b .end_001
dc.b $42
dc.l t1,t2,t3,t4
dc,b 'Enter Name:'
dc,b %0110
.end_001 dc.b 0
OUTPUT FILE FORMATS
GenST is very flexible in terms of output file formats. These
are detailed in this section together with notes on the advantages
and disadvantages of each. Certain directives take different
actions, depending on what output file format is specified.
The exact details of using each format will now be described.
EXECUTABLE FILES
These are directly executable, for example, by double
clicking from the desktop. The file may include relocation
information and/or symbolic information. Normal file extensions
for this of type file .PRG, .TOS, .TTP and .ACC.
ADVANTAGES true BSS sections, reduced development time.
DISADVANTAGES messy if more than one programmer.
GST LINKABLE FILES
When writing larger programs, or when writing assembly
language modules for use from the high level language, a
programmer needs to generate a linkable file. The GST link format
is supported by most of the high level languages produced in
Britain as well as others, for example HiSoft Basic, Lattice C,
Prospero Fortran and Prospero Pascal. GST format files normally
have the extension .BIN.
Advantages great degree of freedom - imported labels can be
used practically anywhere including within arbitrary expressions,
libraries can be created from the assembler, import methods means
the assembler can detect type conflicts.
Disadvantages library format means selective library linking can
be slow, true GEMDOS sections not supported as standard (though
LinkST can create true BSS sections).
DRI LINKABLE FILES
This is the original linker format for the Atari ST created
by Digital Research originally for CP/M 68k. It is supported,
often via a conversion utility, by the majority of US high level
languages. DRI format files normally have the extension .O.
Advantages selective libraries are faster to link than GST
format, GEMDOS sections are fully supported.
Disadvantages very restrictive on use of imported labels; object
files twice as big as executable files, 8 character limit on
symbols.
CHOOSING THE RIGHT FILE FORMAT
If you wish to link with a high level language there isn't
usually much choice - you have to use whichever format is
supported by the language.
If you are writing entirely in assembly language then the
normal choice has to be executable - it is fast to assemble, no
linking required, and allows assembly to memory for decreased
development time.
If you are writing a larger program, say bigger than 32k
object, or writing a program as a team, then linkable code often
makes most sense. We recommend GST-linkable over DRI because of
the much greater flexibility of the format.
OUTPUT FILE DIRECTIVES
This section details those directives whose actions depend on
the output file format chosen. The file format itself can be
chosen by one of the following methods; command line options using
GENST2.TTP; clicking on the radio buttons in the Assembly Options
dialogue box from the editor, or with the OPT L directive at the
beginning of the source file.
Icons are used to denote those sections specific to a file format,
viz
*EXEC* Executable-code, also assembled to memory code.
*GST* GST-linkable code
*DRI* DRI-linkable code.
MODULES AND SECTIONS
MODULE modulename
This defines the start of a new module. The module name
should be contained within quotes if it contains spaces. There is
a default module called ANON_MODULE so the directive is not
obligatory.
*EXEC* This directive is ignored
*DRI* This directive is ignored
*GST* This directive allows assembly-language library files to
be created using multiple modules. Each module is like a self-
contained program segment, with its own imports and exports.
Relative labels are local to there own modules, so you can use two
labels with the same name in different modules with no danger of a
clash. Absolute labels are global to all modules, ideal for
constants and the like.
SECTION sectionname
This defines a switch to the named section. The program may
consist of several sections which will be concatenated together
with other sections of the same name in the final executable file.
By default assembly starts in the TEXT section. You may switch to
any section during the assembly.
*EXEC* Allowed section names are TEXT, the normal program area,
DATA, for initialised data, and BSS a special area of memory
reserved by the GEMDOS program loaded. It is initialised to zero
and takes up no space within the disk file. When in a BSS section
no code generating instructions are allowed except the DS
directive. Using a BSS section for global variables can save
valuable disk space.
*DRI* The rules described above for executable files apply.
*GST* There are no rigid rules about section names. Sections
with the same names from different files will be concatenated by
the linker. The default ordering of sections is the order they are
first used in.
IMPORTS AND EXPORTS
With both linkable types of program it is crucial to be able
to import and export symbols, both relative symbols (i.e. program
references) and absolute symbols (i.e. constants). The GST format
distinguishes between these types whereas the DRI format does not.
The GST format allows the assembler to type check, often finding
programming errors that would otherwise be missed.
XDEF export<,export>...
This defines labels for export to other programs (or
modules). If any of the labels specified are not defined an error
will occur. It is not possible to export local labels.
*EXEC* This directive is ignored
*DRI* Note that all symbols will be truncated (without
warning) before exporting. OPT C8 is therefore recommended.
XREF import<,import>...
XREF.L import<,import>...
This defines labels to be imported from other programs or
modules. If any of the labels specified are defined an error will
occur. The normal XREF statement should be used to import a
relative label (i.e. program reference), while XREF.L should be
used to import absolute labels (i.e. constants). Importing a label
more than once will not produce an error.
*EXEC* This directive is ignored
*DRI* The DRI format does not actually need to know the type
of imports but it is recommended that both forms of XREF are used
to allow the assembler to type check. If you do not type your
imports you should turn type checking off using OPT T-. DRI labels
are only significant to the first 8 characters.
*GST* Care should be taken to import labels of the correct
type otherwise the relocation information will not be correct.
USING IMPORTS IN EXPRESSIONS
*EXEC* There are no imports!
*DRI* Imports may be used in expressions but only one import
per expression is allowed. The results of an expression with an
import in, must be of the form import+number or import-number.
Imports can be combined with arbitrarily complex expressions, so
long as the complex expression lexically precedes it, for example
move.l 3+(1<<count+5)+import
*GST* Imports may be used in expressions, with up to ten per
expression. They may only be added or subtracted from each other
though can be combined with arbitrarily complex expressions, so
long as the complex expression lexically precedes it, for example
move.l 3+(1<<count+5)+import1-import2
Where exactly an expression involving an import can be used
depends on the file format. The following file shows which are
allowed.
Expression GST DRI Example
PC-byte Y N move.w import(pc,d3.w)
bsr.s import
PC-word Y Yž move.w import(pc),a0
bsr import
byte Y N move.b #import,do
word Y Y move.w import(a3),d0
long Y Y move.l import,d0
ž so long as it is not a reference to a different section in the
same program, which is not allowed.
*DRI* *GST* Note that a reference to a symbol in a
different section is regarded as an import and subject to the
above rules.
COMMENT comment string
*EXEC* This directive is ignored
*DRI* This directive is ignored
*GST* The directive passes the following string, exactly as
entered, into the .BIN file and will be shown by the linker.
ORG expression
This will make the assembler generate position dependant code
and set the program counter to the given value. Normal GEMDOS
program,s do not need an ORG statement even if position dependant.
It is included to allow code to be generated for the ROM port or
for other 68000 machines. More than one ORG statement is allowed
in a source file but no padding of the file is done.
*EXEC* It should be used with great care as the binary file
generated will probably not execute correctly when double clicked.
as no relocation information is written out. The binary file
produced has the standard GEMDOS header at the front, but no
relocation information.
*DRI* This directive is not allowed, absolute code generation
is an option in the linker.
*GST* This sends the ORG directive to the linker which will
pad the file with zeros to the given address.
*NOTE* This directive is very unlikely to make sense when
assembling to memory.
OFFSET <expression>
This switches code generation to a special section to
generate absolute labels. The optional expression sets the program
counter for the start of this section. No bytes are written to the
disk and the only code generating directive allowed is DS. Labels
defined in this section will be absolute. For example, to define
some of the system variables of the ST;
offset $400
etv_timer ds.l 1 will be $400
etv_critic ds.l 1 404
etv_term ds.l 1 408
ext_extra ds.l 5 40C
memvalid ds.l 1 420
memcntlr ds.w 1 424
__LK (reserved symbol)
This is a reserved symbol that can be used to detect which
output mode is specified. The value of this symbol is alwayus
absolute and one of the following,
0 executable
1 GST linkable
2 DRI linkable
other values are reserved for future expansion.
DRI DEBUG OPTION
Normally only explicitly XDEF'ed labels are included in the
symbol table within the output file. However the format allows
what it calls local labels (not to be confused with GenST local
labels) which are not true exports and cannot be referred to in
any other modules but will be included in the symbol table in the
file output file for debugging purposes. OPT D+ will cause all
relative labels to be output as DRI local labels.
�9[....�....�....�....�.........�.........�.........�.........�...�]0110
WRITING GST LIBRARIES
When using multiple MODULEs to generate a GST format library
file care must be taken with backward references to imports.
within a library file, Higher level routines should be first,
lower level routines last. For example the source file skeleton
overleaf will not link when used as a selective library.
MODULE low_level
XDEF low_output
low_output
etc
MODULE high_level
XDEF high_output
XREF low_output
high_output
etc
This is because the second module references a label defined in an
earlier module, which is not allowed. The corrected version is:
MODULE high_level
XDEF high_output
XREF low_output
high_output
etc
MODULE low_level
XDEF low_output
low_output
etc
SIMPLE FILE FORMAT EXAMPLES
This section shows a (non-functional and incomplete) example
of the use of each file format.
Executable
SECTION TEXT
start lea string(pc),a0
move.l a0,save_str
bsr printstring
bra quit
SECTION DATA
string dc.b 'Enter Your Name,0
SECTION TEXT
printstring
move.l a0,-(sp)
move.w #9,-(sp)
trap #1
addq.l #6,sp
rts
SECTION BSS
save_str ds.l 1
END
DRI Linkable
XREF.L quit
SECTION TEXT
start move.l #string,a0
move.l a0,save_str
bsr printstring
bra quit
SECTION DATA
string dc.b 'Enter Your Name,0
SECTION TEXT
printstring
move.l a0,-(sp)
move.w #9,-(sp)
trap #1
addq.l #6,sp
rts
SECTION BSS
save_str ds.l 1
END
note the way the instruction has been changed as a PC-
relative reference is not allowed between sections.
GST Linkable
MODULE TESTPROG
COMMENT needs work
XREF.L quit
SECTION TEXT
start lea string(pc),a0
move.l a0,save_str
bsr prinrstring
bra quit
SECTION DATA
string dc.b 'Enter Your Name,0
SECTION TEXT
printstring
move.l a0,-(sp)
move.w #9,-(sp)
trap #1
addq.l #6,sp
rts
SECTION BSS
save_str ds.l 1
END
DIRECTIVE SUMMARY
Assembly Control
END terminate source code
INCLUDE read source file from disk
INCBIN read binary file from disk
OPT option control
EVEN ensure PC even
CNOP align PC arbitrarily
DC define constant
DS define space
DCB define constant block
FAIL force assembly error
Repeat Loop
REPT start repeat block
ENDR end repeat block
Listing Control
LIST enable list
NOLIST disable list
PLEN set page length
LLEN set line length
TTL set title
SUBTTL set sub-title
PAGE start new page
LISTCHAR send control character
FORMAT define listing format
Label Directives
EQU define label value
EQUR define register equate
SET define label value temporarily
REG define register list
RS reserve space
RSRESET reset RS counter
RSSET set RS counter
Conditional Assembly
IFEQ assemble if zero
IFNE assemble in non-zero
IFGT assemble if greater than
IFGE assemble if greater than or equal to
IFLT assemble if less than
IFLE assemble if less than or equal to
IFD assemble if label defined
IFND assemble if label not defined
IFC assemble if strings same
IFNC assemble if strings different
ELSEIF switch assembly state
IIFC immediate IF
Macros
MACRO define macro
ENDM end macro definition
Output File Directives
MODULE start new module
SECTION switch section
XDEF define label for export
XREF define label for import
COMMENT send linker comment
ORG set absolute code generation
OFFSET define offset table
Reserved Symbols
NARG number of macro parameters
__G2 internal version number
__RS RS counter
__LK output file type