.lg 0
.ta 8 16 24 32 40 48 56 64 72 80
.hw iden-ti-fi-er
.nr a 0 1
.nr f 1 1
.de x1
'sp 2
'tl '''%'
'sp 2
.ns
..
.wh 0 x1
.de fo
'bp
..
.wh 60 fo
.ll 79
.lt 79
.de HT
.ti -4
..
.de PP
.sp
.ne 2
.ti +5
..
.de SE
.bp
\fB\\n+a. \\$1\fR
.nr b 0 1
..
.de SB
.br
.ne 10
.sp 5
\fB\\na.\\n+b. \\$1\fR
..
.de DC
.ti -14
DECISION~\\$1:
..
.de IN
.in +6
..
.de OU
.in -6
..
.tr ~
.sp 5
.rs
.sp 10
.ce 3
Changes in EM-1

Addendum to Informatica Rapport IR-54
.sp 5
.PP
This document describes a revision of EM-1.
A list of differences is presented roughly in the order IR-54
describes the original architecture.
A complete list of EM-1 pseudo's and instructions is also included.
.SE Introduction
.PP
EM is a family of intermediate languages, resembling assembly
language for a stack machine.
EM defines the layout of data memory and a partitioning
of instruction memory.
EM has can do operations on five basic types:
pointers, signed integers, unsigned integers, floating point numbers
and sets of bits.
The size of pointers is fixed in each member,
in contrast to the sizes of the other types.
Each member has one more fixed size: the word size.
This is the mimimum size of any object on the stack.
The sizes of all objects on the stack are assumed to
multiples of the word size.
We assume that pointer and word-sizes are both powers of two.
.PP
It is possible to load objects smaller then the word size from memory.
These objects are converted to objects of the word size by
clearing the most significant bytes.
(A separate conversion instruction can do sign extension).
While storing objects smaller then the word size are stored in memory,
the most significant bytes are ignored.
The size of such objects has to be a divisor of the word size.
.PP
Put in other terms, instructions such as LOC, LOL, LOE, STF, etc.
manipulate WORDS.  Up until now, a word was defined as 16 bits.
It is now possible to define a word size other than 16 bits.  For
example, MES 2,1,2 defines a word to be 8 bits and a pointer to be
16 bits.  As another example, MES 2,4,4 defines a word to be 32 bits
and a pointer to be 32 bits.
.PP
If a compiler receives flags telling it to use 32 bit integers, it now
has a choice of setting the word length to 16 bits and using LDL etc
for dealing with integers, or setting the word length to 32 bits and using
LOL etc for integers.
For example, x:=a+b for 32-bit integers would become:

  MES 2,2,4                          MES 2,4,4
  LDL a                              LOL a
  LDL b                              LOL b
  ADI 4                              ADI 4
  SDL x                              STL x

In many cases, the target machine code that is finally produced from either
of the above sequences will not show any traces of the stack machine, however
for some instructions actual pushes and pops at run time will be necessary.
Choosing a wider EM word will usually produce fewer stack operations than
a narrower word, but it eliminates the possibility of doing arithmetic on
quantities smaller than a word.  If, for example, a compiler chooses a 32-bit
EM word, it will be difficult to add two 16 bit integers with ADI, since
the argument must be multiple of the word size.
(The operation can be done by converting the operands to 32 bits using CII,
adding the 32-bit numbers, and reconverting the result.)
On the other hand, choosing a 16-bit EM word makes it possible to do both
16-bit adds (ADI 2) and 32-bit adds (ADI 4), 
but the price paid is that 32-bit operations will be viewed as double
precision, and may be slightly less efficient on target machines with a
32-bit word, i.e. the EM to target translator may not take full advantage
of the 32 bit facilities.
.PP
Note that since LOC pushes a WORD on the stack, the argument of LOC
must fit ina word.  LOC 256 on an EM machine with a 1-byte word length
is not allowed.  LDC 256 is allowed, however.
.PP
A general rule of thumb is that the compiler should choose an EM word
length equal to the width of a single precision integer.
Obviously, compilers should be well parameterized to allow the integer
size(s) and word size(s) to be changed by just changing a few constants.
.PP
The size of a instruction space pointer in is the same
as the size of a data space pointer.
.PP
EM assumes two's complement arithmetic on signed integers,
but does not define an ordering of the bytes in a integer.
The lowest numbered byte of a two-byte object can contain
either the most or the least significant part.
.SE Memory
.PP
EM has two separate addressing spaces, instruction and data.
The sizes of these spaces are not specified.
The layout of instruction space in not defined.
Any interpreter or translator may assume a layout fitting his/her needs.
The layout of data memory is specified by EM.
EM data memory consists of a sequence of 8-bit bytes each separately
addressable.
Certain alignment restrictions exist for object consisting of multiple bytes.
Objects smaller then the word size can only be addressed
at multiples of the object size.
For example: in a member with a four-byte word size, two-byte integers
can only be accessed from even addresses.
Objects larger then the word size can only be placed at multiples
of the word size.
For example: in a member with a four-byte word size,
eight-byte floating point numbers can be fetched at addresses
0, 4, 8, 12, etc.
.SB "Procedure identifiers"
.PP
Procedure identifiers in EM have the same size
as pointers.
Any implementation of EM is free to use any method of identifying procedures.
Common methods are indices into tables containing further information
and addresses of the first instructions of procedures.
.SB "Heap and Stack in global data"
.PP
The stack grows downward, the heap grows upward.
The stack pointer points to the lowest occupied word on the stack.
The heap pointer marks the first free word in the heap area.
.br
.ne 39
.sp 1
.nf
       65534 -> |-------------------------------|
                |///////////////////////////////|
		|//// unimplemented memory /////|
                |///////////////////////////////|
          SB -> |-------------------------------|
		|				|
		|     stack and local area      | <- LB
                |                               |
		|				|
                |-------------------------------| <- SP
		|///////////////////////////////|
		|// implementation dependent  //|
		|///////////////////////////////|
                |-------------------------------| <- HP
		|				|
		|           heap area           |
		|				|
		|                               |
                |-------------------------------|
		|				|
		|          global area          |
		|				|
          EB -> |-------------------------------|
		|				|
		|				|
                |         program text          | <- PC
		|				|
		|				|
          PB -> |-------------------------------|
		|///////////////////////////////|
		|////////// undefined //////////|
		|///////////////////////////////|
           0 -> |-------------------------------|

	   Fig. \nf.  Example of memory layout showing typical register
           positions during execution of an EM program.
.fi
.SB "Data addresses as arguments"
.PP
Anywhere previous versions of the EM assembly language
allowed identifiers of objects in
data space,
it is also possible to use 'identifier+constant' or 'identifier-constant'.
For example, both "CON LABEL+4" and "LAE SAVED+3" are allowed.
More complicated expressions are illegal.
.SB "Local data area"
.PP
The mark block has been banished.
When calling a procedure,
the calling routine first has to push the actual parameters.
All language implementations currently push their arguments
in reverse order, to be compatible with C.
Then the procedure is called using a CAL or CAI instruction.
Either the call or the procedure prolog somehow has to save
the return address and dynamic link.
The prolog allocates the space needed for locals and is free to
surround this space with saved registers and other information it
deems necessary.
.PP
The locals are now accessed using negative offsets in LOL, LDL, SDL, LAL,
LIL, SIL and STL instructions.
The parameters are accessed using positive offsets in LOL, LDL, SDL, LAL,
LIL, STL and
STL instructions.
The prolog might have stored information in the area between parameters and
locals.
As a consequence there are two bases, AB(virtual) and LB.
AB stands for Argument Base and LB stands for Local Base.
Positive arguments to LOL etc ... are interpreted as offsets from AB,
negative arguments as offsets from LB.
.PP
The BEG instruction is not needed to allocate the locals because
storage for locals is set aside in the prolog.
The instruction still exists under the name ASP (Adjust Stack Pointer).
.PP
Procedures return using the RET instruction.
The RET pops the function result from the stack and
brings the stack pointer and other relevant registers to the state
they had just before the procedure was called.
The RET instruction expects that - aside from possible function results -
the stack pointer has the value it had after execution of the prolog.
RET finally returns control to the calling routine.
The actual parameters have to be removed from the stack by the calling routine,
and not by the called procedure.
.sp 1
.ne 38
.nf



		|===============================|
                |     actual argument  n        |
		|-------------------------------|
                |              .                |
                |              .                |
                |              .                |
		|-------------------------------|
                |     actual argument  1        | ( <- AB )
		|===============================|
		|///////////////////////////////|
		|// implementation dependent  //|
		|///////////////////////////////|   <- LB
                |===============================|
                |                               |
                |       local variables         |
                |                               |
		|-------------------------------|
                |                               |
                |      compiler temporaries     |
                |                               |
		|===============================|
		|///////////////////////////////|
		|// implementation dependent  //|
		|///////////////////////////////|
                |===============================|
                |                               |
                |   dynamic local generators    |
                |                               |
		|===============================|
                |           operand             |
		|-------------------------------|
                |           operand             | <- SP
		|===============================|

                A sample procedure frame.

.fi
.sp 1
This scheme allows procedures to be called with a variable number
of parameters.
The parameters have to be pushed in reverse order,
because the called procedure has to be able to locate the first one.
.PP
.PP
Since the mark block has disappeared, a new mechanism for static
links had to be created.
All compilers use the convention that EM procedures needing
a static link will find a link in their zero'th parameter,
i.e. the last one pushed on the stack.
This parameter should be invisible to users of the compiler.
The link needs to be in a fixed place because the lexical instructions
have to locate it.
The LEX instruction is replaced by two instructions: LXL and LXA.
\&"LXL~n" finds the LB of a procedure n static levels removed.
\&"LXA~n" finds the (virtual) AB.
The value used for static link is LB.
.PP
When a procedure needing a static link is called, first the actual
parameters are pushed, then the static link is pushed using LXL
and finally the procedure is called with a CAL with the procedure's
name as argument.
.br
.ne 40
.nf



		|===============================|
                |     actual argument  n        |
		|-------------------------------|
                |              .                |
                |              .                |
                |              .                |
		|-------------------------------|
                |     actual argument  1        |
		|-------------------------------|
                |        static link            | ( <- AB )
		|===============================|
		|///////////////////////////////|
		|// implementation dependent  //|
		|///////////////////////////////|   <- LB
                |===============================|
                |                               |
                |       local variables         |
                |                               |
		|-------------------------------|
                |                               |
                |      compiler temporaries     |
                |                               |
		|===============================|
		|///////////////////////////////|
		|// implementation dependent  //|
		|///////////////////////////////|
                |===============================|
                |                               |
                |   dynamic local generators    |
                |                               |
		|===============================|
                |           operand             |
		|-------------------------------|
                |           operand             | <- SP
		|===============================|

                A procedure frame with static link.

.fi
.sp 1
.sp 1
.PP
Pascal and other languages have to use procedure
instance identifiers containing
the procedure identifier
'ul
and
the static link the procedure has to be called with.
A static link having a value of zero signals
that the called procedure does not need a static link.
C uses the same convention for pointers to C-routines.
In pointers to C-routines the static link is set to zero.
.PP
Note: The distance from LB to AB must be known for each procedure, otherwise
LXA can not be implemented.
Most implementations will have a fixed size area between
the parameter and local storage.
The zone between the compiler temporaries and the dynamic
local generators can be used
to save a variable number of registers.
.PP
.ne 11
Prolog examples:
.sp 2
.nf

	       proc1                       proc2
	   
	   mov lb,-(sp)                mov lb,-(sp)
	   mov sp,lb                   mov sp,lb
	   sub $loc_size,sp            sub $loc_size,sp
	   mov r2,-(sp) ; save r2      mov r2,-(sp)
	   mov r4,-(sp) ; save r4

.fi
.SB "Return values"
.PP
The return value popped by RET is stored in an unnamed 'function return area'.
This area can be different for different sized objects returned,
e.g. one register for two byte objects,
two registers for four byte objects,
memory for larger objects.
The area is available for 'READ-ONCE' access using the LFR instruction.
The result of a LFR is only defined if the sizes used to store and
fetch are identical.
The only instructions guaranteed not to destroy the contents of
any 'function return area' are ASP and BRA.
Thus parameters can be popped before fetching the function result.
The maximum size of all function return areas is
implementation dependant,
but allows procedure instance identifiers and all
implemented objects of type integer, unsigned, float
and pointer to be returned.

.SE "EM Assembly Language"
.nr b 0 1
.SB "Object types and instructions"
.PP
EM knows five basic object types:
pointers,
signed integers,
unsigned integers,
floating point numbers and
sets of bits.
Operations on objects of the last four types do not assume
a specific size.
Pointers (including procedure identifiers) have a fixed size in each
implementation.
Instructions acting on one or more objects of the last four types need
explicit size information.
This information can be given either as the argument of the
instruction or on top of the stack.
.sp 1
For example:
.nf
addition of integers         LOL a, LOL b, ADI 2
subtraction of two floats    LDL a, LDL b, SBF 4
integer to float             LOL a, LOC 2, LOC 4, CIF, SDL b
.fi
.sp
Note that conversion instructions always expect size
before and size after conversion on the stack.
.sp
No obligation exists to implement all operations on all possible sizes.
.PP
The EM assembly language
allows constants as instruction arguments up to a size of four bytes.
In all EM's it is possible to initialize any type and size object.
BSS, HOL, CON and ROM allow type and size indication in initializers.
.SB "Conversion instructions"
.PP
The conversion operators can convert from any type and size to any
type and size.
The types are specified by the instruction,
the sizes should be in words on top of the stack.
Normally the sizes are multiples of the word size,
There is one exception: the CII instructions sign-extends if the
size of the source is a divisor of the word size.
.SB "CSA and CSB"
.PP
The tables used by these instructions do not contain the procedure
identifier any more.
See also "Descriptors".
.SB EXG
.PP
The EXG instruction is deleted from the EM instruction set.
If future applications show any need for this instruction,
it will be added again.
.SB "FIL"
.PP
A FIL instruction has been introduced.
When using separate compilation,
the LIN feature of EM was insufficient.
FIL expects as argument an address in global data.
This address is stored in a fixed place in memory,
where it can be used by any implementation for diagnostics etc.
Like LIN, it provides access to the ABS fragment at the start
of external data.
.SB "LAI and SAI"
.PP
LAI and SAI have been dropped, they thwarted register optimization.
.SB LNC
.PP
The LNC instruction is deleted from the instruction set.
LOC -n wil do what it is supposed to.
.SB "Branch instructions"
.PP
The branch instructions are allowed to branch both forward and backward.
Consequently BRF and BRB are deleted and a BRA instruction is added.
BRA branches unconditionally in any direction.
.SB LDC
.PP
Loads a double word constant on the stack.
.SB LEX
.PP
LXA and LXL replace LEX.
.SB LFR
.PP
LFR loads the function result stored by RET.
.SB "LIL and SIL"
.PP
They replace LOP and STP. (Name change only)
.SB "Traps and Interrupts"
.PP
The numbers used for distinguishing the various types
of traps and interrupts have been reassigned.
The new instructions LIM and SIM
allow setting and clearing of bits in a mask.
The bits in the mask control the action taken upon encountering certain
errors at runtime.
A 1 bit causes the corresponding error to be ignored,
a 0 bit causes the run-time system to trap.
.SB LPI
.PP
Loads a procedure identifier on the stack.
LOC cannot be used to do this anymore.
.SB "ZER and ZRF"
.PP
ZER loads S zero bytes on the stack.
ZRF loads a floating point zero of size S.
.SB "Descriptors"
.PP
All instructions using descriptors have the size of the integer used
in the descriptor as argument.
The descriptors are: case descriptors (CSA and CSB),
range check descriptors (RCK) and
array descriptors ( LAR, SAR, AAR).
.SB "Case descriptors"
.PP
The value used in a case descriptor to indicate the absence of a label
is zero instead of -1.
.SE "EM assembly language"
.SB "Instruction arguments"
.PP
The previous EM had different instructions for distinguishing
between operand on the stack and explicit argument in the instruction.
For example, LOI and LOS.
This distinction has been removed.
Several instructions have two possible forms:
with explicit argument and with implicit argument on top of the stack.
The size of the implicit argument is the word size.
The implicit argument is always popped before all other operands.
Appendix 1 shows what is allowed for each instruction.
.SB Notation
.PP
First the notation used for the arguments of
instructions and pseudo instructions.
.in +12
.ti -11
<num>~~=~~an integer number in the range -32768..32767
.ti -11
<off>~~=~~an offset -2**31..2**31~-~1
.ti -11
<sym>~~=~~an identifier
.ti -11
<arg>~~=~~<off> or <sym> or <sym>+<off> or <sym>-<off>
.ti -11
<con>~~=~~integer constant,
unsigned constant,
floating point constant
.ti -11
<str>~~=~~string constant (surrounded by double quotes),
.ti -11
<lab>~~=~~instruction label ('*' followed by an integer in the range
0..32767).
.ti -11
<pro>~~=~~procedure number ('$' followed by a procedure name)
.ti -11
<val>~~=~~<arg>,
<con>,
<pro> or
<lab>.
.ti -11
<...>*~=~~zero or more of <...>
.ti -11
<...>+~=~~one or more of <...>
.ti -11
[...]~~=~~optional ...
.in -12
.SB Labels
.PP
No label, instruction or data, can have a (pseudo) instruction
on the same line.
.SB Constants
.PP
All constants in EM are interpreted in the decimal base.
.PP
In BSS, HOL, CON and ROM pseudo-instructions
numbers must be followed by I, U or F
indicating Integer, Unsigned or Float.
If no character is present I is assumed.
This character can be followed by an even positive number or a 1.
The number indicates the size in bytes of the object to be initialized,
up to 32766.
Double precision integers can no longer be indicated by a trailing L.
As said before CON and ROM also allow expressions of the form:
\&"LABEL+offset" and "LABEL-offset".
The offset must be an unsigned decimal number.
The 'IUF' indicators cannot be used with the offsets.
.PP
Areas reserved in the global data area by HOL or BSS can be
initialized.
BSS and HOL have a third parameter indicating whether the initialization
is mandatory or optional.
.PP
Since EM needs aligment of objects, this alignment is enforced by the
pseudo instructions.
All objects are aligned on a multiple of their size or the word size
whichever is smaller.
Switching to another type of fragment or placing a label forces word-alignment.
There are three types of fragments in global data space: CON, ROM and BSS-HOL.
.sp
.SB "Pseudo instructions"
.PP
The LET, IMC and FWC pseudo's have disappeared.
The only application of these pseudo's was in postponing the
specification of the size of the local storage to just before
the END of the procedure.
A new mechanism has been introduced to handle this problem.
.ti +5
The pseudos involved in separate compilation and linking have
been reorganized.
.ti +5
PRO and END are altered and reflect the new calling sequence.
EOF has disappeared.
.ti +5
BSS and HOL allow initialization of the requested data areas.
.sp 2
Four pseudo instructions request global data:
.sp 2
  BSS <off>,<val>,<num>
.IN
Reserve <off> bytes.
<val> is the value used to initialize the area.
<off> must be a multiple of the size of <val>.
<num> is 0 if the initialization is not strictly necessary,
1 otherwise.
.OU
.sp
  HOL <off>,<val>,<num> 
.IN
Idem, but all following absolute global data references will
refer to this block.
Only one HOL is allowed per procedure,
it has to be placed before the first instruction.
.OU
.sp
  CON <val>+ 
.IN
Assemble global data words initialized with the <val> constants.
.OU
.sp
  ROM <val>+ 
.IN
Idem, but the initialized data will never be changed by the program.
.OU
.sp 2
Two pseudo instructions partition the input into procedures:
.sp 2
  PRO <sym>[,<off>] 
.IN
Start of procedure.
<sym> is the procedure name.
<off> is the number of bytes for locals.
The number of bytes for locals must be specified in the PRO or
END pseudo-instruction.
When specified in both, they must be identical.
.OU
.sp
  END  [<off>]
.IN
End of Procedure.
<off> is the number of bytes for locals.
The number of bytes for locals must be specified in either the PRO or
END pseudo-instruction or both.
.OU
.PP
Names of data and procedures in a EM module can either be
internal or external.
External names are known outside the module and are used to link
several pieces of a program.
Internal names are not known outside the modules they are used in.
Other modules will not 'see' an internal name.
.ti +5
In order to reduce the number of passes needed,
it must be known at the first occurrence whether
a name is internal or external.
If the first occurrence of a name is in a definition,
the name is considered to be internal.
If the first occurrence of a name is a reference,
the name is considered to be external.
If the first occurrence is in one of the following pseudo instructions,
the effect of the pseudo has precedence.
.sp 2
  EXA <sym> 
.IN
External name.
<sym> is external to this module.
Note that <sym> may be defined in the same module.
.OU
.sp
  EXP <pro>
.IN
External procedure identifier.
Note that <sym> may be defined in the same module.
.OU
.sp
  INA <sym>
.IN
Internal name.
<sym> is internal to this module and must be defined in this module.
.OU
.sp
  INP <pro> 
.IN
Internal procedure.
<sym> is internal to this module and must be defined in this module.
.OU
.sp 2
Two other pseudo instructions provide miscellaneous features:
.sp 2
  EXC <num1>,<num2> 
.IN
Two blocks of instructions preceding this one are
interchanged before being processed.
<num1> gives the number of lines of the first block.
<num2> gives the number of lines of the second one.
Blank and pure comment lines do not count.
.OU
.sp
  MES <num>,<val>* 
.IN
A special type of comment.  Used by compilers to communicate with the
optimizer, assembler, etc. as follows:
.br
  MES 0 -
.IN
An error has occurred, stop further processing.
.OU
.br
  MES 1 -
.IN
Suppress optimization
.OU
.br
  MES 2,<num1>,<num2>
.IN
Use word-size <num1> and pointer size <num2>.
.OU
.br
  MES 3,<off>,<num1>,<num2> -
.IN
Indicates that a local variable is never referenced indirectly.
<off> is offset in bytes from LB if positive
and offset from AB if negative.
<num1> gives the size of the variable.
<num2> indicates the class of the variable.
.OU
.br
  MES 4,<num>,<str>
.IN
Number of source lines in file <str> (for profiler).
.OU
.br
  MES 5 -
.IN
Floating point used.
.OU
.br
  MES 6,<val>* -
.IN
Comment.  Used to provide comments in compact assembly language (see below).
.OU
.sp 1
Each back end is free to skip irrelevant MES pseudos.
.OU
.SB "The Compact Assembly Language"
.PP
The assembler accepts input in a highly encoded form.  This
form is intended to reduce the amount of file transport between the compiler
and assembler, and also reduce the amount of storage required for storing
libraries.
Libraries are stored as archived compact assembly language, not machine language.
.PP
When beginning to read the input, the assembler is in neutral state, and
expects either a label or an instruction (including the pseudoinstructions).
The meaning of the next byte(s) when in neutral state is as follows, where b1, b2 
etc. represent the succeeding bytes.
.sp
       0   Reserved for future use
   1-129   Machine instructions, see Appendix 2, alphabetical list
 130-149   Reserved for future use
 150-161   BSS,CON,END,EXC,EXA,EXP,HOL,INA,INP,MES,PRO,ROM
 162-179   Reserved for future pseudoinstructions
 180-239   Instruction labels 0 - 59  (180 is local label 0 etc.)
 240-244   See the Common Table below
 245-255   Not used

After a label, the assembler is back in neutral state; it can immediately
accept another label or an instruction in the very next byte.  There are
no linefeeds used to separate lines.
.PP
If an opcode expects no arguments,
the assembler is back in neutral state after
reading the one byte containing the instruction number.  If it has one or
more arguments (only pseudos have more than 1), the arguments follow directly,
encoded as follows:
.sp
   0-239     Offsets from -120 to 119
.br
 240-255     See the Common Table below
.sp 2
If an opcode has one optional argument,
a special byte is used to announce that the argument is not present.
.ce 1
Common Table for Neutral State and Arguments
.sp
.nf
<lab>   240 b1                Instruction label b1  (Not used for branches)
<lab>   241 b1 b2             16 bit instruction label  (256*b2 + b1)
<sym>   242 b1                Global label .0-.255, with b1 being the label
<sym>   243 b1 b2             Global label .0-.32767
			      with 256*b2+b1 being the label
<sym>   244 <string>          Global symbol not of the form .nnn
. \" Only the previous can occur in neutral state.
<num>   245 b1 b2             (16 bit constant) 256*b2+b1
<off>   246 b1 b2 b3 b4       (32 bit constant) (256*(256*(256*b4)+b3)+b2)+b1
<arg>   247 <sym><off>        Global label + (possibly negative) constant
<pro>   248 <string>          Procedure name  (not including $)
<str>   249 <string>          String used in CON or ROM (no quotes)
<con>   250 <num><string>     Integer constant, size <num> bytes
<con>   251 <num><string>     Unsigned constant, size <num> bytes
<con>   252 <num><string>     Floating constant, size <num> bytes
<end>   255                   Delimiter for argument lists or
			      indicates absence of optional argument

.fi
.PP
The notation <string> consists first of a length field, and then an
arbitrary string of bytes.
The length is specified by a <num>.
.PP
.ne 8
The pseudoinstructions fall into several categories, depending on their
arguments:
.sp
 Group 1 -- EXC, BSS, HOL have a known number of arguments
 Group 2 -- EXA, EXP, INA, INP start with a string
 Group 3 -- CON, MES, ROM have a variable number of various things
 Group 4 -- END, PRO have a trailing optional argument.

Groups 1 and 2
use the encoding described above.
Group 3 also uses the encoding listed above, with a <end> byte after the
last argument to indicate the end of the list.  
Group 4 uses
a <end> byte if the trailing argument is not present.

.ad
.fi
.sp 2
.ne 12
.nf
Example  ASCII			Example compact
(LOC = 66, BRA = 18 here):

  2				182
  1				181
   LOC 10			66 130
   LOC -10			66 110
   LOC 300			66 245 44 1
   BRA 19			18 139
  300				241 44 1
  .3				242 3 
   CON 4,9,*2,$foo		151 124 130 240 2 248 3 102 111 111 255
   LOC .35			66 242 35
.fi
.nr a 0 1
.SE "ASSEMBLY LANGUAGE INSTRUCTION LIST"
.PP
For each instruction in the list the range of operand values
in the assembly language is given.
All constants, offsets and sizes are in the range -2**31~..~2**31-1.
The column headed \fIassem\fP contains the mnemonics defined
in 4.1.
The following column indicates restrictions in the range of the operand.
Addresses have to obey the restrictions mentioned in chapter 2 - Memory -.
The size parameter of most instructions has to be a multiple
of the word size.
The classes of operands
are indicated by letters:
.ds b \fBb\fP
.ds c \fBc\fP
.ds d \fBd\fP
.ds g \fBg\fP
.ds f \fBf\fP
.ds l \fBl\fP
.ds n \fBn\fP
.ds i \fBi\fP
.ds p \fBp\fP
.ds r \fBr\fP
.ds s \fBs\fP
.ds z \fBz\fP
.ds - \fB-\fP
.nf

  \fIassem\fP       constraints            rationale

\&\*c  off                                 1-word constant
\&\*d  off                                 2-word constant
\&\*l  off                                 local offset
\&\*g  arg          >= 0                   global offset
\&\*f  off                                 fragment offset
\&\*n  num          >= 0                   counter
\&\*s  off          > 0                    object size
\&\*z  off          >= 0                   object size
\&\*i  off          > 0                    object size *
\&\*p  pro                                 pro identifier
\&\*b  lab          >= 0                   label number
\&\*r  num          0,1,2                  register number
\&\*-                                      no operand

.fi
.PP
The * at the rationale for \*i indicates that the operand
can either be given as argument or on top of the stack.
If the operand has to be fetched from the stack,
it is assumed to be a word-sized unsigned integer.
.PP
Instructions that check for undefined operands and underflow or overflow
are indicated by (*).
.nf

GROUP 1 - LOAD

  LOC \*c : Load constant (i.e. push one word onto the stack)
  LDC \*d : Load double constant ( push two words )
  LOL \*l : Load word at \*l-th local (l<0) or parameter (l>=0)
  LOE \*g : Load external word \*g
  LIL \*l : Load word pointed to by \*l-th local or parameter
  LOF \*f : Load offsetted. (top of stack + \*f yield address)
  LAL \*l : Load address of local or parameter
  LAE \*g : Load address of external
  LXL \*n : Load lexical. (address of LB \*n static levels back)
  LXA \*n : Load lexical. (address of AB \*n static levels back)
  LOI \*s : Load indirect \*s bytes (address is popped from the stack)
  LOS \*i : Load indirect. \*i-byte integer on top of stack gives object size
  LDL \*l : Load double local or parameter (two consecutive words are stacked)
  LDE \*g : Load double external (two consecutive externals are stacked)
  LDF \*f : Load double offsetted (top of stack + \*f yield address)
  LPI \*p : Load procedure identifier

GROUP 2 - STORE

  STL \*l : Store local or parameter
  STE \*g : Store external
  SIL \*l : Store into word pointed to by \*l-th local or parameter
  STF \*f : Store offsetted
  STI \*s : Store indirect \*s bytes (pop address, then data)
  STS \*i : Store indirect. \*i-byte integer on top of stack gives object size
  SDL \*l : Store double local or parameter
  SDE \*g : Store double external
  SDF \*f : Store double offsetted

GROUP 3 - INTEGER ARITHMETIC

  ADI \*i : Addition (*)
  SBI \*i : Subtraction (*)
  MLI \*i : Multiplication (*)
  DVI \*i : Division (*)
  RMI \*i : Remainder (*)
  NGI \*i : Negate (two's complement) (*)
  SLI \*i : Shift left (*)
  SRI \*i : Shift right (*)

GROUP 4 - UNSIGNED ARITHMETIC

  ADU \*i : Addition
  SBU \*i : Subtraction
  MLU \*i : Multiplication
  DVU \*i : Division
  RMU \*i : Remainder
  SLU \*i : Shift left
  SRU \*i : Shift right

GROUP 5 - FLOATING POINT ARITHMETIC   (Format not defined)

  ADF \*i : Floating add (*)
  SBF \*i : Floating subtract (*)
  MLF \*i : Floating multiply (*)
  DVF \*i : Floating divide (*)
  NGF \*i : Floating negate (*)
  FIF \*i : Floating multiply and split integer and fraction part (*)
  FEF \*i : Split floating number in exponent and fraction part (*)

GROUP 6 - POINTER ARITHMETIC

  ADP \*f : Add \*c to pointer on top of stack
  ADS \*i : Add \*i-byte value and pointer
  SBS \*i : Subtract pointers in same fragment and push diff as size \*i integer

GROUP 7 - INCREMENT/DECREMENT/ZERO

  INC \*- : Increment top of stack by 1 (*)
  INL \*l : Increment local or parameter (*)
  INE \*g : Increment external (*)
  DEC \*- : Decrement top of stack by 1 (*)
  DEL \*l : Decrement local or parameter (*)
  DEE \*g : Decrement external (*)
  ZRL \*l : Zero local or parameter
  ZRE \*g : Zero external
  ZRF \*i : Load a floating zero of size \*i
  ZER \*i : Load \*i zero bytes

GROUP 8 - CONVERT    ( stack: source, source size, dest. size (top) )

  CII \*- : Convert integer to integer (*)
  CUI \*- : Convert unsigned to integer (*)
  CFI \*- : Convert floating to integer (*)
  CIF \*- : Convert integer to floating (*)
  CUF \*- : Convert unsigned to floating (*)
  CFF \*- : Convert floating to floating (*)
  CIU \*- : Convert integer to unsigned
  CUU \*- : Convert unsigned to unsigned
  CFU \*- : Convert floating to unsigned

GROUP 9 - LOGICAL

  AND \*i : Boolean and on two groups of \*i bytes
  IOR \*i : Boolean inclusive or on two groups of \*i bytes
  XOR \*i : Boolean exclusive or on two groups of \*i bytes
  COM \*i : Complement (one's complement of top \*i bytes)
  ROL \*i : Rotate left a group of \*i bytes
  ROR \*i : Rotate right a group of \*i bytes

GROUP 10 - SETS

  INN \*i : Bit test on \*i byte set (bit number on top of stack)
  SET \*i : Create singleton \*i byte set with bit n on (n is top of stack)

GROUP 11 - ARRAY
 
  LAR \*i : Load array element, descriptor contains integers of size \*i
  SAR \*i : Store array element
  AAR \*i : Load address of array element

GROUP 12 - COMPARE

  CMI \*i : Compare \*i byte integers. Push negative, zero, positive for <, = or >
  CMF \*i : Compare \*i byte reals
  CMU \*i : Compare \*i byte unsigneds
  CMS \*i : Compare \*i byte sets. can only be used for equality test.
  CMP \*- : Compare pointers

  TLT \*- : True if less, i.e. iff top of stack < 0
  TLE \*- : True if less or equal, i.e. iff top of stack <= 0
  TEQ \*- : True if equal, i.e. iff top of stack = 0
  TNE \*- : True if not equal, i.e. iff top of stack non zero
  TGE \*- : True if greater or equal, i.e. iff top of stack >= 0
  TGT \*- : True if greater, i.e. iff top of stack > 0

GROUP 13 - BRANCH

  BRA \*b : Branch unconditionally to label \*b

  BLT \*b : Branch less (pop 2 words, branch if top > second)
  BLE \*b : Branch less or equal
  BEQ \*b : Branch equal
  BNE \*b : Branch not equal
  BGE \*b : Branch greater or equal
  BGT \*b : Branch greater

  ZLT \*b : Branch less than zero (pop 1 word, branch negative)
  ZLE \*b : Branch less or equal to zero
  ZEQ \*b : Branch equal zero
  ZNE \*b : Branch not zero
  ZGE \*b : Branch greater or equal zero
  ZGT \*b : Branch greater than zero

GROUP 14 - PROCEDURE CALL

  CAI \*- : Call procedure (procedure instance identifier on stack)
  CAL \*p : Call procedure (with name \*p)
  LFR \*s : Load function result
  RET \*z : Return (function result consists of top \*z bytes)

GROUP 15 - MISCELLANEOUS

  ASP \*f : Adjust the stack pointer by \*f
  ASS \*i : Adjust the stack pointer by \*i-byte integer
  BLM \*z : Block move \*z bytes; first pop destination addr, then source addr
  BLS \*i : Block move, size is in \*i-byte integer on top of stack
  CSA \*i : Case jump; address of jump table at top of stack
  CSB \*i : Table lookup jump; address of jump table at top of stack
  DUP \*s : Duplicate top \*s bytes
  DUS \*i : Duplicate top \*i bytes
  FIL \*g : File name (external 4 := \*g)
  LIM \*- : Load 16 bit ignore mask
  LIN \*n : Line number (external 0 := \*n)
  LNI \*- : Line number increment
  LOR \*r : Load register (0=LB, 1=SP, 2=HP)
  MON \*- : Monitor call
  NOP \*- : No operation
  RCK \*i : Range check; trap on error
  RTT \*- : Return from trap
  SIG \*- : Trap errors to proc nr on top of stack (-2 resets default).  Static
          link of procedure is below procedure number. Old values returned
  SIM \*- : Store 16 bit ignore mask
  STR \*r : Store register (0=LB, 1=SP, 2=HP)
  TRP \*- : Cause trap to occur (Error number on stack)
.fi
