Digital PDFs

XX-B63ED-1C

May 2000

6 pages

Original

77.2kB

Document:	pdp11 reference
Order Number:	XX-B63ED-1C
Revision:
Pages:	6
Original Filename:	https://www.singlix.com/trdos/archive/pdf_archive/pdp11_reference.pdf

OCR Text

PDP-11 instruction reference
CSC 258

Overall notes
Most numbers in this document are in octal (base 8).
‘‘msb’’ means ‘‘most significant bit’’ (sometimes ‘‘byte’’, but always ‘‘bit’’ in this document).
The ‘‘bit scheme’’ for condition codes is:
N = msb of result
Z = whether the result is zero
V is reset (i.e. V becomes 0)
C is not affected
The ‘‘value scheme’’ for condition codes is:
N,Z are determined by the final result as above
V is determined by whether arithmetic overflow occurred
C is not affected unless specified
The symbol ‘‘01’’ in an opcode refers to a 0 for the word version of the instruction and a 1 for the
byte version of the instruction.

Addressing modes
The six bits indicating addressing type are divided into:
• three bits for ‘‘mode’’
• three bits to indicate a register (yielding a register number from 0 to 7, inclusive)
The top two of the three mode bits work as follows:
top two bits
00_
01_
10_
11_

octal
0 or 1
2 or 3
4 or 5
6 or 7

name
register
autoincrement
autodecrement
index

assembly syntax
Ri
(Ri)+
−(Ri)
n(Ri)

EA and other semantics
Ri
[Ri], then Ri←[Ri]+2 or 1
first Ri←[Ri]−2 or 1, then EA=new [Ri]
[[R7]]+[Ri], then inc PC by 2
(n follows in next memory word)

The third mode bit is ‘‘indirect’’. It yields one extra indirection. In the assembly syntax, we add
an ‘‘@’’.
Some modes have a special assembly syntax when used with R7:
mode
bits
010
011
110
111

octal
2
3
6
7

name when used
with R7
immediate
absolute direct
relative direct
relative indirect

assembly
syntax
#n
@#n
n
@n

EA and other semantics
EA=[R7], then R7←[R7]+2
EA=[[R7]], then R7←[R7]+2
X=[[R7]], then inc R7, then EA=X+[R7]
X=[[R7]], then inc R7, then EA=[X+[R7]]

-2-

Zero-operand instructions
Format:

opcode
15

Mnemonic
HALT
WAIT
RESET
NOP

0
Opcode
000000
000001
000005
000240

Semantics
Halt CPU until restarted; abort i/o
Halt CPU until restarted or interrupted
Reset all i/o devices
No operation

One-operand instructions
Format:

opcode
15

addr
6 5

Mnemonic
CLR{B}
INC{B}
DEC{B}
ADC{B}

Opcode
0
1050
0
1052
0
1053
0
1055

SBC{B}

0
1

056

Semantics
addr ← 0
addr ← [addr] + 1
addr ← [addr] − 1
addr ← [addr] + [C]
i.e. add 1 if C=1, add 0 if C=0
addr ← [addr] − [C]

TST{B}
NEG{B}

0
1
0
1

057
054

set condition codes by [addr]
addr ← −[addr]

COM{B}

0
1

051

addr ← one’s complement of [addr]

ROR{B}

0
1

ROL{B}

0
1

ASR{B}
ASL{B}
SWAB
(swap bytes)
SXT (signextend)

0
1
0
1

addr ← rotate [addr] right one bit through
carry
addr ← rotate [addr] left one bit through
carry
addr ← arithmetic-shift [addr] right one bit
addr ← shift [addr] left one bit
addr ← [addr] with high/low bytes swapped
(it’s a word instruction, despite the ‘‘B’’)
addr ← all bits [N] (the condition code)

060
061

062
063
0003
0067

Condition code notes
N,V,C reset; Z set
‘‘value’’ scheme
‘‘value’’ scheme
‘‘value’’ scheme;
C is carry from addition
‘‘value’’ scheme;
C is ‘‘borrow’’ from subt.
N,Z by [addr]; V,C reset
‘‘value’’ scheme (overflows
iff was 100000); C reset if
result=0, C set if result≠0
N,Z by result; V reset;
C set
N,Z by result; C by rotation;
V = new N ⊕ new C
as ROR{B}
as ROR{B}; C = old low bit
as ROR{B}; C = old high bit
C,V reset; N,V by low byte
of result (i.e. by source!!)
N,C,V not affected;
Z set by result

-3-

One-and-a-half-operand instructions
Format:

opcode
reg
addr
15
9 8
6 5
0

Note! The ‘‘addr’’ field always comes last in the machine-language format but the target field
(which may be ‘‘addr’’ or ‘‘reg’’, according to the semantics) is what comes last in the assemblylanguage format.
Mnemonic
MUL

Opcode
070

DIV

071

ASH

072

ASHC
(combined)
XOR

073

Semantics
reg;reg∨1 ← [reg] × [addr]
If reg is odd, only the low-order word is
stored.
reg ← [reg;reg∨1] div [addr]
reg∨1 ← [reg;reg∨1] mod [addr]
reg must be even.
reg ← [reg] shifted by low 6 bits of [addr];
shift value is interpreted as signed, where
negative means right
reg;reg∨1 ← [reg;reg∨1] shifted by
low 6 bits of [addr], as with ASH
addr ← [reg] ⊕ [addr]

074

Condition code notes
N, Z describe entire product;
V reset;
C set iff low word overflows
C,V both set if divide by 0;
else V set iff div result
would not fit in reg
V set iff msb of [reg]
changed during shift;
C = last bit shifted out
V set iff msb changed;
C = last bit shifted out
‘‘bit’’ scheme

Two-operand instructions
Format:

src

dst

12 11

6 5

Mnemonic
MOV{B}

Opcode
0
11

ADD

Semantics
dst ← [src]
In MOVB, if dst is reg, is sign-extended.
dst ← [dst] + [src]

SUB

dst ← [dst] − [src]

CMP{B}

0
1

BIS{B}
(bit set)
BIC{B}
(bit clear)
BIT{B}
(bit test)

0
1

compute [src] − [dst] (not stored)
N.B. different order from SUB!
dst ← [dst] ∨ [src] (bitwise)

‘‘value’’ scheme;
C is carry from addition
‘‘value’’ scheme;
C is ‘‘borrow’’ from subt.
‘‘value’’ scheme;
C is ‘‘borrow’’ from subt.
‘‘bit’’ scheme

0
1

dst ← [dst] ∧ [src] (bitwise)

‘‘bit’’ scheme

0
1

compute [src] ∧ [dst] (bitwise) (not stored)

‘‘bit’’ scheme

0
Condition code notes
‘‘value’’ scheme; V reset

-4-

Branch instructions

(also see SOB in the following section)
Format:

opcode
15

Mnemonic
BR
BNE
BEQ
BPL
BMI
BVC
BVS
BHIS
BCC
BLO
BCS
BGE
BLT
BGT
BLE
BHI
BLOS

(octal coding doesn’t work out too nicely here)

offset
8 7

Name
Branch
Branch on not equal
Branch on equal
Branch on plus
Branch on minus
Branch on overflow clear
Branch on overflow set
Branch on higher than or same as
Branch on carry clear
Branch on lower
Branch on carry set
Branch on greater than or equal to
Branch on less than
Branch on greater than
Branch on less than or equal to
Branch on higher than
Branch on lower than or same as

Binary opcode
00000001
00000010
00000011
10000000
10000001
10000100
10000101
10000110
10000110
10000111
10000111
00000100
00000101
00000110
00000111
10000010
10000011

Branch condition
unconditional
Z=0
Z=1
N=0
N=1
V=0
V=1
C=0
C=0
C=1
C=1
N⊕V=0
N⊕V=1
Z ∨ (N ⊕ V) = 0
Z ∨ (N ⊕ V) = 1
C∨Z=0
C∨Z=1

The eight bits of the offset are interpreted as the high eight bits of a nine-bit signed offset whose
last bit is zero. Thus if the condition is met, we do R7 ← [R7] + 2 × offset.
BHI, BHIS (aka BCC), BLO (aka BCS), and BLOS do what they say if the data is interpreted as
unsigned; the use of BLT, BLE, BGT, and BGE tends to interpret the data as two’s-complement.

Other instructions involving transfer of control
Format: according to schema below
Where R is a register, and AA is an address in any of the standard addressing modes yielding an EA
(condition codes are not affected, except by setting the entire PSW where indicated)
Mnemonic
JMP

Name
Jump

Octal schema
0001AA

SOB

Subtract One and
Branch

077Rnn

(table continues)

Semantics
R7 ← EA (use @ to get [EA])
(can’t use plain register mode if not ‘@’)
R ← [R] − 1
then if [R] ≠ 0, R7 ← [R7] − 2×nn
Note: nn is treated as unsigned; can only
jump backward. Cond codes unchanged.

-5-

Other instructions involving transfer of control, continued
Mnemonic
JSR

Name
Jump to subroutine

Octal schema
004RAA

RTS

Return from
subroutine

00020R

RTI

Return from
interrupt (or trap)

000002

TRAP

Trap

104xyz, x≥4

BPT

Breakpoint trap.
Used by debuggers.

000003

IOT

I/O trap. Used by
OS for I/O calls.
Emulator trap.
Used by OS to
implement fake ops.
Return from trace
trap

000004

Semantics
temp ← EA
R6 ← [R6] − 2
[R6] ← [R]
R ← [R7]
R7 ← [temp]
R7 ← [R]
R ← [[R6]]
R6 ← [R6] + 2
R7 ← [[R6]]
R6 ← [R6] + 2
PSW ← [[R6]]
R6 ← [R6] + 2
R6 ← [R6] − 2
[R6] ← [PSW]
R6 ← [R6] − 2
[R6] ← [R7]
R7 ← [34]
PSW ← [36]
This seq. is hereby called ‘‘trap from 34’’.
R6 ← [R6] − 2
[R6] ← [PSW]
R6 ← [R6] − 2
[R6] ← [R7]
R7 ← [14]
PSW ← [16]
i.e. ‘‘trap from 14’’.
trap from 20 (see above)

104xyz, x≤3

trap from 30 (see above)

000002

same as RTI, but suppresses the
immediately-following trace trap.
Typically, [14] will have the T bit clear;
after returning, we want to trap after the
next instruction, but not after the RTT itself
when the previous PSW is restored.

EMT
RTT

Note that the opcode in the TRAP and EMT ops is the high byte, and the low byte can be
anything (intended to be interpreted by the ISR).

-6-

Processor status word (PSW)
The PSW’s high byte contains 11/45-specific stuff about kernel and supervisor modes. The
low byte contains the priority (three highest bits), followed by T, N, Z, V, and C, in that order.
An external interrupt which is not precluded by the CPU priority causes a trap from the vector
address appropriate to the interrupting device (see trap sequence, previous section). Zero is the
normal priority. Seven is the highest priority; a higher-number interrupt interrupts a lower
priority but not vice versa. (This is the PDP-11 ordering; it differs among CPUs.)
When T is set, the execution of every instruction except for RTT causes a subsequent trace trap.
A trace trap is a trap from 14 (i.e. it’s the same as executing a BPT).
The processor status word is also affected by the following ops:
Mnemonic
SPL
CLC
CLV
CLZ
CLN
SEC
SEV
SEZ
SEN
CCC
SCC

Name
Set priority level
Clear C
Clear V
Clear Z
Clear N
Set C
Set V
Set Z
Set N
Clear condition codes
Set condition codes

Octal schema
00023n
000241
000242
000244
000250
000261
000262
000264
000270
000257
000277

Semantics
bits 7-5 of PSW ← n
C←0
V←0
Z←0
N←0
C←1
V←1
Z←1
N←1
C,V,Z,N ← 0
C,V,Z,N ← 1

In fact, you can make up your own ‘‘clear’’ and ‘‘set’’ ops in the implied pattern; the last four bits
of the word indicate whether N, Z, V, and/or C are being referred to, in that order. This also
gives us our NOP op (‘‘clear nothing’’).
Alternatively, the PSW can be addressed as location −2, but this should only be done by the OS.

Pseudo-ops and other syntax
Pseudo-ops are lines in your assembly-language program which are instructions to the assembler.
Some of them do not directly correspond to generated code.
They all begin with a period to distinguish them from ops.
Some of the pseudo-ops we will be using are:
.ORG — start assembling at the given address. Example: the next word following a ‘‘.ORG 1000’’
line will be placed at memory address 1000.
.WORD — emit the given value as one word. Example: ‘‘.WORD 264’’ is the same as ‘‘SEZ’’.
.BLKW — emit the stated number of zero words. Example: ‘‘.BLKW 3’’ emits 6 zero bytes.
.BLKB — emit the stated number of zero bytes.
.END — this line must appear as the last line of your assembly language file. It is entirely
unrelated to ‘‘RTS’’. It serves no function and we won’t use it in this course.
A label is an identifier at the beginning of a line, followed by a colon. This causes the address of
the instruction following the label to be entered into the assembler’s symbol table. There is also
a syntax ‘‘var = value’’ (example: ‘‘N = 5’’). The symbol ‘‘ .’’ is always the current instruction’s
address. These symbols can be used anywhere an integer can be used.
A semi-colon begins a comment, which extends to the end of the line.