/*
* Define everything needed to print out some data (or text).
* This means segment, alignment, visibility, etc.
*/
void
defloc(struct symtab *sp)
{
static char *loctbl[] = { "text", "data", "data" };
TWORD t;
char *n;
int s;
if (sp == NULL) {
lastloc = -1;
return;
}
t = sp->stype;
s = ISFTN(t) ? PROG : ISCON(cqual(t, sp->squal)) ? RDATA : DATA;
if (s != lastloc)
printf(" .%s\n", loctbl[s]);
lastloc = s;
while (ISARY(t))
t = DECREF(t);
n = sp->soname ? sp->soname : exname(sp->sname);
if (sp->sclass == EXTDEF)
printf(" .globl %s\n", n);
if (ISFTN(sp->stype) || talign(sp->stype, sp->ssue) > ALCHAR)
printf(".even\n");
if (sp->slevel == 0) {
printf("%s:\n", n);
} else {
printf(LABFMT ":\n", sp->soffset);
}
}
/*
* 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;
}
/*
* Define everything needed to print out some data (or text).
* This means segment, alignment, visibility, etc.
*/
void
defloc(struct symtab *sp)
{
extern char *nextsect;
static int lastloc = -1;
TWORD t;
char *n;
int s;
if (sp == NULL) {
lastloc = -1;
return;
}
t = sp->stype;
s = ISFTN(t) ? PROG : ISCON(cqual(t, sp->squal)) ? RDATA : DATA;
if (nextsect) {
printf("\t.section %s\n", nextsect);
nextsect = NULL;
s = -1;
} else if (s != lastloc)
printf("\t.%s\n", loctbl[s]);
lastloc = s;
while (ISARY(t))
t = DECREF(t);
s = ISFTN(t) ? ALINT : talign(t, sp->ssue);
if (s > ALCHAR)
printf("\t.align\t%d\n", s / ALCHAR);
n = sp->soname ? sp->soname : sp->sname;
if (sp->sclass == EXTDEF)
printf("\t.export %s, %s\n", n,
ISFTN(t)? "code" : "data");
if (sp->slevel == 0)
printf("\t.type\t%s, @%s\n\t.label %s\n",
n, ISFTN(t)? "function" : "object", n);
else
printf("\t.type\t" LABFMT ", @%s\n\t.label\t" LABFMT "\n",
sp->soffset, ISFTN(t)? "function" : "object", sp->soffset);
}
/* 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);
}
/*
* Define everything needed to print out some data (or text).
* This means segment, alignment, visibility, etc.
*/
void
defloc(struct symtab *sp)
{
extern char *nextsect;
static char *loctbl[] = { "text", "data", "section .rodata" };
extern int tbss;
char *name;
TWORD t;
int s;
if (sp == NULL) {
lastloc = -1;
return;
}
if (kflag) {
#ifdef MACHOABI
loctbl[DATA] = "section .data.rel.rw,\"aw\"";
loctbl[RDATA] = "section .data.rel.ro,\"aw\"";
#else
loctbl[DATA] = "section .data.rel.rw,\"aw\",@progbits";
loctbl[RDATA] = "section .data.rel.ro,\"aw\",@progbits";
#endif
}
t = sp->stype;
s = ISFTN(t) ? PROG : ISCON(cqual(t, sp->squal)) ? RDATA : DATA;
if ((name = sp->soname) == NULL)
name = exname(sp->sname);
if (sp->sflags & STLS) {
if (s != DATA)
cerror("non-data symbol in tls section");
if (tbss)
nextsect = ".tbss,\"awT\",@nobits";
else
nextsect = ".tdata,\"awT\",@progbits";
tbss = 0;
lastloc = -1;
}
varattrib(name, sp->sap);
if (nextsect) {
printf(" .section %s\n", nextsect);
nextsect = NULL;
s = -1;
} else if (s != lastloc)
printf(" .%s\n", loctbl[s]);
lastloc = s;
while (ISARY(t))
t = DECREF(t);
s = ISFTN(t) ? ALINT : talign(t, sp->sap);
if (s > ALCHAR)
printf(" .align %d\n", s/ALCHAR);
if (sp->sclass == EXTDEF) {
printf("\t.globl %s\n", name);
#ifndef MACHOABI
printf("\t.type %s,@%s\n", name,
ISFTN(t)? "function" : "object");
#endif
}
if (sp->slevel == 0)
printf("%s:\n", name);
else
printf(LABFMT ":\n", sp->soffset);
}
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);
}
/*
* Define everything needed to print out some data (or text).
* This means segment, alignment, visibility, etc.
*/
void
defloc(struct symtab *sp)
{
extern char *nextsect;
static char *loctbl[] = { "text", "data", "section .rodata" };
extern int tbss;
int weak = 0;
char *name;
TWORD t;
int s;
if (sp == NULL) {
lastloc = -1;
return;
}
if (kflag) {
loctbl[DATA] = "section .data.rel.rw,\"aw\",@progbits";
loctbl[RDATA] = "section .data.rel.ro,\"aw\",@progbits";
}
t = sp->stype;
s = ISFTN(t) ? PROG : ISCON(cqual(t, sp->squal)) ? RDATA : DATA;
if ((name = sp->soname) == NULL)
name = exname(sp->sname);
if (sp->sflags & STLS) {
if (s != DATA)
cerror("non-data symbol in tls section");
if (tbss)
nextsect = ".tbss,\"awT\",@nobits";
else
nextsect = ".tdata,\"awT\",@progbits";
tbss = 0;
lastloc = -1;
}
#ifdef GCC_COMPAT
{
struct attr *ga;
if ((ga = attr_find(sp->sap, GCC_ATYP_SECTION)) != NULL)
nextsect = ga->sarg(0);
if ((ga = attr_find(sp->sap, GCC_ATYP_WEAK)) != NULL)
weak = 1;
if (attr_find(sp->sap, GCC_ATYP_DESTRUCTOR)) {
printf("\t.section\t.dtors,\"aw\",@progbits\n");
printf("\t.align 8\n\t.quad\t%s\n", name);
lastloc = -1;
}
if (attr_find(sp->sap, GCC_ATYP_CONSTRUCTOR)) {
printf("\t.section\t.ctors,\"aw\",@progbits\n");
printf("\t.align 8\n\t.quad\t%s\n", name);
lastloc = -1;
}
if ((ga = attr_find(sp->sap, GCC_ATYP_VISIBILITY)) &&
strcmp(ga->sarg(0), "default"))
printf("\t.%s %s\n", ga->sarg(0), name);
}
#endif
if (nextsect) {
printf(" .section %s\n", nextsect);
nextsect = NULL;
s = -1;
} else if (s != lastloc)
printf(" .%s\n", loctbl[s]);
lastloc = s;
while (ISARY(t))
t = DECREF(t);
s = ISFTN(t) ? ALINT : talign(t, sp->sap);
if (s > ALCHAR)
printf(" .align %d\n", s/ALCHAR);
if (weak)
printf(" .weak %s\n", name);
else if (sp->sclass == EXTDEF) {
printf("\t.globl %s\n", name);
printf("\t.type %s,@%s\n", name,
ISFTN(t)? "function" : "object");
}
if (sp->slevel == 0)
printf("%s:\n", name);
else
printf(LABFMT ":\n", sp->soffset);
}
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 ) );
}
