460 lines
8.7 KiB
C
460 lines
8.7 KiB
C
/* I N T E R M E D I A T E C O D E
|
|
*
|
|
* I C _ A U X . C
|
|
*/
|
|
|
|
|
|
|
|
#include "../share/types.h"
|
|
#include "../share/global.h"
|
|
#include "../share/debug.h"
|
|
#include "../share/def.h"
|
|
#include "../share/aux.h"
|
|
#include "../../../h/em_pseu.h"
|
|
#include "../../../h/em_spec.h"
|
|
#include "../../../h/em_mnem.h"
|
|
#include "ic.h"
|
|
#include "ic_io.h"
|
|
#include "ic_lookup.h"
|
|
#include "../share/alloc.h"
|
|
#include "ic_aux.h"
|
|
|
|
|
|
|
|
/* opr_size */
|
|
|
|
offset opr_size(instr)
|
|
short instr;
|
|
{
|
|
switch(instr) {
|
|
case op_loe:
|
|
case op_ste:
|
|
case op_ine:
|
|
case op_dee:
|
|
case op_zre:
|
|
return (offset) ws;
|
|
case op_lde:
|
|
case op_sde:
|
|
return (offset) 2*ws;
|
|
case op_lae:
|
|
case op_fil:
|
|
return (offset) UNKNOWN_SIZE;
|
|
default:
|
|
error("illegal operand of opr_size: %d", instr);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
|
|
|
|
/* dblockdef */
|
|
|
|
STATIC offset argsize(arg)
|
|
arg_p arg;
|
|
{
|
|
/* Compute the size (in bytes) that the given initializer
|
|
* will occupy.
|
|
*/
|
|
|
|
offset s;
|
|
argb_p argb;
|
|
|
|
switch(arg->a_type) {
|
|
case ARGOFF:
|
|
/* See if value fits in a short */
|
|
if ((short) arg->a_a.a_offset == arg->a_a.a_offset) {
|
|
return ws;
|
|
} else {
|
|
return 2*ws;
|
|
}
|
|
case ARGINSTRLAB:
|
|
case ARGOBJECT:
|
|
case ARGPROC:
|
|
return ps; /* pointer size */
|
|
case ARGSTRING:
|
|
/* strings are partitioned into pieces */
|
|
s = 0;
|
|
for (argb = &arg->a_a.a_string; argb != (argb_p) 0;
|
|
argb = argb->ab_next) {
|
|
s += argb->ab_index;
|
|
}
|
|
return s;
|
|
case ARGICN:
|
|
case ARGUCN:
|
|
case ARGFCN:
|
|
return arg->a_a.a_con.ac_length;
|
|
default:
|
|
assert(FALSE);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
|
|
STATIC offset blocksize(pseudo,args)
|
|
byte pseudo;
|
|
arg_p args;
|
|
{
|
|
/* Determine the number of bytes of a datablock */
|
|
|
|
arg_p arg;
|
|
offset sum;
|
|
|
|
switch(pseudo) {
|
|
case DHOL:
|
|
case DBSS:
|
|
if (args->a_type != ARGOFF) {
|
|
error("offset expected");
|
|
}
|
|
return args->a_a.a_offset;
|
|
case DCON:
|
|
case DROM:
|
|
sum = 0;
|
|
for (arg = args; arg != (arg_p) 0; arg = arg->a_next) {
|
|
/* Add the sizes of all initializers */
|
|
sum += argsize(arg);
|
|
}
|
|
return sum;
|
|
default:
|
|
assert(FALSE);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
|
|
STATIC arg_p copy_arg(arg)
|
|
arg_p arg;
|
|
{
|
|
/* Copy one argument */
|
|
|
|
arg_p new;
|
|
|
|
assert(arg->a_type == ARGOFF);
|
|
new = newarg(ARGOFF);
|
|
new->a_a.a_offset = arg->a_a.a_offset;
|
|
return new;
|
|
}
|
|
|
|
|
|
|
|
STATIC arg_p copy_rom(args)
|
|
arg_p args;
|
|
{
|
|
/* Make a copy of the values of a rom,
|
|
* provided that the rom contains only integer values,
|
|
*/
|
|
|
|
arg_p arg, arg2, argh;
|
|
|
|
for (arg = args; arg != (arg_p) 0; arg = arg->a_next) {
|
|
if (arg->a_type != ARGOFF) {
|
|
return (arg_p) 0;
|
|
}
|
|
}
|
|
/* Now make the copy */
|
|
arg2 = argh = copy_arg(args);
|
|
for (arg = args->a_next; arg != (arg_p) 0; arg = arg->a_next) {
|
|
arg2->a_next = copy_arg(arg);
|
|
arg2 = arg2->a_next;
|
|
}
|
|
return argh;
|
|
}
|
|
|
|
|
|
|
|
dblockdef(db,n,lnp)
|
|
dblock_p db;
|
|
int n;
|
|
line_p lnp;
|
|
{
|
|
/* Process a data block defining occurrence */
|
|
|
|
byte m;
|
|
|
|
switch(n) {
|
|
case ps_hol:
|
|
m = DHOL;
|
|
break;
|
|
case ps_bss:
|
|
m = DBSS;
|
|
break;
|
|
case ps_con:
|
|
m = DCON;
|
|
break;
|
|
case ps_rom:
|
|
m = DROM;
|
|
break;
|
|
default:
|
|
assert(FALSE);
|
|
}
|
|
db->d_pseudo = m;
|
|
db->d_size = blocksize(m, ARG(lnp));
|
|
if (m == DROM) {
|
|
/* We keep the values of a rom block in the data block
|
|
* table if the values consist of integers only.
|
|
*/
|
|
db->d_values = copy_rom(ARG(lnp));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* combine */
|
|
|
|
combine(db,l1,l2,pseu)
|
|
dblock_p db;
|
|
line_p l1,l2;
|
|
byte pseu;
|
|
{
|
|
/* Combine two successive ROMs/CONs (without a data label
|
|
* in between into a single ROM. E.g.:
|
|
* xyz
|
|
* rom 3,6,9,12
|
|
* rom 7,0,2
|
|
* is changed into:
|
|
* xyz
|
|
* rom 3,6,9,12,7,0,2
|
|
*/
|
|
|
|
arg_p v;
|
|
|
|
db->d_size += blocksize(pseu,ARG(l2));
|
|
/* db is the data block that was already assigned to the
|
|
* first rom/con. The second one is not assigned a new
|
|
* data block of course, as the two are combined into
|
|
* one instruction.
|
|
*/
|
|
if (pseu == DROM && db->d_values != (arg_p) 0) {
|
|
/* The values contained in a ROM are only copied
|
|
* to the data block if they may be useful to us
|
|
* (e.g. they certainly may not be strings). In our
|
|
* case it means that both ROMs must have useful
|
|
* arguments.
|
|
*/
|
|
for (v = db->d_values; v->a_next != (arg_p) 0; v = v->a_next);
|
|
/* The first rom contained useful arguments. v now points to
|
|
* its last argument. Append the arguments of the second
|
|
* rom to this list. If the second rom has arguments that are
|
|
* not useful, throw away the entire list (we want to copy
|
|
* everything or nothing).
|
|
*/
|
|
if ((v->a_next = copy_rom(ARG(l2))) == (arg_p) 0) {
|
|
oldargs(db->d_values);
|
|
db->d_values = (arg_p) 0;
|
|
}
|
|
}
|
|
for (v = ARG(l1); v->a_next != (arg_p) 0; v = v->a_next);
|
|
/* combine the arguments of both instructions. */
|
|
v->a_next = ARG(l2);
|
|
ARG(l2) = (arg_p) 0;
|
|
}
|
|
|
|
|
|
|
|
/* arglist */
|
|
|
|
STATIC arg_string(length,abp)
|
|
offset length;
|
|
register argb_p abp;
|
|
{
|
|
|
|
while (length--) {
|
|
if (abp->ab_index == NARGBYTES)
|
|
abp = abp->ab_next = newargb();
|
|
abp->ab_contents[abp->ab_index++] = readchar();
|
|
}
|
|
}
|
|
|
|
|
|
line_p arglist(n)
|
|
int n;
|
|
{
|
|
line_p lnp;
|
|
register arg_p ap,*app;
|
|
bool moretocome;
|
|
offset length;
|
|
|
|
|
|
/*
|
|
* creates an arglist with n elements
|
|
* if n == 0 the arglist is variable and terminated by sp_cend
|
|
*/
|
|
|
|
lnp = newline(OPLIST);
|
|
app = &ARG(lnp);
|
|
moretocome = TRUE;
|
|
do {
|
|
switch(table2()) {
|
|
default:
|
|
error("unknown byte in arglist");
|
|
case CSTX1:
|
|
tabval2 = (offset) tabval;
|
|
case CSTX2:
|
|
*app = ap = newarg(ARGOFF);
|
|
ap->a_a.a_offset = tabval2;
|
|
app = &ap->a_next;
|
|
break;
|
|
case ILBX:
|
|
*app = ap = newarg(ARGINSTRLAB);
|
|
ap->a_a.a_instrlab = instr_lab((short) tabval);
|
|
app = &ap->a_next;
|
|
break;
|
|
case DLBX:
|
|
*app = ap = newarg(ARGOBJECT);
|
|
ap->a_a.a_obj = object(string,(offset) 0, (offset) 0);
|
|
/* The size of the object is unknown */
|
|
app = &ap->a_next;
|
|
break;
|
|
case sp_pnam:
|
|
*app = ap = newarg(ARGPROC);
|
|
ap->a_a.a_proc = proclookup(string,OCCURRING);
|
|
app = &ap->a_next;
|
|
break;
|
|
case VALX1:
|
|
tabval2 = (offset) tabval;
|
|
case VALX2:
|
|
*app = ap = newarg(ARGOBJECT);
|
|
ap->a_a.a_obj = object(string, tabval2, (offset) 0);
|
|
app = &ap->a_next;
|
|
break;
|
|
case sp_scon:
|
|
*app = ap = newarg(ARGSTRING);
|
|
length = get_off();
|
|
arg_string(length,&ap->a_a.a_string);
|
|
app = &ap->a_next;
|
|
break;
|
|
case sp_icon:
|
|
*app = ap = newarg(ARGICN);
|
|
goto casecon;
|
|
case sp_ucon:
|
|
*app = ap = newarg(ARGUCN);
|
|
goto casecon;
|
|
case sp_fcon:
|
|
*app = ap = newarg(ARGFCN);
|
|
casecon:
|
|
length = get_int();
|
|
ap->a_a.a_con.ac_length = (short) length;
|
|
arg_string(get_off(),&ap->a_a.a_con.ac_con);
|
|
app = &ap->a_next;
|
|
break;
|
|
case sp_cend:
|
|
moretocome = FALSE;
|
|
}
|
|
if (n && (--n) == 0)
|
|
moretocome = FALSE;
|
|
} while (moretocome);
|
|
return(lnp);
|
|
}
|
|
|
|
|
|
|
|
/* is_datalabel */
|
|
|
|
bool is_datalabel(l)
|
|
line_p l;
|
|
{
|
|
VL(l);
|
|
return (l->l_instr == (byte) ps_sym);
|
|
}
|
|
|
|
|
|
|
|
/* block_of_lab */
|
|
|
|
dblock_p block_of_lab(ident)
|
|
char *ident;
|
|
{
|
|
dblock_p dbl;
|
|
|
|
/* Find the datablock with the given name.
|
|
* Used for defining occurrences.
|
|
*/
|
|
|
|
dbl = symlookup(ident,DEFINING);
|
|
VD(dbl);
|
|
if (dbl->d_pseudo != DUNKNOWN) {
|
|
error("identifier redeclared");
|
|
}
|
|
return dbl;
|
|
}
|
|
|
|
|
|
|
|
/* object */
|
|
|
|
STATIC obj_p make_object(dbl,off,size)
|
|
dblock_p dbl;
|
|
offset off;
|
|
offset size;
|
|
{
|
|
/* Allocate an obj struct with the given attributes
|
|
* (if it did not exist already).
|
|
* Return a pointer to the found or newly created object struct.
|
|
*/
|
|
|
|
obj_p obj, prev, new;
|
|
|
|
/* See if the object was already present in the object list
|
|
* of the given datablock. If it is not yet present, find
|
|
* the right place to insert the new object. Note that
|
|
* the objects are sorted by offset.
|
|
*/
|
|
prev = (obj_p) 0;
|
|
for (obj = dbl->d_objlist; obj != (obj_p) 0; obj = obj->o_next) {
|
|
if (obj->o_off >= off) {
|
|
break;
|
|
}
|
|
prev = obj;
|
|
}
|
|
/* Note that the data block may contain several objects
|
|
* with the required offset; we also want the size to
|
|
* be the right one.
|
|
*/
|
|
while (obj != (obj_p) 0 && obj->o_off == off) {
|
|
if (obj->o_size == UNKNOWN_SIZE) {
|
|
obj->o_size = size;
|
|
return obj;
|
|
} else {
|
|
if (size == UNKNOWN_SIZE || obj->o_size == size) {
|
|
return obj;
|
|
/* This is the right one */
|
|
} else {
|
|
prev = obj;
|
|
obj = obj->o_next;
|
|
}
|
|
}
|
|
}
|
|
/* Allocate a new object */
|
|
new = newobject();
|
|
new->o_id = ++lastoid; /* create a unique object id */
|
|
new->o_off = off;
|
|
new->o_size = size;
|
|
new->o_dblock = dbl;
|
|
/* Insert the new object */
|
|
if (prev == (obj_p) 0) {
|
|
dbl->d_objlist = new;
|
|
} else {
|
|
prev->o_next = new;
|
|
}
|
|
new->o_next = obj;
|
|
return new;
|
|
}
|
|
|
|
|
|
|
|
obj_p object(ident,off,size)
|
|
char *ident;
|
|
offset off;
|
|
offset size;
|
|
{
|
|
dblock_p dbl;
|
|
|
|
/* Create an object struct (if it did not yet exist)
|
|
* for the object with the given size and offset
|
|
* within the datablock of the given name.
|
|
*/
|
|
|
|
dbl = (ident == (char *) 0 ? curhol : symlookup(ident, OCCURRING));
|
|
VD(dbl);
|
|
return(make_object(dbl,off,size));
|
|
}
|