static llvm::GlobalValue::LinkageTypes lowerFuncLinkage(FuncDeclaration* fdecl)
{
// Intrinsics are always external.
if (fdecl->llvmInternal == LLVMintrinsic)
return llvm::GlobalValue::ExternalLinkage;
// Generated array op functions behave like templates in that they might be
// emitted into many different modules.
if (fdecl->isArrayOp && !isDruntimeArrayOp(fdecl))
return templateLinkage;
// A body-less declaration always needs to be marked as external in LLVM
// (also e.g. naked template functions which would otherwise be weak_odr,
// but where the definition is in module-level inline asm).
if (!fdecl->fbody || fdecl->naked)
return llvm::GlobalValue::ExternalLinkage;
return DtoLinkage(fdecl);
}
void FuncDeclaration_toObjFile(FuncDeclaration *fd, bool multiobj)
{
ClassDeclaration *cd = fd->parent->isClassDeclaration();
//printf("FuncDeclaration::toObjFile(%p, %s.%s)\n", fd, fd->parent->toChars(), fd->toChars());
//if (type) printf("type = %s\n", type->toChars());
#if 0
//printf("line = %d\n", getWhere() / LINEINC);
EEcontext *ee = env->getEEcontext();
if (ee->EEcompile == 2)
{
if (ee->EElinnum < (getWhere() / LINEINC) ||
ee->EElinnum > (endwhere / LINEINC)
)
return; // don't compile this function
ee->EEfunc = toSymbol(this);
}
#endif
if (fd->semanticRun >= PASSobj) // if toObjFile() already run
return;
if (fd->type && fd->type->ty == Tfunction && ((TypeFunction *)fd->type)->next == NULL)
return;
// If errors occurred compiling it, such as bugzilla 6118
if (fd->type && fd->type->ty == Tfunction && ((TypeFunction *)fd->type)->next->ty == Terror)
return;
if (global.errors)
return;
if (!fd->fbody)
return;
UnitTestDeclaration *ud = fd->isUnitTestDeclaration();
if (ud && !global.params.useUnitTests)
return;
if (multiobj && !fd->isStaticDtorDeclaration() && !fd->isStaticCtorDeclaration())
{
obj_append(fd);
return;
}
if (fd->semanticRun == PASSsemanticdone)
{
/* What happened is this function failed semantic3() with errors,
* but the errors were gagged.
* Try to reproduce those errors, and then fail.
*/
fd->error("errors compiling the function");
return;
}
assert(fd->semanticRun == PASSsemantic3done);
assert(fd->ident != Id::empty);
for (FuncDeclaration *fd2 = fd; fd2; )
{
if (fd2->inNonRoot())
return;
if (fd2->isNested())
fd2 = fd2->toParent2()->isFuncDeclaration();
else
break;
}
FuncDeclaration *fdp = fd->toParent2()->isFuncDeclaration();
if (fd->isNested())
{
if (fdp && fdp->semanticRun < PASSobj)
{
if (fdp->semantic3Errors)
return;
/* Can't do unittest's out of order, they are order dependent in that their
* execution is done in lexical order.
*/
if (UnitTestDeclaration *udp = fdp->isUnitTestDeclaration())
{
udp->deferredNested.push(fd);
return;
}
}
}
if (fd->isArrayOp && isDruntimeArrayOp(fd->ident))
{
// Implementation is in druntime
return;
}
// start code generation
fd->semanticRun = PASSobj;
if (global.params.verbose)
fprintf(global.stdmsg, "function %s\n", fd->toPrettyChars());
Symbol *s = toSymbol(fd);
func_t *f = s->Sfunc;
// tunnel type of "this" to debug info generation
if (AggregateDeclaration* ad = fd->parent->isAggregateDeclaration())
{
::type* t = Type_toCtype(ad->getType());
if (cd)
t = t->Tnext; // skip reference
f->Fclass = (Classsym *)t;
}
#if TARGET_WINDOS
/* This is done so that the 'this' pointer on the stack is the same
* distance away from the function parameters, so that an overriding
* function can call the nested fdensure or fdrequire of its overridden function
* and the stack offsets are the same.
*/
if (fd->isVirtual() && (fd->fensure || fd->frequire))
f->Fflags3 |= Ffakeeh;
#endif
#if TARGET_OSX
s->Sclass = SCcomdat;
#else
s->Sclass = SCglobal;
#endif
for (Dsymbol *p = fd->parent; p; p = p->parent)
{
if (p->isTemplateInstance())
{
s->Sclass = SCcomdat;
break;
}
}
/* Vector operations should be comdat's
*/
if (fd->isArrayOp)
s->Sclass = SCcomdat;
if (fd->isNested())
{
//if (!(config.flags3 & CFG3pic))
// s->Sclass = SCstatic;
f->Fflags3 |= Fnested;
/* The enclosing function must have its code generated first,
* in order to calculate correct frame pointer offset.
*/
if (fdp && fdp->semanticRun < PASSobj)
{
toObjFile(fdp, multiobj);
}
}
else
{
const char *libname = (global.params.symdebug)
? global.params.debuglibname
: global.params.defaultlibname;
// Pull in RTL startup code (but only once)
if (fd->isMain() && onlyOneMain(fd->loc))
{
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
objmod->external_def("_main");
objmod->ehsections(); // initialize exception handling sections
#endif
#if TARGET_WINDOS
if (global.params.mscoff)
{
objmod->external_def("main");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("_main");
objmod->external_def("__acrtused_con");
}
#endif
objmod->includelib(libname);
s->Sclass = SCglobal;
}
else if (strcmp(s->Sident, "main") == 0 && fd->linkage == LINKc)
{
#if TARGET_WINDOS
if (global.params.mscoff)
{
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
}
else
{
objmod->external_def("__acrtused_con"); // bring in C startup code
objmod->includelib("snn.lib"); // bring in C runtime library
}
#endif
s->Sclass = SCglobal;
}
#if TARGET_WINDOS
else if (fd->isWinMain() && onlyOneMain(fd->loc))
{
if (global.params.mscoff)
{
objmod->includelib("uuid");
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("__acrtused");
}
objmod->includelib(libname);
s->Sclass = SCglobal;
}
// Pull in RTL startup code
else if (fd->isDllMain() && onlyOneMain(fd->loc))
{
if (global.params.mscoff)
{
objmod->includelib("uuid");
objmod->includelib("LIBCMT");
objmod->includelib("OLDNAMES");
objmod->ehsections(); // initialize exception handling sections
}
else
{
objmod->external_def("__acrtused_dll");
}
objmod->includelib(libname);
s->Sclass = SCglobal;
}
#endif
}
symtab_t *symtabsave = cstate.CSpsymtab;
cstate.CSpsymtab = &f->Flocsym;
// Find module m for this function
Module *m = NULL;
for (Dsymbol *p = fd->parent; p; p = p->parent)
{
m = p->isModule();
if (m)
break;
}
IRState irs(m, fd);
Dsymbols deferToObj; // write these to OBJ file later
irs.deferToObj = &deferToObj;
symbol *shidden = NULL;
Symbol *sthis = NULL;
tym_t tyf = tybasic(s->Stype->Tty);
//printf("linkage = %d, tyf = x%x\n", linkage, tyf);
int reverse = tyrevfunc(s->Stype->Tty);
assert(fd->type->ty == Tfunction);
TypeFunction *tf = (TypeFunction *)fd->type;
RET retmethod = retStyle(tf);
if (retmethod == RETstack)
{
// If function returns a struct, put a pointer to that
// as the first argument
::type *thidden = Type_toCtype(tf->next->pointerTo());
char hiddenparam[5+4+1];
static int hiddenparami; // how many we've generated so far
sprintf(hiddenparam,"__HID%d",++hiddenparami);
shidden = symbol_name(hiddenparam,SCparameter,thidden);
shidden->Sflags |= SFLtrue | SFLfree;
if (fd->nrvo_can && fd->nrvo_var && fd->nrvo_var->nestedrefs.dim)
type_setcv(&shidden->Stype, shidden->Stype->Tty | mTYvolatile);
irs.shidden = shidden;
fd->shidden = shidden;
}
else
{
// Register return style cannot make nrvo.
// Auto functions keep the nrvo_can flag up to here,
// so we should eliminate it before entering backend.
fd->nrvo_can = 0;
}
if (fd->vthis)
{
assert(!fd->vthis->csym);
sthis = toSymbol(fd->vthis);
irs.sthis = sthis;
if (!(f->Fflags3 & Fnested))
f->Fflags3 |= Fmember;
}
// Estimate number of parameters, pi
size_t pi = (fd->v_arguments != NULL);
if (fd->parameters)
pi += fd->parameters->dim;
// Create a temporary buffer, params[], to hold function parameters
Symbol *paramsbuf[10];
Symbol **params = paramsbuf; // allocate on stack if possible
if (pi + 2 > 10) // allow extra 2 for sthis and shidden
{
params = (Symbol **)malloc((pi + 2) * sizeof(Symbol *));
assert(params);
}
// Get the actual number of parameters, pi, and fill in the params[]
pi = 0;
if (fd->v_arguments)
{
params[pi] = toSymbol(fd->v_arguments);
pi += 1;
}
if (fd->parameters)
{
for (size_t i = 0; i < fd->parameters->dim; i++)
{
VarDeclaration *v = (*fd->parameters)[i];
//printf("param[%d] = %p, %s\n", i, v, v->toChars());
assert(!v->csym);
params[pi + i] = toSymbol(v);
}
pi += fd->parameters->dim;
}
if (reverse)
{
// Reverse params[] entries
for (size_t i = 0; i < pi/2; i++)
{
Symbol *sptmp = params[i];
params[i] = params[pi - 1 - i];
params[pi - 1 - i] = sptmp;
}
}
if (shidden)
{
#if 0
// shidden becomes last parameter
params[pi] = shidden;
#else
// shidden becomes first parameter
memmove(params + 1, params, pi * sizeof(params[0]));
params[0] = shidden;
#endif
pi++;
}
if (sthis)
{
#if 0
// sthis becomes last parameter
params[pi] = sthis;
#else
// sthis becomes first parameter
memmove(params + 1, params, pi * sizeof(params[0]));
params[0] = sthis;
#endif
pi++;
}
if ((global.params.isLinux || global.params.isOSX || global.params.isFreeBSD || global.params.isSolaris) &&
fd->linkage != LINKd && shidden && sthis)
{
/* swap shidden and sthis
*/
Symbol *sp = params[0];
params[0] = params[1];
params[1] = sp;
}
for (size_t i = 0; i < pi; i++)
{
Symbol *sp = params[i];
sp->Sclass = SCparameter;
sp->Sflags &= ~SFLspill;
sp->Sfl = FLpara;
symbol_add(sp);
}
// Determine register assignments
if (pi)
{
FuncParamRegs fpr(tyf);
for (size_t i = 0; i < pi; i++)
{
Symbol *sp = params[i];
if (fpr.alloc(sp->Stype, sp->Stype->Tty, &sp->Spreg, &sp->Spreg2))
{
sp->Sclass = (config.exe == EX_WIN64) ? SCshadowreg : SCfastpar;
sp->Sfl = (sp->Sclass == SCshadowreg) ? FLpara : FLfast;
}
}
}
// Done with params
if (params != paramsbuf)
free(params);
params = NULL;
if (fd->fbody)
{
localgot = NULL;
Statement *sbody = fd->fbody;
Blockx bx;
memset(&bx,0,sizeof(bx));
bx.startblock = block_calloc();
bx.curblock = bx.startblock;
bx.funcsym = s;
bx.scope_index = -1;
bx.classdec = cd;
bx.member = fd;
bx.module = fd->getModule();
irs.blx = &bx;
/* Doing this in semantic3() caused all kinds of problems:
* 1. couldn't reliably get the final mangling of the function name due to fwd refs
* 2. impact on function inlining
* 3. what to do when writing out .di files, or other pretty printing
*/
if (global.params.trace && !fd->isCMain())
{
/* The profiler requires TLS, and TLS may not be set up yet when C main()
* gets control (i.e. OSX), leading to a crash.
*/
/* Wrap the entire function body in:
* trace_pro("funcname");
* try
* body;
* finally
* _c_trace_epi();
*/
StringExp *se = StringExp::create(Loc(), s->Sident);
se->type = Type::tstring;
se->type = se->type->semantic(Loc(), NULL);
Expressions *exps = Expressions_create();
exps->push(se);
FuncDeclaration *fdpro = FuncDeclaration::genCfunc(NULL, Type::tvoid, "trace_pro");
Expression *ec = VarExp::create(Loc(), fdpro);
Expression *e = CallExp::create(Loc(), ec, exps);
e->type = Type::tvoid;
Statement *sp = ExpStatement::create(fd->loc, e);
FuncDeclaration *fdepi = FuncDeclaration::genCfunc(NULL, Type::tvoid, "_c_trace_epi");
ec = VarExp::create(Loc(), fdepi);
e = CallExp::create(Loc(), ec);
e->type = Type::tvoid;
Statement *sf = ExpStatement::create(fd->loc, e);
Statement *stf;
if (sbody->blockExit(fd, false) == BEfallthru)
stf = CompoundStatement::create(Loc(), sbody, sf);
else
stf = TryFinallyStatement::create(Loc(), sbody, sf);
sbody = CompoundStatement::create(Loc(), sp, stf);
}
buildClosure(fd, &irs);
#if TARGET_WINDOS
if (fd->isSynchronized() && cd && config.flags2 & CFG2seh &&
!fd->isStatic() && !sbody->usesEH() && !global.params.trace)
{
/* The "jmonitor" hack uses an optimized exception handling frame
* which is a little shorter than the more general EH frame.
*/
s->Sfunc->Fflags3 |= Fjmonitor;
}
#endif
Statement_toIR(sbody, &irs);
bx.curblock->BC = BCret;
f->Fstartblock = bx.startblock;
// einit = el_combine(einit,bx.init);
if (fd->isCtorDeclaration())
{
assert(sthis);
for (block *b = f->Fstartblock; b; b = b->Bnext)
{
if (b->BC == BCret)
{
b->BC = BCretexp;
b->Belem = el_combine(b->Belem, el_var(sthis));
}
}
}
}
// If static constructor
if (fd->isSharedStaticCtorDeclaration()) // must come first because it derives from StaticCtorDeclaration
{
ssharedctors.push(s);
}
else if (fd->isStaticCtorDeclaration())
{
sctors.push(s);
}
// If static destructor
if (fd->isSharedStaticDtorDeclaration()) // must come first because it derives from StaticDtorDeclaration
{
SharedStaticDtorDeclaration *f = fd->isSharedStaticDtorDeclaration();
assert(f);
if (f->vgate)
{
/* Increment destructor's vgate at construction time
*/
esharedctorgates.push(f);
}
sshareddtors.shift(s);
}
else if (fd->isStaticDtorDeclaration())
{
StaticDtorDeclaration *f = fd->isStaticDtorDeclaration();
assert(f);
if (f->vgate)
{
/* Increment destructor's vgate at construction time
*/
ectorgates.push(f);
}
sdtors.shift(s);
}
// If unit test
if (ud)
{
stests.push(s);
}
if (global.errors)
{
// Restore symbol table
cstate.CSpsymtab = symtabsave;
return;
}
writefunc(s);
// Restore symbol table
cstate.CSpsymtab = symtabsave;
if (fd->isExport())
objmod->export_symbol(s, Para.offset);
for (size_t i = 0; i < irs.deferToObj->dim; i++)
{
Dsymbol *s = (*irs.deferToObj)[i];
toObjFile(s, false);
}
if (ud)
{
for (size_t i = 0; i < ud->deferredNested.dim; i++)
{
FuncDeclaration *fd = ud->deferredNested[i];
toObjFile(fd, false);
}
}
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
// A hack to get a pointer to this function put in the .dtors segment
if (fd->ident && memcmp(fd->ident->toChars(), "_STD", 4) == 0)
objmod->staticdtor(s);
#endif
if (irs.startaddress)
{
//printf("Setting start address\n");
objmod->startaddress(irs.startaddress);
}
}
ArrayOp *buildArrayOp(Identifier *ident, BinExp *exp, Scope *sc, Loc loc)
{
Parameters *fparams = new Parameters();
Expression *loopbody = exp->buildArrayLoop(fparams);
ArrayOp *op = new ArrayOp;
if (isDruntimeArrayOp(ident))
op->cFunc = FuncDeclaration::genCfunc(fparams, exp->type, ident);
else
op->cFunc = NULL;
/* Construct the function body:
* foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++)
* loopbody;
* return p;
*/
Parameter *p = (*fparams)[0 /*fparams->dim - 1*/];
#if DMDV1
// for (size_t i = 0; i < p.length; i++)
Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t));
Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init);
Statement *s1 = new ForStatement(0,
new ExpStatement(0, d),
new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))),
new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)),
new ExpStatement(0, loopbody));
#else
// foreach (i; 0 .. p.length)
Statement *s1 = new ForeachRangeStatement(Loc(), TOKforeach,
new Parameter(0, NULL, Id::p, NULL),
new IntegerExp(Loc(), 0, Type::tsize_t),
new ArrayLengthExp(Loc(), new IdentifierExp(Loc(), p->ident)),
new ExpStatement(Loc(), loopbody));
#endif
//printf("%s\n", s1->toChars());
Statement *s2 = new ReturnStatement(Loc(), new IdentifierExp(Loc(), p->ident));
//printf("s2: %s\n", s2->toChars());
Statement *fbody = new CompoundStatement(Loc(), s1, s2);
// Built-in array ops should be @trusted, pure and nothrow
StorageClass stc = STCtrusted | STCpure | STCnothrow;
/* Construct the function
*/
TypeFunction *ftype = new TypeFunction(fparams, exp->type, 0, LINKc, stc);
//printf("ftype: %s\n", ftype->toChars());
FuncDeclaration *fd = new FuncDeclaration(Loc(), Loc(), ident, STCundefined, ftype);
fd->fbody = fbody;
fd->protection = PROTpublic;
fd->linkage = LINKc;
fd->isArrayOp = 1;
if (!op->cFunc)
sc->module->importedFrom->members->push(fd);
sc = sc->push();
sc->parent = sc->module->importedFrom;
sc->stc = 0;
sc->linkage = LINKc;
fd->semantic(sc);
fd->semantic2(sc);
fd->semantic3(sc);
sc->pop();
if (op->cFunc)
{
op->cFunc->dArrayOp = fd;
op->cFunc->type = fd->type;
}
op->dFunc = fd;
return op;
}
void DtoDefineFunction(FuncDeclaration* fd)
{
IF_LOG Logger::println("DtoDefineFunction(%s): %s", fd->toPrettyChars(), fd->loc.toChars());
LOG_SCOPE;
if (fd->ir.isDefined()) return;
if ((fd->type && fd->type->ty == Terror) ||
(fd->type && fd->type->ty == Tfunction && static_cast<TypeFunction *>(fd->type)->next == NULL) ||
(fd->type && fd->type->ty == Tfunction && static_cast<TypeFunction *>(fd->type)->next->ty == Terror))
{
IF_LOG Logger::println("Ignoring; has error type, no return type or returns error type");
fd->ir.setDefined();
return;
}
if (fd->semanticRun == PASSsemanticdone)
{
/* What happened is this function failed semantic3() with errors,
* but the errors were gagged.
* Try to reproduce those errors, and then fail.
*/
error(fd->loc, "errors compiling function %s", fd->toPrettyChars());
fd->ir.setDefined();
return;
}
DtoResolveFunction(fd);
if (fd->isUnitTestDeclaration() && !global.params.useUnitTests)
{
IF_LOG Logger::println("No code generation for unit test declaration %s", fd->toChars());
fd->ir.setDefined();
return;
}
// Skip array ops implemented in druntime
if (fd->isArrayOp && isDruntimeArrayOp(fd))
{
IF_LOG Logger::println("No code generation for array op %s implemented in druntime", fd->toChars());
fd->ir.setDefined();
return;
}
// Check whether the frontend knows that the function is already defined
// in some other module (see DMD's FuncDeclaration::toObjFile).
for (FuncDeclaration *f = fd; f; )
{
if (!f->isInstantiated() && f->inNonRoot())
{
IF_LOG Logger::println("Skipping '%s'.", fd->toPrettyChars());
// TODO: Emit as available_externally for inlining purposes instead
// (see #673).
fd->ir.setDefined();
return;
}
if (f->isNested())
f = f->toParent2()->isFuncDeclaration();
else
break;
}
DtoDeclareFunction(fd);
assert(fd->ir.isDeclared());
// DtoResolveFunction might also set the defined flag for functions we
// should not touch.
if (fd->ir.isDefined()) return;
fd->ir.setDefined();
// We cannot emit nested functions with parents that have not gone through
// semantic analysis. This can happen as DMD leaks some template instances
// from constraints into the module member list. DMD gets away with being
// sloppy as functions in template contraints obviously never need to access
// data from the template function itself, but it would still mess up our
// nested context creation code.
FuncDeclaration* parent = fd;
while ((parent = getParentFunc(parent, true)))
{
if (parent->semanticRun != PASSsemantic3done || parent->semantic3Errors)
{
IF_LOG Logger::println("Ignoring nested function with unanalyzed parent.");
return;
}
}
assert(fd->semanticRun == PASSsemantic3done);
assert(fd->ident != Id::empty);
if (fd->isUnitTestDeclaration()) {
gIR->unitTests.push_back(fd);
} else if (fd->isSharedStaticCtorDeclaration()) {
gIR->sharedCtors.push_back(fd);
} else if (StaticDtorDeclaration *dtorDecl = fd->isSharedStaticDtorDeclaration()) {
gIR->sharedDtors.push_front(fd);
if (dtorDecl->vgate)
gIR->sharedGates.push_front(dtorDecl->vgate);
} else if (fd->isStaticCtorDeclaration()) {
gIR->ctors.push_back(fd);
} else if (StaticDtorDeclaration *dtorDecl = fd->isStaticDtorDeclaration()) {
gIR->dtors.push_front(fd);
if (dtorDecl->vgate)
gIR->gates.push_front(dtorDecl->vgate);
}
// if this function is naked, we take over right away! no standard processing!
if (fd->naked)
{
DtoDefineNakedFunction(fd);
return;
}
IrFunction *irFunc = getIrFunc(fd);
IrFuncTy &irFty = irFunc->irFty;
// debug info
irFunc->diSubprogram = gIR->DBuilder.EmitSubProgram(fd);
Type* t = fd->type->toBasetype();
TypeFunction* f = static_cast<TypeFunction*>(t);
// assert(f->ctype);
llvm::Function* func = irFunc->func;
// is there a body?
if (fd->fbody == NULL)
return;
IF_LOG Logger::println("Doing function body for: %s", fd->toChars());
gIR->functions.push_back(irFunc);
if (fd->isMain())
gIR->emitMain = true;
func->setLinkage(lowerFuncLinkage(fd));
// On x86_64, always set 'uwtable' for System V ABI compatibility.
// TODO: Find a better place for this.
// TODO: Is this required for Win64 as well?
if (global.params.targetTriple.getArch() == llvm::Triple::x86_64)
{
func->addFnAttr(LDC_ATTRIBUTE(UWTable));
}
#if LDC_LLVM_VER >= 303
if (opts::sanitize != opts::None) {
// Set the required sanitizer attribute.
if (opts::sanitize == opts::AddressSanitizer) {
func->addFnAttr(LDC_ATTRIBUTE(SanitizeAddress));
}
if (opts::sanitize == opts::MemorySanitizer) {
func->addFnAttr(LDC_ATTRIBUTE(SanitizeMemory));
}
if (opts::sanitize == opts::ThreadSanitizer) {
func->addFnAttr(LDC_ATTRIBUTE(SanitizeThread));
}
}
#endif
llvm::BasicBlock* beginbb = llvm::BasicBlock::Create(gIR->context(), "", func);
llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endentry", func);
//assert(gIR->scopes.empty());
gIR->scopes.push_back(IRScope(beginbb, endbb));
// create alloca point
// this gets erased when the function is complete, so alignment etc does not matter at all
llvm::Instruction* allocaPoint = new llvm::AllocaInst(LLType::getInt32Ty(gIR->context()), "alloca point", beginbb);
irFunc->allocapoint = allocaPoint;
// debug info - after all allocas, but before any llvm.dbg.declare etc
gIR->DBuilder.EmitFuncStart(fd);
// this hack makes sure the frame pointer elimination optimization is disabled.
// this this eliminates a bunch of inline asm related issues.
if (fd->hasReturnExp & 8) // has inline asm
{
// emit a call to llvm_eh_unwind_init
LLFunction* hack = GET_INTRINSIC_DECL(eh_unwind_init);
gIR->ir->CreateCall(hack, "");
}
// give the 'this' argument storage and debug info
if (irFty.arg_this)
{
LLValue* thisvar = irFunc->thisArg;
assert(thisvar);
LLValue* thismem = thisvar;
if (!irFty.arg_this->byref)
{
thismem = DtoRawAlloca(thisvar->getType(), 0, "this"); // FIXME: align?
DtoStore(thisvar, thismem);
irFunc->thisArg = thismem;
}
assert(getIrParameter(fd->vthis)->value == thisvar);
getIrParameter(fd->vthis)->value = thismem;
gIR->DBuilder.EmitLocalVariable(thismem, fd->vthis);
}
// give the 'nestArg' storage
if (irFty.arg_nest)
{
LLValue *nestArg = irFunc->nestArg;
LLValue *val = DtoRawAlloca(nestArg->getType(), 0, "nestedFrame");
DtoStore(nestArg, val);
irFunc->nestArg = val;
}
// give arguments storage
// and debug info
if (fd->parameters)
{
size_t n = irFty.args.size();
assert(n == fd->parameters->dim);
for (size_t i=0; i < n; ++i)
{
Dsymbol* argsym = static_cast<Dsymbol*>(fd->parameters->data[i]);
VarDeclaration* vd = argsym->isVarDeclaration();
assert(vd);
IrParameter* irparam = getIrParameter(vd);
assert(irparam);
bool refout = vd->storage_class & (STCref | STCout);
bool lazy = vd->storage_class & STClazy;
if (!refout && (!irparam->arg->byref || lazy))
{
// alloca a stack slot for this first class value arg
LLValue* mem = DtoAlloca(irparam->arg->type, vd->ident->toChars());
// let the abi transform the argument back first
DImValue arg_dval(vd->type, irparam->value);
irFty.getParam(vd->type, i, &arg_dval, mem);
// set the arg var value to the alloca
irparam->value = mem;
}
if (global.params.symdebug && !(isaArgument(irparam->value) && isaArgument(irparam->value)->hasByValAttr()) && !refout)
gIR->DBuilder.EmitLocalVariable(irparam->value, vd);
}
}
FuncGen fg;
irFunc->gen = &fg;
DtoCreateNestedContext(fd);
if (fd->vresult && !
fd->vresult->nestedrefs.dim // FIXME: not sure here :/
)
{
DtoVarDeclaration(fd->vresult);
}
// D varargs: prepare _argptr and _arguments
if (f->linkage == LINKd && f->varargs == 1)
{
// allocate _argptr (of type core.stdc.stdarg.va_list)
LLValue* argptrmem = DtoAlloca(Type::tvalist, "_argptr_mem");
irFunc->_argptr = argptrmem;
// initialize _argptr with a call to the va_start intrinsic
LLValue* vaStartArg = gABI->prepareVaStart(argptrmem);
llvm::CallInst::Create(GET_INTRINSIC_DECL(vastart), vaStartArg, "", gIR->scopebb());
// copy _arguments to a memory location
LLType* argumentsType = irFunc->_arguments->getType();
LLValue* argumentsmem = DtoRawAlloca(argumentsType, 0, "_arguments_mem");
new llvm::StoreInst(irFunc->_arguments, argumentsmem, gIR->scopebb());
irFunc->_arguments = argumentsmem;
}
// output function body
codegenFunction(fd->fbody, gIR);
irFunc->gen = 0;
llvm::BasicBlock* bb = gIR->scopebb();
if (pred_begin(bb) == pred_end(bb) && bb != &bb->getParent()->getEntryBlock()) {
// This block is trivially unreachable, so just delete it.
// (This is a common case because it happens when 'return'
// is the last statement in a function)
bb->eraseFromParent();
} else if (!gIR->scopereturned()) {
// 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.
// pass the previous block into this block
gIR->DBuilder.EmitFuncEnd(fd);
if (func->getReturnType() == LLType::getVoidTy(gIR->context())) {
llvm::ReturnInst::Create(gIR->context(), gIR->scopebb());
}
else if (!fd->isMain()) {
AsmBlockStatement* asmb = fd->fbody->endsWithAsm();
if (asmb) {
assert(asmb->abiret);
llvm::ReturnInst::Create(gIR->context(), asmb->abiret, bb);
}
else {
llvm::ReturnInst::Create(gIR->context(), llvm::UndefValue::get(func->getReturnType()), bb);
}
}
else
llvm::ReturnInst::Create(gIR->context(), LLConstant::getNullValue(func->getReturnType()), bb);
}
// erase alloca point
if (allocaPoint->getParent())
allocaPoint->eraseFromParent();
allocaPoint = 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();
gIR->functions.pop_back();
}
