projects/ldc: gen/typinf.cpp comparison

comparison gen/typinf.cpp @ 106:5b5194b25f33 trunk

[svn r110] Fixed typeinfo for classes.

author	lindquist
date	Mon, 19 Nov 2007 06:01:48 +0100
parents	182b41f56b7f
children	5ab8e92611f9

comparison

equal deleted inserted replaced

-:182b41f56b7f
+:5b5194b25f33
 #include "gen/logger.h"
 #include "gen/runtime.h"
 #include "gen/tollvm.h"
 #include "gen/arrays.h"
 #include "gen/structs.h"
+#include "gen/classes.h"
 /*******************************************
 * Get a canonicalized form of the TypeInfo for use with the internal
 * runtime library routines. Canonicalized in that static arrays are
 * represented as dynamic arrays, enums are represented by their
 tid->llvmInitialized = true;
 tid->llvmDefined = true;
 }
 // custom typedef
 else {
+tid->llvmDeclare();
 gIR->constInitList.push_back(tid);
 }
 }
 void DtoConstInitTypeInfo(TypeInfoDeclaration* tid)
 tid->llvmInitialized = true;
 Logger::println("* DtoConstInitTypeInfo(%s)", tid->toChars());
 LOG_SCOPE;
-tid->toDt(NULL);
+gIR->defineList.push_back(tid);
-tid->llvmDefined = true;
-//gIR->defineList.push_back(tid);
 }
 void DtoDefineTypeInfo(TypeInfoDeclaration* tid)
 {
 if (tid->llvmDefined) return;
 tid->llvmDefined = true;
 Logger::println("* DtoDefineTypeInfo(%s)", tid->toChars());
 LOG_SCOPE;
-assert(0);
+tid->llvmDefine();
 }
 /* ========================================================================= */
 void TypeInfoDeclaration::toDt(dt_t **pdt)
 {
-assert(0 && "TypeInfoDeclaration");
+assert(0 && "TypeInfoDeclaration::toDt");
 }
-/* ========================================================================= */
+void TypeInfoDeclaration::llvmDeclare()
+{
-void TypeInfoTypedefDeclaration::toDt(dt_t **pdt)
+assert(0 && "TypeInfoDeclaration::llvmDeclare");
-{
+}
-Logger::println("TypeInfoTypedefDeclaration::toDt() %s", toChars());
+void TypeInfoDeclaration::llvmDefine()
+{
+assert(0 && "TypeInfoDeclaration::llvmDeclare");
+}
+/* ========================================================================= */
+void TypeInfoTypedefDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoTypedefDeclaration::llvmDeclare() %s", toChars());
+LOG_SCOPE;
+ClassDeclaration* base = Type::typeinfotypedef;
+DtoResolveClass(base);
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// create the symbol
+llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
+}
+void TypeInfoTypedefDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoTypedefDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
 ClassDeclaration* base = Type::typeinfotypedef;
 DtoForceConstInitDsymbol(base);
 //sd->basetype = sd->basetype->merge();
 sd->basetype->getTypeInfo(NULL);        // generate vtinfo
 assert(sd->basetype->vtinfo);
 if (!sd->basetype->vtinfo->llvmValue)
-DtoForceConstInitDsymbol(sd->basetype->vtinfo);
+DtoForceDeclareDsymbol(sd->basetype->vtinfo);
 assert(sd->basetype->vtinfo->llvmValue);
 assert(llvm::isa<llvm::Constant>(sd->basetype->vtinfo->llvmValue));
 llvm::Constant* castbase = llvm::cast<llvm::Constant>(sd->basetype->vtinfo->llvmValue);
 castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(1));
 sinits.push_back(DtoConstSlice(DtoConstSize_t(cisize), cicast));
 }
 // create the symbol
 llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
-llvm::GlobalVariable* gvar = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,tiInit,toChars(),gIR->module);
+isaGlobalVar(llvmValue)->setInitializer(tiInit);
+}
-llvmValue = gvar;
-}
+void TypeInfoTypedefDeclaration::toDt(dt_t **pdt)
+{
-/* ========================================================================= */
+assert(0);
+}
-void TypeInfoEnumDeclaration::toDt(dt_t **pdt)
-{
+/* ========================================================================= */
-Logger::println("TypeInfoTypedefDeclaration::toDt() %s", toChars());
+void TypeInfoEnumDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoEnumDeclaration::llvmDeclare() %s", toChars());
+LOG_SCOPE;
+ClassDeclaration* base = Type::typeinfoenum;
+DtoResolveClass(base);
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// create the symbol
+llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
+}
+void TypeInfoEnumDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoEnumDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
 ClassDeclaration* base = Type::typeinfoenum;
 DtoForceConstInitDsymbol(base);
 //sd->basetype = sd->basetype->merge();
 sd->memtype->getTypeInfo(NULL);        // generate vtinfo
 assert(sd->memtype->vtinfo);
 if (!sd->memtype->vtinfo->llvmValue)
-DtoForceConstInitDsymbol(sd->memtype->vtinfo);
+DtoForceDeclareDsymbol(sd->memtype->vtinfo);
 assert(llvm::isa<llvm::Constant>(sd->memtype->vtinfo->llvmValue));
 llvm::Constant* castbase = llvm::cast<llvm::Constant>(sd->memtype->vtinfo->llvmValue);
 castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(1));
 sinits.push_back(castbase);
 sinits.push_back(DtoConstSlice(DtoConstSize_t(cisize), cicast));
 }
 // create the symbol
 llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
-llvm::GlobalVariable* gvar = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,tiInit,toChars(),gIR->module);
+isaGlobalVar(llvmValue)->setInitializer(tiInit);
+}
-llvmValue = gvar;
-}
+void TypeInfoEnumDeclaration::toDt(dt_t **pdt)
+{
-/* ========================================================================= */
+assert(0);
+}
-static llvm::Constant* LLVM_D_Create_TypeInfoBase(Type* basetype, TypeInfoDeclaration* tid, ClassDeclaration* cd)
+/* ========================================================================= */
+static llvm::Constant* LLVM_D_Declare_TypeInfoBase(TypeInfoDeclaration* tid, ClassDeclaration* cd)
+{
+ClassDeclaration* base = cd;
+DtoResolveClass(base);
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// create the symbol
+tid->llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,tid->toChars(),gIR->module);
+}
+static llvm::Constant* LLVM_D_Define_TypeInfoBase(Type* basetype, TypeInfoDeclaration* tid, ClassDeclaration* cd)
 {
 ClassDeclaration* base = cd;
 DtoForceConstInitDsymbol(base);
 const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
 // TypeInfo base
 Logger::println("generating base typeinfo");
 basetype->getTypeInfo(NULL);
 assert(basetype->vtinfo);
 if (!basetype->vtinfo->llvmValue)
-DtoForceConstInitDsymbol(basetype->vtinfo);
+DtoForceDeclareDsymbol(basetype->vtinfo);
 assert(llvm::isa<llvm::Constant>(basetype->vtinfo->llvmValue));
 llvm::Constant* castbase = llvm::cast<llvm::Constant>(basetype->vtinfo->llvmValue);
 castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(1));
 sinits.push_back(castbase);
 // create the symbol
 llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
-llvm::GlobalVariable* gvar = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,tiInit,tid->toChars(),gIR->module);
+isaGlobalVar(tid->llvmValue)->setInitializer(tiInit);
+}
-tid->llvmValue = gvar;
-}
+/* ========================================================================= */
-/* ========================================================================= */
+void TypeInfoPointerDeclaration::llvmDeclare()
+{
-void TypeInfoPointerDeclaration::toDt(dt_t **pdt)
+Logger::println("TypeInfoPointerDeclaration::llvmDeclare() %s", toChars());
-{
-Logger::println("TypeInfoPointerDeclaration::toDt() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tpointer);
 TypePointer *tc = (TypePointer *)tinfo;
-LLVM_D_Create_TypeInfoBase(tc->next, this, Type::typeinfopointer);
+LLVM_D_Declare_TypeInfoBase(this, Type::typeinfopointer);
 }
-/* ========================================================================= */
+void TypeInfoPointerDeclaration::llvmDefine()
+{
-void TypeInfoArrayDeclaration::toDt(dt_t **pdt)
+Logger::println("TypeInfoPointerDeclaration::llvmDefine() %s", toChars());
-{
+LOG_SCOPE;
-Logger::println("TypeInfoArrayDeclaration::toDt() %s", toChars());
+assert(tinfo->ty == Tpointer);
+TypePointer *tc = (TypePointer *)tinfo;
+LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfopointer);
+}
+void TypeInfoPointerDeclaration::toDt(dt_t **pdt)
+{
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoArrayDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoArrayDeclaration::llvmDeclare() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tarray);
 TypeDArray *tc = (TypeDArray *)tinfo;
-LLVM_D_Create_TypeInfoBase(tc->next, this, Type::typeinfoarray);
+LLVM_D_Declare_TypeInfoBase(this, Type::typeinfoarray);
 }
-/* ========================================================================= */
+void TypeInfoArrayDeclaration::llvmDefine()
+{
-void TypeInfoStaticArrayDeclaration::toDt(dt_t **pdt)
+Logger::println("TypeInfoArrayDeclaration::llvmDefine() %s", toChars());
+LOG_SCOPE;
+assert(tinfo->ty == Tarray);
+TypeDArray *tc = (TypeDArray *)tinfo;
+LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfoarray);
+}
+void TypeInfoArrayDeclaration::toDt(dt_t **pdt)
+{
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoStaticArrayDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoStaticArrayDeclaration::toDt() %s", toChars());
+LOG_SCOPE;
+// init typeinfo class
+ClassDeclaration* base = Type::typeinfostaticarray;
+DtoResolveClass(base);
+// get type of typeinfo class
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// create the symbol
+llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
+}
+void TypeInfoStaticArrayDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoStaticArrayDeclaration::toDt() %s", toChars());
 LOG_SCOPE;
 // init typeinfo class
 TypeSArray *tc = (TypeSArray *)tinfo;
 tc->next->getTypeInfo(NULL);
 // get symbol
 assert(tc->next->vtinfo);
-DtoForceConstInitDsymbol(tc->next->vtinfo);
+DtoForceDeclareDsymbol(tc->next->vtinfo);
 llvm::Constant* castbase = isaConstant(tc->next->vtinfo->llvmValue);
 castbase = llvm::ConstantExpr::getBitCast(castbase, stype->getElementType(1));
 sinits.push_back(castbase);
 // length
 sinits.push_back(DtoConstSize_t(tc->dim->toInteger()));
 // create the symbol
 llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
-llvm::GlobalVariable* gvar = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,tiInit,toChars(),gIR->module);
+isaGlobalVar(llvmValue)->setInitializer(tiInit);
+}
-llvmValue = gvar;
-}
+void TypeInfoStaticArrayDeclaration::toDt(dt_t **pdt)
+{
-/* ========================================================================= */
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoAssociativeArrayDeclaration::llvmDeclare()
+{
+assert(0 && "TypeInfoAssociativeArrayDeclaration");
+}
+void TypeInfoAssociativeArrayDeclaration::llvmDefine()
+{
+assert(0 && "TypeInfoAssociativeArrayDeclaration");
+}
 void TypeInfoAssociativeArrayDeclaration::toDt(dt_t **pdt)
 {
 assert(0 && "TypeInfoAssociativeArrayDeclaration");
 */
 }
 /* ========================================================================= */
-void TypeInfoFunctionDeclaration::toDt(dt_t **pdt)
+void TypeInfoFunctionDeclaration::llvmDeclare()
 {
 Logger::println("TypeInfoFunctionDeclaration::toDt() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tfunction);
 TypeFunction *tc = (TypeFunction *)tinfo;
-LLVM_D_Create_TypeInfoBase(tc->next, this, Type::typeinfofunction);
+LLVM_D_Declare_TypeInfoBase(this, Type::typeinfofunction);
 }
-/* ========================================================================= */
+void TypeInfoFunctionDeclaration::llvmDefine()
+{
-void TypeInfoDelegateDeclaration::toDt(dt_t **pdt)
+Logger::println("TypeInfoFunctionDeclaration::toDt() %s", toChars());
+LOG_SCOPE;
+assert(tinfo->ty == Tfunction);
+TypeFunction *tc = (TypeFunction *)tinfo;
+LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfofunction);
+}
+void TypeInfoFunctionDeclaration::toDt(dt_t **pdt)
+{
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoDelegateDeclaration::llvmDeclare()
 {
 Logger::println("TypeInfoDelegateDeclaration::toDt() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tdelegate);
 TypeDelegate *tc = (TypeDelegate *)tinfo;
-LLVM_D_Create_TypeInfoBase(tc->next->next, this, Type::typeinfodelegate);
+LLVM_D_Declare_TypeInfoBase(this, Type::typeinfodelegate);
 }
-/* ========================================================================= */
+void TypeInfoDelegateDeclaration::llvmDefine()
+{
-void TypeInfoStructDeclaration::toDt(dt_t **pdt)
+Logger::println("TypeInfoDelegateDeclaration::toDt() %s", toChars());
-{
+LOG_SCOPE;
-Logger::println("TypeInfoStructDeclaration::toDt() %s", toChars());
+assert(tinfo->ty == Tdelegate);
+TypeDelegate *tc = (TypeDelegate *)tinfo;
+LLVM_D_Define_TypeInfoBase(tc->next->next, this, Type::typeinfodelegate);
+}
+void TypeInfoDelegateDeclaration::toDt(dt_t **pdt)
+{
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoStructDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoStructDeclaration::llvmDeclare() %s", toChars());
+LOG_SCOPE;
+assert(tinfo->ty == Tstruct);
+TypeStruct *tc = (TypeStruct *)tinfo;
+StructDeclaration *sd = tc->sym;
+DtoResolveDsymbol(sd);
+ClassDeclaration* base = Type::typeinfostruct;
+DtoResolveClass(base);
+const llvm::StructType* stype = isaStruct(((TypeClass*)base->type)->llvmType->get());
+// create the symbol
+llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
+}
+void TypeInfoStructDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoStructDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tstruct);
 TypeStruct *tc = (TypeStruct *)tinfo;
 StructDeclaration *sd = tc->sym;
 // create the symbol
 llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,tiInit,toChars(),gIR->module);
-llvmValue = gvar;
+isaGlobalVar(llvmValue)->setInitializer(tiInit);
 }
-/* ========================================================================= */
+void TypeInfoStructDeclaration::toDt(dt_t **pdt)
+{
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoClassDeclaration::llvmDeclare()
+{
+Logger::println("TypeInfoClassDeclaration::llvmDeclare() %s", toChars());
+LOG_SCOPE;
+// init typeinfo class
+ClassDeclaration* base = Type::typeinfoclass;
+assert(base);
+DtoResolveClass(base);
+// get type of typeinfo class
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// create the symbol
+llvmValue = new llvm::GlobalVariable(stype,true,llvm::GlobalValue::WeakLinkage,NULL,toChars(),gIR->module);
+}
+void TypeInfoClassDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoClassDeclaration::llvmDefine() %s", toChars());
+LOG_SCOPE;
+// init typeinfo class
+ClassDeclaration* base = Type::typeinfoclass;
+assert(base);
+DtoForceConstInitDsymbol(base);
+// get type of typeinfo class
+const llvm::StructType* stype = isaStruct(base->type->llvmType->get());
+// initializer vector
+std::vector<llvm::Constant*> sinits;
+// first is always the vtable
+sinits.push_back(base->llvmVtbl);
+// get classinfo
+assert(tinfo->ty == Tclass);
+TypeClass *tc = (TypeClass *)tinfo;
+assert(tc->sym->llvmClass);
+sinits.push_back(tc->sym->llvmClass);
+// create the symbol
+llvm::Constant* tiInit = llvm::ConstantStruct::get(stype, sinits);
+isaGlobalVar(llvmValue)->setInitializer(tiInit);
+}
 void TypeInfoClassDeclaration::toDt(dt_t **pdt)
 {
-assert(0 && "TypeInfoClassDeclaration");
+assert(0);
+}
+/* ========================================================================= */
+void TypeInfoInterfaceDeclaration::llvmDeclare()
+{
+assert(0 && "TypeInfoTupleDeclaration");
+}
+void TypeInfoInterfaceDeclaration::llvmDefine()
+{
+assert(0 && "TypeInfoTupleDeclaration");
+}
+void TypeInfoInterfaceDeclaration::toDt(dt_t **pdt)
+{
+assert(0 && "TypeInfoInterfaceDeclaration");
 /*
-//printf("TypeInfoClassDeclaration::toDt() %s\n", tinfo->toChars());
+//printf("TypeInfoInterfaceDeclaration::toDt() %s\n", tinfo->toChars());
-dtxoff(pdt, Type::typeinfoclass->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoClass
+dtxoff(pdt, Type::typeinfointerface->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface
 dtdword(pdt, 0);                // monitor
 assert(tinfo->ty == Tclass);
 TypeClass *tc = (TypeClass *)tinfo;
 */
 }
 /* ========================================================================= */
-void TypeInfoInterfaceDeclaration::toDt(dt_t **pdt)
+void TypeInfoTupleDeclaration::llvmDeclare()
 {
-assert(0 && "TypeInfoInterfaceDeclaration");
+assert(0 && "TypeInfoTupleDeclaration");
+}
-/*
-//printf("TypeInfoInterfaceDeclaration::toDt() %s\n", tinfo->toChars());
+void TypeInfoTupleDeclaration::llvmDefine()
-dtxoff(pdt, Type::typeinfointerface->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface
+{
-dtdword(pdt, 0);                // monitor
+assert(0 && "TypeInfoTupleDeclaration");
+}
-assert(tinfo->ty == Tclass);
-TypeClass *tc = (TypeClass *)tinfo;
-Symbol *s;
-if (!tc->sym->vclassinfo)
-tc->sym->vclassinfo = new ClassInfoDeclaration(tc->sym);
-s = tc->sym->vclassinfo->toSymbol();
-dtxoff(pdt, s, 0, TYnptr);      // ClassInfo for tinfo
-*/
-}
-/* ========================================================================= */
 void TypeInfoTupleDeclaration::toDt(dt_t **pdt)
 {
 assert(0 && "TypeInfoTupleDeclaration");

Mercurial > projects > ldc

comparison gen/typinf.cpp @ 106:5b5194b25f33 trunk