Initial revision
This commit is contained in:
keie
parent
61c04182b8
commit
166bccd1b5
298
etc/ip_spec.t
Normal file
298
etc/ip_spec.t
Normal file
|
|
@ -0,0 +1,298 @@
|
|||
aar mwPo 1 34
|
||||
adf sP 1 35
|
||||
adi mwPo 2 36
|
||||
adp 2 38
|
||||
adp mPo 2 39
|
||||
adp sP 1 41
|
||||
adp sN 1 42
|
||||
ads mwPo 1 43
|
||||
and mwPo 1 44
|
||||
asp mwPo 5 45
|
||||
asp swP 1 50
|
||||
beq 2 51
|
||||
beq sP 1 52
|
||||
bge sP 1 53
|
||||
bgt sP 1 54
|
||||
ble sP 1 55
|
||||
blm sP 1 56
|
||||
blt sP 1 57
|
||||
bne sP 1 58
|
||||
bra 2 59
|
||||
bra sN 2 60
|
||||
bra sP 2 62
|
||||
cal mPo 28 64
|
||||
cal sP 1 92
|
||||
cff - 93
|
||||
cif - 94
|
||||
cii - 95
|
||||
cmf sP 1 96
|
||||
cmi mwPo 2 97
|
||||
cmp - 99
|
||||
cms sP 1 100
|
||||
csa mwPo 1 101
|
||||
csb mwPo 1 102
|
||||
dec - 103
|
||||
dee sw 1 104
|
||||
del swN 1 105
|
||||
dup mwPo 1 106
|
||||
dvf sP 1 107
|
||||
dvi mwPo 1 108
|
||||
fil 2 109
|
||||
inc - 110
|
||||
ine w2 111
|
||||
ine sw 1 112
|
||||
inl mwN 3 113
|
||||
inl swN 1 116
|
||||
inn sP 1 117
|
||||
ior mwPo 1 118
|
||||
ior sP 1 119
|
||||
lae 2 120
|
||||
lae sw 7 121
|
||||
lal P2 128
|
||||
lal N2 129
|
||||
lal m 1 130
|
||||
lal mN 1 131
|
||||
lal swP 1 132
|
||||
lal swN 2 133
|
||||
lar mwPo 1 135
|
||||
ldc mP 1 136
|
||||
lde w2 137
|
||||
lde sw 1 138
|
||||
ldl mP 1 139
|
||||
ldl swN 1 140
|
||||
lfr mwPo 2 141
|
||||
lfr sP 1 143
|
||||
lil swN 1 144
|
||||
lil swP 1 145
|
||||
lil mwP 2 146
|
||||
lin 2 148
|
||||
lin sP 1 149
|
||||
lni - 150
|
||||
loc 2 151
|
||||
loc mP 34 0
|
||||
loc mN 1 152
|
||||
loc sP 1 153
|
||||
loc sN 1 154
|
||||
loe w2 155
|
||||
loe sw 5 156
|
||||
lof 2 161
|
||||
lof mwPo 4 162
|
||||
lof sP 1 166
|
||||
loi 2 167
|
||||
loi mPo 1 168
|
||||
loi mwPo 4 169
|
||||
loi sP 1 173
|
||||
lol wP2 174
|
||||
lol wN2 175
|
||||
lol mwP 4 176
|
||||
lol mwN 8 180
|
||||
lol swP 1 188
|
||||
lol swN 1 189
|
||||
lxa mPo 1 190
|
||||
lxl mPo 2 191
|
||||
mlf sP 1 193
|
||||
mli mwPo 2 194
|
||||
rck mwPo 1 196
|
||||
ret mwP 2 197
|
||||
ret sP 1 199
|
||||
rmi mwPo 1 200
|
||||
sar mwPo 1 201
|
||||
sbf sP 1 202
|
||||
sbi mwPo 2 203
|
||||
sdl swN 1 205
|
||||
set sP 1 206
|
||||
sil swN 1 207
|
||||
sil swP 1 208
|
||||
sli mwPo 1 209
|
||||
ste w2 210
|
||||
ste sw 3 211
|
||||
stf 2 214
|
||||
stf mwPo 2 215
|
||||
stf sP 1 217
|
||||
sti mPo 1 218
|
||||
sti mwPo 4 219
|
||||
sti sP 1 223
|
||||
stl wP2 224
|
||||
stl wN2 225
|
||||
stl mwP 2 226
|
||||
stl mwN 5 228
|
||||
stl swN 1 233
|
||||
teq - 234
|
||||
tgt - 235
|
||||
tlt - 236
|
||||
tne - 237
|
||||
zeq 2 238
|
||||
zeq sP 2 239
|
||||
zer sP 1 241
|
||||
zge sP 1 242
|
||||
zgt sP 1 243
|
||||
zle sP 1 244
|
||||
zlt sP 1 245
|
||||
zne sP 1 246
|
||||
zne sN 1 247
|
||||
zre w2 248
|
||||
zre sw 1 249
|
||||
zrl mwN 2 250
|
||||
zrl swN 1 252
|
||||
zrl wN2 253
|
||||
aar e2 0
|
||||
aar e- 1
|
||||
adf e2 2
|
||||
adf e- 3
|
||||
adi e2 4
|
||||
adi e- 5
|
||||
ads e2 6
|
||||
ads e- 7
|
||||
adu e2 8
|
||||
adu e- 9
|
||||
and e2 10
|
||||
and e- 11
|
||||
asp ew2 12
|
||||
ass e2 13
|
||||
ass e- 14
|
||||
bge e2 15
|
||||
bgt e2 16
|
||||
ble e2 17
|
||||
blm e2 18
|
||||
bls e2 19
|
||||
bls e- 20
|
||||
blt e2 21
|
||||
bne e2 22
|
||||
cai e- 23
|
||||
cal e2 24
|
||||
cfi e- 25
|
||||
cfu e- 26
|
||||
ciu e- 27
|
||||
cmf e2 28
|
||||
cmf e- 29
|
||||
cmi e2 30
|
||||
cmi e- 31
|
||||
cms e2 32
|
||||
cms e- 33
|
||||
cmu e2 34
|
||||
cmu e- 35
|
||||
com e2 36
|
||||
com e- 37
|
||||
csa e2 38
|
||||
csa e- 39
|
||||
csb e2 40
|
||||
csb e- 41
|
||||
cuf e- 42
|
||||
cui e- 43
|
||||
cuu e- 44
|
||||
dee ew2 45
|
||||
del ewP2 46
|
||||
del ewN2 47
|
||||
dup e2 48
|
||||
dus e2 49
|
||||
dus e- 50
|
||||
dvf e2 51
|
||||
dvf e- 52
|
||||
dvi e2 53
|
||||
dvi e- 54
|
||||
dvu e2 55
|
||||
dvu e- 56
|
||||
fef e2 57
|
||||
fef e- 58
|
||||
fif e2 59
|
||||
fif e- 60
|
||||
inl ewP2 61
|
||||
inl ewN2 62
|
||||
inn e2 63
|
||||
inn e- 64
|
||||
ior e2 65
|
||||
ior e- 66
|
||||
lar e2 67
|
||||
lar e- 68
|
||||
ldc e2 69
|
||||
ldf e2 70
|
||||
ldl ewP2 71
|
||||
ldl ewN2 72
|
||||
lfr e2 73
|
||||
lil ewP2 74
|
||||
lil ewN2 75
|
||||
lim e- 76
|
||||
los e2 77
|
||||
los e- 78
|
||||
lor esP 1 79
|
||||
lpi e2 80
|
||||
lxa e2 81
|
||||
lxl e2 82
|
||||
mlf e2 83
|
||||
mlf e- 84
|
||||
mli e2 85
|
||||
mli e- 86
|
||||
mlu e2 87
|
||||
mlu e- 88
|
||||
mon e- 89
|
||||
ngf e2 90
|
||||
ngf e- 91
|
||||
ngi e2 92
|
||||
ngi e- 93
|
||||
nop e- 94
|
||||
rck e2 95
|
||||
rck e- 96
|
||||
ret e2 97
|
||||
rmi e2 98
|
||||
rmi e- 99
|
||||
rmu e2 100
|
||||
rmu e- 101
|
||||
rol e2 102
|
||||
rol e- 103
|
||||
ror e2 104
|
||||
ror e- 105
|
||||
rtt e- 106
|
||||
sar e2 107
|
||||
sar e- 108
|
||||
sbf e2 109
|
||||
sbf e- 110
|
||||
sbi e2 111
|
||||
sbi e- 112
|
||||
sbs e2 113
|
||||
sbs e- 114
|
||||
sbu e2 115
|
||||
sbu e- 116
|
||||
sde e2 117
|
||||
sdf e2 118
|
||||
sdl ewP2 119
|
||||
sdl ewN2 120
|
||||
set e2 121
|
||||
set e- 122
|
||||
sig e- 123
|
||||
sil ewP2 124
|
||||
sil ewN2 125
|
||||
sim e- 126
|
||||
sli e2 127
|
||||
sli e- 128
|
||||
slu e2 129
|
||||
slu e- 130
|
||||
sri e2 131
|
||||
sri e- 132
|
||||
sru e2 133
|
||||
sru e- 134
|
||||
sti e2 135
|
||||
sts e2 136
|
||||
sts e- 137
|
||||
str esP 1 138
|
||||
tge e- 139
|
||||
tle e- 140
|
||||
trp e- 141
|
||||
xor e2 142
|
||||
xor e- 143
|
||||
zer e2 144
|
||||
zer e- 145
|
||||
zge e2 146
|
||||
zgt e2 147
|
||||
zle e2 148
|
||||
zlt e2 149
|
||||
zne e2 150
|
||||
zrf e2 151
|
||||
zrf e- 152
|
||||
zrl ewP2 153
|
||||
dch e- 154
|
||||
exg esP 1 155
|
||||
exg e2 156
|
||||
exg e- 157
|
||||
lpb e- 158
|
||||
gto e2 159
|
||||
ldc 4 0
|
||||
77
util/ass/Makefile
Normal file
77
util/ass/Makefile
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
d=../..
|
||||
l=$d/lib
|
||||
h=$d/h
|
||||
ASS_PATH=$l/em_ass
|
||||
|
||||
SEP_OPT=-i
|
||||
|
||||
CFLAGS=-O
|
||||
|
||||
all: ass$(SEP_OPT)
|
||||
|
||||
clean:
|
||||
-rm -f ass-i ass-n *.o maktab *.old asstb.c
|
||||
|
||||
install : all
|
||||
cp ass$(SEP_OPT) $(ASS_PATH)
|
||||
|
||||
cmp : all
|
||||
cmp ass$(SEP_OPT) $(ASS_PATH)
|
||||
|
||||
lint: ass00.c ass30.c ass40.c ass50.c ass60.c ass70.c \
|
||||
ass80.c assci.c assda.c assrl.c asstb.c asscm.c
|
||||
lint -hpvbx \
|
||||
ass00.c ass30.c ass40.c ass50.c ass60.c ass70.c \
|
||||
ass80.c assci.c assda.c assrl.c asstb.c asscm.c
|
||||
|
||||
|
||||
ass-n: ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
|
||||
ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
|
||||
$l/em_data.a
|
||||
cc -n $(CFLAGS) -o ass-n \
|
||||
ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
|
||||
ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
|
||||
$l/em_data.a
|
||||
|
||||
ass-i: ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
|
||||
ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
|
||||
$l/em_data.a
|
||||
cc -i $(CFLAGS) -o ass-i \
|
||||
ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
|
||||
ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
|
||||
$l/em_data.a
|
||||
|
||||
ass00.o ass40.o ass60.o ass70.o ass80.o assrl.c: \
|
||||
$h/local.h $h/em_spec.h $h/as_spec.h \
|
||||
$h/em_flag.h $h/arch.h ass00.h assex.h
|
||||
|
||||
assci.o: $h/local.h $h/em_spec.h $h/as_spec.h \
|
||||
$h/em_flag.h $h/em_mes.h $h/em_pseu.h \
|
||||
$h/em_ptyp.h $h/arch.h ass00.h assex.h
|
||||
|
||||
ass30.o ass50.o : \
|
||||
$h/local.h $h/em_spec.h $h/as_spec.h \
|
||||
$h/em_flag.h ip_spec.h ass00.h assex.h
|
||||
|
||||
ass80.o: $h/em_path.h
|
||||
|
||||
assda.o: $h/local.h $h/em_spec.h $h/as_spec.h \
|
||||
$h/em_flag.h $h/arch.h ass00.h
|
||||
|
||||
asscm.o: ass00.h
|
||||
|
||||
asstb.o: asstb.c
|
||||
|
||||
asstb.c: maktab ip_spec.t
|
||||
maktab ip_spec.t asstb.c
|
||||
|
||||
maktab: maktab.c $h/em_spec.h ip_spec.h $h/em_flag.h \
|
||||
$l/em_data.a
|
||||
cc -O -o maktab maktab.c $l/em_data.a
|
||||
|
||||
opr:
|
||||
make pr ^ opr
|
||||
|
||||
pr:
|
||||
@(pr ass00.h assex.h ip_spec.h ass?0.c ass[rcd]?.c \
|
||||
maktab.c ; pr -3 ip_spec.t)
|
||||
371
util/ass/ass30.c
Normal file
371
util/ass/ass30.c
Normal file
|
|
@ -0,0 +1,371 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
#include "ip_spec.h"
|
||||
|
||||
short opt_line ; /* max_line_no - # lines removed from end
|
||||
after perfoming exc's.
|
||||
Used to estimate the distance in # of
|
||||
instructions.
|
||||
*/
|
||||
/*
|
||||
** Determine the exact instruction length & format where possible, and the
|
||||
** the upper and lower limits otherwise. Enter limits in labeltable
|
||||
*/
|
||||
pass_3()
|
||||
{
|
||||
register line_t *lnp, *rev_lnp;
|
||||
line_t *tmp_lnp;
|
||||
locl_t *lbp;
|
||||
int min_l, max_l, min_bytes;
|
||||
short last_line ;
|
||||
short hol_err_line ;
|
||||
register insno ;
|
||||
|
||||
pass = 3;
|
||||
opt_line= line_num ; hol_err_line=0 ;
|
||||
min_bytes = max_bytes = 0; rev_lnp= lnp_cast 0 ;
|
||||
for (lnp = pstate.s_fline ; lnp ; opt_line--, line_num-- ) {
|
||||
pstate.s_fline= lnp;
|
||||
insno = ctrunc(lnp->instr_num);
|
||||
switch( insno ) {
|
||||
case sp_fpseu :
|
||||
last_line = line_num ;
|
||||
line_num = lnp->ad.ad_ln.ln_first ;
|
||||
opt_line -= lnp->ad.ad_ln.ln_extra ;
|
||||
lnp->ad.ad_ln.ln_first= last_line ;
|
||||
break ;
|
||||
case sp_ilb1 :
|
||||
lbp = lnp->ad.ad_lp;
|
||||
lbp->l_defined = SEEN;
|
||||
lbp->l_min = min_bytes;
|
||||
lbp->l_max = max_bytes;
|
||||
break ;
|
||||
default:
|
||||
if ( lnp->type1==CONST && (em_flag[insno]&EM_PAR)==PAR_G ) {
|
||||
if (holbase != 0) {
|
||||
lnp->ad.ad_i += holbase;
|
||||
if (lnp->ad.ad_i >= holsize) {
|
||||
hol_err_line= line_num ;
|
||||
}
|
||||
}
|
||||
} else
|
||||
if ( lnp->type1>=VALLOW && (em_flag[insno]&EM_PAR)==PAR_G ) {
|
||||
if (holbase != 0) {
|
||||
pstate.s_fline= lnp->l_next ;
|
||||
newline(CONST) ;
|
||||
pstate.s_fline->instr_num= insno ;
|
||||
pstate.s_fline->ad.ad_i=
|
||||
VAL1(lnp->type1)+holbase ;
|
||||
freearea((area_t)lnp,
|
||||
(unsigned)linesize[VALLOW]) ;
|
||||
lnp= pstate.s_fline ;
|
||||
if ( VAL1(lnp->type1) >= holsize) {
|
||||
hol_err_line= line_num ;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !valid(lnp) ) fatal("Invalid operand") ;
|
||||
|
||||
determine_props(lnp, &min_l, &max_l);
|
||||
min_bytes += min_l; max_bytes += max_l;
|
||||
break ;
|
||||
}
|
||||
tmp_lnp= lnp->l_next ;
|
||||
lnp->l_next= rev_lnp ; rev_lnp= lnp ;
|
||||
lnp= tmp_lnp ;
|
||||
}
|
||||
pstate.s_fline= rev_lnp ;
|
||||
if ( hol_err_line ) {
|
||||
line_num= hol_err_line ;
|
||||
werror("address exceeds holsize") ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Determine the format that should be used for each instruction,
|
||||
** depending on its offsets
|
||||
*/
|
||||
|
||||
determine_props(lnp, min_len, max_len)
|
||||
line_t *lnp;
|
||||
int *min_len, *max_len;
|
||||
{
|
||||
cons_t val ;
|
||||
register int insno ;
|
||||
register char *f_off, *l_off ;
|
||||
char defined ;
|
||||
|
||||
insno=ctrunc(lnp->instr_num) ;
|
||||
val=parval(lnp,&defined) ;
|
||||
if ( !defined ) {
|
||||
switch(em_flag[insno]&EM_PAR) {
|
||||
case PAR_NO:
|
||||
case PAR_W:
|
||||
f_off = findnop(insno) ;
|
||||
break ;
|
||||
case PAR_G:
|
||||
/* We want the maximum address that is a multiple
|
||||
of the wordsize.
|
||||
Assumption: there is no shortie for
|
||||
intr max_word_multiple
|
||||
where intr is a instruction allowing parameters
|
||||
that are not a word multiple (PAR_G).
|
||||
*/
|
||||
f_off = findfit(insno, maxadr&(~(wordsize-1))) ;
|
||||
break ;
|
||||
case PAR_B:
|
||||
f_off = findfit(insno, (cons_t)0) ;
|
||||
l_off = findfit(insno, val ) ;
|
||||
if ( f_off != l_off ) {
|
||||
*min_len=oplength(*f_off) ;
|
||||
*max_len=oplength(*l_off) ;
|
||||
lnp->opoff = NO_OFF ;
|
||||
return ;
|
||||
}
|
||||
break ;
|
||||
}
|
||||
} else {
|
||||
f_off = findfit(insno,val) ;
|
||||
}
|
||||
lnp->opoff = f_off ;
|
||||
*min_len = *max_len = oplength(*f_off) ;
|
||||
}
|
||||
|
||||
char *findfit(instr,val) int instr ; cons_t val ; {
|
||||
register char *currc,*endc ;
|
||||
int found, flags, number ;
|
||||
char *opc ;
|
||||
|
||||
endc = opindex[instr+1] ;
|
||||
for ( currc=opindex[instr], found=0 ;
|
||||
!found && currc<endc ; currc++ ) {
|
||||
opc = currc ;
|
||||
flags=ctrunc(*currc++) ;
|
||||
switch ( flags&OPTYPE ) {
|
||||
case OPNO :
|
||||
continue ;
|
||||
case OPMINI :
|
||||
case OPSHORT :
|
||||
number=ctrunc(*++currc) ;
|
||||
}
|
||||
found = opfit(flags, number, val, em_flag[instr]&EM_PAR ) ;
|
||||
}
|
||||
if ( !found ) fatal("Cannot find interpreter opcode") ;
|
||||
return opc ;
|
||||
}
|
||||
|
||||
char *findnop(instr) int instr ; {
|
||||
register char *currc,*endc ;
|
||||
|
||||
endc = opindex[instr+1] ;
|
||||
for ( currc=opindex[instr] ; currc<endc ; currc++ ) {
|
||||
switch ( ctrunc(*currc)&OPTYPE ) {
|
||||
case OPNO :
|
||||
return currc ;
|
||||
case OPSHORT :
|
||||
case OPMINI :
|
||||
currc++ ;
|
||||
}
|
||||
currc++ ;
|
||||
}
|
||||
fatal("Cannot find interpreter opcode") ;
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
int opfit(flag,number,val,i_flag)
|
||||
int i_flag,flag,number ; cons_t val ; {
|
||||
/* Number is invalid if flag does not contain MINI or SHORT */
|
||||
switch ( flag&OPRANGE ) {
|
||||
case OP_POS :
|
||||
if ( val<0 ) return 0 ;
|
||||
break ;
|
||||
case OP_NEG :
|
||||
if ( val>=0 ) return 0 ;
|
||||
break ;
|
||||
}
|
||||
if ( flag&OPWORD ) {
|
||||
if ( val%wordsize ) return 0 ;
|
||||
val /= wordsize ;
|
||||
}
|
||||
if ( flag&OPNZ ) {
|
||||
if ( val==0 ) return 0 ;
|
||||
val-- ;
|
||||
}
|
||||
switch ( flag&OPTYPE ) {
|
||||
case OPMINI :
|
||||
if ( val<0 ) val = -1-val ;
|
||||
return val>=0 && val<number ;
|
||||
case OPSHORT :
|
||||
if ( val<0 ) val = -1-val ;
|
||||
return val>=0 && val<number*256 ;
|
||||
case OP16 :
|
||||
if ( i_flag==PAR_G ) return val>=0 && val<=maxadr ;
|
||||
return val>= -32768 && val<=32767 ;
|
||||
case OP32 :
|
||||
return TRUE ;
|
||||
default :
|
||||
fatal("illegal OPTYPE value") ;
|
||||
/* NOTREACHED */
|
||||
}
|
||||
}
|
||||
|
||||
int oplength(flag) int flag ; {
|
||||
int cnt ;
|
||||
|
||||
cnt=1 ;
|
||||
if ( flag&OPESC ) cnt++ ;
|
||||
switch( flag&OPTYPE ) {
|
||||
case OPNO :
|
||||
case OPMINI : break ;
|
||||
case OP8 :
|
||||
case OPSHORT : cnt++ ; break ;
|
||||
case OP16 : cnt+=2 ; break ;
|
||||
case OP32 : cnt+=5 ; break ;
|
||||
case OP64 : cnt+=9 ; break ;
|
||||
}
|
||||
return cnt ;
|
||||
}
|
||||
|
||||
/*
|
||||
** return estimation of value of parameter
|
||||
*/
|
||||
cons_t parval(lnp,defined)
|
||||
line_t *lnp;
|
||||
char *defined;
|
||||
{
|
||||
register int type;
|
||||
register locl_t *lbp;
|
||||
register glob_t *gbp;
|
||||
cons_t offs ;
|
||||
|
||||
*defined = TRUE ;
|
||||
type = lnp->type1;
|
||||
switch(type) {
|
||||
default: if ( type>=VALLOW && type<=VALHIGH )
|
||||
return VAL1(type) ;
|
||||
error("bad type during parval");
|
||||
break;
|
||||
case CONST:
|
||||
return(lnp->ad.ad_i);
|
||||
case GLOSYM:
|
||||
case GLOOFF:
|
||||
if ( type!=GLOOFF) {
|
||||
gbp = lnp->ad.ad_gp;
|
||||
offs= 0 ;
|
||||
} else {
|
||||
gbp =lnp->ad.ad_df.df_gp ;
|
||||
offs=lnp->ad.ad_df.df_i ;
|
||||
}
|
||||
if(gbp->g_status&DEF)
|
||||
return(gbp->g_val.g_addr+offs);
|
||||
else {
|
||||
*defined = FALSE ;
|
||||
return offs ;
|
||||
}
|
||||
case LOCSYM:
|
||||
lbp = lnp->ad.ad_lp;
|
||||
switch(pass) {
|
||||
default:error("bad pass in parval");
|
||||
case 3:
|
||||
*defined = FALSE;
|
||||
switch(lbp->l_defined) {
|
||||
default : fatal("Illegal local label") ;
|
||||
case NO :
|
||||
error("Undefined local label") ;
|
||||
lbp->l_defined= NOTPRESENT ;
|
||||
case NOTPRESENT:
|
||||
return max_bytes;
|
||||
case SEEN :
|
||||
return max_bytes - lbp->l_min ;
|
||||
case YES :
|
||||
/* l_min contains line_num
|
||||
adjusted for exc's.
|
||||
*/
|
||||
return (lbp->l_min - opt_line -1 ) * maxinsl ;
|
||||
}
|
||||
case 4: if(lbp->l_defined == YES)
|
||||
return(lbp->l_min-prog_size-maxinsl);
|
||||
return max_bytes - lbp->l_max- prog_size;
|
||||
case 5: if (lbp->l_defined == YES )
|
||||
return lbp->l_min ;
|
||||
*defined = FALSE ;
|
||||
break ;
|
||||
}
|
||||
break;
|
||||
case MISSING:
|
||||
*defined = FALSE ;
|
||||
break;
|
||||
case PROCNAME:
|
||||
return(lnp->ad.ad_pp->p_num);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
int valid(lnp) register line_t *lnp ; {
|
||||
cons_t val ;
|
||||
char type ;
|
||||
|
||||
type = lnp->type1 ;
|
||||
if ( type>=VALLOW && type<=VALHIGH ) {
|
||||
val= VAL1(type) ;
|
||||
type= CONST ;
|
||||
} else if ( type==CONST ) val = lnp->ad.ad_i ;
|
||||
switch ( em_flag[ctrunc(lnp->instr_num)]&EM_PAR ) {
|
||||
case PAR_NO:
|
||||
return type==MISSING ;
|
||||
case PAR_C:
|
||||
if ( type!=CONST ) return FALSE;
|
||||
if ( val>maxint && val<=maxunsig ) {
|
||||
lnp->ad.ad_i = val -maxunsig -1 ;
|
||||
}
|
||||
return TRUE ;
|
||||
case PAR_D:
|
||||
if ( type!=CONST ) return FALSE;
|
||||
if ( val>maxdint && val<=maxdunsig ) {
|
||||
lnp->ad.ad_i = val -maxdunsig -1 ;
|
||||
}
|
||||
return TRUE ;
|
||||
case PAR_L:
|
||||
case PAR_F:
|
||||
return type==CONST ;
|
||||
case PAR_N:
|
||||
return type==CONST && val>=0 ;
|
||||
case PAR_G:
|
||||
return type==CONST || type==GLOSYM || type==GLOOFF ;
|
||||
case PAR_W:
|
||||
if ( type==MISSING ) return TRUE ;
|
||||
case PAR_S:
|
||||
return type==CONST && val>0 && val%wordsize==0 ;
|
||||
case PAR_Z:
|
||||
return type==CONST && val>=0 && val%wordsize==0 ;
|
||||
case PAR_O:
|
||||
return type==CONST && val>=0 &&
|
||||
( val >= wordsize ? val%wordsize : wordsize%val ) == 0 ;
|
||||
case PAR_P:
|
||||
return type==PROCNAME ;
|
||||
case PAR_B:
|
||||
return type==LOCSYM ;
|
||||
case PAR_R:
|
||||
return type==CONST && val>=0 && val<=3 ;
|
||||
default:
|
||||
fatal("Unknown parameter type") ;
|
||||
/* NOTREACHED */
|
||||
}
|
||||
}
|
||||
55
util/ass/ass40.c
Normal file
55
util/ass/ass40.c
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
/*
|
||||
** Make scans to do final assignment of instruction sizes & formats
|
||||
** to those not already done. assign final values to labels
|
||||
*/
|
||||
pass_4()
|
||||
{
|
||||
register line_t *lnp;
|
||||
register locl_t *lbp;
|
||||
int min_l, max_l;
|
||||
int instr;
|
||||
|
||||
pass = 4;
|
||||
prog_size= 0 ;
|
||||
for (lnp = pstate.s_fline ; lnp ; lnp= lnp->l_next, line_num++) {
|
||||
instr = ctrunc(lnp->instr_num);
|
||||
if ( instr==sp_fpseu ) {
|
||||
line_num = lnp->ad.ad_ln.ln_first ;
|
||||
continue ;
|
||||
}
|
||||
if ( instr==sp_ilb1 ) {
|
||||
lbp = lnp->ad.ad_lp;
|
||||
lbp->l_min= prog_size; lbp->l_defined = YES;
|
||||
continue ;
|
||||
}
|
||||
|
||||
if (lnp->opoff == NO_OFF)
|
||||
{
|
||||
determine_props(lnp, &min_l, &max_l);
|
||||
if (min_l != max_l)
|
||||
fatal("no size known");
|
||||
} else {
|
||||
min_l = oplength(*(lnp->opoff)) ;
|
||||
}
|
||||
prog_size += min_l ;
|
||||
}
|
||||
}
|
||||
190
util/ass/ass50.c
Normal file
190
util/ass/ass50.c
Normal file
|
|
@ -0,0 +1,190 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
#include "ip_spec.h"
|
||||
|
||||
/*
|
||||
** Pass 5 of EM1 assembler/loader
|
||||
** Fix reloc tables
|
||||
** Write out code
|
||||
*/
|
||||
|
||||
pass_5() {
|
||||
register line_t *lnp;
|
||||
cons_t off1;
|
||||
char defined ;
|
||||
int afterlength, partype ;
|
||||
register int inslength, ope;
|
||||
char *op_curr ;
|
||||
|
||||
pass = 5;
|
||||
afterlength = 0;
|
||||
for (lnp = pstate.s_fline ; lnp ; lnp= lnp->l_next, line_num++ ) {
|
||||
ope = ctrunc(lnp->instr_num);
|
||||
if ( ope==sp_ilb1 ) continue ;
|
||||
if ( ope==sp_fpseu ) {
|
||||
line_num = lnp->ad.ad_ln.ln_first ;
|
||||
continue ;
|
||||
}
|
||||
off1 = parval(lnp,&defined);
|
||||
if ( (op_curr = lnp->opoff)==NO_OFF ) {
|
||||
fatal("opoff assertion failed") ;
|
||||
}
|
||||
inslength = oplength(*op_curr) ;
|
||||
afterlength += inslength ;
|
||||
|
||||
/*
|
||||
* Change absolute offset to a relative for branches.
|
||||
*/
|
||||
|
||||
|
||||
partype= em_flag[ope]&EM_PAR ;
|
||||
if ( partype==PAR_B && defined ) {
|
||||
off1 -= afterlength;
|
||||
}
|
||||
|
||||
#ifdef JOHAN
|
||||
if ( jflag ) {
|
||||
extern char em_mnem[][4] ;
|
||||
printf("%s %D\n",em_mnem[ope],off1) ;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( !defined && partype==PAR_G ) { /* must be external */
|
||||
text_reloc((lnp->type1==GLOSYM ?
|
||||
lnp->ad.ad_gp:lnp->ad.ad_df.df_gp),
|
||||
(FOFFSET)(textbytes+afterlength-inslength) ,
|
||||
op_curr-opchoice);
|
||||
xputarb(inslength,off1,tfile);
|
||||
textoff += inslength ;
|
||||
} else {
|
||||
genop(op_curr,off1,partype) ;
|
||||
}
|
||||
} /* end forloop */
|
||||
line_num-- ;
|
||||
|
||||
patchcase();
|
||||
textbytes += prog_size;
|
||||
if ( textbytes>maxadr ) fatal("Maximum code area size exceeded") ;
|
||||
|
||||
} /* end pass_5 */
|
||||
|
||||
genop(startc,value,i_flag) char *startc ; cons_t value ; int i_flag ; {
|
||||
char *currc ;
|
||||
register flag ;
|
||||
char opc ;
|
||||
|
||||
/*
|
||||
* Real code generation.
|
||||
*/
|
||||
|
||||
currc= startc ;
|
||||
flag = ctrunc(*currc++);
|
||||
opc = *currc++;
|
||||
if ( (flag&OPTYPE)!=OPNO ) {
|
||||
|
||||
if ( !opfit(flag,*currc,value,i_flag) ) {
|
||||
fatal("parameter value unsuitable for selected opcode") ;
|
||||
}
|
||||
if ( flag&OPWORD ) {
|
||||
if ( value%wordsize!=0 ) {
|
||||
error("parameter not word multiple");
|
||||
}
|
||||
value /= wordsize ;
|
||||
}
|
||||
if ( flag&OPNZ ) {
|
||||
if ( value<=0 ) error("negative parameter");
|
||||
value-- ;
|
||||
}
|
||||
}
|
||||
if ( flag&OPESC ) put8(ESC) ;
|
||||
|
||||
switch ( flag&OPTYPE ) {
|
||||
case OPMINI :
|
||||
opc += value<0 ? -1-value : value ;
|
||||
break ;
|
||||
case OPSHORT :
|
||||
if ( value<0 ) {
|
||||
opc += -1-(value>>8) ;
|
||||
} else {
|
||||
opc += value>>8 ;
|
||||
}
|
||||
break ;
|
||||
case OP32 :
|
||||
case OP64 :
|
||||
put8(ESC_L) ;
|
||||
}
|
||||
|
||||
#ifdef DUMP
|
||||
if ( c_flag ) {
|
||||
switch(flag&OPTYPE) {
|
||||
case OP32 :
|
||||
case OP64 :
|
||||
opcnt3[opc&0377]= 1 ;
|
||||
break ;
|
||||
default :
|
||||
if ( flag&OPESC ) opcnt2[opc&0377]= 1 ;
|
||||
else opcnt1[opc&0377]= 1 ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
put8(opc) ;
|
||||
switch( flag&OPTYPE ) {
|
||||
case OPNO:
|
||||
case OPMINI:
|
||||
break ;
|
||||
case OPSHORT:
|
||||
case OP8:
|
||||
put8((char)value) ;
|
||||
break ;
|
||||
case OP16:
|
||||
put16(int_cast value) ;
|
||||
break ;
|
||||
case OP32:
|
||||
put32(value) ;
|
||||
break ;
|
||||
case OP64:
|
||||
put64(value) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
patchcase() {
|
||||
register relc_t *r;
|
||||
register locl_t *k;
|
||||
|
||||
if ( r= pstate.s_fdata ) {
|
||||
r= r->r_next ;
|
||||
} else {
|
||||
r= f_data ;
|
||||
}
|
||||
for( ; r ; r= r->r_next ) {
|
||||
if (r->r_typ == RELLOC) {
|
||||
r->r_typ = RELADR;
|
||||
k = r->r_val.rel_lp;
|
||||
if (k->l_defined==YES)
|
||||
r->r_val.rel_i = k->l_min + textbytes;
|
||||
else
|
||||
error("case label at line %d undefined",
|
||||
k->l_min);
|
||||
}
|
||||
}
|
||||
}
|
||||
211
util/ass/ass60.c
Normal file
211
util/ass/ass60.c
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
#include "ip_spec.h"
|
||||
|
||||
#ifdef DUMP
|
||||
static char *typestr[] =
|
||||
{"missing","const","procname","glosym","locsym","glosym+off","pseudo"};
|
||||
static char *labstr[] = {"EMPTY","no","yes","seen","notpresent"};
|
||||
static char formstr[] = { 'm','s','-','1','2','4','8' };
|
||||
static char *r_data[] = { "null","glob","head","loc","adr" };
|
||||
|
||||
cons_t nicepr(typ,ap) addr_u *ap; char typ; {
|
||||
register proc_t *pl;
|
||||
|
||||
switch (typ) {
|
||||
case CONST:
|
||||
return(ap->ad_i);
|
||||
case LOCSYM:
|
||||
return(int_cast ap->ad_lp);
|
||||
case GLOOFF:
|
||||
return(ap->ad_df.df_gp - mglobs);
|
||||
case GLOSYM:
|
||||
return(ap->ad_gp - mglobs);
|
||||
case PROCNAME:
|
||||
pl = ap->ad_pp;;
|
||||
if (pl->p_status&EXT)
|
||||
return((pl-xprocs)+1000);
|
||||
else
|
||||
return(pl-mprocs);
|
||||
default:
|
||||
if ( typ>=VALLOW && typ<=VALHIGH ) return VAL1(typ) ;
|
||||
break ;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
char *pflags(flg) int flg ; {
|
||||
static char res[9] ;
|
||||
register char *cp ;
|
||||
|
||||
cp=res ;
|
||||
if ( flg&OPESC ) *cp++ = 'e' ;
|
||||
switch ( flg&OPRANGE ) {
|
||||
case OP_NEG : *cp++ = 'N' ; break ;
|
||||
case OP_POS : *cp++ = 'P' ; break ;
|
||||
}
|
||||
if ( flg&OPWORD ) *cp++ = 'w' ;
|
||||
if ( flg&OPNZ ) *cp++ = 'o' ;
|
||||
*cp++ = formstr[flg&OPTYPE] ;
|
||||
*cp++ = 0 ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
|
||||
dump(n)
|
||||
{
|
||||
register glob_t *gb;
|
||||
register line_t *ln;
|
||||
register locl_t *lbp;
|
||||
register locl_t *lbhead;
|
||||
proc_t *pl;
|
||||
int i;
|
||||
int insno;
|
||||
extern char em_mnem[][4] ;
|
||||
|
||||
if (d_flag==0) return;
|
||||
if ( (n==0 && d_flag) || (n==4 && d_flag>=2) || (n<100 && d_flag>=3) ) {
|
||||
printf("\nEM1-assembler ***** pass %1d complete:\n",n);
|
||||
printf("current size %D\n",prog_size) ;
|
||||
printf(" %9.9s%9.9s%14.14s%8.8s%8.8s\n", "instr_nr",
|
||||
"type1","addr1","length","format");
|
||||
for (ln = pstate.s_fline ; ln ;
|
||||
ln = ln->l_next, n>=3 || n==0 ? i++ : i-- ) {
|
||||
insno = ctrunc(ln->instr_num) ;
|
||||
if ( insno==sp_fpseu ) {
|
||||
i= ln->ad.ad_ln.ln_first ;
|
||||
continue ;
|
||||
}
|
||||
printf("%4d ",i) ;
|
||||
switch(insno) {
|
||||
default:
|
||||
printf(
|
||||
" %3.3s",em_mnem[insno]) ;
|
||||
break ;
|
||||
case sp_ilb1:
|
||||
printf("l ");
|
||||
break;
|
||||
case sp_fpseu:
|
||||
printf("p ");
|
||||
break;
|
||||
}
|
||||
printf(" %9.9s%14D",
|
||||
typestr[ln->type1<VALLOW ? ln->type1 : CONST],
|
||||
nicepr(ln->type1,&ln->ad)) ;
|
||||
if ( ln->opoff != NO_OFF )
|
||||
printf("%5d %.6s",
|
||||
oplength(*(ln->opoff)),pflags(*(ln->opoff)));
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n %8s%8s%8s%8s%8s\n","labnum","labid","minval","maxval",
|
||||
"defined");
|
||||
for ( i = 0, lbhead= *pstate.s_locl ; i<LOCLABSIZE ; lbhead++,i++) {
|
||||
if ( lbhead->l_defined!=EMPTY ) printf("%4d\n",i);
|
||||
for (lbp= lbhead; lbp != lbp_cast 0; lbp= lbp->l_chain) {
|
||||
if (lbp->l_defined!=EMPTY)
|
||||
printf(" %8d%8d%8d%8d %-s\n",
|
||||
lbp->l_hinum*LOCLABSIZE + i,
|
||||
int_cast lbp,lbp->l_min,
|
||||
lbp->l_max, labstr[lbp->l_defined]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( ( (n==0 || n>=100) && d_flag) || (n<=1 && d_flag>=2) ) {
|
||||
if ( n==0 || n==100 ) {
|
||||
printf("File %s",curfile) ;
|
||||
if ( archmode ) printf("(%.14s)",archhdr.ar_name);
|
||||
printf(" :\n\n") ;
|
||||
}
|
||||
printf("Local data labels:\n");
|
||||
printf(
|
||||
"\n\t%8.8s %8.8s %8.8s\n","g_name","g_status","g_addr");
|
||||
for (gb = mglobs,i = 0;gb < &mglobs[oursize->n_mlab]; gb++, i++)
|
||||
if (gb->g_name[0] != 0) {
|
||||
printf("%5d\t%8.6s",i,gb->g_name);
|
||||
printf(" %8o %8ld\n",gb->g_status,gb->g_val.g_addr);
|
||||
}
|
||||
printf("\n\nGlobal data labels\n");
|
||||
printf("\n\t%8.8s %8.8s %8.8s\n",
|
||||
"g_name","g_status","g_addr");
|
||||
for (gb = xglobs,i = 0;gb < &xglobs[oursize->n_glab]; gb++, i++)
|
||||
if (gb->g_name[0] != 0) {
|
||||
printf("%5d\t%8.6s",i,gb->g_name);
|
||||
printf(" %8o %8ld\n",gb->g_status,gb->g_val.g_addr);
|
||||
}
|
||||
printf("\n\nLocal procedures\n");
|
||||
printf("\n\t%8.8s%8s%8s\t%8s%8s\n",
|
||||
"name","status","num","off","locals");
|
||||
for (pl=mprocs;pl< &mprocs[oursize->n_mproc]; pl++)
|
||||
if (pl->p_name[0]) {
|
||||
printf("%4d\t%-8s%8o%8d",
|
||||
pl-mprocs,pl->p_name,pl->p_status,pl->p_num);
|
||||
if (pl->p_status&DEF)
|
||||
printf("\t%8ld%8ld",proctab[pl->p_num].pr_off,
|
||||
proctab[pl->p_num].pr_loc);
|
||||
printf("\n");
|
||||
}
|
||||
printf("\nGlobal procedures\n");
|
||||
printf("\n\t%8s%8s%8s\t%8s%8s\n",
|
||||
"name","status","num","off","locals");
|
||||
for (pl=xprocs;pl< &xprocs[oursize->n_xproc]; pl++)
|
||||
if (pl->p_name[0]) {
|
||||
printf("%4d\t%-8s%8o%8d",
|
||||
pl-xprocs,pl->p_name,pl->p_status,pl->p_num);
|
||||
if (pl->p_status&DEF)
|
||||
printf("\t%8ld%8ld",proctab[pl->p_num].pr_off,
|
||||
proctab[pl->p_num].pr_loc);
|
||||
printf("\n");
|
||||
}
|
||||
if ( r_flag ) {
|
||||
register relc_t *rl ;
|
||||
printf("\nData relocation\n") ;
|
||||
printf("\n\t%10s %10s %10s\n","offset","type","value");
|
||||
for ( rl=f_data ; rl ; rl= rl->r_next ) {
|
||||
printf("\t%10D %10s ",rl->r_off,r_data[rl->r_typ]);
|
||||
switch(rl->r_typ) {
|
||||
case RELADR:
|
||||
case RELHEAD:
|
||||
printf("%10D\n",rl->r_val.rel_i) ;
|
||||
break ;
|
||||
case RELGLO:
|
||||
printf("%8.8s\n",rl->r_val.rel_gp->g_name) ;
|
||||
break ;
|
||||
case RELLOC:
|
||||
printf("%10d\n",rl->r_val.rel_lp) ;
|
||||
break ;
|
||||
case RELNULL:
|
||||
printf("\n"); break ;
|
||||
}
|
||||
}
|
||||
printf("\n\nText relocation\n") ;
|
||||
printf("\n\t%10s %10s %10s\n","offset","flags","value");
|
||||
for ( rl=f_text; rl ; rl= rl->r_next ) {
|
||||
printf("\t%10D %10s ",
|
||||
rl->r_off,pflags(opchoice[rl->r_typ&~RELMNS])) ;
|
||||
if ( rl->r_typ&RELMNS )
|
||||
printf("%10D\n",rl->r_val.rel_i) ;
|
||||
else printf("\n") ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
341
util/ass/ass70.c
Normal file
341
util/ass/ass70.c
Normal file
|
|
@ -0,0 +1,341 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
/*
|
||||
** utilities of EM1-assembler/loader
|
||||
*/
|
||||
|
||||
static int globstep;
|
||||
|
||||
/*
|
||||
* glohash returns an index in table and leaves a stepsize in globstep
|
||||
*
|
||||
*/
|
||||
|
||||
static int glohash(aname,size) char *aname; {
|
||||
register char *p;
|
||||
register i;
|
||||
register sum;
|
||||
|
||||
/*
|
||||
* Computes a hash-value from a string.
|
||||
* Algorithm is adding all the characters after shifting some way.
|
||||
*/
|
||||
|
||||
for(sum=i=0,p=aname;*p;i += 3)
|
||||
sum += (*p++)<<(i&07);
|
||||
sum &= 077777;
|
||||
globstep = (sum / size) + 7;
|
||||
return(sum % size);
|
||||
}
|
||||
|
||||
/*
|
||||
* lookup idname in labeltable , if it is not there enter it
|
||||
* return index in labeltable
|
||||
*/
|
||||
|
||||
glob_t *glo2lookup(name,status) char *name; {
|
||||
|
||||
return(glolookup(name,status,mglobs,oursize->n_mlab));
|
||||
}
|
||||
|
||||
glob_t *xglolookup(name,status) char *name; {
|
||||
|
||||
return(glolookup(name,status,xglobs,oursize->n_glab));
|
||||
}
|
||||
|
||||
static void findext(g) glob_t *g ; {
|
||||
glob_t *x;
|
||||
|
||||
x = xglolookup(g->g_name,ENTERING);
|
||||
if (x && (x->g_status&DEF)) {
|
||||
g->g_status |= DEF;
|
||||
g->g_val.g_addr = x->g_val.g_addr;
|
||||
}
|
||||
g->g_status |= EXT;
|
||||
}
|
||||
|
||||
glob_t *glolookup(name,status,table,size)
|
||||
char *name; /* name */
|
||||
int status; /* kind of lookup */
|
||||
glob_t *table; /* which table to use */
|
||||
int size; /* size for hash */
|
||||
{
|
||||
register glob_t *g;
|
||||
register rem,j;
|
||||
int new;
|
||||
|
||||
/*
|
||||
* lookup global symbol name in specified table.
|
||||
* Various actions are taken depending on status.
|
||||
*
|
||||
* DEFINING:
|
||||
* Lookup or enter the symbol, check for mult. def.
|
||||
* OCCURRING:
|
||||
* Lookup the symbol, export if not known.
|
||||
* INTERNING:
|
||||
* Enter symbol local to the module.
|
||||
* EXTERNING:
|
||||
* Enter symbol visable from every module.
|
||||
* SEARCHING:
|
||||
* Lookup the symbol, return 0 if not found.
|
||||
* ENTERING:
|
||||
* Lookup or enter the symbol, don't check
|
||||
*/
|
||||
|
||||
rem = glohash(name,size);
|
||||
j = 0; new=0;
|
||||
g = &table[rem];
|
||||
while (g->g_name[0] != 0 && strcmp(name,g->g_name) != 0) {
|
||||
j++;
|
||||
if (j>size)
|
||||
fatal("global label table overflow");
|
||||
rem = (rem + globstep) % size;
|
||||
g = &table[rem];
|
||||
}
|
||||
if (g->g_name[0] == 0) {
|
||||
/*
|
||||
* This symbol is shining new.
|
||||
* Enter it in table except for status = SEARCHING
|
||||
*/
|
||||
if (status == SEARCHING)
|
||||
return(0);
|
||||
strcpy(g->g_name,name);
|
||||
g->g_status = 0;
|
||||
g->g_val.g_addr=0;
|
||||
new++;
|
||||
}
|
||||
switch(status) {
|
||||
case SEARCHING: /* nothing special */
|
||||
case ENTERING:
|
||||
break;
|
||||
case INTERNING:
|
||||
if (!new)
|
||||
werror("INA must be first occurrence of '%s'",name);
|
||||
break;
|
||||
case EXTERNING: /* lookup in other table */
|
||||
/*
|
||||
* The If statement is removed to be friendly
|
||||
* to Backend writers having to deal with assemblers
|
||||
* not following our conventions.
|
||||
if (!new)
|
||||
error("EXA must be first occurrence of '%s'",name);
|
||||
*/
|
||||
findext(g);
|
||||
break;
|
||||
case DEFINING: /* Thou shalt not redefine */
|
||||
if (g->g_status&DEF)
|
||||
error("global symbol '%s' redefined",name);
|
||||
g->g_status |= DEF;
|
||||
break;
|
||||
case OCCURRING:
|
||||
if ( new )
|
||||
findext(g);
|
||||
g->g_status |= OCC;
|
||||
break;
|
||||
default:
|
||||
fatal("bad status in glolookup");
|
||||
}
|
||||
return(g);
|
||||
}
|
||||
|
||||
locl_t *loclookup(an,status) {
|
||||
register locl_t *lbp,*l_lbp;
|
||||
register unsigned num;
|
||||
char hinum;
|
||||
|
||||
if ( !pstate.s_locl ) fatal("label outside procedure");
|
||||
num = an;
|
||||
if ( num/LOCLABSIZE>255 ) fatal("local label number too large");
|
||||
hinum = num/LOCLABSIZE;
|
||||
l_lbp= lbp= &(*pstate.s_locl)[num%LOCLABSIZE];
|
||||
if ( lbp->l_defined==EMPTY ) {
|
||||
lbp= lbp_cast 0 ;
|
||||
} else {
|
||||
while ( lbp!= lbp_cast 0 && lbp->l_hinum != hinum ) {
|
||||
l_lbp = lbp ;
|
||||
lbp = lbp->l_chain;
|
||||
}
|
||||
}
|
||||
if ( lbp == lbp_cast 0 ) {
|
||||
if ( l_lbp->l_defined!=EMPTY ) {
|
||||
lbp = lbp_cast getarea(sizeof *lbp);
|
||||
l_lbp->l_chain= lbp ;
|
||||
} else lbp= l_lbp ;
|
||||
lbp->l_chain= lbp_cast 0 ;
|
||||
lbp->l_hinum=hinum;
|
||||
lbp->l_defined = (status==OCCURRING ? NO : YES);
|
||||
lbp->l_min= line_num;
|
||||
} else
|
||||
if (status == DEFINING) {
|
||||
if (lbp->l_defined == YES)
|
||||
error("multiple defined local symbol");
|
||||
else
|
||||
lbp->l_defined = YES;
|
||||
}
|
||||
if ( status==DEFINING ) lbp->l_min= line_num ;
|
||||
return(lbp);
|
||||
}
|
||||
|
||||
proc_t *prolookup(name,status) char *name; {
|
||||
register proc_t *p;
|
||||
register pstat;
|
||||
|
||||
/*
|
||||
* Look up a procedure name according to status
|
||||
*
|
||||
* PRO_OCC: Occurrence
|
||||
* Search both tables, local table first.
|
||||
* If not found, enter in global table
|
||||
* PRO_INT: INP
|
||||
* Enter symbol in local table.
|
||||
* PRO_DEF: Definition
|
||||
* Define local procedure.
|
||||
* PRO_EXT: EXP
|
||||
* Enter symbol in global table.
|
||||
*
|
||||
* The EXT bit in this table indicates the the name is used
|
||||
* as external in this module.
|
||||
*/
|
||||
|
||||
switch(status) {
|
||||
case PRO_OCC:
|
||||
p = searchproc(name,mprocs,oursize->n_mproc);
|
||||
if (p->p_name[0]) {
|
||||
p->p_status |= OCC;
|
||||
return(p);
|
||||
}
|
||||
p = searchproc(name,xprocs,oursize->n_xproc);
|
||||
if (p->p_name[0]) {
|
||||
p->p_status |= OCC;
|
||||
return(p);
|
||||
}
|
||||
pstat = OCC|EXT;
|
||||
unresolved++ ;
|
||||
break;
|
||||
case PRO_INT:
|
||||
p = searchproc(name,xprocs,oursize->n_xproc);
|
||||
if (p->p_name[0] && (p->p_status&EXT) )
|
||||
error("pro '%s' conflicting use",name);
|
||||
|
||||
p = searchproc(name,mprocs,oursize->n_mproc);
|
||||
if (p->p_name[0])
|
||||
werror("INP must be first occurrence of '%s'",name);
|
||||
pstat = 0;
|
||||
break;
|
||||
case PRO_EXT:
|
||||
p = searchproc(name,mprocs,oursize->n_mproc);
|
||||
if (p->p_name[0])
|
||||
error("pro '%s' exists already localy",name);
|
||||
p = searchproc(name,xprocs,oursize->n_xproc);
|
||||
if (p->p_name[0]) {
|
||||
/*
|
||||
* The If statement is removed to be friendly
|
||||
* to Backend writers having to deal with assemblers
|
||||
* not following our conventions.
|
||||
if ( p->p_status&EXT )
|
||||
werror("EXP must be first occurrence of '%s'",
|
||||
name) ;
|
||||
*/
|
||||
p->p_status |= EXT;
|
||||
return(p);
|
||||
}
|
||||
pstat = EXT;
|
||||
unresolved++;
|
||||
break;
|
||||
case PRO_DEF:
|
||||
p = searchproc(name,xprocs,oursize->n_xproc);
|
||||
if (p->p_name[0] && (p->p_status&EXT) ) {
|
||||
if (p->p_status&DEF)
|
||||
error("global pro '%s' redeclared",name);
|
||||
else
|
||||
unresolved-- ;
|
||||
p->p_status |= DEF;
|
||||
return(p);
|
||||
} else {
|
||||
p = searchproc(name,mprocs,oursize->n_mproc);
|
||||
if (p->p_name[0]) {
|
||||
if (p->p_status&DEF)
|
||||
error("local pro '%s' redeclared",
|
||||
name);
|
||||
p->p_status |= DEF;
|
||||
return(p);
|
||||
}
|
||||
}
|
||||
pstat = DEF;
|
||||
break;
|
||||
default:
|
||||
fatal("bad status in prolookup");
|
||||
}
|
||||
return(enterproc(name,pstat,p));
|
||||
}
|
||||
|
||||
proc_t *searchproc(name,table,size)
|
||||
char *name;
|
||||
proc_t *table;
|
||||
int size;
|
||||
{
|
||||
register proc_t *p;
|
||||
register rem,j;
|
||||
|
||||
/*
|
||||
* return a pointer into table to the place where the procedure
|
||||
* name is or should be if in the table.
|
||||
*/
|
||||
|
||||
rem = glohash(name,size);
|
||||
j = 0;
|
||||
p = &table[rem];
|
||||
while (p->p_name[0] != 0 && strcmp(name,p->p_name) != 0) {
|
||||
j++;
|
||||
if (j>size)
|
||||
fatal("procedure table overflow");
|
||||
rem = (rem + globstep) % size;
|
||||
p = &table[rem];
|
||||
}
|
||||
return(p);
|
||||
}
|
||||
|
||||
proc_t *enterproc(name,status,place)
|
||||
char *name;
|
||||
char status;
|
||||
proc_t *place; {
|
||||
register proc_t *p;
|
||||
|
||||
/*
|
||||
* Enter the procedure name into the table at place place.
|
||||
* Place had better be computed by searchproc().
|
||||
*
|
||||
* NOTE:
|
||||
* At this point the procedure gets assigned a number.
|
||||
* This number is used as a parameter of cal and in some
|
||||
* other ways. There exists a 1-1 correspondence between
|
||||
* procedures and numbers.
|
||||
* Two local procedures with the same name in different
|
||||
* modules have different numbers.
|
||||
*/
|
||||
|
||||
p=place;
|
||||
strcpy(p->p_name,name);
|
||||
p->p_status = status;
|
||||
if (procnum>=oursize->n_proc)
|
||||
fatal("too many procedures");
|
||||
p->p_num = procnum++;
|
||||
return(p);
|
||||
}
|
||||
412
util/ass/ass80.c
Normal file
412
util/ass/ass80.c
Normal file
|
|
@ -0,0 +1,412 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
#include "../../h/em_path.h"
|
||||
|
||||
/*
|
||||
* this file contains several library routines.
|
||||
*/
|
||||
|
||||
zero(area,length) char *area; unsigned length ; {
|
||||
register char *p;
|
||||
register n;
|
||||
/*
|
||||
* Clear area of length bytes.
|
||||
*/
|
||||
if ((n=length)==0)
|
||||
return;
|
||||
p = area;
|
||||
do *p++=0; while (--n);
|
||||
}
|
||||
|
||||
/* VARARGS1 */
|
||||
static void pr_error(string1,a1,a2,a3,a4) char *string1 ; {
|
||||
/*
|
||||
* diagnostic output
|
||||
*/
|
||||
fprintf(stderr,"%s: ",progname);
|
||||
if (curfile) {
|
||||
fprintf(stderr,"file %s",curfile);
|
||||
if (archmode)
|
||||
fprintf(stderr," (%.14s)",archhdr.ar_name);
|
||||
fprintf(stderr,": ");
|
||||
}
|
||||
if ( pstate.s_curpro ) {
|
||||
fprintf(stderr,"proc %s, ",pstate.s_curpro->p_name);
|
||||
}
|
||||
fprintf(stderr,"line %d: ",line_num);
|
||||
fprintf(stderr,string1,a1,a2,a3,a4);
|
||||
fprintf(stderr,"\n");
|
||||
}
|
||||
|
||||
/* VARARGS1 */
|
||||
void error(string1,a1,a2,a3,a4) char *string1 ; {
|
||||
pr_error(string1,a1,a2,a3,a4) ;
|
||||
nerrors++ ;
|
||||
}
|
||||
|
||||
/* VARARGS1 */
|
||||
void werror(string1,a1,a2,a3,a4) char *string1 ; {
|
||||
if ( wflag ) return ;
|
||||
pr_error(string1,a1,a2,a3,a4) ;
|
||||
}
|
||||
|
||||
fatal(s) char *s; {
|
||||
/*
|
||||
* handle fatal errors
|
||||
*/
|
||||
error("Fatal error: %s",s);
|
||||
dump(0);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
#ifndef CPM
|
||||
FILE *frewind(f) FILE *f ; {
|
||||
/* Rewind a file open for writing and open it for reading */
|
||||
/* Assumption, file descriptor is r/w */
|
||||
register FILE *tmp ;
|
||||
rewind(f);
|
||||
tmp=fdopen(dup(fileno(f)),"r");
|
||||
fclose(f);
|
||||
return tmp ;
|
||||
}
|
||||
#endif
|
||||
|
||||
int xgetc(af) register FILE *af; {
|
||||
register int nextc;
|
||||
/*
|
||||
* read next character; fatal if there isn't one
|
||||
*/
|
||||
nextc=fgetc(af) ;
|
||||
if ( feof(af) )
|
||||
fatal("unexpected end of file");
|
||||
return nextc ;
|
||||
}
|
||||
|
||||
xputc(c,af) register FILE *af; {
|
||||
/* output one character and scream if it gives an error */
|
||||
fputc(c,af) ;
|
||||
if ( ferror(af) ) fatal("write error") ;
|
||||
}
|
||||
|
||||
|
||||
putblk(stream,from,amount)
|
||||
register FILE *stream; register char *from ; register int amount ; {
|
||||
|
||||
for ( ; amount-- ; from++ ) {
|
||||
fputc(*from,stream) ;
|
||||
if ( ferror(stream) ) fatal("write error") ;
|
||||
}
|
||||
}
|
||||
|
||||
int getblk(stream,from,amount)
|
||||
register FILE *stream; register char *from ; register int amount ; {
|
||||
|
||||
for ( ; amount-- ; from++ ) {
|
||||
*from = fgetc(stream) ;
|
||||
if ( feof(stream) ) return 1 ;
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
||||
xput16(w,f) FILE *f; {
|
||||
/*
|
||||
* two times xputc
|
||||
*/
|
||||
xputc(w,f);
|
||||
xputc(w>>8,f);
|
||||
}
|
||||
|
||||
xputarb(l,w,f) int l ; cons_t w ; FILE *f ; {
|
||||
while ( l-- ) {
|
||||
xputc( int_cast w,f) ;
|
||||
w >>=8 ;
|
||||
}
|
||||
}
|
||||
|
||||
put8(n) {
|
||||
xputc(n,tfile);
|
||||
textoff++;
|
||||
}
|
||||
|
||||
put16(n) {
|
||||
/*
|
||||
* note reversed order of bytes.
|
||||
* this is done for faster interpretation.
|
||||
*/
|
||||
xputc(n>>8,tfile);
|
||||
xputc(n&0377,tfile);
|
||||
textoff += 2;
|
||||
}
|
||||
|
||||
put32(n) cons_t n ; {
|
||||
put16( int_cast (n>>16)) ;
|
||||
put16( int_cast n) ;
|
||||
}
|
||||
|
||||
put64(n) cons_t n ; {
|
||||
fatal("put64 called") ;
|
||||
}
|
||||
|
||||
int xget8() {
|
||||
/*
|
||||
* Read one byte from ifile.
|
||||
*/
|
||||
if (libeof && inpoff >= libeof)
|
||||
return EOF ;
|
||||
inpoff++;
|
||||
return fgetc(ifile) ;
|
||||
}
|
||||
|
||||
unsigned get8() {
|
||||
register int nextc;
|
||||
/*
|
||||
* Read one byte from ifile.
|
||||
*/
|
||||
nextc=xget8();
|
||||
if ( nextc==EOF ) {
|
||||
if (libeof)
|
||||
fatal("Tried to read past end of arentry\n");
|
||||
else
|
||||
fatal("end of file on input");
|
||||
}
|
||||
return nextc ;
|
||||
}
|
||||
|
||||
cons_t xgetarb(l,f) int l; FILE *f ; {
|
||||
cons_t val ;
|
||||
register int shift ;
|
||||
|
||||
shift=0 ; val=0 ;
|
||||
while ( l-- ) {
|
||||
val += ((cons_t)ctrunc(xgetc(f)))<<shift ;
|
||||
shift += 8 ;
|
||||
}
|
||||
return val ;
|
||||
}
|
||||
|
||||
ext8(b) {
|
||||
/*
|
||||
* Handle one byte of data.
|
||||
*/
|
||||
++dataoff;
|
||||
xputc(b,dfile);
|
||||
}
|
||||
|
||||
extword(w) cons_t w ; {
|
||||
/* Assemble the word constant w.
|
||||
* NOTE: The bytes are written low to high.
|
||||
*/
|
||||
register i ;
|
||||
for ( i=wordsize ; i-- ; ) {
|
||||
ext8( int_cast w) ;
|
||||
w >>= 8 ;
|
||||
}
|
||||
}
|
||||
|
||||
extarb(size,value) int size ; long value ; {
|
||||
/* Assemble the 'size' constant value.
|
||||
* The bytes are again written low to high.
|
||||
*/
|
||||
register i ;
|
||||
for ( i=size ; i-- ; ) {
|
||||
ext8( int_cast value ) ;
|
||||
value >>=8 ;
|
||||
}
|
||||
}
|
||||
|
||||
extadr(a) cons_t a ; {
|
||||
/* Assemble the word constant a.
|
||||
* NOTE: The bytes are written low to high.
|
||||
*/
|
||||
register i ;
|
||||
for ( i=ptrsize ; i-- ; ) {
|
||||
ext8( int_cast a) ;
|
||||
a >>= 8 ;
|
||||
}
|
||||
}
|
||||
|
||||
xputa(a,f) cons_t a ; FILE *f ; {
|
||||
/* Assemble the pointer constant a.
|
||||
* NOTE: The bytes are written low to high.
|
||||
*/
|
||||
register i ;
|
||||
for ( i=ptrsize ; i-- ; ) {
|
||||
xputc( int_cast a,f) ;
|
||||
a >>= 8 ;
|
||||
}
|
||||
}
|
||||
|
||||
cons_t xgeta(f) FILE *f ; {
|
||||
/* Read the pointer constant a.
|
||||
* NOTE: The bytes were written low to high.
|
||||
*/
|
||||
register i, shift ;
|
||||
cons_t val ;
|
||||
val = 0 ; shift=0 ;
|
||||
for ( i=ptrsize ; i-- ; ) {
|
||||
val += ((cons_t)xgetc(f))<<shift ;
|
||||
shift += 8 ;
|
||||
}
|
||||
return val ;
|
||||
}
|
||||
|
||||
#define MAXBYTE 255
|
||||
|
||||
int icount(size) {
|
||||
int amount ;
|
||||
amount=(dataoff-lastoff)/size ;
|
||||
if ( amount>MAXBYTE) fatal("Descriptor overflow");
|
||||
return amount ;
|
||||
}
|
||||
|
||||
setmode(mode) {
|
||||
|
||||
if (datamode==mode) { /* in right mode already */
|
||||
switch ( datamode ) {
|
||||
case DATA_CONST:
|
||||
if ( (dataoff-lastoff)/wordsize < MAXBYTE ) return ;
|
||||
break ;
|
||||
case DATA_BYTES:
|
||||
if ( dataoff-lastoff < MAXBYTE ) return ;
|
||||
break ;
|
||||
case DATA_IPTR:
|
||||
case DATA_DPTR:
|
||||
if ( (dataoff-lastoff)/ptrsize < MAXBYTE ) return ;
|
||||
break ;
|
||||
case DATA_ICON:
|
||||
case DATA_FCON:
|
||||
case DATA_UCON:
|
||||
break ;
|
||||
default:
|
||||
return ;
|
||||
}
|
||||
setmode(DATA_NUL) ; /* flush current descriptor */
|
||||
setmode(mode) ;
|
||||
return;
|
||||
}
|
||||
switch(datamode) { /* terminate current mode */
|
||||
case DATA_NUL:
|
||||
break; /* nothing to terminate */
|
||||
case DATA_CONST:
|
||||
lastheader->r_val.rel_i=icount(wordsize) ;
|
||||
lastheader->r_typ = RELHEAD;
|
||||
datablocks++;
|
||||
break;
|
||||
case DATA_BYTES:
|
||||
lastheader->r_val.rel_i=icount(1) ;
|
||||
lastheader->r_typ = RELHEAD;
|
||||
datablocks++;
|
||||
break;
|
||||
case DATA_DPTR:
|
||||
case DATA_IPTR:
|
||||
lastheader->r_val.rel_i=icount(ptrsize) ;
|
||||
lastheader->r_typ = RELHEAD;
|
||||
datablocks++;
|
||||
break;
|
||||
default:
|
||||
datablocks++;
|
||||
break;
|
||||
}
|
||||
datamode=mode;
|
||||
switch(datamode) {
|
||||
case DATA_NUL:
|
||||
break;
|
||||
case DATA_CONST:
|
||||
ext8(HEADCONST);
|
||||
lastheader=data_reloc( chp_cast 0,dataoff,RELNULL);
|
||||
ext8(0);
|
||||
lastoff=dataoff;
|
||||
break;
|
||||
case DATA_BYTES:
|
||||
ext8(HEADBYTE);
|
||||
lastheader=data_reloc( chp_cast 0,dataoff,RELNULL);
|
||||
ext8(0);
|
||||
lastoff=dataoff;
|
||||
break;
|
||||
case DATA_IPTR:
|
||||
ext8(HEADIPTR);
|
||||
lastheader=data_reloc( chp_cast 0,dataoff,RELNULL);
|
||||
ext8(0);
|
||||
lastoff=dataoff;
|
||||
break;
|
||||
case DATA_DPTR:
|
||||
ext8(HEADDPTR);
|
||||
lastheader=data_reloc( chp_cast 0,dataoff,RELNULL);
|
||||
ext8(0);
|
||||
lastoff=dataoff;
|
||||
break;
|
||||
case DATA_ICON:
|
||||
ext8(HEADICON) ;
|
||||
ext8( int_cast consiz) ;
|
||||
break;
|
||||
case DATA_FCON:
|
||||
ext8(HEADFCON) ;
|
||||
ext8( int_cast consiz) ;
|
||||
break;
|
||||
case DATA_UCON:
|
||||
ext8(HEADUCON) ;
|
||||
ext8( int_cast consiz) ;
|
||||
break;
|
||||
case DATA_REP:
|
||||
ext8(HEADREP) ;
|
||||
break ;
|
||||
default:
|
||||
fatal("Unknown mode in setmode") ;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef CPM
|
||||
int tmpfil() {
|
||||
register char *fname, *cpname ;
|
||||
char *sfname;
|
||||
register fildes,pid;
|
||||
static char name[80] = TMP_DIR ;
|
||||
int count;
|
||||
/*
|
||||
* This procedure returns a file-descriptor of a temporary
|
||||
* file valid for reading and writing.
|
||||
* After closing the tmpfil-descriptor the file is lost
|
||||
* Calling this routine frees the program from generating uniqe names.
|
||||
*/
|
||||
sfname = fname = "tmp.00000";
|
||||
count = 10;
|
||||
pid = getpid();
|
||||
fname += 4;
|
||||
while (pid!=0) {
|
||||
*fname++ = (pid&07) + '0';
|
||||
pid >>= 3;
|
||||
}
|
||||
*fname = 0;
|
||||
for ( fname=name ; *fname ; fname++ ) ;
|
||||
cpname=sfname ;
|
||||
while ( *fname++ = *cpname++ ) ;
|
||||
do {
|
||||
fname = name;
|
||||
if ((fildes = creat(fname, 0600)) < 0)
|
||||
if ((fildes = creat(fname=sfname, 0600)) < 0)
|
||||
return(-1);
|
||||
if (close(fildes) < 0)
|
||||
;
|
||||
} while((fildes = open(fname, 2)) < 0 && count--);
|
||||
if (unlink(fname) < 0)
|
||||
;
|
||||
return(fildes);
|
||||
}
|
||||
#endif
|
||||
847
util/ass/assci.c
Normal file
847
util/ass/assci.c
Normal file
|
|
@ -0,0 +1,847 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
#include "../../h/em_mes.h"
|
||||
#include "../../h/em_pseu.h"
|
||||
#include "../../h/em_ptyp.h"
|
||||
|
||||
/*
|
||||
* read compact code and fill in tables
|
||||
*/
|
||||
|
||||
static int tabval;
|
||||
static cons_t argval;
|
||||
|
||||
static int oksizes; /* MES EMX,.,. seen */
|
||||
|
||||
static enum m_type { CON, ROM, HOLBSS } memtype ;
|
||||
static int valtype; /* Transfer of type information between
|
||||
valsize ans putval
|
||||
*/
|
||||
|
||||
int table3(i) {
|
||||
|
||||
switch(i) {
|
||||
case sp_ilb1:
|
||||
tabval = get8();
|
||||
break;
|
||||
case sp_dlb1:
|
||||
make_string(get8());
|
||||
i= sp_dnam;
|
||||
break;
|
||||
case sp_dlb2:
|
||||
tabval = get16();
|
||||
if ( tabval<0 ) {
|
||||
error("illegal data label .%d",tabval);
|
||||
tabval=0 ;
|
||||
}
|
||||
make_string(tabval);
|
||||
i= sp_dnam;
|
||||
break;
|
||||
case sp_cst2:
|
||||
argval = get16();
|
||||
break;
|
||||
case sp_ilb2:
|
||||
tabval = get16();
|
||||
if ( tabval<0 ) {
|
||||
error("illegal instruction label %d",tabval);
|
||||
tabval=0 ;
|
||||
}
|
||||
i = sp_ilb1;
|
||||
break;
|
||||
case sp_cst4:
|
||||
i = sp_cst2;
|
||||
argval = get32();
|
||||
break;
|
||||
case sp_dnam:
|
||||
case sp_pnam:
|
||||
inident();
|
||||
break ;
|
||||
case sp_scon:
|
||||
getstring() ;
|
||||
break;
|
||||
case sp_doff:
|
||||
getarg(sym_ptyp);
|
||||
getarg(cst_ptyp);
|
||||
break;
|
||||
case sp_icon:
|
||||
case sp_ucon:
|
||||
case sp_fcon:
|
||||
getarg(cst_ptyp);
|
||||
consiz = argval;
|
||||
if ( consiz<wordsize ?
|
||||
wordsize%consiz!=0 : consiz%wordsize!=0 ) {
|
||||
fatal("illegal object size") ;
|
||||
}
|
||||
getstring();
|
||||
break;
|
||||
}
|
||||
return(i);
|
||||
}
|
||||
|
||||
int get16() {
|
||||
register int l_byte, h_byte;
|
||||
|
||||
l_byte = get8();
|
||||
h_byte = get8();
|
||||
if ( h_byte>=128 ) h_byte -= 256 ;
|
||||
return l_byte | (h_byte*256) ;
|
||||
}
|
||||
|
||||
cons_t get32() {
|
||||
register cons_t l;
|
||||
register int h_byte;
|
||||
|
||||
l = get8(); l |= (unsigned)get8()*256 ; l |= get8()*256L*256L ;
|
||||
h_byte = get8() ;
|
||||
if ( h_byte>=128 ) h_byte -= 256 ;
|
||||
return l | (h_byte*256L*256*256L) ;
|
||||
}
|
||||
|
||||
int table1() {
|
||||
register i;
|
||||
|
||||
i = xget8();
|
||||
if (i < sp_fmnem+sp_nmnem && i >= sp_fmnem) {
|
||||
tabval = i-sp_fmnem;
|
||||
return(sp_fmnem);
|
||||
}
|
||||
if (i < sp_fpseu+sp_npseu && i >= sp_fpseu) {
|
||||
tabval = i;
|
||||
return(sp_fpseu);
|
||||
}
|
||||
if (i < sp_filb0+sp_nilb0 && i >= sp_filb0) {
|
||||
tabval = i - sp_filb0;
|
||||
return(sp_ilb1);
|
||||
}
|
||||
return(table3(i));
|
||||
}
|
||||
|
||||
int table2() {
|
||||
register i;
|
||||
|
||||
i = get8();
|
||||
if (i < sp_fcst0+sp_ncst0 && i >= sp_fcst0) {
|
||||
argval = i - sp_zcst0;
|
||||
return(sp_cst2);
|
||||
}
|
||||
return(table3(i));
|
||||
}
|
||||
|
||||
int getarg(typset) {
|
||||
register t,argtyp;
|
||||
|
||||
argtyp = t = table2();
|
||||
t -= sp_fspec;
|
||||
t = 1 << t;
|
||||
if ((typset & t) == 0)
|
||||
error("bad argument type %d",argtyp);
|
||||
return(argtyp);
|
||||
}
|
||||
|
||||
cons_t getint() {
|
||||
getarg(cst_ptyp);
|
||||
return(argval);
|
||||
}
|
||||
|
||||
glob_t *getlab(status) {
|
||||
getarg(sym_ptyp);
|
||||
return(glo2lookup(string,status));
|
||||
}
|
||||
|
||||
char *inproname() {
|
||||
getarg(ptyp(sp_pnam));
|
||||
return(string);
|
||||
}
|
||||
|
||||
int needed() {
|
||||
register glob_t *g;
|
||||
register proc_t *p;
|
||||
|
||||
for(;;){
|
||||
switch ( table2() ) {
|
||||
case sp_dnam :
|
||||
if (g = xglolookup(string,SEARCHING)) {
|
||||
if ((g->g_status&DEF) != 0)
|
||||
continue ;
|
||||
} else continue ;
|
||||
break ;
|
||||
case sp_pnam :
|
||||
p = searchproc(string,xprocs,oursize->n_xproc);
|
||||
if (p->p_name[0]) {
|
||||
if ((p->p_status & DEF) != 0)
|
||||
continue ;
|
||||
} else continue ;
|
||||
break ;
|
||||
default :
|
||||
error("Unexpected byte after ms_ext") ;
|
||||
case sp_cend :
|
||||
return FALSE ;
|
||||
}
|
||||
while ( table2()!=sp_cend ) ;
|
||||
return TRUE ;
|
||||
}
|
||||
}
|
||||
|
||||
cons_t valsize() {
|
||||
switch(valtype=table2()) { /* valtype is used by putval */
|
||||
case sp_cst2:
|
||||
return wordsize ;
|
||||
case sp_ilb1:
|
||||
case sp_dnam:
|
||||
case sp_doff:
|
||||
case sp_pnam:
|
||||
return ptrsize ;
|
||||
case sp_scon:
|
||||
return strlngth ;
|
||||
case sp_fcon:
|
||||
case sp_icon:
|
||||
case sp_ucon:
|
||||
return consiz ;
|
||||
case sp_cend:
|
||||
return 0 ;
|
||||
default:
|
||||
fatal("value expected") ;
|
||||
/* NOTREACHED */
|
||||
}
|
||||
}
|
||||
|
||||
newline(type) {
|
||||
register line_t *n_lnp ;
|
||||
|
||||
if ( type>VALLOW ) type=VALLOW ;
|
||||
n_lnp = lnp_cast getarea((unsigned)linesize[type]) ;
|
||||
n_lnp->l_next = pstate.s_fline ;
|
||||
pstate.s_fline = n_lnp ;
|
||||
n_lnp->type1 = type ;
|
||||
n_lnp->opoff = NO_OFF ;
|
||||
}
|
||||
|
||||
read_compact() {
|
||||
|
||||
/*
|
||||
* read module in compact EM1 code
|
||||
*/
|
||||
init_module();
|
||||
pass = 1;
|
||||
eof_seen = 0;
|
||||
do {
|
||||
compact_line() ;
|
||||
line_num++;
|
||||
} while (!eof_seen) ;
|
||||
endproc() ; /* Throw away unwanted garbage */
|
||||
if ( mod_sizes ) end_module();
|
||||
/* mod_sizes is only false for rejected library modules */
|
||||
}
|
||||
|
||||
int compact_line() {
|
||||
register instr_no ;
|
||||
|
||||
/*
|
||||
* read one "line" of compact code.
|
||||
*/
|
||||
curglosym=0;
|
||||
switch (table1()) {
|
||||
default:
|
||||
fatal("unknown byte at start of \"line\""); /* NOTREACHED */
|
||||
case EOF:
|
||||
eof_seen++ ;
|
||||
while ( pstate.s_prevstat != pst_cast 0 ) {
|
||||
error("missing end") ; do_proc() ;
|
||||
}
|
||||
return ;
|
||||
case sp_fmnem:
|
||||
if ( pstate.s_curpro == prp_cast 0) {
|
||||
error("instruction outside procedure");
|
||||
}
|
||||
instr_no = tabval;
|
||||
if ( (em_flag[instr_no]&EM_PAR)==PAR_NO ) {
|
||||
newline(MISSING) ;
|
||||
pstate.s_fline->instr_num= instr_no ;
|
||||
return ;
|
||||
}
|
||||
/*
|
||||
* This instruction should have an opcode, so read it after
|
||||
* this switch.
|
||||
*/
|
||||
break;
|
||||
case sp_dnam:
|
||||
chkstart() ;
|
||||
align(wordsize) ;
|
||||
curglosym = glo2lookup(string,DEFINING);
|
||||
curglosym->g_val.g_addr = databytes;
|
||||
lastglosym = curglosym;
|
||||
setline() ; line_num++ ;
|
||||
if (table1() != sp_fpseu)
|
||||
fatal("no pseudo after global label");
|
||||
case sp_fpseu:
|
||||
inpseudo(tabval);
|
||||
setline() ;
|
||||
return ;
|
||||
case sp_ilb1:
|
||||
newline(LOCSYM) ;
|
||||
pstate.s_fline->ad.ad_lp = loclookup(tabval,DEFINING);
|
||||
pstate.s_fline->instr_num = sp_ilb1;
|
||||
return ;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now process argument
|
||||
*/
|
||||
|
||||
switch(table2()) {
|
||||
default:
|
||||
fatal("unknown byte at start of argument"); /*NOTREACHED*/
|
||||
case sp_cst2:
|
||||
if ( (em_flag[instr_no]&EM_PAR)==PAR_B ) {
|
||||
/* value indicates a label */
|
||||
newline(LOCSYM) ;
|
||||
pstate.s_fline->ad.ad_lp=
|
||||
loclookup((int)argval,OCCURRING) ;
|
||||
} else {
|
||||
if ( argval>=VAL1(VALLOW) && argval<=VAL1(VALHIGH)) {
|
||||
newline(VALLOW) ;
|
||||
pstate.s_fline->type1 = argval+VALMID ;
|
||||
} else {
|
||||
newline(CONST) ;
|
||||
pstate.s_fline->ad.ad_i = argval;
|
||||
pstate.s_fline->type1 = CONST;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case sp_ilb1:
|
||||
newline(LOCSYM) ;
|
||||
pstate.s_fline->ad.ad_lp = loclookup(tabval,OCCURRING);
|
||||
break;
|
||||
case sp_dnam:
|
||||
newline(GLOSYM) ;
|
||||
pstate.s_fline->ad.ad_gp = glo2lookup(string,OCCURRING);
|
||||
break;
|
||||
case sp_pnam:
|
||||
newline(PROCNAME) ;
|
||||
pstate.s_fline->ad.ad_pp=prolookup(string,PRO_OCC);
|
||||
break;
|
||||
case sp_cend:
|
||||
if ( (em_flag[instr_no]&EM_PAR)!=PAR_W ) {
|
||||
fatal("missing operand") ;
|
||||
}
|
||||
newline(MISSING) ;
|
||||
break ;
|
||||
case sp_doff:
|
||||
newline(GLOOFF) ;
|
||||
pstate.s_fline->ad.ad_df.df_i = argval ;
|
||||
pstate.s_fline->ad.ad_df.df_gp= glo2lookup(string,OCCURRING) ;
|
||||
break ;
|
||||
}
|
||||
pstate.s_fline->instr_num= instr_no ;
|
||||
return ;
|
||||
}
|
||||
|
||||
inpseudo(instr_no) {
|
||||
cons_t cst;
|
||||
register proc_t *prptr;
|
||||
cons_t objsize;
|
||||
cons_t par1,par2;
|
||||
register char *pars;
|
||||
|
||||
/*
|
||||
* get operands of pseudo (if needed) and process it.
|
||||
*/
|
||||
|
||||
switch ( ctrunc(instr_no) ) {
|
||||
case ps_bss:
|
||||
chkstart() ;
|
||||
typealign(HOLBSS) ;
|
||||
cst = getint(); /* number of bytes */
|
||||
extbss(cst);
|
||||
break;
|
||||
case ps_hol:
|
||||
chkstart() ;
|
||||
typealign(HOLBSS) ;
|
||||
holsize=getint();
|
||||
holbase=databytes;
|
||||
extbss(holsize);
|
||||
break;
|
||||
case ps_rom:
|
||||
case ps_con:
|
||||
chkstart() ;
|
||||
typealign( ctrunc(instr_no)==ps_rom ? ROM : CON ) ;
|
||||
while( (objsize=valsize())!=0 ) {
|
||||
sizealign(objsize) ;
|
||||
putval() ;
|
||||
databytes+=objsize ;
|
||||
}
|
||||
break;
|
||||
case ps_end:
|
||||
prptr= pstate.s_curpro ;
|
||||
if ( prptr == prp_cast 0 ) fatal("unexpected END") ;
|
||||
proctab[prptr->p_num].pr_off = textbytes;
|
||||
if (procflag) {
|
||||
printf("%6lu\t%6lo\t%5d\t%-12s\t%s",
|
||||
textbytes,textbytes,
|
||||
prptr->p_num,prptr->p_name,curfile);
|
||||
if (archmode)
|
||||
printf("(%.14s)",archhdr.ar_name);
|
||||
printf("\n");
|
||||
}
|
||||
par2 = proctab[prptr->p_num].pr_loc ;
|
||||
if ( getarg(cst_ptyp|ptyp(sp_cend))==sp_cend ) {
|
||||
if ( par2 == -1 ) {
|
||||
fatal("size of local area unspecified") ;
|
||||
}
|
||||
} else {
|
||||
if ( par2 != -1 && argval!=par2 ) {
|
||||
fatal("inconsistent local area size") ;
|
||||
}
|
||||
proctab[prptr->p_num].pr_loc = argval ;
|
||||
}
|
||||
setline();
|
||||
do_proc();
|
||||
break;
|
||||
case ps_mes:
|
||||
switch( int_cast getint() ) {
|
||||
case ms_err:
|
||||
error("module with error") ; ertrap();
|
||||
/* NOTREACHED */
|
||||
case ms_emx:
|
||||
if ( oksizes ) {
|
||||
if ( wordsize!=getint() ) {
|
||||
fatal("Inconsistent word size");
|
||||
}
|
||||
if ( ptrsize!=getint() ) {
|
||||
fatal("Inconsistent pointer size");
|
||||
}
|
||||
} else {
|
||||
oksizes++ ;
|
||||
wordsize=getint();ptrsize=getint();
|
||||
if ( wordsize!=2 && wordsize!=4 ) {
|
||||
fatal("Illegal word size");
|
||||
}
|
||||
if ( ptrsize!=2 && ptrsize!=4 ) {
|
||||
fatal("Illegal pointer size");
|
||||
}
|
||||
setsizes() ;
|
||||
}
|
||||
++mod_sizes ;
|
||||
break;
|
||||
case ms_src:
|
||||
break;
|
||||
case ms_flt:
|
||||
intflags |= 020; break; /*floats used*/
|
||||
case ms_ext:
|
||||
if ( !needed() ) {
|
||||
eof_seen++ ;
|
||||
}
|
||||
if ( line_num!=1 ) {
|
||||
werror("mes ms_ext must be first pseudo") ;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
while (table2() != sp_cend)
|
||||
;
|
||||
break;
|
||||
case ps_exc:
|
||||
par1 = getint();
|
||||
par2 = getint();
|
||||
if (par1 == 0 || par2 == 0)
|
||||
break;
|
||||
exchange((int)par2,(int)par1) ;
|
||||
break;
|
||||
case ps_exa:
|
||||
getlab(EXTERNING);
|
||||
break;
|
||||
case ps_ina:
|
||||
getlab(INTERNING);
|
||||
break;
|
||||
case ps_pro:
|
||||
chkstart() ;
|
||||
initproc();
|
||||
pars = inproname();
|
||||
if ( getarg(cst_ptyp|ptyp(sp_cend))==sp_cend ) {
|
||||
par2 = -1 ;
|
||||
} else {
|
||||
par2 = argval ;
|
||||
}
|
||||
prptr = prolookup(pars,PRO_DEF);
|
||||
proctab[prptr->p_num].pr_loc = par2;
|
||||
pstate.s_curpro=prptr;
|
||||
break;
|
||||
case ps_inp:
|
||||
prptr = prolookup(inproname(),PRO_INT);
|
||||
break;
|
||||
case ps_exp:
|
||||
prptr = prolookup(inproname(),PRO_EXT);
|
||||
break;
|
||||
default:
|
||||
fatal("unknown pseudo");
|
||||
}
|
||||
if ( !mod_sizes ) fatal("Missing size specification");
|
||||
if ( databytes>maxadr ) error("Maximum data area size exceeded") ;
|
||||
}
|
||||
|
||||
setline() {
|
||||
|
||||
/* Get line numbers correct */
|
||||
|
||||
if ( pstate.s_fline &&
|
||||
ctrunc(pstate.s_fline->instr_num) == sp_fpseu ) {
|
||||
/* Already one present */
|
||||
pstate.s_fline->ad.ad_ln.ln_extra++ ;
|
||||
} else {
|
||||
newline(LINES) ;
|
||||
pstate.s_fline->instr_num= sp_fpseu ;
|
||||
pstate.s_fline->ad.ad_ln.ln_extra= 0 ;
|
||||
pstate.s_fline->ad.ad_ln.ln_first= line_num ;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
cons_t maxval(bits) int bits ; {
|
||||
/* find the maximum positive value,
|
||||
* fitting in 'bits' bits AND
|
||||
* fitting in a 'cons_t' .
|
||||
*/
|
||||
|
||||
cons_t val ;
|
||||
val=1 ;
|
||||
while ( bits-- ) {
|
||||
val<<= 1 ;
|
||||
if ( val<0 ) return ~val ;
|
||||
}
|
||||
return val-1 ;
|
||||
}
|
||||
|
||||
setsizes() {
|
||||
maxadr = maxval(8*ptrsize) ;
|
||||
maxint = maxval(8*wordsize-1) ;
|
||||
maxunsig = maxval(8*wordsize) ;
|
||||
maxdint = maxval(2*8*wordsize-1) ;
|
||||
maxdunsig = maxval(2*8*wordsize) ;
|
||||
}
|
||||
|
||||
char *getdig(str,number) char *str; register unsigned number; {
|
||||
register int remain;
|
||||
|
||||
remain= number%10;
|
||||
number /= 10;
|
||||
if ( number ) str= getdig(str,number) ;
|
||||
*str++ = '0'+remain ;
|
||||
return str ;
|
||||
}
|
||||
|
||||
make_string(n) unsigned n ; {
|
||||
string[0] = '.';
|
||||
*getdig(&string[1],n)= 0;
|
||||
}
|
||||
|
||||
|
||||
getstring() {
|
||||
register char *p;
|
||||
register n;
|
||||
|
||||
getarg(cst_ptyp);
|
||||
if ( argval < 0 || argval >= MAXSTRING-1 )
|
||||
fatal("string/identifier too long");
|
||||
strlngth = n = argval;
|
||||
p = string;
|
||||
while (--n >= 0)
|
||||
*p++ = get8();
|
||||
*p = 0 ;
|
||||
}
|
||||
|
||||
inident() {
|
||||
getstring();
|
||||
string[IDLENGTH] = '\0';
|
||||
}
|
||||
|
||||
exchange(p1,p2) {
|
||||
int size, line ;
|
||||
int l_of_p1, l_of_p2, l_of_before ;
|
||||
register line_t *t_lnp,*a_lnp, *b_lnp ;
|
||||
|
||||
/* Since the lines are linked backwards it is easy
|
||||
* to count the number of lines backwards.
|
||||
* Each instr counts for 1, each pseudo for ln_extra + 1.
|
||||
* The line numbers in error messages etc. are INCORRECT
|
||||
* If exc's are used.
|
||||
*/
|
||||
|
||||
line= line_num ; size=0 ;
|
||||
newline(LINES) ; a_lnp=pstate.s_fline ;
|
||||
a_lnp->instr_num= sp_fpseu ;
|
||||
a_lnp->ad.ad_ln.ln_first= line ;
|
||||
a_lnp->ad.ad_ln.ln_extra= -1 ;
|
||||
for ( ; a_lnp ; a_lnp= a_lnp->l_next ) {
|
||||
line-- ;
|
||||
switch ( ctrunc(a_lnp->instr_num) ) {
|
||||
case sp_fpseu :
|
||||
line= a_lnp->ad.ad_ln.ln_first ;
|
||||
size += a_lnp->ad.ad_ln.ln_extra ;
|
||||
break ;
|
||||
case sp_ilb1 :
|
||||
a_lnp->ad.ad_lp->l_min -= p2 ;
|
||||
break ;
|
||||
}
|
||||
size++ ;
|
||||
if ( size>=p1 ) break ;
|
||||
}
|
||||
if ( ( size-= p1 )>0 ) {
|
||||
if ( ctrunc(a_lnp->instr_num) !=sp_fpseu ) {
|
||||
fatal("EXC inconsistency") ;
|
||||
}
|
||||
doinsert(a_lnp,line,a_lnp->ad.ad_ln.ln_extra-size) ;
|
||||
a_lnp->ad.ad_ln.ln_first += size ;
|
||||
a_lnp->ad.ad_ln.ln_extra = size-1 ;
|
||||
size=0 ;
|
||||
b_lnp=a_lnp->l_next ;
|
||||
} else {
|
||||
doinsert(a_lnp,line,-1) ;
|
||||
b_lnp= a_lnp ;
|
||||
}
|
||||
while ( b_lnp ) {
|
||||
b_lnp= b_lnp->l_next ;
|
||||
line-- ;
|
||||
switch ( ctrunc(b_lnp->instr_num) ) {
|
||||
case sp_fpseu :
|
||||
size += b_lnp->ad.ad_ln.ln_extra ;
|
||||
line = b_lnp->ad.ad_ln.ln_first ;
|
||||
break ;
|
||||
case sp_ilb1 :
|
||||
b_lnp->ad.ad_lp->l_min += p1 ;
|
||||
break ;
|
||||
}
|
||||
size++ ;
|
||||
if ( size>=p2 ) break ;
|
||||
}
|
||||
if ( ( size-= p2 )>0 ) {
|
||||
if ( ctrunc(b_lnp->instr_num) !=sp_fpseu ) {
|
||||
fatal("EXC inconsistency") ;
|
||||
}
|
||||
doinsert(b_lnp,line,b_lnp->ad.ad_ln.ln_extra-size) ;
|
||||
b_lnp->ad.ad_ln.ln_first += size ;
|
||||
b_lnp->ad.ad_ln.ln_extra = size-1 ;
|
||||
} else {
|
||||
doinsert(b_lnp,line,-1) ;
|
||||
}
|
||||
if ( !b_lnp ) { /* if a_lnp==0, so is b_lnp */
|
||||
fatal("Cannot perform exchange") ;
|
||||
}
|
||||
t_lnp = b_lnp->l_next ;
|
||||
b_lnp->l_next = pstate.s_fline ;
|
||||
pstate.s_fline= a_lnp->l_next ;
|
||||
a_lnp->l_next=t_lnp ;
|
||||
}
|
||||
|
||||
doinsert(lnp,first,extra) line_t *lnp ; {
|
||||
/* Beware : s_fline will be clobbered and restored */
|
||||
register line_t *t_lnp ;
|
||||
|
||||
t_lnp= pstate.s_fline;
|
||||
pstate.s_fline= lnp->l_next ;
|
||||
newline(LINES) ;
|
||||
pstate.s_fline->instr_num= sp_fpseu ;
|
||||
pstate.s_fline->ad.ad_ln.ln_first= first ;
|
||||
pstate.s_fline->ad.ad_ln.ln_extra= extra ;
|
||||
lnp->l_next= pstate.s_fline ;
|
||||
pstate.s_fline= t_lnp; /* restore */
|
||||
}
|
||||
|
||||
putval() {
|
||||
switch(valtype){
|
||||
case sp_cst2:
|
||||
extconst(argval);
|
||||
return ;
|
||||
case sp_ilb1:
|
||||
extloc(loclookup(tabval,OCCURRING));
|
||||
return ;
|
||||
case sp_dnam:
|
||||
extglob(glo2lookup(string,OCCURRING),(cons_t)0);
|
||||
return ;
|
||||
case sp_doff:
|
||||
extglob(glo2lookup(string,OCCURRING),argval);
|
||||
return ;
|
||||
case sp_pnam:
|
||||
extpro(prolookup(string,PRO_OCC));
|
||||
return ;
|
||||
case sp_scon:
|
||||
extstring() ;
|
||||
return ;
|
||||
case sp_fcon:
|
||||
extxcon(DATA_FCON) ;
|
||||
return ;
|
||||
case sp_icon:
|
||||
extvcon(DATA_ICON) ;
|
||||
return ;
|
||||
case sp_ucon:
|
||||
extvcon(DATA_UCON) ;
|
||||
return ;
|
||||
default:
|
||||
fatal("putval notreached") ;
|
||||
/* NOTREACHED */
|
||||
}
|
||||
}
|
||||
|
||||
chkstart() {
|
||||
static int absout = 0 ;
|
||||
|
||||
if ( absout ) return ;
|
||||
if ( !oksizes ) fatal("missing size specification") ;
|
||||
setmode(DATA_CONST) ;
|
||||
extconst((cons_t)0) ;
|
||||
setmode(DATA_REP) ;
|
||||
extadr( (cons_t) (ABSSIZE/wordsize-1) ) ;
|
||||
absout++ ;
|
||||
databytes = ABSSIZE ;
|
||||
memtype= HOLBSS ;
|
||||
}
|
||||
|
||||
typealign(new) enum m_type new ; {
|
||||
if ( memtype==new ) return ;
|
||||
align(wordsize);
|
||||
memtype=new ;
|
||||
}
|
||||
|
||||
sizealign(size) cons_t size ; {
|
||||
align( size>wordsize ? wordsize : (int)size ) ;
|
||||
}
|
||||
|
||||
align(size) int size ; {
|
||||
register unsigned gapsize ;
|
||||
|
||||
for ( gapsize= databytes%size ; gapsize ; gapsize-- ) {
|
||||
setmode(DATA_BYTES) ;
|
||||
ext8(0) ;
|
||||
databytes++ ;
|
||||
}
|
||||
}
|
||||
|
||||
extconst(n) cons_t n ; {
|
||||
setmode(DATA_CONST);
|
||||
extword(n);
|
||||
}
|
||||
|
||||
extbss(n) cons_t n ; {
|
||||
cons_t objsize,amount ;
|
||||
|
||||
if ( n<=0 ) {
|
||||
if ( n<0 ) werror("negative bss/hol size") ;
|
||||
if ( table2()==sp_cend || table2()==sp_cend) {
|
||||
werror("Unexpected end-of-line") ;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
setmode(DATA_NUL) ; /* flush descriptor */
|
||||
objsize= valsize();
|
||||
if ( objsize==0 ) {
|
||||
werror("Unexpected end-of-line");
|
||||
return;
|
||||
}
|
||||
if ( n%objsize != 0 ) error("BSS/HOL incompatible sizes");
|
||||
putval();
|
||||
amount= n/objsize ;
|
||||
if ( amount>1 ) {
|
||||
setmode(DATA_REP);
|
||||
extadr(amount-1) ;
|
||||
}
|
||||
databytes +=n ;
|
||||
getarg(sp_cst2);
|
||||
if ( argval<0 || argval>1 ) error("illegal last argument") ;
|
||||
}
|
||||
|
||||
extloc(lbp) register locl_t *lbp; {
|
||||
|
||||
/*
|
||||
* assemble a pointer constant from a local label.
|
||||
* For example con *1
|
||||
*/
|
||||
setmode(DATA_IPTR);
|
||||
data_reloc( chp_cast lbp,dataoff,RELLOC);
|
||||
extadr((cons_t)0);
|
||||
}
|
||||
|
||||
extglob(agbp,off) glob_t *agbp; cons_t off; {
|
||||
register glob_t *gbp;
|
||||
|
||||
/*
|
||||
* generate a word of data that is defined by a global symbol.
|
||||
* Various relocation has to be prepared here in some cases
|
||||
*/
|
||||
gbp=agbp;
|
||||
setmode(DATA_DPTR);
|
||||
if ( gbp->g_status&DEF ) {
|
||||
extadr(gbp->g_val.g_addr+off);
|
||||
} else {
|
||||
data_reloc( chp_cast gbp,dataoff,RELGLO);
|
||||
extadr(off);
|
||||
}
|
||||
}
|
||||
|
||||
extpro(aprp) proc_t *aprp; {
|
||||
/*
|
||||
* generate a addres that is defined by a procedure descriptor.
|
||||
*/
|
||||
consiz= ptrsize ; setmode(DATA_UCON);
|
||||
extarb((int)ptrsize,(long)(aprp->p_num));
|
||||
}
|
||||
|
||||
extstring() {
|
||||
register char *s;
|
||||
register n ;
|
||||
|
||||
/*
|
||||
* generate data for a string.
|
||||
*/
|
||||
for(n=strlngth,s=string ; n--; ) {
|
||||
setmode(DATA_BYTES) ;
|
||||
ext8(*s++);
|
||||
}
|
||||
return ;
|
||||
}
|
||||
|
||||
extxcon(header) {
|
||||
register char *s ;
|
||||
register n;
|
||||
|
||||
/*
|
||||
* generate data for a floating constant initialized by a string.
|
||||
*/
|
||||
|
||||
setmode(header);
|
||||
s = string ;
|
||||
for (n=strlngth ; n-- ;) {
|
||||
if ( *s==0 ) error("Zero byte in initializer") ;
|
||||
ext8(*s++);
|
||||
}
|
||||
ext8(0);
|
||||
return ;
|
||||
}
|
||||
|
||||
extvcon(header) {
|
||||
extern long atol() ;
|
||||
/*
|
||||
* generate data for a constant initialized by a string.
|
||||
*/
|
||||
|
||||
setmode(header);
|
||||
if ( consiz>4 ) {
|
||||
error("Size of initializer exceeds loader capability") ;
|
||||
}
|
||||
extarb((int)consiz,atol(string)) ;
|
||||
return ;
|
||||
}
|
||||
137
util/ass/asscm.c
Normal file
137
util/ass/asscm.c
Normal file
|
|
@ -0,0 +1,137 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
/* Core management for the EM assembler.
|
||||
two routines:
|
||||
getarea(size)
|
||||
returns a pointer to a free area of 'size' bytes.
|
||||
freearea(ptr,size)
|
||||
free's the area of 'size' bytes pointed to by ptr
|
||||
|
||||
Free blocks are linked together and kept sorted.
|
||||
Adjacent free blocks are collapsed.
|
||||
Free blocks with a size smaller then the administration cannot
|
||||
exist.
|
||||
The algorithm is first fit.
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
|
||||
#ifdef MEMUSE
|
||||
static unsigned m_used = 0 ;
|
||||
static unsigned m_free = 0 ;
|
||||
#endif
|
||||
|
||||
struct freeblock {
|
||||
struct freeblock *f_next ;
|
||||
unsigned f_size ;
|
||||
} ;
|
||||
|
||||
static struct freeblock freexx[2] = {
|
||||
{ freexx, 0 },
|
||||
{ freexx+1, 0 }
|
||||
} ;
|
||||
|
||||
#define freehead freexx[1]
|
||||
|
||||
#define CHUNK 2048 /* Smallest chunk to be gotten from UNIX */
|
||||
|
||||
area_t getarea(size) unsigned size ; {
|
||||
register struct freeblock *c_ptr,*l_ptr ;
|
||||
register char *ptr ;
|
||||
unsigned rqsize ;
|
||||
char *malloc() ;
|
||||
|
||||
#ifdef MEMUSE
|
||||
m_used += size ;
|
||||
m_free -= size ;
|
||||
#endif
|
||||
for(;;) {
|
||||
for ( l_ptr= &freehead, c_ptr= freehead.f_next ;
|
||||
c_ptr!= &freehead ; c_ptr = c_ptr->f_next ) {
|
||||
if ( size==c_ptr->f_size ) {
|
||||
l_ptr->f_next= c_ptr->f_next ;
|
||||
return (area_t) c_ptr ;
|
||||
}
|
||||
if ( size+sizeof freehead <= c_ptr->f_size ) {
|
||||
c_ptr->f_size -= size ;
|
||||
return (area_t) ((char *) c_ptr + c_ptr->f_size) ;
|
||||
}
|
||||
l_ptr = c_ptr ;
|
||||
}
|
||||
rqsize = size<CHUNK ? CHUNK : size ;
|
||||
for(;;){
|
||||
ptr = malloc( rqsize ) ;
|
||||
if ( ptr ) break ; /* request succesfull */
|
||||
rqsize /= 2 ;
|
||||
rqsize -= rqsize%sizeof (short) ;
|
||||
if ( rqsize < sizeof freehead ) {
|
||||
fatal("Out of memory") ;
|
||||
}
|
||||
}
|
||||
freearea((area_t)ptr,rqsize) ;
|
||||
#ifdef MEMUSE
|
||||
m_used += rqsize ;
|
||||
#endif
|
||||
}
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
freearea(ptr,size) register area_t ptr ; unsigned size ; {
|
||||
register struct freeblock *c_ptr, *l_ptr ;
|
||||
|
||||
#ifdef MEMUSE
|
||||
m_free += size ;
|
||||
m_used -= size ;
|
||||
#endif
|
||||
for ( l_ptr= &freehead, c_ptr=freehead.f_next ;
|
||||
c_ptr!= &freehead ; c_ptr= c_ptr->f_next ) {
|
||||
if ( (area_t)c_ptr>ptr ) break ;
|
||||
l_ptr= c_ptr ;
|
||||
}
|
||||
/* now insert between l_ptr and c_ptr */
|
||||
/* Beware they may both point to freehead */
|
||||
|
||||
#ifdef MEMUSE
|
||||
if ( ((char *)l_ptr)+l_ptr->f_size> (char *)ptr && l_ptr<=ptr )
|
||||
fatal("Double freed") ;
|
||||
if ( ((char *)ptr)+size > (char *)c_ptr && ptr<=c_ptr )
|
||||
fatal("Frreed double") ;
|
||||
#endif
|
||||
/* Is the block before this one adjacent ? */
|
||||
if ( ((char *)l_ptr) + l_ptr->f_size == (char *) ptr ) {
|
||||
l_ptr->f_size += size ; /* yes */
|
||||
} else {
|
||||
/* No, create an entry */
|
||||
((struct freeblock *)ptr)->f_next = c_ptr ;
|
||||
((struct freeblock *)ptr)->f_size = size ;
|
||||
l_ptr->f_next = (struct freeblock *)ptr ;
|
||||
l_ptr = (struct freeblock *)ptr ;
|
||||
}
|
||||
/* Are the two entries adjacent ? */
|
||||
if ( (char *)l_ptr + l_ptr->f_size == (char *) c_ptr ) {
|
||||
/* the two entries are adjacent */
|
||||
l_ptr->f_next = c_ptr->f_next ;
|
||||
l_ptr->f_size += c_ptr->f_size ;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef MEMUSE
|
||||
memuse() {
|
||||
printf("Free %7u, Used %7u, Total %7u\n",m_free,m_used,m_free+m_used);
|
||||
}
|
||||
#endif
|
||||
125
util/ass/assda.c
Normal file
125
util/ass/assda.c
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
/*
|
||||
* global data
|
||||
*/
|
||||
|
||||
int wordsize ;
|
||||
int ptrsize ;
|
||||
cons_t maxadr ;
|
||||
cons_t maxint;
|
||||
cons_t maxdint;
|
||||
cons_t maxunsig;
|
||||
cons_t maxdunsig;
|
||||
|
||||
/*
|
||||
The structure containing used for procedure environment stacking
|
||||
*/
|
||||
stat_t pstate ;
|
||||
|
||||
/*
|
||||
* pointers to not yet allocated storage
|
||||
*/
|
||||
glob_t *mglobs; /* pointer to module symbols */
|
||||
glob_t *xglobs; /* pointer to extern symbols */
|
||||
proc_t *mprocs; /* pointer to local procs */
|
||||
proc_t *xprocs; /* pointer to external procs */
|
||||
ptab_t *proctab; /* pointer to proctab[] */
|
||||
|
||||
/*
|
||||
* some array and structures of known size
|
||||
*/
|
||||
FILE *ifile; /* input file buffer */
|
||||
FILE *tfile; /* code file buffer */
|
||||
FILE *dfile; /* data file buffer */
|
||||
FILE *rtfile; /* code file buffer */
|
||||
FILE *rdfile; /* data file buffer */
|
||||
char string[MAXSTRING];
|
||||
|
||||
/*
|
||||
* some other pointers
|
||||
*/
|
||||
glob_t *lastglosym; /* last global symbol */
|
||||
glob_t *curglosym; /* current global symbol */
|
||||
relc_t *f_data = (relc_t *)0 ; /* first data reloc pointer */
|
||||
relc_t *l_data = (relc_t *)0 ; /* last data reloc pointer */
|
||||
relc_t *f_text = (relc_t *)0 ; /* first text reloc pointer */
|
||||
relc_t *l_text = (relc_t *)0 ; /* last text reloc pointer */
|
||||
|
||||
/*
|
||||
* some indices
|
||||
*/
|
||||
int strlngth; /* index in string[] */
|
||||
FOFFSET inpoff; /* offset in current input file */
|
||||
FOFFSET libeof; /* ceiling for above number */
|
||||
|
||||
/*
|
||||
* some other counters
|
||||
*/
|
||||
int procnum; /* generic for unique proc-descr. */
|
||||
cons_t prog_size; /* length of current proc */
|
||||
int max_bytes;
|
||||
int pass;
|
||||
int line_num; /* line number for error messages */
|
||||
int nerrors; /* number of nonfatal errors */
|
||||
cons_t consiz; /* size of U,I or F value */
|
||||
cons_t textbytes; /* size of code file */
|
||||
cons_t databytes; /* highwater mark in data */
|
||||
FOFFSET dataoff; /* size of data file */
|
||||
FOFFSET textoff; /* size of text file */
|
||||
FOFFSET lastoff; /* previous size before last block */
|
||||
int datamode; /* what kind of data */
|
||||
int datablocks; /* number of datablocks written out */
|
||||
relc_t *lastheader; /* pointer into datareloc */
|
||||
cons_t holbase;
|
||||
cons_t holsize;
|
||||
int unresolved; /* # of unresolved references */
|
||||
int sourcelines; /* number of lines in source program*/
|
||||
int intflags = 1; /* flags for interpreter */
|
||||
/*
|
||||
* some flags
|
||||
*/
|
||||
int archmode; /* reading library ? */
|
||||
int procflag; /* print "namelist" of procedures */
|
||||
#ifdef DUMP
|
||||
int c_flag; /* print unused opcodes */
|
||||
char opcnt1[256]; /* count primary opcodes */
|
||||
char opcnt2[256]; /* count secondary opcodes */
|
||||
char opcnt3[256]; /* count long opcodes */
|
||||
#endif
|
||||
int d_flag = 0; /* don't dump */
|
||||
int r_flag = 0; /* don't dump relocation tables */
|
||||
#ifdef JOHAN
|
||||
int jflag;
|
||||
#endif
|
||||
int wflag = 0; /* don't issue warning messages */
|
||||
int eof_seen;
|
||||
int mod_sizes; /* Size info in current module ok? */
|
||||
|
||||
#define BASE (sizeof (struct lines) - sizeof (addr_u))
|
||||
|
||||
char linesize[VALLOW+1] = {
|
||||
BASE, /* MISSING */
|
||||
BASE + sizeof (cons_t), /* CONST */
|
||||
BASE + sizeof prp_cast, /* PROCNAME */
|
||||
BASE + sizeof gbp_cast, /* GLOSYM */
|
||||
BASE + sizeof lbp_cast, /* LOCSYM */
|
||||
BASE + sizeof (struct sad_df), /* GLOOFF */
|
||||
BASE + sizeof (struct sad_ln), /* LINES */
|
||||
BASE /* VALLOW */
|
||||
} ;
|
||||
|
||||
/*
|
||||
* miscellaneous
|
||||
*/
|
||||
char *progname; /* argv[0] */
|
||||
char *curfile = 0; /* name of current file */
|
||||
char *eout = "e.out";
|
||||
arch_t archhdr;
|
||||
size_t sizes[NDEFAULT] = {
|
||||
/* mlab, glab,mproc,xproc, proc */
|
||||
{ 151, 29, 31, 73, 130 },
|
||||
{ 307, 127, 151, 401, 460 },
|
||||
{ 601, 251, 151, 401, 600 }
|
||||
};
|
||||
size_t *oursize = &sizes[1] ; /* point to selected sizes */
|
||||
158
util/ass/assex.h
Normal file
158
util/ass/assex.h
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
/*
|
||||
* global data
|
||||
*/
|
||||
|
||||
extern int wordsize;
|
||||
extern int ptrsize;
|
||||
extern cons_t maxadr;
|
||||
extern cons_t maxint;
|
||||
extern cons_t maxdint;
|
||||
extern cons_t maxunsig;
|
||||
extern cons_t maxdunsig;
|
||||
|
||||
/*
|
||||
* tables loaded from em_libraries
|
||||
*/
|
||||
extern char em_flag[];
|
||||
|
||||
/*
|
||||
The structure containing used for procedure environment stacking
|
||||
*/
|
||||
extern stat_t pstate ;
|
||||
|
||||
/*
|
||||
* pointers to not yet allocated storage
|
||||
*/
|
||||
extern glob_t *mglobs;
|
||||
extern glob_t *xglobs;
|
||||
extern proc_t *mprocs;
|
||||
extern proc_t *xprocs;
|
||||
extern ptab_t *proctab;
|
||||
|
||||
extern FILE *ifile;
|
||||
extern FILE *tfile;
|
||||
extern FILE *dfile;
|
||||
extern FILE *rtfile;
|
||||
extern FILE *rdfile;
|
||||
extern char string[];
|
||||
|
||||
/*
|
||||
* some other pointers
|
||||
*/
|
||||
extern glob_t *lastglosym;
|
||||
extern glob_t *curglosym;
|
||||
extern size_t *oursize;
|
||||
extern relc_t *f_data;
|
||||
extern relc_t *l_data;
|
||||
extern relc_t *f_text;
|
||||
extern relc_t *l_text;
|
||||
|
||||
/*
|
||||
* some indices
|
||||
*/
|
||||
extern int strlngth;
|
||||
extern FOFFSET inpoff;
|
||||
extern FOFFSET libeof;
|
||||
|
||||
/*
|
||||
* some other counters
|
||||
*/
|
||||
extern int procnum;
|
||||
extern cons_t prog_size;
|
||||
extern int max_bytes;
|
||||
extern int pass;
|
||||
extern int line_num;
|
||||
extern int nerrors;
|
||||
extern cons_t textbytes;
|
||||
extern cons_t databytes;
|
||||
extern FOFFSET dataoff;
|
||||
extern FOFFSET textoff;
|
||||
extern FOFFSET lastoff;
|
||||
extern int datamode;
|
||||
extern int datablocks;
|
||||
extern relc_t *lastheader;
|
||||
extern cons_t holbase;
|
||||
extern cons_t holsize;
|
||||
extern int unresolved;
|
||||
extern int sourcelines;
|
||||
extern int intflags;
|
||||
/*
|
||||
* some flags
|
||||
*/
|
||||
extern int archmode;
|
||||
extern int procflag;
|
||||
#ifdef DUMP
|
||||
extern int c_flag;
|
||||
extern char opcnt1[];
|
||||
extern char opcnt2[];
|
||||
extern char opcnt3[];
|
||||
#endif
|
||||
extern int d_flag;
|
||||
extern int r_flag;
|
||||
#ifdef JOHAN
|
||||
extern int jflag;
|
||||
#endif
|
||||
extern int wflag;
|
||||
extern int eof_seen;
|
||||
extern int mod_sizes;
|
||||
/*
|
||||
* miscellaneous
|
||||
*/
|
||||
extern cons_t consiz;
|
||||
extern char *progname;
|
||||
extern char *curfile;
|
||||
extern char *eout;
|
||||
extern arch_t archhdr;
|
||||
extern size_t sizes[];
|
||||
|
||||
extern char linesize[];
|
||||
|
||||
/*
|
||||
* from asstb.c
|
||||
*/
|
||||
|
||||
extern char *opindex[] ;
|
||||
extern char opchoice[] ;
|
||||
extern int maxinsl ;
|
||||
|
||||
/*
|
||||
* types of value returning routines
|
||||
*/
|
||||
#ifndef CPM
|
||||
extern int tmpfil();
|
||||
extern FILE *frewind();
|
||||
#endif
|
||||
extern int xgetc();
|
||||
extern unsigned get8();
|
||||
extern int get16();
|
||||
extern cons_t get32();
|
||||
extern cons_t xgeta();
|
||||
extern cons_t parval();
|
||||
extern cons_t valsize();
|
||||
extern cons_t xgetarb();
|
||||
extern char *findnop();
|
||||
extern char *findfit();
|
||||
extern glob_t *glolookup();
|
||||
extern glob_t *glo2lookup();
|
||||
extern glob_t *xglolookup();
|
||||
extern locl_t *loclookup();
|
||||
extern proc_t *prolookup();
|
||||
extern proc_t *enterproc();
|
||||
extern proc_t *searchproc();
|
||||
extern relc_t *text_reloc();
|
||||
extern relc_t *data_reloc();
|
||||
extern area_t getarea();
|
||||
|
||||
/*
|
||||
* all used library routines
|
||||
*/
|
||||
extern char *malloc();
|
||||
extern int open();
|
||||
extern int creat();
|
||||
extern int getpid();
|
||||
extern int unlink();
|
||||
extern int close();
|
||||
extern int strcmp();
|
||||
extern char *strcpy();
|
||||
|
||||
#define void int
|
||||
298
util/ass/assrl.c
Normal file
298
util/ass/assrl.c
Normal file
|
|
@ -0,0 +1,298 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ass00.h"
|
||||
#include "assex.h"
|
||||
|
||||
#define COPYFINAL 1
|
||||
#define COPYTEMP 0
|
||||
|
||||
/*
|
||||
* collection of routines to deal with relocation business
|
||||
*/
|
||||
|
||||
void dataprocess();
|
||||
void textprocess();
|
||||
relc_t *
|
||||
text_reloc(glosym,off,typ) glob_t *glosym; FOFFSET off ; int typ ; {
|
||||
|
||||
/*
|
||||
* prepare the relocation that has to be done at text-offset off
|
||||
* according to global symbol glosym.
|
||||
* NOTE: The pointer glosym will point into mglobs[], while at
|
||||
* the time copyout() is called all the symbols here
|
||||
* will have disappeared.
|
||||
* The procedure upd_reloc() will change this pointer
|
||||
* into the one in xglobs[] later.
|
||||
*/
|
||||
|
||||
register relc_t *nxtextreloc ;
|
||||
|
||||
nxtextreloc= rlp_cast getarea(sizeof *nxtextreloc) ;
|
||||
if ( !f_text ) {
|
||||
f_text= nxtextreloc ;
|
||||
} else {
|
||||
l_text->r_next= nxtextreloc ;
|
||||
}
|
||||
nxtextreloc->r_next= rlp_cast 0 ;
|
||||
l_text= nxtextreloc ;
|
||||
nxtextreloc->r_off = off;
|
||||
nxtextreloc->r_val.rel_gp = glosym;
|
||||
nxtextreloc->r_typ = typ; /* flags of instruction */
|
||||
return(nxtextreloc);
|
||||
}
|
||||
|
||||
relc_t *
|
||||
data_reloc(arg,off,typ) char *arg ; FOFFSET off ; int typ ; {
|
||||
|
||||
/*
|
||||
* Same as above.
|
||||
*/
|
||||
|
||||
register relc_t *nxdatareloc ;
|
||||
|
||||
nxdatareloc= rlp_cast getarea(sizeof *nxdatareloc) ;
|
||||
if ( !f_data ) {
|
||||
f_data= nxdatareloc ;
|
||||
} else {
|
||||
l_data->r_next= nxdatareloc ;
|
||||
}
|
||||
nxdatareloc->r_next= rlp_cast 0 ;
|
||||
l_data= nxdatareloc ;
|
||||
nxdatareloc->r_off = off;
|
||||
nxdatareloc->r_val.rel_lp = lbp_cast arg;
|
||||
nxdatareloc->r_typ = typ;
|
||||
return(nxdatareloc);
|
||||
}
|
||||
|
||||
copyout() {
|
||||
register i;
|
||||
int remtext ;
|
||||
|
||||
/*
|
||||
* Make the e.out file that looks as follows:
|
||||
*
|
||||
* __________________________
|
||||
* | MAGIC | \
|
||||
* | FLAGS | \
|
||||
* | UNRESOLVED | \
|
||||
* | VERSION | | 8*(2-byte word) header
|
||||
* | WORDSIZE | | for interpreter selection
|
||||
* | PTRSIZE | /
|
||||
* | <UNUSED> | /
|
||||
* | <UNUSED> | /
|
||||
* | NTEXT | \
|
||||
* | NDATA | \
|
||||
* | NPROC | \
|
||||
* | ENTRY-POINT | | 8*(wordsize-word) header
|
||||
* | NLINES | | for interpreter proper
|
||||
* | <UNUSED> | /
|
||||
* | <UNUSED> | /
|
||||
* | <UNUSED> | /
|
||||
* |________________________|
|
||||
* | |
|
||||
* | TEXT | zero filled
|
||||
* | | if not word multiple
|
||||
* |________________________|
|
||||
* | |
|
||||
* | DATA |
|
||||
* | |
|
||||
* |________________________|
|
||||
* | |
|
||||
* | PROCTABLE |
|
||||
* | |
|
||||
* |________________________|
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
remtext = textbytes%wordsize ;
|
||||
if ( remtext != 0 ) remtext = wordsize-remtext ;
|
||||
|
||||
if ((ifile = fopen(eout,"w")) == NULL )
|
||||
fatal("can't create e.out");
|
||||
#ifdef CPM
|
||||
fclose(tfile); tfile=fopen("TFILE.$$$, "r");
|
||||
fclose(dfile); dfile=fopen("DFILE.$$$, "r");
|
||||
#else
|
||||
tfile=frewind(tfile);
|
||||
dfile=frewind(dfile);
|
||||
#endif
|
||||
xput16(as_magic,ifile);
|
||||
xput16(intflags,ifile);
|
||||
xput16(unresolved,ifile);
|
||||
xput16(VERSION,ifile);
|
||||
xput16(wordsize,ifile);
|
||||
xput16(ptrsize,ifile);
|
||||
xput16(0,ifile);
|
||||
xput16(0,ifile);
|
||||
xputa(textbytes+remtext ,ifile);
|
||||
xputa((cons_t)datablocks,ifile);
|
||||
xputa((cons_t)procnum,ifile);
|
||||
xputa((cons_t)searchproc(MAIN,xprocs,oursize->n_xproc)->p_num,
|
||||
ifile);
|
||||
xputa((cons_t)sourcelines,ifile);
|
||||
xputa((cons_t)databytes,ifile);
|
||||
xputa((cons_t)0,ifile);
|
||||
xputa((cons_t)0,ifile);
|
||||
|
||||
textprocess(tfile,ifile);
|
||||
while ( remtext-- ) xputc(0,ifile) ;
|
||||
|
||||
dataprocess(dfile,ifile);
|
||||
for (i=0;i<procnum;i++) {
|
||||
xputarb(ptrsize,proctab[i].pr_loc,ifile);
|
||||
xputarb(ptrsize,proctab[i].pr_off,ifile);
|
||||
}
|
||||
if ( fclose(ifile)==EOF ) ;
|
||||
}
|
||||
|
||||
dataprocess(f1,f2) FILE *f1,*f2; {
|
||||
relc_t datareloc;
|
||||
FOFFSET i;
|
||||
register ieof ;
|
||||
|
||||
#ifdef CPM
|
||||
fclose(rdfile); rdfile=fopen("RDFILE.$$$, "r");
|
||||
#else
|
||||
rdfile=frewind(rdfile) ;
|
||||
#endif
|
||||
ieof=getblk(rdfile,(char *)(&datareloc.r_off),
|
||||
sizeof datareloc - sizeof datareloc.r_next) ;
|
||||
for (i=0 ; i<dataoff && !ieof ; i++) {
|
||||
if (i==datareloc.r_off) {
|
||||
switch(datareloc.r_typ) {
|
||||
case RELADR:
|
||||
xputa(xgeta(f1)+datareloc.r_val.rel_i,f2) ;
|
||||
i += ptrsize-1 ;
|
||||
break ;
|
||||
case RELGLO:
|
||||
if (datareloc.r_val.rel_gp->g_status&DEF) {
|
||||
xputa(xgeta(f1)+
|
||||
datareloc.r_val.rel_gp->g_val.g_addr,
|
||||
f2);
|
||||
i+= ptrsize-1 ;
|
||||
break ;
|
||||
}
|
||||
if ( unresolved == 0 )
|
||||
fatal("Definition botch") ;
|
||||
case RELHEAD:
|
||||
xputc((int)(xgetc(f1)+datareloc.r_val.rel_i),
|
||||
f2);
|
||||
break;
|
||||
default:
|
||||
fatal("Bad r_typ in dataprocess");
|
||||
}
|
||||
ieof=getblk(rdfile,(char *)(&datareloc.r_off),
|
||||
sizeof datareloc - sizeof datareloc.r_next) ;
|
||||
} else
|
||||
xputc(xgetc(f1),f2);
|
||||
}
|
||||
for ( ; i<dataoff ; i++ ) xputc(xgetc(f1),f2) ;
|
||||
if ( !ieof && !getblk(rdfile,(char *)&datareloc,1) )
|
||||
fatal("data relocation botch") ;
|
||||
}
|
||||
|
||||
textprocess(f1,f2) FILE *f1,*f2; {
|
||||
relc_t textreloc;
|
||||
cons_t n;
|
||||
FOFFSET i;
|
||||
FILE *otfile ;
|
||||
int insl ; register int ieof ;
|
||||
char *op_curr ;
|
||||
register FOFFSET keep ;
|
||||
|
||||
#ifdef CPM
|
||||
fclose(rtfile); rtfile=fopen("RTFILE.$$$, "r");
|
||||
#else
|
||||
rtfile=frewind(rtfile) ;
|
||||
#endif
|
||||
keep = textoff ; textoff=0 ; otfile=tfile ; tfile=f2 ;
|
||||
/* This redirects the output of genop */
|
||||
ieof=getblk(rtfile,(char *)(&textreloc.r_off),
|
||||
sizeof textreloc - sizeof textreloc.r_next) ;
|
||||
for(i=0;i<keep && !ieof ;i++) {
|
||||
if( i == textreloc.r_off ) {
|
||||
if (textreloc.r_typ&RELMNS) {
|
||||
n=textreloc.r_val.rel_i;
|
||||
} else {
|
||||
if (textreloc.r_val.rel_gp->g_status&DEF) {
|
||||
n=textreloc.r_val.rel_gp->g_val.g_addr;
|
||||
} else {
|
||||
if ( unresolved==0 )
|
||||
fatal("Definition botch") ;
|
||||
xputc(xgetc(f1),f2) ;
|
||||
ieof=getblk(rtfile,(char *)(&textreloc.r_off),
|
||||
sizeof textreloc-sizeof textreloc.r_next);
|
||||
continue ;
|
||||
}
|
||||
}
|
||||
op_curr = &opchoice[textreloc.r_typ& ~RELMNS] ;
|
||||
insl = oplength(*op_curr) ;
|
||||
genop(op_curr, n+xgetarb(insl,f1), PAR_G);
|
||||
i += insl-1 ;
|
||||
ieof=getblk(rtfile,(char *)(&textreloc.r_off),
|
||||
sizeof textreloc - sizeof textreloc.r_next) ;
|
||||
} else {
|
||||
xputc(xgetc(f1),f2) ;
|
||||
}
|
||||
}
|
||||
for ( ; i<keep ; i++ ) xputc(xgetc(f1),f2) ;
|
||||
if ( !ieof && !getblk(rtfile,(char *)&textreloc,1) )
|
||||
fatal("text relocation botch") ;
|
||||
textoff = keep ;
|
||||
tfile = otfile ;
|
||||
}
|
||||
|
||||
upd_reloc() {
|
||||
register relc_t *p;
|
||||
register glob_t *gbp;
|
||||
|
||||
/*
|
||||
* Change reloc-tables such that for every pointer into mglobs
|
||||
* either the corresponding pointer into xglobs or its value
|
||||
* is substituted.
|
||||
*
|
||||
* Use is made of the known order of mglobs and xglobs
|
||||
* see also getcore()
|
||||
*/
|
||||
|
||||
while ( p= f_text ) {
|
||||
gbp= p->r_val.rel_gp ;
|
||||
if( gbp->g_status&DEF ) {
|
||||
p->r_typ |= RELMNS;
|
||||
p->r_val.rel_i = gbp->g_val.g_addr;
|
||||
} else
|
||||
p->r_val.rel_gp = gbp->g_val.g_gp;
|
||||
putblk(rtfile,(char *)(&(p->r_off)),sizeof *p - sizeof p) ;
|
||||
f_text= p->r_next ; freearea( (area_t) p , sizeof *p ) ;
|
||||
}
|
||||
|
||||
while( p= f_data ) {
|
||||
if (p->r_typ == RELGLO) {
|
||||
gbp= p->r_val.rel_gp ;
|
||||
if(gbp->g_status&DEF) {
|
||||
p->r_typ = RELADR;
|
||||
p->r_val.rel_i = gbp->g_val.g_addr;
|
||||
} else
|
||||
p->r_val.rel_gp = gbp->g_val.g_gp;
|
||||
}
|
||||
putblk(rdfile,(char *)(&(p->r_off)),sizeof *p - sizeof p) ;
|
||||
f_data= p->r_next ; freearea( (area_t) p , sizeof *p ) ;
|
||||
}
|
||||
l_data= rlp_cast 0 ;
|
||||
}
|
||||
33
util/ass/ip_spec.h
Normal file
33
util/ass/ip_spec.h
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/* Contents of flags used when describing interpreter opcodes */
|
||||
|
||||
#define OPTYPE 07 /* type field in flag */
|
||||
|
||||
#define OPMINI 0 /* m MINI */
|
||||
#define OPSHORT 1 /* s SHORT */
|
||||
#define OPNO 2 /* - No operand */
|
||||
#define OP8 3 /* 1 1-byte signed operand */
|
||||
#define OP16 4 /* 2 2-byte signed operand */
|
||||
#define OP32 5 /* 4 4-byte signed operand */
|
||||
#define OP64 6 /* 8 8-byte signed operand */
|
||||
|
||||
#define OPESC 010 /* e escaped opcode */
|
||||
#define OPWORD 020 /* w operand is word multiple */
|
||||
#define OPNZ 040 /* o operand starts at 1 ( or wordsize if w-flag) */
|
||||
|
||||
#define OPRANGE 0300 /* Range of operands: Positive, negative, both */
|
||||
|
||||
#define OP_BOTH 0000 /* the default */
|
||||
#define OP_POS 0100 /* p Positive (>=0) operands only */
|
||||
#define OP_NEG 0200 /* n Negative (<0) operands only */
|
||||
|
||||
struct opform {
|
||||
char i_opcode ; /* the opcode number */
|
||||
char i_flag ; /* the flag byte */
|
||||
char i_low ; /* the interpreter first opcode */
|
||||
char i_num ; /* the number of shorts/minis (optional) */
|
||||
};
|
||||
|
||||
/* Escape indicators */
|
||||
|
||||
#define ESC 254 /* To escape group */
|
||||
#define ESC_L 255 /* To 32 and 64 bit operands */
|
||||
475
util/ass/maktab.c
Normal file
475
util/ass/maktab.c
Normal file
|
|
@ -0,0 +1,475 @@
|
|||
/*
|
||||
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||
*
|
||||
* This product is part of the Amsterdam Compiler Kit.
|
||||
*
|
||||
* Permission to use, sell, duplicate or disclose this software must be
|
||||
* obtained in writing. Requests for such permissions may be sent to
|
||||
*
|
||||
* Dr. Andrew S. Tanenbaum
|
||||
* Wiskundig Seminarium
|
||||
* Vrije Universiteit
|
||||
* Postbox 7161
|
||||
* 1007 MC Amsterdam
|
||||
* The Netherlands
|
||||
*
|
||||
*/
|
||||
|
||||
#include "ip_spec.h"
|
||||
#include <stdio.h>
|
||||
#include "../../h/em_spec.h"
|
||||
#include "../../h/em_flag.h"
|
||||
|
||||
/* This program reads the human readable interpreter specification
|
||||
and produces a efficient machine representation that can be
|
||||
translated by a C-compiler.
|
||||
*/
|
||||
|
||||
#define NOTAB 600 /* The max no of interpreter specs */
|
||||
#define ESCAP 256
|
||||
|
||||
struct opform intable[NOTAB] ;
|
||||
struct opform *lastform = intable-1 ;
|
||||
|
||||
int nerror = 0 ;
|
||||
int atend = 0 ;
|
||||
int line = 1 ;
|
||||
int maxinsl= 0 ;
|
||||
|
||||
extern char em_mnem[][4] ;
|
||||
char esca[] = "escape" ;
|
||||
#define ename(no) ((no)==ESCAP?esca:em_mnem[(no)])
|
||||
|
||||
extern char em_flag[] ;
|
||||
|
||||
main(argc,argv) char **argv ; {
|
||||
if ( argc>1 ) {
|
||||
if ( freopen(argv[1],"r",stdin)==NULL) {
|
||||
fatal("Cannot open %s",argv[1]) ;
|
||||
}
|
||||
}
|
||||
if ( argc>2 ) {
|
||||
if ( freopen(argv[2],"w",stdout)==NULL) {
|
||||
fatal("Cannot create %s",argv[2]) ;
|
||||
}
|
||||
}
|
||||
if ( argc>3 ) {
|
||||
fatal("%s [ file [ file ] ]",argv[0]) ;
|
||||
}
|
||||
atend=0 ;
|
||||
readin();
|
||||
atend=1 ;
|
||||
checkall();
|
||||
if ( nerror==0 ) {
|
||||
writeout();
|
||||
}
|
||||
return nerror ;
|
||||
}
|
||||
|
||||
readin() {
|
||||
register struct opform *nextform ;
|
||||
char *ident();
|
||||
char *firstid ;
|
||||
register maxl ;
|
||||
|
||||
maxl = 0 ;
|
||||
for ( nextform=intable ;
|
||||
!feof(stdin) && nextform<&intable[NOTAB] ; ) {
|
||||
firstid=ident() ;
|
||||
if ( *firstid=='\n' || feof(stdin) ) continue ;
|
||||
lastform=nextform ;
|
||||
nextform->i_opcode = getmnem(firstid) ;
|
||||
nextform->i_flag = decflag(ident()) ;
|
||||
switch ( nextform->i_flag&OPTYPE ) {
|
||||
case OPMINI:
|
||||
case OPSHORT:
|
||||
nextform->i_num = atoi(ident()) ;
|
||||
break ;
|
||||
}
|
||||
nextform->i_low = atoi(ident()) ;
|
||||
if ( *ident()!='\n' ) {
|
||||
int c ;
|
||||
error("End of line expected");
|
||||
while ( (c=readchar())!='\n' && c!=EOF ) ;
|
||||
}
|
||||
if ( oplength(nextform)>maxl ) maxl=oplength(nextform) ;
|
||||
nextform++ ;
|
||||
}
|
||||
if ( !feof(stdin) ) fatal("Internal table too small") ;
|
||||
maxinsl = maxl ;
|
||||
}
|
||||
|
||||
char *ident() {
|
||||
/* skip spaces and tabs, anything up to space,tab or eof is
|
||||
a identifier.
|
||||
Anything from # to end-of-line is an end-of-line.
|
||||
End-of-line is an identifier all by itself.
|
||||
*/
|
||||
|
||||
static char array[200] ;
|
||||
register int c ;
|
||||
register char *cc ;
|
||||
|
||||
do {
|
||||
c=readchar() ;
|
||||
} while ( c==' ' || c=='\t' ) ;
|
||||
for ( cc=array ; cc<&array[(sizeof array) - 1] ; cc++ ) {
|
||||
if ( c=='#' ) {
|
||||
do {
|
||||
c=readchar();
|
||||
} while ( c!='\n' && c!=EOF ) ;
|
||||
}
|
||||
*cc = c ;
|
||||
if ( c=='\n' && cc==array ) break ;
|
||||
c=readchar() ;
|
||||
if ( c=='\n' ) {
|
||||
pushback(c) ;
|
||||
break ;
|
||||
}
|
||||
if ( c==' ' || c=='\t' || c==EOF ) break ;
|
||||
}
|
||||
*++cc=0 ;
|
||||
return array ;
|
||||
}
|
||||
|
||||
int getmnem(str) char *str ; {
|
||||
char (*ptr)[4] ;
|
||||
|
||||
for ( ptr = em_mnem ; *ptr<= &em_mnem[sp_lmnem-sp_fmnem][0] ; ptr++ ) {
|
||||
if ( strcmp(*ptr,str)==0 ) return (ptr-em_mnem) ;
|
||||
}
|
||||
error("Illegal mnemonic") ;
|
||||
return 0 ;
|
||||
}
|
||||
|
||||
error(str,a1,a2,a3,a4,a5,a6) /* VARARGS1 */ char *str ; {
|
||||
if ( !atend ) fprintf(stderr,"line %d: ",line) ;
|
||||
fprintf(stderr,str,a1,a2,a3,a4,a5,a6) ;
|
||||
fprintf(stderr,"\n");
|
||||
nerror++ ;
|
||||
}
|
||||
|
||||
mess(str,a1,a2,a3,a4,a5,a6) /* VARARGS1 */ char *str ; {
|
||||
if ( !atend ) fprintf(stderr,"line %d: ",line) ;
|
||||
fprintf(stderr,str,a1,a2,a3,a4,a5,a6) ;
|
||||
fprintf(stderr,"\n");
|
||||
}
|
||||
|
||||
fatal(str,a1,a2,a3,a4,a5,a6) /* VARARGS1 */ char *str ; {
|
||||
error(str,a1,a2,a3,a4,a5,a6) ;
|
||||
exit(1) ;
|
||||
}
|
||||
|
||||
#define ILLGL -1
|
||||
|
||||
check(val) int val ; {
|
||||
if ( val!=ILLGL ) error("Illegal flag combination") ;
|
||||
}
|
||||
|
||||
int decflag(str) char *str ; {
|
||||
int type ;
|
||||
int escape ;
|
||||
int range ;
|
||||
int wordm ;
|
||||
int notzero ;
|
||||
|
||||
type=escape=range=wordm=notzero= ILLGL ;
|
||||
while ( *str ) switch ( *str++ ) {
|
||||
case 'm' :
|
||||
check(type) ; type=OPMINI ; break ;
|
||||
case 's' :
|
||||
check(type) ; type=OPSHORT ; break ;
|
||||
case '-' :
|
||||
check(type) ; type=OPNO ; break ;
|
||||
case '1' :
|
||||
check(type) ; type=OP8 ; break ;
|
||||
case '2' :
|
||||
check(type) ; type=OP16 ; break ;
|
||||
case '4' :
|
||||
check(type) ; type=OP32 ; break ;
|
||||
case '8' :
|
||||
check(type) ; type=OP64 ; break ;
|
||||
case 'e' :
|
||||
check(escape) ; escape=0 ; break ;
|
||||
case 'N' :
|
||||
check(range) ; range= 2 ; break ;
|
||||
case 'P' :
|
||||
check(range) ; range= 1 ; break ;
|
||||
case 'w' :
|
||||
check(wordm) ; wordm=0 ; break ;
|
||||
case 'o' :
|
||||
check(notzero) ; notzero=0 ; break ;
|
||||
default :
|
||||
error("Unknown flag") ;
|
||||
}
|
||||
if ( type==ILLGL ) error("Type must be specified") ;
|
||||
switch ( type ) {
|
||||
case OP64 :
|
||||
case OP32 :
|
||||
if ( escape!=ILLGL ) error("Conflicting escapes") ;
|
||||
escape=ILLGL ;
|
||||
case OP16 :
|
||||
case OP8 :
|
||||
case OPSHORT :
|
||||
case OPNO :
|
||||
if ( notzero!=ILLGL ) mess("Improbable OPNZ") ;
|
||||
if ( type==OPNO && range!=ILLGL ) {
|
||||
mess("No operand in range") ;
|
||||
}
|
||||
}
|
||||
if ( escape!=ILLGL ) type|=OPESC ;
|
||||
if ( wordm!=ILLGL ) type|=OPWORD ;
|
||||
switch ( range) {
|
||||
case ILLGL : type|=OP_BOTH ; break ;
|
||||
case 1 : type|=OP_POS ; break ;
|
||||
case 2 : type|=OP_NEG ; break ;
|
||||
}
|
||||
if ( notzero!=ILLGL ) type|=OPNZ ;
|
||||
return type ;
|
||||
}
|
||||
|
||||
writeout() {
|
||||
register struct opform *next ;
|
||||
int elem[sp_lmnem-sp_fmnem+1+1] ;
|
||||
/* for each op points to first of descr. */
|
||||
register int i,currop ;
|
||||
int nch ;
|
||||
int compare() ;
|
||||
|
||||
qsort(intable,(lastform-intable)+1,sizeof intable[0],compare) ;
|
||||
|
||||
printf("int\tmaxinsl\t= %d ;\n",maxinsl) ;
|
||||
currop= -1 ; nch=0 ;
|
||||
printf("char opchoice[] = {\n") ;
|
||||
for (next=intable ; next<=lastform ; next++ ) {
|
||||
if ( (next->i_opcode&0377)!=currop ) {
|
||||
for ( currop++ ;
|
||||
currop<(next->i_opcode&0377) ; currop++ ) {
|
||||
elem[currop]= nch ;
|
||||
error("Missing opcode %s",em_mnem[currop]) ;
|
||||
}
|
||||
elem[currop]= nch ;
|
||||
}
|
||||
printf("%d, %d,",next->i_flag&0377,next->i_low&0377) ;
|
||||
nch+=2 ;
|
||||
switch ( next->i_flag&OPTYPE ) {
|
||||
case OPMINI :
|
||||
case OPSHORT :
|
||||
printf("%d,",next->i_num&0377) ; nch++ ;
|
||||
}
|
||||
printf("\n") ;
|
||||
}
|
||||
for ( currop++ ; currop<=sp_lmnem-sp_fmnem ; currop++ ) {
|
||||
elem[currop]= nch ;
|
||||
error("Missing opcode %s",em_mnem[currop]) ;
|
||||
}
|
||||
elem[sp_lmnem-sp_fmnem+1]=nch ;
|
||||
printf("0 } ;\n\nchar *opindex[] = {\n");
|
||||
for ( i=0 ; i<=sp_lmnem-sp_fmnem+1 ; i++ ) {
|
||||
printf(" &opchoice[%d],\n",elem[i]) ;
|
||||
}
|
||||
printf("} ;\n") ;
|
||||
}
|
||||
|
||||
int compare(a,b) struct opform *a,*b ; {
|
||||
if ( a->i_opcode!=b->i_opcode ) {
|
||||
return (a->i_opcode&0377)-(b->i_opcode&0377) ;
|
||||
}
|
||||
return oplength(a)-oplength(b) ;
|
||||
}
|
||||
|
||||
int oplength(a) struct opform *a ; {
|
||||
int cnt ;
|
||||
|
||||
cnt=1 ;
|
||||
if ( a->i_flag&OPESC ) cnt++ ;
|
||||
switch( a->i_flag&OPTYPE ) {
|
||||
case OPNO :
|
||||
case OPMINI : break ;
|
||||
case OP8 :
|
||||
case OPSHORT : cnt++ ; break ;
|
||||
case OP16 : cnt+=2 ; break ;
|
||||
case OP32 : cnt+=5 ; break ;
|
||||
case OP64 : cnt+=9 ; break ;
|
||||
}
|
||||
return cnt ;
|
||||
}
|
||||
|
||||
/* ----------- checking --------------*/
|
||||
|
||||
int ecodes[256],codes[256],lcodes[256] ;
|
||||
|
||||
#define NMNEM (sp_lmnem-sp_fmnem+1)
|
||||
#define MUST 1
|
||||
#define MAY 2
|
||||
#define FORB 3
|
||||
|
||||
char negc[NMNEM], zc[NMNEM], posc[NMNEM] ;
|
||||
|
||||
checkall() {
|
||||
register i,flag ;
|
||||
register struct opform *next ;
|
||||
int opc,low ;
|
||||
|
||||
for ( i=0 ; i<NMNEM ; i++ ) negc[i]=zc[i]=posc[i]=0 ;
|
||||
for ( i=0 ; i<256 ; i++ ) lcodes[i]= codes[i]= ecodes[i]= -1 ;
|
||||
codes[254]=codes[255]=ESCAP;
|
||||
|
||||
atend=0 ; line=0 ;
|
||||
for ( next=intable ; next<=lastform ; next++ ) {
|
||||
line++ ;
|
||||
flag = next->i_flag&0377 ;
|
||||
opc = next->i_opcode&0377 ;
|
||||
low = next->i_low&0377 ;
|
||||
chkc(flag,low,opc) ;
|
||||
switch(flag&OPTYPE) {
|
||||
case OPNO : zc[opc]++ ; break ;
|
||||
case OPMINI :
|
||||
case OPSHORT :
|
||||
for ( i=1 ; i<((next->i_num)&0377) ; i++ ) {
|
||||
chkc(flag,low+i,opc) ;
|
||||
}
|
||||
if ( !(em_flag[opc]&PAR_G) &&
|
||||
(flag&OPRANGE)==OP_BOTH) {
|
||||
mess("Mini's and shorties should have P or N");
|
||||
}
|
||||
break ;
|
||||
case OP8 :
|
||||
error("OP8 is removed") ;
|
||||
break ;
|
||||
case OP16 :
|
||||
if ( flag&OP_NEG )
|
||||
negc[opc]++ ;
|
||||
else if ( flag&OP_POS )
|
||||
posc[opc]++ ;
|
||||
break ;
|
||||
case OP32 :
|
||||
case OP64 :
|
||||
break ;
|
||||
default :
|
||||
error("Illegal type") ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
atend=1 ;
|
||||
for ( i=0 ; i<256 ; i++ ) if ( codes[i]== -1 ) {
|
||||
mess("interpreter opcode %d not used",i) ;
|
||||
}
|
||||
for ( opc=0 ; opc<NMNEM ; opc++ ) {
|
||||
switch(em_flag[opc]&EM_PAR) {
|
||||
case PAR_NO :
|
||||
ckop(opc,MUST,FORB,FORB) ;
|
||||
break ;
|
||||
case PAR_C:
|
||||
case PAR_D:
|
||||
case PAR_F:
|
||||
case PAR_B:
|
||||
ckop(opc,FORB,MAY,MAY) ;
|
||||
break ;
|
||||
case PAR_N:
|
||||
case PAR_G:
|
||||
case PAR_S:
|
||||
case PAR_Z:
|
||||
case PAR_O:
|
||||
case PAR_P:
|
||||
ckop(opc,FORB,MAY,FORB) ;
|
||||
break ;
|
||||
case PAR_R:
|
||||
ckop(opc,FORB,MAY,FORB) ;
|
||||
break ;
|
||||
case PAR_L:
|
||||
ckop(opc,FORB,MUST,MUST) ;
|
||||
break ;
|
||||
case PAR_W:
|
||||
ckop(opc,MUST,MAY,FORB) ;
|
||||
break ;
|
||||
default :
|
||||
error("Unknown instruction type of %s",ename(opc)) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
chkc(flag,icode,emc) {
|
||||
if ( flag&OPESC ) {
|
||||
if ( ecodes[icode]!=-1 ) {
|
||||
mess("Escaped opcode %d used by %s and %s",
|
||||
icode,ename(emc),ename(ecodes[icode])) ;
|
||||
}
|
||||
ecodes[icode]=emc;
|
||||
} else switch ( flag&OPTYPE ) {
|
||||
default:
|
||||
if ( codes[icode]!=-1 ) {
|
||||
mess("Opcode %d used by %s and %s",
|
||||
icode,ename(emc),ename(codes[icode])) ;
|
||||
}
|
||||
codes[icode]=emc;
|
||||
break ;
|
||||
case OP32:
|
||||
case OP64:
|
||||
if ( lcodes[icode]!=-1 ) {
|
||||
mess("Long opcode %d used by %s and %s",
|
||||
icode,ename(emc),ename(codes[icode])) ;
|
||||
}
|
||||
lcodes[icode]=emc;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
ckop(emc,zf,pf,nf) {
|
||||
if ( zc[emc]>1 ) mess("More then one OPNO for %s",ename(emc)) ;
|
||||
if ( posc[emc]>1 ) mess("More then one OP16(pos) for %s",ename(emc)) ;
|
||||
if ( negc[emc]>1 ) mess("More then one OP16(neg) for %s",ename(emc)) ;
|
||||
switch(zf) {
|
||||
case MUST:
|
||||
if ( zc[emc]==0 ) mess("No OPNO for %s",ename(emc)) ;
|
||||
break ;
|
||||
case FORB:
|
||||
if ( zc[emc]==1 ) mess("Forbidden OPNO for %s",ename(emc)) ;
|
||||
break ;
|
||||
}
|
||||
switch(pf) {
|
||||
case MUST:
|
||||
if ( posc[emc]==0 ) mess("No OP16(pos) for %s",ename(emc)) ;
|
||||
break ;
|
||||
case FORB:
|
||||
if ( posc[emc]==1 )
|
||||
mess("Forbidden OP16(pos) for %s",ename(emc)) ;
|
||||
break ;
|
||||
}
|
||||
switch(nf) {
|
||||
case MUST:
|
||||
if ( negc[emc]==0 ) mess("No OP16(neg) for %s",ename(emc)) ;
|
||||
break ;
|
||||
case FORB:
|
||||
if ( negc[emc]==1 )
|
||||
mess("Forbidden OP16(neg) for %s",ename(emc)) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
static int pushchar ;
|
||||
static int pushf ;
|
||||
|
||||
int readchar() {
|
||||
int c ;
|
||||
|
||||
if ( pushf ) {
|
||||
pushf=0 ;
|
||||
c = pushchar ;
|
||||
} else {
|
||||
if ( feof(stdin) ) return EOF ;
|
||||
c=getc(stdin) ;
|
||||
}
|
||||
if ( c=='\n' ) line++ ;
|
||||
return c ;
|
||||
}
|
||||
|
||||
pushback(c) {
|
||||
if ( pushf ) {
|
||||
fatal("Double pushback") ;
|
||||
}
|
||||
pushf++ ;
|
||||
pushchar=c ;
|
||||
if ( c=='\n' ) line-- ;
|
||||
}
|
||||
Loading…
Reference in a new issue