void Win64TargetABI::rewriteArgument(IrFuncTy& fty, IrFuncTyArg& arg)
{
LLType* originalLType = arg.ltype;
Type* t = arg.type->toBasetype();
if (isPassedWithByvalSemantics(t))
{
// these types are passed byval:
// the caller allocates a copy and then passes a pointer to the copy
arg.rewrite = &byvalRewrite;
arg.ltype = byvalRewrite.type(arg.type, arg.ltype);
// the copy is treated as a local variable of the callee
// hence add the NoAlias and NoCapture attributes
arg.attrs.clear()
.add(LDC_ATTRIBUTE(NoAlias))
.add(LDC_ATTRIBUTE(NoCapture));
}
else if (isAggregate(t) && canRewriteAsInt(t) && !IntegerRewrite::isObsoleteFor(originalLType))
{
arg.rewrite = &integerRewrite;
arg.ltype = integerRewrite.type(arg.type, arg.ltype);
}
IF_LOG if (arg.rewrite)
{
Logger::println("Rewriting argument type %s", t->toChars());
LOG_SCOPE;
Logger::cout() << *originalLType << " => " << *arg.ltype << '\n';
}
}
void rewriteArgument(IrFuncTy& fty, IrFuncTyArg& arg)
{
Type* ty = arg.type->toBasetype();
if (ty->ty == Tstruct || ty->ty == Tsarray)
{
if (canRewriteAsInt(ty))
{
arg.rewrite = &integerRewrite;
arg.ltype = integerRewrite.type(arg.type, arg.ltype);
}
else
{
// these types are passed byval:
// the caller allocates a copy and then passes a pointer to the copy
arg.rewrite = &byvalRewrite;
arg.ltype = byvalRewrite.type(arg.type, arg.ltype);
// the copy is treated as a local variable of the callee
// hence add the NoAlias and NoCapture attributes
arg.attrs.clear()
.add(LDC_ATTRIBUTE(NoAlias))
.add(LDC_ATTRIBUTE(NoCapture));
}
}
}
AttrBuilder::A DtoShouldExtend(Type* type)
{
type = type->toBasetype();
if (type->isintegral())
{
switch(type->ty)
{
case Tint8:
case Tint16:
return LDC_ATTRIBUTE(SExt);
case Tuns8:
case Tuns16:
return LDC_ATTRIBUTE(ZExt);
default:
// Do not extend.
break;
}
}
return LDC_ATTRIBUTE(None);
}
void rewriteFunctionType(TypeFunction* tf, IrFuncTy &fty)
{
// extern(D)
if (tf->linkage == LINKd)
{
// IMPLICIT PARAMETERS
// mark this/nested params inreg
if (fty.arg_this)
{
Logger::println("Putting 'this' in register");
fty.arg_this->attrs.clear()
.add(LDC_ATTRIBUTE(InReg));
}
else if (fty.arg_nest)
{
Logger::println("Putting context ptr in register");
fty.arg_nest->attrs.clear()
.add(LDC_ATTRIBUTE(InReg));
}
else if (IrFuncTyArg* sret = fty.arg_sret)
{
Logger::println("Putting sret ptr in register");
// sret and inreg are incompatible, but the ABI requires the
// sret parameter to be in EAX in this situation...
sret->attrs.add(LDC_ATTRIBUTE(InReg)).remove(LDC_ATTRIBUTE(StructRet));
}
// otherwise try to mark the last param inreg
else if (!fty.args.empty())
{
// The last parameter is passed in EAX rather than being pushed on the stack if the following conditions are met:
// * It fits in EAX.
// * It is not a 3 byte struct.
// * It is not a floating point type.
IrFuncTyArg* last = fty.args.back();
Type* lastTy = last->type->toBasetype();
unsigned sz = lastTy->size();
if (last->byref && !last->isByVal())
{
Logger::println("Putting last (byref) parameter in register");
last->attrs.add(LDC_ATTRIBUTE(InReg));
}
else if (!lastTy->isfloating() && (sz == 1 || sz == 2 || sz == 4)) // right?
{
// rewrite the struct into an integer to make inreg work
if (lastTy->ty == Tstruct || lastTy->ty == Tsarray)
{
last->rewrite = &integerRewrite;
last->ltype = integerRewrite.type(last->type, last->ltype);
last->byref = false;
// erase previous attributes
last->attrs.clear();
}
last->attrs.add(LDC_ATTRIBUTE(InReg));
}
}
// FIXME: tf->varargs == 1 need to use C calling convention and vararg mechanism to live up to the spec:
// "The caller is expected to clean the stack. _argptr is not passed, it is computed by the callee."
// EXPLICIT PARAMETERS
// reverse parameter order
// for non variadics
if (!fty.args.empty() && tf->varargs != 1)
{
fty.reverseParams = true;
}
}
// extern(C) and all others
else
{
// RETURN VALUE
// cfloat -> i64
if (tf->next->toBasetype() == Type::tcomplex32)
{
fty.ret->rewrite = &integerRewrite;
fty.ret->ltype = integerRewrite.type(fty.ret->type, fty.ret->ltype);
}
// IMPLICIT PARAMETERS
// EXPLICIT PARAMETERS
}
}
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();
}
void DtoDeclareFunction(FuncDeclaration* fdecl)
{
DtoResolveFunction(fdecl);
if (fdecl->ir.isDeclared()) return;
fdecl->ir.setDeclared();
IF_LOG Logger::println("DtoDeclareFunction(%s): %s", fdecl->toPrettyChars(), fdecl->loc.toChars());
LOG_SCOPE;
if (fdecl->isUnitTestDeclaration() && !global.params.useUnitTests)
{
Logger::println("unit tests not enabled");
return;
}
//printf("declare function: %s\n", fdecl->toPrettyChars());
// intrinsic sanity check
if (fdecl->llvmInternal == LLVMintrinsic && fdecl->fbody) {
error(fdecl->loc, "intrinsics cannot have function bodies");
fatal();
}
// get TypeFunction*
Type* t = fdecl->type->toBasetype();
TypeFunction* f = static_cast<TypeFunction*>(t);
// create IrFunction
IrFunction *irFunc = getIrFunc(fdecl, true);
LLFunction* vafunc = 0;
if (DtoIsVaIntrinsic(fdecl))
vafunc = DtoDeclareVaFunction(fdecl);
// calling convention
LINK link = f->linkage;
if (vafunc || fdecl->llvmInternal == LLVMintrinsic
// DMD treats _Dmain as having C calling convention and this has been
// hardcoded into druntime, even if the frontend type has D linkage.
// See Bugzilla issue 9028.
|| fdecl->isMain()
)
{
link = LINKc;
}
// mangled name
std::string mangledName(mangleExact(fdecl));
mangledName = gABI->mangleForLLVM(mangledName, link);
// construct function
LLFunctionType* functype = DtoFunctionType(fdecl);
LLFunction* func = vafunc ? vafunc : gIR->module->getFunction(mangledName);
if (!func) {
if(fdecl->llvmInternal == LLVMinline_ir)
{
func = DtoInlineIRFunction(fdecl);
}
else
{
// All function declarations are "external" - any other linkage type
// is set when actually defining the function.
func = LLFunction::Create(functype,
llvm::GlobalValue::ExternalLinkage, mangledName, gIR->module);
}
} else if (func->getFunctionType() != functype) {
error(fdecl->loc, "Function type does not match previously declared function with the same mangled name: %s", mangleExact(fdecl));
fatal();
}
func->setCallingConv(gABI->callingConv(link));
IF_LOG Logger::cout() << "func = " << *func << std::endl;
// add func to IRFunc
irFunc->func = func;
// parameter attributes
if (!DtoIsIntrinsic(fdecl)) {
set_param_attrs(f, func, fdecl);
if (global.params.disableRedZone) {
func->addFnAttr(LDC_ATTRIBUTE(NoRedZone));
}
}
// main
if (fdecl->isMain()) {
// Detect multiple main functions, which is disallowed. DMD checks this
// in the glue code, so we need to do it here as well.
if (gIR->mainFunc) {
error(fdecl->loc, "only one main function allowed");
}
gIR->mainFunc = func;
}
if (fdecl->neverInline)
{
irFunc->setNeverInline();
}
if (fdecl->llvmInternal == LLVMglobal_crt_ctor || fdecl->llvmInternal == LLVMglobal_crt_dtor)
{
AppendFunctionToLLVMGlobalCtorsDtors(func, fdecl->priority, fdecl->llvmInternal == LLVMglobal_crt_ctor);
}
IrFuncTy &irFty = irFunc->irFty;
// if (!declareOnly)
{
// name parameters
llvm::Function::arg_iterator iarg = func->arg_begin();
if (irFty.arg_sret) {
iarg->setName(".sret_arg");
irFunc->retArg = iarg;
++iarg;
}
if (irFty.arg_this) {
iarg->setName(".this_arg");
irFunc->thisArg = iarg;
VarDeclaration* v = fdecl->vthis;
if (v) {
// We already build the this argument here if we will need it
// later for codegen'ing the function, just as normal
// parameters below, because it can be referred to in nested
// context types. Will be given storage in DtoDefineFunction.
assert(!isIrParameterCreated(v));
IrParameter *irParam = getIrParameter(v, true);
irParam->value = iarg;
irParam->arg = irFty.arg_this;
irParam->isVthis = true;
}
++iarg;
}
else if (irFty.arg_nest) {
iarg->setName(".nest_arg");
irFunc->nestArg = iarg;
assert(irFunc->nestArg);
++iarg;
}
if (irFty.arg_arguments) {
iarg->setName("._arguments");
irFunc->_arguments = iarg;
++iarg;
}
// we never reference parameters of function prototypes
unsigned int k = 0;
for (; iarg != func->arg_end(); ++iarg)
{
if (fdecl->parameters && fdecl->parameters->dim > k)
{
int paramIndex = irFty.reverseParams ? fdecl->parameters->dim-k-1 : k;
Dsymbol* argsym = static_cast<Dsymbol*>(fdecl->parameters->data[paramIndex]);
VarDeclaration* argvd = argsym->isVarDeclaration();
assert(argvd);
assert(!isIrLocalCreated(argvd));
std::string str(argvd->ident->toChars());
str.append("_arg");
iarg->setName(str);
IrParameter *irParam = getIrParameter(argvd, true);
irParam->value = iarg;
irParam->arg = irFty.args[paramIndex];
k++;
}
else
{
iarg->setName("unnamed");
}
}
}
}
llvm::FunctionType* DtoFunctionType(Type* type, IrFuncTy &irFty, Type* thistype, Type* nesttype,
bool isMain, bool isCtor, bool isIntrinsic)
{
IF_LOG Logger::println("DtoFunctionType(%s)", type->toChars());
LOG_SCOPE
// sanity check
assert(type->ty == Tfunction);
TypeFunction* f = static_cast<TypeFunction*>(type);
assert(f->next && "Encountered function type with invalid return type; "
"trying to codegen function ignored by the frontend?");
// Return cached type if available
if (irFty.funcType) return irFty.funcType;
TargetABI* abi = (isIntrinsic ? TargetABI::getIntrinsic() : gABI);
// Do not modify irFty yet; this function may be called recursively if any
// of the argument types refer to this type.
IrFuncTy newIrFty;
// llvm idx counter
size_t lidx = 0;
// main needs a little special handling
if (isMain)
{
newIrFty.ret = new IrFuncTyArg(Type::tint32, false);
}
// sane return value
else
{
Type* rt = f->next;
AttrBuilder attrBuilder;
// sret return
if (abi->returnInArg(f))
{
newIrFty.arg_sret = new IrFuncTyArg(rt, true,
AttrBuilder().add(LDC_ATTRIBUTE(StructRet)).add(LDC_ATTRIBUTE(NoAlias)));
rt = Type::tvoid;
lidx++;
}
// sext/zext return
else
{
Type *t = rt;
if (f->isref)
t = t->pointerTo();
attrBuilder.add(DtoShouldExtend(t));
}
newIrFty.ret = new IrFuncTyArg(rt, f->isref, attrBuilder);
}
lidx++;
// member functions
if (thistype)
{
AttrBuilder attrBuilder;
#if LDC_LLVM_VER >= 303
if (isCtor)
attrBuilder.add(LDC_ATTRIBUTE(Returned));
#endif
newIrFty.arg_this = new IrFuncTyArg(thistype, thistype->toBasetype()->ty == Tstruct, attrBuilder);
lidx++;
}
// and nested functions
else if (nesttype)
{
newIrFty.arg_nest = new IrFuncTyArg(nesttype, false);
lidx++;
}
// vararg functions are special too
if (f->varargs)
{
if (f->linkage == LINKd)
{
// d style with hidden args
// 2 (array) is handled by the frontend
if (f->varargs == 1)
{
// _arguments
newIrFty.arg_arguments = new IrFuncTyArg(Type::dtypeinfo->type->arrayOf(), false);
lidx++;
}
}
newIrFty.c_vararg = true;
}
// if this _Dmain() doesn't have an argument, we force it to have one
int nargs = Parameter::dim(f->parameters);
if (isMain && nargs == 0)
{
Type* mainargs = Type::tchar->arrayOf()->arrayOf();
newIrFty.args.push_back(new IrFuncTyArg(mainargs, false));
lidx++;
}
// add explicit parameters
else for (int i = 0; i < nargs; i++)
{
// get argument
Parameter* arg = Parameter::getNth(f->parameters, i);
// reference semantics? ref, out and d1 static arrays are
bool byref = arg->storageClass & (STCref|STCout);
Type* argtype = arg->type;
AttrBuilder attrBuilder;
// handle lazy args
if (arg->storageClass & STClazy)
{
Logger::println("lazy param");
TypeFunction *ltf = new TypeFunction(NULL, arg->type, 0, LINKd);
TypeDelegate *ltd = new TypeDelegate(ltf);
argtype = ltd;
}
else if (!byref)
{
// byval
if (abi->passByVal(argtype))
{
attrBuilder.add(LDC_ATTRIBUTE(ByVal));
// set byref, because byval requires a pointed LLVM type
byref = true;
}
// sext/zext
else
{
attrBuilder.add(DtoShouldExtend(argtype));
}
}
newIrFty.args.push_back(new IrFuncTyArg(argtype, byref, attrBuilder));
lidx++;
}
// let the abi rewrite the types as necesary
abi->rewriteFunctionType(f, newIrFty);
// Now we can modify irFty safely.
irFty = llvm_move(newIrFty);
// build the function type
std::vector<LLType*> argtypes;
argtypes.reserve(lidx);
if (irFty.arg_sret) argtypes.push_back(irFty.arg_sret->ltype);
if (irFty.arg_this) argtypes.push_back(irFty.arg_this->ltype);
if (irFty.arg_nest) argtypes.push_back(irFty.arg_nest->ltype);
if (irFty.arg_arguments) argtypes.push_back(irFty.arg_arguments->ltype);
size_t beg = argtypes.size();
size_t nargs2 = irFty.args.size();
for (size_t i = 0; i < nargs2; i++)
{
argtypes.push_back(irFty.args[i]->ltype);
}
// reverse params?
if (irFty.reverseParams && nargs2 > 1)
{
std::reverse(argtypes.begin() + beg, argtypes.end());
}
irFty.funcType = LLFunctionType::get(irFty.ret->ltype, argtypes, irFty.c_vararg);
IF_LOG Logger::cout() << "Final function type: " << *irFty.funcType << "\n";
return irFty.funcType;
}
LLFunction* DtoInlineIRFunction(FuncDeclaration* fdecl)
{
const char* mangled_name = mangleExact(fdecl);
TemplateInstance* tinst = fdecl->parent->isTemplateInstance();
assert(tinst);
Objects& objs = tinst->tdtypes;
assert(objs.dim == 3);
Expression* a0 = isExpression(objs[0]);
assert(a0);
StringExp* strexp = a0->toStringExp();
assert(strexp);
assert(strexp->sz == 1);
std::string code(static_cast<char*>(strexp->string), strexp->len);
Type* ret = isType(objs[1]);
assert(ret);
Tuple* a2 = isTuple(objs[2]);
assert(a2);
Objects& arg_types = a2->objects;
std::string str;
llvm::raw_string_ostream stream(str);
stream << "define " << *DtoType(ret) << " @" << mangled_name << "(";
for(size_t i = 0; ;)
{
Type* ty = isType(arg_types[i]);
//assert(ty);
if(!ty)
{
error(tinst->loc,
"All parameters of a template defined with pragma llvm_inline_ir, except for the first one, should be types");
fatal();
}
stream << *DtoType(ty);
i++;
if(i >= arg_types.dim)
break;
stream << ", ";
}
if(ret->ty == Tvoid)
code.append("\nret void");
stream << ")\n{\n" << code << "\n}";
llvm::SMDiagnostic err;
#if LDC_LLVM_VER >= 306
std::unique_ptr<llvm::Module> m = llvm::parseAssemblyString(
stream.str().c_str(), err, gIR->context());
#elif LDC_LLVM_VER >= 303
llvm::Module* m = llvm::ParseAssemblyString(
stream.str().c_str(), NULL, err, gIR->context());
#else
llvm::ParseAssemblyString(
stream.str().c_str(), gIR->module, err, gIR->context());
#endif
std::string errstr = err.getMessage();
if(errstr != "")
error(tinst->loc,
"can't parse inline LLVM IR:\n%s\n%s\n%s\nThe input string was: \n%s",
#if LDC_LLVM_VER >= 303
err.getLineContents().str().c_str(),
#else
err.getLineContents().c_str(),
#endif
(std::string(err.getColumnNo(), ' ') + '^').c_str(),
errstr.c_str(), stream.str().c_str());
#if LDC_LLVM_VER >= 306
llvm::Linker(gIR->module).linkInModule(m.get());
#else
#if LDC_LLVM_VER >= 303
std::string errstr2 = "";
#if LDC_LLVM_VER >= 306
llvm::Linker(gIR->module).linkInModule(m.get(), &errstr2);
#else
llvm::Linker(gIR->module).linkInModule(m, &errstr2);
#endif
if(errstr2 != "")
error(tinst->loc,
"Error when linking in llvm inline ir: %s", errstr2.c_str());
#endif
#endif
LLFunction* fun = gIR->module->getFunction(mangled_name);
fun->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
fun->addFnAttr(LDC_ATTRIBUTE(AlwaysInline));
return fun;
}