2005-08-26 17:39:27 +00:00
|
|
|
#include <time.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include "c.h"
|
|
|
|
|
|
|
|
#define I(f) s_##f
|
|
|
|
|
|
|
|
static Node *tail;
|
|
|
|
static int off, maxoff, uid = 0, verbose = 0, html = 0;
|
|
|
|
|
|
|
|
static const char *yyBEGIN(const char *tag) {
|
|
|
|
if (html)
|
|
|
|
print("<%s>", tag);
|
|
|
|
return tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void yyEND(const char *tag) {
|
|
|
|
if (html)
|
|
|
|
print("</%s>", tag);
|
|
|
|
if (isupper(*tag))
|
|
|
|
print("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
#define BEGIN(tag) do { const char *yytag=yyBEGIN(#tag);
|
|
|
|
#define END yyEND(yytag); } while (0)
|
|
|
|
#define ITEM BEGIN(li)
|
|
|
|
#define START BEGIN(LI)
|
|
|
|
#define ANCHOR(attr,code) do { const char *yytag="a"; if (html) { printf("<a " #attr "=\""); code; print("\">"); }
|
|
|
|
#define NEWLINE print(html ? "<br>\n" : "\n")
|
|
|
|
|
|
|
|
static void emitCoord(Coordinate src) {
|
|
|
|
if (src.file && *src.file) {
|
|
|
|
ANCHOR(href,print("%s", src.file)); print("%s", src.file); END;
|
|
|
|
print(":");
|
|
|
|
}
|
|
|
|
print("%d.%d", src.y, src.x);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void emitString(int len, const char *s) {
|
|
|
|
for ( ; len-- > 0; s++)
|
|
|
|
if (*s == '&' && html)
|
|
|
|
print("&");
|
|
|
|
else if (*s == '<' && html)
|
|
|
|
print("<");
|
|
|
|
else if (*s == '>' && html)
|
|
|
|
print("<");
|
|
|
|
else if (*s == '"' || *s == '\\')
|
|
|
|
print("\\%c", *s);
|
|
|
|
else if (*s >= ' ' && *s < 0177)
|
|
|
|
print("%c", *s);
|
|
|
|
else
|
|
|
|
print("\\%d%d%d", (*s>>6)&3, (*s>>3)&7, *s&7);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void emitSymRef(Symbol p) {
|
|
|
|
(*IR->defsymbol)(p);
|
|
|
|
ANCHOR(href,print("#%s", p->x.name)); BEGIN(code); print("%s", p->name); END; END;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void emitSymbol(Symbol p) {
|
|
|
|
(*IR->defsymbol)(p);
|
|
|
|
ANCHOR(name,print("%s", p->x.name)); BEGIN(code); print("%s", p->name); END; END;
|
|
|
|
BEGIN(ul);
|
|
|
|
#define xx(field,code) ITEM; if (!html) print(" "); print(#field "="); code; END
|
|
|
|
if (verbose && (src.y || src.x))
|
|
|
|
xx(src,emitCoord(p->src));
|
|
|
|
xx(type,print("%t", p->type));
|
|
|
|
xx(sclass,print("%k", p->sclass));
|
|
|
|
switch (p->scope) {
|
|
|
|
case CONSTANTS: xx(scope,print("CONSTANTS")); break;
|
|
|
|
case LABELS: xx(scope,print("LABELS")); break;
|
|
|
|
case GLOBAL: xx(scope,print("GLOBAL")); break;
|
|
|
|
case PARAM: xx(scope,print("PARAM")); break;
|
|
|
|
case LOCAL: xx(scope,print("LOCAL")); break;
|
|
|
|
default:
|
|
|
|
if (p->scope > LOCAL)
|
|
|
|
xx(scope,print("LOCAL+%d", p->scope-LOCAL));
|
|
|
|
else
|
|
|
|
xx(scope,print("%d", p->scope));
|
|
|
|
}
|
|
|
|
if (p->scope >= PARAM && p->sclass != STATIC)
|
|
|
|
xx(offset,print("%d", p->x.offset));
|
|
|
|
xx(ref,print("%f", p->ref));
|
|
|
|
if (p->temporary && p->u.t.cse)
|
|
|
|
xx(u.t.cse,print("%p", p->u.t.cse));
|
|
|
|
END;
|
|
|
|
#undef xx
|
|
|
|
}
|
|
|
|
|
|
|
|
/* address - initialize q for addressing expression p+n */
|
|
|
|
static void I(address)(Symbol q, Symbol p, long n) {
|
|
|
|
q->name = stringf("%s%s%D", p->name, n > 0 ? "+" : "", n);
|
|
|
|
(*IR->defsymbol)(q);
|
|
|
|
START; print("address "); emitSymbol(q); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* blockbeg - start a block */
|
|
|
|
static void I(blockbeg)(Env *e) {
|
|
|
|
e->offset = off;
|
|
|
|
START; print("blockbeg off=%d", off); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* blockend - start a block */
|
|
|
|
static void I(blockend)(Env *e) {
|
|
|
|
if (off > maxoff)
|
|
|
|
maxoff = off;
|
|
|
|
START; print("blockend off=%d", off); END;
|
|
|
|
off = e->offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* defaddress - initialize an address */
|
|
|
|
static void I(defaddress)(Symbol p){
|
|
|
|
START; print("defaddress "); emitSymRef(p); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* defconst - define a constant */
|
|
|
|
static void I(defconst)(int suffix, int size, Value v) {
|
|
|
|
START;
|
|
|
|
print("defconst ");
|
|
|
|
switch (suffix) {
|
|
|
|
case I:
|
|
|
|
print("int.%d ", size);
|
|
|
|
BEGIN(code);
|
|
|
|
if (size > sizeof (int))
|
|
|
|
print("%D", v.i);
|
|
|
|
else
|
|
|
|
print("%d", (int)v.i);
|
|
|
|
END;
|
|
|
|
break;
|
|
|
|
case U:
|
|
|
|
print("unsigned.%d ", size);
|
|
|
|
BEGIN(code);
|
|
|
|
if (size > sizeof (unsigned))
|
|
|
|
print("%U", v.u);
|
|
|
|
else
|
|
|
|
print("%u", (unsigned)v.u);
|
|
|
|
END;
|
|
|
|
break;
|
|
|
|
case P: print("void*.%d ", size); BEGIN(code); print("%p", v.p); END; break;
|
|
|
|
case F: print("float.%d ", size); BEGIN(code); print("%g", (double)v.d); END; break;
|
|
|
|
default: assert(0);
|
|
|
|
}
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* defstring - emit a string constant */
|
|
|
|
static void I(defstring)(int len, char *s) {
|
|
|
|
START; print("defstring ");
|
|
|
|
BEGIN(code); print("\""); emitString(len, s); print("\""); END;
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* defsymbol - define a symbol: initialize p->x */
|
|
|
|
static void I(defsymbol)(Symbol p) {
|
|
|
|
if (p->x.name == NULL)
|
|
|
|
p->x.name = stringd(++uid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* emit - emit the dags on list p */
|
|
|
|
static void I(emit)(Node p){
|
|
|
|
ITEM;
|
|
|
|
if (!html)
|
|
|
|
print(" ");
|
|
|
|
for (; p; p = p->x.next) {
|
|
|
|
if (p->op == LABEL+V) {
|
|
|
|
assert(p->syms[0]);
|
|
|
|
ANCHOR(name,print("%s", p->syms[0]->x.name));
|
|
|
|
BEGIN(code); print("%s", p->syms[0]->name); END;
|
|
|
|
END;
|
|
|
|
print(":");
|
|
|
|
} else {
|
|
|
|
int i;
|
|
|
|
if (p->x.listed) {
|
|
|
|
BEGIN(strong); print("%d", p->x.inst); END; print("'");
|
|
|
|
print(" %s", opname(p->op));
|
|
|
|
} else
|
|
|
|
print("%d. %s", p->x.inst, opname(p->op));
|
|
|
|
if (p->count > 1)
|
|
|
|
print(" count=%d", p->count);
|
|
|
|
for (i = 0; i < NELEMS(p->kids) && p->kids[i]; i++)
|
|
|
|
print(" #%d", p->kids[i]->x.inst);
|
|
|
|
if (generic(p->op) == CALL && p->syms[0] && p->syms[0]->type)
|
|
|
|
print(" {%t}", p->syms[0]->type);
|
|
|
|
else
|
|
|
|
for (i = 0; i < NELEMS(p->syms) && p->syms[i]; i++) {
|
|
|
|
print(" ");
|
|
|
|
if (p->syms[i]->scope == CONSTANTS)
|
|
|
|
print(p->syms[i]->name);
|
|
|
|
else
|
|
|
|
emitSymRef(p->syms[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NEWLINE;
|
|
|
|
}
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* export - announce p as exported */
|
|
|
|
static void I(export)(Symbol p) {
|
|
|
|
START; print("export "); emitSymRef(p); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* function - generate code for a function */
|
|
|
|
static void I(function)(Symbol f, Symbol caller[], Symbol callee[], int ncalls) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
(*IR->defsymbol)(f);
|
|
|
|
off = 0;
|
|
|
|
for (i = 0; caller[i] && callee[i]; i++) {
|
|
|
|
off = roundup(off, caller[i]->type->align);
|
|
|
|
caller[i]->x.offset = callee[i]->x.offset = off;
|
|
|
|
off += caller[i]->type->size;
|
|
|
|
}
|
|
|
|
if (!html) {
|
|
|
|
print("function ");
|
|
|
|
emitSymbol(f);
|
|
|
|
print(" ncalls=%d\n", ncalls);
|
|
|
|
for (i = 0; caller[i]; i++)
|
|
|
|
START; print("caller "); emitSymbol(caller[i]); END;
|
|
|
|
for (i = 0; callee[i]; i++)
|
|
|
|
START; print("callee "); emitSymbol(callee[i]); END;
|
|
|
|
} else {
|
|
|
|
START;
|
|
|
|
print("function");
|
|
|
|
BEGIN(UL);
|
|
|
|
#define xx(field,code) ITEM; print(#field "="); code; END
|
|
|
|
xx(f,emitSymbol(f));
|
|
|
|
xx(ncalls,print("%d", ncalls));
|
|
|
|
if (caller[0]) {
|
|
|
|
ITEM; print("caller"); BEGIN(OL);
|
|
|
|
for (i = 0; caller[i]; i++)
|
|
|
|
ITEM; emitSymbol(caller[i]); END;
|
|
|
|
END; END;
|
|
|
|
ITEM; print("callee"); BEGIN(OL);
|
|
|
|
for (i = 0; callee[i]; i++)
|
|
|
|
ITEM; emitSymbol(callee[i]); END;
|
|
|
|
END; END;
|
|
|
|
} else {
|
|
|
|
xx(caller,BEGIN(em); print("empty"); END);
|
|
|
|
xx(callee,BEGIN(em); print("empty"); END);
|
|
|
|
}
|
|
|
|
END;
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
maxoff = off = 0;
|
|
|
|
gencode(caller, callee);
|
|
|
|
if (html)
|
|
|
|
START; print("emitcode"); BEGIN(ul); emitcode(); END; END;
|
|
|
|
else
|
|
|
|
emitcode();
|
|
|
|
START; print("maxoff=%d", maxoff); END;
|
|
|
|
#undef xx
|
|
|
|
}
|
|
|
|
|
|
|
|
/* visit - generate code for *p */
|
|
|
|
static int visit(Node p, int n) {
|
|
|
|
if (p && p->x.inst == 0) {
|
|
|
|
p->x.inst = ++n;
|
|
|
|
n = visit(p->kids[0], n);
|
|
|
|
n = visit(p->kids[1], n);
|
|
|
|
*tail = p;
|
|
|
|
tail = &p->x.next;
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* gen0 - generate code for the dags on list p */
|
|
|
|
static Node I(gen)(Node p) {
|
|
|
|
int n;
|
|
|
|
Node nodelist;
|
|
|
|
|
|
|
|
tail = &nodelist;
|
|
|
|
for (n = 0; p; p = p->link) {
|
|
|
|
switch (generic(p->op)) { /* check for valid forest */
|
|
|
|
case CALL:
|
|
|
|
assert(IR->wants_dag || p->count == 0);
|
|
|
|
break;
|
|
|
|
case ARG:
|
|
|
|
case ASGN: case JUMP: case LABEL: case RET:
|
|
|
|
case EQ: case GE: case GT: case LE: case LT: case NE:
|
|
|
|
assert(p->count == 0);
|
|
|
|
break;
|
|
|
|
case INDIR:
|
|
|
|
assert(IR->wants_dag && p->count > 0);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
check(p);
|
|
|
|
p->x.listed = 1;
|
|
|
|
n = visit(p, n);
|
|
|
|
}
|
|
|
|
*tail = 0;
|
|
|
|
return nodelist;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* global - announce a global */
|
|
|
|
static void I(global)(Symbol p) {
|
|
|
|
START; print("global "); emitSymbol(p); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* import - import a symbol */
|
|
|
|
static void I(import)(Symbol p) {
|
|
|
|
START; print("import "); emitSymRef(p); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* local - local variable */
|
|
|
|
static void I(local)(Symbol p) {
|
|
|
|
if (p->temporary)
|
|
|
|
p->name = stringf("t%s", p->name);
|
|
|
|
(*IR->defsymbol)(p);
|
|
|
|
off = roundup(off, p->type->align);
|
|
|
|
p->x.offset = off;
|
|
|
|
off += p->type->size;
|
|
|
|
START; print(p->temporary ? "temporary " : "local "); emitSymbol(p); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* progbeg - beginning of program */
|
|
|
|
static void I(progbeg)(int argc, char *argv[]) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++)
|
|
|
|
if (strcmp(argv[i], "-v") == 0)
|
|
|
|
verbose++;
|
|
|
|
else if (strcmp(argv[i], "-html") == 0)
|
|
|
|
html++;
|
|
|
|
if (html) {
|
|
|
|
print("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n");
|
|
|
|
print("<html>");
|
|
|
|
BEGIN(head);
|
|
|
|
if (firstfile && *firstfile)
|
|
|
|
BEGIN(title); emitString(strlen(firstfile), firstfile); END;
|
|
|
|
print("<link rev=made href=\"mailto:drh@microsoft.com\">\n");
|
|
|
|
END;
|
|
|
|
print("<body>\n");
|
|
|
|
if (firstfile && *firstfile)
|
|
|
|
BEGIN(h1); emitString(strlen(firstfile), firstfile); END;
|
|
|
|
BEGIN(P); BEGIN(em);
|
|
|
|
print("Links lead from uses of identifiers and labels to their definitions.");
|
|
|
|
END; END;
|
|
|
|
print("<ul>\n");
|
|
|
|
START;
|
|
|
|
print("progbeg");
|
|
|
|
BEGIN(ol);
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
ITEM;
|
|
|
|
BEGIN(code); print("\""); emitString(strlen(argv[i]), argv[i]); print("\""); END;
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
END;
|
|
|
|
END;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* progend - end of program */
|
|
|
|
static void I(progend)(void) {
|
|
|
|
START; print("progend"); END;
|
|
|
|
if (html) {
|
|
|
|
time_t t;
|
|
|
|
print("</ul>\n");
|
|
|
|
time(&t);
|
|
|
|
print("<hr><address>%s</address>\n", ctime(&t));
|
|
|
|
print("</body></html>\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* segment - switch to segment s */
|
|
|
|
static void I(segment)(int s) {
|
|
|
|
START; print("segment %s", &"text\0bss\0.data\0lit\0.sym\0."[5*s-5]); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* space - initialize n bytes of space */
|
|
|
|
static void I(space)(int n) {
|
|
|
|
START; print("space %d", n); END;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void I(stabblock)(int brace, int lev, Symbol *p) {}
|
|
|
|
|
|
|
|
/* stabend - finalize stab output */
|
|
|
|
static void I(stabend)(Coordinate *cp, Symbol p, Coordinate **cpp, Symbol *sp, Symbol *stab) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (p)
|
|
|
|
emitSymRef(p);
|
|
|
|
print("\n");
|
|
|
|
if (cpp && sp)
|
|
|
|
for (i = 0; cpp[i] && sp[i]; i++) {
|
|
|
|
print("%w.%d: ", cpp[i], cpp[i]->x);
|
|
|
|
emitSymRef(sp[i]);
|
|
|
|
print("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void I(stabfend)(Symbol p, int lineno) {}
|
|
|
|
static void I(stabinit)(char *file, int argc, char *argv[]) {}
|
|
|
|
|
|
|
|
/* stabline - emit line number information for source coordinate *cp */
|
|
|
|
static void I(stabline)(Coordinate *cp) {
|
|
|
|
if (cp->file)
|
|
|
|
print("%s:", cp->file);
|
|
|
|
print("%d.%d:\n", cp->y, cp->x);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void I(stabsym)(Symbol p) {}
|
|
|
|
static void I(stabtype)(Symbol p) {}
|
|
|
|
|
|
|
|
Interface symbolicIR = {
|
2005-10-04 01:21:34 +00:00
|
|
|
{1, 1, 0}, /* char */
|
|
|
|
{2, 2, 0}, /* short */
|
|
|
|
{4, 4, 0}, /* int */
|
|
|
|
{4, 4, 0}, /* long */
|
|
|
|
{4, 4, 0}, /* long long */
|
|
|
|
{4, 4, 1}, /* float */
|
|
|
|
{8, 8, 1}, /* double */
|
|
|
|
{8, 8, 1}, /* long double */
|
|
|
|
{4, 4, 0}, /* T* */
|
|
|
|
{0, 4, 0}, /* struct */
|
2005-08-26 17:39:27 +00:00
|
|
|
0, /* little_endian */
|
|
|
|
0, /* mulops_calls */
|
|
|
|
0, /* wants_callb */
|
|
|
|
1, /* wants_argb */
|
|
|
|
1, /* left_to_right */
|
|
|
|
1, /* wants_dag */
|
|
|
|
0, /* unsigned_char */
|
|
|
|
I(address),
|
|
|
|
I(blockbeg),
|
|
|
|
I(blockend),
|
|
|
|
I(defaddress),
|
|
|
|
I(defconst),
|
|
|
|
I(defstring),
|
|
|
|
I(defsymbol),
|
|
|
|
I(emit),
|
|
|
|
I(export),
|
|
|
|
I(function),
|
|
|
|
I(gen),
|
|
|
|
I(global),
|
|
|
|
I(import),
|
|
|
|
I(local),
|
|
|
|
I(progbeg),
|
|
|
|
I(progend),
|
|
|
|
I(segment),
|
|
|
|
I(space),
|
|
|
|
I(stabblock),
|
|
|
|
I(stabend),
|
|
|
|
I(stabfend),
|
|
|
|
I(stabinit),
|
|
|
|
I(stabline),
|
|
|
|
I(stabsym),
|
|
|
|
I(stabtype)
|
|
|
|
};
|
|
|
|
|
|
|
|
Interface symbolic64IR = {
|
2005-10-04 01:21:34 +00:00
|
|
|
{1, 1, 0}, /* char */
|
|
|
|
{2, 2, 0}, /* short */
|
|
|
|
{4, 4, 0}, /* int */
|
|
|
|
{8, 8, 0}, /* long */
|
|
|
|
{8, 8, 0}, /* long long */
|
|
|
|
{4, 4, 1}, /* float */
|
|
|
|
{8, 8, 1}, /* double */
|
|
|
|
{8, 8, 1}, /* long double */
|
|
|
|
{8, 8, 0}, /* T* */
|
|
|
|
{0, 1, 0}, /* struct */
|
2005-08-26 17:39:27 +00:00
|
|
|
1, /* little_endian */
|
|
|
|
0, /* mulops_calls */
|
|
|
|
0, /* wants_callb */
|
|
|
|
1, /* wants_argb */
|
|
|
|
1, /* left_to_right */
|
|
|
|
1, /* wants_dag */
|
|
|
|
0, /* unsigned_char */
|
|
|
|
I(address),
|
|
|
|
I(blockbeg),
|
|
|
|
I(blockend),
|
|
|
|
I(defaddress),
|
|
|
|
I(defconst),
|
|
|
|
I(defstring),
|
|
|
|
I(defsymbol),
|
|
|
|
I(emit),
|
|
|
|
I(export),
|
|
|
|
I(function),
|
|
|
|
I(gen),
|
|
|
|
I(global),
|
|
|
|
I(import),
|
|
|
|
I(local),
|
|
|
|
I(progbeg),
|
|
|
|
I(progend),
|
|
|
|
I(segment),
|
|
|
|
I(space),
|
|
|
|
I(stabblock),
|
|
|
|
I(stabend),
|
|
|
|
I(stabfend),
|
|
|
|
I(stabinit),
|
|
|
|
I(stabline),
|
|
|
|
I(stabsym),
|
|
|
|
I(stabtype)
|
|
|
|
};
|