static NODE *
movtomem(NODE *p, int off, int reg)
{
struct symtab s;
NODE *r, *l;
s.stype = p->n_type;
s.squal = 0;
s.sdf = p->n_df;
s.sap = p->n_ap;
s.soffset = off;
s.sclass = AUTO;
l = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
l->n_lval = 0;
regno(l) = reg;
r = block(NAME, NIL, NIL, p->n_type, p->n_df, p->n_ap);
r->n_sp = &s;
r = stref(block(STREF, l, r, 0, 0, 0));
return clocal(buildtree(ASSIGN, r, p));
}
NODE *
clocal(NODE *p)
{
/* this is called to do local transformations on
an expression tree preparitory to its being
written out in intermediate code.
*/
/* the major essential job is rewriting the
automatic variables and arguments in terms of
REG and OREG nodes */
/* conversion ops which are not necessary are also clobbered here */
/* in addition, any special features (such as rewriting
exclusive or) are easily handled here as well */
struct symtab *q;
NODE *l, *r;
int o;
TWORD ml;
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
r->n_lval = 0;
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case STATIC:
if (q->slevel == 0)
break;
p->n_lval = 0;
p->n_sp = q;
break;
case REGISTER:
p->n_op = REG;
p->n_lval = 0;
p->n_rval = q->soffset;
break;
}
break;
case PCONV:
ml = p->n_left->n_type;
l = p->n_left;
if ((ml == CHAR || ml == UCHAR) && l->n_op != ICON)
break;
l->n_type = p->n_type;
l->n_qual = p->n_qual;
l->n_df = p->n_df;
l->n_sue = p->n_sue;
nfree(p);
p = l;
break;
case SCONV:
l = p->n_left;
if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT) {
nfree(p);
return l;
}
if (l->n_op == ICON) {
CONSZ val = l->n_lval;
switch (p->n_type) {
case CHAR:
l->n_lval = (char)val;
break;
case UCHAR:
l->n_lval = val & 0377;
break;
case SHORT:
case INT:
l->n_lval = (short)val;
break;
case USHORT:
case UNSIGNED:
l->n_lval = val & 0177777;
break;
case ULONG:
case ULONGLONG:
l->n_lval = val & 0xffffffff;
break;
case LONG:
case LONGLONG:
l->n_lval = (int)val;
break;
case VOID:
break;
case LDOUBLE:
case DOUBLE:
case FLOAT:
l->n_op = FCON;
l->n_dcon = val;
break;
default:
cerror("unknown type %d", p->n_type);
}
l->n_type = p->n_type;
nfree(p);
return l;
}
break;
}
return(p);
}
/* clocal() is called to do local transformations on
* an expression tree preparitory to its being
* written out in intermediate code.
*
* the major essential job is rewriting the
* automatic variables and arguments in terms of
* REG and OREG nodes
* conversion ops which are not necessary are also clobbered here
* in addition, any special features (such as rewriting
* exclusive or) are easily handled here as well
*/
NODE *
clocal(NODE *p)
{
register struct symtab *q;
register NODE *r, *l;
register int o;
register int m;
TWORD t;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
slval(r, 0);
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case USTATIC:
if (kflag == 0)
break;
/* FALLTHROUGH */
case STATIC:
#ifdef TLS
if (q->sflags & STLS) {
p = tlsref(p);
break;
}
#endif
break;
case REGISTER:
p->n_op = REG;
slval(p, 0);
p->n_rval = q->soffset;
break;
case EXTERN:
case EXTDEF:
if (q->sflags & STLS) {
p = tlsref(p);
break;
}
if (kflag == 0 || statinit)
break;
if (blevel > 0)
p = picext(p);
break;
}
break;
case UCALL:
case USTCALL:
/* For now, always clear eax */
l = block(REG, NIL, NIL, INT, 0, 0);
regno(l) = RAX;
p->n_right = clocal(buildtree(ASSIGN, l, bcon(0)));
p->n_op -= (UCALL-CALL);
break;
case SCONV:
/* Special-case shifts */
if (p->n_type == LONG && (l = p->n_left)->n_op == LS &&
l->n_type == INT && l->n_right->n_op == ICON) {
p->n_left = l->n_left;
p = buildtree(LS, p, l->n_right);
nfree(l);
break;
}
l = p->n_left;
/* Float conversions may need extra casts */
if (p->n_type == FLOAT || p->n_type == DOUBLE ||
p->n_type == LDOUBLE) {
if (l->n_type < INT || l->n_type == BOOL) {
p->n_left = block(SCONV, l, NIL,
ISUNSIGNED(l->n_type) ? UNSIGNED : INT,
l->n_df, l->n_ap);
break;
}
}
if (p->n_type == l->n_type) {
nfree(p);
return l;
}
if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
tsize(p->n_type, p->n_df, p->n_ap) ==
tsize(l->n_type, l->n_df, l->n_ap)) {
if (p->n_type != FLOAT && p->n_type != DOUBLE &&
l->n_type != FLOAT && l->n_type != DOUBLE &&
l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
if (l->n_op == NAME || l->n_op == UMUL ||
l->n_op == TEMP) {
l->n_type = p->n_type;
nfree(p);
return l;
}
}
}
if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
coptype(l->n_op) == BITYPE && l->n_op != COMOP &&
l->n_op != QUEST && l->n_op != ASSIGN) {
l->n_type = p->n_type;
nfree(p);
return l;
}
o = l->n_op;
m = p->n_type;
if (o == ICON) {
CONSZ val = glval(l);
/* if named constant and pointer, allow cast
to long/ulong */
if (!nncon(l) && (l->n_type & TMASK) &&
(m == LONG || m == ULONG)) {
l->n_type = m;
l->n_ap = 0;
return nfree(p);
}
if (ISPTR(l->n_type) && !nncon(l))
break; /* cannot convert named pointers */
if (!ISPTR(m)) /* Pointers don't need to be conv'd */
switch (m) {
case BOOL:
val = nncon(l) ? (val != 0) : 1;
slval(l, val);
l->n_sp = NULL;
break;
case CHAR:
slval(l, (char)val);
break;
case UCHAR:
slval(l, val & 0377);
break;
case SHORT:
slval(l, (short)val);
break;
case USHORT:
slval(l, val & 0177777);
break;
case UNSIGNED:
slval(l, val & 0xffffffff);
break;
case INT:
slval(l, (int)val);
break;
case LONG:
case LONGLONG:
slval(l, (long long)val);
break;
case ULONG:
case ULONGLONG:
slval(l, val);
break;
case VOID:
break;
case LDOUBLE:
case DOUBLE:
case FLOAT:
l->n_op = FCON;
l->n_dcon = fltallo();
FCAST(l->n_dcon)->fp = val;
break;
default:
cerror("unknown type %d", m);
}
l->n_type = m;
l->n_ap = NULL;
nfree(p);
return l;
} else if (l->n_op == FCON) {
CONSZ lv;
if (p->n_type == BOOL)
lv = !FLOAT_ISZERO(FCAST(l->n_dcon));
else {
FLOAT_FP2INT(lv, FCAST(l->n_dcon), m);
}
slval(l, lv);
l->n_sp = NULL;
l->n_op = ICON;
l->n_type = m;
l->n_ap = NULL;
nfree(p);
return clocal(l);
}
if ((p->n_type == CHAR || p->n_type == UCHAR ||
p->n_type == SHORT || p->n_type == USHORT) &&
(l->n_type == FLOAT || l->n_type == DOUBLE ||
l->n_type == LDOUBLE)) {
p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
p->n_left->n_type = INT;
return p;
}
break;
case MOD:
case DIV:
if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
break;
if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
break;
/* make it an int division by inserting conversions */
p->n_left = makety(p->n_left, INT, 0, 0, 0);
p->n_right = makety(p->n_right, INT, 0, 0, 0);
p = makety(p, p->n_type, 0, 0, 0);
p->n_left->n_type = INT;
break;
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
t = p->n_type;
if (ISITY(t))
t = t - (FIMAG-FLOAT);
p->n_left->n_rval = p->n_left->n_type == BOOL ?
RETREG(CHAR) : RETREG(t);
break;
case LS:
case RS:
/* shift count must be in a char */
if (p->n_right->n_type == CHAR || p->n_right->n_type == UCHAR)
break;
p->n_right = makety(p->n_right, CHAR, 0, 0, 0);
break;
}
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal end: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
return(p);
}
NODE *
clocal(NODE *p)
{
struct symtab *q;
NODE *r, *l;
TWORD t;
int o;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal\n");
fwalk(p, eprint, 0);
}
#endif
switch( o = p->n_op ){
case NAME:
/* handle variables */
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
if (0 && q->soffset < MAXZP * SZINT &&
q->sclass != PARAM) {
p->n_lval = -(q->soffset/SZCHAR) + ZPOFF*2;
p->n_sp = NULL;
} else {
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
r->n_lval = 0;
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
}
break;
default:
break;
}
break;
case PMCONV:
case PVCONV:
if( p->n_right->n_op != ICON ) cerror( "bad conversion", 0);
nfree(p);
p = (buildtree(o==PMCONV?MUL:DIV, p->n_left, p->n_right));
break;
case PCONV:
t = p->n_type;
if (t == INCREF(CHAR) || t == INCREF(UCHAR) ||
t == INCREF(BOOL) || t == INCREF(VOID))
break;
l = p->n_left;
t = l->n_type;
if (t == INCREF(CHAR) || t == INCREF(UCHAR) ||
t == INCREF(BOOL) || t == INCREF(VOID))
break;
if (p->n_type <= UCHAR || l->n_type <= UCHAR)
break; /* must do runtime ptr conv */
/* if conversion to another pointer type, just remove */
if (p->n_type > BTMASK && l->n_type > BTMASK)
goto delp;
if (l->n_op == ICON && l->n_sp == NULL)
goto delp;
break;
delp: l->n_type = p->n_type;
l->n_qual = p->n_qual;
l->n_df = p->n_df;
l->n_ap = p->n_ap;
p = nfree(p);
break;
}
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal end\n");
fwalk(p, eprint, 0);
}
#endif
#if 0
register struct symtab *q;
register NODE *r, *l;
register int o;
register int m;
TWORD t;
//printf("in:\n");
//fwalk(p, eprint, 0);
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
r->n_lval = 0;
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case STATIC:
if (q->slevel == 0)
break;
p->n_lval = 0;
p->n_sp = q;
break;
case REGISTER:
p->n_op = REG;
p->n_lval = 0;
p->n_rval = q->soffset;
break;
}
break;
case STCALL:
case CALL:
/* Fix function call arguments. On x86, just add funarg */
for (r = p->n_right; r->n_op == CM; r = r->n_left) {
if (r->n_right->n_op != STARG &&
r->n_right->n_op != FUNARG)
r->n_right = block(FUNARG, r->n_right, NIL,
r->n_right->n_type, r->n_right->n_df,
r->n_right->n_sue);
}
if (r->n_op != STARG && r->n_op != FUNARG) {
l = talloc();
*l = *r;
r->n_op = FUNARG; r->n_left = l; r->n_type = l->n_type;
}
break;
case CBRANCH:
l = p->n_left;
/*
* Remove unnecessary conversion ops.
*/
if (clogop(l->n_op) && l->n_left->n_op == SCONV) {
if (coptype(l->n_op) != BITYPE)
break;
if (l->n_right->n_op == ICON) {
r = l->n_left->n_left;
if (r->n_type >= FLOAT && r->n_type <= LDOUBLE)
break;
/* Type must be correct */
t = r->n_type;
nfree(l->n_left);
l->n_left = r;
l->n_type = t;
l->n_right->n_type = t;
}
}
break;
case PCONV:
/* Remove redundant PCONV's. Be careful */
l = p->n_left;
if (l->n_op == ICON) {
l->n_lval = (unsigned)l->n_lval;
goto delp;
}
if (l->n_type < INT || l->n_type == LONGLONG ||
l->n_type == ULONGLONG) {
/* float etc? */
p->n_left = block(SCONV, l, NIL,
UNSIGNED, 0, 0);
break;
}
/* if left is SCONV, cannot remove */
if (l->n_op == SCONV)
break;
/* if conversion to another pointer type, just remove */
if (p->n_type > BTMASK && l->n_type > BTMASK)
goto delp;
break;
delp: l->n_type = p->n_type;
l->n_qual = p->n_qual;
l->n_df = p->n_df;
l->n_sue = p->n_sue;
nfree(p);
p = l;
break;
case SCONV:
l = p->n_left;
if (p->n_type == l->n_type) {
nfree(p);
return l;
}
if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
btdims[p->n_type].suesize == btdims[l->n_type].suesize) {
if (p->n_type != FLOAT && p->n_type != DOUBLE &&
l->n_type != FLOAT && l->n_type != DOUBLE &&
l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
if (l->n_op == NAME || l->n_op == UMUL ||
l->n_op == TEMP) {
l->n_type = p->n_type;
nfree(p);
return l;
}
}
}
if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
coptype(l->n_op) == BITYPE) {
l->n_type = p->n_type;
nfree(p);
return l;
}
o = l->n_op;
m = p->n_type;
if (o == ICON) {
CONSZ val = l->n_lval;
if (!ISPTR(m)) /* Pointers don't need to be conv'd */
switch (m) {
case CHAR:
l->n_lval = (char)val;
break;
case UCHAR:
l->n_lval = val & 0377;
break;
case SHORT:
l->n_lval = (short)val;
break;
case USHORT:
l->n_lval = val & 0177777;
break;
case ULONG:
case UNSIGNED:
l->n_lval = val & 0xffffffff;
break;
case LONG:
case INT:
l->n_lval = (int)val;
break;
case LONGLONG:
l->n_lval = (long long)val;
break;
case ULONGLONG:
l->n_lval = val;
break;
case VOID:
break;
case LDOUBLE:
case DOUBLE:
case FLOAT:
l->n_op = FCON;
l->n_dcon = val;
break;
default:
cerror("unknown type %d", m);
}
l->n_type = m;
l->n_sue = 0;
nfree(p);
return l;
}
if (DEUNSIGN(p->n_type) == SHORT &&
DEUNSIGN(l->n_type) == SHORT) {
nfree(p);
p = l;
}
if ((p->n_type == CHAR || p->n_type == UCHAR ||
p->n_type == SHORT || p->n_type == USHORT) &&
(l->n_type == FLOAT || l->n_type == DOUBLE ||
l->n_type == LDOUBLE)) {
p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_sue);
p->n_left->n_type = INT;
return p;
}
break;
case MOD:
case DIV:
if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
break;
if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
break;
/* make it an int division by inserting conversions */
p->n_left = block(SCONV, p->n_left, NIL, INT, 0, 0);
p->n_right = block(SCONV, p->n_right, NIL, INT, 0, 0);
p = block(SCONV, p, NIL, p->n_type, 0, 0);
p->n_left->n_type = INT;
break;
case PMCONV:
case PVCONV:
if( p->n_right->n_op != ICON ) cerror( "bad conversion", 0);
nfree(p);
return(buildtree(o==PMCONV?MUL:DIV, p->n_left, p->n_right));
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
p->n_left->n_rval = RETREG(p->n_type);
break;
case LS:
case RS:
/* shift count must be in a char
* unless longlong, where it must be int */
if (p->n_right->n_op == ICON)
break; /* do not do anything */
if (p->n_type == LONGLONG || p->n_type == ULONGLONG) {
if (p->n_right->n_type != INT)
p->n_right = block(SCONV, p->n_right, NIL,
INT, 0, 0);
break;
}
if (p->n_right->n_type == CHAR || p->n_right->n_type == UCHAR)
break;
p->n_right = block(SCONV, p->n_right, NIL,
CHAR, 0, 0);
break;
}
//printf("ut:\n");
//fwalk(p, eprint, 0);
#endif
return(p);
}
/* this is called to do local transformations on
* an expression tree preparitory to its being
* written out in intermediate code.
*/
NODE *
clocal(NODE *p)
{
struct symtab *q;
NODE *r, *l;
int o;
int m;
TWORD ty;
int tmpnr, isptrvoid = 0;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal in: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
switch (o = p->n_op) {
case UCALL:
case CALL:
case STCALL:
case USTCALL:
if (p->n_type == VOID)
break;
/*
* if the function returns void*, ecode() invokes
* delvoid() to convert it to uchar*.
* We just let this happen on the ASSIGN to the temp,
* and cast the pointer back to void* on access
* from the temp.
*/
if (p->n_type == PTR+VOID)
isptrvoid = 1;
r = tempnode(0, p->n_type, p->n_df, p->n_ap);
tmpnr = regno(r);
r = block(ASSIGN, r, p, p->n_type, p->n_df, p->n_ap);
p = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);
if (isptrvoid) {
p = block(PCONV, p, NIL, PTR+VOID, p->n_df, 0);
}
p = buildtree(COMOP, r, p);
break;
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
r->n_lval = 0;
r->n_rval = FP;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case STATIC:
if (q->slevel == 0)
break;
p->n_lval = 0;
p->n_sp = q;
break;
case REGISTER:
p->n_op = REG;
p->n_lval = 0;
p->n_rval = q->soffset;
break;
}
break;
case FUNARG:
/* Args smaller than int are given as int */
if (p->n_type != CHAR && p->n_type != UCHAR &&
p->n_type != SHORT && p->n_type != USHORT)
break;
p->n_left = block(SCONV, p->n_left, NIL, INT, 0, 0);
p->n_type = INT;
p->n_ap = 0;
p->n_rval = SZINT;
break;
case CBRANCH:
l = p->n_left;
/*
* Remove unnecessary conversion ops.
*/
if (clogop(l->n_op) && l->n_left->n_op == SCONV) {
if (coptype(l->n_op) != BITYPE)
break;
if (l->n_right->n_op == ICON) {
r = l->n_left->n_left;
if (r->n_type >= FLOAT && r->n_type <= LDOUBLE)
break;
/* Type must be correct */
ty = r->n_type;
nfree(l->n_left);
l->n_left = r;
l->n_type = ty;
l->n_right->n_type = ty;
}
#if 0
else if (l->n_right->n_op == SCONV &&
l->n_left->n_type == l->n_right->n_type) {
r = l->n_left->n_left;
nfree(l->n_left);
l->n_left = r;
r = l->n_right->n_left;
nfree(l->n_right);
l->n_right = r;
}
#endif
}
break;
case PCONV:
/* Remove redundant PCONV's. Be careful */
l = p->n_left;
if (l->n_op == ICON) {
l->n_lval = (unsigned)l->n_lval;
goto delp;
}
if (l->n_type < INT || DEUNSIGN(l->n_type) == LONGLONG) {
/* float etc? */
p->n_left = block(SCONV, l, NIL, UNSIGNED, 0, 0);
break;
}
/* if left is SCONV, cannot remove */
if (l->n_op == SCONV)
break;
/* avoid ADDROF TEMP */
if (l->n_op == ADDROF && l->n_left->n_op == TEMP)
break;
/* if conversion to another pointer type, just remove */
if (p->n_type > BTMASK && l->n_type > BTMASK)
goto delp;
break;
delp: l->n_type = p->n_type;
l->n_qual = p->n_qual;
l->n_df = p->n_df;
l->n_ap = p->n_ap;
nfree(p);
p = l;
break;
case SCONV:
l = p->n_left;
if (p->n_type == l->n_type) {
nfree(p);
p = l;
break;
}
if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
tsize(p->n_type, p->n_df, p->n_ap) ==
tsize(l->n_type, l->n_df, l->n_ap)) {
if (p->n_type != FLOAT && p->n_type != DOUBLE &&
l->n_type != FLOAT && l->n_type != DOUBLE &&
l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
if (l->n_op == NAME || l->n_op == UMUL ||
l->n_op == TEMP) {
l->n_type = p->n_type;
nfree(p);
p = l;
break;
}
}
}
if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
coptype(l->n_op) == BITYPE) {
l->n_type = p->n_type;
nfree(p);
p = l;
}
if (DEUNSIGN(p->n_type) == SHORT &&
DEUNSIGN(l->n_type) == SHORT) {
nfree(p);
p = l;
}
/* convert float/double to int before to (u)char/(u)short */
if ((DEUNSIGN(p->n_type) == CHAR ||
DEUNSIGN(p->n_type) == SHORT) &&
(l->n_type == FLOAT || l->n_type == DOUBLE ||
l->n_type == LDOUBLE)) {
p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
p->n_left->n_type = INT;
break;
}
/* convert (u)char/(u)short to int before float/double */
if ((p->n_type == FLOAT || p->n_type == DOUBLE ||
p->n_type == LDOUBLE) && (DEUNSIGN(l->n_type) == CHAR ||
DEUNSIGN(l->n_type) == SHORT)) {
p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
p->n_left->n_type = INT;
break;
}
o = l->n_op;
m = p->n_type;
if (o == ICON) {
CONSZ val = l->n_lval;
if (!ISPTR(m)) /* Pointers don't need to be conv'd */
switch (m) {
case BOOL:
l->n_lval = l->n_lval != 0;
break;
case CHAR:
l->n_lval = (char)val;
break;
case UCHAR:
l->n_lval = val & 0377;
break;
case SHORT:
l->n_lval = (short)val;
break;
case USHORT:
l->n_lval = val & 0177777;
break;
case ULONG:
case UNSIGNED:
l->n_lval = val & 0xffffffff;
break;
case LONG:
case INT:
l->n_lval = (int)val;
break;
case LONGLONG:
l->n_lval = (long long)val;
break;
case ULONGLONG:
l->n_lval = val;
break;
case VOID:
break;
case LDOUBLE:
case DOUBLE:
case FLOAT:
l->n_op = FCON;
l->n_dcon = val;
break;
default:
cerror("unknown type %d", m);
}
l->n_type = m;
nfree(p);
p = l;
} else if (o == FCON) {
l->n_lval = l->n_dcon;
l->n_sp = NULL;
l->n_op = ICON;
l->n_type = m;
l->n_ap = 0;
nfree(p);
p = clocal(l);
}
break;
case MOD:
case DIV:
if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
break;
if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
break;
/* make it an int division by inserting conversions */
p->n_left = block(SCONV, p->n_left, NIL, INT, 0, 0);
p->n_right = block(SCONV, p->n_right, NIL, INT, 0, 0);
p = block(SCONV, p, NIL, p->n_type, 0, 0);
p->n_left->n_type = INT;
break;
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
p->n_left->n_rval = RETREG(p->n_type);
break;
}
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal out: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
return(p);
}
/* clocal() is called to do local transformations on
* an expression tree preparitory to its being
* written out in intermediate code.
*
* the major essential job is rewriting the
* automatic variables and arguments in terms of
* REG and OREG nodes
* conversion ops which are not necessary are also clobbered here
* in addition, any special features (such as rewriting
* exclusive or) are easily handled here as well
*/
P1ND *
clocal(P1ND *p)
{
struct attr *ap;
register struct symtab *q;
register P1ND *r, *l, *n, *s;
register int o;
register int m;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal: %p\n", p);
p1fwalk(p, eprint, 0);
}
#endif
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
slval(r, 0);
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case USTATIC:
if (kflag == 0)
break;
/* FALLTHROUGH */
case STATIC:
#ifdef TLS
if (q->sflags & STLS) {
p = tlsref(p);
break;
}
#endif
if (kflag == 0) {
if (q->slevel == 0)
break;
} else if (kflag && !statinit && blevel > 0 &&
#ifdef GCC_COMPAT
attr_find(q->sap, GCC_ATYP_WEAKREF)) {
#else
0) {
#endif
/* extern call */
p = picext(p);
} else if (blevel > 0 && !statinit)
p = picstatic(p);
break;
case REGISTER:
p->n_op = REG;
slval(p, 0);
p->n_rval = q->soffset;
break;
case EXTERN:
case EXTDEF:
#ifdef TLS
if (q->sflags & STLS) {
p = tlsref(p);
break;
}
#endif
#ifdef PECOFFABI
if (q->sflags & SDLLINDIRECT)
p = import(p);
#endif
#ifdef GCC_COMPAT
if ((ap = attr_find(q->sap,
GCC_ATYP_VISIBILITY)) != NULL &&
strcmp(ap->sarg(0), "hidden") == 0)
printf(PRTPREF "\t.hidden %s\n", getsoname(q));
#endif
if (kflag == 0)
break;
if (blevel > 0 && !statinit)
p = picext(p);
break;
}
break;
case ADDROF:
if (kflag == 0 || blevel == 0 || statinit)
break;
/* char arrays may end up here */
l = p->n_left;
if (l->n_op != NAME ||
(l->n_type != ARY+CHAR && l->n_type != ARY+WCHAR_TYPE))
break;
l = p;
p = picstatic(p->n_left);
p1nfree(l);
if (p->n_op != UMUL)
cerror("ADDROF error");
l = p;
p = p->n_left;
p1nfree(l);
break;
case UCALL:
if (kflag == 0)
break;
l = block(REG, NIL, NIL, INT, 0, 0);
l->n_rval = EBX;
p->n_right = buildtree(ASSIGN, l, tempnode(gotnr, INT, 0, 0));
p->n_op -= (UCALL-CALL);
break;
case USTCALL:
#if defined(os_openbsd)
ap = strattr(p->n_left->n_ap);
if (ap->amsize == SZCHAR || ap->amsize == SZSHORT ||
ap->amsize == SZINT || ap->amsize == SZLONGLONG)
#else
if (attr_find(p->n_left->n_ap, ATTR_COMPLEX) &&
(ap = strattr(p->n_left->n_ap)) &&
ap->amsize == SZLONGLONG)
#endif
{
/* float complex */
/* fake one arg to make pass2 happy */
p->n_right = block(FUNARG, bcon(0), NIL, INT, 0, 0);
p->n_op -= (UCALL-CALL);
break;
}
/* Add hidden arg0 */
r = block(REG, NIL, NIL, INCREF(VOID), 0, 0);
regno(r) = EBP;
#ifdef GCC_COMPAT
if ((ap = attr_find(p->n_ap, GCC_ATYP_REGPARM)) != NULL &&
ap->iarg(0) > 0) {
l = block(REG, NIL, NIL, INCREF(VOID), 0, 0);
regno(l) = EAX;
p->n_right = buildtree(ASSIGN, l, r);
} else
#endif
p->n_right = block(FUNARG, r, NIL, INCREF(VOID), 0, 0);
p->n_op -= (UCALL-CALL);
if (kflag == 0)
break;
l = block(REG, NIL, NIL, INT, 0, 0);
regno(l) = EBX;
r = buildtree(ASSIGN, l, tempnode(gotnr, INT, 0, 0));
p->n_right = block(CM, r, p->n_right, INT, 0, 0);
break;
/* FALLTHROUGH */
#if defined(MACHOABI)
case CALL:
case STCALL:
if (p->n_type == VOID)
break;
r = tempnode(0, p->n_type, p->n_df, p->n_ap);
l = tcopy(r);
p = buildtree(COMOP, buildtree(ASSIGN, r, p), l);
#endif
break;
#ifdef notyet
/* XXX breaks sometimes */
case CBRANCH:
l = p->n_left;
/*
* Remove unnecessary conversion ops.
*/
if (!clogop(l->n_op) || l->n_left->n_op != SCONV)
break;
if (coptype(l->n_op) != BITYPE)
break;
if (l->n_right->n_op != ICON)
break;
r = l->n_left->n_left;
if (r->n_type >= FLOAT)
break;
if (toolarge(r->n_type, l->n_right->n_lval))
break;
l->n_right->n_type = r->n_type;
if (l->n_op >= ULE && l->n_op <= UGT)
l->n_op -= (UGT-ULE);
p->n_left = buildtree(l->n_op, r, l->n_right);
p1nfree(l->n_left);
p1nfree(l);
break;
#endif
case PCONV:
l = p->n_left;
/* Make int type before pointer */
if (l->n_type < INT || l->n_type == LONGLONG ||
l->n_type == ULONGLONG || l->n_type == BOOL) {
/* float etc? */
p->n_left = block(SCONV, l, NIL, UNSIGNED, 0, 0);
}
break;
case SCONV:
if (p->n_left->n_op == COMOP)
break; /* may propagate wrong type later */
l = p->n_left;
if (p->n_type == l->n_type) {
p1nfree(p);
return l;
}
if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
tsize(p->n_type, p->n_df, p->n_ap) ==
tsize(l->n_type, l->n_df, l->n_ap)) {
if (p->n_type != FLOAT && p->n_type != DOUBLE &&
l->n_type != FLOAT && l->n_type != DOUBLE &&
l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
if (l->n_op == NAME || l->n_op == UMUL ||
l->n_op == TEMP) {
l->n_type = p->n_type;
p1nfree(p);
return l;
}
}
}
if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
coptype(l->n_op) == BITYPE && l->n_op != COMOP &&
l->n_op != QUEST && l->n_op != ASSIGN) {
l->n_type = p->n_type;
p1nfree(p);
return l;
}
o = l->n_op;
m = p->n_type;
if (o == ICON) {
/*
* Can only end up here if o is an address,
* and in that case the only compile-time conversion
* possible is to int.
*/
if ((TMASK & l->n_type) == 0 && l->n_sp == NULL)
cerror("SCONV ICON");
if (l->n_sp == 0) {
p->n_type = UNSIGNED;
concast(l, m);
} else if (m != INT && m != UNSIGNED)
break;
l->n_type = m;
l->n_ap = 0;
p1nfree(p);
return l;
} else if (l->n_op == FCON)
cerror("SCONV FCON");
if ((p->n_type == CHAR || p->n_type == UCHAR ||
p->n_type == SHORT || p->n_type == USHORT) &&
(l->n_type == FLOAT || l->n_type == DOUBLE ||
l->n_type == LDOUBLE)) {
p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
p->n_left->n_type = INT;
return p;
}
break;
case MOD:
case DIV:
if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
break;
if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
break;
/* make it an int division by inserting conversions */
p->n_left = makety(p->n_left, INT, 0, 0, 0);
p->n_right = makety(p->n_right, INT, 0, 0, 0);
o = p->n_type;
p->n_type = INT;
p = makety(p, o, 0, 0, 0);
break;
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
p->n_left->n_rval = p->n_left->n_type == BOOL ?
RETREG(CHAR) : RETREG(p->n_type);
break;
case LS:
case RS:
/* shift count must be in a char */
if (p->n_right->n_type == CHAR || p->n_right->n_type == UCHAR)
break;
p->n_right = block(SCONV, p->n_right, NIL, CHAR, 0, 0);
break;
/* If not using pcc struct return */
case STASG:
r = p->n_right;
if (r->n_op != STCALL && r->n_op != USTCALL)
break;
m = tsize(BTYPE(r->n_type), r->n_df, r->n_ap);
if (m == SZCHAR)
m = CHAR;
else if (m == SZSHORT)
m = SHORT;
else if (m == SZINT)
m = INT;
else if (m == SZLONGLONG)
m = LONGLONG;
else
break;
#if !defined(os_openbsd)
if (attr_find(r->n_ap, ATTR_COMPLEX) == 0)
break; /* float _Complex always in regs */
#endif
l = buildtree(ADDROF, p->n_left, NIL);
p1nfree(p);
r->n_op -= (STCALL-CALL);
r->n_type = m;
/* r = long, l = &struct */
n = tempnode(0, m, r->n_df, r->n_ap);
r = buildtree(ASSIGN, p1tcopy(n), r);
s = tempnode(0, l->n_type, l->n_df, l->n_ap);
l = buildtree(ASSIGN, p1tcopy(s), l);
p = buildtree(COMOP, r, l);
l = buildtree(CAST,
block(NAME, NIL, NIL, m|PTR, 0, 0), p1tcopy(s));
r = l->n_right;
p1nfree(l->n_left);
p1nfree(l);
r = buildtree(ASSIGN, buildtree(UMUL, r, NIL), n);
p = buildtree(COMOP, p, r);
p = buildtree(COMOP, p, s);
break;
}
/*
* Do the "hard work" in assigning correct destination for arguments.
* Also convert arguments < INT to inte (default argument promotions).
* XXX - should be dome elsewhere.
*/
static NODE *
argput(NODE *p)
{
NODE *q;
TWORD ty;
int typ, r, ssz;
if (p->n_op == CM) {
p->n_left = argput(p->n_left);
p->n_right = argput(p->n_right);
return p;
}
/* first arg may be struct return pointer */
/* XXX - check if varargs; setup al */
switch (typ = argtyp(p->n_type, p->n_df, p->n_ap)) {
case INTEGER:
case SSE:
if (typ == SSE)
r = XMM0 + nsse++;
else
r = argregsi[ngpr++];
if (p->n_type < INT || p->n_type == BOOL)
p = cast(p, INT, 0);
p = movtoreg(p, r);
break;
case X87:
r = nrsp;
nrsp += SZLDOUBLE;
p = movtomem(p, r, STKREG);
break;
case SSEMEM:
r = nrsp;
nrsp += SZDOUBLE;
p = movtomem(p, r, STKREG);
break;
case INTMEM:
r = nrsp;
nrsp += SZLONG;
p = movtomem(p, r, STKREG);
break;
case STRCPX:
case STRREG: /* Struct in registers */
/* Cast to long pointer and move to the registers */
/* XXX can overrun struct size */
/* XXX check carefully for SSE members */
ssz = tsize(p->n_type, p->n_df, p->n_ap);
if (typ == STRCPX) {
ty = DOUBLE;
r = XMM0 + nsse++;
} else {
ty = LONG;
r = argregsi[ngpr++];
}
if (ssz <= SZLONG) {
q = cast(p->n_left, INCREF(ty), 0);
nfree(p);
q = buildtree(UMUL, q, NIL);
p = movtoreg(q, r);
} else if (ssz <= SZLONG*2) {
NODE *ql, *qr;
qr = cast(ccopy(p->n_left), INCREF(ty), 0);
qr = movtoreg(buildtree(UMUL, qr, NIL), r);
ql = cast(p->n_left, INCREF(ty), 0);
ql = buildtree(UMUL, buildtree(PLUS, ql, bcon(1)), NIL);
r = (typ == STRCPX ? XMM0 + nsse++ : argregsi[ngpr++]);
ql = movtoreg(ql, r);
nfree(p);
p = buildtree(CM, ql, qr);
} else
cerror("STRREG");
break;
case STRMEM: {
struct symtab s;
NODE *l, *t;
q = buildtree(UMUL, p->n_left, NIL);
s.stype = p->n_type;
s.squal = 0;
s.sdf = p->n_df;
s.sap = p->n_ap;
s.soffset = nrsp;
s.sclass = AUTO;
nrsp += tsize(p->n_type, p->n_df, p->n_ap);
l = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
l->n_lval = 0;
regno(l) = STKREG;
t = block(NAME, NIL, NIL, p->n_type, p->n_df, p->n_ap);
t->n_sp = &s;
t = stref(block(STREF, l, t, 0, 0, 0));
t = (buildtree(ASSIGN, t, q));
nfree(p);
p = t->n_left;
nfree(t);
break;
}
default:
cerror("argument %d", typ);
}
return p;
}
/* clocal() is called to do local transformations on
* an expression tree preparitory to its being
* written out in intermediate code.
*
* the major essential job is rewriting the
* automatic variables and arguments in terms of
* REG and OREG nodes
* conversion ops which are not necessary are also clobbered here
* in addition, any special features (such as rewriting
* exclusive or) are easily handled here as well
*/
NODE *
clocal(NODE *p)
{
register struct symtab *q;
register NODE *r, *l;
register int o;
TWORD t;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
slval(r, 0);
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case REGISTER:
p->n_op = REG;
slval(p, 0);
p->n_rval = q->soffset;
break;
case USTATIC:
case STATIC:
if (kflag == 0)
break;
if (blevel > 0 && !statinit)
p = picstatic(p);
break;
case EXTERN:
case EXTDEF:
if (kflag == 0)
break;
if (blevel > 0 && !statinit)
p = picext(p);
break;
}
break;
case ADDROF:
if (kflag == 0 || blevel == 0 || statinit)
break;
/* char arrays may end up here */
l = p->n_left;
if (l->n_op != NAME ||
(l->n_type != ARY+CHAR && l->n_type != ARY+WCHAR_TYPE))
break;
l = p;
p = picstatic(p->n_left);
nfree(l);
if (p->n_op != UMUL)
cerror("ADDROF error");
l = p;
p = p->n_left;
nfree(l);
break;
case STASG: /* convert struct assignment to call memcpy */
l = p->n_left;
if (l->n_op == NAME && ISFTN(l->n_sp->stype))
break; /* struct return, do nothing */
/* first construct arg list */
p->n_left = buildtree(ADDROF, p->n_left, 0);
r = bcon(tsize(STRTY, p->n_df, p->n_ap)/SZCHAR);
p->n_left = buildtree(CM, p->n_left, p->n_right);
p->n_right = r;
p->n_op = CM;
p->n_type = INT;
r = block(NAME, NIL, NIL, INT, 0, 0);
r->n_sp = lookup(addname("memcpy"), SNORMAL);
if (r->n_sp->sclass == SNULL) {
r->n_sp->sclass = EXTERN;
r->n_sp->stype = INCREF(VOID+PTR)+(FTN-PTR);
}
r->n_type = r->n_sp->stype;
p = buildtree(CALL, r, p);
break;
case SCONV:
l = p->n_left;
if (l->n_op == ICON && ISPTR(l->n_type)) {
/* Do immediate cast here */
/* Should be common code */
q = l->n_sp;
l->n_sp = NULL;
l->n_type = UNSIGNED;
if (concast(l, p->n_type) == 0)
cerror("clocal");
p = nfree(p);
p->n_sp = q;
}
break;
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
t = p->n_type;
if (ISITY(t))
t = t - (FIMAG-FLOAT);
p->n_left->n_rval = RETREG(t);
break;
}
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal end: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
return(p);
}