Mercurial > projects > ldc
view gen/toobj.c @ 65:d4a678905d5e trunk
[svn r69] forgot std.stdarg
author | lindquist |
---|---|
date | Fri, 26 Oct 2007 15:14:51 +0200 |
parents | b688ad419f8c |
children | f918f3e2e99e |
line wrap: on
line source
// Copyright (c) 1999-2004 by Digital Mars // All Rights Reserved // written by Walter Bright // www.digitalmars.com // License for redistribution is by either the Artistic License // in artistic.txt, or the GNU General Public License in gnu.txt. // See the included readme.txt for details. #include <cstddef> #include <iostream> #include <fstream> #include "gen/llvm.h" #include "llvm/Analysis/Verifier.h" #include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachineRegistry.h" #include "mars.h" #include "module.h" #include "mtype.h" #include "declaration.h" #include "statement.h" #include "enum.h" #include "aggregate.h" #include "init.h" #include "attrib.h" #include "id.h" #include "import.h" #include "template.h" #include "scope.h" #include "gen/irstate.h" #include "gen/elem.h" #include "gen/logger.h" #include "gen/tollvm.h" #include "gen/arrays.h" ////////////////////////////////////////////////////////////////////////////////////////// void Module::genobjfile() { Logger::cout() << "Generating module: " << (md ? md->toChars() : toChars()) << '\n'; LOG_SCOPE; // start by deleting the old object file deleteObjFile(); // create a new ir state IRState ir; gIR = &ir; ir.dmodule = this; // name the module std::string mname(toChars()); if (md != 0) mname = md->toChars(); ir.module = new llvm::Module(mname); // set target stuff std::string target_triple(global.params.tt_arch); target_triple.append(global.params.tt_os); ir.module->setTargetTriple(target_triple); ir.module->setDataLayout(global.params.data_layout); gTargetData = new llvm::TargetData(ir.module); // process module members for (int k=0; k < members->dim; k++) { Dsymbol* dsym = (Dsymbol*)(members->data[k]); assert(dsym); dsym->toObjFile(); } delete gTargetData; gTargetData = 0; // emit the llvm main function if necessary if (ir.emitMain) { LLVM_DtoMain(); } // verify the llvm if (!global.params.novalidate) { std::string verifyErr; Logger::println("Verifying module..."); if (llvm::verifyModule(*ir.module,llvm::ReturnStatusAction,&verifyErr)) { error("%s", verifyErr.c_str()); fatal(); } else { Logger::println("Verification passed!"); } } // run passes // TODO // write bytecode { Logger::println("Writing LLVM bitcode\n"); std::ofstream bos(bcfile->name->toChars(), std::ios::binary); llvm::WriteBitcodeToFile(ir.module, bos); } // disassemble ? if (global.params.disassemble) { Logger::println("Writing LLVM asm to: %s\n", llfile->name->toChars()); std::ofstream aos(llfile->name->toChars()); ir.module->print(aos); } delete ir.module; gIR = NULL; } /* ================================================================== */ // Put out instance of ModuleInfo for this Module void Module::genmoduleinfo() { } /* ================================================================== */ void Dsymbol::toObjFile() { Logger::println("Ignoring Dsymbol::toObjFile for %s", toChars()); } /* ================================================================== */ void Declaration::toObjFile() { Logger::println("Ignoring Declaration::toObjFile for %s", toChars()); } /* ================================================================== */ /// Returns the LLVM style index from a DMD style offset void AggregateDeclaration::offsetToIndex(Type* t, unsigned os, std::vector<unsigned>& result) { Logger::println("checking for offset %u type %s:", os, t->toChars()); LOG_SCOPE; for (unsigned i=0; i<fields.dim; ++i) { VarDeclaration* vd = (VarDeclaration*)fields.data[i]; Type* vdtype = LLVM_DtoDType(vd->type); Logger::println("found %u type %s", vd->offset, vdtype->toChars()); if (os == vd->offset && vdtype == t) { result.push_back(i); return; } else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) { TypeStruct* ts = (TypeStruct*)vdtype; StructDeclaration* sd = ts->sym; result.push_back(i); sd->offsetToIndex(t, os - vd->offset, result); return; } } assert(0 && "Offset not found in any aggregate field"); } /* ================================================================== */ static unsigned LLVM_ClassOffsetToIndex(ClassDeclaration* cd, unsigned os, unsigned& idx) { // start at the bottom of the inheritance chain if (cd->baseClass != 0) { unsigned o = LLVM_ClassOffsetToIndex(cd->baseClass, os, idx); if (o != (unsigned)-1) return o; } // check this class unsigned i; for (i=0; i<cd->fields.dim; ++i) { VarDeclaration* vd = (VarDeclaration*)cd->fields.data[i]; if (os == vd->offset) return i+idx; } idx += i; return (unsigned)-1; } /// Returns the LLVM style index from a DMD style offset /// Handles class inheritance void ClassDeclaration::offsetToIndex(Type* t, unsigned os, std::vector<unsigned>& result) { unsigned idx = 0; unsigned r = LLVM_ClassOffsetToIndex(this, os, idx); assert(r != (unsigned)-1 && "Offset not found in any aggregate field"); result.push_back(r+1); // vtable is 0 } /* ================================================================== */ void InterfaceDeclaration::toObjFile() { Logger::println("Ignoring InterfaceDeclaration::toObjFile for %s", toChars()); } /* ================================================================== */ void StructDeclaration::toObjFile() { TypeStruct* ts = (TypeStruct*)LLVM_DtoDType(type); if (llvmType != 0) return; static int sdi = 0; Logger::print("StructDeclaration::toObjFile(%d): %s\n", sdi++, toChars()); LOG_SCOPE; gIR->structs.push_back(IRStruct(ts)); for (int k=0; k < members->dim; k++) { Dsymbol* dsym = (Dsymbol*)(members->data[k]); dsym->toObjFile(); } if (gIR->topstruct().fields.empty()) { gIR->topstruct().fields.push_back(llvm::Type::Int8Ty); gIR->topstruct().inits.push_back(llvm::ConstantInt::get(llvm::Type::Int8Ty, 0, false)); } llvm::StructType* structtype = llvm::StructType::get(gIR->topstruct().fields); // refine abstract types for stuff like: struct S{S* next;} if (gIR->topstruct().recty != 0) { llvm::PATypeHolder& pa = gIR->topstruct().recty; llvm::cast<llvm::OpaqueType>(pa.get())->refineAbstractTypeTo(structtype); structtype = llvm::cast<llvm::StructType>(pa.get()); } ts->llvmType = structtype; llvmType = structtype; if (parent->isModule()) { gIR->module->addTypeName(mangle(),ts->llvmType); } // generate static data llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::ExternalLinkage; llvm::Constant* _init = 0; // always generate the constant initalizer if (!zeroInit) { Logger::println("Not zero initialized"); //assert(tk == gIR->topstruct().size()); #ifndef LLVMD_NO_LOGGER Logger::cout() << *structtype << '\n'; for (size_t k=0; k<gIR->topstruct().inits.size(); ++k) { Logger::cout() << "Type:" << '\n'; Logger::cout() << *gIR->topstruct().inits[k]->getType() << '\n'; Logger::cout() << "Value:" << '\n'; Logger::cout() << *gIR->topstruct().inits[k] << '\n'; } Logger::cout() << "Initializer printed" << '\n'; #endif llvmInitZ = llvm::ConstantStruct::get(structtype,gIR->topstruct().inits); } else { Logger::println("Zero initialized"); llvmInitZ = llvm::ConstantAggregateZero::get(structtype); } // only provide the constant initializer for the defining module if (getModule() == gIR->dmodule) { _init = llvmInitZ; } std::string initname(mangle()); initname.append("__initZ"); llvm::GlobalVariable* initvar = new llvm::GlobalVariable(ts->llvmType, true, _linkage, _init, initname, gIR->module); ts->llvmInit = initvar; // generate member function definitions gIR->topstruct().queueFuncs = false; IRStruct::FuncDeclVec& mfs = gIR->topstruct().funcs; size_t n = mfs.size(); for (size_t i=0; i<n; ++i) { mfs[i]->toObjFile(); } llvmDModule = gIR->dmodule; gIR->structs.pop_back(); // generate typeinfo //type->getTypeInfo(NULL); } /* ================================================================== */ static void LLVM_AddBaseClassData(BaseClasses* bcs) { // add base class data members first for (int j=0; j<bcs->dim; j++) { BaseClass* bc = (BaseClass*)(bcs->data[j]); assert(bc); Logger::println("Adding base class members of %s", bc->base->toChars()); LOG_SCOPE; LLVM_AddBaseClassData(&bc->base->baseclasses); for (int k=0; k < bc->base->members->dim; k++) { Dsymbol* dsym = (Dsymbol*)(bc->base->members->data[k]); if (dsym->isVarDeclaration()) { dsym->toObjFile(); } } } } void ClassDeclaration::toObjFile() { TypeClass* ts = (TypeClass*)LLVM_DtoDType(type); if (ts->llvmType != 0 || llvmInProgress) return; llvmInProgress = true; static int fdi = 0; Logger::print("ClassDeclaration::toObjFile(%d): %s\n", fdi++, toChars()); LOG_SCOPE; gIR->structs.push_back(IRStruct(ts)); gIR->classes.push_back(this); // add vtable llvm::PATypeHolder pa = llvm::OpaqueType::get(); const llvm::Type* vtabty = llvm::PointerType::get(pa); gIR->topstruct().fields.push_back(vtabty); gIR->topstruct().inits.push_back(0); // base classes first LLVM_AddBaseClassData(&baseclasses); // then add own members for (int k=0; k < members->dim; k++) { Dsymbol* dsym = (Dsymbol*)(members->data[k]); dsym->toObjFile(); } llvm::StructType* structtype = llvm::StructType::get(gIR->topstruct().fields); // refine abstract types for stuff like: class C {C next;} if (gIR->topstruct().recty != 0) { llvm::PATypeHolder& pa = gIR->topstruct().recty; llvm::cast<llvm::OpaqueType>(pa.get())->refineAbstractTypeTo(structtype); structtype = llvm::cast<llvm::StructType>(pa.get()); } ts->llvmType = structtype; llvmType = structtype; bool needs_definition = false; if (parent->isModule()) { gIR->module->addTypeName(mangle(),ts->llvmType); needs_definition = (getModule() == gIR->dmodule); } else { assert(0 && "class parent is not a module"); } // generate vtable llvm::GlobalVariable* svtblVar = 0; std::vector<llvm::Constant*> sinits; std::vector<const llvm::Type*> sinits_ty; sinits.reserve(vtbl.dim); sinits_ty.reserve(vtbl.dim); for (int k=0; k < vtbl.dim; k++) { Dsymbol* dsym = (Dsymbol*)vtbl.data[k]; assert(dsym); //Logger::cout() << "vtblsym: " << dsym->toChars() << '\n'; if (FuncDeclaration* fd = dsym->isFuncDeclaration()) { fd->toObjFile(); assert(fd->llvmValue); llvm::Constant* c = llvm::cast<llvm::Constant>(fd->llvmValue); sinits.push_back(c); sinits_ty.push_back(c->getType()); } else if (ClassDeclaration* cd = dsym->isClassDeclaration()) { const llvm::Type* cty = llvm::PointerType::get(llvm::Type::Int8Ty); llvm::Constant* c = llvm::Constant::getNullValue(cty); sinits.push_back(c); sinits_ty.push_back(cty); } else assert(0); } const llvm::StructType* svtbl_ty = 0; if (!sinits.empty()) { llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::ExternalLinkage; std::string varname("_D"); varname.append(mangle()); varname.append("6__vtblZ"); std::string styname(mangle()); styname.append("__vtblTy"); svtbl_ty = llvm::StructType::get(sinits_ty); gIR->module->addTypeName(styname, svtbl_ty); svtblVar = new llvm::GlobalVariable(svtbl_ty, true, _linkage, 0, varname, gIR->module); llvmConstVtbl = llvm::cast<llvm::ConstantStruct>(llvm::ConstantStruct::get(svtbl_ty, sinits)); if (needs_definition) svtblVar->setInitializer(llvmConstVtbl); llvmVtbl = svtblVar; } //////////////////////////////////////////////////////////////////////////////// // refine for final vtable type llvm::cast<llvm::OpaqueType>(pa.get())->refineAbstractTypeTo(svtbl_ty); svtbl_ty = llvm::cast<llvm::StructType>(pa.get()); structtype = llvm::cast<llvm::StructType>(gIR->topstruct().recty.get()); ts->llvmType = structtype; llvmType = structtype; // generate initializer llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::ExternalLinkage; llvm::Constant* _init = 0; // first field is always the vtable assert(svtblVar != 0); gIR->topstruct().inits[0] = svtblVar; llvmInitZ = _init = llvm::ConstantStruct::get(structtype,gIR->topstruct().inits); assert(_init); std::string initname("_D"); initname.append(mangle()); initname.append("6__initZ"); //Logger::cout() << *_init << '\n'; llvm::GlobalVariable* initvar = new llvm::GlobalVariable(ts->llvmType, true, _linkage, NULL, initname, gIR->module); ts->llvmInit = initvar; if (needs_definition) { initvar->setInitializer(_init); // generate member functions gIR->topstruct().queueFuncs = false; IRStruct::FuncDeclVec& mfs = gIR->topstruct().funcs; size_t n = mfs.size(); for (size_t i=0; i<n; ++i) { mfs[i]->toObjFile(); } } gIR->classes.pop_back(); gIR->structs.pop_back(); llvmInProgress = false; } /****************************************** * Get offset of base class's vtbl[] initializer from start of csym. * Returns ~0 if not this csym. */ unsigned ClassDeclaration::baseVtblOffset(BaseClass *bc) { return ~0; } /* ================================================================== */ void VarDeclaration::toObjFile() { Logger::print("VarDeclaration::toObjFile(): %s | %s\n", toChars(), type->toChars()); LOG_SCOPE; llvm::Module* M = gIR->module; // handle bind pragma if (llvmInternal == LLVMbind) { Logger::println("var is bound: %s", llvmInternal1); llvmValue = M->getGlobalVariable(llvmInternal1); assert(llvmValue); return; } // global variable or magic if (isDataseg() || parent->isModule()) { if (llvmTouched) return; else llvmTouched = true; bool _isconst = isConst(); llvm::GlobalValue::LinkageTypes _linkage; if (parent && parent->isFuncDeclaration()) _linkage = llvm::GlobalValue::InternalLinkage; else _linkage = LLVM_DtoLinkage(protection, storage_class); Type* t = LLVM_DtoDType(type); const llvm::Type* _type = LLVM_DtoType(t); assert(_type); llvm::Constant* _init = 0; bool _signed = !type->isunsigned(); Logger::println("Creating global variable"); std::string _name(mangle()); llvm::GlobalVariable* gvar = new llvm::GlobalVariable(_type,_isconst,_linkage,0,_name,M); llvmValue = gvar; // if extern don't emit initializer if (!(storage_class & STCextern)) { _init = LLVM_DtoConstInitializer(t, init); //Logger::cout() << "initializer: " << *_init << '\n'; if (_type != _init->getType()) { Logger::cout() << "got type '" << *_init->getType() << "' expected '" << *_type << "'\n"; // zero initalizer if (_init->isNullValue()) _init = llvm::Constant::getNullValue(_type); // pointer to global constant (struct.init) else if (llvm::isa<llvm::GlobalVariable>(_init)) { assert(_init->getType()->getContainedType(0) == _type); llvm::GlobalVariable* gv = llvm::cast<llvm::GlobalVariable>(_init); assert(t->ty == Tstruct); TypeStruct* ts = (TypeStruct*)t; assert(ts->sym->llvmInitZ); _init = ts->sym->llvmInitZ; } // array single value init else if (llvm::isa<llvm::ArrayType>(_type)) { _init = LLVM_DtoConstantStaticArray(_type, _init); } else { Logger::cout() << "Unexpected initializer type: " << *_type << '\n'; //assert(0); } } Logger::cout() << "final init = " << *_init << '\n'; gvar->setInitializer(_init); } llvmDModule = gIR->dmodule; //if (storage_class & STCprivate) // gvar->setVisibility(llvm::GlobalValue::ProtectedVisibility); } // inside aggregate declaration. declare a field. else { Logger::println("Aggregate var declaration: '%s' offset=%d", toChars(), offset); Type* t = LLVM_DtoDType(type); const llvm::Type* _type = LLVM_DtoType(t); gIR->topstruct().fields.push_back(_type); llvm::Constant*_init = LLVM_DtoConstInitializer(t, init); assert(_init); Logger::cout() << "field init is: " << *_init << " type should be " << *_type << '\n'; if (_type != _init->getType()) { if (t->ty == Tsarray) { const llvm::ArrayType* arrty = llvm::cast<llvm::ArrayType>(_type); uint64_t n = arrty->getNumElements(); std::vector<llvm::Constant*> vals(n,_init); _init = llvm::ConstantArray::get(arrty, vals); } else if (t->ty == Tarray) { assert(llvm::isa<llvm::StructType>(_type)); _init = llvm::ConstantAggregateZero::get(_type); } else if (t->ty == Tstruct) { const llvm::StructType* structty = llvm::cast<llvm::StructType>(_type); TypeStruct* ts = (TypeStruct*)t; assert(ts); assert(ts->sym); assert(ts->sym->llvmInitZ); _init = ts->sym->llvmInitZ; } else if (t->ty == Tclass) { _init = llvm::Constant::getNullValue(_type); } else { Logger::println("failed for type %s", type->toChars()); assert(0); } } gIR->topstruct().inits.push_back(_init); } Logger::println("VarDeclaration::toObjFile is done"); } /* ================================================================== */ void TypedefDeclaration::toObjFile() { static int tdi = 0; Logger::print("TypedefDeclaration::toObjFile(%d): %s\n", tdi++, toChars()); LOG_SCOPE; // generate typeinfo if (!type->builtinTypeInfo()) type->getTypeInfo(NULL); } /* ================================================================== */ void EnumDeclaration::toObjFile() { Logger::println("Ignoring EnumDeclaration::toObjFile for %s", toChars()); } /* ================================================================== */ void FuncDeclaration::toObjFile() { if (llvmDModule) { assert(llvmValue != 0); return; } if (isUnitTestDeclaration()) { Logger::println("*** ATTENTION: ignoring unittest declaration: %s", toChars()); return; } Type* t = LLVM_DtoDType(type); TypeFunction* f = (TypeFunction*)t; bool declareOnly = false; if (TemplateInstance* tinst = parent->isTemplateInstance()) { TemplateDeclaration* tempdecl = tinst->tempdecl; if (tempdecl->llvmInternal == LLVMva_start) { Logger::println("magic va_start found"); llvmInternal = LLVMva_start; declareOnly = true; } else if (tempdecl->llvmInternal == LLVMva_arg) { Logger::println("magic va_arg found"); llvmInternal = LLVMva_arg; return; } } llvm::Function* func = LLVM_DtoDeclareFunction(this); if (declareOnly) return; if (!gIR->structs.empty() && gIR->topstruct().queueFuncs) { if (!llvmQueued) { Logger::println("queueing %s", toChars()); gIR->topstruct().funcs.push_back(this); llvmQueued = true; } return; // we wait with the definition as they might invoke a virtual method and the vtable is not yet complete } assert(f->llvmType); const llvm::FunctionType* functype = llvm::cast<llvm::FunctionType>(llvmValue->getType()->getContainedType(0)); // only members of the current module maybe be defined if (getModule() == gIR->dmodule || parent->isTemplateInstance()) { llvmDModule = gIR->dmodule; bool allow_fbody = true; // handle static constructor / destructor if (isStaticCtorDeclaration() || isStaticDtorDeclaration()) { const llvm::ArrayType* sctor_type = llvm::ArrayType::get(llvm::PointerType::get(functype),1); //Logger::cout() << "static ctor type: " << *sctor_type << '\n'; llvm::Constant* sctor_func = llvm::cast<llvm::Constant>(llvmValue); //Logger::cout() << "static ctor func: " << *sctor_func << '\n'; llvm::Constant* sctor_init = 0; if (llvmInternal == LLVMnull) { llvm::Constant* sctor_init_null = llvm::Constant::getNullValue(sctor_func->getType()); sctor_init = llvm::ConstantArray::get(sctor_type,&sctor_init_null,1); allow_fbody = false; } else { sctor_init = llvm::ConstantArray::get(sctor_type,&sctor_func,1); } //Logger::cout() << "static ctor init: " << *sctor_init << '\n'; // output the llvm.global_ctors array const char* varname = isStaticCtorDeclaration() ? "_d_module_ctor_array" : "_d_module_dtor_array"; llvm::GlobalVariable* sctor_arr = new llvm::GlobalVariable(sctor_type, false, llvm::GlobalValue::AppendingLinkage, sctor_init, varname, gIR->module); } // function definition if (allow_fbody && fbody != 0) { gIR->functions.push_back(IRFunction(this)); gIR->func().func = func; // first make absolutely sure the type is up to date f->llvmType = llvmValue->getType()->getContainedType(0); //Logger::cout() << "func type: " << *f->llvmType << '\n'; // this handling if (f->llvmUsesThis) { Logger::println("uses this"); if (f->llvmRetInPtr) llvmThisVar = ++func->arg_begin(); else llvmThisVar = func->arg_begin(); assert(llvmThisVar != 0); } if (isMain()) gIR->emitMain = true; llvm::BasicBlock* beginbb = new llvm::BasicBlock("entry",func); llvm::BasicBlock* endbb = new llvm::BasicBlock("endentry",func); //assert(gIR->scopes.empty()); gIR->scopes.push_back(IRScope(beginbb, endbb)); // create alloca point f->llvmAllocaPoint = new llvm::BitCastInst(llvm::ConstantInt::get(llvm::Type::Int32Ty,0,false),llvm::Type::Int32Ty,"alloca point",gIR->scopebb()); gIR->func().allocapoint = f->llvmAllocaPoint; llvm::Value* parentNested = NULL; if (FuncDeclaration* fd = toParent()->isFuncDeclaration()) { parentNested = fd->llvmNested; } // construct nested variables struct if (!llvmNestedVars.empty() || parentNested) { std::vector<const llvm::Type*> nestTypes; int j = 0; if (parentNested) { nestTypes.push_back(parentNested->getType()); j++; } for (std::set<VarDeclaration*>::iterator i=llvmNestedVars.begin(); i!=llvmNestedVars.end(); ++i) { VarDeclaration* vd = *i; vd->llvmNestedIndex = j++; nestTypes.push_back(LLVM_DtoType(vd->type)); } const llvm::StructType* nestSType = llvm::StructType::get(nestTypes); Logger::cout() << "nested var struct has type:" << '\n' << *nestSType; llvmNested = new llvm::AllocaInst(nestSType,"nestedvars",f->llvmAllocaPoint); if (parentNested) { assert(llvmThisVar); llvm::Value* ptr = gIR->ir->CreateBitCast(llvmThisVar, parentNested->getType(), "tmp"); gIR->ir->CreateStore(ptr, LLVM_DtoGEPi(llvmNested, 0,0, "tmp")); } } // copy _argptr to a memory location if (f->linkage == LINKd && f->varargs == 1) { llvm::Value* argptrmem = new llvm::AllocaInst(llvmArgPtr->getType(), "_argptrmem", gIR->topallocapoint()); new llvm::StoreInst(llvmArgPtr, argptrmem, gIR->scopebb()); llvmArgPtr = argptrmem; } // output function body fbody->toIR(gIR); // llvm requires all basic blocks to end with a TerminatorInst but DMD does not put a return statement // in automatically, so we do it here. if (!isMain()) { if (!gIR->scopereturned()) { // pass the previous block into this block //new llvm::BranchInst(irs.end, irs.begin); if (func->getReturnType() == llvm::Type::VoidTy) { new llvm::ReturnInst(gIR->scopebb()); } else { new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), gIR->scopebb()); } } } // erase alloca point f->llvmAllocaPoint->eraseFromParent(); f->llvmAllocaPoint = 0; gIR->func().allocapoint = 0; gIR->scopes.pop_back(); // get rid of the endentry block, it's never used assert(!func->getBasicBlockList().empty()); func->getBasicBlockList().pop_back(); // if the last block is empty now, it must be unreachable or it's a bug somewhere else // would be nice to figure out how to assert that this is correct llvm::BasicBlock* lastbb = &func->getBasicBlockList().back(); if (lastbb->empty()) { if (lastbb->getNumUses() == 0) lastbb->eraseFromParent(); else { new llvm::UnreachableInst(lastbb); /*if (func->getReturnType() == llvm::Type::VoidTy) { new llvm::ReturnInst(lastbb); } else { new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), lastbb); }*/ } } gIR->functions.pop_back(); } // template instances should have weak linkage if (parent->isTemplateInstance()) { func->setLinkage(llvm::GlobalValue::WeakLinkage); } } }