/*
* Check and cast arguments for builtins.
*/
static int
acnt(NODE *a, int narg, TWORD *tp)
{
NODE *q;
TWORD t;
if (a == NIL)
return narg;
for (; a->n_op == CM; a = a->n_left, narg--) {
if (tp == NULL)
continue;
q = a->n_right;
t = tp[narg-1];
if (q->n_type == t)
continue;
a->n_right = ccast(q, t, 0, NULL, MKAP(BTYPE(t)));
}
/* Last arg is ugly to deal with */
if (narg == 1 && tp != NULL) {
q = talloc();
*q = *a;
q = ccast(q, tp[0], 0, NULL, MKAP(BTYPE(tp[0])));
*a = *q;
nfree(q);
}
return narg != 1;
}
/*
* code for the end of a function
* deals with struct return here
* The return value is in (or pointed to by) RETREG.
*/
void
efcode()
{
struct symtab *sp;
extern int gotnr;
TWORD t;
NODE *p, *r, *l;
int typ, ssz, rno;
gotnr = 0; /* new number for next fun */
sp = cftnsp;
t = DECREF(sp->stype);
if (t != STRTY && t != UNIONTY)
return;
/* XXX should have one routine for this */
if ((typ = argtyp(t, sp->sdf, sp->sap)) == STRREG || typ == STRCPX) {
/* Cast to long pointer and move to the registers */
/* XXX can overrun struct size */
/* XXX check carefully for SSE members */
if ((ssz = tsize(t, sp->sdf, sp->sap)) > SZLONG*2)
cerror("efcode1");
if (typ == STRCPX) {
t = DOUBLE;
rno = XMM0;
} else {
t = LONG;
rno = RAX;
}
if (ssz > SZLONG) {
p = block(REG, NIL, NIL, INCREF(t), 0, MKAP(t));
regno(p) = RAX;
p = buildtree(UMUL, buildtree(PLUS, p, bcon(1)), NIL);
ecomp(movtoreg(p, rno+1));
}
p = block(REG, NIL, NIL, INCREF(t), 0, MKAP(t));
regno(p) = RAX;
p = buildtree(UMUL, p, NIL);
ecomp(movtoreg(p, rno));
} else if (typ == STRMEM) {
r = block(REG, NIL, NIL, INCREF(t), sp->sdf, sp->sap);
regno(r) = RAX;
r = buildtree(UMUL, r, NIL);
l = tempnode(stroffset, INCREF(t), sp->sdf, sp->sap);
l = buildtree(UMUL, l, NIL);
ecomp(buildtree(ASSIGN, l, r));
l = block(REG, NIL, NIL, LONG, 0, MKAP(LONG));
regno(l) = RAX;
r = tempnode(stroffset, LONG, 0, MKAP(LONG));
ecomp(buildtree(ASSIGN, l, r));
} else
cerror("efcode");
}
/*
* Called with a function call with arguments as argument.
* This is done early in buildtree() and only done once.
* Returns p.
*/
NODE *
funcode(NODE *p)
{
NODE *l, *r;
TWORD t;
nsse = ngpr = nrsp = 0;
/* Check if hidden arg needed */
/* If so, add it in pass2 */
if ((l = p->n_left)->n_type == INCREF(FTN)+STRTY ||
l->n_type == INCREF(FTN)+UNIONTY) {
int ssz = tsize(BTYPE(l->n_type), l->n_df, l->n_ap);
if (ssz > 2*SZLONG)
ngpr++;
}
/* Convert just regs to assign insn's */
p->n_right = argput(p->n_right);
/* Must sort arglist so that STASG ends up first */
/* This avoids registers being clobbered */
while (argsort(p->n_right))
;
/* Check if there are varargs */
if (nsse || l->n_df == NULL || l->n_df->dfun == NULL) {
; /* Need RAX */
} else {
union arglist *al = l->n_df->dfun;
for (; al->type != TELLIPSIS; al++) {
if ((t = al->type) == TNULL)
return p; /* No need */
if (BTYPE(t) == STRTY || BTYPE(t) == UNIONTY)
al++;
for (; t > BTMASK; t = DECREF(t))
if (ISARY(t) || ISFTN(t))
al++;
}
}
/* Always emit number of SSE regs used */
l = movtoreg(bcon(nsse), RAX);
if (p->n_right->n_op != CM) {
p->n_right = block(CM, l, p->n_right, INT, 0, MKAP(INT));
} else {
for (r = p->n_right; r->n_left->n_op == CM; r = r->n_left)
;
r->n_left = block(CM, l, r->n_left, INT, 0, MKAP(INT));
}
return p;
}
void
myp2tree(NODE *p)
{
struct symtab *sp;
if (p->n_op != FCON)
return;
/* Write float constants to memory */
sp = IALLOC(sizeof(struct symtab));
sp->sclass = STATIC;
sp->sap = MKAP(p->n_type);
sp->slevel = 1; /* fake numeric label */
sp->soffset = getlab();
sp->sflags = 0;
sp->stype = p->n_type;
sp->squal = (CON >> TSHIFT);
defloc(sp);
ninval(0, sp->sap->atypsz, p);
p->n_op = NAME;
p->n_lval = 0;
p->n_sp = sp;
}
/*
* Handle the builtin macros for the math functions is*
* To get something that is be somewhat generic assume that
* isnan() is a real function and that cast of a NaN type
* to double will still be a NaN.
*/
static NODE *
mtisnan(NODE *p)
{
NODE *q = block(NAME, NIL, NIL, INT, 0, MKAP(INT));
return binhelp(q, cast(ccopy(p), DOUBLE, 0), INT, "isnan");
}
static NODE *
mkstkref(int off, TWORD typ)
{
NODE *p;
p = block(REG, NIL, NIL, PTR|typ, 0, MKAP(LONG));
regno(p) = FPREG;
return buildtree(PLUS, p, bcon(off/SZCHAR));
}
/*
* replace an alloca function with direct allocation on stack.
* return a destination temp node.
*/
static NODE *
builtin_alloca(NODE *f, NODE *a, TWORD rt)
{
struct symtab *sp;
NODE *t, *u;
#ifdef notyet
if (xnobuiltins)
return NULL;
#endif
sp = f->n_sp;
t = tempnode(0, VOID|PTR, 0, MKAP(INT) /* XXX */);
u = tempnode(regno(t), VOID|PTR, 0, MKAP(INT) /* XXX */);
spalloc(t, a, SZCHAR);
tfree(f);
return u;
}
void
bjobcode()
{
struct symtab *sp;
struct rstack *rp;
NODE *p, *q;
char *c;
gp_offset = addname("gp_offset");
fp_offset = addname("fp_offset");
overflow_arg_area = addname("overflow_arg_area");
reg_save_area = addname("reg_save_area");
rp = bstruct(NULL, STNAME, NULL);
p = block(NAME, NIL, NIL, UNSIGNED, 0, MKAP(UNSIGNED));
soumemb(p, gp_offset, 0);
soumemb(p, fp_offset, 0);
p->n_type = VOID+PTR;
p->n_ap = MKAP(VOID);
soumemb(p, overflow_arg_area, 0);
soumemb(p, reg_save_area, 0);
nfree(p);
q = dclstruct(rp);
c = addname("__builtin_va_list");
p = block(LB, bdty(NAME, c), bcon(1), INT, 0, MKAP(INT));
p = tymerge(q, p);
p->n_sp = lookup(c, 0);
defid(p, TYPEDEF);
nfree(q);
nfree(p);
/* for the static varargs functions */
#define MKN(vn, rn, tp) \
{ vn = addname(rn); sp = lookup(vn, SNORMAL); \
sp->sclass = USTATIC; sp->stype = tp; }
MKN(gpnext, "__pcc_gpnext", FTN|LONG);
MKN(fpnext, "__pcc_fpnext", FTN|DOUBLE);
MKN(_1regref, "__pcc_1regref", FTN|VOID|(PTR<<TSHIFT));
MKN(_2regref, "__pcc_2regref", FTN|VOID|(PTR<<TSHIFT));
MKN(memref, "__pcc_memref", FTN|VOID|(PTR<<TSHIFT));
}
void
gcc_init()
{
struct kw *kwp;
NODE *p;
TWORD t;
int i;
for (kwp = kw; kwp->name; kwp++)
kwp->ptr = addname(kwp->name);
for (i = 0; i < 4; i++) {
struct symtab *sp;
t = ctype(g77t[i]);
p = block(NAME, NIL, NIL, t, NULL, MKAP(t));
sp = lookup(addname(g77n[i]), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(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, MKAP(PTR+VOID));
}
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, MKAP(INT));
p->n_type = INT;
p->n_ap = MKAP(INT);
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, MKAP(UNSIGNED));
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 &&
btattr[p->n_type].atypsz == btattr[l->n_type].atypsz) {
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 = MKAP(m);
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, MKAP(INT));
p->n_right = block(SCONV, p->n_right, NIL, INT, 0, MKAP(INT));
p = block(SCONV, p, NIL, p->n_type, 0, MKAP(p->n_type));
p->n_left->n_type = INT;
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 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, MKAP(INT));
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);
}
/*
* 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 **s, int cnt)
{
union arglist *al;
struct symtab *sp;
NODE *p, *r;
TWORD t;
int i, rno, typ;
/* recalculate the arg offset and create TEMP moves */
/* Always do this for reg, even if not optimizing, to free arg regs */
nsse = ngpr = 0;
nrsp = ARGINIT;
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
sp = cftnsp;
if (argtyp(DECREF(sp->stype), sp->sdf, sp->sap) == STRMEM) {
r = block(REG, NIL, NIL, LONG, 0, MKAP(LONG));
regno(r) = argregsi[ngpr++];
p = tempnode(0, r->n_type, r->n_df, r->n_ap);
stroffset = regno(p);
ecomp(buildtree(ASSIGN, p, r));
}
}
for (i = 0; i < cnt; i++) {
sp = s[i];
if (sp == NULL)
continue; /* XXX when happens this? */
switch (typ = argtyp(sp->stype, sp->sdf, sp->sap)) {
case INTEGER:
case SSE:
if (typ == SSE)
rno = XMM0 + nsse++;
else
rno = argregsi[ngpr++];
r = block(REG, NIL, NIL, sp->stype, sp->sdf, sp->sap);
regno(r) = rno;
p = tempnode(0, sp->stype, sp->sdf, sp->sap);
sp->soffset = regno(p);
sp->sflags |= STNODE;
ecomp(buildtree(ASSIGN, p, r));
break;
case SSEMEM:
sp->soffset = nrsp;
nrsp += SZDOUBLE;
if (xtemps) {
p = tempnode(0, sp->stype, sp->sdf, sp->sap);
p = buildtree(ASSIGN, p, nametree(sp));
sp->soffset = regno(p->n_left);
sp->sflags |= STNODE;
ecomp(p);
}
break;
case INTMEM:
sp->soffset = nrsp;
nrsp += SZLONG;
if (xtemps) {
p = tempnode(0, sp->stype, sp->sdf, sp->sap);
p = buildtree(ASSIGN, p, nametree(sp));
sp->soffset = regno(p->n_left);
sp->sflags |= STNODE;
ecomp(p);
}
break;
case STRMEM: /* Struct in memory */
sp->soffset = nrsp;
nrsp += tsize(sp->stype, sp->sdf, sp->sap);
break;
case X87: /* long double args */
sp->soffset = nrsp;
nrsp += SZLDOUBLE;
break;
case STRCPX:
case STRREG: /* Struct in register */
/* Allocate space on stack for the struct */
/* For simplicity always fetch two longwords */
autooff += (2*SZLONG);
if (typ == STRCPX) {
t = DOUBLE;
rno = XMM0 + nsse++;
} else {
t = LONG;
rno = argregsi[ngpr++];
}
r = block(REG, NIL, NIL, t, 0, MKAP(t));
regno(r) = rno;
ecomp(movtomem(r, -autooff, FPREG));
if (tsize(sp->stype, sp->sdf, sp->sap) > SZLONG) {
r = block(REG, NIL, NIL, t, 0, MKAP(t));
regno(r) = (typ == STRCPX ?
XMM0 + nsse++ : argregsi[ngpr++]);
ecomp(movtomem(r, -autooff+SZLONG, FPREG));
}
sp->soffset = -autooff;
break;
default:
cerror("bfcode: %d", typ);
}
}
/* Check if there are varargs */
if (cftnsp->sdf == NULL || cftnsp->sdf->dfun == NULL)
return; /* no prototype */
al = cftnsp->sdf->dfun;
for (; al->type != TELLIPSIS; al++) {
t = al->type;
if (t == TNULL)
return;
if (BTYPE(t) == STRTY || BTYPE(t) == UNIONTY)
al++;
for (; t > BTMASK; t = DECREF(t))
if (ISARY(t) || ISFTN(t))
al++;
}
/* fix stack offset */
SETOFF(autooff, ALMAX);
/* Save reg arguments in the reg save area */
p = NIL;
for (i = ngpr; i < 6; i++) {
r = block(REG, NIL, NIL, LONG, 0, MKAP(LONG));
regno(r) = argregsi[i];
r = movtomem(r, -RSALONGOFF(i)-autooff, FPREG);
p = (p == NIL ? r : block(COMOP, p, r, INT, 0, MKAP(INT)));
}
for (i = nsse; i < 8; i++) {
r = block(REG, NIL, NIL, DOUBLE, 0, MKAP(DOUBLE));
regno(r) = i + XMM0;
r = movtomem(r, -RSADBLOFF(i)-autooff, FPREG);
p = (p == NIL ? r : block(COMOP, p, r, INT, 0, MKAP(INT)));
}
autooff += RSASZ;
rsaoff = autooff;
thissse = nsse;
thisgpr = ngpr;
thisrsp = nrsp;
ecomp(p);
}
/* control multiple files */
int
main(int argc, char *argv[])
{
int ch;
#ifdef TIMING
struct timeval t1, t2;
(void)gettimeofday(&t1, NULL);
#endif
prgname = argv[0];
while ((ch = getopt(argc, argv, "OT:VW:X:Z:f:gklm:psvwx:")) != -1) {
switch (ch) {
#if !defined(MULTIPASS) || defined(PASS1)
case 'X':
while (*optarg)
switch (*optarg++) {
case 'd': ++ddebug; break; /* declarations */
case 'i': ++idebug; break; /* initializations */
case 'b': ++bdebug; break; /* buildtree */
case 't': ++tdebug; break; /* type match */
case 'e': ++edebug; break; /* pass1 exit */
case 'x': ++xdebug; break; /* MD code */
case 's': ++sdebug; break; /* inline */
case 'n': ++nflag; break; /* node alloc */
case 'o': ++oflag; break; /* optim */
case 'p': ++pdebug; break; /* prototype */
default:
fprintf(stderr, "unknown X flag '%c'\n",
optarg[-1]);
exit(1);
}
#endif
break;
#if !defined(MULTIPASS) || defined(PASST)
case 'T':
while (*optarg)
switch (*optarg++) {
case 'i': ++iTflag; break;
case 'o': ++oTflag; break;
case 'n': ++nflag; break;
default:
fprintf(stderr, "unknown T flag '%c'\n",
optarg[-1]);
exit(1);
}
#endif
break;
#if !defined(MULTIPASS) || defined(PASS2)
case 'Z':
while (*optarg)
switch (*optarg++) {
case 'f': /* instruction matching */
++f2debug;
break;
case 'e': /* print tree upon pass2 enter */
++e2debug;
break;
case 'o': ++odebug; break;
case 'r': /* register alloc/graph coloring */
++rdebug;
break;
case 'b': /* basic block and SSA building */
++b2debug;
break;
case 'c': /* code printout */
++c2debug;
break;
case 't': ++t2debug; break;
case 's': /* shape matching */
++s2debug;
break;
case 'u': /* Sethi-Ullman debugging */
++udebug;
break;
case 'x': ++x2debug; break;
case 'g': /* print flow graphs */
++g2debug;
break;
case 'n': ++nflag; break;
default:
fprintf(stderr, "unknown Z flag '%c'\n",
optarg[-1]);
exit(1);
}
#endif
break;
case 'f': /* Language */
fflags(optarg);
break;
case 'g': /* Debugging */
gflag = 1;
break;
case 'k': /* PIC code */
++kflag;
break;
case 'l': /* Linenos */
++lflag;
break;
case 'm': /* Target-specific */
mflags(optarg);
break;
case 'p': /* Profiling */
pflag = 1;
break;
case 's': /* Statistics */
++sflag;
break;
case 'W': /* Enable different warnings */
Wflags(optarg);
break;
case 'x': /* Different optimizations */
if (strcmp(optarg, "ssa") == 0)
xssaflag++;
else if (strcmp(optarg, "tailcall") == 0)
xtailcallflag++;
else if (strcmp(optarg, "temps") == 0)
xtemps++;
else if (strcmp(optarg, "deljumps") == 0)
xdeljumps++;
else if (strcmp(optarg, "dce") == 0)
xdce++;
else if (strcmp(optarg, "inline") == 0)
xinline++;
else if (strcmp(optarg, "ccp") == 0)
xccp++;
else
usage();
break;
case 'v':
printf("ccom: %s\n", VERSSTR);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 0 && isatty(0))
usage();
if (argc > 0 && strcmp(argv[0], "-") != 0) {
if (freopen(argv[0], "r", stdin) == NULL) {
fprintf(stderr, "open input file '%s':",
argv[0]);
perror(NULL);
exit(1);
}
}
if (argc > 1 && strcmp(argv[1], "-") != 0) {
if (freopen(argv[1], "w", stdout) == NULL) {
fprintf(stderr, "open output file '%s':",
argv[1]);
perror(NULL);
exit(1);
}
}
mkdope();
signal(SIGSEGV, segvcatch);
#ifdef SIGBUS
signal(SIGBUS, segvcatch);
#endif
fregs = FREGS; /* number of free registers */
lineno = 1;
#ifdef GCC_COMPAT
gcc_init();
#endif
/* starts past any of the above */
reached = 1;
bjobcode();
#ifndef TARGET_VALIST
{
NODE *p = block(NAME, NIL, NIL, PTR|CHAR, NULL, MKAP(CHAR));
struct symtab *sp = lookup(addname("__builtin_va_list"), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
#endif
complinit();
#ifdef STABS
if (gflag) {
stabs_file(argc ? argv[0] : "");
stabs_init();
}
#endif
if (sspflag)
sspinit();
(void) yyparse();
yyaccpt();
if (!nerrors)
lcommprint();
#ifdef STABS
if (gflag)
stabs_efile(argc ? argv[0] : "");
#endif
ejobcode( nerrors ? 1 : 0 );
#ifdef TIMING
(void)gettimeofday(&t2, NULL);
t2.tv_sec -= t1.tv_sec;
t2.tv_usec -= t1.tv_usec;
if (t2.tv_usec < 0) {
t2.tv_usec += 1000000;
t2.tv_sec -= 1;
}
fprintf(stderr, "ccom total time: %ld s %ld us\n",
t2.tv_sec, t2.tv_usec);
#endif
if (sflag)
prtstats();
return(nerrors?1:0);
}
/*
* See if a string matches a gcc keyword.
*/
int
gcc_keyword(char *str, NODE **n)
{
extern int inattr, parlvl, parbal;
YYSTYPE *yyl = (YYSTYPE *)n; /* XXX should pass yylval */
char tlbuf[TLLEN], *tw;
struct kw *kwp;
int i;
/* XXX hack, should pass everything in expressions */
if (str == kw[21].ptr)
return kw[21].rv;
if (inattr)
return 0;
for (i = 0, kwp = kw; kwp->name; kwp++, i++)
if (str == kwp->ptr)
break;
if (kwp->name == NULL)
return 0;
if (kwp->rv)
return kwp->rv;
switch (i) {
case 1: /* __signed */
case 14: /* __signed__ */
*n = mkty((TWORD)SIGNED, 0, MKAP(SIGNED));
return C_TYPE;
case 3: /* __const */
*n = block(QUALIFIER, NIL, NIL, CON, 0, 0);
return C_QUALIFIER;
case 6: /* __thread */
snprintf(tlbuf, TLLEN, TS, lineno);
tw = &tlbuf[strlen(tlbuf)];
while (tw > tlbuf)
cunput(*--tw);
return -1;
case 7: /* __FUNCTION__ */
case 20: /* __PRETTY_FUNCTION__ */
if (cftnsp == NULL) {
uerror("%s outside function", kwp->name);
yylval.strp = "";
} else
yylval.strp = cftnsp->sname; /* XXX - not C99 */
return C_STRING;
case 8: /* __volatile */
case 9: /* __volatile__ */
*n = block(QUALIFIER, NIL, NIL, VOL, 0, 0);
return C_QUALIFIER;
case 15: /* __attribute__ */
case 16: /* __attribute */
inattr = 1;
parlvl = parbal;
return C_ATTRIBUTE;
case 17: /* __real__ */
yyl->intval = XREAL;
return C_UNOP;
case 18: /* __imag__ */
yyl->intval = XIMAG;
return C_UNOP;
}
cerror("gcc_keyword");
return 0;
}
