void visit(ClassDeclaration *decl) override {
IF_LOG Logger::println("ClassDeclaration::codegen: '%s'",
decl->toPrettyChars());
LOG_SCOPE
assert(!irs->dcomputetarget);
if (decl->ir->isDefined()) {
return;
}
if (decl->type->ty == Terror) {
error(decl->loc, "had semantic errors when compiling");
decl->ir->setDefined();
return;
}
if (decl->members && decl->symtab) {
DtoResolveClass(decl);
decl->ir->setDefined();
for (auto m : *decl->members) {
m->accept(this);
}
IrAggr *ir = getIrAggr(decl);
const auto lwc = DtoLinkage(decl);
auto &initZ = ir->getInitSymbol();
auto initGlobal = llvm::cast<LLGlobalVariable>(initZ);
initZ = irs->setGlobalVarInitializer(initGlobal, ir->getDefaultInit());
setLinkage(lwc, initGlobal);
llvm::GlobalVariable *vtbl = ir->getVtblSymbol();
vtbl->setInitializer(ir->getVtblInit());
setLinkage(lwc, vtbl);
llvm::GlobalVariable *classZ = ir->getClassInfoSymbol();
if (!isSpeculativeType(decl->type)) {
classZ->setInitializer(ir->getClassInfoInit());
setLinkage(lwc, classZ);
}
}
}
void visit(InterfaceDeclaration *decl) override {
IF_LOG Logger::println("InterfaceDeclaration::codegen: '%s'",
decl->toPrettyChars());
LOG_SCOPE
assert(!irs->dcomputetarget);
if (decl->ir->isDefined()) {
return;
}
if (decl->type->ty == Terror) {
error(decl->loc, "had semantic errors when compiling");
decl->ir->setDefined();
return;
}
if (decl->members && decl->symtab) {
DtoResolveClass(decl);
decl->ir->setDefined();
// Emit any members (e.g. final functions).
for (auto m : *decl->members) {
m->accept(this);
}
// Emit TypeInfo.
DtoTypeInfoOf(decl->type, /*base=*/false);
// Declare __InterfaceZ.
IrAggr *ir = getIrAggr(decl);
llvm::GlobalVariable *interfaceZ = ir->getClassInfoSymbol();
// Only define if not speculative.
if (!isSpeculativeType(decl->type)) {
interfaceZ->setInitializer(ir->getClassInfoInit());
setLinkage(decl, interfaceZ);
}
}
}
void DtoResolveClass(ClassDeclaration* cd)
{
// make sure the base classes are processed first
ArrayIter<BaseClass> base_iter(cd->baseclasses);
while (base_iter.more())
{
BaseClass* bc = base_iter.get();
if (bc)
{
bc->base->codegen(Type::sir);
}
base_iter.next();
}
if (cd->ir.resolved) return;
cd->ir.resolved = true;
Logger::println("DtoResolveClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
LOG_SCOPE;
// make sure type exists
DtoType(cd->type);
// create IrAggr
assert(cd->ir.irAggr == NULL);
IrAggr* irAggr = new IrAggr(cd);
cd->ir.irAggr = irAggr;
// make sure all fields really get their ir field
ArrayIter<VarDeclaration> it(cd->fields);
for (; !it.done(); it.next())
{
VarDeclaration* vd = it.get();
if (vd->ir.irField == NULL) {
new IrField(vd);
} else {
IF_LOG Logger::println("class field already exists!!!");
}
}
bool needs_def = mustDefineSymbol(cd);
// emit the ClassZ symbol
LLGlobalVariable* ClassZ = irAggr->getClassInfoSymbol();
// emit the interfaceInfosZ symbol if necessary
if (cd->vtblInterfaces && cd->vtblInterfaces->dim > 0)
irAggr->getInterfaceArraySymbol(); // initializer is applied when it's built
// interface only emit typeinfo and classinfo
if (cd->isInterfaceDeclaration())
{
irAggr->initializeInterface();
}
else
{
// emit the initZ symbol
LLGlobalVariable* initZ = irAggr->getInitSymbol();
// emit the vtblZ symbol
LLGlobalVariable* vtblZ = irAggr->getVtblSymbol();
// perform definition
if (needs_def)
{
// set symbol initializers
initZ->setInitializer(irAggr->getDefaultInit());
vtblZ->setInitializer(irAggr->getVtblInit());
}
}
// emit members
if (cd->members)
{
ArrayIter<Dsymbol> it(*cd->members);
while (!it.done())
{
Dsymbol* member = it.get();
if (member)
member->codegen(Type::sir);
it.next();
}
}
if (needs_def)
{
// emit typeinfo
DtoTypeInfoOf(cd->type);
// define classinfo
ClassZ->setInitializer(irAggr->getClassInfoInit());
}
}