/*
* Fixup struct/unions depending on attributes.
*/
void
gcc_tcattrfix(NODE *p)
{
struct symtab *sp;
struct attr *ap;
int sz, coff, csz, al;
if ((ap = attr_find(p->n_ap, GCC_ATYP_PACKED)) == NULL)
return; /* nothing to fix */
al = ap->iarg(0);
/* Must repack struct */
coff = csz = 0;
for (sp = strmemb(ap); sp; sp = sp->snext) {
if (sp->sclass & FIELD)
sz = sp->sclass&FLDSIZ;
else
sz = (int)tsize(sp->stype, sp->sdf, sp->sap);
SETOFF(sz, al);
sp->soffset = coff;
coff += sz;
if (coff > csz)
csz = coff;
if (p->n_type == UNIONTY)
coff = 0;
}
SETOFF(csz, al); /* Roundup to whatever */
ap = attr_find(p->n_ap, ATTR_BASETYP);
ap->atypsz = csz;
ap->aalign = al;
}
void Pass2 ()
{
char * strcat (), * malloc();
if (verbose > 1)
fprintf (stderr, "Pass 2 --- Optimization\n");
maxfun = SETOFF (maxfun, 4);
bufsize = max (poolsize, maxfun);
if ((buf1 = malloc (bufsize)) == (char *)0 ||
(buf2 = malloc (bufsize)) == (char *)0) {
unlink(ofname);
error ("Not enough memory\n\n");
}
fflush (fpcode);
fflush (fpinit);
fflush (fpallo);
fflush (fpobj);
fdobj = fileno(fpobj);
fsize = HDSIZE * 4 + poolsize;
lseek(fdobj, (long)fsize, 0);
/* reuse the space of jump labels table */
lab = (int *) jlabels;
* lab = 0;
inittable();
export ();
int main(int argc, char* argv[]){
uint64_t i, j;
uint64_t ti=0;
walkargs *threadargs;
//printf("size of unsigned long long: %d\n", sizeof(unsigned long long));
//printf("size of uint64_t: %d\n", sizeof(uint64_t));
if ( argc > 1 ) {
max = strtoull(argv[1], NULL, 0);
}
grid = malloc(max/8);
memset(grid,0xaa,max/8); // 10101010 multiples of 2 are already set to 0
memset(grid,0b10101100,1);
threadargs = malloc(sqrt(max) * sizeof(walkargs));
tid = malloc(sqrt(max) * sizeof(pthread_t));
for (i=3; i<(uint64_t)sqrt(max); i++) {
if ( ISON(i) ) {
j = (uint64_t)pow(i,2);
SETOFF(j);
threadargs[ti].i=i;
threadargs[ti].j=j;
// printf("creating thread %d to remove multiples of %d\n", ti, i);
pthread_create(&tid[ti], NULL, walkovergrid, (void *)&threadargs[ti]);
numthreads++;
ti++;
pthread_mutex_lock(&mutex);
// printf("numthreads is %d and maxthreads is %d\n", numthreads, maxthreads);
while ( numthreads >= maxthreads ) {
pthread_cond_wait(&cond, &mutex);
}
pthread_mutex_unlock(&mutex);
}
}
// uncomment to print numbers
//int t=0;
//int rc;
//for(t=ti-maxthreads; t<ti; t++){
// printf("In main: joining thread #%d\n", t);
// rc = pthread_join(tid[ti-t], NULL);
// if (rc) { fprintf(stderr, "failed to join thread #%ld - %s\n",
// (long)t, strerror(rc));
// exit(EXIT_FAILURE);
// }
//}
//for (i=0;i<max;i++) {
// if ( ISON(i) ) {
// printf("%d\n", i);
// }
//}
free(grid);
pthread_exit(NULL);
}
void *walkovergrid(void *args){
// walkargs *threadargs = (walkargs*)args;
uint64_t i = ((walkargs*)args)->i;
uint64_t j = ((walkargs*)args)->j;
for (j;j<max;j+=i) {
SETOFF(j);
// usleep(1000*500);
}
// printf("Finished deleting multiples of %u\n", i);
pthread_mutex_lock(&mutex);
numthreads--;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
void
bfcode(struct symtab **sp, int n)
{
struct symtab *sp2;
NODE *p, *q;
int i, argbase, sz;
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
/* Move return address into temporary */
p = tempnode(0, INT, 0, 0);
strtemp = regno(p);
q = block(REG, 0, 0, INT, 0, 0);
regno(q) = R1;
ecomp(buildtree(ASSIGN, p, q));
}
/* correct arg alignment XXX should be done somewhere else */
argbase = ARGINIT;
for (i = 0; i < n; i++) {
sp2 = sp[i];
sz = tsize(sp2->stype, sp2->sdf, sp2->sap);
SETOFF(sz, SZINT);
sp2->soffset = argbase;
argbase += sz;
}
if (xtemps == 0)
return;
/* put arguments in temporaries */
for (i = 0; i < n; i++) {
if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY ||
cisreg(sp[i]->stype) == 0)
continue;
if (cqual(sp[i]->stype, sp[i]->squal) & VOL)
continue;
sp2 = sp[i];
p = tempnode(0, sp[i]->stype, sp[i]->sdf, sp[i]->sap);
p = buildtree(ASSIGN, p, nametree(sp2));
sp[i]->soffset = regno(p->n_left);
sp[i]->sflags |= STNODE;
ecomp(p);
}
}
/*
* Fixup struct/unions depending on attributes.
*/
void
gcc_tcattrfix(NODE *p)
{
struct symtab *sp;
struct attr *ap;
int sz, coff, csz, al, oal, mxal;
if (!ISSOU(p->n_type)) /* only for structs or unions */
return;
if ((ap = attr_find(p->n_ap, GCC_ATYP_PACKED)) == NULL)
return; /* nothing to fix */
al = ap->iarg(0);
mxal = 0;
/* Must repack struct */
coff = csz = 0;
for (sp = strmemb(ap); sp; sp = sp->snext) {
oal = talign(sp->stype, sp->sap);
if (oal > al)
oal = al;
if (mxal < oal)
mxal = oal;
if (sp->sclass & FIELD)
sz = sp->sclass&FLDSIZ;
else
sz = (int)tsize(sp->stype, sp->sdf, sp->sap);
sp->soffset = upoff(sz, oal, &coff);
if (coff > csz)
csz = coff;
if (p->n_type == UNIONTY)
coff = 0;
}
if (mxal < ALCHAR)
mxal = ALCHAR; /* for bitfields */
SETOFF(csz, mxal); /* Roundup to whatever */
ap = attr_find(p->n_ap, ATTR_STRUCT);
ap->amsize = csz;
ap = attr_find(p->n_ap, ATTR_ALIGNED);
ap->iarg(0) = mxal;
}
/* make a common declaration for id, if reasonable */
void
defzero(struct symtab *sp)
{
int off, al;
char *name;
name = getexname(sp);
off = tsize(sp->stype, sp->sdf, sp->sap);
SETOFF(off,SZCHAR);
off /= SZCHAR;
al = talign(sp->stype, sp->sap)/SZCHAR;
if (sp->sclass == STATIC) {
if (sp->slevel == 0) {
printf("\t.local %s\n", name);
} else
printf("\t.local " LABFMT "\n", sp->soffset);
}
if (sp->slevel == 0) {
printf("\t.comm %s,0%o,%d\n", name, off, al);
} else
printf("\t.comm " LABFMT ",0%o,%d\n", sp->soffset, off, al);
}
NODE *
amd64_builtin_va_arg(NODE *f, NODE *a, TWORD t)
{
NODE *ap, *r, *dp;
ap = a->n_left;
dp = a->n_right;
if (dp->n_type <= ULONGLONG || ISPTR(dp->n_type) ||
dp->n_type == FLOAT || dp->n_type == DOUBLE) {
/* type might be in general register */
if (dp->n_type == FLOAT || dp->n_type == DOUBLE) {
f->n_sp = lookup(fpnext, SNORMAL);
varneeds |= NEED_FPNEXT;
} else {
f->n_sp = lookup(gpnext, SNORMAL);
varneeds |= NEED_GPNEXT;
}
f->n_type = f->n_sp->stype = INCREF(dp->n_type) + (FTN-PTR);
f->n_ap = dp->n_ap;
f->n_df = /* dp->n_df */ NULL;
f = clocal(f);
r = buildtree(CALL, f, ccopy(ap));
} else if (ISSOU(dp->n_type) || dp->n_type == LDOUBLE) {
/* put a reference directly to the stack */
int sz = tsize(dp->n_type, dp->n_df, dp->n_ap);
int al = talign(dp->n_type, dp->n_ap);
if (al < ALLONG)
al = ALLONG;
if (sz <= SZLONG*2 && al == ALLONG) {
if (sz <= SZLONG) {
f->n_sp = lookup(_1regref, SNORMAL);
varneeds |= NEED_1REGREF;
} else {
f->n_sp = lookup(_2regref, SNORMAL);
varneeds |= NEED_2REGREF;
}
f->n_type = f->n_sp->stype;
f = clocal(f);
r = buildtree(CALL, f, ccopy(ap));
r = ccast(r, INCREF(dp->n_type), 0, dp->n_df, dp->n_ap);
r = buildtree(UMUL, r, NIL);
} else {
f->n_sp = lookup(memref, SNORMAL);
varneeds |= NEED_MEMREF;
f->n_type = f->n_sp->stype;
f = clocal(f);
SETOFF(sz, al);
r = buildtree(CALL, f,
buildtree(CM, ccopy(ap), bcon(sz/SZCHAR)));
r = ccast(r, INCREF(dp->n_type), 0, dp->n_df, dp->n_ap);
r = buildtree(UMUL, r, NIL);
}
} else {
uerror("amd64_builtin_va_arg not supported type");
goto bad;
}
tfree(a);
return r;
bad:
uerror("bad argument to __builtin_va_arg");
return bcon(0);
}
/*
* by now, the automatics and register variables are allocated
*/
void
bccode()
{
SETOFF(autooff, SZINT);
}
/*
* 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);
}
void
zzzcode(NODE *p, int c)
{
NODE *l, *r;
TWORD t;
int m;
char *ch;
switch (c) {
case 'N': /* logical ops, turned into 0-1 */
/* use register given by register 1 */
cbgen( 0, m=getlab2());
deflab( p->n_label );
printf( " clrl %s\n", rnames[getlr( p, '1' )->n_rval] );
deflab( m );
return;
case 'A': /* Assign a constant directly to a memory position */
printf("\t");
if (p->n_type < LONG || ISPTR(p->n_type))
casg(p);
else
casg64(p);
printf("\n");
break;
case 'B': /* long long compare */
twollcomp(p);
break;
case 'C': /* num words pushed on arg stack */
printf("$%d", p->n_qual);
break;
case 'D': /* INCR and DECR */
zzzcode(p->n_left, 'A');
printf("\n ");
#if 0
case 'E': /* INCR and DECR, FOREFF */
if (p->n_right->n_lval == 1)
{
printf("%s", (p->n_op == INCR ? "inc" : "dec") );
prtype(p->n_left);
printf(" ");
adrput(stdout, p->n_left);
return;
}
printf("%s", (p->n_op == INCR ? "add" : "sub") );
prtype(p->n_left);
printf("2 ");
adrput(stdout, p->n_right);
printf(",");
adrput(p->n_left);
return;
#endif
case 'F': /* register type of right operand */
{
register NODE *n;
register int ty;
n = getlr( p, 'R' );
ty = n->n_type;
if (x2debug) printf("->%d<-", ty);
if ( ty==DOUBLE) printf("d");
else if ( ty==FLOAT ) printf("f");
else printf("l");
return;
}
case 'G': /* emit conversion instructions */
sconv(p);
break;
case 'J': /* jump or ret? */
{
struct interpass *ip =
DLIST_PREV((struct interpass *)p2env.epp, qelem);
if (ip->type != IP_DEFLAB ||
ip->ip_lbl != getlr(p, 'L')->n_lval)
expand(p, FOREFF, "jbr LL");
else
printf("ret");
}
break;
case 'L': /* type of left operand */
case 'R': /* type of right operand */
{
register NODE *n;
n = getlr ( p, c);
if (x2debug) printf("->%d<-", n->n_type);
prtype(n);
return;
}
case 'O': /* print out emulated ops */
expand(p, FOREFF, "\tmovq AR,-(%sp)\n");
expand(p, FOREFF, "\tmovq AL,-(%sp)\n");
if (p->n_op == DIV && p->n_type == ULONGLONG) ch = "udiv";
else if (p->n_op == DIV) ch = "div";
else if (p->n_op == MOD && p->n_type == ULONGLONG) ch = "umod";
else if (p->n_op == MOD) ch = "mod";
else if (p->n_op == MUL) ch = "mul";
else ch = 0, comperr("ZO %d", p->n_op);
printf("\tcalls $4,__%sdi3\n", ch);
break;
case 'Z': /* complement mask for bit instr */
printf("$%Ld", ~p->n_right->n_lval);
return;
case 'U': /* 32 - n, for unsigned right shifts */
t = DEUNSIGN(p->n_left->n_type);
m = t == CHAR ? 8 : t == SHORT ? 16 : 32;
printf("$" CONFMT, m - p->n_right->n_lval);
return;
case 'T': /* rounded structure length for arguments */
{
int size;
size = p->n_stsize;
SETOFF( size, 4);
printf("$%d", size);
return;
}
case 'S': /* structure assignment */
{
register int size;
size = p->n_stsize;
l = r = NULL; /* XXX gcc */
if( p->n_op == STASG ){
l = p->n_left;
r = p->n_right;
}
else if( p->n_op == STARG ){
/* store an arg into a temporary */
printf("\tsubl2 $%d,%%sp\n",
size < 4 ? 4 : size);
l = mklnode(OREG, 0, SP, INT);
r = p->n_left;
}
else cerror( "STASG bad" );
if( r->n_op == ICON ) r->n_op = NAME;
else if( r->n_op == REG ) r->n_op = OREG;
else if( r->n_op != OREG ) cerror( "STASG-r" );
if (size != 0) {
if( size <= 0 || size > 65535 )
cerror("structure size <0=0 or >65535");
switch(size) {
case 1:
printf(" movb ");
break;
case 2:
printf(" movw ");
break;
case 4:
printf(" movl ");
break;
case 8:
printf(" movq ");
break;
default:
printf(" movc3 $%d,", size);
break;
}
adrput(stdout, r);
printf(",");
adrput(stdout, l);
printf("\n");
}
if( r->n_op == NAME ) r->n_op = ICON;
else if( r->n_op == OREG ) r->n_op = REG;
if (p->n_op == STARG)
tfree(l);
}
break;
default:
comperr("illegal zzzcode '%c'", c);
}
}
/*
* code for the beginning of a function; a is an array of
* indices in symtab for the arguments; n is the number
*
* Classifying args on i386; not simple:
* - Args may be on stack or in registers (regparm)
* - There may be a hidden first arg, unless OpenBSD struct return.
* - Regparm syntax is not well documented.
* - There may be stdcall functions, where the called function pops stack
* - ...probably more
*/
void
bfcode(struct symtab **sp, int cnt)
{
extern int argstacksize;
#ifdef GCC_COMPAT
struct attr *ap;
#endif
struct symtab *sp2;
extern int gotnr;
NODE *n, *p;
int i, regparmarg;
int argbase, nrarg, sz;
argbase = ARGINIT;
nrarg = regparmarg = 0;
#ifdef GCC_COMPAT
if (attr_find(cftnsp->sap, GCC_ATYP_STDCALL) != NULL)
cftnsp->sflags |= SSTDCALL;
if ((ap = attr_find(cftnsp->sap, GCC_ATYP_REGPARM)))
regparmarg = ap->iarg(0);
#endif
/* Function returns struct, create return arg node */
if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
{
if (regparmarg) {
n = block(REG, 0, 0, INT, 0, 0);
regno(n) = regpregs[nrarg++];
} else {
n = block(OREG, 0, 0, INT, 0, 0);
n->n_lval = argbase/SZCHAR;
argbase += SZINT;
regno(n) = FPREG;
}
p = tempnode(0, INT, 0, 0);
structrettemp = regno(p);
p = buildtree(ASSIGN, p, n);
ecomp(p);
}
}
/*
* Find where all params are so that they end up at the right place.
* At the same time recalculate their arg offset on stack.
* We also get the "pop size" for stdcall.
*/
for (i = 0; i < cnt; i++) {
sp2 = sp[i];
sz = tsize(sp2->stype, sp2->sdf, sp2->sap);
SETOFF(sz, SZINT);
if (cisreg(sp2->stype) == 0 ||
((regparmarg - nrarg) * SZINT < sz)) { /* not in reg */
sp2->soffset = argbase;
argbase += sz;
nrarg = regparmarg; /* no more in reg either */
} else { /* in reg */
sp2->soffset = nrarg;
nrarg += sz/SZINT;
sp2->sclass = REGISTER;
}
}
/*
* Now (argbase - ARGINIT) is used space on stack.
* Move (if necessary) the args to something new.
*/
for (i = 0; i < cnt; i++) {
int reg, j;
sp2 = sp[i];
if (ISSOU(sp2->stype) && sp2->sclass == REGISTER) {
/* must move to stack */
sz = tsize(sp2->stype, sp2->sdf, sp2->sap);
SETOFF(sz, SZINT);
SETOFF(autooff, SZINT);
reg = sp2->soffset;
sp2->sclass = AUTO;
sp2->soffset = NOOFFSET;
oalloc(sp2, &autooff);
for (j = 0; j < sz/SZCHAR; j += 4) {
p = block(OREG, 0, 0, INT, 0, 0);
p->n_lval = sp2->soffset/SZCHAR + j;
regno(p) = FPREG;
n = block(REG, 0, 0, INT, 0, 0);
regno(n) = regpregs[reg++];
p = block(ASSIGN, p, n, INT, 0, 0);
ecomp(p);
}
} else if (cisreg(sp2->stype) && !ISSOU(sp2->stype) &&
((cqual(sp2->stype, sp2->squal) & VOL) == 0)) {
/* just put rest in temps */
if (sp2->sclass == REGISTER) {
n = block(REG, 0, 0, sp2->stype,
sp2->sdf, sp2->sap);
if (ISLONGLONG(sp2->stype)|| sp2->stype == LONG || sp2->stype == ULONG)
regno(n) = longregs[sp2->soffset];
else if (DEUNSIGN(sp2->stype) == CHAR || sp2->stype == BOOL)
regno(n) = charregs[sp2->soffset];
else
regno(n) = regpregs[sp2->soffset];
} else {
n = block(OREG, 0, 0, sp2->stype,
sp2->sdf, sp2->sap);
n->n_lval = sp2->soffset/SZCHAR;
regno(n) = FPREG;
}
p = tempnode(0, sp2->stype, sp2->sdf, sp2->sap);
sp2->soffset = regno(p);
sp2->sflags |= STNODE;
n = buildtree(ASSIGN, p, n);
ecomp(n);
}
}
argstacksize = 0;
if (cftnsp->sflags & SSTDCALL) {
argstacksize = (argbase - ARGINIT)/SZCHAR;
}
}
NODE *
dclstruct( oparam ){
register struct symtab *p;
register i, al, sa, j, sz, szindex;
register TWORD temp;
register high, low;
/* paramstack contains:
paramstack[ oparam ] = previous instruct
paramstack[ oparam+1 ] = previous class
paramstk[ oparam+2 ] = previous strucoff
paramstk[ oparam+3 ] = structure name
paramstk[ oparam+4, ... ] = member stab indices
*/
if( (i=paramstk[oparam+3]) < 0 ){
szindex = curdim;
dstash( 0 ); /* size */
dstash( -1 ); /* index to member names */
dstash( ALSTRUCT ); /* alignment */
}
else {
szindex = stab[i].sizoff;
}
if( ddebug ){
printf( "dclstruct( %.8s ), szindex = %d\n", (i>=0)? stab[i].sname : "??", szindex );
}
temp = (instruct&INSTRUCT)?STRTY:((instruct&INUNION)?UNIONTY:ENUMTY);
stwart = instruct = paramstk[ oparam ];
curclass = paramstk[ oparam+1 ];
dimtab[ szindex+1 ] = curdim;
al = ALSTRUCT;
high = low = 0;
for( i = oparam+4; i< paramno; ++i ){
dstash( j=paramstk[i] );
if( j<0 || j>= SYMTSZ ) cerror( "gummy structure member" );
p = &stab[j];
if( temp == ENUMTY ){
if( p->offset < low ) low = p->offset;
if( p->offset > high ) high = p->offset;
p->sizoff = szindex;
continue;
}
sa = talign( p->stype, p->sizoff );
if( p->sclass & FIELD ){
sz = p->sclass&FLDSIZ;
}
else {
sz = tsize( p->stype, p->dimoff, p->sizoff );
}
if( sz == 0 ){
uerror( "illegal zero sized structure member: %.8s", p->sname );
}
if( sz > strucoff ) strucoff = sz; /* for use with unions */
SETOFF( al, sa );
/* set al, the alignment, to the lcm of the alignments of the members */
}
dstash( -1 ); /* endmarker */
SETOFF( strucoff, al );
if( temp == ENUMTY ){
register TWORD ty;
# ifdef ENUMSIZE
ty = ENUMSIZE(high,low);
# else
if( (char)high == high && (char)low == low ) ty = ctype( CHAR );
else if( (short)high == high && (short)low == low ) ty = ctype( SHORT );
else ty = ctype(INT);
#endif
strucoff = tsize( ty, 0, (int)ty );
dimtab[ szindex+2 ] = al = talign( ty, (int)ty );
}
if( strucoff == 0 ) uerror( "zero sized structure" );
dimtab[ szindex ] = strucoff;
dimtab[ szindex+2 ] = al;
if( ddebug>1 ){
printf( "\tdimtab[%d,%d,%d] = %d,%d,%d\n", szindex,szindex+1,szindex+2,
dimtab[szindex],dimtab[szindex+1],dimtab[szindex+2] );
for( i = dimtab[szindex+1]; dimtab[i] >= 0; ++i ){
printf( "\tmember %.8s(%d)\n", stab[dimtab[i]].sname, dimtab[i] );
}
}
strucoff = paramstk[ oparam+2 ];
paramno = oparam;
return( mkty( temp, 0, szindex ) );
}