bstruct( idn, soru ){ /* begining of structure or union declaration */
register NODE *q;
psave( instruct );
psave( curclass );
psave( strucoff );
strucoff = 0;
instruct = soru;
q = block( FREE, NIL, NIL, 0, 0, 0 );
q->rval = idn;
if( instruct==INSTRUCT ){
curclass = MOS;
q->type = STRTY;
if( idn >= 0 ) defid( q, STNAME );
}
else if( instruct == INUNION ) {
curclass = MOU;
q->type = UNIONTY;
if( idn >= 0 ) defid( q, UNAME );
}
else { /* enum */
curclass = MOE;
q->type = ENUMTY;
if( idn >= 0 ) defid( q, ENAME );
}
psave( q->rval );
return( paramno-4 );
}
/*
* Put all builtin functions into the global symbol table.
*/
void
builtin_init()
{
const struct bitable *bt;
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
int i, d_debug;
d_debug = ddebug;
ddebug = 0;
for (i = 0; i < (int)(sizeof(bitable)/sizeof(bitable[0])); i++) {
bt = &bitable[i];
if ((bt->flags & BTGNUONLY) && xgnu99 == 0 && xgnu89 == 0)
continue; /* not in c99 universe, at least for now */
sp = lookup(addname(bt->name), 0);
if (bt->rt == 0 && (bt->flags & BTNORVAL) == 0)
cerror("function '%s' has no return type", bt->name);
p->n_type = INCREF(bt->rt) + (FTN-PTR);
p->n_df = memset(permalloc(sizeof(union dimfun)), 0,
sizeof(union dimfun));
p->n_sp = sp;
defid(p, EXTERN);
sp->soffset = i;
sp->sflags |= SBUILTIN;
}
nfree(p);
ddebug = d_debug;
}
NODE *
rstruct( idn, soru ){ /* reference to a structure or union, with no definition */
register struct symtab *p;
register NODE *q;
p = &stab[idn];
switch( p->stype ){
case UNDEF:
def:
q = block( FREE, NIL, NIL, 0, 0, 0 );
q->rval = idn;
q->type = (soru&INSTRUCT) ? STRTY : ( (soru&INUNION) ? UNIONTY : ENUMTY );
defid( q, (soru&INSTRUCT) ? STNAME : ( (soru&INUNION) ? UNAME : ENAME ) );
break;
case STRTY:
if( soru & INSTRUCT ) break;
goto def;
case UNIONTY:
if( soru & INUNION ) break;
goto def;
case ENUMTY:
if( !(soru&(INUNION|INSTRUCT)) ) break;
goto def;
}
stwart = instruct;
return( mkty( p->stype, 0, p->sizoff ) );
}
static struct symtab *
addstr(char *n)
{
NODE *p = block(NAME, NIL, NIL, FLOAT, 0, 0);
struct symtab *sp;
NODE *q;
struct attr *ap;
struct rstack *rp;
extern struct rstack *rpole;
p->n_type = ctype(ULONGLONG);
rpole = rp = bstruct(NULL, STNAME, NULL);
soumemb(p, loti, 0);
soumemb(p, hiti, 0);
q = dclstruct(rp);
sp = q->n_sp = lookup(addname(n), 0);
defid(q, TYPEDEF);
ap = attr_new(GCC_ATYP_MODE, 3);
ap->sarg(0) = addname("TI");
ap->iarg(1) = 0;
sp->sap = attr_add(sp->sap, ap);
nfree(q);
nfree(p);
return sp;
}
/*
* Create a symbol out of a struct.
* We call the symbol "__%THIS" to avoid interference.
*/
struct symtab *
cxxstrvar(struct symtab *so)
{
struct symtab *sp;
NODE *p;
sp = lookup("__%THIS", 0);
p = block(NAME, 0, 0, INCREF(so->stype), so->sdf, so->sap);
p->n_sp = sp;
defid(p, PARAM);
nfree(p);
return sp;
}
static struct symtab *
addftn(char *n, TWORD t)
{
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
sp = lookup(addname(n), 0);
p->n_type = INCREF(t) + (FTN-PTR);
p->n_sp = sp;
p->n_df = memset(permalloc(sizeof(union dimfun)), 0,
sizeof(union dimfun));
defid(p, EXTERN);
nfree(p);
return sp;
}
void
bjobcode(void)
{
struct symtab *sp;
struct rstack *rp;
NODE *p, *q;
char *c;
/* amd64 names for some asm constant printouts */
astypnames[INT] = astypnames[UNSIGNED] = "\t.long";
astypnames[LONG] = astypnames[ULONG] = "\t.quad";
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, 0);
soumemb(p, gp_offset, 0);
soumemb(p, fp_offset, 0);
p->n_type = VOID+PTR;
p->n_ap = NULL;
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, 0);
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(void)
{
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, 0);
sp = lookup(addname(g77n[i]), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
}
/*
* Put all builtin functions into the global symbol table.
*/
void
builtin_init()
{
const struct bitable *bt;
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
int i;
for (i = 0; i < (int)(sizeof(bitable)/sizeof(bitable[0])); i++) {
bt = &bitable[i];
sp = lookup(addname(bt->name), 0);
if (bt->rt == 0 && (bt->flags & BTNORVAL) == 0)
cerror("function '%s' has no return type", bt->name);
p->n_type = INCREF(bt->rt) + (FTN-PTR);
p->n_sp = sp;
defid(p, EXTDEF);
sp->soffset = i;
sp->sflags |= SBUILTIN;
}
nfree(p);
}
dclargs(){
register i, j;
register struct symtab *p;
register NODE *q;
argoff = ARGINIT;
for( i=0; i<paramno; ++i ){
if( (j = paramstk[i]) < 0 ) continue;
p = &stab[j];
if( p->stype == FARG ) {
q = block(FREE,NIL,NIL,INT,0,INT);
q->rval = j;
defid( q, PARAM );
}
oalloc( p, &argoff ); /* always set aside space, even for register arguments */
}
cendarg();
locctr(PROG);
defalign(ALINT);
++ftnno;
bfcode( paramstk, paramno );
paramno = 0;
}
/* 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:gkm:psvwx:")) != -1) {
switch (ch) {
#if !defined(MULTIPASS) || defined(PASS1)
case 'X': /* pass1 debugging */
while (*optarg)
switch (*optarg++) {
case 'b': ++bdebug; break; /* buildtree */
case 'd': ++ddebug; break; /* declarations */
case 'e': ++edebug; break; /* pass1 exit */
case 'i': ++idebug; break; /* initializations */
case 'n': ++ndebug; break; /* node allocation */
case 'o': ++odebug; break; /* optim */
case 'p': ++pdebug; break; /* prototype */
case 's': ++sdebug; break; /* inline */
case 't': ++tdebug; break; /* type match */
case 'x': ++xdebug; break; /* MD code */
default:
fprintf(stderr, "unknown -X flag '%c'\n",
optarg[-1]);
exit(1);
}
break;
#endif
#if !defined(MULTIPASS) || defined(PASS2)
case 'Z': /* pass2 debugging */
while (*optarg)
switch (*optarg++) {
case 'b': /* basic block and SSA building */
++b2debug;
break;
case 'c': /* code printout */
++c2debug;
break;
case 'e': /* print tree upon pass2 enter */
++e2debug;
break;
case 'f': /* instruction matching */
++f2debug;
break;
case 'g': /* print flow graphs */
++g2debug;
break;
case 'n': /* node allocation */
++ndebug;
break;
case 'o': /* instruction generator */
++o2debug;
break;
case 'r': /* register alloc/graph coloring */
++r2debug;
break;
case 's': /* shape matching */
++s2debug;
break;
case 't': /* type matching */
++t2debug;
break;
case 'u': /* Sethi-Ullman debugging */
++u2debug;
break;
case 'x': /* target specific */
++x2debug;
break;
default:
fprintf(stderr, "unknown -Z flag '%c'\n",
optarg[-1]);
exit(1);
}
break;
#endif
case 'f': /* Language */
fflags(optarg);
break;
case 'g': /* Debugging */
++gflag;
break;
case 'k': /* PIC code */
++kflag;
break;
case 'm': /* Target-specific */
mflags(optarg);
break;
case 'p': /* Profiling */
++pflag;
break;
case 's': /* Statistics */
++sflag;
break;
case 'W': /* Enable different warnings */
Wflags(optarg);
break;
case 'x': /* Different settings */
xopt(optarg);
break;
case 'v':
printf("ccom: %s\n", VERSSTR);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
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, 0);
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);
}
void
gcc_init(void)
{
struct kw *kwp;
NODE *p;
TWORD t;
int i, d_debug;
d_debug = ddebug;
ddebug = 0;
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, 0);
sp = lookup(addname(g77n[i]), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
ddebug = d_debug;
#ifdef TARGET_TIMODE
{
struct attr *ap;
loti = addname("__loti");
hiti = addname("__hiti");
TISTR = addname("TI");
tisp = addstr("0ti");
cmpti2sp = addftn("__cmpti2", INT);
ucmpti2sp = addftn("__ucmpti2", INT);
addvti3sp = addftn("__addvti3", STRTY);
addvti3sp->sap = tisp->sap;
subvti3sp = addftn("__subvti3", STRTY);
subvti3sp->sap = tisp->sap;
mulvti3sp = addftn("__mulvti3", STRTY);
mulvti3sp->sap = tisp->sap;
divti3sp = addftn("__divti3", STRTY);
divti3sp->sap = tisp->sap;
modti3sp = addftn("__modti3", STRTY);
modti3sp->sap = tisp->sap;
ap = attr_new(GCC_ATYP_MODE, 3);
ap->sarg(0) = TISTR;
ap->iarg(1) = 1;
ap = attr_add(tisp->sap, ap);
udivti3sp = addftn("__udivti3", STRTY);
udivti3sp->sap = ap;
umodti3sp = addftn("__umodti3", STRTY);
umodti3sp->sap = ap;
ashldi3sp = addftn("__ashldi3", ctype(LONGLONG));
ashldi3sp->sap = ap;
ashrdi3sp = addftn("__ashrdi3", ctype(LONGLONG));
ashrdi3sp->sap = ap;
lshrdi3sp = addftn("__lshrdi3", ctype(LONGLONG));
lshrdi3sp->sap = ap;
floatuntixfsp = addftn("__floatuntixf", LDOUBLE);
}
#endif
}