projects/ldc: gen/typinf.cpp comparison

comparison gen/typinf.cpp @ 1374:e630ff79e10d

Cleaned up TypeInfo generation, still need to do TypeInfo_Struct/Tuple. Eventually do ClassInfo and ModuleInfo as well using same interface.

author	Tomas Lindquist Olsen <tomas.l.olsen gmail com>
date	Sun, 17 May 2009 03:10:55 +0200
parents	8026319762be
children	63f4afd01036

comparison

equal deleted inserted replaced

-:551b01341728
+:e630ff79e10d
 #include "gen/arrays.h"
 #include "gen/structs.h"
 #include "gen/classes.h"
 #include "gen/linkage.h"
 #include "gen/metadata.h"
+#include "gen/rttibuilder.h"
 #include "ir/irvar.h"
 #include "ir/irtype.h"
 /*******************************************
 /* ========================================================================= */
 //////////////////////////////////////////////////////////////////////////////
 //                             MAGIC   PLACE
+//                                (wut?)
 //////////////////////////////////////////////////////////////////////////////
 void DtoResolveTypeInfo(TypeInfoDeclaration* tid);
 void DtoDeclareTypeInfo(TypeInfoDeclaration* tid);
-void DtoConstInitTypeInfo(TypeInfoDeclaration* tid);
 void TypeInfoDeclaration::codegen(Ir*)
 {
 DtoResolveTypeInfo(this);
 }
 tid->ir.declared = true;
 Logger::println("DtoDeclareTypeInfo(%s)", tid->toChars());
 LOG_SCOPE;
+if (Logger::enabled())
+{
+std::string mangled(tid->mangle());
+Logger::println("type = '%s'", tid->tinfo->toChars());
+Logger::println("typeinfo mangle: %s", mangled.c_str());
+}
 IrGlobal* irg = tid->ir.irGlobal;
-std::string mangled(tid->mangle());
-Logger::println("type = '%s'", tid->tinfo->toChars());
-Logger::println("typeinfo mangle: %s", mangled.c_str());
 assert(irg->value != NULL);
 // this is a declaration of a builtin __initZ var
 if (tid->tinfo->builtinTypeInfo()) {
 // fixup the global
-const llvm::Type* rty = Type::typeinfo->type->irtype->getPA().get();
+const llvm::Type* rty = Type::typeinfo->type->irtype->getPA();
 llvm::cast<llvm::OpaqueType>(irg->type.get())->refineAbstractTypeTo(rty);
 LLGlobalVariable* g = isaGlobalVar(irg->value);
 g->setLinkage(llvm::GlobalValue::ExternalLinkage);
 return;
 }
-// custom typedef
+// define custom typedef
-DtoConstInitTypeInfo(tid);
-}
-void DtoConstInitTypeInfo(TypeInfoDeclaration* tid)
-{
-if (tid->ir.initialized) return;
-tid->ir.initialized = true;
-Logger::println("DtoConstInitTypeInfo(%s)", tid->toChars());
-LOG_SCOPE;
 tid->llvmDefine();
 }
 /* ========================================================================= */
 void TypeInfoDeclaration::llvmDefine()
 {
-assert(0 && "TypeInfoDeclaration::llvmDeclare");
+assert(0 && "cannot generate generic typeinfo");
 }
 /* ========================================================================= */
 void TypeInfoTypedefDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoTypedefDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-ClassDeclaration* base = Type::typeinfotypedef;
+TypeInfoBuilder b(Type::typeinfotypedef);
-base->codegen(Type::sir);
-// vtbl
-std::vector<LLConstant*> sinits;
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(getNullPtr(getPtrToType(LLType::Int8Ty)));
 assert(tinfo->ty == Ttypedef);
 TypeTypedef *tc = (TypeTypedef *)tinfo;
 TypedefDeclaration *sd = tc->sym;
 // TypeInfo base
-sd->basetype = sd->basetype->merge(); // DMD does this!
+sd->basetype = sd->basetype->merge(); // dmd does it ... why?
-LLConstant* castbase = DtoTypeInfoOf(sd->basetype, true);
+b.push_typeinfo(sd->basetype);
-sinits.push_back(castbase);
 // char[] name
-char *name = sd->toPrettyChars();
+b.push_string(sd->toPrettyChars());
-sinits.push_back(DtoConstString(name));
 // void[] init
-const LLPointerType* initpt = getPtrToType(LLType::Int8Ty);
+// emit null array if we should use the basetype, or if the basetype
-if (tinfo->isZeroInit() || !sd->init) // 0 initializer, or the same as the base type
+// uses default initialization.
-{
+if (!sd->init || tinfo->isZeroInit(0))
-sinits.push_back(DtoConstSlice(DtoConstSize_t(0), getNullPtr(initpt)));
+{
-}
+b.push_null_void_array();
+}
+// otherwise emit a void[] with the default initializer
 else
 {
-LLConstant* ci = DtoConstInitializer(sd->loc, sd->basetype, sd->init);
+LLConstant* C = DtoConstInitializer(sd->loc, sd->basetype, sd->init);
-std::string ciname(sd->mangle());
+b.push_void_array(C, sd->basetype, sd);
-ciname.append("__init");
+}
-llvm::GlobalVariable* civar = new llvm::GlobalVariable(DtoType(sd->basetype),true,llvm::GlobalValue::InternalLinkage,ci,ciname,gIR->module);
-LLConstant* cicast = llvm::ConstantExpr::getBitCast(civar, initpt);
+// finish
-size_t cisize = getTypeStoreSize(DtoType(sd->basetype));
+b.finalize(ir.irGlobal);
-sinits.push_back(DtoConstSlice(DtoConstSize_t(cisize), cicast));
-}
-// create the inititalizer
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
 }
 /* ========================================================================= */
 void TypeInfoEnumDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoEnumDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-ClassDeclaration* base = Type::typeinfoenum;
+TypeInfoBuilder b(Type::typeinfoenum);
-base->codegen(Type::sir);
-// vtbl
-std::vector<LLConstant*> sinits;
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
 assert(tinfo->ty == Tenum);
 TypeEnum *tc = (TypeEnum *)tinfo;
 EnumDeclaration *sd = tc->sym;
 // TypeInfo base
-LLConstant* castbase = DtoTypeInfoOf(sd->memtype, true);
+b.push_typeinfo(sd->memtype);
-sinits.push_back(castbase);
 // char[] name
-char *name = sd->toPrettyChars();
+b.push_string(sd->toPrettyChars());
-sinits.push_back(DtoConstString(name));
 // void[] init
-const LLPointerType* initpt = getPtrToType(LLType::Int8Ty);
+// emit void[] with the default initialier, the array is null if the default
-if (tinfo->isZeroInit() || !sd->defaultval) // 0 initializer, or the same as the base type
+// initializer is zero
-{
+if (!sd->defaultval || tinfo->isZeroInit(0))
-sinits.push_back(DtoConstSlice(DtoConstSize_t(0), llvm::ConstantPointerNull::get(initpt)));
+{
-}
+b.push_null_void_array();
+}
+// otherwise emit a void[] with the default initializer
 else
 {
-#if DMDV2
-assert(0 && "initializer not implemented");
-#else
 const LLType* memty = DtoType(sd->memtype);
-LLConstant* ci = llvm::ConstantInt::get(memty, sd->defaultval, !sd->memtype->isunsigned());
+LLConstant* C = llvm::ConstantInt::get(memty, sd->defaultval, !sd->memtype->isunsigned());
-std::string ciname(sd->mangle());
+b.push_void_array(C, sd->memtype, sd);
-ciname.append("__init");
+}
-llvm::GlobalVariable* civar = new llvm::GlobalVariable(memty,true,llvm::GlobalValue::InternalLinkage,ci,ciname,gIR->module);
-LLConstant* cicast = llvm::ConstantExpr::getBitCast(civar, initpt);
+// finish
-size_t cisize = getTypeStoreSize(memty);
+b.finalize(ir.irGlobal);
-sinits.push_back(DtoConstSlice(DtoConstSize_t(cisize), cicast));
-#endif
-}
-// create the inititalizer
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
-}
-/* ========================================================================= */
-static void LLVM_D_Define_TypeInfoBase(Type* basetype, TypeInfoDeclaration* tid, ClassDeclaration* cd)
-{
-ClassDeclaration* base = cd;
-base->codegen(Type::sir);
-// vtbl
-std::vector<LLConstant*> sinits;
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
-// TypeInfo base
-LLConstant* castbase = DtoTypeInfoOf(basetype, true);
-sinits.push_back(castbase);
-// create the inititalizer
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(tid->ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(tid->ir.irGlobal->value)->setInitializer(tiInit);
 }
 /* ========================================================================= */
 void TypeInfoPointerDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoPointerDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-assert(tinfo->ty == Tpointer);
+TypeInfoBuilder b(Type::typeinfopointer);
-TypePointer *tc = (TypePointer *)tinfo;
+// TypeInfo base
+b.push_typeinfo(tinfo->nextOf());
-LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfopointer);
+// finish
+b.finalize(ir.irGlobal);
 }
 /* ========================================================================= */
 void TypeInfoArrayDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoArrayDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-assert(tinfo->ty == Tarray);
+TypeInfoBuilder b(Type::typeinfoarray);
-TypeDArray *tc = (TypeDArray *)tinfo;
+// TypeInfo base
+b.push_typeinfo(tinfo->nextOf());
-LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfoarray);
+// finish
+b.finalize(ir.irGlobal);
 }
 /* ========================================================================= */
 void TypeInfoStaticArrayDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoStaticArrayDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-// init typeinfo class
-ClassDeclaration* base = Type::typeinfostaticarray;
-base->codegen(Type::sir);
-// get type of typeinfo class
-const LLStructType* stype = isaStruct(base->type->irtype->getPA().get());
-// initializer vector
-std::vector<LLConstant*> sinits;
-// first is always the vtable
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
-// value typeinfo
 assert(tinfo->ty == Tsarray);
 TypeSArray *tc = (TypeSArray *)tinfo;
-LLConstant* castbase = DtoTypeInfoOf(tc->next, true);
-assert(castbase->getType() == stype->getElementType(2));
+TypeInfoBuilder b(Type::typeinfostaticarray);
-sinits.push_back(castbase);
+// value typeinfo
+b.push_typeinfo(tc->nextOf());
 // length
-sinits.push_back(DtoConstSize_t(tc->dim->toInteger()));
+b.push(DtoConstSize_t((size_t)tc->dim->toUInteger()));
-// create the inititalizer
+// finish
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
+b.finalize(ir.irGlobal);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
 }
 /* ========================================================================= */
 void TypeInfoAssociativeArrayDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoAssociativeArrayDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-// init typeinfo class
-ClassDeclaration* base = Type::typeinfoassociativearray;
-base->codegen(Type::sir);
-// initializer vector
-std::vector<LLConstant*> sinits;
-// first is always the vtable
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
-// get type
 assert(tinfo->ty == Taarray);
 TypeAArray *tc = (TypeAArray *)tinfo;
+TypeInfoBuilder b(Type::typeinfoassociativearray);
 // value typeinfo
-LLConstant* castbase = DtoTypeInfoOf(tc->next, true);
+b.push_typeinfo(tc->nextOf());
-sinits.push_back(castbase);
 // key typeinfo
-castbase = DtoTypeInfoOf(tc->index, true);
+b.push_typeinfo(tc->index);
-sinits.push_back(castbase);
+// finish
-// create the inititalizer
+b.finalize(ir.irGlobal);
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
 }
 /* ========================================================================= */
 void TypeInfoFunctionDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoFunctionDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-assert(tinfo->ty == Tfunction);
+TypeInfoBuilder b(Type::typeinfofunction);
-TypeFunction *tc = (TypeFunction *)tinfo;
+// TypeInfo base
+b.push_typeinfo(tinfo->nextOf());
-LLVM_D_Define_TypeInfoBase(tc->next, this, Type::typeinfofunction);
+// finish
+b.finalize(ir.irGlobal);
 }
 /* ========================================================================= */
 void TypeInfoDelegateDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoDelegateDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
 assert(tinfo->ty == Tdelegate);
-TypeDelegate *tc = (TypeDelegate *)tinfo;
+Type* ret_type = tinfo->nextOf()->nextOf();
-LLVM_D_Define_TypeInfoBase(tc->nextOf()->nextOf(), this, Type::typeinfodelegate);
+TypeInfoBuilder b(Type::typeinfodelegate);
+// TypeInfo base
+b.push_typeinfo(ret_type);
+// finish
+b.finalize(ir.irGlobal);
 }
 /* ========================================================================= */
 void TypeInfoStructDeclaration::llvmDefine()
 // make sure class is resolved
 assert(tinfo->ty == Tclass);
 TypeClass *tc = (TypeClass *)tinfo;
 tc->sym->codegen(Type::sir);
+TypeInfoBuilder b(Type::typeinfoclass);
+// TypeInfo base
+b.push_classinfo(tc->sym);
+// finish
+b.finalize(ir.irGlobal);
+}
+/* ========================================================================= */
+void TypeInfoInterfaceDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoInterfaceDeclaration::llvmDefine() %s", toChars());
+LOG_SCOPE;
+// make sure interface is resolved
+assert(tinfo->ty == Tclass);
+TypeClass *tc = (TypeClass *)tinfo;
+tc->sym->codegen(Type::sir);
+TypeInfoBuilder b(Type::typeinfointerface);
+// TypeInfo base
+b.push_classinfo(tc->sym);
+// finish
+b.finalize(ir.irGlobal);
+}
+/* ========================================================================= */
+void TypeInfoTupleDeclaration::llvmDefine()
+{
+Logger::println("TypeInfoTupleDeclaration::llvmDefine() %s", toChars());
+LOG_SCOPE;
 // init typeinfo class
-ClassDeclaration* base = Type::typeinfoclass;
+ClassDeclaration* base = Type::typeinfotypelist;
 assert(base);
 base->codegen(Type::sir);
+// get type of typeinfo class
+const LLStructType* stype = isaStruct(base->type->irtype->getPA());
 // initializer vector
 std::vector<LLConstant*> sinits;
 // first is always the vtable
 sinits.push_back(base->ir.irStruct->getVtblSymbol());
 // monitor
 sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
-// get classinfo
-sinits.push_back(tc->sym->ir.irStruct->getClassInfoSymbol());
-// create the inititalizer
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
-}
-/* ========================================================================= */
-void TypeInfoInterfaceDeclaration::llvmDefine()
-{
-Logger::println("TypeInfoInterfaceDeclaration::llvmDefine() %s", toChars());
-LOG_SCOPE;
-// make sure interface is resolved
-assert(tinfo->ty == Tclass);
-TypeClass *tc = (TypeClass *)tinfo;
-tc->sym->codegen(Type::sir);
-// init typeinfo class
-ClassDeclaration* base = Type::typeinfointerface;
-assert(base);
-base->codegen(Type::sir);
-// get type of typeinfo class
-const LLStructType* stype = isaStruct(base->type->irtype->getPA());
-// initializer vector
-std::vector<LLConstant*> sinits;
-// first is always the vtable
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
-// get classinfo
-sinits.push_back(tc->sym->ir.irStruct->getClassInfoSymbol());
-// create the inititalizer
-LLConstant* tiInit = llvm::ConstantStruct::get(sinits);
-// refine global type
-llvm::cast<llvm::OpaqueType>(ir.irGlobal->type.get())->refineAbstractTypeTo(tiInit->getType());
-// set the initializer
-isaGlobalVar(ir.irGlobal->value)->setInitializer(tiInit);
-}
-/* ========================================================================= */
-void TypeInfoTupleDeclaration::llvmDefine()
-{
-Logger::println("TypeInfoTupleDeclaration::llvmDefine() %s", toChars());
-LOG_SCOPE;
-// init typeinfo class
-ClassDeclaration* base = Type::typeinfotypelist;
-assert(base);
-base->codegen(Type::sir);
-// get type of typeinfo class
-const LLStructType* stype = isaStruct(base->type->irtype->getPA());
-// initializer vector
-std::vector<LLConstant*> sinits;
-// first is always the vtable
-sinits.push_back(base->ir.irStruct->getVtblSymbol());
-// monitor
-sinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(LLType::Int8Ty)));
 // create elements array
 assert(tinfo->ty == Ttuple);
 TypeTuple *tu = (TypeTuple *)tinfo;
 size_t dim = tu->arguments->dim;
 void TypeInfoConstDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoConstDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-Type *tm = tinfo->mutableOf();
+TypeInfoBuilder b(Type::typeinfoconst);
-tm = tm->merge();
+// TypeInfo base
+b.push_typeinfo(tinfo->mutableOf()->merge());
-LLVM_D_Define_TypeInfoBase(tm, this, Type::typeinfoconst);
+// finish
+b.finalize(ir.irGlobal);
 }
 /* ========================================================================= */
 void TypeInfoInvariantDeclaration::llvmDefine()
 {
 Logger::println("TypeInfoInvariantDeclaration::llvmDefine() %s", toChars());
 LOG_SCOPE;
-Type *tm = tinfo->mutableOf();
+TypeInfoBuilder b(Type::typeinfoinvariant);
-tm = tm->merge();
+// TypeInfo base
+b.push_typeinfo(tinfo->mutableOf()->merge());
-LLVM_D_Define_TypeInfoBase(tm, this, Type::typeinfoinvariant);
+// finish
-}
+b.finalize(ir.irGlobal);
+}
-#endif
+#endif

Mercurial > projects > ldc

comparison gen/typinf.cpp @ 1374:e630ff79e10d