mirror of
https://github.com/ldc-developers/ldc.git
synced 2025-05-02 08:01:11 +03:00
611 lines
22 KiB
C++
611 lines
22 KiB
C++
//===-- tocall.cpp --------------------------------------------------------===//
|
||
//
|
||
// LDC – the LLVM D compiler
|
||
//
|
||
// This file is distributed under the BSD-style LDC license. See the LICENSE
|
||
// file for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include "declaration.h"
|
||
#include "id.h"
|
||
#include "mtype.h"
|
||
#include "target.h"
|
||
#include "pragma.h"
|
||
#include "gen/abi.h"
|
||
#include "gen/dvalue.h"
|
||
#include "gen/functions.h"
|
||
#include "gen/irstate.h"
|
||
#include "gen/llvm.h"
|
||
#include "gen/llvmhelpers.h"
|
||
#include "gen/logger.h"
|
||
#include "gen/nested.h"
|
||
#include "gen/tollvm.h"
|
||
#include "ir/irtype.h"
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
IrFuncTy &DtoIrTypeFunction(DValue* fnval)
|
||
{
|
||
if (DFuncValue* dfnval = fnval->isFunc())
|
||
{
|
||
if (dfnval->func)
|
||
return getIrFunc(dfnval->func)->irFty;
|
||
}
|
||
|
||
Type* type = stripModifiers(fnval->getType()->toBasetype());
|
||
DtoType(type);
|
||
assert(type->ctype);
|
||
return type->ctype->getIrFuncTy();
|
||
}
|
||
|
||
TypeFunction* DtoTypeFunction(DValue* fnval)
|
||
{
|
||
Type* type = fnval->getType()->toBasetype();
|
||
if (type->ty == Tfunction)
|
||
{
|
||
return static_cast<TypeFunction*>(type);
|
||
}
|
||
else if (type->ty == Tdelegate)
|
||
{
|
||
// FIXME: There is really no reason why the function type should be
|
||
// unmerged at this stage, but the frontend still seems to produce such
|
||
// cases; for example for the uint(uint) next type of the return type of
|
||
// (&zero)(), leading to a crash in DtoCallFunction:
|
||
// ---
|
||
// void test8198() {
|
||
// uint delegate(uint) zero() { return null; }
|
||
// auto a = (&zero)()(0);
|
||
// }
|
||
// ---
|
||
// Calling merge() here works around the symptoms, but does not fix the
|
||
// root cause.
|
||
|
||
Type* next = type->nextOf()->merge();
|
||
assert(next->ty == Tfunction);
|
||
return static_cast<TypeFunction*>(next);
|
||
}
|
||
|
||
llvm_unreachable("Cannot get TypeFunction* from non lazy/function/delegate");
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
LLValue* DtoCallableValue(DValue* fn)
|
||
{
|
||
Type* type = fn->getType()->toBasetype();
|
||
if (type->ty == Tfunction)
|
||
{
|
||
return fn->getRVal();
|
||
}
|
||
else if (type->ty == Tdelegate)
|
||
{
|
||
if (fn->isLVal())
|
||
{
|
||
LLValue* dg = fn->getLVal();
|
||
LLValue* funcptr = DtoGEPi(dg, 0, 1);
|
||
return DtoLoad(funcptr, ".funcptr");
|
||
}
|
||
else
|
||
{
|
||
LLValue* dg = fn->getRVal();
|
||
assert(isaStruct(dg));
|
||
return gIR->ir->CreateExtractValue(dg, 1, ".funcptr");
|
||
}
|
||
}
|
||
|
||
llvm_unreachable("Not a callable type.");
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
LLFunctionType* DtoExtractFunctionType(LLType* type)
|
||
{
|
||
if (LLFunctionType* fty = isaFunction(type))
|
||
return fty;
|
||
else if (LLPointerType* pty = isaPointer(type))
|
||
{
|
||
if (LLFunctionType* fty = isaFunction(pty->getElementType()))
|
||
return fty;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
static void addExplicitArguments(std::vector<LLValue*>& args, AttrSet& attrs,
|
||
IrFuncTy& irFty, LLFunctionType* callableTy, const std::vector<DValue*>& argvals, int numFormalParams)
|
||
{
|
||
const int numImplicitArgs = args.size();
|
||
const int numExplicitArgs = argvals.size();
|
||
|
||
args.resize(numImplicitArgs + numExplicitArgs, static_cast<LLValue*>(0));
|
||
|
||
// construct and initialize an IrFuncTyArg object for each vararg
|
||
std::vector<IrFuncTyArg*> optionalIrArgs;
|
||
for (int i = numFormalParams; i < numExplicitArgs; i++) {
|
||
Type* argType = argvals[i]->getType();
|
||
bool passByVal = gABI->passByVal(argType);
|
||
|
||
AttrBuilder initialAttrs;
|
||
if (passByVal)
|
||
initialAttrs.add(LDC_ATTRIBUTE(ByVal));
|
||
else
|
||
initialAttrs.add(DtoShouldExtend(argType));
|
||
|
||
optionalIrArgs.push_back(new IrFuncTyArg(argType, passByVal, initialAttrs));
|
||
}
|
||
|
||
// let the ABI rewrite the IrFuncTyArg objects
|
||
gABI->rewriteVarargs(irFty, optionalIrArgs);
|
||
|
||
for (int i = 0; i < numExplicitArgs; i++)
|
||
{
|
||
int j = numImplicitArgs + (irFty.reverseParams ? numExplicitArgs - i - 1 : i);
|
||
|
||
DValue* argval = argvals[i];
|
||
Type* argType = argval->getType();
|
||
|
||
const bool isVararg = (i >= numFormalParams);
|
||
IrFuncTyArg* irArg = NULL;
|
||
LLValue* arg = NULL;
|
||
|
||
if (!isVararg)
|
||
{
|
||
irArg = irFty.args[i];
|
||
arg = irFty.putParam(argType, i, argval);
|
||
}
|
||
else
|
||
{
|
||
irArg = optionalIrArgs[i - numFormalParams];
|
||
arg = irFty.putParam(argType, *irArg, argval);
|
||
}
|
||
|
||
LLType* callableArgType = (isVararg ? NULL : callableTy->getParamType(j));
|
||
|
||
// Hack around LDC assuming structs and static arrays are in memory:
|
||
// If the function wants a struct, and the argument value is a
|
||
// pointer to a struct, load from it before passing it in.
|
||
if (isaPointer(arg) && DtoIsPassedByRef(argType) &&
|
||
( (!isVararg && !isaPointer(callableArgType)) ||
|
||
(isVararg && !irArg->byref && !irArg->isByVal()) ) )
|
||
{
|
||
Logger::println("Loading struct type for function argument");
|
||
arg = DtoLoad(arg);
|
||
}
|
||
|
||
// parameter type mismatch, this is hard to get rid of
|
||
if (!isVararg && arg->getType() != callableArgType)
|
||
{
|
||
#if 1
|
||
IF_LOG {
|
||
Logger::cout() << "arg: " << *arg << '\n';
|
||
Logger::cout() << "of type: " << *arg->getType() << '\n';
|
||
Logger::cout() << "expects: " << *callableArgType << '\n';
|
||
}
|
||
#endif
|
||
if (isaStruct(arg))
|
||
arg = DtoAggrPaint(arg, callableArgType);
|
||
else
|
||
arg = DtoBitCast(arg, callableArgType);
|
||
}
|
||
|
||
args[j] = arg;
|
||
attrs.add(j + 1, irArg->attrs);
|
||
|
||
if (isVararg)
|
||
delete irArg;
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
static LLValue* getTypeinfoArrayArgumentForDVarArg(Expressions* arguments, int begin)
|
||
{
|
||
IF_LOG Logger::println("doing d-style variadic arguments");
|
||
LOG_SCOPE
|
||
|
||
// number of non variadic args
|
||
IF_LOG Logger::println("num non vararg params = %d", begin);
|
||
|
||
// get n args in arguments list
|
||
size_t n_arguments = arguments ? arguments->dim : 0;
|
||
|
||
const size_t numVariadicArgs = n_arguments - begin;
|
||
|
||
// build type info array
|
||
LLType* typeinfotype = DtoType(Type::dtypeinfo->type);
|
||
LLArrayType* typeinfoarraytype = LLArrayType::get(typeinfotype, numVariadicArgs);
|
||
|
||
llvm::GlobalVariable* typeinfomem =
|
||
new llvm::GlobalVariable(gIR->module, typeinfoarraytype, true, llvm::GlobalValue::InternalLinkage, NULL, "._arguments.storage");
|
||
IF_LOG Logger::cout() << "_arguments storage: " << *typeinfomem << '\n';
|
||
|
||
std::vector<LLConstant*> vtypeinfos;
|
||
vtypeinfos.reserve(n_arguments);
|
||
for (size_t i=begin; i<n_arguments; i++)
|
||
{
|
||
vtypeinfos.push_back(DtoTypeInfoOf((*arguments)[i]->type));
|
||
}
|
||
|
||
// apply initializer
|
||
LLConstant* tiinits = LLConstantArray::get(typeinfoarraytype, vtypeinfos);
|
||
typeinfomem->setInitializer(tiinits);
|
||
|
||
// put data in d-array
|
||
LLConstant* pinits[] = {
|
||
DtoConstSize_t(numVariadicArgs),
|
||
llvm::ConstantExpr::getBitCast(typeinfomem, getPtrToType(typeinfotype))
|
||
};
|
||
LLType* tiarrty = DtoType(Type::dtypeinfo->type->arrayOf());
|
||
tiinits = LLConstantStruct::get(isaStruct(tiarrty), llvm::ArrayRef<LLConstant*>(pinits));
|
||
LLValue* typeinfoarrayparam = new llvm::GlobalVariable(gIR->module, tiarrty,
|
||
true, llvm::GlobalValue::InternalLinkage, tiinits, "._arguments.array");
|
||
|
||
return DtoLoad(typeinfoarrayparam);
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// FIXME: this function is a mess !
|
||
|
||
DValue* DtoCallFunction(Loc& loc, Type* resulttype, DValue* fnval, Expressions* arguments, llvm::Value *retvar)
|
||
{
|
||
IF_LOG Logger::println("DtoCallFunction()");
|
||
LOG_SCOPE
|
||
|
||
// the callee D type
|
||
Type* calleeType = fnval->getType();
|
||
|
||
// make sure the callee type has been processed
|
||
DtoType(calleeType);
|
||
|
||
// get func value if any
|
||
DFuncValue* dfnval = fnval->isFunc();
|
||
|
||
// handle intrinsics
|
||
bool intrinsic = (dfnval && dfnval->func && dfnval->func->llvmInternal == LLVMintrinsic);
|
||
|
||
// get function type info
|
||
IrFuncTy &irFty = DtoIrTypeFunction(fnval);
|
||
TypeFunction* tf = DtoTypeFunction(fnval);
|
||
|
||
// misc
|
||
bool retinptr = irFty.arg_sret;
|
||
bool thiscall = irFty.arg_this;
|
||
bool delegatecall = (calleeType->toBasetype()->ty == Tdelegate);
|
||
bool nestedcall = irFty.arg_nest;
|
||
bool dvarargs = irFty.arg_arguments;
|
||
|
||
// get callee llvm value
|
||
LLValue* callable = DtoCallableValue(fnval);
|
||
LLFunctionType* callableTy = DtoExtractFunctionType(callable->getType());
|
||
assert(callableTy);
|
||
llvm::CallingConv::ID callconv = gABI->callingConv(callableTy, tf->linkage);
|
||
|
||
// IF_LOG Logger::cout() << "callable: " << *callable << '\n';
|
||
|
||
// get number of explicit arguments
|
||
size_t n_arguments = arguments ? arguments->dim : 0;
|
||
|
||
// get llvm argument iterator, for types
|
||
LLFunctionType::param_iterator argTypesBegin = callableTy->param_begin();
|
||
|
||
// parameter attributes
|
||
AttrSet attrs;
|
||
|
||
// return attrs
|
||
attrs.add(0, irFty.ret->attrs);
|
||
|
||
// handle implicit arguments
|
||
std::vector<LLValue*> args;
|
||
args.reserve(irFty.args.size());
|
||
|
||
// return in hidden ptr is first
|
||
if (retinptr)
|
||
{
|
||
if (!retvar)
|
||
retvar = DtoRawAlloca((*argTypesBegin)->getContainedType(0), resulttype->alignsize(), ".rettmp");
|
||
args.push_back(retvar);
|
||
|
||
// add attrs for hidden ptr
|
||
// after adding the argument to args, args.size() is the index for the
|
||
// related attributes since attrs[0] are the return value's attributes
|
||
attrs.add(args.size(), irFty.arg_sret->attrs);
|
||
|
||
// verify that sret and/or inreg attributes are set
|
||
const AttrBuilder& sretAttrs = irFty.arg_sret->attrs;
|
||
assert((sretAttrs.contains(LDC_ATTRIBUTE(StructRet)) || sretAttrs.contains(LDC_ATTRIBUTE(InReg)))
|
||
&& "Sret arg not sret or inreg?");
|
||
}
|
||
|
||
// then comes a context argument...
|
||
if(thiscall || delegatecall || nestedcall)
|
||
{
|
||
LLType* contextArgType = *(argTypesBegin + args.size());
|
||
|
||
if (dfnval && (dfnval->func->ident == Id::ensure || dfnval->func->ident == Id::require)) {
|
||
// ... which can be the this "context" argument for a contract
|
||
// invocation (in D2, we do not generate a full nested contexts
|
||
// for __require/__ensure as the needed parameters are passed
|
||
// explicitly, while in D1, the normal nested function handling
|
||
// mechanisms are used)
|
||
LLValue* thisarg = DtoBitCast(DtoLoad(gIR->func()->thisArg), getVoidPtrType());
|
||
args.push_back(thisarg);
|
||
}
|
||
else if (thiscall && dfnval && dfnval->vthis)
|
||
{
|
||
// ... or a normal 'this' argument
|
||
LLValue* thisarg = DtoBitCast(dfnval->vthis, contextArgType);
|
||
args.push_back(thisarg);
|
||
}
|
||
else if (delegatecall)
|
||
{
|
||
// ... or a delegate context arg
|
||
LLValue* ctxarg;
|
||
if (fnval->isLVal()) {
|
||
ctxarg = DtoLoad(DtoGEPi(fnval->getLVal(), 0, 0), ".ptr");
|
||
} else {
|
||
ctxarg = gIR->ir->CreateExtractValue(fnval->getRVal(), 0, ".ptr");
|
||
}
|
||
ctxarg = DtoBitCast(ctxarg, contextArgType);
|
||
args.push_back(ctxarg);
|
||
}
|
||
else if (nestedcall)
|
||
{
|
||
// ... or a nested function context arg
|
||
if (dfnval) {
|
||
LLValue* contextptr = DtoNestedContext(loc, dfnval->func);
|
||
contextptr = DtoBitCast(contextptr, getVoidPtrType());
|
||
args.push_back(contextptr);
|
||
} else {
|
||
args.push_back(llvm::UndefValue::get(getVoidPtrType()));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
error(loc, "Context argument required but none given");
|
||
fatal();
|
||
}
|
||
|
||
// add attributes for context argument
|
||
if (irFty.arg_this) {
|
||
attrs.add(args.size(), irFty.arg_this->attrs);
|
||
} else if (irFty.arg_nest) {
|
||
attrs.add(args.size(), irFty.arg_nest->attrs);
|
||
}
|
||
}
|
||
|
||
const int numFormalParams = Parameter::dim(tf->parameters); // excl. variadics
|
||
|
||
// D vararg functions need an additional "TypeInfo[] _arguments" argument
|
||
if (dvarargs) {
|
||
LLValue* argumentsArg = getTypeinfoArrayArgumentForDVarArg(arguments, numFormalParams);
|
||
args.push_back(argumentsArg);
|
||
attrs.add(args.size(), irFty.arg_arguments->attrs);
|
||
}
|
||
|
||
// handle explicit arguments
|
||
|
||
Logger::println("doing normal arguments");
|
||
IF_LOG {
|
||
Logger::println("Arguments so far: (%d)", static_cast<int>(args.size()));
|
||
Logger::indent();
|
||
for (size_t i = 0; i < args.size(); i++) {
|
||
Logger::cout() << *args[i] << '\n';
|
||
}
|
||
Logger::undent();
|
||
Logger::cout() << "Function type: " << tf->toChars() << '\n';
|
||
//Logger::cout() << "LLVM functype: " << *callable->getType() << '\n';
|
||
}
|
||
|
||
std::vector<DValue*> argvals(n_arguments, static_cast<DValue*>(0));
|
||
if (dfnval && dfnval->func->isArrayOp) {
|
||
// For array ops, the druntime implementation signatures are crafted
|
||
// specifically such that the evaluation order is as expected with
|
||
// the strange DMD reverse parameter passing order. Thus, we need
|
||
// to actually build the arguments right-to-left for them.
|
||
for (int i = numFormalParams - 1; i >= 0; --i) {
|
||
Parameter* fnarg = Parameter::getNth(tf->parameters, i);
|
||
assert(fnarg);
|
||
DValue* argval = DtoArgument(fnarg, (*arguments)[i]);
|
||
argvals[i] = argval;
|
||
}
|
||
} else {
|
||
for (int i = 0; i < numFormalParams; ++i) {
|
||
Parameter* fnarg = Parameter::getNth(tf->parameters, i);
|
||
assert(fnarg);
|
||
DValue* argval = DtoArgument(fnarg, (*arguments)[i]);
|
||
argvals[i] = argval;
|
||
}
|
||
}
|
||
// add varargs
|
||
for (size_t i = numFormalParams; i < n_arguments; ++i)
|
||
argvals[i] = DtoArgument(0, (*arguments)[i]);
|
||
|
||
addExplicitArguments(args, attrs, irFty, callableTy, argvals, numFormalParams);
|
||
|
||
#if 0
|
||
IF_LOG {
|
||
Logger::println("%lu params passed", args.size());
|
||
for (int i=0; i<args.size(); ++i) {
|
||
assert(args[i]);
|
||
Logger::cout() << "arg["<<i<<"] = " << *args[i] << '\n';
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// void returns cannot not be named
|
||
const char* varname = "";
|
||
if (callableTy->getReturnType() != LLType::getVoidTy(gIR->context()))
|
||
varname = "tmp";
|
||
|
||
#if 0
|
||
IF_LOG Logger::cout() << "Calling: " << *callable << '\n';
|
||
#endif
|
||
|
||
// call the function
|
||
LLCallSite call = gIR->CreateCallOrInvoke(callable, args, varname);
|
||
|
||
// get return value
|
||
LLValue* retllval = (retinptr) ? args[0] : call.getInstruction();
|
||
|
||
// Hack around LDC assuming structs and static arrays are in memory:
|
||
// If the function returns a struct or a static array, and the return
|
||
// value is not a pointer to a struct or a static array, store it to
|
||
// a stack slot before continuing.
|
||
Type* dReturnType = tf->next;
|
||
TY returnTy = dReturnType->toBasetype()->ty;
|
||
bool storeReturnValueOnStack =
|
||
(returnTy == Tstruct && !isaPointer(retllval)) ||
|
||
(returnTy == Tsarray && isaArray(retllval));
|
||
|
||
// Ignore ABI for intrinsics
|
||
if (!intrinsic && !retinptr)
|
||
{
|
||
// do abi specific return value fixups
|
||
DImValue dretval(dReturnType, retllval);
|
||
if (storeReturnValueOnStack)
|
||
{
|
||
Logger::println("Storing return value to stack slot");
|
||
LLValue* mem = DtoRawAlloca(DtoType(dReturnType), 0);
|
||
irFty.getRet(dReturnType, &dretval, mem);
|
||
retllval = mem;
|
||
storeReturnValueOnStack = false;
|
||
}
|
||
else
|
||
{
|
||
retllval = irFty.getRet(dReturnType, &dretval);
|
||
storeReturnValueOnStack =
|
||
(returnTy == Tstruct && !isaPointer(retllval)) ||
|
||
(returnTy == Tsarray && isaArray(retllval));
|
||
}
|
||
}
|
||
|
||
if (storeReturnValueOnStack)
|
||
{
|
||
Logger::println("Storing return value to stack slot");
|
||
LLValue* mem = DtoRawAlloca(retllval->getType(), 0);
|
||
DtoStore(retllval, mem);
|
||
retllval = mem;
|
||
}
|
||
|
||
// repaint the type if necessary
|
||
if (resulttype)
|
||
{
|
||
Type* rbase = stripModifiers(resulttype->toBasetype(), true);
|
||
Type* nextbase = stripModifiers(tf->nextOf()->toBasetype(), true);
|
||
if (!rbase->equals(nextbase))
|
||
{
|
||
IF_LOG Logger::println("repainting return value from '%s' to '%s'", tf->nextOf()->toChars(), rbase->toChars());
|
||
switch(rbase->ty)
|
||
{
|
||
case Tarray:
|
||
if (tf->isref)
|
||
retllval = DtoBitCast(retllval, DtoType(rbase->pointerTo()));
|
||
else
|
||
retllval = DtoAggrPaint(retllval, DtoType(rbase));
|
||
break;
|
||
|
||
case Tsarray:
|
||
// nothing ?
|
||
break;
|
||
|
||
case Tclass:
|
||
case Taarray:
|
||
case Tpointer:
|
||
if (tf->isref)
|
||
retllval = DtoBitCast(retllval, DtoType(rbase->pointerTo()));
|
||
else
|
||
retllval = DtoBitCast(retllval, DtoType(rbase));
|
||
break;
|
||
|
||
case Tstruct:
|
||
if (nextbase->ty == Taarray && !tf->isref)
|
||
{
|
||
// In the D2 frontend, the associative array type and its
|
||
// object.AssociativeArray representation are used
|
||
// interchangably in some places. However, AAs are returned
|
||
// by value and not in an sret argument, so if the struct
|
||
// type will be used, give the return value storage here
|
||
// so that we get the right amount of indirections.
|
||
LLValue* tmp = DtoAlloca(rbase, ".aalvauetmp");
|
||
LLValue* val = DtoInsertValue(
|
||
llvm::UndefValue::get(DtoType(rbase)), retllval, 0);
|
||
DtoStore(val, tmp);
|
||
retllval = tmp;
|
||
retinptr = true;
|
||
break;
|
||
}
|
||
// Fall through.
|
||
|
||
default:
|
||
// Unfortunately, DMD has quirks resp. bugs with regard to name
|
||
// mangling: For voldemort-type functions which return a nested
|
||
// struct, the mangled name of the return type changes during
|
||
// semantic analysis.
|
||
//
|
||
// (When the function deco is first computed as part of
|
||
// determining the return type deco, its return type part is
|
||
// left off to avoid cycles. If mangle/toDecoBuffer is then
|
||
// called again for the type, it will pick up the previous
|
||
// result and return the full deco string for the nested struct
|
||
// type, consisting of both the full mangled function name, and
|
||
// the struct identifier.)
|
||
//
|
||
// Thus, the type merging in stripModifiers does not work
|
||
// reliably, and the equality check above can fail even if the
|
||
// types only differ in a qualifier.
|
||
//
|
||
// Because a proper fix for this in the frontend is hard, we
|
||
// just carry on and hope that the frontend didn't mess up,
|
||
// i.e. that the LLVM types really match up.
|
||
//
|
||
// An example situation where this case occurs is:
|
||
// ---
|
||
// auto iota() {
|
||
// static struct Result {
|
||
// this(int) {}
|
||
// inout(Result) test() inout { return cast(inout)Result(0); }
|
||
// }
|
||
// return Result.init;
|
||
// }
|
||
// void main() { auto r = iota(); }
|
||
// ---
|
||
Logger::println("Unknown return mismatch type, ignoring.");
|
||
break;
|
||
}
|
||
IF_LOG Logger::cout() << "final return value: " << *retllval << '\n';
|
||
}
|
||
}
|
||
|
||
// set calling convention and parameter attributes
|
||
#if LDC_LLVM_VER >= 303
|
||
llvm::AttributeSet attrlist = attrs.toNativeSet();
|
||
#else
|
||
llvm::AttrListPtr attrlist = attrs.toNativeSet();
|
||
#endif
|
||
if (dfnval && dfnval->func)
|
||
{
|
||
LLFunction* llfunc = llvm::dyn_cast<LLFunction>(dfnval->val);
|
||
if (llfunc && llfunc->isIntrinsic()) // override intrinsic attrs
|
||
#if LDC_LLVM_VER >= 302
|
||
attrlist = llvm::Intrinsic::getAttributes(gIR->context(), static_cast<llvm::Intrinsic::ID>(llfunc->getIntrinsicID()));
|
||
#else
|
||
attrlist = llvm::Intrinsic::getAttributes(static_cast<llvm::Intrinsic::ID>(llfunc->getIntrinsicID()));
|
||
#endif
|
||
else
|
||
call.setCallingConv(callconv);
|
||
}
|
||
else
|
||
call.setCallingConv(callconv);
|
||
call.setAttributes(attrlist);
|
||
|
||
// if we are returning through a pointer arg
|
||
// or if we are returning a reference
|
||
// make sure we provide a lvalue back!
|
||
if (retinptr || (tf->isref && returnTy != Tvoid))
|
||
return new DVarValue(resulttype, retllval);
|
||
|
||
return new DImValue(resulttype, retllval);
|
||
}
|