/* I N T E R M E D I A T E C O D E * * I C _ L O O K U P . C */ #include #include "../share/types.h" #include "../share/debug.h" #include "../share/map.h" #include "../../../h/em_spec.h" #include "ic.h" #include "ic_lookup.h" #include "../share/alloc.h" sym_p symhash[NSYMHASH]; prc_p prochash[NPROCHASH]; num_p numhash[NNUMHASH]; /* instr_lab */ lab_id instr_lab(number) short number; { register num_p *npp, np; /* In EM assembly language, a label is an unsigned number, * e.g. 120 in 'BRA *120'. In IC the labels of a procedure * are represented by consecutive integer numbers, called * lab_id. The mapping takes place here. */ npp = &numhash[number%NNUMHASH]; while (*npp != (num_p) 0) { if ((*npp)->n_number == number) { return(*npp)->n_labid; } else { npp = &(*npp)->n_next; } } /* The label was not found in the hashtable, so * create a new entry for it. */ *npp = np = newnum(); np->n_number = number; np->n_labid = ++lastlid; /* Assign a new label identifier to the num struct. * lastlid is reset to 0 at the beginning of * every new EM procedure (by cleaninstrlabs). */ return (np->n_labid); } /* symlookup */ STATIC unsigned hash(string) char *string; { register char *p; register unsigned i,sum; for (sum=i=0,p=string;*p;i += 3) sum ^= (*p++)<<(i&07); return(sum); } dblock_p symlookup(name, status) char *name; int status; { /* Look up the name of a data block. The name can appear * in either a defining or applied occurrence (status is * DEFINING, OCCURRING resp.), or in a MES ms_ext instruction * as the name of a data block imported by a library module * (status is IMPORTING). Things get complicated, * because a HOL pseudo need not be preceded by a * data label, i.e. a hol block need not have a name. */ register sym_p *spp, sp; register dblock_p dp; if (name == (char *) 0) { assert(status == DEFINING); dp = newdblock(); } else { spp = &symhash[hash(name)%NSYMHASH]; while (*spp != (sym_p) 0) { /* Every hashtable entry points to a list * of synonyms (i.e. names with the same * hash values). Try to find 'name' in its * list. */ if (strncmp((*spp)->sy_name, name, IDL) == 0) { /* found */ return ((*spp)->sy_dblock); } else { spp = &(*spp)->sy_next; } } /* The name is not found, so create a new entry for it. * However, if the status is IMPORTING, we just return 0, * indicating that we don't need this name. */ if (status == IMPORTING) return (dblock_p) 0; *spp = sp = newsym(); strncpy(sp->sy_name, name, IDL); dp = sp->sy_dblock = newdblock(); } if (fdblock == (dblock_p) 0) { fdblock = dp; /* first data block */ } else { ldblock->d_next = dp; /* link to last dblock */ } ldblock = dp; dp->d_pseudo = DUNKNOWN; /* clear all fields */ dp->d_id = ++lastdid; dp->d_size = 0; dp->d_objlist = (obj_p) 0; dp->d_values = (arg_p) 0; dp->d_next = (dblock_p) 0; dp->d_flags1 = 0; dp->d_flags2 = 0; if (status == OCCURRING) { /* This is the first occurrence of the identifier, * so if it is a used occurrence make the * identifier externally visible, else make it * internal. */ dp->d_flags1 |= DF_EXTERNAL; } return dp; } /* getsym */ dblock_p getsym(status) int status; { if (table2() != DLBX) { error("symbol expected"); } return(symlookup(string,status)); } /* getproc */ proc_p getproc(status) int status; { if (table2() != sp_pnam) { error("proc name expected"); } return(proclookup(string,status)); } /* proclookup */ proc_p proclookup(name, status) char *name; int status; { register prc_p *ppp, pp; register proc_p dp; ppp = &prochash[hash(name)%NPROCHASH]; while (*ppp != (prc_p) 0) { /* Every hashtable entry points to a list * of synonyms (i.e. names with the same * hash values). Try to find 'name' in its * list. */ if (strncmp((*ppp)->pr_name, name, IDL) == 0) { /* found */ return ((*ppp)->pr_proc); } else { ppp = &(*ppp)->pr_next; } } /* The name is not found, so create a new entry for it, * unless the status is IMPORTING, in which case we * return 0, indicating we don't want this proc. */ if (status == IMPORTING) return (proc_p) 0; *ppp = pp = newprc(); strncpy(pp->pr_name, name, IDL); dp = pp->pr_proc = newproc(); if (fproc == (proc_p) 0) { fproc = dp; /* first proc */ } else { lproc->p_next = dp; } lproc = dp; dp->p_id = ++lastpid; /* create a unique proc_id */ dp->p_next = (proc_p) 0; dp->p_flags1 = 0; dp->p_flags2 = 0; if (status == OCCURRING) { /* This is the first occurrence of the identifier, * so if it is a used occurrence the make the * identifier externally visible, else make it * internal. */ dp->p_flags1 |= PF_EXTERNAL; } return dp; } /* cleaninstrlabs */ cleaninstrlabs() { register num_p *npp, np, next; for (npp = numhash; npp < &numhash[NNUMHASH]; npp++) { for (np = *npp; np != (num_p) 0; np = next) { next = np->n_next; oldnum(np); } *npp = (num_p) 0; } /* Reset last label id (used by instr_lab). */ lastlid = (lab_id) 0; } /* dump_procnames */ dump_procnames(hash,n,f) prc_p hash[]; int n; FILE *f; { /* Save the names of the EM procedures in file f. * Note that the Optimizer Intermediate Code does not * use identifiers but proc_ids, object_ids etc. * The names, however, can be used after optimization * is completed, to reconstruct Compact Assembly Language. * The output consists of tuples (proc_id, name). * This routine is called once for every input file. * To prevent names of external procedures being written * more than once, the PF_WRITTEN flag is used. */ register prc_p *pp, ph; proc_p p; char str[IDL+1]; register int i; #define PF_WRITTEN 01 for (pp = &hash[0]; pp < &hash[n]; pp++) { /* Traverse the entire hash table */ for (ph = *pp; ph != (prc_p) 0; ph = ph->pr_next) { /* Traverse the list of synonyms */ p = ph->pr_proc; if ((p->p_flags2 & PF_WRITTEN) == 0) { /* not been written yet */ for(i = 0; i < IDL; i++) { str[i] = ph->pr_name[i]; } str[IDL] = '\0'; fprintf(f,"%d %s\n",p->p_id, str); p->p_flags2 |= PF_WRITTEN; } } } } /* cleanprocs */ cleanprocs(hash,n,mask) prc_p hash[]; int n,mask; { /* After an EM input file has been processed, the names * of those procedures that are internal (i.e. not visible * outside the file they are defined in) must be removed * from the procedure hash table. This is accomplished * by removing the 'prc struct' from its synonym list. * After the final input file has been processed, all * remaining prc structs are also removed. */ register prc_p *pp, ph, x, next; for (pp = &hash[0]; pp < &hash[n]; pp++) { /* Traverse the hash table */ x = (prc_p) 0; for (ph = *pp; ph != (prc_p) 0; ph = next) { /* Traverse the synonym list. * x points to the prc struct just before ph, * or is 0 if ph is the first struct of * the list. */ next = ph->pr_next; if ((ph->pr_proc->p_flags1 & mask) == 0) { if (x == (prc_p) 0) { *pp = next; } else { x->pr_next = next; } oldprc(ph); /* delete the struct */ } else { x = ph; } } } } /* dump_dblocknames */ dump_dblocknames(hash,n,f) sym_p hash[]; int n; FILE *f; { /* Save the names of the EM data blocks in file f. * The output consists of tuples (dblock_id, name). * This routine is called once for every input file. */ register sym_p *sp, sh; dblock_p d; char str[IDL+1]; register int i; #define DF_WRITTEN 01 for (sp = &hash[0]; sp < &hash[n]; sp++) { /* Traverse the entire hash table */ for (sh = *sp; sh != (sym_p) 0; sh = sh->sy_next) { /* Traverse the list of synonyms */ d = sh->sy_dblock; if ((d->d_flags2 & DF_WRITTEN) == 0) { /* not been written yet */ for (i = 0; i < IDL; i++) { str[i] = sh->sy_name[i]; str[IDL] = '\0'; } fprintf(f,"%d %s\n",d->d_id, str); d->d_flags2 |= DF_WRITTEN; } } } } /* cleandblocks */ cleandblocks(hash,n,mask) sym_p hash[]; int n,mask; { /* After an EM input file has been processed, the names * of those data blocks that are internal must be removed. */ register sym_p *sp, sh, x, next; for (sp = &hash[0]; sp < &hash[n]; sp++) { x = (sym_p) 0; for (sh = *sp; sh != (sym_p) 0; sh = next) { next = sh->sy_next; if ((sh->sy_dblock->d_flags1 & mask) == 0) { if (x == (sym_p) 0) { *sp = next; } else { x->sy_next = next; } oldsym(sh); /* delete the struct */ } else { x = sh; } } } }