int
tlen(NODE *p)
{
switch (p->n_type) {
case CHAR:
case UCHAR:
return 1;
case SHORT:
case USHORT:
return (SZSHORT / SZCHAR);
case FLOAT:
return (SZFLOAT / SZCHAR);
case DOUBLE:
return (SZDOUBLE / SZCHAR);
case INT:
case UNSIGNED:
return (SZINT / SZCHAR);
case LONG:
case ULONG:
case LONGLONG:
case ULONGLONG:
return SZLONGLONG / SZCHAR;
default:
if (!ISPTR(p->n_type))
comperr("tlen type unknown: %d");
return SZPOINT(p->n_type) / SZCHAR;
}
}
/*
* Return type size in bytes. Used by R2REGS, arg 2 to offset().
*/
int
tlen(NODE *p)
{
switch(p->n_type) {
case CHAR:
case UCHAR:
return(1);
case SHORT:
case USHORT:
return(SZSHORT/SZCHAR);
case DOUBLE:
return(SZDOUBLE/SZCHAR);
case INT:
case UNSIGNED:
case LONG:
case ULONG:
return(SZINT/SZCHAR);
case LONGLONG:
case ULONGLONG:
return SZLONGLONG/SZCHAR;
default:
if (!ISPTR(p->n_type))
comperr("tlen type %d not pointer");
return SZPOINT(p->n_type)/SZCHAR;
}
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
*/
void
bfcode(struct symtab **sp, int cnt)
{
struct symtab *sp2;
NODE *n;
int i;
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
/* Function returns struct, adjust arg offset */
for (i = 0; i < cnt; i++)
sp[i]->soffset += SZPOINT(INT);
}
if (xtemps == 0)
return;
/* put arguments in temporaries */
for (i = 0; i < cnt; i++) {
if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY ||
cisreg(sp[i]->stype) == 0)
continue;
sp2 = sp[i];
n = tempnode(0, sp[i]->stype, sp[i]->sdf, sp[i]->sap);
n = buildtree(ASSIGN, n, nametree(sp2));
sp[i]->soffset = regno(n->n_left);
sp[i]->sflags |= STNODE;
ecomp(n);
}
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
*/
void
bfcode(struct symtab **a, int n)
{
int i;
if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
return;
cerror("bfcode");
/* Function returns struct, adjust arg offset */
for (i = 0; i < n; i++)
a[i]->soffset += SZPOINT(INT);
}
void
dwarf_init(char *iname)
{
char buf[MAXPATHLEN];
/*
* Setup sections.
* We'll print out the basic stuff early so that not
* so much context must be kept around.
*/
dwname = iname;
debug_info_sz_lbl = dwlab();
debug_abbrev_beg_lbl = dwlab();
/* begin with setting up the compilation unit header */
info412l(debug_info_sz_lbl); debug_info_sz = 0;
info2w(DVERSION);
info412l(debug_abbrev_beg_lbl);
info1b(SZPOINT(VOID)/SZCHAR);
/* Define abbrev table */
dwslab(DABBREV, debug_abbrev_beg_lbl);
/* compile unit follows, both in abbrev and info table */
/* Recommended stuff here as in the documentation */
al128(1); /* always first entry */
al128(DW_TAG_compile_unit);
al128(DW_CHILDREN_yes);
apair(DW_AT_name, DW_FORM_strp); /* file name; e.g. foo.c */
apair(DW_AT_producer, DW_FORM_string); /* producer; PCC 1.2.3 */
apair(DW_AT_comp_dir, DW_FORM_string); /* working directory */
apair(DW_AT_language, DW_FORM_data1); /* C99 */
apair(DW_AT_low_pc, DW_FORM_addr); /* start text */
apair(DW_AT_high_pc, DW_FORM_addr); /* end text */
apair(0, 0);
/* Above in info table */
il128(1); /* first entry */
ilbl(dwcfl = dwlab());
istring(PACKAGE_STRING);
istring(getwd(buf));
il128(DW_LANG_C99);
ilbl(dwbtext = dwlab());
ilbl(dwetext = dwlab());
locctr(PROG, NULL);
printf(PRTPREF DLABEL ":\n", dwbtext);
}
/*
* code for the beginning of a function; 'a' is an array of
* indices in symtab for the arguments; n is the number
*/
void
bfcode(struct symtab **a, int cnt)
{
struct symtab *sp;
NODE *p, *q;
int i, n, sz;
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
/* Function returns struct, adjust arg offset */
for (i = 0; i < n; i++)
a[i]->soffset += SZPOINT(LONG);
}
/* recalculate the arg offset and create TEMP moves */
for (n = 0, i = 0; i < cnt; i++) {
sp = a[i];
sz = szty(sp->stype);
if (n % sz)
n++; /* XXX LDOUBLE */
if (n < 4) {
p = tempnode(0, sp->stype, sp->sdf, sp->ssue);
/* TODO p->n_left->n_lval = -(32 + n * 4); */
q = block(REG, NIL, NIL, sp->stype, sp->sdf, sp->ssue);
q->n_rval = argreg(sp->stype, &n);
p = buildtree(ASSIGN, p, q);
sp->soffset = regno(p->n_left);
sp->sflags |= STNODE;
ecomp(p);
} else {
sp->soffset += SZINT * n;
if (xtemps) {
/* put stack args in temps if optimizing */
p = tempnode(0, sp->stype, sp->sdf, sp->ssue);
p = buildtree(ASSIGN, p, buildtree(NAME, 0, 0));
sp->soffset = regno(p->n_left);
sp->sflags |= STNODE;
ecomp(p);
}
}
}
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
*/
void
bfcode(struct symtab **a, int n)
{
// NODE *p, *q;
int i;
for (i = 0; i < n; i++) {
if (a[i]->stype == CHAR)
a[i]->stype = INT;
if (a[i]->stype == UCHAR)
a[i]->stype = UNSIGNED;
}
if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
return;
cerror("bfcode");
/* Function returns struct, adjust arg offset */
for (i = 0; i < n; i++)
a[i]->soffset += SZPOINT(INT);
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
* On m16k, space is allocated on stack for register arguments,
* arguments are moved to the stack and symtab is updated accordingly.
*/
void
bfcode(struct symtab **a, int n)
{
struct symtab *s;
int i, r0l, r0h, a0, r2, sz, hasch, stk;
int argoff = ARGINIT;
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
/* Function returns struct, adjust arg offset */
for (i = 0; i < n; i++)
a[i]->soffset += SZPOINT(INT);
}
/* first check if there are 1-byte parameters */
for (hasch = i = 0; i < n && i < 6; i++)
if (DEUNSIGN(a[i]->stype) == CHAR)
hasch = 1;
stk = r0l = r0h = a0 = r2 = 0;
for (i = 0; i < n; i++) {
s = a[i];
sz = tsize(s->stype, s->sdf, s->ssue);
if (ISPTR(s->stype) && ISFTN(DECREF(s->stype)))
sz = SZLONG; /* function pointers are always 32 */
if (stk == 0)
switch (sz) {
case SZCHAR:
if (r0l) {
if (r0h)
break;
argmove(s, 1);
r0h = 1;
} else {
argmove(s, 0);
r0l = 1;
}
continue;
case SZINT:
if (s->stype > BTMASK) {
/* is a pointer */
if (a0) {
if (r0l || hasch) {
if (r2)
break;
argmove(s, R2);
r2 = 1;
} else {
argmove(s, R0);
r0l = r0h = 1;
}
} else {
argmove(s, A0);
a0 = 1;
}
} else if (r0l || hasch) {
if (r2) {
if (a0)
break;
argmove(s, A0);
a0 = 1;
} else {
argmove(s, R2);
r2 = 1;
}
} else {
argmove(s, R0);
r0l = r0h = 1;
}
continue;
case SZLONG:
if (r0l||r0h||r2)
break;
argmove(s, R0);
r0l = r0h = r2 = 1;
continue;
default:
break;
}
stk = 1;
s->soffset = argoff;
argoff += sz;
}
}
