void RedundantVoidArgCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(functionDecl(parameterCountIs(0), unless(isImplicit()),
unless(isInstantiated()), unless(isExternC()))
.bind(FunctionId),
this);
Finder->addMatcher(typedefNameDecl().bind(TypedefId), this);
auto ParenFunctionType = parenType(innerType(functionType()));
auto PointerToFunctionType = pointee(ParenFunctionType);
auto FunctionOrMemberPointer =
anyOf(hasType(pointerType(PointerToFunctionType)),
hasType(memberPointerType(PointerToFunctionType)));
Finder->addMatcher(fieldDecl(FunctionOrMemberPointer).bind(FieldId), this);
Finder->addMatcher(varDecl(FunctionOrMemberPointer).bind(VarId), this);
auto CastDestinationIsFunction =
hasDestinationType(pointsTo(ParenFunctionType));
Finder->addMatcher(
cStyleCastExpr(CastDestinationIsFunction).bind(CStyleCastId), this);
Finder->addMatcher(
cxxStaticCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);
Finder->addMatcher(
cxxReinterpretCastExpr(CastDestinationIsFunction).bind(NamedCastId),
this);
Finder->addMatcher(
cxxConstCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);
Finder->addMatcher(lambdaExpr().bind(LambdaId), this);
}
void TypedefDeclaration::toObjFile(int multiobj)
{
//printf("TypedefDeclaration::toObjFile('%s')\n", toChars());
if (type->ty == Terror)
{ error("had semantic errors when compiling");
return;
}
if (global.params.symdebug)
toDebug(this);
type->genTypeInfo(NULL);
TypeTypedef *tc = (TypeTypedef *)type;
if (type->isZeroInit() || !tc->sym->init)
;
else
{
enum_SC scclass = SCglobal;
if (isInstantiated())
scclass = SCcomdat;
// Generate static initializer
toInitializer();
sinit->Sclass = scclass;
sinit->Sfl = FLdata;
sinit->Sdt = Initializer_toDt(tc->sym->init);
out_readonly(sinit);
outdata(sinit);
}
}
void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (getLangOpts().CPlusPlus)
Finder->addMatcher(
cxxConstructorDecl(unless(isInstantiated())).bind("ctor"), this);
}
Module *Dsymbol::getAccessModule()
{
//printf("Dsymbol::getAccessModule()\n");
if (TemplateInstance *ti = isInstantiated())
return ti->tempdecl->getAccessModule();
Dsymbol *s = this;
while (s)
{
//printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars());
Module *m = s->isModule();
if (m)
return m;
TemplateInstance *ti = s->isTemplateInstance();
if (ti && ti->enclosing)
{
/* Because of local template instantiation, the parent isn't where the access
* rights come from - it's the template declaration
*/
s = ti->tempdecl;
}
else
s = s->parent;
}
return NULL;
}
void StructDeclaration::toObjFile(int multiobj)
{
//printf("StructDeclaration::toObjFile('%s')\n", toChars());
if (type->ty == Terror)
{ error("had semantic errors when compiling");
return;
}
if (multiobj && !hasStaticCtorOrDtor())
{ obj_append(this);
return;
}
// Anonymous structs/unions only exist as part of others,
// do not output forward referenced structs's
if (!isAnonymous() && members)
{
if (global.params.symdebug)
toDebug(this);
type->genTypeInfo(NULL);
if (1)
{
// Generate static initializer
toInitializer();
if (isInstantiated())
{
sinit->Sclass = SCcomdat;
}
else
{
sinit->Sclass = SCglobal;
}
sinit->Sfl = FLdata;
StructDeclaration_toDt(this, &sinit->Sdt);
dt_optimize(sinit->Sdt);
out_readonly(sinit); // put in read-only segment
outdata(sinit);
}
// Put out the members
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *member = (*members)[i];
/* There might be static ctors in the members, and they cannot
* be put in separate obj files.
*/
member->toObjFile(multiobj);
}
if (xeq && xeq != xerreq)
xeq->toObjFile(multiobj);
if (xcmp && xcmp != xerrcmp)
xcmp->toObjFile(multiobj);
}
}
void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
cxxConstructorDecl(unless(anyOf(isImplicit(), // Compiler-generated.
isDeleted(), isInstantiated())))
.bind("ctor"),
this);
Finder->addMatcher(
cxxConversionDecl(unless(anyOf(isExplicit(), // Already marked explicit.
isImplicit(), // Compiler-generated.
isDeleted(), isInstantiated())))
.bind("conversion"),
this);
}
void NonConstReferences::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
parmVarDecl(
unless(isInstantiated()),
hasType(references(
qualType(unless(isConstQualified())).bind("referenced_type"))),
unless(hasType(rValueReferenceType())))
.bind("param"),
this);
}
void StringReferenceMemberCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) {
// Look for const references to std::string or ::string.
auto String = anyOf(recordDecl(hasName("::std::basic_string")),
recordDecl(hasName("::string")));
auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
// Ignore members in template instantiations.
Finder->addMatcher(fieldDecl(hasType(references(ConstString)),
unless(isInstantiated())).bind("member"),
this);
}
void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
const auto ExpensiveValueParamDecl =
parmVarDecl(hasType(hasCanonicalType(allOf(matchers::isExpensiveToCopy(),
unless(referenceType())))),
decl().bind("param"));
Finder->addMatcher(
functionDecl(isDefinition(), unless(cxxMethodDecl(isOverride())),
unless(isInstantiated()),
has(typeLoc(forEach(ExpensiveValueParamDecl))),
decl().bind("functionDecl")),
this);
}
void FunctionSizeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
functionDecl(
unless(isInstantiated()),
forEachDescendant(
stmt(unless(compoundStmt()),
hasParent(stmt(anyOf(compoundStmt(), ifStmt(),
anyOf(whileStmt(), doStmt(),
forRangeStmt(), forStmt())))))
.bind("stmt"))).bind("func"),
this);
}
Module *Dsymbol::getModule()
{
//printf("Dsymbol::getModule()\n");
if (TemplateInstance *ti = isInstantiated())
return ti->tempdecl->getModule();
Dsymbol *s = this;
while (s)
{
//printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars());
Module *m = s->isModule();
if (m)
return m;
s = s->parent;
}
return NULL;
}
void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
// Add parameters to Parameters.
Finder->addMatcher(parmVarDecl(unless(isInstantiated())).bind("Parm"), this);
// C++ constructor.
Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this);
// Track unused parameters, there is Wunused-parameter about unused
// parameters.
Finder->addMatcher(declRefExpr().bind("Ref"), this);
// Analyse parameter usage in function.
Finder->addMatcher(stmt(anyOf(unaryOperator(anyOf(hasOperatorName("++"),
hasOperatorName("--"))),
binaryOperator(), callExpr(), returnStmt(),
cxxConstructExpr()))
.bind("Mark"),
this);
Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this);
}
void EnumDeclaration::toObjFile(int multiobj)
{
if (semanticRun >= PASSobj) // already written
return;
//printf("EnumDeclaration::toObjFile('%s')\n", toChars());
if (errors || type->ty == Terror)
{ error("had semantic errors when compiling");
return;
}
if (isAnonymous())
return;
if (global.params.symdebug)
toDebug(this);
type->genTypeInfo(NULL);
TypeEnum *tc = (TypeEnum *)type;
if (!tc->sym->members || type->isZeroInit())
;
else
{
enum_SC scclass = SCglobal;
if (isInstantiated())
scclass = SCcomdat;
// Generate static initializer
toInitializer();
sinit->Sclass = scclass;
sinit->Sfl = FLdata;
tc->sym->defaultval->toDt(&sinit->Sdt);
outdata(sinit);
}
semanticRun = PASSobj;
}
void ClassDeclaration::toObjFile(int multiobj)
{
unsigned offset;
Symbol *sinit;
enum_SC scclass;
//printf("ClassDeclaration::toObjFile('%s')\n", toChars());
if (type->ty == Terror)
{ error("had semantic errors when compiling");
return;
}
if (!members)
return;
if (multiobj && !hasStaticCtorOrDtor())
{ obj_append(this);
return;
}
if (global.params.symdebug)
toDebug(this);
assert(!scope); // semantic() should have been run to completion
scclass = SCglobal;
if (isInstantiated())
scclass = SCcomdat;
// Put out the members
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *member = (*members)[i];
/* There might be static ctors in the members, and they cannot
* be put in separate obj files.
*/
member->toObjFile(multiobj);
}
// Generate C symbols
toSymbol(this);
toVtblSymbol();
sinit = toInitializer();
//////////////////////////////////////////////
// Generate static initializer
sinit->Sclass = scclass;
sinit->Sfl = FLdata;
ClassDeclaration_toDt(this, &sinit->Sdt);
out_readonly(sinit);
outdata(sinit);
//////////////////////////////////////////////
// Put out the TypeInfo
type->genTypeInfo(NULL);
//type->vtinfo->toObjFile(multiobj);
//////////////////////////////////////////////
// Put out the ClassInfo
csym->Sclass = scclass;
csym->Sfl = FLdata;
/* The layout is:
{
void **vptr;
monitor_t monitor;
byte[] initializer; // static initialization data
char[] name; // class name
void *[] vtbl;
Interface[] interfaces;
ClassInfo *base; // base class
void *destructor;
void *invariant; // class invariant
ClassFlags flags;
void *deallocator;
OffsetTypeInfo[] offTi;
void *defaultConstructor;
//const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function
void *xgetRTInfo;
//TypeInfo typeinfo;
}
*/
dt_t *dt = NULL;
unsigned classinfo_size = global.params.isLP64 ? CLASSINFO_SIZE_64 : CLASSINFO_SIZE; // must be ClassInfo.size
offset = classinfo_size;
if (Type::typeinfoclass)
{
if (Type::typeinfoclass->structsize != classinfo_size)
{
#ifdef DEBUG
printf("CLASSINFO_SIZE = x%x, Type::typeinfoclass->structsize = x%x\n", offset, Type::typeinfoclass->structsize);
#endif
error("mismatch between dmd and object.d or object.di found. Check installation and import paths with -v compiler switch.");
fatal();
}
}
if (Type::typeinfoclass)
dtxoff(&dt, Type::typeinfoclass->toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo
else
dtsize_t(&dt, 0); // BUG: should be an assert()
dtsize_t(&dt, 0); // monitor
// initializer[]
assert(structsize >= 8 || (cpp && structsize >= 4));
dtsize_t(&dt, structsize); // size
dtxoff(&dt, sinit, 0, TYnptr); // initializer
// name[]
const char *name = ident->toChars();
size_t namelen = strlen(name);
if (!(namelen > 9 && memcmp(name, "TypeInfo_", 9) == 0))
{ name = toPrettyChars();
namelen = strlen(name);
}
dtsize_t(&dt, namelen);
dtabytes(&dt, TYnptr, 0, namelen + 1, name);
// vtbl[]
dtsize_t(&dt, vtbl.dim);
dtxoff(&dt, vtblsym, 0, TYnptr);
// interfaces[]
dtsize_t(&dt, vtblInterfaces->dim);
if (vtblInterfaces->dim)
dtxoff(&dt, csym, offset, TYnptr); // (*)
else
dtsize_t(&dt, 0);
// base
if (baseClass)
dtxoff(&dt, toSymbol(baseClass), 0, TYnptr);
else
dtsize_t(&dt, 0);
// destructor
if (dtor)
dtxoff(&dt, toSymbol(dtor), 0, TYnptr);
else
dtsize_t(&dt, 0);
// invariant
if (inv)
dtxoff(&dt, toSymbol(inv), 0, TYnptr);
else
dtsize_t(&dt, 0);
// flags
ClassFlags::Type flags = ClassFlags::hasOffTi;
if (isCOMclass()) flags |= ClassFlags::isCOMclass;
if (isCPPclass()) flags |= ClassFlags::isCPPclass;
flags |= ClassFlags::hasGetMembers;
flags |= ClassFlags::hasTypeInfo;
if (ctor)
flags |= ClassFlags::hasCtor;
if (isabstract)
flags |= ClassFlags::isAbstract;
for (ClassDeclaration *cd = this; cd; cd = cd->baseClass)
{
if (cd->members)
{
for (size_t i = 0; i < cd->members->dim; i++)
{
Dsymbol *sm = (*cd->members)[i];
//printf("sm = %s %s\n", sm->kind(), sm->toChars());
if (sm->hasPointers())
goto L2;
}
}
}
flags |= ClassFlags::noPointers;
L2:
dtsize_t(&dt, flags);
// deallocator
if (aggDelete)
dtxoff(&dt, toSymbol(aggDelete), 0, TYnptr);
else
dtsize_t(&dt, 0);
// offTi[]
dtsize_t(&dt, 0);
dtsize_t(&dt, 0); // null for now, fix later
// defaultConstructor
if (defaultCtor)
dtxoff(&dt, toSymbol(defaultCtor), 0, TYnptr);
else
dtsize_t(&dt, 0);
// xgetRTInfo
if (getRTInfo)
getRTInfo->toDt(&dt);
else if (flags & ClassFlags::noPointers)
dtsize_t(&dt, 0);
else
dtsize_t(&dt, 1);
//dtxoff(&dt, toSymbol(type->vtinfo), 0, TYnptr); // typeinfo
//////////////////////////////////////////////
// Put out (*vtblInterfaces)[]. Must immediately follow csym, because
// of the fixup (*)
offset += vtblInterfaces->dim * (4 * Target::ptrsize);
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{ BaseClass *b = (*vtblInterfaces)[i];
ClassDeclaration *id = b->base;
/* The layout is:
* struct Interface
* {
* ClassInfo *interface;
* void *[] vtbl;
* size_t offset;
* }
*/
// Fill in vtbl[]
b->fillVtbl(this, &b->vtbl, 1);
dtxoff(&dt, toSymbol(id), 0, TYnptr); // ClassInfo
// vtbl[]
dtsize_t(&dt, id->vtbl.dim);
dtxoff(&dt, csym, offset, TYnptr);
dtsize_t(&dt, b->offset); // this offset
offset += id->vtbl.dim * Target::ptrsize;
}
// Put out the (*vtblInterfaces)[].vtbl[]
// This must be mirrored with ClassDeclaration::baseVtblOffset()
//printf("putting out %d interface vtbl[]s for '%s'\n", vtblInterfaces->dim, toChars());
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{ BaseClass *b = (*vtblInterfaces)[i];
ClassDeclaration *id = b->base;
//printf(" interface[%d] is '%s'\n", i, id->toChars());
size_t j = 0;
if (id->vtblOffset())
{
// First entry is ClassInfo reference
//dtxoff(&dt, toSymbol(id), 0, TYnptr);
// First entry is struct Interface reference
dtxoff(&dt, csym, classinfo_size + i * (4 * Target::ptrsize), TYnptr);
j = 1;
}
assert(id->vtbl.dim == b->vtbl.dim);
for (; j < id->vtbl.dim; j++)
{
assert(j < b->vtbl.dim);
#if 0
RootObject *o = b->vtbl[j];
if (o)
{
printf("o = %p\n", o);
assert(o->dyncast() == DYNCAST_DSYMBOL);
Dsymbol *s = (Dsymbol *)o;
printf("s->kind() = '%s'\n", s->kind());
}
#endif
FuncDeclaration *fd = b->vtbl[j];
if (fd)
dtxoff(&dt, fd->toThunkSymbol(b->offset), 0, TYnptr);
else
dtsize_t(&dt, 0);
}
}
// Put out the overriding interface vtbl[]s.
// This must be mirrored with ClassDeclaration::baseVtblOffset()
//printf("putting out overriding interface vtbl[]s for '%s' at offset x%x\n", toChars(), offset);
ClassDeclaration *cd;
FuncDeclarations bvtbl;
for (cd = this->baseClass; cd; cd = cd->baseClass)
{
for (size_t k = 0; k < cd->vtblInterfaces->dim; k++)
{ BaseClass *bs = (*cd->vtblInterfaces)[k];
if (bs->fillVtbl(this, &bvtbl, 0))
{
//printf("\toverriding vtbl[] for %s\n", bs->base->toChars());
ClassDeclaration *id = bs->base;
size_t j = 0;
if (id->vtblOffset())
{
// First entry is ClassInfo reference
//dtxoff(&dt, toSymbol(id), 0, TYnptr);
// First entry is struct Interface reference
dtxoff(&dt, toSymbol(cd), classinfo_size + k * (4 * Target::ptrsize), TYnptr);
j = 1;
}
for (; j < id->vtbl.dim; j++)
{
FuncDeclaration *fd;
assert(j < bvtbl.dim);
fd = bvtbl[j];
if (fd)
dtxoff(&dt, fd->toThunkSymbol(bs->offset), 0, TYnptr);
else
dtsize_t(&dt, 0);
}
}
}
}
csym->Sdt = dt;
// ClassInfo cannot be const data, because we use the monitor on it
outdata(csym);
if (isExport())
objmod->export_symbol(csym,0);
//////////////////////////////////////////////
// Put out the vtbl[]
//printf("putting out %s.vtbl[]\n", toChars());
dt = NULL;
if (vtblOffset())
dtxoff(&dt, csym, 0, TYnptr); // first entry is ClassInfo reference
for (size_t i = vtblOffset(); i < vtbl.dim; i++)
{
FuncDeclaration *fd = vtbl[i]->isFuncDeclaration();
//printf("\tvtbl[%d] = %p\n", i, fd);
if (fd && (fd->fbody || !isAbstract()))
{
// Ensure function has a return value (Bugzilla 4869)
fd->functionSemantic();
Symbol *s = toSymbol(fd);
if (isFuncHidden(fd))
{ /* fd is hidden from the view of this class.
* If fd overlaps with any function in the vtbl[], then
* issue 'hidden' error.
*/
for (size_t j = 1; j < vtbl.dim; j++)
{ if (j == i)
continue;
FuncDeclaration *fd2 = vtbl[j]->isFuncDeclaration();
if (!fd2->ident->equals(fd->ident))
continue;
if (fd->leastAsSpecialized(fd2) || fd2->leastAsSpecialized(fd))
{
TypeFunction *tf = (TypeFunction *)fd->type;
if (tf->ty == Tfunction)
deprecation("use of %s%s hidden by %s is deprecated. Use 'alias %s.%s %s;' to introduce base class overload set.", fd->toPrettyChars(), Parameter::argsTypesToChars(tf->parameters, tf->varargs), toChars(), fd->parent->toChars(), fd->toChars(), fd->toChars());
else
deprecation("use of %s hidden by %s is deprecated", fd->toPrettyChars(), toChars());
s = rtlsym[RTLSYM_DHIDDENFUNC];
break;
}
}
}
dtxoff(&dt, s, 0, TYnptr);
}
else
dtsize_t(&dt, 0);
}
vtblsym->Sdt = dt;
vtblsym->Sclass = scclass;
vtblsym->Sfl = FLdata;
out_readonly(vtblsym);
outdata(vtblsym);
if (isExport())
objmod->export_symbol(vtblsym,0);
}
void FunctionSizeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("func"), this);
}
void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("decl"), this);
}
void InterfaceDeclaration::toObjFile(int multiobj)
{
enum_SC scclass;
//printf("InterfaceDeclaration::toObjFile('%s')\n", toChars());
if (type->ty == Terror)
{ error("had semantic errors when compiling");
return;
}
if (!members)
return;
if (global.params.symdebug)
toDebug(this);
scclass = SCglobal;
if (isInstantiated())
scclass = SCcomdat;
// Put out the members
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *member = (*members)[i];
member->toObjFile(0);
}
// Generate C symbols
toSymbol(this);
//////////////////////////////////////////////
// Put out the TypeInfo
type->genTypeInfo(NULL);
type->vtinfo->toObjFile(multiobj);
//////////////////////////////////////////////
// Put out the ClassInfo
csym->Sclass = scclass;
csym->Sfl = FLdata;
/* The layout is:
{
void **vptr;
monitor_t monitor;
byte[] initializer; // static initialization data
char[] name; // class name
void *[] vtbl;
Interface[] interfaces;
Object *base; // base class
void *destructor;
void *invariant; // class invariant
uint flags;
void *deallocator;
OffsetTypeInfo[] offTi;
void *defaultConstructor;
//const(MemberInfo[]) function(string) xgetMembers; // module getMembers() function
void* xgetRTInfo;
//TypeInfo typeinfo;
}
*/
dt_t *dt = NULL;
if (Type::typeinfoclass)
dtxoff(&dt, Type::typeinfoclass->toVtblSymbol(), 0, TYnptr); // vtbl for ClassInfo
else
dtsize_t(&dt, 0); // BUG: should be an assert()
dtsize_t(&dt, 0); // monitor
// initializer[]
dtsize_t(&dt, 0); // size
dtsize_t(&dt, 0); // initializer
// name[]
const char *name = toPrettyChars();
size_t namelen = strlen(name);
dtsize_t(&dt, namelen);
dtabytes(&dt, TYnptr, 0, namelen + 1, name);
// vtbl[]
dtsize_t(&dt, 0);
dtsize_t(&dt, 0);
// (*vtblInterfaces)[]
unsigned offset;
dtsize_t(&dt, vtblInterfaces->dim);
if (vtblInterfaces->dim)
{
offset = global.params.isLP64 ? CLASSINFO_SIZE_64 : CLASSINFO_SIZE; // must be ClassInfo.size
if (Type::typeinfoclass)
{
if (Type::typeinfoclass->structsize != offset)
{
error("mismatch between dmd and object.d or object.di found. Check installation and import paths with -v compiler switch.");
fatal();
}
}
dtxoff(&dt, csym, offset, TYnptr); // (*)
}
else
{ offset = 0;
dtsize_t(&dt, 0);
}
// base
assert(!baseClass);
dtsize_t(&dt, 0);
// dtor
dtsize_t(&dt, 0);
// invariant
dtsize_t(&dt, 0);
// flags
ClassFlags::Type flags = ClassFlags::hasOffTi | ClassFlags::hasTypeInfo;
if (isCOMinterface()) flags |= ClassFlags::isCOMclass;
dtsize_t(&dt, flags);
// deallocator
dtsize_t(&dt, 0);
// offTi[]
dtsize_t(&dt, 0);
dtsize_t(&dt, 0); // null for now, fix later
// defaultConstructor
dtsize_t(&dt, 0);
// xgetMembers
//dtsize_t(&dt, 0);
// xgetRTInfo
// xgetRTInfo
if (getRTInfo)
getRTInfo->toDt(&dt);
else
dtsize_t(&dt, 0); // no pointers
//dtxoff(&dt, toSymbol(type->vtinfo), 0, TYnptr); // typeinfo
//////////////////////////////////////////////
// Put out (*vtblInterfaces)[]. Must immediately follow csym, because
// of the fixup (*)
offset += vtblInterfaces->dim * (4 * Target::ptrsize);
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{ BaseClass *b = (*vtblInterfaces)[i];
ClassDeclaration *id = b->base;
// ClassInfo
dtxoff(&dt, toSymbol(id), 0, TYnptr);
// vtbl[]
dtsize_t(&dt, 0);
dtsize_t(&dt, 0);
// this offset
dtsize_t(&dt, b->offset);
}
csym->Sdt = dt;
out_readonly(csym);
outdata(csym);
if (isExport())
objmod->export_symbol(csym,0);
}