* Moved lcc and q3asm into code/tools
This commit is contained in:
Tim Angus
parent
b1cef6352e
commit
ad118b9baf
452 changed files with 0 additions and 0 deletions
314
code/tools/lcc/src/sym.c
Normal file
314
code/tools/lcc/src/sym.c
Normal file
|
|
@ -0,0 +1,314 @@
|
|||
#include "c.h"
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
#define equalp(x) v.x == p->sym.u.c.v.x
|
||||
|
||||
struct table {
|
||||
int level;
|
||||
Table previous;
|
||||
struct entry {
|
||||
struct symbol sym;
|
||||
struct entry *link;
|
||||
} *buckets[256];
|
||||
Symbol all;
|
||||
};
|
||||
#define HASHSIZE NELEMS(((Table)0)->buckets)
|
||||
static struct table
|
||||
cns = { CONSTANTS },
|
||||
ext = { GLOBAL },
|
||||
ids = { GLOBAL },
|
||||
tys = { GLOBAL };
|
||||
Table constants = &cns;
|
||||
Table externals = &ext;
|
||||
Table identifiers = &ids;
|
||||
Table globals = &ids;
|
||||
Table types = &tys;
|
||||
Table labels;
|
||||
int level = GLOBAL;
|
||||
static int tempid;
|
||||
List loci, symbols;
|
||||
|
||||
Table table(Table tp, int level) {
|
||||
Table new;
|
||||
|
||||
NEW0(new, FUNC);
|
||||
new->previous = tp;
|
||||
new->level = level;
|
||||
if (tp)
|
||||
new->all = tp->all;
|
||||
return new;
|
||||
}
|
||||
void foreach(Table tp, int lev, void (*apply)(Symbol, void *), void *cl) {
|
||||
assert(tp);
|
||||
while (tp && tp->level > lev)
|
||||
tp = tp->previous;
|
||||
if (tp && tp->level == lev) {
|
||||
Symbol p;
|
||||
Coordinate sav;
|
||||
sav = src;
|
||||
for (p = tp->all; p && p->scope == lev; p = p->up) {
|
||||
src = p->src;
|
||||
(*apply)(p, cl);
|
||||
}
|
||||
src = sav;
|
||||
}
|
||||
}
|
||||
void enterscope(void) {
|
||||
if (++level == LOCAL)
|
||||
tempid = 0;
|
||||
}
|
||||
void exitscope(void) {
|
||||
rmtypes(level);
|
||||
if (types->level == level)
|
||||
types = types->previous;
|
||||
if (identifiers->level == level) {
|
||||
if (Aflag >= 2) {
|
||||
int n = 0;
|
||||
Symbol p;
|
||||
for (p = identifiers->all; p && p->scope == level; p = p->up)
|
||||
if (++n > 127) {
|
||||
warning("more than 127 identifiers declared in a block\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
identifiers = identifiers->previous;
|
||||
}
|
||||
assert(level >= GLOBAL);
|
||||
--level;
|
||||
}
|
||||
Symbol install(const char *name, Table *tpp, int level, int arena) {
|
||||
Table tp = *tpp;
|
||||
struct entry *p;
|
||||
unsigned h = (unsigned long)name&(HASHSIZE-1);
|
||||
|
||||
assert(level == 0 || level >= tp->level);
|
||||
if (level > 0 && tp->level < level)
|
||||
tp = *tpp = table(tp, level);
|
||||
NEW0(p, arena);
|
||||
p->sym.name = (char *)name;
|
||||
p->sym.scope = level;
|
||||
p->sym.up = tp->all;
|
||||
tp->all = &p->sym;
|
||||
p->link = tp->buckets[h];
|
||||
tp->buckets[h] = p;
|
||||
return &p->sym;
|
||||
}
|
||||
Symbol relocate(const char *name, Table src, Table dst) {
|
||||
struct entry *p, **q;
|
||||
Symbol *r;
|
||||
unsigned h = (unsigned long)name&(HASHSIZE-1);
|
||||
|
||||
for (q = &src->buckets[h]; *q; q = &(*q)->link)
|
||||
if (name == (*q)->sym.name)
|
||||
break;
|
||||
assert(*q);
|
||||
/*
|
||||
Remove the entry from src's hash chain
|
||||
and from its list of all symbols.
|
||||
*/
|
||||
p = *q;
|
||||
*q = (*q)->link;
|
||||
for (r = &src->all; *r && *r != &p->sym; r = &(*r)->up)
|
||||
;
|
||||
assert(*r == &p->sym);
|
||||
*r = p->sym.up;
|
||||
/*
|
||||
Insert the entry into dst's hash chain
|
||||
and into its list of all symbols.
|
||||
Return the symbol-table entry.
|
||||
*/
|
||||
p->link = dst->buckets[h];
|
||||
dst->buckets[h] = p;
|
||||
p->sym.up = dst->all;
|
||||
dst->all = &p->sym;
|
||||
return &p->sym;
|
||||
}
|
||||
Symbol lookup(const char *name, Table tp) {
|
||||
struct entry *p;
|
||||
unsigned h = (unsigned long)name&(HASHSIZE-1);
|
||||
|
||||
assert(tp);
|
||||
do
|
||||
for (p = tp->buckets[h]; p; p = p->link)
|
||||
if (name == p->sym.name)
|
||||
return &p->sym;
|
||||
while ((tp = tp->previous) != NULL);
|
||||
return NULL;
|
||||
}
|
||||
int genlabel(int n) {
|
||||
static int label = 1;
|
||||
|
||||
label += n;
|
||||
return label - n;
|
||||
}
|
||||
Symbol findlabel(int lab) {
|
||||
struct entry *p;
|
||||
unsigned h = lab&(HASHSIZE-1);
|
||||
|
||||
for (p = labels->buckets[h]; p; p = p->link)
|
||||
if (lab == p->sym.u.l.label)
|
||||
return &p->sym;
|
||||
NEW0(p, FUNC);
|
||||
p->sym.name = stringd(lab);
|
||||
p->sym.scope = LABELS;
|
||||
p->sym.up = labels->all;
|
||||
labels->all = &p->sym;
|
||||
p->link = labels->buckets[h];
|
||||
labels->buckets[h] = p;
|
||||
p->sym.generated = 1;
|
||||
p->sym.u.l.label = lab;
|
||||
(*IR->defsymbol)(&p->sym);
|
||||
return &p->sym;
|
||||
}
|
||||
Symbol constant(Type ty, Value v) {
|
||||
struct entry *p;
|
||||
unsigned h = v.u&(HASHSIZE-1);
|
||||
|
||||
ty = unqual(ty);
|
||||
for (p = constants->buckets[h]; p; p = p->link)
|
||||
if (eqtype(ty, p->sym.type, 1))
|
||||
switch (ty->op) {
|
||||
case INT: if (equalp(i)) return &p->sym; break;
|
||||
case UNSIGNED: if (equalp(u)) return &p->sym; break;
|
||||
case FLOAT: if (equalp(d)) return &p->sym; break;
|
||||
case FUNCTION: if (equalp(g)) return &p->sym; break;
|
||||
case ARRAY:
|
||||
case POINTER: if (equalp(p)) return &p->sym; break;
|
||||
default: assert(0);
|
||||
}
|
||||
NEW0(p, PERM);
|
||||
p->sym.name = vtoa(ty, v);
|
||||
p->sym.scope = CONSTANTS;
|
||||
p->sym.type = ty;
|
||||
p->sym.sclass = STATIC;
|
||||
p->sym.u.c.v = v;
|
||||
p->link = constants->buckets[h];
|
||||
p->sym.up = constants->all;
|
||||
constants->all = &p->sym;
|
||||
constants->buckets[h] = p;
|
||||
if (ty->u.sym && !ty->u.sym->addressed)
|
||||
(*IR->defsymbol)(&p->sym);
|
||||
p->sym.defined = 1;
|
||||
return &p->sym;
|
||||
}
|
||||
Symbol intconst(int n) {
|
||||
Value v;
|
||||
|
||||
v.i = n;
|
||||
return constant(inttype, v);
|
||||
}
|
||||
Symbol genident(int scls, Type ty, int lev) {
|
||||
Symbol p;
|
||||
|
||||
NEW0(p, lev >= LOCAL ? FUNC : PERM);
|
||||
p->name = stringd(genlabel(1));
|
||||
p->scope = lev;
|
||||
p->sclass = scls;
|
||||
p->type = ty;
|
||||
p->generated = 1;
|
||||
if (lev == GLOBAL)
|
||||
(*IR->defsymbol)(p);
|
||||
return p;
|
||||
}
|
||||
|
||||
Symbol temporary(int scls, Type ty) {
|
||||
Symbol p;
|
||||
|
||||
NEW0(p, FUNC);
|
||||
p->name = stringd(++tempid);
|
||||
p->scope = level < LOCAL ? LOCAL : level;
|
||||
p->sclass = scls;
|
||||
p->type = ty;
|
||||
p->temporary = 1;
|
||||
p->generated = 1;
|
||||
return p;
|
||||
}
|
||||
Symbol newtemp(int sclass, int tc, int size) {
|
||||
Symbol p = temporary(sclass, btot(tc, size));
|
||||
|
||||
(*IR->local)(p);
|
||||
p->defined = 1;
|
||||
return p;
|
||||
}
|
||||
|
||||
Symbol allsymbols(Table tp) {
|
||||
return tp->all;
|
||||
}
|
||||
|
||||
void locus(Table tp, Coordinate *cp) {
|
||||
loci = append(cp, loci);
|
||||
symbols = append(allsymbols(tp), symbols);
|
||||
}
|
||||
|
||||
void use(Symbol p, Coordinate src) {
|
||||
Coordinate *cp;
|
||||
|
||||
NEW(cp, PERM);
|
||||
*cp = src;
|
||||
p->uses = append(cp, p->uses);
|
||||
}
|
||||
/* findtype - find type ty in identifiers */
|
||||
Symbol findtype(Type ty) {
|
||||
Table tp = identifiers;
|
||||
int i;
|
||||
struct entry *p;
|
||||
|
||||
assert(tp);
|
||||
do
|
||||
for (i = 0; i < HASHSIZE; i++)
|
||||
for (p = tp->buckets[i]; p; p = p->link)
|
||||
if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
|
||||
return &p->sym;
|
||||
while ((tp = tp->previous) != NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* mkstr - make a string constant */
|
||||
Symbol mkstr(char *str) {
|
||||
Value v;
|
||||
Symbol p;
|
||||
|
||||
v.p = str;
|
||||
p = constant(array(chartype, strlen(v.p) + 1, 0), v);
|
||||
if (p->u.c.loc == NULL)
|
||||
p->u.c.loc = genident(STATIC, p->type, GLOBAL);
|
||||
return p;
|
||||
}
|
||||
|
||||
/* mksymbol - make a symbol for name, install in &globals if sclass==EXTERN */
|
||||
Symbol mksymbol(int sclass, const char *name, Type ty) {
|
||||
Symbol p;
|
||||
|
||||
if (sclass == EXTERN)
|
||||
p = install(string(name), &globals, GLOBAL, PERM);
|
||||
else {
|
||||
NEW0(p, PERM);
|
||||
p->name = string(name);
|
||||
p->scope = GLOBAL;
|
||||
}
|
||||
p->sclass = sclass;
|
||||
p->type = ty;
|
||||
(*IR->defsymbol)(p);
|
||||
p->defined = 1;
|
||||
return p;
|
||||
}
|
||||
|
||||
/* vtoa - return string for the constant v of type ty */
|
||||
char *vtoa(Type ty, Value v) {
|
||||
|
||||
ty = unqual(ty);
|
||||
switch (ty->op) {
|
||||
case INT: return stringd(v.i);
|
||||
case UNSIGNED: return stringf((v.u&~0x7FFF) ? "0x%X" : "%U", v.u);
|
||||
case FLOAT: return stringf("%g", (double)v.d);
|
||||
case ARRAY:
|
||||
if (ty->type == chartype || ty->type == signedchar
|
||||
|| ty->type == unsignedchar)
|
||||
return v.p;
|
||||
return stringf("%p", v.p);
|
||||
case POINTER: return stringf("%p", v.p);
|
||||
case FUNCTION: return stringf("%p", v.g);
|
||||
}
|
||||
assert(0); return NULL;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue