123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122 |
- .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.
- This instruction is obsolete. Its use is strongly discouraged.
- .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
|