void EnumDeclaration::toDebug()
{
//printf("EnumDeclaration::toDebug('%s')\n", toChars());
assert(config.fulltypes >= CV4);
// If it is a member, it is handled by cvMember()
if (!isMember())
{
const char *id = toPrettyChars();
idx_t typidx = cv4_Denum(this);
if (config.fulltypes == CV8)
cv8_udt(id, typidx);
else
{
unsigned len = strlen(id);
unsigned char *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);
unsigned length = 2 + 2 + cgcv.sz_idx;
length += cv_namestring(debsym + length,id);
TOWORD(debsym,length - 2);
assert(length <= 40 + len);
objmod->write_bytes(SegData[DEBSYM],length,debsym);
}
}
}
/****************************************
* Return type index for a darray of type E[]
* Input:
* t darray type
* etypidx type index for E
*/
idx_t cv8_darray(type *t, idx_t etypidx)
{
//printf("cv8_darray(etypidx = %x)\n", etypidx);
/* Put out a struct:
* struct dArray {
* size_t length;
* E* ptr;
* }
*/
#if 0
d = debtyp_alloc(18);
TOWORD(d->data, 0x100F);
TOWORD(d->data + 2, OEM);
TOWORD(d->data + 4, 1); // 1 = dynamic array
TOLONG(d->data + 6, 2); // count of type indices to follow
TOLONG(d->data + 10, 0x23); // index type, T_UQUAD
TOLONG(d->data + 14, next); // element type
return cv_debtyp(d);
#endif
type *tp = type_pointer(t->Tnext);
idx_t ptridx = cv4_typidx(tp);
type_free(tp);
static const unsigned char fl[] =
{
0x03, 0x12, // LF_FIELDLIST_V2
0x0d, 0x15, // LF_MEMBER_V3
0x03, 0x00, // attribute
0x23, 0x00, 0x00, 0x00, // size_t
0x00, 0x00, // offset
'l', 'e', 'n', 'g', 't', 'h', 0x00,
0xf3, 0xf2, 0xf1, // align to 4-byte including length word before data
0x0d, 0x15,
0x03, 0x00,
0x00, 0x00, 0x00, 0x00, // etypidx
0x08, 0x00,
'p', 't', 'r', 0x00,
0xf2, 0xf1,
};
debtyp_t *f = debtyp_alloc(sizeof(fl));
memcpy(f->data,fl,sizeof(fl));
TOLONG(f->data + 6, I64 ? 0x23 : 0x22); // size_t
TOLONG(f->data + 26, ptridx);
TOWORD(f->data + 30, NPTRSIZE);
idx_t fieldlist = cv_debtyp(f);
const char *id;
switch (t->Tnext->Tty)
{
case mTYimmutable | TYchar:
id = "string";
break;
case mTYimmutable | TYwchar_t:
id = "wstring";
break;
case mTYimmutable | TYdchar:
id = "dstring";
break;
default:
id = t->Tident ? t->Tident : "dArray";
break;
}
int idlen = strlen(id);
if (idlen > CV8_MAX_SYMBOL_LENGTH)
idlen = CV8_MAX_SYMBOL_LENGTH;
debtyp_t *d = debtyp_alloc(20 + idlen + 1);
TOWORD(d->data, LF_STRUCTURE_V3);
TOWORD(d->data + 2, 2); // count
TOWORD(d->data + 4, 0); // property
TOLONG(d->data + 6, fieldlist);
TOLONG(d->data + 10, 0); // dList
TOLONG(d->data + 14, 0); // vtshape
TOWORD(d->data + 18, 2 * NPTRSIZE); // size
cv_namestring(d->data + 20, id, idlen);
d->data[20 + idlen] = 0;
idx_t top = cv_numdebtypes();
idx_t debidx = cv_debtyp(d);
if(top != cv_numdebtypes())
cv8_udt(id, debidx);
return debidx;
}
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;
}
