projects/ldc: gen/classes.cpp comparison

comparison gen/classes.cpp @ 1148:3d1b16dabd25

Eliminated the need for resolve, declare, const-init and define lists to drive code generation.

author	Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
date	Fri, 27 Mar 2009 21:50:32 +0100
parents	dbe4af57b240
children	5ebe8224988b

comparison

equal deleted inserted replaced

-:dbe4af57b240
+:3d1b16dabd25
 }
 }
 //////////////////////////////////////////////////////////////////////////////////////////
+static void DtoDeclareInterface(InterfaceDeclaration* cd);
+static void DtoConstInitInterface(InterfaceDeclaration* cd);
+static void DtoDefineInterface(InterfaceDeclaration* cd);
 static void DtoResolveInterface(InterfaceDeclaration* cd)
 {
 if (cd->ir.resolved) return;
 cd->ir.resolved = true;
 InterfaceDeclaration* id = bc->base->isInterfaceDeclaration();
 assert(id);
 DtoResolveInterface(id);
 // add to interfaceInfos
 IrInterface* iri = new IrInterface(bc);
 irstruct->interfaceVec.push_back(iri);
 irstruct->classInfoInterfaces.push_back(iri);
 }
 const LLType* t = LLArrayType::get(getVoidPtrType(), cd->vtbl.dim);
 assert(!ts->ir.type);
 ts->ir.type = new LLPATypeHolder(getPtrToType(t));
 // request declaration
-gIR->declareList.push_back(cd);
+DtoDeclareInterface(cd);
 // handle members
 // like "nested" interfaces
 Array* arr = cd->members;
 for (int k=0; k < arr->dim; k++) {
 {
 DtoResolveInterface(id);
 return;
 }
+// make sure the base classes are processed first
+if (cd->baseClass)
+cd->baseClass->codegen(Type::sir);
 if (cd->ir.resolved) return;
 cd->ir.resolved = true;
 Logger::println("DtoResolveClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
 LOG_SCOPE;
-//printf("resolve class: %s\n", cd->toPrettyChars());
 // get the TypeClass
 assert(cd->type->ty == Tclass);
 TypeClass* ts = (TypeClass*)cd->type;
 // just name the type
 gIR->module->addTypeName(cd->mangle(), ts->ir.type->get());
 return;
 }
-// resolve the base class
+// create the symbols we're going to need
-if (cd->baseClass) {
+// avoids chicken egg problems
-DtoResolveClass(cd->baseClass);
+llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(cd);
-}
+// there is always a vtbl symbol
+std::string varname("_D");
+varname.append(cd->mangle());
+varname.append("6__vtblZ");
+irstruct->vtbl = new llvm::GlobalVariable(irstruct->vtblInitTy.get(), true, _linkage, NULL, varname, gIR->module);
+// ... and initZ
+std::string initname("_D");
+initname.append(cd->mangle());
+initname.append("6__initZ");
+irstruct->init = new llvm::GlobalVariable(irstruct->initOpaque.get(), true, _linkage, NULL, initname, gIR->module);
 // push state
 gIR->structs.push_back(irstruct);
 // add vtable
 // refine abstract types for stuff like: class C {C next;}
 llvm::PATypeHolder* spa = ts->ir.type;
 llvm::cast<llvm::OpaqueType>(spa->get())->refineAbstractTypeTo(structtype);
 structtype = isaStruct(spa->get());
+assert(structtype);
 // name the type
 gIR->module->addTypeName(cd->mangle(), ts->ir.type->get());
 // refine vtable type
 // pop state
 gIR->structs.pop_back();
 // queue declare
-gIR->declareList.push_back(cd);
+DtoDeclareClass(cd);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 static void DtoDeclareInterface(InterfaceDeclaration* cd)
 {
+DtoResolveInterface(cd);
 if (cd->ir.declared) return;
 cd->ir.declared = true;
 Logger::println("DtoDeclareInterface(%s): %s", cd->toPrettyChars(), cd->locToChars());
 LOG_SCOPE;
 // declare the classinfo
 DtoDeclareClassInfo(cd);
 // request const init
-gIR->constInitList.push_back(cd);
+DtoConstInitInterface(cd);
 // emit typeinfo and request definition
 if (mustDefineSymbol(cd))
 {
-gIR->defineList.push_back(cd);
+DtoDefineInterface(cd);
 DtoTypeInfoOf(cd->type, false);
 }
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 if (InterfaceDeclaration* id = cd->isInterfaceDeclaration())
 {
 DtoDeclareInterface(id);
 return;
 }
+DtoResolveClass(cd);
 if (cd->ir.declared) return;
 cd->ir.declared = true;
 Logger::println("DtoDeclareClass(%s): %s", cd->toPrettyChars(), cd->locToChars());
 if (mustDefineSymbol(cd)) {
 needs_definition = true;
 }
 llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(cd);
-// create vtbl symbol
-std::string varname("_D");
-varname.append(cd->mangle());
-varname.append("6__vtblZ");
-irstruct->vtbl = new llvm::GlobalVariable(irstruct->vtblInitTy.get(), true, _linkage, 0, varname, gIR->module);
 // get interface info type
 const llvm::StructType* infoTy = DtoInterfaceInfoType();
 // interface info array
 LLConstant* idxs[2] = {DtoConstUint(0), DtoConstUint(idx)};
 iri->info = llvm::ConstantExpr::getGetElementPtr(irstruct->interfaceInfos, idxs, 2);
 idx++;
 }
-// initZ init
-std::string initname("_D");
-initname.append(cd->mangle());
-initname.append("6__initZ");
-// initZ global
-llvm::GlobalVariable* initvar = new llvm::GlobalVariable(irstruct->initOpaque.get(), true, _linkage, NULL, initname, gIR->module);
-irstruct->init = initvar;
 gIR->structs.pop_back();
 // request const init
-gIR->constInitList.push_back(cd);
+DtoConstInitClass(cd);
 // define ? (set initializers)
 if (needs_definition)
-gIR->defineList.push_back(cd);
+DtoDefineClass(cd);
 // classinfo
 DtoDeclareClassInfo(cd);
 // do typeinfo ?
 //////////////////////////////////////////////////////////////////////////////
 // build the vtable initializer for class cd
 static void init_class_vtbl_initializer(ClassDeclaration* cd)
 {
+cd->codegen(Type::sir);
 // generate vtable initializer
 std::vector<LLConstant*> sinits(cd->vtbl.dim, NULL);
 IrStruct* irstruct = cd->ir.irStruct;
 assert(cd->vtbl.dim > 1);
+DtoDeclareClassInfo(cd);
 // first entry always classinfo
 assert(irstruct->classInfo);
 sinits[0] = DtoBitCast(irstruct->classInfo, DtoType(ClassDeclaration::classinfo->type));
 {
 sinits[k] = getNullPtr(getVoidPtrType());
 }
 else
 {
-DtoForceDeclareDsymbol(fd);
+fd->codegen(Type::sir);
+Logger::println("F = %s", fd->toPrettyChars());
+assert(fd->ir.irFunc);
 assert(fd->ir.irFunc->func);
 sinits[k] = fd->ir.irFunc->func;
 }
 //         if (Logger::enabled())
 if (fd->isAbstract())
 inits[j] = getNullPtr(getVoidPtrType());
 else
 {
-DtoForceDeclareDsymbol(fd);
+fd->codegen(Type::sir);
 assert(fd->ir.irFunc->func);
 inits[j] = fd->ir.irFunc->func;
 }
 }
 // build the interface info for ClassInfo
 // generate interface info initializer
-DtoForceDeclareDsymbol(iri->decl);
+iri->decl->codegen(Type::sir);
 // classinfo
 IrStruct* iris = iri->decl->ir.irStruct;
 assert(iris);
 assert(iris->classInfo);
 //////////////////////////////////////////////////////////////////////////////
 static void DtoConstInitInterface(InterfaceDeclaration* cd)
 {
+DtoDeclareInterface(cd);
 if (cd->ir.initialized) return;
 cd->ir.initialized = true;
 Logger::println("DtoConstInitClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
 LOG_SCOPE;
 {
 DtoConstInitInterface(it);
 return;
 }
+DtoDeclareClass(cd);
 if (cd->ir.initialized) return;
 cd->ir.initialized = true;
 Logger::println("DtoConstInitClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
 LOG_SCOPE;
-assert(!cd->isInterfaceDeclaration());
-// make sure the baseclass is const initialized
-if (cd->baseClass)
-DtoForceConstInitDsymbol(cd->baseClass);
 // get IrStruct
 IrStruct* irstruct = cd->ir.irStruct;
 gIR->structs.push_back(irstruct);
 //////////////////////////////////////////////////////////////////////////////////////////
 static void DtoDefineInterface(InterfaceDeclaration* cd)
 {
+DtoConstInitInterface(cd);
 if (cd->ir.defined) return;
 cd->ir.defined = true;
 Logger::println("DtoDefineClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
 LOG_SCOPE;
 if (InterfaceDeclaration* id = cd->isInterfaceDeclaration())
 {
 DtoDefineInterface(id);
 return;
 }
+DtoConstInitClass(cd);
 if (cd->ir.defined) return;
 cd->ir.defined = true;
 Logger::println("DtoDefineClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
 //////////////////////////////////////////////////////////////////////////////////////////
 DValue* DtoNewClass(Loc loc, TypeClass* tc, NewExp* newexp)
 {
 // resolve type
-DtoForceDeclareDsymbol(tc->sym);
+tc->sym->codegen(Type::sir);
 // allocate
 LLValue* mem;
 if (newexp->onstack)
 {
 mem = DtoAlloca(DtoType(tc)->getContainedType(0), ".newclass_alloca");
 }
 // custom allocator
 else if (newexp->allocator)
 {
-DtoForceDeclareDsymbol(newexp->allocator);
+newexp->allocator->codegen(Type::sir);
 DFuncValue dfn(newexp->allocator, newexp->allocator->ir.irFunc->func);
 DValue* res = DtoCallFunction(newexp->loc, NULL, &dfn, newexp->newargs);
 mem = DtoBitCast(res->getRVal(), DtoType(tc), ".newclass_custom");
 }
 // default allocator
 // call constructor
 if (newexp->member)
 {
 Logger::println("Calling constructor");
 assert(newexp->arguments != NULL);
-DtoForceDeclareDsymbol(newexp->member);
+newexp->member->codegen(Type::sir);
 DFuncValue dfn(newexp->member, newexp->member->ir.irFunc->func, mem);
 return DtoCallFunction(newexp->loc, tc, &dfn, newexp->arguments);
 }
 // return default constructed class
 //////////////////////////////////////////////////////////////////////////////////////////
 void DtoInitClass(TypeClass* tc, LLValue* dst)
 {
-DtoForceConstInitDsymbol(tc->sym);
+tc->sym->codegen(Type::sir);
 size_t presz = 2*getTypePaddedSize(DtoSize_t());
 uint64_t n = getTypePaddedSize(tc->ir.type->get()) - presz;
 // set vtable field seperately, this might give better optimization
 DValue* DtoDynamicCastObject(DValue* val, Type* _to)
 {
 // call:
 // Object _d_dynamic_cast(Object o, ClassInfo c)
-DtoForceDeclareDsymbol(ClassDeclaration::object);
+ClassDeclaration::object->codegen(Type::sir);
-DtoForceDeclareDsymbol(ClassDeclaration::classinfo);
+ClassDeclaration::classinfo->codegen(Type::sir);
 llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_dynamic_cast");
 const llvm::FunctionType* funcTy = func->getFunctionType();
 std::vector<LLValue*> args;
 obj = DtoBitCast(obj, funcTy->getParamType(0));
 assert(funcTy->getParamType(0) == obj->getType());
 // ClassInfo c
 TypeClass* to = (TypeClass*)_to->toBasetype();
-DtoForceDeclareDsymbol(to->sym);
+to->sym->codegen(Type::sir);
 assert(to->sym->ir.irStruct->classInfo);
 LLValue* cinfo = to->sym->ir.irStruct->classInfo;
 // unfortunately this is needed as the implementation of object differs somehow from the declaration
 // this could happen in user code as well :/
 cinfo = DtoBitCast(cinfo, funcTy->getParamType(1));
 DValue* DtoDynamicCastInterface(DValue* val, Type* _to)
 {
 // call:
 // Object _d_interface_cast(void* p, ClassInfo c)
-DtoForceDeclareDsymbol(ClassDeclaration::object);
+ClassDeclaration::object->codegen(Type::sir);
-DtoForceDeclareDsymbol(ClassDeclaration::classinfo);
+ClassDeclaration::classinfo->codegen(Type::sir);
 llvm::Function* func = LLVM_D_GetRuntimeFunction(gIR->module, "_d_interface_cast");
 const llvm::FunctionType* funcTy = func->getFunctionType();
 std::vector<LLValue*> args;
 LLValue* ptr = val->getRVal();
 ptr = DtoBitCast(ptr, funcTy->getParamType(0));
 // ClassInfo c
 TypeClass* to = (TypeClass*)_to->toBasetype();
-DtoForceDeclareDsymbol(to->sym);
+to->sym->codegen(Type::sir);
 assert(to->sym->ir.irStruct->classInfo);
 LLValue* cinfo = to->sym->ir.irStruct->classInfo;
 // unfortunately this is needed as the implementation of object differs somehow from the declaration
 // this could happen in user code as well :/
 cinfo = DtoBitCast(cinfo, funcTy->getParamType(1));
 // if no destructor emit a null
 if (!dtor)
 return getNullPtr(getVoidPtrType());
-DtoForceDeclareDsymbol(dtor);
+dtor->codegen(Type::sir);
 return llvm::ConstantExpr::getBitCast(dtor->ir.irFunc->func, getPtrToType(LLType::Int8Ty));
 }
 static unsigned build_classinfo_flags(ClassDeclaration* cd)
 {
 // holds the list of initializers for llvm
 std::vector<LLConstant*> inits;
 ClassDeclaration* cinfo = ClassDeclaration::classinfo;
-DtoForceConstInitDsymbol(cinfo);
+cinfo->codegen(Type::sir);
 LLConstant* c;
 const LLType* voidPtr = getVoidPtrType();
 const LLType* voidPtrPtr = getPtrToType(voidPtr);
 // invariant
 VarDeclaration* invVar = (VarDeclaration*)cinfo->fields.data[6];
 const LLType* invTy = DtoType(invVar->type);
 if (cd->inv)
 {
-DtoForceDeclareDsymbol(cd->inv);
+cd->inv->codegen(Type::sir);
 c = cd->inv->ir.irFunc->func;
 c = DtoBitCast(c, invTy);
 }
 else
 c = LLConstant::getNullValue(invTy);
 inits.push_back(c);
 // deallocator
 if (cd->aggDelete)
 {
-DtoForceDeclareDsymbol(cd->aggDelete);
+cd->aggDelete->codegen(Type::sir);
 c = cd->aggDelete->ir.irFunc->func;
 c = DtoBitCast(c, voidPtr);
 }
 else
 c = LLConstant::getNullValue(voidPtr);
 inits.push_back(c);
 // default constructor
 if (cd->defaultCtor)
 {
-DtoForceDeclareDsymbol(cd->defaultCtor);
+cd->defaultCtor->codegen(Type::sir);
 c = isaConstant(cd->defaultCtor->ir.irFunc->func);
 c = DtoBitCast(c, voidPtr);
 }
 else
 c = LLConstant::getNullValue(voidPtr);

Mercurial > projects > ldc

comparison gen/classes.cpp @ 1148:3d1b16dabd25