unsigned AggregateDeclaration::size(Loc loc)
{
//printf("AggregateDeclaration::size() %s, scope = %p\n", toChars(), scope);
if (loc.linnum == 0)
loc = this->loc;
if (sizeok != SIZEOKdone && scope)
semantic(NULL);
StructDeclaration *sd = isStructDeclaration();
if (sizeok != SIZEOKdone && sd && sd->members)
{
/* See if enough is done to determine the size,
* meaning all the fields are done.
*/
struct SV
{
/* Returns:
* 0 this member doesn't need further processing to determine struct size
* 1 this member does
*/
static int func(Dsymbol *s, void *param)
{
VarDeclaration *v = s->isVarDeclaration();
if (v)
{
if (v->scope)
v->semantic(NULL);
if (v->storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCctfe | STCtemplateparameter))
return 0;
if (v->isField() && v->sem >= SemanticDone)
return 0;
return 1;
}
return 0;
}
};
SV sv;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
if (s->apply(&SV::func, &sv))
goto L1;
}
sd->finalizeSize(NULL);
L1: ;
}
if (!members)
{
error(loc, "unknown size");
}
else if (sizeok != SIZEOKdone)
{
error(loc, "no size yet for forward reference");
//*(char*)0=0;
}
return structsize;
}
int Nspace::apply(Dsymbol_apply_ft_t fp, void *param)
{
if (members)
{
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
if (s)
{
if (s->apply(fp, param))
return 1;
}
}
}
return 0;
}
int AttribDeclaration::apply(Dsymbol_apply_ft_t fp, void *param)
{
Dsymbols *d = include(scope, NULL);
if (d)
{
for (size_t i = 0; i < d->dim; i++)
{ Dsymbol *s = (*d)[i];
if (s)
{
if (s->apply(fp, param))
return 1;
}
}
}
return 0;
}
void ClassDeclaration::toDebug()
{
idx_t typidx = 0;
//printf("ClassDeclaration::toDebug('%s')\n", toChars());
assert(config.fulltypes >= CV4);
if (isAnonymous())
return /*0*/;
if (typidx) // if reference already generated
return /*typidx*/; // use already existing reference
targ_size_t size;
unsigned property = 0;
if (!members)
{ size = 0;
property |= 0x80; // forward reference
}
else
size = structsize;
if (parent->isAggregateDeclaration()) // if class is nested
property |= 8;
if (ctor || dtors.dim)
property |= 2; // class has ctors and/or dtors
// if (st->Sopoverload)
// property |= 4; // class has overloaded operators
// if (st->Scastoverload)
// property |= 0x40; // class has casting methods
// if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug))
// property |= 0x20; // class has overloaded assignment
#if DMDV1
const char *id = toPrettyChars();
#else
const char *id = isCPPinterface() ? ident->toChars() : toPrettyChars();
#endif
unsigned leaf = config.fulltypes == CV8 ? LF_CLASS_V3 : LF_CLASS;
unsigned numidx = (leaf == LF_CLASS_V3) ? 18 : 12;
unsigned len = numidx + cv4_numericbytes(size);
debtyp_t *d = debtyp_alloc(len + cv_stringbytes(id));
cv4_storenumeric(d->data + numidx,size);
len += cv_namestring(d->data + len,id);
idx_t vshapeidx = 0;
if (1)
{
size_t n = vtbl.dim; // number of virtual functions
if (n)
{ // 4 bits per descriptor
debtyp_t *vshape = debtyp_alloc(4 + (n + 1) / 2);
TOWORD(vshape->data,LF_VTSHAPE);
TOWORD(vshape->data + 2,n);
n = 0;
unsigned char descriptor = 0;
for (size_t i = 0; i < vtbl.dim; i++)
{ FuncDeclaration *fd = (FuncDeclaration *)vtbl[i];
//if (intsize == 4)
descriptor |= 5;
vshape->data[4 + n / 2] = descriptor;
descriptor <<= 4;
n++;
}
vshapeidx = cv_debtyp(vshape);
}
}
if (leaf == LF_CLASS)
{
TOWORD(d->data + 8,0); // dList
TOWORD(d->data + 10,vshapeidx);
}
else if (leaf == LF_CLASS_V3)
{
TOLONG(d->data + 10,0); // dList
TOLONG(d->data + 14,vshapeidx);
}
TOWORD(d->data,leaf);
// Assign a number to prevent infinite recursion if a struct member
// references the same struct.
unsigned length_save = d->length;
d->length = 0; // so cv_debtyp() will allocate new
typidx = cv_debtyp(d);
d->length = length_save; // restore length
if (!members) // if reference only
{
if (leaf == LF_CLASS_V3)
{
TOWORD(d->data + 2,0); // count: number of fields is 0
TOLONG(d->data + 6,0); // field list is 0
TOWORD(d->data + 4,property);
}
else
{
TOWORD(d->data + 2,0); // count: number of fields is 0
TOWORD(d->data + 4,0); // field list is 0
TOWORD(d->data + 6,property);
}
return /*typidx*/;
}
// Compute the number of fields (nfields), and the length of the fieldlist record (fnamelen)
CvMemberCount mc;
mc.nfields = 0;
mc.fnamelen = 2;
/* Adding in the base classes causes VS 2010 debugger to refuse to display any
* of the fields. I have not been able to determine why.
* (Could it be because the base class is "forward referenced"?)
* It does work with VS 2012.
*/
bool addInBaseClasses = true;
if (addInBaseClasses)
{
// Add in base classes
for (size_t i = 0; i < baseclasses->dim; i++)
{ BaseClass *bc = (*baseclasses)[i];
mc.nfields++;
unsigned elementlen = 4 + cgcv.sz_idx + cv4_numericbytes(bc->offset);
elementlen = cv_align(NULL, elementlen);
mc.fnamelen += elementlen;
}
}
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_count, &mc);
}
unsigned nfields = mc.nfields;
unsigned fnamelen = mc.fnamelen;
int count = nfields;
TOWORD(d->data + 2,count);
// Generate fieldlist type record
debtyp_t *dt = debtyp_alloc(fnamelen);
unsigned char *p = dt->data;
// And fill it in
TOWORD(p,config.fulltypes == CV8 ? LF_FIELDLIST_V2 : LF_FIELDLIST);
p += 2;
if (addInBaseClasses)
{
// Add in base classes
for (size_t i = 0; i < baseclasses->dim; i++)
{ BaseClass *bc = (*baseclasses)[i];
idx_t typidx = cv4_typidx(bc->base->type->toCtype()->Tnext);
unsigned attribute = PROTtoATTR(bc->protection);
unsigned elementlen;
switch (config.fulltypes)
{
case CV8:
TOWORD(p, LF_BCLASS_V2);
TOWORD(p + 2,attribute);
TOLONG(p + 4,typidx);
elementlen = 8;
break;
case CV4:
TOWORD(p, LF_BCLASS);
TOWORD(p + 2,typidx);
TOWORD(p + 4,attribute);
elementlen = 6;
break;
}
cv4_storenumeric(p + elementlen, bc->offset);
elementlen += cv4_numericbytes(bc->offset);
elementlen = cv_align(p + elementlen, elementlen);
p += elementlen;
}
}
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_p, &p);
}
//dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data);
assert(p - dt->data == fnamelen);
idx_t fieldlist = cv_debtyp(dt);
TOWORD(d->data + 2,count);
if (config.fulltypes == CV8)
{
TOWORD(d->data + 4,property);
TOLONG(d->data + 6,fieldlist);
}
else
{
TOWORD(d->data + 4,fieldlist);
TOWORD(d->data + 6,property);
}
// cv4_outsym(s);
if (config.fulltypes == CV8)
cv8_udt(id, typidx);
else
{
size_t idlen = strlen(id);
unsigned char *debsym = (unsigned char *) alloca(39 + IDOHD + idlen);
// Output a 'user-defined type' for the tag name
TOWORD(debsym + 2,S_UDT);
TOIDX(debsym + 4,typidx);
unsigned length = 2 + 2 + cgcv.sz_idx;
length += cv_namestring(debsym + length,id);
TOWORD(debsym,length - 2);
assert(length <= 40 + idlen);
objmod->write_bytes(SegData[DEBSYM],length,debsym);
}
// return typidx;
}
void StructDeclaration::toDebug()
{
idx_t typidx = 0;
//printf("StructDeclaration::toDebug('%s')\n", toChars());
assert(config.fulltypes >= CV4);
if (isAnonymous())
return /*0*/;
if (typidx) // if reference already generated
return /*typidx*/; // use already existing reference
targ_size_t size;
unsigned property = 0;
if (!members)
{ size = 0;
property |= 0x80; // forward reference
}
else
size = structsize;
if (parent->isAggregateDeclaration()) // if class is nested
property |= 8;
// if (st->Sctor || st->Sdtor)
// property |= 2; // class has ctors and/or dtors
// if (st->Sopoverload)
// property |= 4; // class has overloaded operators
// if (st->Scastoverload)
// property |= 0x40; // class has casting methods
// if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug))
// property |= 0x20; // class has overloaded assignment
const char *id = toPrettyChars();
unsigned leaf = isUnionDeclaration() ? LF_UNION : LF_STRUCTURE;
if (config.fulltypes == CV8)
leaf = leaf == LF_UNION ? LF_UNION_V3 : LF_STRUCTURE_V3;
unsigned numidx;
switch (leaf)
{
case LF_UNION: numidx = 8; break;
case LF_UNION_V3: numidx = 10; break;
case LF_STRUCTURE: numidx = 12; break;
case LF_STRUCTURE_V3: numidx = 18; break;
}
unsigned len = numidx + cv4_numericbytes(size);
debtyp_t *d = debtyp_alloc(len + cv_stringbytes(id));
cv4_storenumeric(d->data + numidx,size);
len += cv_namestring(d->data + len,id);
if (leaf == LF_STRUCTURE)
{
TOWORD(d->data + 8,0); // dList
TOWORD(d->data + 10,0); // vshape is 0 (no virtual functions)
}
else if (leaf == LF_STRUCTURE_V3)
{
TOLONG(d->data + 10,0); // dList
TOLONG(d->data + 14,0); // vshape is 0 (no virtual functions)
}
TOWORD(d->data,leaf);
// Assign a number to prevent infinite recursion if a struct member
// references the same struct.
unsigned length_save = d->length;
d->length = 0; // so cv_debtyp() will allocate new
typidx = cv_debtyp(d);
d->length = length_save; // restore length
if (!members) // if reference only
{
if (config.fulltypes == CV8)
{
TOWORD(d->data + 2,0); // count: number of fields is 0
TOLONG(d->data + 6,0); // field list is 0
TOWORD(d->data + 4,property);
}
else
{
TOWORD(d->data + 2,0); // count: number of fields is 0
TOWORD(d->data + 4,0); // field list is 0
TOWORD(d->data + 6,property);
}
return /*typidx*/;
}
// Compute the number of fields (nfields), and the length of the fieldlist record (fnamelen)
CvMemberCount mc;
mc.nfields = 0;
mc.fnamelen = 2;
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_count, &mc);
}
unsigned nfields = mc.nfields;
unsigned fnamelen = mc.fnamelen;
int count = nfields; // COUNT field in LF_CLASS
// Generate fieldlist type record
debtyp_t *dt = debtyp_alloc(fnamelen);
unsigned char *p = dt->data;
// And fill it in
TOWORD(p,config.fulltypes == CV8 ? LF_FIELDLIST_V2 : LF_FIELDLIST);
p += 2;
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_p, &p);
}
//dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data);
assert(p - dt->data == fnamelen);
idx_t fieldlist = cv_debtyp(dt);
TOWORD(d->data + 2,count);
if (config.fulltypes == CV8)
{
TOWORD(d->data + 4,property);
TOLONG(d->data + 6,fieldlist);
}
else
{
TOWORD(d->data + 4,fieldlist);
TOWORD(d->data + 6,property);
}
// cv4_outsym(s);
if (config.fulltypes == CV8)
cv8_udt(id, typidx);
else
{
size_t idlen = strlen(id);
unsigned char *debsym = (unsigned char *) alloca(39 + IDOHD + idlen);
// Output a 'user-defined type' for the tag name
TOWORD(debsym + 2,S_UDT);
TOIDX(debsym + 4,typidx);
unsigned length = 2 + 2 + cgcv.sz_idx;
length += cv_namestring(debsym + length,id);
TOWORD(debsym,length - 2);
assert(length <= 40 + idlen);
objmod->write_bytes(SegData[DEBSYM],length,debsym);
}
// return typidx;
}
void ClassDeclaration::toDebug()
{
unsigned leaf;
unsigned property;
unsigned nfields;
unsigned fnamelen;
const char *id;
targ_size_t size;
unsigned numidx;
debtyp_t *d,*dt;
unsigned len;
int i;
int count; // COUNT field in LF_CLASS
unsigned char *p;
idx_t typidx = 0;
//printf("ClassDeclaration::toDebug('%s')\n", toChars());
assert(config.fulltypes >= CV4);
if (isAnonymous())
return /*0*/;
if (typidx) // if reference already generated
return /*typidx*/; // use already existing reference
property = 0;
if (!members)
{ size = 0;
property |= 0x80; // forward reference
}
else
size = structsize;
if (parent->isAggregateDeclaration()) // if class is nested
property |= 8;
if (ctor || dtors.dim)
property |= 2; // class has ctors and/or dtors
// if (st->Sopoverload)
// property |= 4; // class has overloaded operators
// if (st->Scastoverload)
// property |= 0x40; // class has casting methods
// if (st->Sopeq && !(st->Sopeq->Sfunc->Fflags & Fnodebug))
// property |= 0x20; // class has overloaded assignment
id = isCPPinterface() ? ident->toChars() : toPrettyChars();
numidx = isUnionDeclaration() ? 8 : 12;
len = numidx + cv4_numericbytes(size);
d = debtyp_alloc(len + cv_stringbytes(id));
cv4_storenumeric(d->data + numidx,size);
len += cv_namestring(d->data + len,id);
leaf = LF_CLASS;
TOWORD(d->data + 8,0); // dList
if (1)
{ debtyp_t *vshape;
unsigned char descriptor;
size_t n = vtbl.dim; // number of virtual functions
if (n == 0)
{
TOWORD(d->data + 10,0); // vshape is 0
}
else
{
vshape = debtyp_alloc(4 + (n + 1) / 2);
TOWORD(vshape->data,LF_VTSHAPE);
TOWORD(vshape->data + 2,1);
n = 0;
descriptor = 0;
for (size_t i = 0; i < vtbl.dim; i++)
{ FuncDeclaration *fd = (FuncDeclaration *)vtbl[i];
//if (intsize == 4)
descriptor |= 5;
vshape->data[4 + n / 2] = descriptor;
descriptor <<= 4;
n++;
}
TOWORD(d->data + 10,cv_debtyp(vshape)); // vshape
}
}
else
TOWORD(d->data + 10,0); // vshape is 0 (no virtual functions)
TOWORD(d->data,leaf);
// Assign a number to prevent infinite recursion if a struct member
// references the same struct.
d->length = 0; // so cv_debtyp() will allocate new
typidx = cv_debtyp(d);
d->length = len; // restore length
if (!members) // if reference only
{
TOWORD(d->data + 2,0); // count: number of fields is 0
TOWORD(d->data + 4,0); // field list is 0
TOWORD(d->data + 6,property);
return /*typidx*/;
}
// Compute the number of fields (nfields), and the length of the fieldlist record (fnamelen)
CvMemberCount mc;
mc.nfields = 0;
mc.fnamelen = 2;
// Add in base classes
for (size_t i = 0; i < baseclasses->dim; i++)
{ BaseClass *bc = (*baseclasses)[i];
mc.nfields++;
mc.fnamelen += 6 + cv4_numericbytes(bc->offset);
}
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_count, &mc);
}
nfields = mc.nfields;
fnamelen = mc.fnamelen;
count = nfields;
TOWORD(d->data + 2,count);
TOWORD(d->data + 6,property);
// Generate fieldlist type record
dt = debtyp_alloc(fnamelen);
p = dt->data;
// And fill it in
TOWORD(p,LF_FIELDLIST);
p += 2;
// Add in base classes
for (size_t i = 0; i < baseclasses->dim; i++)
{ BaseClass *bc = (*baseclasses)[i];
idx_t typidx;
unsigned attribute;
typidx = cv4_typidx(bc->base->type->toCtype()->Tnext);
attribute = PROTtoATTR(bc->protection);
TOWORD(p,LF_BCLASS);
TOWORD(p + 2,typidx);
TOWORD(p + 4,attribute);
p += 6;
cv4_storenumeric(p, bc->offset);
p += cv4_numericbytes(bc->offset);
}
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->apply(&cv_mem_p, &p);
}
//dbg_printf("fnamelen = %d, p-dt->data = %d\n",fnamelen,p-dt->data);
assert(p - dt->data == fnamelen);
TOWORD(d->data + 4,cv_debtyp(dt));
// cv4_outsym(s);
unsigned char *debsym;
unsigned length;
len = strlen(id);
debsym = (unsigned char *) alloca(39 + IDOHD + len);
// Output a 'user-defined type' for the tag name
TOWORD(debsym + 2,S_UDT);
TOIDX(debsym + 4,typidx);
length = 2 + 2 + cgcv.sz_idx;
length += cv_namestring(debsym + length,id);
TOWORD(debsym,length - 2);
assert(length <= 40 + len);
obj_write_bytes(SegData[DEBSYM],length,debsym);
// return typidx;
}
void StructDeclaration::finalizeSize(Scope *sc)
{
//printf("StructDeclaration::finalizeSize() %s\n", toChars());
if (sizeok != SIZEOKnone)
return;
// Set the offsets of the fields and determine the size of the struct
unsigned offset = 0;
bool isunion = isUnionDeclaration() != NULL;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->setFieldOffset(this, &offset, isunion);
}
if (sizeok == SIZEOKfwd)
return;
// 0 sized struct's are set to 1 byte
if (structsize == 0)
{
structsize = 1;
alignsize = 1;
}
// Round struct size up to next alignsize boundary.
// This will ensure that arrays of structs will get their internals
// aligned properly.
if (alignment == STRUCTALIGN_DEFAULT)
structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
else
structsize = (structsize + alignment - 1) & ~(alignment - 1);
sizeok = SIZEOKdone;
// Calculate fields[i]->overlapped
fill(loc, NULL, true);
// Determine if struct is all zeros or not
zeroInit = 1;
for (size_t i = 0; i < fields.dim; i++)
{
VarDeclaration *vd = fields[i];
if (!vd->isDataseg())
{
if (vd->init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else
{
if (!vd->type->isZeroInit(loc))
{
zeroInit = 0;
break;
}
}
}
}
// Look for the constructor, for the struct literal/constructor call expression
ctor = searchCtor();
if (ctor)
{
// Finish all constructors semantics to determine this->noDefaultCtor.
struct SearchCtor
{
static int fp(Dsymbol *s, void *ctxt)
{
CtorDeclaration *f = s->isCtorDeclaration();
if (f && f->semanticRun == PASSinit)
f->semantic(NULL);
return 0;
}
};
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->apply(&SearchCtor::fp, NULL);
}
}
}
unsigned AggregateDeclaration::size(Loc loc)
{
//printf("AggregateDeclaration::size() %s, scope = %p\n", toChars(), scope);
if (loc.linnum == 0)
loc = this->loc;
if (sizeok != SIZEOKdone && scope)
{
semantic(NULL);
// Determine the instance size of base class first.
if (ClassDeclaration *cd = isClassDeclaration())
cd->baseClass->size(loc);
}
if (sizeok != SIZEOKdone && members)
{
/* See if enough is done to determine the size,
* meaning all the fields are done.
*/
struct SV
{
/* Returns:
* 0 this member doesn't need further processing to determine struct size
* 1 this member does
*/
static int func(Dsymbol *s, void *param)
{
VarDeclaration *v = s->isVarDeclaration();
if (v)
{
/* Bugzilla 12799: enum a = ...; is a VarDeclaration and
* STCmanifest is already set in parssing stage. So we can
* check this before the semantic() call.
*/
if (v->storage_class & STCmanifest)
return 0;
if (v->scope)
v->semantic(NULL);
if (v->storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCctfe | STCtemplateparameter))
return 0;
if (v->isField() && v->sem >= SemanticDone)
return 0;
return 1;
}
return 0;
}
};
SV sv;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
if (s->apply(&SV::func, &sv))
goto L1;
}
finalizeSize(NULL);
L1: ;
}
if (!members)
{
error(loc, "unknown size");
}
else if (sizeok != SIZEOKdone)
{
error(loc, "no size yet for forward reference");
//*(char*)0=0;
}
return structsize;
}
