Digital PDFs

XX-24E5A-5A

February 1965

60 pages

Original

1.0MB

Document:	DEC-6-0-TP-MAC-LM-FP-ACT01 MACRO-6 Assembly Language
Order Number:	XX-24E5A-5A
Revision:
Pages:	60
Original Filename:	http://bitsavers.org/pdf/dec/pdp6/DEC-6-0-TP-MAC-LM-FP-ACT01_MACRO-6_Assembly_Language_Feb65.pdf

OCR Text

OC2236

DEC-6-0-TP-MAC-LM-FP-ACTOI

PROGRAMMING
MANUAL

MACRO-6
ASSEMBLY LANGUAGE

D.IGITAL E.QUIPMENT CORPORATION

•

MAYNARD, MASSACHUSETTS

DEC-6-0-TP-MAC-LM-FP-ACTOI

/PDP-6

PROGRAMMING MANUAL.

MACRO-6

ASSEMBLY

DIGITAL EQUIPMENT CORPORATION

•

LANGUAGE

MAYNARD. MASSACHUSETTS

CONTENTS
Chapter
LANGUAGE FUNDAMENTALS ••••••••..•••••••••.•••.•.••..••
Introduction •••••••••••••.•••••.••••••.••.••••••.••••.•.
Character Set ••••...••••••••.•••••.••••.••••.••••..•

The Location Counter •.•..•••....••••.•.•...•••...••.•...

Elements ••.•.•..••••.•.•.•••..•..••••...••.•••.••••....

Symbols............................................

Numbers ••.••.••.••••••••••••••••.••.•.••.•.•••••..

Point

Text

Literals ••••••••••••••••••••.•.••••••••••••••••••..•

Expressions ••••••••••••••••••••••••••••••••••••..••..•..

Evaluation of Symbols •••••••••••.•••••••••••••••••.••••••

STATEMENTS

Comment Statements ••••••••••••••••••••••••••••••.••••••

Instruction Statements •••••••••••••••••.••••••••••••••••.•

Primary Instruction Statements ••••••••••••••••.•..••••.

I/O Instruction Statements ••••••••••••••.••.••••.••..•

Extended Instruction Statements •••. • • • . • • • • • • • • • • • • . . . •

Assembly ••••••••••••••••••••••.••••••••••..••••.•.•

Number Codes ......................................

Data Statements •••••••••••••••••••••••••••••••••.•••••••

Assembler Control Codes ••••••••••••••••••••••••.•••••••.•

Listing Control ........•.•......•...••..•..•.........

MACROS .................................................. .

Definition of Macros ...•••....•.•.•....•..•.••...........

Macros Calls

................................. . . . . . . . . . .

Additional Considerations.............................

Created Symbols

••••••••••••••••••••••••••••••••••••
iii

CONTENTS (continued)
Chapter

Page
Concatenation ....•..••......•.••.•.•.••..••.••.•...•.

Indefinite Report

..••••..••••••.•..•.•••••••••••.•••.•

Nesting and Redefinition.......... •••..... ... .••.•.••..

RELOCATION AND LINKING ....•.•.......•.•..•.•..•..•..•..

Relocation .............•..•••.........•..••........•....•

Linking Subroutines .............•..•.......•.....•.•.•...•

ERRORS .......................••...••...•..............••..•

The Error Flags ..........•.....•.........•••.....•......••

ASSEMBLY OUTPUT

Assembly Listing

Binary Program

Rim Format ..•.•..••.......•..•.....•.••••••.....••.•

LIN K Format •........••.••••...•.••.•........•.••••.•

The Formats for the Block Types

ASSEMBLER INITIALIZATION..................................

CODES

......•.••..•.....••.•••.•..•••.•••••.....•.•.•••••••

SUMMARY OF ERROR FLAGS. . . . . . . . • • . . . • • . . • • . . . . . . • . . . . . . . . .

PROGRAMMING EXAMPLES...................................

CHARACTER SETS· . • . . . . . . . . . . . • • . . . . . . . . . . . . . . . • . . • . . . . . . . • • .

Appendix

CHAPTER 1
LANGUAGE FUNDAM ENTALS

INTRODUCTION
MACRO-6 programs consist of a sequence of statements, each of which may generate one or
more machine instructions, generate words of data, or give special instructions to the MACRO-6
Assembler. The statements, in turn, are subdivided into fields: a label field, a code field,
argument fields, and comment fields. The fields may contain one-or more-of the basic elements of the language described below. The interpretation of the basic element depends on
the field in which it appears.
This chapter begins with the MACRO-6 character set. It then describes the basic elements of
the language and how they may be constructed.

Character Set
The characters which are meaningful to the MACRO-6 Assembler are:
(space)

$
%

[

]

The corresponding ASCII, 6-bit ASCII, and punched-card codes are shown in Appendix 4. Two
of the characters shown in the appendix do not appear above. They are back slash and reverse
arrow. These two characters are ignored by the Assembler"and should not be used.

Punched Paper Tape
The ASCII code is used for paper tape input.

In addition to the characters shown above there

are some nonprinting characters of significance, i.e., carriage return, line feed, and tabs.
Tabs are equivalent to a number of spaces and are properly translated to the correct number of
spaces on the output listings. Both tabs and spaces may be freely used (except for one
restriction-see Code Fields) to improve the appearance of programs. Statements must be
terminated by a semicolon or by a carriage return. All carriage returns must be followed by
a line feed, and all line feeds must be preceded by either a carriage return or another line feed

Punched Cards
A modified Hollerith code (Appendix 4) is used for card input. Only the first 72 columns are
considered by the processor; the remaining 8 may be used for identifying information. The
Assembler does not recognize a fixed-field input from the cards. That is, fields within a statement are not delimited by appearing in specified card columns. The fields must be delimited
by specified characters; the delimiters being exactly the same as for punched tape. The statement itself is automatically delimited by reaching the end of the card-column 72. To skip
lines, blank cards which generate no information may be inserted.

THE LOCATION COUNTER
In general, statements generate 36-bit binary words, which are placed into consecutive memory
locations. The location counter is a register used by the MACRO-6 processor to keep track of
the next available location in memory. It is updated after processing each statement. A statement which generates a single machine instruction would update the location counter by one;
a statement which generates six data words would update it by six. The location counter may
be expl icitly set by the LOC or RELOC codes.

ELEMENTS
Elements represent binary integers less than 2

. There are five types of elements: symbols,

numbers, characters, points, and literals .

.Symbols
These are strings of letters, numbers, 'or decimal points, the first of which must be a letter or
decimal point. The characters. % and $ are regarded as letters in forming symbols, although
a symbol may be any length, only the first six characters are considered, and any additional
characters are ignored. Symbols which are identical in their first six characters are considered
identical.

X
A65
NUMERIC
X.38
HIGH.
N12345

(equivalent to NUMERI)

Numbers
A number is a string of digits. If the string contains a decimal point, it is evaluated as a
floating-decimal number and the digits are taken radix 1,0. If the string does not contain a
decimal point, the digits are assigned values according to the prevailing radix. (This prevailing radix is normally regulated by the RADIX code.) If 8 were the prevailing radix, the number 17 would have the value 17 =15 . If 1,0 were prevailing, 17 would have the value
10
8
17 =21 . The number 17.,0 would always have the value 2,0542,0,0,0,0,0,0,0 since the decimal
10
8
point denotes a floating-decimal number. A number must always begin with a digit or a decimal point.
Occasiona~ly, it may be desirable to change the valuS" of the radix for only one numeric element.

This is done by the qualifier tfollowed by a letter. Numbers are qualified in this manner to be pecimal, Octal, ~inary, or £ixed point decimal fractions irrespective of the prevai ling radix. Thus:

tD17= 171O
t017= 1510
tB1,01,0 = 1,010 = 128

These qualifiers have no further effect on the prevailing radix.

Floating-decimal numbers

never consider qualifiers, except F. The exponent parts of floating-decimal numbers may be
further augmented by following the number by E±n; the number is then considered to be multipi ied by l,0±n.

1,0.,0E-1
1.
,0 .,0,0,01 E4
.,0,01 E+ 3

The binary representation
of each is
2,014,0,0,0,0,0,0,0,0

If, in addition, the characters t F are prefixed to a number, it is considered to be a fixed
decimal fraction.

In this case, Bn should be suffixed to the number where n is an integer and

,0 2 n 2 35. The decimal point is then taken to be to the right of bit n. (If no bit position,
B, is specified, 35 is assumed.) Any integer part of the number's truncated to fit in n bits.

tF3.25B8 =
tF.281250B12 =
tF.4498,046E+1B11

A number may also be logically shifted left by following it by B:.: The number is shifted left
so that the right-hand (low-order) bit is in position ~ (decimal) of the 36-bit computer word.
Thus:

Point
The decimal point alone has a special meaning; it represents the current value of the location
counter. For example:

A:
JRST .-1
iEQUIVALENT TO
A:
JRST A-1

Text
If the first nonblank character of an element is a quote(II), the characters following it are
assembled right justified as their 7-bit ASCII representations. Only printing characters are
assembled. This element is terminated by a quote or a carriage return. If more than five characters are included within the quotes, only the right-hand five are considered.

AXE is equivalent to 4%661%5
(This representation is useful with
immediate mode operations.)

Literals
Literals are referenced in the argument field of a statement and are delimited by a pair of
brackets. The information within the brackets (whether it be a data word or machine instruction)
is assembled and assigned a specific storage location (usually at the end of the program).

The

address of the generated word appears in the statement which referenced the literal. Literals
may be nested to any reasonable depth.

ADD 2, [DEC 65], DECIMAL LITERAL
FAD 1, [8.14], FLOATING POINT
MOVE 3, [ASCII .BYTES.]
XCT[XCT[XCT[ADD 2,X]] (4)], NESTED

The last example generates the following constants. For example:

LlTl: XCT LlT2(4)
LlT2: XCT LlT3
LlT3: ADD 2, X

EXPRESSIONS
Expressions are strings of elements separated by arithmetic or Boolean operators. Expressions
35
in magnitude. The v~lue of an expression is calculated
represent numeric values less than 2
by substituting the numeric values for each of the elements and performing the specified operations. The a IIowabl e operations are:
Operator

Meaning

multiply

divide

add
substract

and
inc lusive or

When combining elements, the Boolean operations (AND, lOR) are performed first, from left
to right. Then the multipl ications are performed from left to right; and, finally, the additions
and subtractions are performed. Division always truncates the fraction part. All arithmetic
35
is performed modu 10 2 = 34, 359, 738, 368.
For example, suppose the element:
A represents the value 2
B represents the value 8

10
C represents the value 3
10
D represents the value 5 , the expression:
10
AlB + A*C represents 6 0
1
BIA - 2* A -1 represents -110 = 7777777777778
A&B represents ~
B+Dl,0+C represents 21
1 + A&C represents 3

An expression enclosed by angle bracket may be regarded as an element, allowing compound
expressions to be formed:
<A+B> /5 represents 2
C* <A+B* <D-C» represents 54

EVALUATION OF SYMBOLS
The value represented by a symbol is assigned by one of three mechanisms: a label, a direct
assignment, or a variable.
Label

If a statement begins with a symbol followed by a
colon, the symbol is called a label.

It is assigned

the current val ue of the location counter.
Direct Assignment

If a symbol appears on the left-hand side of the equal
sign in a direct assignment statement, it is assigned
a value equal to the value represented by the expression on the right-hand side. A direct assignment
statement has the form:

SYM = EXP,

COMMENT

where SYM is a symbol and EXP is an expression.
For example:

A = B+2
TSIZE = TEND-TSTART
K=4

Variable

If a symbol is followed by a number sign (#), a
storage cell is automatically reserved (usually at
the end of the program), and the symbol represents
the location of this storage cell. The number sign

may appear after anyone or more occurrences of the
variable; it need not appear after all occurrences,
nor after the first occurr.ence.
This is useful for defining a symbolic temporary
storage location. For example: TEMPI, which
reserves a cell whose address is represented by
TEMP.
If a value is assigned directly, it may be altered by another direct assignment statement. If
it is defined as a label or variable, it may not be altered.

CHAPTER

STATEMENTS

There are four types of statements in the MACRO-6 language: comment statements, instruction
statements, data statements, and assembler control statements. The type of a statement is
identified by the fields present and the code contained in the code field.
The possible fields are listed below in the order in which they would appear from left to right.
Each field extends from the terminator for the preceding field, or from the beginning of the
statement if all preceding fields are null, to its own terminator.
Label Field

If present, this field must be terminated by a colon.
This field contains a string of characters representing one, and only one, symbol. When a symbol
appears in a label field, it is immediately defined
to have a value equal to the current value of the
location counter.

Code Field

This field is terminated by either a space or a comma.
It may contain mnemonics representing either PDP-6
instruct ions or any of the pseudo-operat ion codes
recognized by the Assembler.

Argument Fields

The function of these fields is determined by the
code field. They may describe data, machine
addresses, accumulators, assembler control parameters, index registers, etc. They may be del imited
by commas, parentheses, or angle-brackets, depending on their function in the statement.

If a statement is ended with fewer fields than are normally required, the unspecified fields are
considered null.

If a statement has more fields than are required, the superfluous fields are

taken to be comments. The information between the semicolon, if present, and the end of a
card or carriage return is also taken as a comment.
The field completely determines the interpretation to be given to its contents.

For example,

if the characters ADD appeared in a label field, they would be interpreted as a statement label
and would receive a value equal to the statements location in memory. If the same characters
appeared in a code field, they would be interpreted as the mnemonic for a PDP-6 instruction
and would receive the value 270B8.

COMMENT STATEMENTS
A statement with an empty or blank code field is considered to be a comment statement. The
presence of the empty field is indicated by the presence of the field's delimitor, i.e., a semicolon.
For example:

THIS IS A COMMENT

INSTRUCTION STATEMENTS
Instruction statements may have any or all of the possible fields.
code field.

They must have a nonempty

There are three types of instruction statements: primary instruction statements,

extended instruction statements, and I/O instruction statements.

Primary Instruction Statements
The primary instruction statements must have in their code field one of the PDP.-6 instruction
mnemonics, (including the appropriate mode suffix) except for the eight I/O instructions.

(For

the complete list of mnemonics and mode controls, see F-65.) There must be ~ space between
the instruction mnemonic and the mode control since this space would attempt to terminate the
code field.

If the field following the code field is terminated by a comma, it is an accumulator field;
otherwise, it is the operand address field.
the address field.

If there is an accumulator field, the next field is

If a field is enclosed in parentheses, it is an index register field. The char-

acter g appearing in the address field denotes indirect addressing. The contents of these
argument fields may be any desired expression.
The accumulator field may be left out and the code field delimited by a comma or space.
this case, the accumulator is considered to be accumulator~.

If indexing is not used, the

index field may also be left out and the address field delimited by a comma, carriage return,
or semicolon; otherwise, it is delimited by the opening parenthesis of the index field.

For

example:

SUM: ADD 2, TABLE(X3)
ADD AC2, Y
JRST .-3;
JMP (4)

I/O Instruction Statements
The I/O instruction statements are exactly like the primary instruction statements with the
fo lIowi ng except ions:
1. The code field must contain one of the I/O instruction mnemonics for
the P DP-6 (see F-65).
2. The accumulator field is replaced by a device field.

The device field

may contain either a device number or a device mnemonic (see F-65).
example:

READ: DATA1 PTR, IglNUM(4)
CONO 2,03; ENABLE PC ON CH 3

For

Extended Instruct ion Statements
For programming convenience, some extended operation codes are provided in the MACRO-6
Assembler. Primari Iy, these are to replace those PDP-6 instructions where the combination of
instruction mnemonic and accumulator field are both used to denote a single instruction. For
example:

JRST 4,

which is equivalent to a single halt instruction. Additionally, they are used to replace certain
commonly used I/O instruction-device number combinations.
The extended instruction statements are exactly Iike the basic instruction statements or I/O
instruction statements, except that they may not have an accumulator field or device field.
The code field must have one of the following extended mnemonics:

Extended
Mnemonics

Equivalent
PDP-6
Mnemonics

Meaning

JEN

JRST 12,

Jump and enable the PI system

HALT

JRST 4,

Halt

JRSTF

JRST 2,

Jump and reset flags

JOV

JFCL 8,

Jump on overflow and clear

JCRY0'

JFCL 4,

Jump on CRY~ and clear

JCRY1

JFCL 2,

Jump on CRY1 and clear

JCRY

JFCL 6,

Jump on CRY~ or CRY1 and clear

JPC

JFCL 1,

Jump on PC change flag and clear

RSW

DATAl ~,

Read the console switches

Assembly
Instructions are assembled in the following manner. Each instruction code represents a 36-bit
number. If it is a primary instruction code, the low-order 4 bits of the value of the accumulator expression are 10Red into positions 9-12. The low-order 9 bits of the value of the device
expression of an I/O instruction are 10Red into positions 3-11. The low-order 18 bits of the
value of the address expression are 10Red into the right half of the instruction. If the indirect
address symbol @ appears in the address field, a bit is placed into position 13. Finally, if the
index register field exists, the lower four bits are 10Red into positions 14-17.

Numeric Codes
Numeric codes are considered to indicate primary instructions. The remainder of the statement
is assembled as a normal instruction.

If the numeric code is preceded by a minus sign, the

2's complement of the number is taken. The minus sign is ignored for other codes. Character
elements are considered to be numeric. For example:

X;Ai THE VALUE OF A IS IN THE RT HALF
27X;B8 2,Xi EQUIVALENT TO ADD 2,X
tDX;5i X;X;X;X;X;X;X;X;X;IX;1 IS GENERATED
-Ii
7777m77777 IS GENERATED

DATA STATEMENTS
Several codes are used to indicate various data formats. These codes describe the type
of data to be generated. A label on a data-generating statement refers to the first word
assembled.
DEC

(decimal data}-Set the radix to IX; for this statement
only and generate a word for each expression followi ng the code. Expressions are separated by commas.
For example:

DEC 1~, 4.5, 3.1416, 6.~3E-26, 3i
i5 WORDS GENERATED

(octal data)-Similar to the DEC code, but the

OCT

radix is temporarily set to 8. For example:

OCT -3, 2, 777, 4.1iTHE 4TH ITEM IS FLOATING PT.

(espressions)-The radix is unchanged. Each ex-

EXP

pression following the code generates one 36-bit
data word.

For example:

EXP X, 4, tD65, HALF, B+362-Ai

(transfer word)- Two expressions follow this code

XWD

which generates one data word. The low-order
18 bits of the value of the first are placed into the
left-half word, and the low-order 18 bits of the
value of the second expression are placed into the
right half. For example:

ATOB:

XWD A, Bi

POINTER WORD FOR BLOCK TRANSFER

(zero word)-One word containing zeros is generated.
For example:

TEMP: Zi

10WD

TEMPORARY STORAGE

(I/O transfer word)-used in the BLKI and BLKO
instructions. Two expressions separated by a comma
follow this code, which generates one data word.
The left half of the assembled word contains the

2's complement of the value of the first expression,
and the right half contains the value of the second
expression minus one.

For example:

INAREA: IOWD 6, tD265;
ASSEMBLES AS 777772~~~377

POINT

(byte pointer word)- The first expression indicates
the byte size, the second indicates the address, and
the third indicates the position of the right-hand bit
of the byte position. The indirect character (l) and
and index expression in parentheses may appear in
conjunction with the address part. The local radix
for the position and size expressions is always 1~,
regardless of the prevailing radix.

For example:

STRING: POINT 6/Q-lN(4),5i
iPOINTS TO THE LH CHAR

If the position expression is left blank, the position
part will assemble as 44 . On incrementing, the
S
pointer will point to the left-hand byte.

SIXBIT

(alphabetic information)- This code is used to generate
characters in 6-bit ASCII code, pack them into
6-character words and place the words in sequential
registers. The first nonblank character following
the code is the delimiter.

Information is assembled

from the second character unt i I the first character
is repeated.

Only the printing characters of the

ASCII code are assembled, except line feeds which
are assembled as 74 (\). The characters are left
justified.

For example: .

SIXBIT "2"
NUMBER2
ALPHA: SIXBIT /ALPHABETIC INFORMATION/
,EQUIVALENT TO
ALPHA: OCT 41146,05,04142, 45645143,0,051;
OCT 564657625541, 64515756,0,0,0,0;

ASCII

(alphabetic information)- This code is similar to
SIXBIT, but it packs words with the low 7 bits of
the full ASCII representation.

The entire ASCII

character set may be assembled under this mode,
including the reverse slash (\) and back arrow
(~ ).

For example:

ASCII . ~
.; A CARRIAGE RETURN AND LINE FEED

BLOCK

(block of storage reserved)-The expression following
the code indicates the number of cells to be reserved.
The location counter is incremented by the value of
the expression. The expression may be an absolute
value or a mixed arithmetic.

For example:

MATRIX: BLOCK N*M

BYTE

(byte strings)- The first expression following this
code is enclosed in parentheses and is the byte size.
Subsequent expressions, separated by commas, are
eva Iuated, truncated to the byte size, packed and
assembled into sequential memory locations.
16

If a

byte cannot fit into a word, it is assembled as the
first byte of the next word. The byte size may be
altered in the middle of a word or a string by inserting a byte size expression in parentheses. The
local radix for the size portion is always considered
to be 1,0, no matter what value the prevailing radix
may have.

For example:

RADIX 1,0
AX: BYTE (6) 1,0,4, 9, 1, 1, 3, 6
Q:
BYTE (15)12, 3, 9,
STR: BYTE (6) 1,0,4, 9 (12) "AB"
, EQUIVALENT TO
AX:
OCT 12,0411,01,01,03, ,06,0,0,0,0,0,0,0,0,0,0;
Q:
OCT ,0,0,04,0,0,0,0,03,0,0, ,0,0,011,0,0,0,0,0,0,0;
STR: OCT 12,0411,0,04142;

ASSEMBLER CONTROL CODES
These statements do not generate data or instructions, but control the operation of the assembler.
REPEAT

This code causes a character string to be processed
repeatedly. The code is followed by an expression
whose value indicates the number of repetitions
desired. This is followed by the string to be repeated enclosed by angle-brackets. The expression
for the number of repititions in a REPEAT statement
must be followed by a comma.

For example:

ADDX:

REPEAT 3,<ADD 6,X(4}
ADDI 4, 1>
, EQUIVALENT TO
ADDX: ADD 6,X(4}
ADDI 4, 1
ADD 6,X(4}
ADDI 4, 1
ADD 6,X(4}
ADD I 4, 1

...........................................
SQ:

REPEAT N, <
EXP . * . +SQ*SO+ 1-2*. *50+2*. -2*SQ>
;A TABLE OF SQUARES

The label of a repeat is placed on the first statement
generated. REPEATs may be nested to any reasonab Ie
degree.

For example:

REPEAT N+1,<MOVE 6, A(K}
REPEAT N, <ADD 6, (3)
ADDI3,L>
MOVEM 6,A(K} >

IFn

(conditional assembly}-An IFn code is followed by
an expression, and a string of coding enclosed in
angle-brackets. The expression for a conditional
assembly must be followed by a comma.

If the

expression fulfills the condition indicated by ~, the
string is processed; if not, it is ignored. The IFn
codes are:

53.

IFE

Assemble if expression is

IFG

Assemble if expression is positive ..

IFGE

Assemble if expression is positive or %.

IFL

Assemble if expression is negative.

IFLE

Assemble if expression is negative or %.

IFN

Assemble if expression is nonzero.

IFI

Assemble if PASS 1 (no expression).

IF2

Assemble if PASS 2 (no expression).
For example:

IF
X-Y, <ADD Z, Xi>
;ASSEMBLED ONLY IF X=Y

IFIDN

(conditional assembly on character strings)-This
is followed by three sets of angl e-brackets. If the
character strings enclosed by the first two sets of
angle-brackets are identical, the coding within the
third set is processed.

For example:

IFIDN <+ > <+ >, < FAD 3,X >
;FAD 3,Xi WILL BE PROCESSED

IFDIF

{conditional assembly on character strings}-This
is the converse of IFIDN and is similar in format.
The coding within the third set of angle-brackets
is processed if the two character strings differ.

RADIX

The prevailing value of the radix is controlled by
this code.

It is followed by a decimal number

between 2 and 10 which then becomes the prevai ling
radix. The radix may be changed at any point on the
assemblYi it is initially considered to be 8.

For

example:

RADIX 1.0,
iSET PREVAILING RADIX DECIMAL

LaC

This code changes the location counter to a value
equivalent to the expression which follows. The block

of coding following a LOC is assembled into the
absolute locations, and any labels defined are considered absolute.

For example:

ADD AC2,X
LOC 2%%
ADD AC3, @Q2
LOC .+3;
SKIP 3 LOCATIONS
ADD ACl ,AC2

RELOC

This is similar to LOC in that it explicitly sets the
location counter. The block of code which follows
is relocatable and all labels within the block are
relocatable. The implicit statement begins all
programs.

For example:

RELOC %i

PHASE

A portion of code may be moved i'nto other registers
before it is executed. PHASE gives the location
counter a value different from the location into
which the assembled code is to be loaded. The
code is actually loaded into continuing sequential
iocations, but all labels within a phased area are
in relation to the PHASE. Point elements (.) also
relate to the PHASE. PHASE is followed by an
expression indicating the first address of the subroutine when it is to be executed.

For example:

MOVE [XWD LOOPX, LOOP]
BLT LOOP+5
LOOP:
LOOP:

PHASE 11
Z
MOVN A(X)
FMP MPYR
FADM A(Y)
SOJGE X, .-3
JRST @LOOP

DE PHASE

This example is the central loop in a matrix inversion.
Before executing it, the routine will be moved into
fast accumulator memory locations 11-16. The
symbol LOOP represents 11 and the point in the
SOJGE instruction represents 15. The routine is,
however, loaded into the normal sequential registers.
A phased area is terminated by a DEPHASE, LOC or
RELOC code. The DEPHASE code has no effect on
the next sequential loading location, but restores
the location counter to this value.
PASS2

This code causes the location assignment phase,
PASS1 to be suspended and PASS2 to commence.

END

This statement must be the last statement in a program or subroutine.

If it is a program, the follow-

ing expression is the location of the first instruction
to be executed.
NOSYM

The assembler will normally output a symbol table
or list of the symbols used and their definitions.

The

code NOSYM will suppress this.

LIT

This code will cause literals that have been previously
defined to be assembled starting at the current location.
21

If ~ literals have been defined, the next free cell
will be at (.+n). This statement will have no effect
on Iitera Is which are defined after it. LIT may not
be used more than eight times.
VAR

This code will cause the symbols which have been
defined by following them with # in previous statements to be assembled as block statements. This has
no effect on subsequent symbol definitions of the
same type. This, and the previous pseudo-op, LIT,
are useful in controlling storage allocation.

If these

codes do not appear, all variables and literals are
placed at the end of the program.
RIM

In paper tape assemblies, this code will cause binary
output to be punched in RIM format.

OPDEF

(define an operation mnemonic)-This is followed by
a symbol and a pair of brackets ~ontaining a statement that wi II generate one word of data. The
symbol then becomes a mnemonic for the operation
code represented by the 36-b it data word.

For

example:

OPDEF PUSHP [PUSH PP,,0'J
OPDEF PUNCH [DATAO PIP,]

These OPDEFs may then be treated as ordinary op
codes.

For example:

PUSHP X
PUNCH Y

SYN

(define synonyms)-This code is followed by two
symbo Is or macros. The first must have been previously defined, and the second is made equivalent
to the first.

If the first is a symbol, the second

becomes a symbol with the same value; if the first
is a macro, the second becomes a macro wh ich acts
identically; if the first isa machine-op, control
code, or data generating code, the second will be
interpreted in the same manner.

For example:

SYN K,X
SYN FAD,ADD
SYN END,XEND

If the first item is identical to both a symbol and
a code, the second item {which is the synonym} is
made synonymous with the symbol in preference to
the code.

Listing Control
Several codes are used to control the final listing.
LIST

Causes the assembler to begin listing the assembled
program in both octal and source text.

XLiST

Causes the assembler to stop listing the assembled
program.

LALL

Causes the assembler to list all text that is processed:
macro expansions, list control codes, repeats, etc.

XALL

Causes the assemblef" to stop listing all text.

TITLE

The comments field is written at the top of each
pr i nted page.

SUBTTL

The comments field is written as a second line at
the top of each printed page.

PAGE

The listing begins a new page. (A form feed on the
input tape also has the same effect.)

These list control codes are never printed in the final listings, except under LALL.

CHAPTER

MACROS

When writing a program, it often happens that certain coding sequences are used several times
with just the arguments changed. If so, it is convenient if the entire sequence can be generated
by a single statement. To do this, the cod ing sequence is defined with dummy arguments as a
macro. A single statement referring to the macro by name, along with a list of real arguments,
will generate the correct sequence.

DEFINITION OF MACROS
The first statement of a macro definition must consist of the code DEFINE followed by the name
of the macro. The name must be constructed by the rules for constructing symbols. The macro
name may be followed by a string of dummy arguments enclosed in parentheses. The dummy
arguments are separated by commas and may be any symbols that are convenient-single letters
are sufficient. A comment may follow the dummy argument list.
The character sequence, which constitutes the body of the macro, is delimited by angle
brackets. The body of the macro may consist of any proper string of coding; normally, but is
not restricted to, a group of complete statements.
Example: A macro to compute the length of a vector.

DEFINE VMAG (A, B)
<MOVE O,A;
FMP 0;
MOVE l,A+1;
FMP 1,1;
FAD 1;
MOVE l,A+2;
FMP 1,1;
FA" 1;
JSR FSQRT;
MOVEM B;

ROUTINE FOR THE LENGTH OF A VECTOR
GET THE FIRST COMPONENT
SQUARE IT
GET THE SECOND COMPONENT
SQUARE IT
ADD THE SQUARE OF THE SECOND
GET THE THIRD COMPONENT
SQUARE IT
ADD THE SQUARE OF THE THIRD
USE THE FLOATING SQUARE ROOT ROUTINE
STORE THE LENGTH>

MACRO CALLS
A macro may be ca II ed by any statement conta i n i ng the macro name fo II owed by a Iist of arguments. The arguments are separated by commas and may be enclosed within parentheses.

1£

parentheses are used (indicated by an open parenthesis following the macro name), the argument
string is ended by a closed parenthesis.

If there are n dummy arguments in the macro definition,

a II arguments beyond the first n, if any, are ignored.

If parentheses are omitted, the argument

string ends when all the dummy arguments of the macro definition have been assigned, or when
a carriage return or semicolon delimits an argument.
The arguments must be written in the order in which they are to be substituted for dummy arguments. That is, the first argument is substituted for each appearance of the first dummy argument, the second argument is substituted for each appearance of the second dummy argument,
etc.

For example:

VMAG VECT, LENGTH

The appearance of this statement in a program would generate the code sequence defined above
for the macro VMAG. The character string VECT would be substituted for each occurrence in
the coding of the dummy argument A, the character string LENGTH being substituted for the
single occurrence of B in the coding.
Statements with a macro call may have label fields.

The value of the label is the location of

the first instruction generated.

Additional Considerations
1. Arguments must be separated by commas. However, arguments may also
contain commas.

For example:

DEFINE JEQ (A,B,C)
<MOVE [AJ
CAMN B
JRST C>

If the data in location B is equal to A (a literal), the program jumps to C.
If A is to be the instruction ADD 2,X; then the calling macro instruction would
be written:

JEQ «ADD 2, X>, B, INSTX)

The angle brackets surrounding the argument are removed and the proper
coding is generated.
The general rule is: If an argument contains commas, semicolons, or any other
argument delimiters, the argument must be enclosed in angle brackets.
2. A macro need not have arguments. The instruction:

DATAO PTP,PUNBUF(4)

which causes the contents of PUNBUF, indexed by register 4, to be punched
on paper tape, may be generated by the macro:

DEFINE PUNCH
<DATAO PTP,PUNBUF(4»

The calling macro instruction could be written:

PUNCH

PUNCH calls for the DATAO instruction contained in the body of the macro.
3. The macro name, followed by a list of arguments, may appear anywhere
in a statement. The string within the angle brackets of the macro definition
will exactly replace the macro name and argument string.

For example:

DEFIN E L(A, B) <3*<B-A+ 1»

gives an expression for the number of items in a table"where three cells are
used to store each item. A is the address of the first item, and B is the
address of the last item. To load an index register with the table length,
the macro can be called as follows:

MOVEI X, L(FIRST, LAST)

Created Symbols
When a macro is called, it is often convenient to generate symbols without expl icitly stating
them in the call, for example, symbols for labels within the macro body. If it is not necessary
to refer to these labels from outside the macro, there is no reason to be concerned as to what
the labels are. Nevertheless, different symbols must be used for the labels each time the
macro is called. Created symbols are used for this purpose.
Each time a macro that requires a created symbol is called, a symbol is generated and inserted
into the macro. These generated symbols are of the form .. hijk, that is, two decimal points
followed by four digits. The first created symbol is .. ,0,0,01, the next is .. ,0,0,02, etc.
If a dummy symbol in a definition statement is preceded by a percent sign (%), it is considered
to be a created symbol. When a macro is called, all missing arguments that are of the form
%X are replaced by created symbols. However, if there are sufficient arguments in the call ing
Iist that some of the arguments are in a position to be assigned to the dummy arguments of the
form %X, the percent sign is overruled and the stated argument is assigned in the normal
manner.
Null arguments are not considered to be the same as missing arguments.
a macro has been defined with the dummy string:

(A,%B, %C)

For ex~mple, suppose

If the macro were called with the argument string:

(ARG,) or ARG"

the second argument would be considered to have been declared as a null string. This would
override the % prefixed to the second dummy argument and would substitute the null string for
each appearance of the second dummy argument in the code.

However, the third argument is

missing. A label would be created for each occurrence of %C.

For example:

DEFINE TYPE (A,%B)
<JSR TYPEOUT
JUMP %B
SIXBIT /A/
%B:>

This macro types the text string substituted for A on the console Teletype. TYPEOUT is an
output routine.

Labeling the location following the text is appropriate since A may be text

of indefinite length. A created symbol is appropriate for this label since the programmer would
probably not be interested in knowing the label.
This macro might be called by:

TYPE HELLO

which would result in typing HELLO when the assembled macro is executed.

If the call had

been:

TYPE HELLO, BX

the effect w~ld be the same.

However, BX would be substituted for %B, overruling the

effect of the percent sign.

Concatenat ion
The character single quote (') is defined to be the concatenation operator and may not be used
otherwise inside a macro definition. (Outside a macro definition, it is ignored except as a
character in textual data.) A macro argument need not be a complete symbol. Rather, it may
be a string of characters which will form a complete symbol when joined to characters already
contained in the macro definition. This joining, called concatenation, is indicated by the
appearance of an apostrophe appearing between the strings to be so joined.
As an example, the macro:

DEFINE J(A, S,C)
<JUMP'A S,C>

when called, the argument A is suffixed to JUMP to form a single symbol. If the call were:

J (LE,3,X+l)

the generated code would be:

JUMPLE 3,X+l

Indefinite Repeat
It is often convenient if a macro can be repeated one or more times for a single call; each
repetition substituting successive arguments in the call statement for specified arguments in
the macro. This may be done by use of the indefinite repeat code, IRP. The code IRP is
followed by a dummy argument which may be enclosed in parentheses. This argument must
also be contained in the DEFINE statement's list. This argument is broken into subarguments.
When the macro is called, the range of the IRP is assembled once for each subargument, the
successive subarguments being substituted for each appearance of the dummy argument within
the range of the IRP. For example, the single argument:

<ALPHA, BETA, GAMMA>

consists of the subarguments ALPHA, BETA, and GAMMA. The macro definition:

DEFINE DOEACH (A)
<IRP A
<A

and the co II:

DOEACH <ALPHA, BETA, GAMMA>]

produces the following coding:

ALPHA
BETA
GAMMA

An opening angle bracket must follow the argument of the IRP statement to delimit the range
of the IRP. A closing angle bracket must terminate the range of the IRP.
It is sometimes desirable to stop processing an indefinite repeat depending on conditions given
by the assembler. This is done by the code STOPI. When the code STOPI is encountered, the
macro processor will finish expanding the range of the IRP for the present argument and terminate
the repeat action. An example:

DEFINE CONVERT (A)
<IRP A <IFE K-A, <STOPI
CONV1 A>

Assume that the val ue of K is 3; then the call:

CONVERT (jj,1,2,3,4,5,6,7)

will generate:

<IRP
IFE K-,0,<STOPI
CONV1,0>
IFE K-,0,<STOPI
CONVll>
IFE K-2,<STOPI
CONVI2>
IFE K-3,<STOPI
CONVI3>
STOPI
CONVI 3

The assemb Iy condition is not met for the first three arguments of the macro. Therefore, the
STOPI code is not encountered until the fourth argument, i.e., the number 3. When the condition is met, the STOPI code is processed which prevents further scanning of the arguments.
However, the action continues for the current argument and generates CONVI 3, i.e., a
call for the macro CONVI (defined elsewhere) with an argument of 3.

Nesting and Redefinition
Macros may be nested; that is, macros may be defined within other macros.

For ease of dis-

cussions, levels may be assigned to these nested macros. The outermost macros, i.e., those
defined directly to the macro processor, may be called first level macros. Macros defined
within first level macros may be called second level macros; space macros defin'ed within
second level macros may be called third level macros; etc.
At the beginning of processing, first level macros are known to the macro processor and may
be called in the normal manner. However, second and higher level macros are not yet defined. When a first level macro containing second, and higher, level macros is called, all

its second level macros become defined to the processor.

Henceforth, their level of definition

is irrelevant and they may be called in the normal manner.

Of course, if these second level

macros contain third level macros, the third level macros are still not defined until the second
level macros containing them have been called.
When a macro of level n contains a macro of level n+l, calling the macro results in generating
the body of the macro into the user's program in the normal manner until the DEFINE statement
is encountered.

The level n+ 1 macro is then defined to the macro processor; it does not appear

in the user's program.

When the definition is complete, the macro processor resumes generating

the macro body into the user's program unt i I, or un less, the ent ire macro has been generated.
If a macro name which has been previously defined appears within another definition statement,
the macro is redefined, and the original definition is eliminated.

The first example, calculation of the length of a vector, may be rewritten to illustrate both
nesting and redefinition.

VL:

DEFINE VMAG (A, B, %C)
<DEFINE VMAG (D, E)
<JSP SJ, VL
EXP D, E>
VMAG (A, B)
JRST %C
HLRZ 2, (SJ)
MOVE (2)
FMP f:J
MOVE 1,1(2)
FMP 1,1
FAD 1
MOVE 1,2(2)
FMP 1,1
FAD 1
JSR FSQRT
MOVEM ,( (SJ)
JRST 2(SJ)

%C: >
The procedure to find the length of a vector has been written as a closed subroutine.
only appear once in a user's program.

It need

From then on it can be called as a subroutine by the JSP

instruct ion.

The first time the macro VMAG is called, the subroutine calling sequence is generated followed
immediately by the subroutine itself. Before generating the subroutine, the macro processor
encounters a DEFINE statement containing the name VMAG. This new macro is defined and
takes the place of the original macro VMAG. Henceforth, when VMAG is called, only the
calling sequence is generated. However, the original definition of VMAG is not removed
unti I after the expansion is complete.

CHAPTER 4
RELOCATION AND LINKING

RELOCATION
The MACRO-6 assembler will create a relocatable program. This program may be loaded into
any part of memory as a function of what has been previously loaded. To accomplish this, the
address field of some instructions must have a relocation constant added to it. This relocation
constant is added at load time by the Linking Loader and is equal to the difference between
the memory location an instruction is actually loaded into and the location it is assembled into.
Most programs begin in location 6%8; if a program is loaded into cells beginning at location
14%%8' the relocation constant K would be 132%8.
Not all instructions must be modified by the relocation constant. Consider the two instructions:
MOVEI2,
MOVEI2,

.-3
1

The first is probably used in address manipulation and must be modified; the second probably
should not. To properly accomplish the relocation, the actual expression forming an address
is considered and modification is decided.

Integer elements are fixed and not modified.

Point

elements (.) are relocatable and are always modified. * Symbolic elements may be fixed or
relocatable according to the means used in their definition.

If a symbol is defined by direct

assignment statement, it may be relocatable or fixed depending on the expression following the
equal sign (=).

If a symbol is defined as a macro, it is replaced by the string and the string

itself must be considered.

If it is defined as a label or a variable (#), it is relocatable.*

Finally, references to literals are relocatable.*
To evaluate the relocatability of an expression, consider what happens at load time.
stant, k, must be added to each relocatable element and the expression evaluated.

*Except under the LOC code which specified absolute addressing.

A con-

Consider the expression:

x = A + 2*B-3*C+D
where A,B,C, and Dare relocatable. Assume k is the relocation constant. Adding this to
each relocatable term we get:

xr = (A+k)+2*(B+k)-3*(C+k)+D+k)
This expression may be rearranged to separate the k's, yielding:
X = A+2*B-3*C+D+k
r

This expression is suitable for relocation since it involves the addition of a single k. In general,
if the expression can be rearranged to result in the addition of
.¢*k
1*k
n*k

The expression is legal and fixed.
The expression is legal and relocatable.
Where n is any positive or negative integer
other than .¢ or 1, the expression is i lIega I.

Finally, if the expression involves k to any power other than 1, the expression is illegal. This
leads to the following conventions:
1. Only two values of relocatability for a complete expression are allowed,
~ and'¢.

2. An element may not be divided by a relocatable element.
3. Two relocatable elements may not be multiplied together.
4. Relocatable elements may not be combined by Boolean expressions.

If any of these rules are broken, the expression is illegal and the assembled code is flagged.
If A, C, and Bare relocatable symbols, then:
A+B-C

is relocatable

A-C

is fixed

A+2

is relocatable

2*A-B

is relocatable

2&A-B

is erroneous

LINKING SUBROUTINES
Programs usually consist of subroutines which must be linked. This is relatively easy if all subroutines are assembled together; they can be linked by JSR SUBR instructions. If independently
assembled, relocatable subroutines are used, linking must be considered since the symbol tables
from the assembly are inaccessibl e to the loader.
To accomplish this linking, selected symbols are made available to the Linking Loader by the
codes EXTERN, INTERN, and ENTRY.
The EXTERN code identifies certain symbols as external to the program. The condensed object
program contains the information that values for certain symbols must be derived from other
programs at load time. An expression containing a reference to an external symbol must consist of only the single external symbol. The statement

EXTERN SQRT, CUBE, TYPE;

identifies the symbols SQRT, CUBE and TYPE as external symbols.

Symbols defined as external

must not be defined as labels, variables, macros, or assignments.
An external reference may not occur within a literal, and may only appear as the address part
of a machine command.
For example, if a square root is required, it would be called by

PUSHJ 1,

SQRT:

Elsewhere in the program would be the statement

EXTERN SQRT;

To make internal program symbols available to other subroutines as external symbols, the code
INTERN or ENTRY is used. This code has no effect on the actual assembly of the subroutine,
but will make a list of symbol equivalences available to other programs at loading time. The
statement

INTERN SIN, COS, SIND, COSDi

might appear in a sin-cos routine where SIN, COS, SIND and COSD are entry points to the
subroutine to calculate, respectively, sines and cosines of angles in radians and degrees.
Internal symbols must be defined within the subroutine as assignments, labels, or variables.
In the square root subroutine would be the statement

INTERN SQRTi

Some subroutines have common usage, and it is convenient to place them in a library. To load
these subroutines, the code ENTRY is used. ENTRY is equivalent to INTERN except for the
following additional feature.

All names in a list following ENTRY are defined as internal

symbols and are placed in a list at the beginning of the program.

If the loader is in library

search mode, a program will be loaded only if an undefined global symbol, i.e., any symbol
made accessible to other programs, matches an internal symbol in the ENTRY list.
routine mentioned above were a library program, the statement

ENTRY SQRTi

would also appear in the SQRT program.

If the SQRT

CHAPTER

ERRORS

There are two c lasses of errors-errors in language usage and program errors.

MACR 0-6 will

exam i ne the statements for errors in Ianguage usage, and pri nt appropr iate messages.

These

errors are caused by meaningless or inconsistent construction in the source language.

When a

listing is prepared during theassembly, eachMACRO-6statement that contains errors will be
flagged by one or several letters in the margin.

At the end of the listing will be a summary

of the errors; this summary will be printed even if a listing is not prepared.

Program errors

which properlyusetheMACRO-6 language will be correctly translated into errors in the binary
program.

THE ERROR FLAGS
M

{multiply defined symbol)-A symbol is defined
more than once, either as a label or variable.

The

symbol retains its original definition.

(symbol error)- There is a meaningless character
string that resembles a symbol or macro.

It is

assembled as though the value were ¢.

{phase error)-A symbol is assigned a value as a
label during PASS 2 different from that which it
was assigned in PASS 1.

(undefi ned code)- The code i nd icat i ng the statement type is not defined in the code table.

It is

assembl ed as a numer ic code of ¢.

(number error)- There is a meaningless string of
characters that resembl es a number.
as ¢.

It is assemb Ied

(argument error}-An argument of a control code
has a peculiar value.

(Iiteral}-There is an error within a literal.

(macro definition error}-A format error exists in a
DEFINE statement.

(undefined symbol}-A symbol or macro is undefined.
It is given a value of ¢.

(value previously undefined}-A symbol used to control the processor is undefined prior to the point at
which it is first used.

(relocation error}-An expression has a relocation
constant other than 1 or ¢, contains division by a
relocatable number, contains the product of two
relocatable numbers, or involves relocatable numbers in Boolean operations. The relocation constant
is set to ~.

(multiply defined symbol reference)-The statement
contains a reference to a multiply defined symbol.
It is assembled with the first value defined.

(external}-Improper usage of external symbols.

On PASS 1, an error printout consists of two lines. The first has the most recently used tag
followed by + ~ where ~ is the (decimal) number of lines of coding between the tag and the
error.
The second line, and the only line in PASS 2, is a copy of the erroneous line of code with a
letter(s) indicating the error type(s} in the left-hand margin.

CHAPTER 6
ASSEMBLY OUTPUT

ASSEMBLY LISTING
There are two types of assembly output-the assembly listing and the binary program.

The

assembly listing consists of a printout of the source program. On the same line with each source
statement are three numeric fields-the location of the assembled code, the left half word,
and the right half word. Above each line containing an error is an appropriate message. This
Iisting is controll ed by the List Control Codes except that error messages are always pr inted.
All assemblies begin with an implicit LIST. Apostrophes on the assembly listing indicate
relocatability. The program break is printed at the end of the assembly-this is the highest
relocatable location assembled plus one.

BINARY PROGRAM
The binary program may assume two forms: RIM and LINK. The RIM {read-in mode} format is
always punched into paper tape and is usually used for loaders and computer hardware maintenance programs. RIM programs may be completely loaded by the loader resident in the shadow
memory located behind the accumulator memory.

Rim Format
Programs in RIM moae consist of two word pairs. The first word is an instruction:
DATAl PTR , A,
The second word of the pair is the word of instruction or data to be loaded into memory
location A.
The last word of a RIM tape is a single instruction:
HALT I START;
where START is the first location of the program.

LINK Format
LINK format is the normal binary output mode. Programs in this format are acceptable to the
Linking Loader and are usually relocatable. The Linking Loader will load subprograms into
memory, properly relocating each one and adjusting addresses to compensate for the relocation.
It will also link external and internal symbols to provide communication between independently
assembled subprograms. Finally, the Linking Loader will load subroutines in library search
mode.
LINK format data is in blocks. All blocks have an identical format. The first word of a
LINK block consists of two halves. The left half is a code for the block type, and the right
half is a count of the number of data words in the block. The data words are grouped in subblocks of 18 items. Each 18-word sub-block is preceded by a relocation word. This relocation
word consists of 18 2-bit bytes.

Each byte corresponds to one word in the sub-block, and

contains relocation information regarding that word.
If the byte value is:
no relocation occurs
the right half is relocated
2

the left half is relocated

both halves are relocated

These relocation words are not included in the count; they always appear before each subblock of 18 words or less to insure proper relocation.
All programs (except those in paper tape RIM format) are stored in this format, inc luding programs on paper tape, DECtape, standard magnetic tape, punched cards, drums and discs. This
format is totally independent of logical divisions in the input medium (40-word check summed
paper tape blocks, 128-word blocks on DECtape and drums, 23-word check summed punched
cards, etc.).

It is also independent of the block type.

The Formats for the Block Types

Block Type 1 Relocatable or Absolute Programs and Data
WORD 1
WORD 2

THE LOCATION OF THE FIRST DATA WORD IN THE BLOCK
A CONTIGUOUS BLOCK OF PROGRAM OR DATA WORDS.

WORD N

(N MUST BE LESS THAN 2%%,%%% OCTAL)

Block Type 2 Symbols
CONSISTS OF WORD PAIRS
1ST WORD
BITS %-3 CODE BITS
1ST WORD
BITS 4-35 RADIX 5% REPRESENTATION OF SYMBOL
(See Below)
2ND WORD
DATA (VALUE OR POINTER)
CODE %4:
2ND WORD

GLOBAL (INTERNAL) DEFIN ITION
BITS %-35 VALUE OF SYMBOL

CODE 1%:
2ND WORD

LOCAL DEFINITION
BITS %-35 VALUE OF SYMBOL

CODE 6%:
2ND WORD
2ND WORD

CHAINED GLOBAL REQUESTS:
BITS %-17 = %
BITS 18-35 POINTER TO FIRST WORD OF CHAIN
REQUIRING DEFINITION (See Loader Manual)

CODE 6%:
2ND WORD
BIT 1
BIT 2
BIT 3
BIT 9
BIT 10
BIT 11
BIT 12
BITS 18-35

GLOBAL SYMBOL ADDITIVE REQUEST: (See Loader Manual)
BIT %= 1.
SUBTRACT VALUE BEFORE ADDITION
SWAP HALVES BEFORE ADDITION
ROTATE LEFT 5 BEFORE ADDITION
REPLACE LH WITH RESULT IN STORAGE
REPLACE RH WITH RESULT I N STORAGE
REPLACE INDEX FIELD WITH RESULT IN STORAGE
REPLACE AC FIELD WITH RESULT IN STORAGE
POINTER TO WORD REQUIRING ADDITION

Block Type 4 Entry Block
THIS BLOCK CONTAINS A LIST OF RADIX 5% SYMBOLS, EACH OF WHICH
MAY CONTAIN A ZERO OR ONE IN THE HIGH ORDER CODE BIT. EACH
REPRESENTS A SERIES OF LOGICAL 'AND' CONDITIONS. IF ALL THE

GLOBALS IN ANY SERIES ARE REQUESTED, THE FOLLOWING PROGRAM IS
LOADED. OTHERWISE ALL INPUT IS IGNORED UNTIL THE NEXT END
BLOCK. THIS BLOCK MUST BE THE FIRST BLOCK IN A PROGRAM.

Block Type 5 End Block
THIS IS THE LAST BLOCK IN A PROGRAM. IT CONTAINS ONE WORD
WHICH IS THE PROGRAM BREAK, THAT IS, THE LOCATION OF THE FIRST
FREE REGISTER ABOVE THE PROGRAM. (NOTE: THIS WORD IS RELOCATABLE).
IT IS THE RELOCATION CONSTANT FOR THE FOLLOWING PROGRAM LOADED.

Block Type 6 Name Block
THE FIRST WORD OF THIS BLOCK IS THE PROGRAM NAME (RADIX 5¢).
IT MUST APPEAR BEFORE ANY TYPE 2 BLOCKS. THE SECOND WORD IF
IT APPEARS DEFINES THE LENGTH OF COMMON.

Block Type 7 Starting Address
THE FIRST WORD OF THIS BLOCK IS THE STARTING ADDRESS OF THE PROGRAM. THE LAST BLOCK OF THIS TYPE ENCOUNTERED BY THE LOADER
IS USED UNLESS THE CONTROL CHARACTER (A) HAS BEEN TYPED. THE
STARTING ADDRESS FOR A RELOCATABLE PROGRAM MAY BE RELOCATED
BY MEANS OF THE RELOCATION BITS.

Block Type 1¢ Internal Request
EACH DATA WORD IS ONE REQUEST. THE LEFT HALF IS THE POINTER TO
THE PROGRAM. THE RIGHT HALF IS THE VALUE. EITHER QUANTITY MAY
BE RELOCATABLE.

Radix 5¢ Representation
Radix 5¢ representation is used to condense 6 character symbols into 32 bits. Let each character
of a symbol be subscripted in descending order from left to right; that is, let the symbols be of
the form

If C denotes the six bit code for L I the radix 5% representation is generated by the following:
n
n

where a II numbers are octa I.
The code numbers corresponding to the characters are:
Code (Octal)

%%
%1-12
13-44
45
45
47

Characters
Space

%-9
A-Z

$
%

CHAPTER 7
ASSEMBLER INITIALIZATlON

At the beginning of each assembly, the assembler is initialized to certain states affected by
control codes. The initial states are:
1. Radix is set to 8.

2. The location counter is set to 0 and relocatable assembly wi II occur.
3. There will be a' normal listing.
4. There will be LINK binary output with a symbol table.

5. Phase mode is off.
6. The title and subtitle are blanked.

7. Only device mnemonics are placed in the symbol table. They are:
CPA
= ~~~
PRS
~~4
PTP
= 1~~
PTR
= 1~4
CP
11~
CR
= 114
TTY
= 12~
124
LPT
DI
13~
DC
= 2~~
UT
= 21~
UTS
= 214
MTC = 22~
224
MTS
MTM = 23~
DCSA
3~~
DCSB
3~
DRUM
4~~

Arithmetic Processor
Priority Interrupt System
Paper Tape Punch
Paper Tape Reader
Card Punch
Card Reader
Console Teleprinter
Line Printer
Display
Data Control
Micro Tape Control
Micro Tape Status
Mag Tape Control
Mag Tape Status
Mag Tape Status
Data Communication System
Data Communication System
Drum System

8. No macros or opdefs exist.

APPENDIX 1
CODES

DATA GENERATING CODES
DEC

Decimal numbers

OCT

Octal numbers

EXP

Express ions

XWD

Block transfer word

10WD

Input/output transfer word

POINT

Pointer word

SIXBIT

ASCII (6-bit) character strings

BYTE

Variable length bytes

BLOCK

Block of storage reserved

ASCII

ASCII (7-bit) character strings

PROCESSOR CONTROL CODES
REPEAT

Repeat character string

IFn

Conditional assembly
n

Condition

zero

positive

zero or positive

negative

zero or negat ive

non zero

blank
pass I
pass 2

2
OPDEF

Define an op mnemonic

SYM

Define a synonym
Al

PHASE

Enter ph,:!se mode

DEPHASE

Leave phase mode

RIM

Assemble RIM tapes

IFIDN

Conditional assembly on character strings

IFDIF

Conditional assembly on character strings

RADIX

Radix control

LOC

Set location counter

PASS2

Terminate PASS 1

NOSYM

Suppress symbol table output

LIT

Assemble literals

VAR

Assemble variables

EXTERN

List of external symbols

INTERN

List of internal symbols

IRP

Indefinite repeat

PURGE

Purge symbols

TAPE

End of a physical tape

END

Last line

LIST CONTROL
LIST

List

XLiST

Stop listing

LALL

Expanded listing

XALL

Stop expanded listing

TITLE

Title

SUBTTL

Subtitle

PAGE

Skip to top of next page

APPENDIX

SUM MARY OF ERR FLAGS

Argument of control op

Reference to multiply defined symbol

III ega I use of an externa I

Macro definition

Usage of I itera I

Multiply defined symbol

Number

Undefined operation code

Phase discrepancy

Relocation

Undefined symbol

Value previously undefined

Macro definition error

APPENDIX 3
PROG RAM M I NG EXAMPLES

FLOATING POINT LOG (BASE E) SUBROUTINE
A
A,L
A,-33
A,211~~~
A,LS
A,567377
A,LS

iGET ABSF(X)
iRETURN ~ FOR LOG(¢) OR LOG(-~)
iSEPARATE FRACTION FROM EXPONENT
iFLOAT THE EXPONENT AND MULTIPLY BY 2
iNUMBER NOW IN CORRECT FLOATING FORMAT
iSET UP -4~1 .~ IN A
iSUBTRACT 4~1 FROM THE EXPONENT*2
iSHIFT FRACTION PART FOR FLOAT
iFLOAT THE FRACTION PART

MOVMS
JUMPLE
ASHC
ADDI
MOVSM
MOVSI
FADM
ASH
TLC
FAD
MOVE
FAD
FDV
MOVEM
FMP
MOVE
FMP
FAD
FMP
FAD
FMP
FAD
FMP
POPJ

L1 :
L2:
L3:
L4:
L5:
L7:

577225754146

i-~·7~71~6781187

2~1552~23632
2~~62532522
2~~7542136~
2~2561251~~6
2~~54271~3~~

i 1.414213562374
i ~.5989786496
i ~. 96147%6323
i 2.88539129~3
i ~.69314718~56

LS:
LZ:

~
~

LOG:

B,-l~

B,2~~~~
B, 11
A,B
A,L2
B,A
B,LZ
B, B
A,L3
A,B
A,L4
A,B
A,L5
A,LZ
A,LS
A,L7
P,

iB=B-SQRTF(2.~)/2.~

iA=B
iA=A+SQRTF(2 .~)/2.~
iB=B/A
iSTORE NEW VARIABLE IN LZ
iCALCULATE Zt2
iPICK UP FIRST CONSTANT
iMULTIPLY BY Zt2
iADD IN NEXT CONSTANT
iMULTIPLY BY Zt2
iADD IN LAST CONSTANT
iMULTIPLY BY Z
iADD IN EXPONENT TO FROM LOG BASE 2
iMUL TlPL Y BY LOG(2), BASE E
i EXIT

A=i7
B=~
P=1
ENTRY

LOG

END
A4

FLOATING POINT SQUARE ROOT FUNCTION
iARGUMENT IS WRITTEN IN THE FORM X=F*2**2B
iSQRT(X) IS THEN SQRT(F)*2**B
iSQRT(F) IS CALCULATED BY A LINEAR APPROXIMATION
iSQRT(F) IS CALCULATED BY A LINEAR APPROXIMATION
iTHE NATURE OF WHICH DEPENDS ON WHETHER 1/4<F<1/2
iOR 1/2<F<l, FOLLOWED BY 2 ITERATIONS OF NEWTON'S METHOD.
SQRT:

SQ1:
SQ2:
Sl :
S2:

ST:

MOVMS
JUMPLE
ASHC
SUBI
ROT
HRRM
LSH
ASH
FSC
MOVEM
FMP
FAD
MOVE
FDV
FAD
FSC
MOVE
FDV
FADR
FSC
POPJ

A
A,SQ2
A,-33
A,2%1
A,-l
A,SQ1
A,-43
B,-l%
B,177(A)
B,ST
B,Sl(A)
B, S2(A)
A,ST
A, B
B,A
B,-I
A,ST
A, B
A,B
A,%
P,

iGET ABSOLUTE VALUE OF ARG
iEXIT IF X=%
iPUT EXPONENT IN A, FRACTION IN B
iSUBTRACT 2%1 FROM EXPONENT
iCUT EXPONENT IN HALF, SAVE ODD BIT
iSAVE FOR FUTURE SCALING OF ANSWER
iGET BIT SAVED BY PREVIOUS INSTRUCTION
iPUT FRACTION IN PROPER POSITION
iPUT EXPONENT OF FRAC TO EITHER % OR 1
iSAVE IT. 1/4< FRAC <1
iLlNEAR FIRST APPROX, DEPENDING ON
iWHETHER 1/4<F<1/2 OR 1/2<F<1
iSTART NEWTON'S METHOD WITH FRAC
iCALCULATE X(0)/X(l )
iX(l }+X(0)/X(l )
i 1/2(X(1 }+X(0)/X(1 ))
iSECOND ITERATION NEWTON's METHOD
iX(0)/X2)
i X(2}+X(0)/X(2)
iSCALE ANSWER FOR NEWTON AND EXPONENT
i EXIT
iCONSTANT, USED IF 1/4<FRAC<1/2
iCONSTANT, USED IF 1/2 < FRAC<1
iCONSTANT, USED IF 1/4 < FRAC <1/2
iCONSTANT, USED IF 1/2 <FRAC<1

%.8125
%.578125
%.3%2734
%.421875
%
A=17
P=1
B=%
ENTRY

SQRT

END

FLOATING POINT NUMBER TO A FIXED POINT POWER
iROUTINE CALCULATES A**B, A FLOATING POINT
iB IS OF THE FOLLOWING FORM:
i B=A(0)+A(1 )*2+A(2)*4+ ••. , WHERE A(I)=.0 OR 1 •
iANSWER MULTIPLIED BY A**I IF A(I)=1
iTHEN B IS SHIFTED TO GET NEXT BIT.
EXP.2:

FEXP1:
FEXP2:

FEXP4:

JUMPE
MOVSI
JUMPGE
MOVMS
PUSHJ
MOVSI
FDVM
POPJ

A,FEXP4
T,2.014.0.0
B, FEXP2

FMP
LSH
TRZE
FMP
JUMPN
MOVE
POPJ

A,A
B, -1
B, 1
T,A
B,FEXPI
A, T

P,FEXP2
T,2.014.0.0
T,A

iZERO BASE, RETURN
iPUT 1 •.0 IN ACC. T
iCHECK SIGN OF EXPONENT
iNEGATE EXPONENT - SET TO POSITIVE
iDO CALCULATION
iGET 1 •.0 IN T
iFORM 1/A**B
i EXIT
iFORM A**N, FLOATING POINT
iSHIFT EXPONENT FOR NEXT BIT
ilS BIT A ZERO?
iNO, MULTIPLY ANSWER BY A**N
iUPDATE A**N UNLESS ALL THROUGH
iPICK UP RESULT FROM T
i EXIT

T=.0
P=1
A=17
B=16
ENTRY

EXP.2

END

APPENDIX 4
CHARACTER SETS

6 bit
(space)
II

$
%

(
)

*
+

/
~

1
2
3
4
5
6
7
8
9
i

<
=

>
?

6 bit

Punched
Card

ASCII

240
241
242
243
244
245
246
247

b
12-7-8
0-5-8
0-6-8
11-3-8
0-7-8
11-7-8
6-8

01
02
03
04
05
06
07

250
251
252
253
254
255
256
257

10
11
12
13
14
15
16
17

0-4-8
12-4-8
11-4-8
12
0-3-8
11
12-3-8
0-1

260
261
262
263
264
265
266
267

20
21
22
23
24
25
26
27

270
271
272
273
274
275
276
277

30
31
32
33
34
35
36
37

A
B
C
D

E
F
G

I
J
K
L
M
N
0
P
Q

1
2
3
4
5
6
7
/

R
S
T

U
V
W

8
9
11-0
0-2-8
12-6-8
3-8
11-6-8
12-0

Y
Z
[

"-]

ASCII

Punched
Card

300
301
302
303
304
305
306
307

---;w-

310
311
312
313
314
315
316
317

51
52
53
54
55
56
57

12-8
12-9
11- 1
11-2
11-3
11-4
11-5
11-6

320
321
322
323
324
325
326
327

60
61
62
63
64
65
66
67

11-7
11-8
11-9
0-2
0-3
0-4
0-5
0-6

330
331
332
333
334
335
336

70
71
72
73
74
75
76

0-7
0-8
0-9
11-5-8
7-8
12-5-8
5-8

41
42
43
44

45
46
47

4-8
12-1
12-2
12-3
12-4
12-5
12-6
12-7

momooma

EQUIPMENT
CORPORATION
MAYNARD,MASSACHUSETTS

5244

PRINTED IN U.S.A.

10-2/65