void retcode(Tree p) {
Type ty;
if (p == NULL) {
if (events.returns)
apply(events.returns, cfunc, NULL);
return;
}
p = pointer(p);
ty = assign(freturn(cfunc->type), p);
if (ty == NULL) {
error("illegal return type; found `%t' expected `%t'\n",
p->type, freturn(cfunc->type));
return;
}
p = cast(p, ty);
if (retv)
{
if (iscallb(p))
p = tree(RIGHT, p->type,
tree(CALL+B, p->type,
p->kids[0]->kids[0], idtree(retv)),
rvalue(idtree(retv)));
else {
Type ty = retv->type->type;
assert(isstruct(ty));
if (ty->u.sym->u.s.cfields) {
ty->u.sym->u.s.cfields = 0;
p = asgntree(ASGN, rvalue(idtree(retv)), p);
ty->u.sym->u.s.cfields = 1;
} else
p = asgntree(ASGN, rvalue(idtree(retv)), p);
}
walk(p, 0, 0);
if (events.returns)
apply(events.returns, cfunc, rvalue(idtree(retv)));
return;
}
if (events.returns)
{
Symbol t1 = genident(AUTO, p->type, level);
addlocal(t1);
walk(asgn(t1, p), 0, 0);
apply(events.returns, cfunc, idtree(t1));
p = idtree(t1);
}
if (!isfloat(p->type))
p = cast(p, promote(p->type));
if (isptr(p->type))
{
Symbol q = localaddr(p);
if (q && (q->computed || q->generated))
warning("pointer to a %s is an illegal return value\n",
q->scope == PARAM ? "parameter" : "local");
else if (q)
warning("pointer to %s `%s' is an illegal return value\n",
q->scope == PARAM ? "parameter" : "local", q->name);
}
walk(tree(mkop(RET,p->type), p->type, p, NULL), 0, 0);
}
static void cparams(JF, js_Ast *list)
{
F->numparams = listlength(list);
while (list) {
addlocal(J, F, list->a, 0);
list = list->b;
}
}
int dofunc() { cloc=&co; strcpy1(fname, symbol);
prs("\n\n"); prs(symbol); prs(" PROC");
expect('('); narg=0; LTop=LStart;
if (istoken(')')==0) { prs("\narg ");
do { typeName(); addlocal();
if (narg) prc(','); prs(symbol);
if (istype!='*') {if (iswidth=='B') prs(":byte ");} narg++; }
while (istoken(',')); expect(')'); }
expect('{'); /*body*/
nlocal=0; nreturn=0; nconst=0;
if (isvariable()) prs("\nlocal ");
while(isvariable()) {
do { typeName(); addlocal();
if (nlocal) prc(','); prs(symbol);
if (istype!='*') {if (iswidth=='B') prs(":byte ");} nlocal++;
if (istoken('[')){istype='&';GType[LTop]='&';expect(T_CONST);expect(']');
prs(":BYTE:"); prnum(lexval); }
} while (istoken(',')); expect(';'); }
while(istoken('}')==0) stmt();
if (nreturn) prs("\n@@retn:"); prs("\n ret\nENDP"); listproc(); }
static void swstmt(int loop, int lab, int lev) {
Tree e;
struct swtch sw;
Code head, tail;
t = gettok();
expect('(');
definept(NULL);
e = expr(')');
if (!isint(e->type)) {
error("illegal type `%t' in switch expression\n",
e->type);
e = retype(e, inttype);
}
e = cast(e, promote(e->type));
if (generic(e->op) == INDIR && isaddrop(e->kids[0]->op)
&& e->kids[0]->u.sym->type == e->type
&& !isvolatile(e->kids[0]->u.sym->type)) {
sw.sym = e->kids[0]->u.sym;
walk(NULL, 0, 0);
} else {
sw.sym = genident(REGISTER, e->type, level);
addlocal(sw.sym);
walk(asgn(sw.sym, e), 0, 0);
}
head = code(Switch);
sw.lab = lab;
sw.deflab = NULL;
sw.ncases = 0;
sw.size = SWSIZE;
sw.values = newarray(SWSIZE, sizeof *sw.values, FUNC);
sw.labels = newarray(SWSIZE, sizeof *sw.labels, FUNC);
refinc /= 10.0;
statement(loop, &sw, lev);
if (sw.deflab == NULL) {
sw.deflab = findlabel(lab);
definelab(lab);
if (sw.ncases == 0)
warning("switch statement with no cases\n");
}
if (findlabel(lab + 1)->ref)
definelab(lab + 1);
tail = codelist;
codelist = head->prev;
codelist->next = head->prev = NULL;
if (sw.ncases > 0)
swgen(&sw);
branch(lab);
head->next->prev = codelist;
codelist->next = head->next;
codelist = tail;
}
static void cvardecs(JF, js_Ast *node)
{
if (isfun(node->type))
return; /* stop at inner functions */
if (node->type == EXP_VAR) {
if (F->lightweight)
addlocal(J, F, node->a, 1);
else
emitstring(J, F, OP_DEFVAR, node->a->string);
}
if (node->a) cvardecs(J, F, node->a);
if (node->b) cvardecs(J, F, node->b);
if (node->c) cvardecs(J, F, node->c);
if (node->d) cvardecs(J, F, node->d);
}
static void cfunbody(JF, js_Ast *name, js_Ast *params, js_Ast *body)
{
F->lightweight = 1;
F->arguments = 0;
if (F->script)
F->lightweight = 0;
if (body)
analyze(J, F, body);
cparams(J, F, params);
if (name) {
emit(J, F, OP_CURRENT);
if (F->lightweight) {
addlocal(J, F, name, 0);
emit(J, F, OP_INITLOCAL);
emitraw(J, F, findlocal(J, F, name->string));
} else {
emitstring(J, F, OP_INITVAR, name->string);
}
}
if (body) {
cvardecs(J, F, body);
cfundecs(J, F, body);
}
if (F->script) {
emit(J, F, OP_UNDEF);
cstmlist(J, F, body);
emit(J, F, OP_RETURN);
} else {
cstmlist(J, F, body);
emit(J, F, OP_UNDEF);
emit(J, F, OP_RETURN);
}
}
/* tracecall - generate code to trace entry to f */
static void tracecall(Symbol printer, Symbol f, void *ignore) {
int i;
Symbol counter = genident(STATIC, inttype, GLOBAL);
defglobal(counter, BSS);
(*IR->space)(counter->type->size);
frameno = genident(AUTO, inttype, level);
addlocal(frameno);
appendstr(f->name); appendstr("#");
tracevalue(asgn(frameno, incr(INCR, idtree(counter), consttree(1, inttype))), 0);
appendstr("(");
for (i = 0; f->u.f.callee[i]; i++) {
if (i)
appendstr(",");
appendstr(f->u.f.callee[i]->name); appendstr("=");
tracevalue(idtree(f->u.f.callee[i]), 0);
}
if (variadic(f->type))
appendstr(",...");
appendstr(") called\n");
tracefinis(printer);
}
static Tree addrtree(Tree e, long n, Type ty)
{
Symbol p = e->u.sym, q;
if (p->scope == GLOBAL
|| p->sclass == STATIC || p->sclass == EXTERN)
NEW0(q, PERM);
else
NEW0(q, FUNC);
q->name = stringd(genlabel(1));
q->sclass = p->sclass;
q->scope = p->scope;
assert(isptr(ty) || isarray(ty));
q->type = isptr(ty) ? ty->type : ty;
q->temporary = p->temporary;
q->generated = p->generated;
q->addressed = p->addressed;
q->computed = 1;
q->defined = 1;
q->ref = 1;
assert(IR->address);
if (p->scope == GLOBAL
|| p->sclass == STATIC || p->sclass == EXTERN) {
if (p->sclass == AUTO)
q->sclass = STATIC;
(*IR->address)(q, p, n);
} else {
Code cp;
addlocal(p);
cp = code(Address);
cp->u.addr.sym = q;
cp->u.addr.base = p;
cp->u.addr.offset = n;
}
e = tree(e->op, ty, NULL, NULL);
e->u.sym = q;
return e;
}
/* entry_hook - called an function entry */
static void entry_hook(void *cl, Symbol cfunc) {
static int nfuncs;
Type ty;
/*
Simulate the declaration of an sframe structure,
but without the tag.
*/
ty = newstruct(STRUCT, "");
#define addfield(name,t) \
ty->size = roundup(ty->size, t->align);\
if (ty->align < t->align) ty->align = t->align; \
newfield(string(name), ty, t)->offset = ty->size; \
ty->size += t->size
addfield("up", voidptype);
addfield("down", voidptype);
addfield("func", inttype);
addfield("module",inttype);
addfield("ip", inttype);
#undef addfield
ty->size = roundup(ty->size, ty->align);
ty->u.sym->defined = 1;
ty->u.sym->generated = 1;
tos = genident(AUTO, ty, LOCAL);
addlocal(tos);
tos->defined = 1;
/*
Generated the assignments to the shadow
frame fields.
*/
#define set(name,e) walk(asgntree(ASGN,field(lvalue(idtree(tos)),string(#name)),(e)),0,0)
set(down, idtree(nub_tos));
set(func, cnsttree(inttype, symboluid(cfunc)));
set(module, cnsttree(inttype, uname));
#undef set
walk(asgn(nub_tos, lvalue(idtree(tos))), 0, 0);
foreach(identifiers, PARAM, setoffset, tos);
}
