jona/unix-v6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add original unix v6

Browse Source
This commit is contained in:
memnoth
2018-01-27 22:35:41 +09:00
commit 2c7099ee50
664 changed files with 106254 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sys/conf/data.s
+3
View File
@@ -0,0 +1,3 @@
/ l45.o needs to be in data space
/ to get l45.o; as data.s l.s
.data
sys/conf/m40.s
+839
View File
@@ -0,0 +1,839 @@
/ machine language assist
/ for 11/40
/ non-UNIX instructions
mfpi = 6500^tst
mtpi = 6600^tst
wait = 1
rtt = 6
reset = 5
.globl trap, call
.globl _trap
trap:
mov PS,-4(sp)
tst nofault
bne 1f
mov SSR0,ssr
mov SSR2,ssr+4
mov $1,SSR0
jsr r0,call1; _trap
/ no return
1:
mov $1,SSR0
mov nofault,(sp)
rtt
.globl _runrun, _swtch
call1:
tst -(sp)
bic $340,PS
br 1f
call:
mov PS,-(sp)
1:
mov r1,-(sp)
mfpi sp
mov 4(sp),-(sp)
bic $!37,(sp)
bit $30000,PS
beq 1f
jsr pc,*(r0)+
2:
bis $340,PS
tstb _runrun
beq 2f
bic $340,PS
jsr pc,_swtch
br 2b
2:
tst (sp)+
mtpi sp
br 2f
1:
bis $30000,PS
jsr pc,*(r0)+
cmp (sp)+,(sp)+
2:
mov (sp)+,r1
tst (sp)+
mov (sp)+,r0
rtt
.globl _savfp, _display
_savfp:
_display:
rts pc
.globl _incupc
_incupc:
mov r2,-(sp)
mov 6(sp),r2 / base of prof with base,leng,off,scale
mov 4(sp),r0 / pc
sub 4(r2),r0 / offset
clc
ror r0
mul 6(r2),r0 / scale
ashc $-14.,r0
inc r1
bic $1,r1
cmp r1,2(r2) / length
bhis 1f
add (r2),r1 / base
mov nofault,-(sp)
mov $2f,nofault
mfpi (r1)
inc (sp)
mtpi (r1)
br 3f
2:
clr 6(r2)
3:
mov (sp)+,nofault
1:
mov (sp)+,r2
rts pc
/ Character list get/put
.globl _getc, _putc
.globl _cfreelist
_getc:
mov 2(sp),r1
mov PS,-(sp)
mov r2,-(sp)
bis $340,PS
bic $100,PS / spl 5
mov 2(r1),r2 / first ptr
beq 9f / empty
movb (r2)+,r0 / character
bic $!377,r0
mov r2,2(r1)
dec (r1)+ / count
bne 1f
clr (r1)+
clr (r1)+ / last block
br 2f
1:
bit $7,r2
bne 3f
mov -10(r2),(r1) / next block
add $2,(r1)
2:
dec r2
bic $7,r2
mov _cfreelist,(r2)
mov r2,_cfreelist
3:
mov (sp)+,r2
mov (sp)+,PS
rts pc
9:
clr 4(r1)
mov $-1,r0
mov (sp)+,r2
mov (sp)+,PS
rts pc
_putc:
mov 2(sp),r0
mov 4(sp),r1
mov PS,-(sp)
mov r2,-(sp)
mov r3,-(sp)
bis $340,PS
bic $100,PS / spl 5
mov 4(r1),r2 / last ptr
bne 1f
mov _cfreelist,r2
beq 9f
mov (r2),_cfreelist
clr (r2)+
mov r2,2(r1) / first ptr
br 2f
1:
bit $7,r2
bne 2f
mov _cfreelist,r3
beq 9f
mov (r3),_cfreelist
mov r3,-10(r2)
mov r3,r2
clr (r2)+
2:
movb r0,(r2)+
mov r2,4(r1)
inc (r1) / count
clr r0
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,PS
rts pc
9:
mov pc,r0
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,PS
rts pc
.globl _backup
.globl _regloc
_backup:
mov 2(sp),ssr+2
mov r2,-(sp)
jsr pc,backup
mov r2,ssr+2
mov (sp)+,r2
movb jflg,r0
bne 2f
mov 2(sp),r0
movb ssr+2,r1
jsr pc,1f
movb ssr+3,r1
jsr pc,1f
movb _regloc+7,r1
asl r1
add r0,r1
mov ssr+4,(r1)
clr r0
2:
rts pc
1:
mov r1,-(sp)
asr (sp)
asr (sp)
asr (sp)
bic $!7,r1
movb _regloc(r1),r1
asl r1
add r0,r1
sub (sp)+,(r1)
rts pc
/ hard part
/ simulate the ssr2 register missing on 11/40
backup:
clr r2 / backup register ssr1
mov $1,bflg / clrs jflg
mov ssr+4,r0
jsr pc,fetch
mov r0,r1
ash $-11.,r0
bic $!36,r0
jmp *0f(r0)
0: t00; t01; t02; t03; t04; t05; t06; t07
t10; t11; t12; t13; t14; t15; t16; t17
t00:
clrb bflg
t10:
mov r1,r0
swab r0
bic $!16,r0
jmp *0f(r0)
0: u0; u1; u2; u3; u4; u5; u6; u7
u6: / single op, m[tf]pi, sxt, illegal
bit $400,r1
beq u5 / all but m[tf], sxt
bit $200,r1
beq 1f / mfpi
bit $100,r1
bne u5 / sxt
/ simulate mtpi with double (sp)+,dd
bic $4000,r1 / turn instr into (sp)+
br t01
/ simulate mfpi with double ss,-(sp)
1:
ash $6,r1
bis $46,r1 / -(sp)
br t01
u4: / jsr
mov r1,r0
jsr pc,setreg / assume no fault
bis $173000,r2 / -2 from sp
rts pc
t07: / EIS
clrb bflg
u0: / jmp, swab
u5: / single op
mov r1,r0
br setreg
t01: / mov
t02: / cmp
t03: / bit
t04: / bic
t05: / bis
t06: / add
t16: / sub
clrb bflg
t11: / movb
t12: / cmpb
t13: / bitb
t14: / bicb
t15: / bisb
mov r1,r0
ash $-6,r0
jsr pc,setreg
swab r2
mov r1,r0
jsr pc,setreg
/ if delta(dest) is zero,
/ no need to fetch source
bit $370,r2
beq 1f
/ if mode(source) is R,
/ no fault is possible
bit $7000,r1
beq 1f
/ if reg(source) is reg(dest),
/ too bad.
mov r2,-(sp)
bic $174370,(sp)
cmpb 1(sp),(sp)+
beq t17
/ start source cycle
/ pick up value of reg
mov r1,r0
ash $-6,r0
bic $!7,r0
movb _regloc(r0),r0
asl r0
add ssr+2,r0
mov (r0),r0
/ if reg has been incremented,
/ must decrement it before fetch
bit $174000,r2
ble 2f
dec r0
bit $10000,r2
beq 2f
dec r0
2:
/ if mode is 6,7 fetch and add X(R) to R
bit $4000,r1
beq 2f
bit $2000,r1
beq 2f
mov r0,-(sp)
mov ssr+4,r0
add $2,r0
jsr pc,fetch
add (sp)+,r0
2:
/ fetch operand
/ if mode is 3,5,7 fetch *
jsr pc,fetch
bit $1000,r1
beq 1f
bit $6000,r1
bne fetch
1:
rts pc
t17: / illegal
u1: / br
u2: / br
u3: / br
u7: / illegal
incb jflg
rts pc
setreg:
mov r0,-(sp)
bic $!7,r0
bis r0,r2
mov (sp)+,r0
ash $-3,r0
bic $!7,r0
movb 0f(r0),r0
tstb bflg
beq 1f
bit $2,r2
beq 2f
bit $4,r2
beq 2f
1:
cmp r0,$20
beq 2f
cmp r0,$-20
beq 2f
asl r0
2:
bisb r0,r2
rts pc
0: .byte 0,0,10,20,-10,-20,0,0
fetch:
bic $1,r0
mov nofault,-(sp)
mov $1f,nofault
mfpi (r0)
mov (sp)+,r0
mov (sp)+,nofault
rts pc
1:
mov (sp)+,nofault
clrb r2 / clear out dest on fault
mov $-1,r0
rts pc
.bss
bflg: .=.+1
jflg: .=.+1
.text
.globl _fubyte, _subyte
.globl _fuibyte, _suibyte
.globl _fuword, _suword
.globl _fuiword, _suiword
_fuibyte:
_fubyte:
mov 2(sp),r1
bic $1,r1
jsr pc,gword
cmp r1,2(sp)
beq 1f
swab r0
1:
bic $!377,r0
rts pc
_suibyte:
_subyte:
mov 2(sp),r1
bic $1,r1
jsr pc,gword
mov r0,-(sp)
cmp r1,4(sp)
beq 1f
movb 6(sp),1(sp)
br 2f
1:
movb 6(sp),(sp)
2:
mov (sp)+,r0
jsr pc,pword
clr r0
rts pc
_fuiword:
_fuword:
mov 2(sp),r1
fuword:
jsr pc,gword
rts pc
gword:
mov PS,-(sp)
bis $340,PS
mov nofault,-(sp)
mov $err,nofault
mfpi (r1)
mov (sp)+,r0
br 1f
_suiword:
_suword:
mov 2(sp),r1
mov 4(sp),r0
suword:
jsr pc,pword
rts pc
pword:
mov PS,-(sp)
bis $340,PS
mov nofault,-(sp)
mov $err,nofault
mov r0,-(sp)
mtpi (r1)
1:
mov (sp)+,nofault
mov (sp)+,PS
rts pc
err:
mov (sp)+,nofault
mov (sp)+,PS
tst (sp)+
mov $-1,r0
rts pc
.globl _copyin, _copyout
_copyin:
jsr pc,copsu
1:
mfpi (r0)+
mov (sp)+,(r1)+
sob r2,1b
br 2f
_copyout:
jsr pc,copsu
1:
mov (r0)+,-(sp)
mtpi (r1)+
sob r2,1b
2:
mov (sp)+,nofault
mov (sp)+,r2
clr r0
rts pc
copsu:
mov (sp)+,r0
mov r2,-(sp)
mov nofault,-(sp)
mov r0,-(sp)
mov 10(sp),r0
mov 12(sp),r1
mov 14(sp),r2
asr r2
mov $1f,nofault
rts pc
1:
mov (sp)+,nofault
mov (sp)+,r2
mov $-1,r0
rts pc
.globl _idle
_idle:
mov PS,-(sp)
bic $340,PS
wait
mov (sp)+,PS
rts pc
.globl _savu, _retu, _aretu
_savu:
bis $340,PS
mov (sp)+,r1
mov (sp),r0
mov sp,(r0)+
mov r5,(r0)+
bic $340,PS
jmp (r1)
_aretu:
bis $340,PS
mov (sp)+,r1
mov (sp),r0
br 1f
_retu:
bis $340,PS
mov (sp)+,r1
mov (sp),KISA6
mov $_u,r0
1:
mov (r0)+,sp
mov (r0)+,r5
bic $340,PS
jmp (r1)
.globl _spl0, _spl1, _spl4, _spl5, _spl6, _spl7
_spl0:
bic $340,PS
rts pc
_spl1:
bis $40,PS
bic $300,PS
rts pc
_spl4:
_spl5:
bis $340,PS
bic $100,PS
rts pc
_spl6:
bis $340,PS
bic $40,PS
rts pc
_spl7:
bis $340,PS
rts pc
.globl _copyseg
_copyseg:
mov PS,-(sp)
mov UISA0,-(sp)
mov UISA1,-(sp)
mov $30340,PS
mov 10(sp),UISA0
mov 12(sp),UISA1
mov UISD0,-(sp)
mov UISD1,-(sp)
mov $6,UISD0
mov $6,UISD1
mov r2,-(sp)
clr r0
mov $8192.,r1
mov $32.,r2
1:
mfpi (r0)+
mtpi (r1)+
sob r2,1b
mov (sp)+,r2
mov (sp)+,UISD1
mov (sp)+,UISD0
mov (sp)+,UISA1
mov (sp)+,UISA0
mov (sp)+,PS
rts pc
.globl _clearseg
_clearseg:
mov PS,-(sp)
mov UISA0,-(sp)
mov $30340,PS
mov 6(sp),UISA0
mov UISD0,-(sp)
mov $6,UISD0
clr r0
mov $32.,r1
1:
clr -(sp)
mtpi (r0)+
sob r1,1b
mov (sp)+,UISD0
mov (sp)+,UISA0
mov (sp)+,PS
rts pc
.globl _dpadd
_dpadd:
mov 2(sp),r0
add 4(sp),2(r0)
adc (r0)
rts pc
.globl _dpcmp
_dpcmp:
mov 2(sp),r0
mov 4(sp),r1
sub 6(sp),r0
sub 8(sp),r1
sbc r0
bge 1f
cmp r0,$-1
bne 2f
cmp r1,$-512.
bhi 3f
2:
mov $-512.,r0
rts pc
1:
bne 2f
cmp r1,$512.
blo 3f
2:
mov $512.,r1
3:
mov r1,r0
rts pc
.globl dump
dump:
bit $1,SSR0
bne dump
/ save regs r0,r1,r2,r3,r4,r5,r6,KIA6
/ starting at abs location 4
mov r0,4
mov $6,r0
mov r1,(r0)+
mov r2,(r0)+
mov r3,(r0)+
mov r4,(r0)+
mov r5,(r0)+
mov sp,(r0)+
mov KISA6,(r0)+
/ dump all of core (ie to first mt error)
/ onto mag tape. (9 track or 7 track 'binary')
mov $MTC,r0
mov $60004,(r0)+
clr 2(r0)
1:
mov $-512.,(r0)
inc -(r0)
2:
tstb (r0)
bge 2b
tst (r0)+
bge 1b
reset
/ end of file and loop
mov $60007,-(r0)
br .
.globl start, _end, _edata, _main
start:
bit $1,SSR0
bne start / loop if restart
reset
/ initialize systems segments
mov $KISA0,r0
mov $KISD0,r1
mov $200,r4
clr r2
mov $6,r3
1:
mov r2,(r0)+
mov $77406,(r1)+ / 4k rw
add r4,r2
sob r3,1b
/ initialize user segment
mov $_end+63.,r2
ash $-6,r2
bic $!1777,r2
mov r2,(r0)+ / ksr6 = sysu
mov $usize-1\<8|6,(r1)+
/ initialize io segment
/ set up counts on supervisor segments
mov $IO,(r0)+
mov $77406,(r1)+ / rw 4k
/ get a sp and start segmentation
mov $_u+[usize*64.],sp
inc SSR0
/ clear bss
mov $_edata,r0
1:
clr (r0)+
cmp r0,$_end
blo 1b
/ clear user block
mov $_u,r0
1:
clr (r0)+
cmp r0,$_u+[usize*64.]
blo 1b
/ set up previous mode and call main
/ on return, enter user mode at 0R
mov $30000,PS
jsr pc,_main
mov $170000,-(sp)
clr -(sp)
rtt
.globl _ldiv
_ldiv:
clr r0
mov 2(sp),r1
div 4(sp),r0
rts pc
.globl _lrem
_lrem:
clr r0
mov 2(sp),r1
div 4(sp),r0
mov r1,r0
rts pc
.globl _lshift
_lshift:
mov 2(sp),r1
mov (r1)+,r0
mov (r1),r1
ashc 4(sp),r0
mov r1,r0
rts pc
.globl csv
csv:
mov r5,r0
mov sp,r5
mov r4,-(sp)
mov r3,-(sp)
mov r2,-(sp)
jsr pc,(r0)
.globl cret
cret:
mov r5,r1
mov -(r1),r4
mov -(r1),r3
mov -(r1),r2
mov r5,sp
mov (sp)+,r5
rts pc
.globl _u
_u = 140000
usize = 16.
PS = 177776
SSR0 = 177572
SSR2 = 177576
KISA0 = 172340
KISA6 = 172354
KISD0 = 172300
MTC = 172522
UISA0 = 177640
UISA1 = 177642
UISD0 = 177600
UISD1 = 177602
IO = 7600
.data
.globl _ka6, _cputype
_ka6: KISA6
_cputype:40.
.bss
.globl nofault, ssr, badtrap
nofault:.=.+2
ssr: .=.+6
badtrap:.=.+2
sys/conf/m45.s
+890
View File
@@ -0,0 +1,890 @@
/ machine language assist
/ for 11/45 or 11/70 CPUs
.fpp = 1
/ non-UNIX instructions
mfpi = 6500^tst
mtpi = 6600^tst
mfpd = 106500^tst
mtpd = 106600^tst
spl = 230
ldfps = 170100^tst
stfps = 170200^tst
wait = 1
rtt = 6
reset = 5
HIPRI = 300
HIGH = 6
/ Mag tape dump
/ save registers in low core and
/ write all core onto mag tape.
/ entry is thru 44 abs
.data
.globl dump
dump:
bit $1,SSR0
bne dump
/ save regs r0,r1,r2,r3,r4,r5,r6,KIA6
/ starting at abs location 4
mov r0,4
mov $6,r0
mov r1,(r0)+
mov r2,(r0)+
mov r3,(r0)+
mov r4,(r0)+
mov r5,(r0)+
mov sp,(r0)+
mov KDSA6,(r0)+
/ dump all of core (ie to first mt error)
/ onto mag tape. (9 track or 7 track 'binary')
mov $MTC,r0
mov $60004,(r0)+
clr 2(r0)
1:
mov $-512.,(r0)
inc -(r0)
2:
tstb (r0)
bge 2b
tst (r0)+
bge 1b
reset
/ end of file and loop
mov $60007,-(r0)
br .
.globl start, _end, _edata, _etext, _main
/ 11/45 and 11/70 startup.
/ entry is thru 0 abs.
/ since core is shuffled,
/ this code can be executed but once
start:
inc $-1
bne .
reset
clr PS
/ set KI0 to physical 0
mov $77406,r3
mov $KISA0,r0
mov $KISD0,r1
clr (r0)+
mov r3,(r1)+
/ set KI1-6 to eventual text resting place
mov $_end+63.,r2
ash $-6,r2
bic $!1777,r2
1:
mov r2,(r0)+
mov r3,(r1)+
add $200,r2
cmp r0,$KISA7
blos 1b
/ set KI7 to IO seg for escape
mov $IO,-(r0)
/ set KD0-7 to physical
mov $KDSA0,r0
mov $KDSD0,r1
clr r2
1:
mov r2,(r0)+
mov r3,(r1)+
add $200,r2
cmp r0,$KDSA7
blos 1b
/ initialization
/ get a temp (1-word) stack
/ turn on segmentation
/ copy text to I space
/ clear bss in D space
mov $stk+2,sp
mov $65,SSR3 / 22-bit, map, K+U sep
bit $20,SSR3
beq 1f
mov $70.,_cputype
1:
inc SSR0
mov $_etext,r0
mov $_edata,r1
add $_etext-8192.,r1
1:
mov -(r1),-(sp)
mtpi -(r0)
cmp r1,$_edata
bhi 1b
1:
clr (r1)+
cmp r1,$_end
blo 1b
/ use KI escape to set KD7 to IO seg
/ set KD6 to first available core
mov $IO,-(sp)
mtpi *$KDSA7
mov $_etext-8192.+63.,r2
ash $-6,r2
bic $!1777,r2
add KISA1,r2
mov r2,KDSA6
/ set up supervisor D registers
mov $6,SISD0
mov $6,SISD1
/ set up real sp
/ clear user block
mov $_u+[usize*64.],sp
mov $_u,r0
1:
clr (r0)+
cmp r0,sp
blo 1b
/ jsr pc,_isprof
/ set up previous mode and call main
/ on return, enter user mode at 0R
mov $30000,PS
jsr pc,_main
mov $170000,-(sp)
clr -(sp)
rtt
.globl trap, call
.globl _trap
/ all traps and interrupts are
/ vectored thru this routine.
trap:
mov PS,saveps
tst nofault
bne 1f
mov SSR0,ssr
mov SSR1,ssr+2
mov SSR2,ssr+4
mov $1,SSR0
jsr r0,call1; _trap
/ no return
1:
mov $1,SSR0
mov nofault,(sp)
rtt
.text
.globl _runrun, _swtch
call1:
mov saveps,-(sp)
spl 0
br 1f
call:
mov PS,-(sp)
1:
mov r1,-(sp)
mfpd sp
mov 4(sp),-(sp)
bic $!37,(sp)
bit $30000,PS
beq 1f
.if .fpp
mov $20,_u+4 / FP maint mode
.endif
jsr pc,*(r0)+
2:
spl HIGH
tstb _runrun
beq 2f
spl 0
jsr pc,_savfp
jsr pc,_swtch
br 2b
2:
.if .fpp
mov $_u+4,r1
bit $20,(r1)
bne 2f
mov (r1)+,r0
ldfps r0
movf (r1)+,fr0
movf (r1)+,fr1
movf fr1,fr4
movf (r1)+,fr1
movf fr1,fr5
movf (r1)+,fr1
movf (r1)+,fr2
movf (r1)+,fr3
ldfps r0
2:
.endif
tst (sp)+
mtpd sp
br 2f
1:
bis $30000,PS
jsr pc,*(r0)+
cmp (sp)+,(sp)+
2:
mov (sp)+,r1
tst (sp)+
mov (sp)+,r0
rtt
.globl _savfp
_savfp:
.if .fpp
mov $_u+4,r1
bit $20,(r1)
beq 1f
stfps (r1)+
movf fr0,(r1)+
movf fr4,fr0
movf fr0,(r1)+
movf fr5,fr0
movf fr0,(r1)+
movf fr1,(r1)+
movf fr2,(r1)+
movf fr3,(r1)+
1:
.endif
rts pc
.globl _incupc
_incupc:
mov r2,-(sp)
mov 6(sp),r2 / base of prof with base,leng,off,scale
mov 4(sp),r0 / pc
sub 4(r2),r0 / offset
clc
ror r0
mul 6(r2),r0 / scale
ashc $-14.,r0
inc r1
bic $1,r1
cmp r1,2(r2) / length
bhis 1f
add (r2),r1 / base
mov nofault,-(sp)
mov $2f,nofault
mfpd (r1)
inc (sp)
mtpd (r1)
br 3f
2:
clr 6(r2)
3:
mov (sp)+,nofault
1:
mov (sp)+,r2
rts pc
.globl _display
_display:
dec dispdly
bge 2f
clr dispdly
mov PS,-(sp)
mov $HIPRI,PS
mov CSW,r1
bit $1,r1
beq 1f
bis $30000,PS
dec r1
1:
jsr pc,fuword
mov r0,CSW
mov (sp)+,PS
cmp r0,$-1
bne 2f
mov $120.,dispdly / 2 sec delay after CSW fault
2:
rts pc
/ Character list get/put
.globl _getc, _putc
.globl _cfreelist
_getc:
mov 2(sp),r1
mov PS,-(sp)
mov r2,-(sp)
spl 5
mov 2(r1),r2 / first ptr
beq 9f / empty
movb (r2)+,r0 / character
bic $!377,r0
mov r2,2(r1)
dec (r1)+ / count
bne 1f
clr (r1)+
clr (r1)+ / last block
br 2f
1:
bit $7,r2
bne 3f
mov -10(r2),(r1) / next block
add $2,(r1)
2:
dec r2
bic $7,r2
mov _cfreelist,(r2)
mov r2,_cfreelist
3:
mov (sp)+,r2
mov (sp)+,PS
rts pc
9:
clr 4(r1)
mov $-1,r0
mov (sp)+,r2
mov (sp)+,PS
rts pc
_putc:
mov 2(sp),r0
mov 4(sp),r1
mov PS,-(sp)
mov r2,-(sp)
mov r3,-(sp)
spl 5
mov 4(r1),r2 / last ptr
bne 1f
mov _cfreelist,r2
beq 9f
mov (r2),_cfreelist
clr (r2)+
mov r2,2(r1) / first ptr
br 2f
1:
bit $7,r2
bne 2f
mov _cfreelist,r3
beq 9f
mov (r3),_cfreelist
mov r3,-10(r2)
mov r3,r2
clr (r2)+
2:
movb r0,(r2)+
mov r2,4(r1)
inc (r1) / count
clr r0
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,PS
rts pc
9:
mov pc,r0
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,PS
rts pc
.globl _backup
.globl _regloc
_backup:
mov 2(sp),r0
movb ssr+2,r1
jsr pc,1f
movb ssr+3,r1
jsr pc,1f
movb _regloc+7,r1
asl r1
add r0,r1
mov ssr+4,(r1)
clr r0
2:
rts pc
1:
mov r1,-(sp)
asr (sp)
asr (sp)
asr (sp)
bic $!7,r1
movb _regloc(r1),r1
asl r1
add r0,r1
sub (sp)+,(r1)
rts pc
.globl _fubyte, _subyte
.globl _fuword, _suword
.globl _fuibyte, _suibyte
.globl _fuiword, _suiword
_fuibyte:
mov 2(sp),r1
bic $1,r1
jsr pc,giword
br 2f
_fubyte:
mov 2(sp),r1
bic $1,r1
jsr pc,gword
2:
cmp r1,2(sp)
beq 1f
swab r0
1:
bic $!377,r0
rts pc
_suibyte:
mov 2(sp),r1
bic $1,r1
jsr pc,giword
mov r0,-(sp)
cmp r1,4(sp)
beq 1f
movb 6(sp),1(sp)
br 2f
1:
movb 6(sp),(sp)
2:
mov (sp)+,r0
jsr pc,piword
clr r0
rts pc
_subyte:
mov 2(sp),r1
bic $1,r1
jsr pc,gword
mov r0,-(sp)
cmp r1,4(sp)
beq 1f
movb 6(sp),1(sp)
br 2f
1:
movb 6(sp),(sp)
2:
mov (sp)+,r0
jsr pc,pword
clr r0
rts pc
_fuiword:
mov 2(sp),r1
fuiword:
jsr pc,giword
rts pc
_fuword:
mov 2(sp),r1
fuword:
jsr pc,gword
rts pc
giword:
mov PS,-(sp)
spl HIGH
mov nofault,-(sp)
mov $err,nofault
mfpi (r1)
mov (sp)+,r0
br 1f
gword:
mov PS,-(sp)
spl HIGH
mov nofault,-(sp)
mov $err,nofault
mfpd (r1)
mov (sp)+,r0
br 1f
_suiword:
mov 2(sp),r1
mov 4(sp),r0
suiword:
jsr pc,piword
rts pc
_suword:
mov 2(sp),r1
mov 4(sp),r0
suword:
jsr pc,pword
rts pc
piword:
mov PS,-(sp)
spl HIGH
mov nofault,-(sp)
mov $err,nofault
mov r0,-(sp)
mtpi (r1)
br 1f
pword:
mov PS,-(sp)
spl HIGH
mov nofault,-(sp)
mov $err,nofault
mov r0,-(sp)
mtpd (r1)
1:
mov (sp)+,nofault
mov (sp)+,PS
rts pc
err:
mov (sp)+,nofault
mov (sp)+,PS
tst (sp)+
mov $-1,r0
rts pc
.globl _copyin, _copyout
.globl _copyiin, _copyiout
_copyiin:
jsr pc,copsu
1:
mfpi (r0)+
mov (sp)+,(r1)+
sob r2,1b
br 2f
_copyin:
jsr pc,copsu
1:
mfpd (r0)+
mov (sp)+,(r1)+
sob r2,1b
br 2f
_copyiout:
jsr pc,copsu
1:
mov (r0)+,-(sp)
mtpi (r1)+
sob r2,1b
br 2f
_copyout:
jsr pc,copsu
1:
mov (r0)+,-(sp)
mtpd (r1)+
sob r2,1b
2:
mov (sp)+,nofault
mov (sp)+,r2
clr r0
rts pc
copsu:
mov (sp)+,r0
mov r2,-(sp)
mov nofault,-(sp)
mov r0,-(sp)
mov 10(sp),r0
mov 12(sp),r1
mov 14(sp),r2
asr r2
mov $1f,nofault
rts pc
1:
mov (sp)+,nofault
mov (sp)+,r2
mov $-1,r0
rts pc
.globl _idle
_idle:
mov PS,-(sp)
spl 0
wait
mov (sp)+,PS
rts pc
.globl _savu, _retu, _aretu
_savu:
spl HIGH
mov (sp)+,r1
mov (sp),r0
mov sp,(r0)+
mov r5,(r0)+
spl 0
jmp (r1)
_aretu:
spl 7
mov (sp)+,r1
mov (sp),r0
br 1f
_retu:
spl 7
mov (sp)+,r1
mov (sp),KDSA6
mov $_u,r0
1:
mov (r0)+,sp
mov (r0)+,r5
spl 0
jmp (r1)
.globl _spl0, _spl1, _spl4, _spl5, _spl6, _spl7
_spl0:
spl 0
rts pc
_spl1:
spl 1
rts pc
_spl4:
spl 4
rts pc
_spl5:
spl 5
rts pc
_spl6:
spl 6
rts pc
_spl7:
spl HIGH
rts pc
.globl _copyseg
_copyseg:
mov PS,-(sp)
mov 4(sp),SISA0
mov 6(sp),SISA1
mov $10000+HIPRI,PS
mov r2,-(sp)
clr r0
mov $8192.,r1
mov $32.,r2
1:
mfpd (r0)+
mtpd (r1)+
sob r2,1b
mov (sp)+,r2
mov (sp)+,PS
rts pc
.globl _clearseg
_clearseg:
mov PS,-(sp)
mov 4(sp),SISA0
mov $10000+HIPRI,PS
clr r0
mov $32.,r1
1:
clr -(sp)
mtpd (r0)+
sob r1,1b
mov (sp)+,PS
rts pc
.globl _dpadd
_dpadd:
mov 2(sp),r0
add 4(sp),2(r0)
adc (r0)
rts pc
.globl _dpcmp
_dpcmp:
mov 2(sp),r0
mov 4(sp),r1
sub 6(sp),r0
sub 8(sp),r1
sbc r0
bge 1f
cmp r0,$-1
bne 2f
cmp r1,$-512.
bhi 3f
2:
mov $-512.,r0
rts pc
1:
bne 2f
cmp r1,$512.
blo 3f
2:
mov $512.,r1
3:
mov r1,r0
rts pc
.globl _ldiv
_ldiv:
clr r0
mov 2(sp),r1
div 4(sp),r0
rts pc
.globl _lrem
_lrem:
clr r0
mov 2(sp),r1
div 4(sp),r0
mov r1,r0
rts pc
.globl _lshift
_lshift:
mov 2(sp),r1
mov (r1)+,r0
mov (r1),r1
ashc 4(sp),r0
mov r1,r0
rts pc
.globl csv
csv:
mov r5,r0
mov sp,r5
mov r4,-(sp)
mov r3,-(sp)
mov r2,-(sp)
jsr pc,(r0)
.globl cret
cret:
mov r5,r1
mov -(r1),r4
mov -(r1),r3
mov -(r1),r2
mov r5,sp
mov (sp)+,r5
rts pc
.globl _u
_u = 140000
usize = 16.
CSW = 177570
PS = 177776
SSR0 = 177572
SSR1 = 177574
SSR2 = 177576
SSR3 = 172516
KISA0 = 172340
KISA1 = 172342
KISA7 = 172356
KISD0 = 172300
KDSA0 = 172360
KDSA6 = 172374
KDSA7 = 172376
KDSD0 = 172320
MTC = 172522
SISA0 = 172240
SISA1 = 172242
SISD0 = 172200
SISD1 = 172202
IO = 177600
.data
.globl _ka6
.globl _cputype
_ka6: KDSA6
_cputype:45.
stk: 0
.bss
.globl nofault, ssr
nofault:.=.+2
ssr: .=.+6
dispdly:.=.+2
saveps: .=.+2
.text
/ system profiler
/
/rtt = 6
/CCSB = 172542
/CCSR = 172540
/PS = 177776
/
/.globl _sprof, _xprobuf, _probuf, _probsiz, _mode
/_probsiz = 7500.+2048.
/
/_isprof:
/ mov $_sprof,104 / interrupt
/ mov $340,106 / pri
/ mov $100.,CCSB / count set = 100
/ mov $113,CCSR / count down, 10kHz, repeat
/ rts pc
/
/_sprof:
/ mov r0,-(sp)
/ mov PS,r0
/ ash $-11.,r0
/ bic $!14,r0
/ add $1,_mode+2(r0)
/ adc _mode(r0)
/ cmp r0,$14 / user
/ beq done
/ mov 2(sp),r0 / pc
/ asr r0
/ asr r0
/ bic $140001,r0
/ cmp r0,$_probsiz
/ blo 1f
/ inc _outside
/ br done
/1:
/ inc _probuf(r0)
/ bne done
/ mov r1,-(sp)
/ mov $_xprobuf,r1
/2:
/ cmp (r1)+,r0
/ bne 3f
/ inc (r1)
/ br 4f
/3:
/ tst (r1)+
/ bne 2b
/ sub $4,r1
/ mov r0,(r1)+
/ mov $1,(r1)+
/4:
/ mov (sp)+,r1
/done:
/ mov (sp)+,r0
/ mov $113,CCSR
/ rtt
/
/.bss
/_xprobuf: .=.+512.
/_probuf:.=.+_probsiz
/_mode: .=.+16.
/_outside: .=.+2
sys/conf/mkconf.c
+540
View File
@@ -0,0 +1,540 @@
#define CHAR 01
#define BLOCK 02
#define INTR 04
#define EVEN 010
#define KL 020
#define ROOT 040
char *btab[]
{
"rk",
"rp",
"rf",
"tm",
"tc",
"hs",
"hp",
"ht",
0
};
char *ctab[]
{
"console",
"pc",
"lp",
"dc",
"dh",
"dp",
"dj",
"dn",
"mem",
"rk",
"rf",
"rp",
"tm",
"hs",
"hp",
"ht",
0
};
struct tab
{
char *name;
int count;
int address;
int key;
char *codea;
char *codeb;
char *codec;
char *coded;
char *codee;
} table[]
{
"console",
-1, 60, CHAR+INTR+KL,
"\tklin; br4\n\tklou; br4\n",
".globl\t_klrint\nklin:\tjsr\tr0,call; _klrint\n",
".globl\t_klxint\nklou:\tjsr\tr0,call; _klxint\n",
"",
"\t&klopen, &klclose, &klread, &klwrite, &klsgtty,",
"mem",
-1, 300, CHAR,
"",
"",
"",
"",
"\t&nulldev, &nulldev, &mmread, &mmwrite, &nodev,",
"pc",
0, 70, CHAR+INTR,
"\tpcin; br4\n\tpcou; br4\n",
".globl\t_pcrint\npcin:\tjsr\tr0,call; _pcrint\n",
".globl\t_pcpint\npcou:\tjsr\tr0,call; _pcpint\n",
"",
"\t&pcopen, &pcclose, &pcread, &pcwrite, &nodev,",
"clock",
-2, 100, INTR,
"\tkwlp; br6\n",
".globl\t_clock\n",
"kwlp:\tjsr\tr0,call; _clock\n",
"",
"",
"parity",
-1, 114, INTR,
"\ttrap; br7+7.\t\t/ 11/70 parity\n",
"",
"",
"",
"",
/*
* 110 unused
* 114 memory parity
* 120 XY plotter
* 124 DR11-B
* 130 AD01
* 134 AFC11
* 140 AA11
* 144 AA11
* 150-174 unused
*/
"lp",
0, 200, CHAR+INTR,
"\tlpou; br4\n",
"",
".globl\t_lpint\nlpou:\tjsr\tr0,call; _lpint\n",
"",
"\t&lpopen, &lpclose, &nodev, &lpwrite, &nodev,",
"rf",
0, 204, BLOCK+CHAR+INTR,
"\trfio; br5\n",
".globl\t_rfintr\n",
"rfio:\tjsr\tr0,call; _rfintr\n",
"\t&nulldev,\t&nulldev,\t&rfstrategy, \t&rftab,",
"\t&nulldev, &nulldev, &rfread, &rfwrite, &nodev,",
"hs",
0, 204, BLOCK+CHAR+INTR,
"\thsio; br5\n",
".globl\t_hsintr\n",
"hsio:\tjsr\tr0,call; _hsintr\n",
"\t&nulldev,\t&nulldev,\t&hsstrategy, \t&hstab,",
"\t&nulldev, &nulldev, &hsread, &hswrite, &nodev,",
/*
* 210 RC
*/
"tc",
0, 214, BLOCK+INTR,
"\ttcio; br6\n",
".globl\t_tcintr\n",
"tcio:\tjsr\tr0,call; _tcintr\n",
"\t&nulldev,\t&tcclose,\t&tcstrategy, \t&tctab,",
"",
"rk",
0, 220, BLOCK+CHAR+INTR,
"\trkio; br5\n",
".globl\t_rkintr\n",
"rkio:\tjsr\tr0,call; _rkintr\n",
"\t&nulldev,\t&nulldev,\t&rkstrategy, \t&rktab,",
"\t&nulldev, &nulldev, &rkread, &rkwrite, &nodev,",
"tm",
0, 224, BLOCK+CHAR+INTR,
"\ttmio; br5\n",
".globl\t_tmintr\n",
"tmio:\tjsr\tr0,call; _tmintr\n",
"\t&tmopen,\t&tmclose,\t&tmstrategy, \t&tmtab,",
"\t&tmopen, &tmclose, &tmread, &tmwrite, &nodev,",
"ht",
0, 224, BLOCK+CHAR+INTR,
"\thtio; br5\n",
".globl\t_htintr\n",
"htio:\tjsr\tr0,call; _htintr\n",
"\t&htopen,\t&htclose,\t&htstrategy, \t&httab,",
"\t&htopen, &htclose, &htread, &htwrite, &nodev,",
"cr",
0, 230, CHAR+INTR,
"\tcrin; br6\n",
"",
".globl\t_crint\ncrin:\tjsr\tr0,call; _crint\n",
"",
"\t&cropen, &crclose, &crread, &nodev, &nodev,",
/*
* 234 UDC11
*/
"rp",
0, 254, BLOCK+CHAR+INTR,
"\trpio; br5\n",
".globl\t_rpintr\n",
"rpio:\tjsr\tr0,call; _rpintr\n",
"\t&nulldev,\t&nulldev,\t&rpstrategy, \t&rptab,",
"\t&nulldev, &nulldev, &rpread, &rpwrite, &nodev,",
"hp",
0, 254, BLOCK+CHAR+INTR,
"\thpio; br5\n",
".globl\t_hpintr\n",
"hpio:\tjsr\tr0,call; _hpintr\n",
"\t&hpopen,\t&nulldev,\t&hpstrategy, \t&hptab,",
"\t&hpopen, &nulldev, &hpread, &hpwrite, &nodev,",
/*
* 260 TA11
* 264-274 unused
*/
"dc",
0, 308, CHAR+INTR,
"\tdcin; br5+%d.\n\tdcou; br5+%d.\n",
".globl\t_dcrint\ndcin:\tjsr\tr0,call; _dcrint\n",
".globl\t_dcxint\ndcou:\tjsr\tr0,call; _dcxint\n",
"",
"\t&dcopen, &dcclose, &dcread, &dcwrite, &dcsgtty,",
"kl",
0, 308, INTR+KL,
"\tklin; br4+%d.\n\tklou; br4+%d.\n",
"",
"",
"",
"",
"dp",
0, 308, CHAR+INTR,
"\tdpin; br6+%d.\n\tdpou; br6+%d.\n",
".globl\t_dprint\ndpin:\tjsr\tr0,call; _dprint\n",
".globl\t_dpxint\ndpou:\tjsr\tr0,call; _dpxint\n",
"",
"\t&dpopen, &dpclose, &dpread, &dpwrite, &nodev,",
/*
* DM11-A
*/
"dn",
0, 304, CHAR+INTR,
"\tdnou; br5+%d.\n",
"",
".globl\t_dnint\ndnou:\tjsr\tr0,call; _dnint\n",
"",
"\t&dnopen, &dnclose, &nodev, &dnwrite, &nodev,",
"dhdm",
0, 304, INTR,
"\tdmin; br4+%d.\n",
"",
".globl\t_dmint\ndmin:\tjsr\tr0,call; _dmint\n",
"",
"",
/*
* DR11-A+
* DR11-C+
* PA611+
* PA611+
* DT11+
* DX11+
*/
"dl",
0, 308, INTR+KL,
"\tklin; br4+%d.\n\tklou; br4+%d.\n",
"",
"",
"",
"",
/*
* DJ11
*/
"dh",
0, 308, CHAR+INTR+EVEN,
"\tdhin; br5+%d.\n\tdhou; br5+%d.\n",
".globl\t_dhrint\ndhin:\tjsr\tr0,call; _dhrint\n",
".globl\t_dhxint\ndhou:\tjsr\tr0,call; _dhxint\n",
"",
"\t&dhopen, &dhclose, &dhread, &dhwrite, &dhsgtty,",
/*
* GT40
* LPS+
* VT20
*/
0
};
char *stra[]
{
"/ low core",
"",
"br4 = 200",
"br5 = 240",
"br6 = 300",
"br7 = 340",
"",
". = 0^.",
"\tbr\t1f",
"\t4",
"",
"/ trap vectors",
"\ttrap; br7+0.\t\t/ bus error",
"\ttrap; br7+1.\t\t/ illegal instruction",
"\ttrap; br7+2.\t\t/ bpt-trace trap",
"\ttrap; br7+3.\t\t/ iot trap",
"\ttrap; br7+4.\t\t/ power fail",
"\ttrap; br7+5.\t\t/ emulator trap",
"\ttrap; br7+6.\t\t/ system entry",
"",
". = 40^.",
".globl\tstart, dump",
"1:\tjmp\tstart",
"\tjmp\tdump",
"",
0,
};
char *strb[]
{
"",
". = 240^.",
"\ttrap; br7+7.\t\t/ programmed interrupt",
"\ttrap; br7+8.\t\t/ floating point",
"\ttrap; br7+9.\t\t/ segmentation violation",
0
};
char *strc[]
{
"",
"/ floating vectors",
". = 300^.",
0,
};
char *strd[]
{
"",
"//////////////////////////////////////////////////////",
"/\t\tinterface code to C",
"//////////////////////////////////////////////////////",
"",
".globl\tcall, trap",
0
};
char *stre[]
{
"/*",
" */",
"",
"int\t(*bdevsw[])()",
"{",
0,
};
char *strf[]
{
"\t0",
"};",
"",
"int\t(*cdevsw[])()",
"{",
0,
};
char *strg[]
{
"\t0",
"};",
"",
"int\trootdev\t{(%d<<8)|0};",
"int\tswapdev\t{(%d<<8)|0};",
"int\tswplo\t4000;\t/* cannot be zero */",
"int\tnswap\t872;",
0,
};
int fout;
int root -1;
main()
{
register struct tab *p;
register *q;
int i, n, ev, nkl;
int flagf, flagb;
while(input());
/*
* pass1 -- create interrupt vectors
*/
nkl = 0;
flagf = flagb = 1;
fout = creat("l.s", 0666);
puke(stra);
for(p=table; p->name; p++)
if(p->count != 0 && p->key & INTR) {
if(p->address>240 && flagb) {
flagb = 0;
puke(strb);
}
if(p->address >= 300) {
if(flagf) {
ev = 0;
flagf = 0;
puke(strc);
}
if(p->key & EVEN && ev & 07) {
printf("\t.=.+4\n");
ev =+ 4;
}
ev =+ p->address - 300;
} else
printf("\n. = %d^.\n", p->address);
n = p->count;
if(n < 0)
n = -n;
for(i=0; i<n; i++)
if(p->key & KL) {
printf(p->codea, nkl, nkl);
nkl++;
} else
printf(p->codea, i, i);
}
if(flagb)
puke(strb);
puke(strd);
for(p=table; p->name; p++)
if(p->count != 0 && p->key & INTR)
printf("\n%s%s", p->codeb, p->codec);
flush();
close(fout);
/*
* pass 2 -- create configuration table
*/
fout = creat("c.c", 0666);
puke(stre);
for(i=0; q=btab[i]; i++) {
for(p=table; p->name; p++)
if(equal(q, p->name) &&
(p->key&BLOCK) && p->count) {
printf("%s\t/* %s */\n", p->coded, q);
if(p->key & ROOT)
root = i;
goto newb;
}
printf("\t&nodev,\t\t&nodev,\t\t&nodev,\t\t0,\t/* %s */\n", q);
newb:;
}
puke(strf);
for(i=0; q=ctab[i]; i++) {
for(p=table; p->name; p++)
if(equal(q, p->name) &&
(p->key&CHAR) && p->count) {
printf("%s\t/* %s */\n", p->codee, q);
goto newc;
}
printf("\t&nodev, &nodev, &nodev, &nodev, &nodev,\t/* %s */\n", q);
newc:;
}
puke(strg, root);
flush();
close(fout);
if(root < 0)
write(2, "no block device given\n", 22);
}
puke(s, a)
char **s;
{
char *c;
while(c = *s++) {
printf(c, a);
printf("\n");
}
}
input()
{
char line[100];
register char *p;
register struct tab *q;
register n;
p = line;
while((n=getchar()) != '\n') {
if(n == 0)
return(0);
if(n == ' ' || n == '\t')
continue;
*p++ = n;
}
*p++ = 0;
n = 0;
p = line;
while(*p>='0' && *p<='9') {
n =* 10;
n =+ *p++ - '0';
}
if(n == 0)
n = 1;
if(*p == 0)
return(1);
for(q=table; q->name; q++)
if(equal(q->name, p)) {
if(root < 0 && (q->key&BLOCK)) {
root = 0;
q->key =| ROOT;
}
if(q->count < 0) {
printf("%s: no more, no less\n", p);
return(1);
}
q->count =+ n;
if(q->address < 300 && q->count > 1) {
q->count = 1;
printf("%s: only one\n", p);
}
return(1);
}
if(equal(p, "done"))
return(0);
printf("%s: cannot find\n", p);
return(1);
}
equal(a, b)
char *a, *b;
{
while(*a++ == *b)
if(*b++ == 0)
return(1);
return(0);
}
getchar()
{
int c;
c = 0;
read(0, &c, 1);
return(c);
}
sys/conf/sysfix
Executable
BIN
View File
Binary file not shown.
sys/conf/sysfix.c
+146
View File
@@ -0,0 +1,146 @@
/*
* fix system image for I/D space
* Move data down to 0; move text to 4K.
* Also put the data at the start of the
* file and the text after it.
*/
int tbuf[259];
int rbuf[259];
int obuf[259];
int txtsiz;
int datsiz;
int bsssiz;
int symsiz;
int txtrel 8192;
int datrel;
main(argc, argv)
char **argv;
{
register word, rel, s;
if (argc<3) {
printf("Arg count\n");
exit(1);
}
if ((tbuf[0] = open(argv[1], 0)) < 0) {
printf("Input file\n");
exit(1);
}
rbuf[0] = open(argv[1], 0);
if ((fcreat(argv[2], obuf)) < 0) {
printf("Output file\n");
exit(1);
}
if (getw(tbuf) != 0407) {
printf("Bad input format\n");
exit(1);
}
putw(0407, obuf);
txtsiz = getw(tbuf);
datsiz = getw(tbuf);
bsssiz = getw(tbuf);
symsiz = getw(tbuf);
getw(tbuf);
getw(tbuf);
if (getw(tbuf) != 0) {
printf("No relocation bits\n");
exit(1);
}
putw(txtsiz, obuf);
putw(datsiz, obuf);
putw(bsssiz, obuf);
putw(symsiz, obuf);
putw(0, obuf);
putw(0, obuf);
putw(1, obuf);
datrel = -txtsiz;
/*
* Copy out data first
*/
tbuf[1] = 0;
seek(tbuf[0], 020+txtsiz, 0);
seek(rbuf[0], 020+txtsiz, 0);
seek(rbuf[0], txtsiz, 1);
seek(rbuf[0], datsiz, 1);
s = datsiz >> 1;
while (s--) {
word = getw(tbuf);
rel = getw(rbuf);
if (rel&01)
word =- datrel;
word =+ getrel(rel);
putw(word, obuf);
}
/*
* Now to the text.
*/
rbuf[1] = 0;
tbuf[1] = 0;
seek(rbuf[0], 020+txtsiz, 0);
seek(rbuf[0], datsiz, 1);
seek(tbuf[0], 020, 0);
s = txtsiz >> 1;
while(s--) {
rel = getw(rbuf);
word = getw(tbuf);
if (rel&01)
word =- txtrel;
word =+ getrel(rel);
putw(word, obuf);
}
/*
* The symbol table.
*/
tbuf[1] = 0;
seek(tbuf[0], 020+txtsiz, 0);
seek(tbuf[0], txtsiz, 1);
seek(tbuf[0], datsiz, 1);
seek(tbuf[0], datsiz, 1);
s = symsiz;
while ((s =- 12) >= 0) {
putw(getw(tbuf), obuf);
putw(getw(tbuf), obuf);
putw(getw(tbuf), obuf);
putw(getw(tbuf), obuf);
rel = getw(tbuf);
putw(rel, obuf);
word = getw(tbuf);
switch(rel&07) {
case 2:
word =+ txtrel;
break;
case 3:
case 4:
word =+ datrel;
}
putw(word, obuf);
}
fflush(obuf);
close(obuf[0]);
exit(0);
}
getrel(r)
{
switch (r&016) {
case 02: /* ref to text */
return(txtrel);
case 04: /* ref to data */
case 06: /* ref to bss */
return(datrel);
case 0:
return(0);
default:
printf("Bad relocation %o\n", r);
return(0);
}
}