blob: f0e107973c1938a5728887b852ce4d43015ec97b [file] [log] [blame]
Daniel Dunbar0dbe2272008-09-08 21:33:45 +00001//===----- CGCall.h - Encapsulate calling convention details ----*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// These classes wrap the information about a call or function
11// definition used to handle ABI compliancy.
12//
13//===----------------------------------------------------------------------===//
14
15#include "CGCall.h"
Chris Lattnerce933992010-06-29 16:40:28 +000016#include "ABIInfo.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000017#include "CodeGenFunction.h"
Daniel Dunbarb7688072008-09-10 00:41:16 +000018#include "CodeGenModule.h"
Daniel Dunbar6b1da0e2008-10-13 17:02:26 +000019#include "clang/Basic/TargetInfo.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000020#include "clang/AST/Decl.h"
Anders Carlssonf6f8ae52009-04-03 22:48:58 +000021#include "clang/AST/DeclCXX.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000022#include "clang/AST/DeclObjC.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000023#include "clang/Frontend/CodeGenOptions.h"
Devang Pateld0646bd2008-09-24 01:01:36 +000024#include "llvm/Attributes.h"
Daniel Dunbard14151d2009-03-02 04:32:35 +000025#include "llvm/Support/CallSite.h"
Daniel Dunbar54d1ccb2009-01-27 01:36:03 +000026#include "llvm/Target/TargetData.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000027using namespace clang;
28using namespace CodeGen;
29
30/***/
31
John McCall04a67a62010-02-05 21:31:56 +000032static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) {
33 switch (CC) {
34 default: return llvm::CallingConv::C;
35 case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
36 case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
Douglas Gregorf813a2c2010-05-18 16:57:00 +000037 case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
John McCall04a67a62010-02-05 21:31:56 +000038 }
39}
40
John McCall0b0ef0a2010-02-24 07:14:12 +000041/// Derives the 'this' type for codegen purposes, i.e. ignoring method
42/// qualification.
43/// FIXME: address space qualification?
John McCallead608a2010-02-26 00:48:12 +000044static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) {
45 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
46 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +000047}
48
John McCall0b0ef0a2010-02-24 07:14:12 +000049/// Returns the canonical formal type of the given C++ method.
John McCallead608a2010-02-26 00:48:12 +000050static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
51 return MD->getType()->getCanonicalTypeUnqualified()
52 .getAs<FunctionProtoType>();
John McCall0b0ef0a2010-02-24 07:14:12 +000053}
54
55/// Returns the "extra-canonicalized" return type, which discards
56/// qualifiers on the return type. Codegen doesn't care about them,
57/// and it makes ABI code a little easier to be able to assume that
58/// all parameter and return types are top-level unqualified.
John McCallead608a2010-02-26 00:48:12 +000059static CanQualType GetReturnType(QualType RetTy) {
60 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
John McCall0b0ef0a2010-02-24 07:14:12 +000061}
62
63const CGFunctionInfo &
Chris Lattnerbcaedae2010-06-30 19:14:05 +000064CodeGenTypes::getFunctionInfo(CanQual<FunctionNoProtoType> FTNP,
65 bool IsRecursive) {
John McCallead608a2010-02-26 00:48:12 +000066 return getFunctionInfo(FTNP->getResultType().getUnqualifiedType(),
67 llvm::SmallVector<CanQualType, 16>(),
Chris Lattnerbcaedae2010-06-30 19:14:05 +000068 FTNP->getExtInfo(), IsRecursive);
John McCall0b0ef0a2010-02-24 07:14:12 +000069}
70
71/// \param Args - contains any initial parameters besides those
72/// in the formal type
73static const CGFunctionInfo &getFunctionInfo(CodeGenTypes &CGT,
John McCallead608a2010-02-26 00:48:12 +000074 llvm::SmallVectorImpl<CanQualType> &ArgTys,
Chris Lattnerbcaedae2010-06-30 19:14:05 +000075 CanQual<FunctionProtoType> FTP,
76 bool IsRecursive = false) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +000077 // FIXME: Kill copy.
Daniel Dunbar45c25ba2008-09-10 04:01:49 +000078 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
Daniel Dunbar541b63b2009-02-02 23:23:47 +000079 ArgTys.push_back(FTP->getArgType(i));
John McCallead608a2010-02-26 00:48:12 +000080 CanQualType ResTy = FTP->getResultType().getUnqualifiedType();
Chris Lattnerbcaedae2010-06-30 19:14:05 +000081 return CGT.getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo(), IsRecursive);
John McCall0b0ef0a2010-02-24 07:14:12 +000082}
83
84const CGFunctionInfo &
Chris Lattnerbcaedae2010-06-30 19:14:05 +000085CodeGenTypes::getFunctionInfo(CanQual<FunctionProtoType> FTP,
86 bool IsRecursive) {
John McCallead608a2010-02-26 00:48:12 +000087 llvm::SmallVector<CanQualType, 16> ArgTys;
Chris Lattnerbcaedae2010-06-30 19:14:05 +000088 return ::getFunctionInfo(*this, ArgTys, FTP, IsRecursive);
Daniel Dunbarbac7c252009-09-11 22:24:53 +000089}
90
John McCall04a67a62010-02-05 21:31:56 +000091static CallingConv getCallingConventionForDecl(const Decl *D) {
Daniel Dunbarbac7c252009-09-11 22:24:53 +000092 // Set the appropriate calling convention for the Function.
93 if (D->hasAttr<StdCallAttr>())
John McCall04a67a62010-02-05 21:31:56 +000094 return CC_X86StdCall;
Daniel Dunbarbac7c252009-09-11 22:24:53 +000095
96 if (D->hasAttr<FastCallAttr>())
John McCall04a67a62010-02-05 21:31:56 +000097 return CC_X86FastCall;
Daniel Dunbarbac7c252009-09-11 22:24:53 +000098
Douglas Gregorf813a2c2010-05-18 16:57:00 +000099 if (D->hasAttr<ThisCallAttr>())
100 return CC_X86ThisCall;
101
John McCall04a67a62010-02-05 21:31:56 +0000102 return CC_C;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000103}
104
Anders Carlsson375c31c2009-10-03 19:43:08 +0000105const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXRecordDecl *RD,
106 const FunctionProtoType *FTP) {
John McCallead608a2010-02-26 00:48:12 +0000107 llvm::SmallVector<CanQualType, 16> ArgTys;
John McCall0b0ef0a2010-02-24 07:14:12 +0000108
Anders Carlsson375c31c2009-10-03 19:43:08 +0000109 // Add the 'this' pointer.
John McCall0b0ef0a2010-02-24 07:14:12 +0000110 ArgTys.push_back(GetThisType(Context, RD));
111
112 return ::getFunctionInfo(*this, ArgTys,
John McCallead608a2010-02-26 00:48:12 +0000113 FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>());
Anders Carlsson375c31c2009-10-03 19:43:08 +0000114}
115
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000116const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXMethodDecl *MD) {
John McCallead608a2010-02-26 00:48:12 +0000117 llvm::SmallVector<CanQualType, 16> ArgTys;
John McCall0b0ef0a2010-02-24 07:14:12 +0000118
Chris Lattner3eb67ca2009-05-12 20:27:19 +0000119 // Add the 'this' pointer unless this is a static method.
120 if (MD->isInstance())
John McCall0b0ef0a2010-02-24 07:14:12 +0000121 ArgTys.push_back(GetThisType(Context, MD->getParent()));
Mike Stump1eb44332009-09-09 15:08:12 +0000122
John McCall0b0ef0a2010-02-24 07:14:12 +0000123 return ::getFunctionInfo(*this, ArgTys, GetFormalType(MD));
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000124}
125
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000126const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXConstructorDecl *D,
127 CXXCtorType Type) {
John McCallead608a2010-02-26 00:48:12 +0000128 llvm::SmallVector<CanQualType, 16> ArgTys;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000129
130 // Add the 'this' pointer.
John McCall0b0ef0a2010-02-24 07:14:12 +0000131 ArgTys.push_back(GetThisType(Context, D->getParent()));
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000132
133 // Check if we need to add a VTT parameter (which has type void **).
134 if (Type == Ctor_Base && D->getParent()->getNumVBases() != 0)
135 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
John McCall0b0ef0a2010-02-24 07:14:12 +0000136
137 return ::getFunctionInfo(*this, ArgTys, GetFormalType(D));
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000138}
139
140const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXDestructorDecl *D,
141 CXXDtorType Type) {
John McCallead608a2010-02-26 00:48:12 +0000142 llvm::SmallVector<CanQualType, 16> ArgTys;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000143
144 // Add the 'this' pointer.
John McCallead608a2010-02-26 00:48:12 +0000145 ArgTys.push_back(GetThisType(Context, D->getParent()));
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000146
147 // Check if we need to add a VTT parameter (which has type void **).
148 if (Type == Dtor_Base && D->getParent()->getNumVBases() != 0)
149 ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
John McCall0b0ef0a2010-02-24 07:14:12 +0000150
151 return ::getFunctionInfo(*this, ArgTys, GetFormalType(D));
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000152}
153
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000154const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionDecl *FD) {
Chris Lattner3eb67ca2009-05-12 20:27:19 +0000155 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000156 if (MD->isInstance())
157 return getFunctionInfo(MD);
Mike Stump1eb44332009-09-09 15:08:12 +0000158
John McCallead608a2010-02-26 00:48:12 +0000159 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
160 assert(isa<FunctionType>(FTy));
John McCall0b0ef0a2010-02-24 07:14:12 +0000161 if (isa<FunctionNoProtoType>(FTy))
John McCallead608a2010-02-26 00:48:12 +0000162 return getFunctionInfo(FTy.getAs<FunctionNoProtoType>());
163 assert(isa<FunctionProtoType>(FTy));
164 return getFunctionInfo(FTy.getAs<FunctionProtoType>());
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000165}
166
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000167const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const ObjCMethodDecl *MD) {
John McCallead608a2010-02-26 00:48:12 +0000168 llvm::SmallVector<CanQualType, 16> ArgTys;
169 ArgTys.push_back(Context.getCanonicalParamType(MD->getSelfDecl()->getType()));
170 ArgTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000171 // FIXME: Kill copy?
Chris Lattner20732162009-02-20 06:23:21 +0000172 for (ObjCMethodDecl::param_iterator i = MD->param_begin(),
John McCall0b0ef0a2010-02-24 07:14:12 +0000173 e = MD->param_end(); i != e; ++i) {
174 ArgTys.push_back(Context.getCanonicalParamType((*i)->getType()));
175 }
176 return getFunctionInfo(GetReturnType(MD->getResultType()),
177 ArgTys,
Rafael Espindola264ba482010-03-30 20:24:48 +0000178 FunctionType::ExtInfo(
179 /*NoReturn*/ false,
Rafael Espindola425ef722010-03-30 22:15:11 +0000180 /*RegParm*/ 0,
Rafael Espindola264ba482010-03-30 20:24:48 +0000181 getCallingConventionForDecl(MD)));
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000182}
183
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000184const CGFunctionInfo &CodeGenTypes::getFunctionInfo(GlobalDecl GD) {
185 // FIXME: Do we need to handle ObjCMethodDecl?
186 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
187
188 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
189 return getFunctionInfo(CD, GD.getCtorType());
190
191 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
192 return getFunctionInfo(DD, GD.getDtorType());
193
194 return getFunctionInfo(FD);
195}
196
Mike Stump1eb44332009-09-09 15:08:12 +0000197const CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy,
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000198 const CallArgList &Args,
Rafael Espindola264ba482010-03-30 20:24:48 +0000199 const FunctionType::ExtInfo &Info) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000200 // FIXME: Kill copy.
John McCallead608a2010-02-26 00:48:12 +0000201 llvm::SmallVector<CanQualType, 16> ArgTys;
Mike Stump1eb44332009-09-09 15:08:12 +0000202 for (CallArgList::const_iterator i = Args.begin(), e = Args.end();
Daniel Dunbar725ad312009-01-31 02:19:00 +0000203 i != e; ++i)
John McCall0b0ef0a2010-02-24 07:14:12 +0000204 ArgTys.push_back(Context.getCanonicalParamType(i->second));
Rafael Espindola264ba482010-03-30 20:24:48 +0000205 return getFunctionInfo(GetReturnType(ResTy), ArgTys, Info);
Daniel Dunbar725ad312009-01-31 02:19:00 +0000206}
207
Mike Stump1eb44332009-09-09 15:08:12 +0000208const CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy,
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000209 const FunctionArgList &Args,
Rafael Espindola264ba482010-03-30 20:24:48 +0000210 const FunctionType::ExtInfo &Info) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000211 // FIXME: Kill copy.
John McCallead608a2010-02-26 00:48:12 +0000212 llvm::SmallVector<CanQualType, 16> ArgTys;
Mike Stump1eb44332009-09-09 15:08:12 +0000213 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000214 i != e; ++i)
John McCall0b0ef0a2010-02-24 07:14:12 +0000215 ArgTys.push_back(Context.getCanonicalParamType(i->second));
Rafael Espindola264ba482010-03-30 20:24:48 +0000216 return getFunctionInfo(GetReturnType(ResTy), ArgTys, Info);
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000217}
218
John McCallead608a2010-02-26 00:48:12 +0000219const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
220 const llvm::SmallVectorImpl<CanQualType> &ArgTys,
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000221 const FunctionType::ExtInfo &Info,
222 bool IsRecursive) {
John McCallead608a2010-02-26 00:48:12 +0000223#ifndef NDEBUG
224 for (llvm::SmallVectorImpl<CanQualType>::const_iterator
225 I = ArgTys.begin(), E = ArgTys.end(); I != E; ++I)
226 assert(I->isCanonicalAsParam());
227#endif
228
Rafael Espindola425ef722010-03-30 22:15:11 +0000229 unsigned CC = ClangCallConvToLLVMCallConv(Info.getCC());
John McCall04a67a62010-02-05 21:31:56 +0000230
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000231 // Lookup or create unique function info.
232 llvm::FoldingSetNodeID ID;
Rafael Espindola264ba482010-03-30 20:24:48 +0000233 CGFunctionInfo::Profile(ID, Info, ResTy,
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000234 ArgTys.begin(), ArgTys.end());
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000235
236 void *InsertPos = 0;
237 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, InsertPos);
238 if (FI)
239 return *FI;
240
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000241 // Construct the function info.
Chris Lattnerce700162010-06-28 23:44:11 +0000242 FI = new CGFunctionInfo(CC, Info.getNoReturn(), Info.getRegParm(), ResTy,
Chris Lattnerbb521142010-06-29 18:13:52 +0000243 ArgTys.data(), ArgTys.size());
Daniel Dunbar35e67d42009-02-05 00:00:23 +0000244 FunctionInfos.InsertNode(FI, InsertPos);
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000245
246 // Compute ABI information.
Chris Lattneree5dcd02010-07-29 02:31:05 +0000247 getABIInfo().computeInfo(*FI);
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000248
Chris Lattnera9fa8582010-07-01 06:20:47 +0000249 // If this is a top-level call and ConvertTypeRecursive hit unresolved pointer
250 // types, resolve them now. These pointers may point to this function, which
251 // we *just* filled in the FunctionInfo for.
Chris Lattneree5dcd02010-07-29 02:31:05 +0000252 if (!IsRecursive && !PointersToResolve.empty())
Chris Lattnera9fa8582010-07-01 06:20:47 +0000253 HandleLateResolvedPointers();
Chris Lattnera9fa8582010-07-01 06:20:47 +0000254
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000255 return *FI;
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000256}
257
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000258CGFunctionInfo::CGFunctionInfo(unsigned _CallingConvention,
Chris Lattnerbb521142010-06-29 18:13:52 +0000259 bool _NoReturn, unsigned _RegParm,
John McCallead608a2010-02-26 00:48:12 +0000260 CanQualType ResTy,
Chris Lattnerbb521142010-06-29 18:13:52 +0000261 const CanQualType *ArgTys,
262 unsigned NumArgTys)
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000263 : CallingConvention(_CallingConvention),
John McCall04a67a62010-02-05 21:31:56 +0000264 EffectiveCallingConvention(_CallingConvention),
Rafael Espindola425ef722010-03-30 22:15:11 +0000265 NoReturn(_NoReturn), RegParm(_RegParm)
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000266{
Chris Lattnerbb521142010-06-29 18:13:52 +0000267 NumArgs = NumArgTys;
Chris Lattnerce700162010-06-28 23:44:11 +0000268
269 // FIXME: Coallocate with the CGFunctionInfo object.
Chris Lattnerbb521142010-06-29 18:13:52 +0000270 Args = new ArgInfo[1 + NumArgTys];
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000271 Args[0].type = ResTy;
Chris Lattnerbb521142010-06-29 18:13:52 +0000272 for (unsigned i = 0; i != NumArgTys; ++i)
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000273 Args[1 + i].type = ArgTys[i];
274}
275
276/***/
277
Mike Stump1eb44332009-09-09 15:08:12 +0000278void CodeGenTypes::GetExpandedTypes(QualType Ty,
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000279 std::vector<const llvm::Type*> &ArgTys,
280 bool IsRecursive) {
Daniel Dunbar56273772008-09-17 00:51:38 +0000281 const RecordType *RT = Ty->getAsStructureType();
282 assert(RT && "Can only expand structure types.");
283 const RecordDecl *RD = RT->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000284 assert(!RD->hasFlexibleArrayMember() &&
Daniel Dunbar56273772008-09-17 00:51:38 +0000285 "Cannot expand structure with flexible array.");
Mike Stump1eb44332009-09-09 15:08:12 +0000286
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000287 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
288 i != e; ++i) {
Daniel Dunbar56273772008-09-17 00:51:38 +0000289 const FieldDecl *FD = *i;
Mike Stump1eb44332009-09-09 15:08:12 +0000290 assert(!FD->isBitField() &&
Daniel Dunbar56273772008-09-17 00:51:38 +0000291 "Cannot expand structure with bit-field members.");
Mike Stump1eb44332009-09-09 15:08:12 +0000292
Daniel Dunbar56273772008-09-17 00:51:38 +0000293 QualType FT = FD->getType();
Chris Lattnerdeabde22010-07-28 18:24:28 +0000294 if (CodeGenFunction::hasAggregateLLVMType(FT))
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000295 GetExpandedTypes(FT, ArgTys, IsRecursive);
Chris Lattnerdeabde22010-07-28 18:24:28 +0000296 else
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000297 ArgTys.push_back(ConvertType(FT, IsRecursive));
Daniel Dunbar56273772008-09-17 00:51:38 +0000298 }
299}
300
Mike Stump1eb44332009-09-09 15:08:12 +0000301llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +0000302CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
303 llvm::Function::arg_iterator AI) {
304 const RecordType *RT = Ty->getAsStructureType();
305 assert(RT && "Can only expand structure types.");
306
307 RecordDecl *RD = RT->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000308 assert(LV.isSimple() &&
309 "Unexpected non-simple lvalue during struct expansion.");
Daniel Dunbar56273772008-09-17 00:51:38 +0000310 llvm::Value *Addr = LV.getAddress();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000311 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
312 i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000313 FieldDecl *FD = *i;
Daniel Dunbar56273772008-09-17 00:51:38 +0000314 QualType FT = FD->getType();
315
316 // FIXME: What are the right qualifiers here?
Anders Carlssone6d2a532010-01-29 05:05:36 +0000317 LValue LV = EmitLValueForField(Addr, FD, 0);
Daniel Dunbar56273772008-09-17 00:51:38 +0000318 if (CodeGenFunction::hasAggregateLLVMType(FT)) {
319 AI = ExpandTypeFromArgs(FT, LV, AI);
320 } else {
321 EmitStoreThroughLValue(RValue::get(AI), LV, FT);
322 ++AI;
323 }
324 }
325
326 return AI;
327}
328
Mike Stump1eb44332009-09-09 15:08:12 +0000329void
330CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
Daniel Dunbar56273772008-09-17 00:51:38 +0000331 llvm::SmallVector<llvm::Value*, 16> &Args) {
332 const RecordType *RT = Ty->getAsStructureType();
333 assert(RT && "Can only expand structure types.");
334
335 RecordDecl *RD = RT->getDecl();
336 assert(RV.isAggregate() && "Unexpected rvalue during struct expansion");
337 llvm::Value *Addr = RV.getAggregateAddr();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000338 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
339 i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000340 FieldDecl *FD = *i;
Daniel Dunbar56273772008-09-17 00:51:38 +0000341 QualType FT = FD->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000342
Daniel Dunbar56273772008-09-17 00:51:38 +0000343 // FIXME: What are the right qualifiers here?
Anders Carlssone6d2a532010-01-29 05:05:36 +0000344 LValue LV = EmitLValueForField(Addr, FD, 0);
Daniel Dunbar56273772008-09-17 00:51:38 +0000345 if (CodeGenFunction::hasAggregateLLVMType(FT)) {
346 ExpandTypeToArgs(FT, RValue::getAggregate(LV.getAddress()), Args);
347 } else {
348 RValue RV = EmitLoadOfLValue(LV, FT);
Mike Stump1eb44332009-09-09 15:08:12 +0000349 assert(RV.isScalar() &&
Daniel Dunbar56273772008-09-17 00:51:38 +0000350 "Unexpected non-scalar rvalue during struct expansion.");
351 Args.push_back(RV.getScalarVal());
352 }
353 }
354}
355
Chris Lattnere7bb7772010-06-27 06:04:18 +0000356/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
Chris Lattner08dd2a02010-06-27 05:56:15 +0000357/// accessing some number of bytes out of it, try to gep into the struct to get
358/// at its inner goodness. Dive as deep as possible without entering an element
359/// with an in-memory size smaller than DstSize.
360static llvm::Value *
Chris Lattnere7bb7772010-06-27 06:04:18 +0000361EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr,
362 const llvm::StructType *SrcSTy,
363 uint64_t DstSize, CodeGenFunction &CGF) {
Chris Lattner08dd2a02010-06-27 05:56:15 +0000364 // We can't dive into a zero-element struct.
365 if (SrcSTy->getNumElements() == 0) return SrcPtr;
366
367 const llvm::Type *FirstElt = SrcSTy->getElementType(0);
368
369 // If the first elt is at least as large as what we're looking for, or if the
370 // first element is the same size as the whole struct, we can enter it.
371 uint64_t FirstEltSize =
372 CGF.CGM.getTargetData().getTypeAllocSize(FirstElt);
373 if (FirstEltSize < DstSize &&
374 FirstEltSize < CGF.CGM.getTargetData().getTypeAllocSize(SrcSTy))
375 return SrcPtr;
376
377 // GEP into the first element.
378 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive");
379
380 // If the first element is a struct, recurse.
381 const llvm::Type *SrcTy =
382 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
383 if (const llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
Chris Lattnere7bb7772010-06-27 06:04:18 +0000384 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000385
386 return SrcPtr;
387}
388
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000389/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
390/// are either integers or pointers. This does a truncation of the value if it
391/// is too large or a zero extension if it is too small.
392static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
393 const llvm::Type *Ty,
394 CodeGenFunction &CGF) {
395 if (Val->getType() == Ty)
396 return Val;
397
398 if (isa<llvm::PointerType>(Val->getType())) {
399 // If this is Pointer->Pointer avoid conversion to and from int.
400 if (isa<llvm::PointerType>(Ty))
401 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
402
403 // Convert the pointer to an integer so we can play with its width.
Chris Lattner77b89b82010-06-27 07:15:29 +0000404 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000405 }
406
407 const llvm::Type *DestIntTy = Ty;
408 if (isa<llvm::PointerType>(DestIntTy))
Chris Lattner77b89b82010-06-27 07:15:29 +0000409 DestIntTy = CGF.IntPtrTy;
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000410
411 if (Val->getType() != DestIntTy)
412 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
413
414 if (isa<llvm::PointerType>(Ty))
415 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
416 return Val;
417}
418
Chris Lattner08dd2a02010-06-27 05:56:15 +0000419
420
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000421/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
422/// a pointer to an object of type \arg Ty.
423///
424/// This safely handles the case when the src type is smaller than the
425/// destination type; in this situation the values of bits which not
426/// present in the src are undefined.
427static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr,
428 const llvm::Type *Ty,
429 CodeGenFunction &CGF) {
Mike Stump1eb44332009-09-09 15:08:12 +0000430 const llvm::Type *SrcTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000431 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Chris Lattner6ae00692010-06-28 22:51:39 +0000432
433 // If SrcTy and Ty are the same, just do a load.
434 if (SrcTy == Ty)
435 return CGF.Builder.CreateLoad(SrcPtr);
436
Duncan Sands9408c452009-05-09 07:08:47 +0000437 uint64_t DstSize = CGF.CGM.getTargetData().getTypeAllocSize(Ty);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000438
439 if (const llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000440 SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000441 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
442 }
443
444 uint64_t SrcSize = CGF.CGM.getTargetData().getTypeAllocSize(SrcTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000445
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000446 // If the source and destination are integer or pointer types, just do an
447 // extension or truncation to the desired type.
448 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
449 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
450 llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr);
451 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
452 }
453
Daniel Dunbarb225be42009-02-03 05:59:18 +0000454 // If load is legal, just bitcast the src pointer.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000455 if (SrcSize >= DstSize) {
Mike Stumpf5408fe2009-05-16 07:57:57 +0000456 // Generally SrcSize is never greater than DstSize, since this means we are
457 // losing bits. However, this can happen in cases where the structure has
458 // additional padding, for example due to a user specified alignment.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000459 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000460 // FIXME: Assert that we aren't truncating non-padding bits when have access
461 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000462 llvm::Value *Casted =
463 CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000464 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted);
465 // FIXME: Use better alignment / avoid requiring aligned load.
466 Load->setAlignment(1);
467 return Load;
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000468 }
Chris Lattner35b21b82010-06-27 01:06:27 +0000469
470 // Otherwise do coercion through memory. This is stupid, but
471 // simple.
472 llvm::Value *Tmp = CGF.CreateTempAlloca(Ty);
473 llvm::Value *Casted =
474 CGF.Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(SrcTy));
475 llvm::StoreInst *Store =
476 CGF.Builder.CreateStore(CGF.Builder.CreateLoad(SrcPtr), Casted);
477 // FIXME: Use better alignment / avoid requiring aligned store.
478 Store->setAlignment(1);
479 return CGF.Builder.CreateLoad(Tmp);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000480}
481
482/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
483/// where the source and destination may have different types.
484///
485/// This safely handles the case when the src type is larger than the
486/// destination type; the upper bits of the src will be lost.
487static void CreateCoercedStore(llvm::Value *Src,
488 llvm::Value *DstPtr,
Anders Carlssond2490a92009-12-24 20:40:36 +0000489 bool DstIsVolatile,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000490 CodeGenFunction &CGF) {
491 const llvm::Type *SrcTy = Src->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000492 const llvm::Type *DstTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000493 cast<llvm::PointerType>(DstPtr->getType())->getElementType();
Chris Lattner6ae00692010-06-28 22:51:39 +0000494 if (SrcTy == DstTy) {
495 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
496 return;
497 }
498
499 uint64_t SrcSize = CGF.CGM.getTargetData().getTypeAllocSize(SrcTy);
500
Chris Lattnere7bb7772010-06-27 06:04:18 +0000501 if (const llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
502 DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF);
503 DstTy = cast<llvm::PointerType>(DstPtr->getType())->getElementType();
504 }
505
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000506 // If the source and destination are integer or pointer types, just do an
507 // extension or truncation to the desired type.
508 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
509 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
510 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
511 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
512 return;
513 }
514
Duncan Sands9408c452009-05-09 07:08:47 +0000515 uint64_t DstSize = CGF.CGM.getTargetData().getTypeAllocSize(DstTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000516
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000517 // If store is legal, just bitcast the src pointer.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000518 if (SrcSize <= DstSize) {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000519 llvm::Value *Casted =
520 CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000521 // FIXME: Use better alignment / avoid requiring aligned store.
Anders Carlssond2490a92009-12-24 20:40:36 +0000522 CGF.Builder.CreateStore(Src, Casted, DstIsVolatile)->setAlignment(1);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000523 } else {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000524 // Otherwise do coercion through memory. This is stupid, but
525 // simple.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000526
527 // Generally SrcSize is never greater than DstSize, since this means we are
528 // losing bits. However, this can happen in cases where the structure has
529 // additional padding, for example due to a user specified alignment.
530 //
531 // FIXME: Assert that we aren't truncating non-padding bits when have access
532 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000533 llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy);
534 CGF.Builder.CreateStore(Src, Tmp);
Mike Stump1eb44332009-09-09 15:08:12 +0000535 llvm::Value *Casted =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000536 CGF.Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(DstTy));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000537 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted);
538 // FIXME: Use better alignment / avoid requiring aligned load.
539 Load->setAlignment(1);
Anders Carlssond2490a92009-12-24 20:40:36 +0000540 CGF.Builder.CreateStore(Load, DstPtr, DstIsVolatile);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000541 }
542}
543
Daniel Dunbar56273772008-09-17 00:51:38 +0000544/***/
545
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000546bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000547 return FI.getReturnInfo().isIndirect();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000548}
549
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000550bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
551 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
552 switch (BT->getKind()) {
553 default:
554 return false;
555 case BuiltinType::Float:
556 return getContext().Target.useObjCFPRetForRealType(TargetInfo::Float);
557 case BuiltinType::Double:
558 return getContext().Target.useObjCFPRetForRealType(TargetInfo::Double);
559 case BuiltinType::LongDouble:
560 return getContext().Target.useObjCFPRetForRealType(
561 TargetInfo::LongDouble);
562 }
563 }
564
565 return false;
566}
567
John McCallc0bf4622010-02-23 00:48:20 +0000568const llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
569 const CGFunctionInfo &FI = getFunctionInfo(GD);
570
571 // For definition purposes, don't consider a K&R function variadic.
572 bool Variadic = false;
573 if (const FunctionProtoType *FPT =
574 cast<FunctionDecl>(GD.getDecl())->getType()->getAs<FunctionProtoType>())
575 Variadic = FPT->isVariadic();
576
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000577 return GetFunctionType(FI, Variadic, false);
John McCallc0bf4622010-02-23 00:48:20 +0000578}
579
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000580const llvm::FunctionType *
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000581CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI, bool IsVariadic,
582 bool IsRecursive) {
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000583 std::vector<const llvm::Type*> ArgTys;
584
585 const llvm::Type *ResultType = 0;
586
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000587 QualType RetTy = FI.getReturnType();
Daniel Dunbarb225be42009-02-03 05:59:18 +0000588 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000589 switch (RetAI.getKind()) {
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000590 case ABIArgInfo::Expand:
591 assert(0 && "Invalid ABI kind for return argument");
592
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000593 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000594 case ABIArgInfo::Direct:
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000595 ResultType = ConvertType(RetTy, IsRecursive);
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000596 break;
597
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000598 case ABIArgInfo::Indirect: {
599 assert(!RetAI.getIndirectAlign() && "Align unused on indirect return.");
Owen Anderson0032b272009-08-13 21:57:51 +0000600 ResultType = llvm::Type::getVoidTy(getLLVMContext());
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000601 const llvm::Type *STy = ConvertType(RetTy, IsRecursive);
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000602 ArgTys.push_back(llvm::PointerType::get(STy, RetTy.getAddressSpace()));
603 break;
604 }
605
Daniel Dunbar11434922009-01-26 21:26:08 +0000606 case ABIArgInfo::Ignore:
Owen Anderson0032b272009-08-13 21:57:51 +0000607 ResultType = llvm::Type::getVoidTy(getLLVMContext());
Daniel Dunbar11434922009-01-26 21:26:08 +0000608 break;
609
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000610 case ABIArgInfo::Coerce:
Daniel Dunbar639ffe42008-09-10 07:04:09 +0000611 ResultType = RetAI.getCoerceToType();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000612 break;
613 }
Mike Stump1eb44332009-09-09 15:08:12 +0000614
615 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000616 ie = FI.arg_end(); it != ie; ++it) {
617 const ABIArgInfo &AI = it->info;
Mike Stump1eb44332009-09-09 15:08:12 +0000618
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000619 switch (AI.getKind()) {
Daniel Dunbar11434922009-01-26 21:26:08 +0000620 case ABIArgInfo::Ignore:
621 break;
622
Chris Lattnerce700162010-06-28 23:44:11 +0000623 case ABIArgInfo::Coerce: {
624 // If the coerce-to type is a first class aggregate, flatten it. Either
625 // way is semantically identical, but fast-isel and the optimizer
626 // generally likes scalar values better than FCAs.
627 const llvm::Type *ArgTy = AI.getCoerceToType();
628 if (const llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgTy)) {
629 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
630 ArgTys.push_back(STy->getElementType(i));
631 } else {
632 ArgTys.push_back(ArgTy);
633 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000634 break;
Chris Lattnerce700162010-06-28 23:44:11 +0000635 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000636
Daniel Dunbaradc8bdd2009-02-10 01:51:39 +0000637 case ABIArgInfo::Indirect: {
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000638 // indirect arguments are always on the stack, which is addr space #0.
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000639 const llvm::Type *LTy = ConvertTypeForMem(it->type, IsRecursive);
Daniel Dunbaradc8bdd2009-02-10 01:51:39 +0000640 ArgTys.push_back(llvm::PointerType::getUnqual(LTy));
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000641 break;
Daniel Dunbaradc8bdd2009-02-10 01:51:39 +0000642 }
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000643
644 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000645 case ABIArgInfo::Direct:
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000646 ArgTys.push_back(ConvertType(it->type, IsRecursive));
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000647 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000648
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000649 case ABIArgInfo::Expand:
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000650 GetExpandedTypes(it->type, ArgTys, IsRecursive);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000651 break;
652 }
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000653 }
654
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000655 return llvm::FunctionType::get(ResultType, ArgTys, IsVariadic);
Daniel Dunbar3913f182008-09-09 23:48:28 +0000656}
657
Anders Carlssonecf282b2009-11-24 05:08:52 +0000658const llvm::Type *
Anders Carlsson046c2942010-04-17 20:15:18 +0000659CodeGenTypes::GetFunctionTypeForVTable(const CXXMethodDecl *MD) {
Anders Carlssonecf282b2009-11-24 05:08:52 +0000660 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
661
Eli Friedmanc00129a2010-05-30 06:03:20 +0000662 if (!VerifyFuncTypeComplete(FPT))
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000663 return GetFunctionType(getFunctionInfo(MD), FPT->isVariadic(), false);
Anders Carlssonecf282b2009-11-24 05:08:52 +0000664
665 return llvm::OpaqueType::get(getLLVMContext());
666}
667
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000668void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
Daniel Dunbar88b53962009-02-02 22:03:45 +0000669 const Decl *TargetDecl,
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000670 AttributeListType &PAL,
671 unsigned &CallingConv) {
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000672 unsigned FuncAttrs = 0;
Devang Patela2c69122008-09-26 22:53:57 +0000673 unsigned RetAttrs = 0;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000674
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000675 CallingConv = FI.getEffectiveCallingConvention();
676
John McCall04a67a62010-02-05 21:31:56 +0000677 if (FI.isNoReturn())
678 FuncAttrs |= llvm::Attribute::NoReturn;
679
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000680 // FIXME: handle sseregparm someday...
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000681 if (TargetDecl) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000682 if (TargetDecl->hasAttr<NoThrowAttr>())
Devang Patel761d7f72008-09-25 21:02:23 +0000683 FuncAttrs |= llvm::Attribute::NoUnwind;
John McCall9c0c1f32010-07-08 06:48:12 +0000684 else if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
685 const FunctionProtoType *FPT = Fn->getType()->getAs<FunctionProtoType>();
686 if (FPT && FPT->hasEmptyExceptionSpec())
687 FuncAttrs |= llvm::Attribute::NoUnwind;
688 }
689
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000690 if (TargetDecl->hasAttr<NoReturnAttr>())
Devang Patel761d7f72008-09-25 21:02:23 +0000691 FuncAttrs |= llvm::Attribute::NoReturn;
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000692 if (TargetDecl->hasAttr<ConstAttr>())
Anders Carlsson232eb7d2008-10-05 23:32:53 +0000693 FuncAttrs |= llvm::Attribute::ReadNone;
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000694 else if (TargetDecl->hasAttr<PureAttr>())
Daniel Dunbar64c2e072009-04-10 22:14:52 +0000695 FuncAttrs |= llvm::Attribute::ReadOnly;
Ryan Flynn76168e22009-08-09 20:07:29 +0000696 if (TargetDecl->hasAttr<MallocAttr>())
697 RetAttrs |= llvm::Attribute::NoAlias;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000698 }
699
Chandler Carruth2811ccf2009-11-12 17:24:48 +0000700 if (CodeGenOpts.OptimizeSize)
Daniel Dunbar7ab1c3e2009-10-27 19:48:08 +0000701 FuncAttrs |= llvm::Attribute::OptimizeForSize;
Chandler Carruth2811ccf2009-11-12 17:24:48 +0000702 if (CodeGenOpts.DisableRedZone)
Devang Patel24095da2009-06-04 23:32:02 +0000703 FuncAttrs |= llvm::Attribute::NoRedZone;
Chandler Carruth2811ccf2009-11-12 17:24:48 +0000704 if (CodeGenOpts.NoImplicitFloat)
Devang Patelacebb392009-06-05 22:05:48 +0000705 FuncAttrs |= llvm::Attribute::NoImplicitFloat;
Devang Patel24095da2009-06-04 23:32:02 +0000706
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000707 QualType RetTy = FI.getReturnType();
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000708 unsigned Index = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +0000709 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000710 switch (RetAI.getKind()) {
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000711 case ABIArgInfo::Extend:
Chris Lattner2eb9cdd2010-07-28 23:46:15 +0000712 if (RetTy->hasSignedIntegerRepresentation())
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000713 RetAttrs |= llvm::Attribute::SExt;
Chris Lattner2eb9cdd2010-07-28 23:46:15 +0000714 else if (RetTy->hasUnsignedIntegerRepresentation())
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000715 RetAttrs |= llvm::Attribute::ZExt;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000716 // FALLTHROUGH
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000717 case ABIArgInfo::Direct:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000718 break;
719
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000720 case ABIArgInfo::Indirect:
Mike Stump1eb44332009-09-09 15:08:12 +0000721 PAL.push_back(llvm::AttributeWithIndex::get(Index,
Chris Lattnerfb97cf22010-04-20 05:44:43 +0000722 llvm::Attribute::StructRet));
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000723 ++Index;
Daniel Dunbar0ac86f02009-03-18 19:51:01 +0000724 // sret disables readnone and readonly
725 FuncAttrs &= ~(llvm::Attribute::ReadOnly |
726 llvm::Attribute::ReadNone);
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000727 break;
728
Daniel Dunbar11434922009-01-26 21:26:08 +0000729 case ABIArgInfo::Ignore:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000730 case ABIArgInfo::Coerce:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000731 break;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000732
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000733 case ABIArgInfo::Expand:
Mike Stump1eb44332009-09-09 15:08:12 +0000734 assert(0 && "Invalid ABI kind for return argument");
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000735 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000736
Devang Patela2c69122008-09-26 22:53:57 +0000737 if (RetAttrs)
738 PAL.push_back(llvm::AttributeWithIndex::get(0, RetAttrs));
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000739
Chris Lattnerdeabde22010-07-28 18:24:28 +0000740 // FIXME: we need to honor command line settings also.
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000741 // FIXME: RegParm should be reduced in case of nested functions and/or global
742 // register variable.
Rafael Espindola425ef722010-03-30 22:15:11 +0000743 signed RegParm = FI.getRegParm();
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000744
745 unsigned PointerWidth = getContext().Target.getPointerWidth(0);
Mike Stump1eb44332009-09-09 15:08:12 +0000746 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000747 ie = FI.arg_end(); it != ie; ++it) {
748 QualType ParamType = it->type;
749 const ABIArgInfo &AI = it->info;
Devang Patel761d7f72008-09-25 21:02:23 +0000750 unsigned Attributes = 0;
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000751
John McCalld8e10d22010-03-27 00:47:27 +0000752 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
753 // have the corresponding parameter variable. It doesn't make
754 // sense to do it here because parameters are so fucked up.
Nuno Lopes079b4952009-12-07 18:30:06 +0000755
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000756 switch (AI.getKind()) {
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000757 case ABIArgInfo::Coerce:
Chris Lattnerce700162010-06-28 23:44:11 +0000758 if (const llvm::StructType *STy =
759 dyn_cast<llvm::StructType>(AI.getCoerceToType()))
760 Index += STy->getNumElements();
761 else
762 ++Index;
763 continue; // Skip index increment.
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000764
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000765 case ABIArgInfo::Indirect:
Anders Carlsson0a8f8472009-09-16 15:53:40 +0000766 if (AI.getIndirectByVal())
767 Attributes |= llvm::Attribute::ByVal;
768
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000769 Attributes |=
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000770 llvm::Attribute::constructAlignmentFromInt(AI.getIndirectAlign());
Daniel Dunbar0ac86f02009-03-18 19:51:01 +0000771 // byval disables readnone and readonly.
772 FuncAttrs &= ~(llvm::Attribute::ReadOnly |
773 llvm::Attribute::ReadNone);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000774 break;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000775
776 case ABIArgInfo::Extend:
Chris Lattner2eb9cdd2010-07-28 23:46:15 +0000777 if (ParamType->isSignedIntegerType())
778 Attributes |= llvm::Attribute::SExt;
779 else if (ParamType->isUnsignedIntegerType())
780 Attributes |= llvm::Attribute::ZExt;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000781 // FALLS THROUGH
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000782 case ABIArgInfo::Direct:
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000783 if (RegParm > 0 &&
784 (ParamType->isIntegerType() || ParamType->isPointerType())) {
785 RegParm -=
786 (Context.getTypeSize(ParamType) + PointerWidth - 1) / PointerWidth;
787 if (RegParm >= 0)
788 Attributes |= llvm::Attribute::InReg;
789 }
790 // FIXME: handle sseregparm someday...
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000791 break;
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000792
Daniel Dunbar11434922009-01-26 21:26:08 +0000793 case ABIArgInfo::Ignore:
794 // Skip increment, no matching LLVM parameter.
Mike Stump1eb44332009-09-09 15:08:12 +0000795 continue;
Daniel Dunbar11434922009-01-26 21:26:08 +0000796
Daniel Dunbar56273772008-09-17 00:51:38 +0000797 case ABIArgInfo::Expand: {
Mike Stump1eb44332009-09-09 15:08:12 +0000798 std::vector<const llvm::Type*> Tys;
Mike Stumpf5408fe2009-05-16 07:57:57 +0000799 // FIXME: This is rather inefficient. Do we ever actually need to do
800 // anything here? The result should be just reconstructed on the other
801 // side, so extension should be a non-issue.
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000802 getTypes().GetExpandedTypes(ParamType, Tys, false);
Daniel Dunbar56273772008-09-17 00:51:38 +0000803 Index += Tys.size();
804 continue;
805 }
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000806 }
Mike Stump1eb44332009-09-09 15:08:12 +0000807
Devang Patel761d7f72008-09-25 21:02:23 +0000808 if (Attributes)
809 PAL.push_back(llvm::AttributeWithIndex::get(Index, Attributes));
Daniel Dunbar56273772008-09-17 00:51:38 +0000810 ++Index;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000811 }
Devang Patela2c69122008-09-26 22:53:57 +0000812 if (FuncAttrs)
813 PAL.push_back(llvm::AttributeWithIndex::get(~0, FuncAttrs));
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000814}
815
Daniel Dunbar88b53962009-02-02 22:03:45 +0000816void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
817 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000818 const FunctionArgList &Args) {
John McCall0cfeb632009-07-28 01:00:58 +0000819 // If this is an implicit-return-zero function, go ahead and
820 // initialize the return value. TODO: it might be nice to have
821 // a more general mechanism for this that didn't require synthesized
822 // return statements.
Chris Lattner121b3fa2010-07-05 20:21:00 +0000823 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl)) {
John McCall0cfeb632009-07-28 01:00:58 +0000824 if (FD->hasImplicitReturnZero()) {
825 QualType RetTy = FD->getResultType().getUnqualifiedType();
826 const llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
Owen Andersonc9c88b42009-07-31 20:28:54 +0000827 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
John McCall0cfeb632009-07-28 01:00:58 +0000828 Builder.CreateStore(Zero, ReturnValue);
829 }
830 }
831
Mike Stumpf5408fe2009-05-16 07:57:57 +0000832 // FIXME: We no longer need the types from FunctionArgList; lift up and
833 // simplify.
Daniel Dunbar5251afa2009-02-03 06:02:10 +0000834
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000835 // Emit allocs for param decls. Give the LLVM Argument nodes names.
836 llvm::Function::arg_iterator AI = Fn->arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +0000837
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000838 // Name the struct return argument.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000839 if (CGM.ReturnTypeUsesSRet(FI)) {
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000840 AI->setName("agg.result");
841 ++AI;
842 }
Mike Stump1eb44332009-09-09 15:08:12 +0000843
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +0000844 assert(FI.arg_size() == Args.size() &&
845 "Mismatch between function signature & arguments.");
Daniel Dunbarb225be42009-02-03 05:59:18 +0000846 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000847 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
Daniel Dunbarb225be42009-02-03 05:59:18 +0000848 i != e; ++i, ++info_it) {
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000849 const VarDecl *Arg = i->first;
Daniel Dunbarb225be42009-02-03 05:59:18 +0000850 QualType Ty = info_it->type;
851 const ABIArgInfo &ArgI = info_it->info;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000852
853 switch (ArgI.getKind()) {
Daniel Dunbar1f745982009-02-05 09:16:39 +0000854 case ABIArgInfo::Indirect: {
Chris Lattnerce700162010-06-28 23:44:11 +0000855 llvm::Value *V = AI;
Daniel Dunbar1f745982009-02-05 09:16:39 +0000856 if (hasAggregateLLVMType(Ty)) {
857 // Do nothing, aggregates and complex variables are accessed by
858 // reference.
859 } else {
860 // Load scalar value from indirect argument.
Daniel Dunbaradc8bdd2009-02-10 01:51:39 +0000861 V = EmitLoadOfScalar(V, false, Ty);
Daniel Dunbar1f745982009-02-05 09:16:39 +0000862 if (!getContext().typesAreCompatible(Ty, Arg->getType())) {
863 // This must be a promotion, for something like
864 // "void a(x) short x; {..."
865 V = EmitScalarConversion(V, Ty, Arg->getType());
866 }
867 }
Mike Stump1eb44332009-09-09 15:08:12 +0000868 EmitParmDecl(*Arg, V);
Daniel Dunbar1f745982009-02-05 09:16:39 +0000869 break;
870 }
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000871
872 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000873 case ABIArgInfo::Direct: {
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000874 assert(AI != Fn->arg_end() && "Argument mismatch!");
Chris Lattnerce700162010-06-28 23:44:11 +0000875 llvm::Value *V = AI;
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +0000876 if (hasAggregateLLVMType(Ty)) {
877 // Create a temporary alloca to hold the argument; the rest of
878 // codegen expects to access aggregates & complex values by
879 // reference.
Daniel Dunbar195337d2010-02-09 02:48:28 +0000880 V = CreateMemTemp(Ty);
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +0000881 Builder.CreateStore(AI, V);
882 } else {
John McCalld8e10d22010-03-27 00:47:27 +0000883 if (Arg->getType().isRestrictQualified())
884 AI->addAttr(llvm::Attribute::NoAlias);
885
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +0000886 if (!getContext().typesAreCompatible(Ty, Arg->getType())) {
887 // This must be a promotion, for something like
888 // "void a(x) short x; {..."
889 V = EmitScalarConversion(V, Ty, Arg->getType());
890 }
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000891 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000892 EmitParmDecl(*Arg, V);
893 break;
894 }
Mike Stump1eb44332009-09-09 15:08:12 +0000895
Daniel Dunbar56273772008-09-17 00:51:38 +0000896 case ABIArgInfo::Expand: {
Daniel Dunbarb225be42009-02-03 05:59:18 +0000897 // If this structure was expanded into multiple arguments then
Daniel Dunbar56273772008-09-17 00:51:38 +0000898 // we need to create a temporary and reconstruct it from the
899 // arguments.
Daniel Dunbar195337d2010-02-09 02:48:28 +0000900 llvm::Value *Temp = CreateMemTemp(Ty, Arg->getName() + ".addr");
Daniel Dunbar56273772008-09-17 00:51:38 +0000901 // FIXME: What are the right qualifiers here?
Mike Stump1eb44332009-09-09 15:08:12 +0000902 llvm::Function::arg_iterator End =
John McCall0953e762009-09-24 19:53:00 +0000903 ExpandTypeFromArgs(Ty, LValue::MakeAddr(Temp, Qualifiers()), AI);
Daniel Dunbar56273772008-09-17 00:51:38 +0000904 EmitParmDecl(*Arg, Temp);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000905
Daniel Dunbar56273772008-09-17 00:51:38 +0000906 // Name the arguments used in expansion and increment AI.
907 unsigned Index = 0;
908 for (; AI != End; ++AI, ++Index)
Daniel Dunbar259e9cc2009-10-19 01:21:05 +0000909 AI->setName(Arg->getName() + "." + llvm::Twine(Index));
Daniel Dunbar56273772008-09-17 00:51:38 +0000910 continue;
911 }
Daniel Dunbar11434922009-01-26 21:26:08 +0000912
913 case ABIArgInfo::Ignore:
Daniel Dunbar8b979d92009-02-10 00:06:49 +0000914 // Initialize the local variable appropriately.
Mike Stump1eb44332009-09-09 15:08:12 +0000915 if (hasAggregateLLVMType(Ty)) {
Daniel Dunbar195337d2010-02-09 02:48:28 +0000916 EmitParmDecl(*Arg, CreateMemTemp(Ty));
Daniel Dunbar8b979d92009-02-10 00:06:49 +0000917 } else {
918 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())));
919 }
Mike Stump1eb44332009-09-09 15:08:12 +0000920
Daniel Dunbar59e5a0e2009-02-03 20:00:13 +0000921 // Skip increment, no matching LLVM parameter.
Mike Stump1eb44332009-09-09 15:08:12 +0000922 continue;
Daniel Dunbar11434922009-01-26 21:26:08 +0000923
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000924 case ABIArgInfo::Coerce: {
Chris Lattner121b3fa2010-07-05 20:21:00 +0000925 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, "coerce");
Chris Lattnerdeabde22010-07-28 18:24:28 +0000926
927 // The alignment we need to use is the max of the requested alignment for
928 // the argument plus the alignment required by our access code below.
929 unsigned AlignmentToUse =
930 CGF.CGM.getTargetData().getABITypeAlignment(ArgI.getCoerceToType());
931 AlignmentToUse = std::max(AlignmentToUse,
932 (unsigned)getContext().getDeclAlign(Arg).getQuantity());
933
934 Alloca->setAlignment(AlignmentToUse);
Chris Lattner121b3fa2010-07-05 20:21:00 +0000935 llvm::Value *V = Alloca;
Chris Lattner309c59f2010-06-29 00:06:42 +0000936
937 // If the coerce-to type is a first class aggregate, we flatten it and
938 // pass the elements. Either way is semantically identical, but fast-isel
939 // and the optimizer generally likes scalar values better than FCAs.
940 if (const llvm::StructType *STy =
941 dyn_cast<llvm::StructType>(ArgI.getCoerceToType())) {
Chris Lattner92826882010-07-05 20:41:41 +0000942 llvm::Value *Ptr = V;
943 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
944
945 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
946 assert(AI != Fn->arg_end() && "Argument mismatch!");
947 AI->setName(Arg->getName() + ".coerce" + llvm::Twine(i));
948 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i);
949 Builder.CreateStore(AI++, EltPtr);
Chris Lattner309c59f2010-06-29 00:06:42 +0000950 }
951 } else {
952 // Simple case, just do a coerced store of the argument into the alloca.
953 assert(AI != Fn->arg_end() && "Argument mismatch!");
Chris Lattner225e2862010-06-29 00:14:52 +0000954 AI->setName(Arg->getName() + ".coerce");
Chris Lattner309c59f2010-06-29 00:06:42 +0000955 CreateCoercedStore(AI++, V, /*DestIsVolatile=*/false, *this);
956 }
957
958
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000959 // Match to what EmitParmDecl is expecting for this type.
Daniel Dunbar8b29a382009-02-04 07:22:24 +0000960 if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
Daniel Dunbaradc8bdd2009-02-10 01:51:39 +0000961 V = EmitLoadOfScalar(V, false, Ty);
Daniel Dunbar8b29a382009-02-04 07:22:24 +0000962 if (!getContext().typesAreCompatible(Ty, Arg->getType())) {
963 // This must be a promotion, for something like
964 // "void a(x) short x; {..."
965 V = EmitScalarConversion(V, Ty, Arg->getType());
966 }
967 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000968 EmitParmDecl(*Arg, V);
Chris Lattnerce700162010-06-28 23:44:11 +0000969 continue; // Skip ++AI increment, already done.
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000970 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000971 }
Daniel Dunbar56273772008-09-17 00:51:38 +0000972
973 ++AI;
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000974 }
975 assert(AI == Fn->arg_end() && "Argument mismatch!");
976}
977
Chris Lattner35b21b82010-06-27 01:06:27 +0000978void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000979 // Functions with no result always return void.
Chris Lattnerc6e6dd22010-06-26 23:13:19 +0000980 if (ReturnValue == 0) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000981 Builder.CreateRetVoid();
Chris Lattnerc6e6dd22010-06-26 23:13:19 +0000982 return;
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +0000983 }
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +0000984
Dan Gohman4751a532010-07-20 20:13:52 +0000985 llvm::DebugLoc RetDbgLoc;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +0000986 llvm::Value *RV = 0;
987 QualType RetTy = FI.getReturnType();
988 const ABIArgInfo &RetAI = FI.getReturnInfo();
989
990 switch (RetAI.getKind()) {
991 case ABIArgInfo::Indirect:
992 if (RetTy->isAnyComplexType()) {
993 ComplexPairTy RT = LoadComplexFromAddr(ReturnValue, false);
994 StoreComplexToAddr(RT, CurFn->arg_begin(), false);
995 } else if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
996 // Do nothing; aggregrates get evaluated directly into the destination.
997 } else {
998 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), CurFn->arg_begin(),
999 false, RetTy);
1000 }
1001 break;
1002
1003 case ABIArgInfo::Extend:
Chris Lattner35b21b82010-06-27 01:06:27 +00001004 case ABIArgInfo::Direct: {
1005 // The internal return value temp always will have pointer-to-return-type
1006 // type, just do a load.
1007
1008 // If the instruction right before the insertion point is a store to the
1009 // return value, we can elide the load, zap the store, and usually zap the
1010 // alloca.
1011 llvm::BasicBlock *InsertBB = Builder.GetInsertBlock();
1012 llvm::StoreInst *SI = 0;
1013 if (InsertBB->empty() ||
1014 !(SI = dyn_cast<llvm::StoreInst>(&InsertBB->back())) ||
1015 SI->getPointerOperand() != ReturnValue || SI->isVolatile()) {
1016 RV = Builder.CreateLoad(ReturnValue);
1017 } else {
1018 // Get the stored value and nuke the now-dead store.
Dan Gohman4751a532010-07-20 20:13:52 +00001019 RetDbgLoc = SI->getDebugLoc();
Chris Lattner35b21b82010-06-27 01:06:27 +00001020 RV = SI->getValueOperand();
1021 SI->eraseFromParent();
1022
1023 // If that was the only use of the return value, nuke it as well now.
1024 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) {
1025 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent();
1026 ReturnValue = 0;
1027 }
1028 }
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001029 break;
Chris Lattner35b21b82010-06-27 01:06:27 +00001030 }
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001031 case ABIArgInfo::Ignore:
1032 break;
1033
1034 case ABIArgInfo::Coerce:
1035 RV = CreateCoercedLoad(ReturnValue, RetAI.getCoerceToType(), *this);
1036 break;
1037
1038 case ABIArgInfo::Expand:
1039 assert(0 && "Invalid ABI kind for return argument");
1040 }
1041
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001042 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid();
Devang Pateld3f265d2010-07-21 18:08:50 +00001043 if (!RetDbgLoc.isUnknown())
1044 Ret->setDebugLoc(RetDbgLoc);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001045}
1046
John McCall27360712010-05-26 22:34:26 +00001047RValue CodeGenFunction::EmitDelegateCallArg(const VarDecl *Param) {
1048 // StartFunction converted the ABI-lowered parameter(s) into a
1049 // local alloca. We need to turn that into an r-value suitable
1050 // for EmitCall.
1051 llvm::Value *Local = GetAddrOfLocalVar(Param);
1052
1053 QualType ArgType = Param->getType();
1054
1055 // For the most part, we just need to load the alloca, except:
1056 // 1) aggregate r-values are actually pointers to temporaries, and
1057 // 2) references to aggregates are pointers directly to the aggregate.
1058 // I don't know why references to non-aggregates are different here.
1059 if (const ReferenceType *RefType = ArgType->getAs<ReferenceType>()) {
1060 if (hasAggregateLLVMType(RefType->getPointeeType()))
1061 return RValue::getAggregate(Local);
1062
1063 // Locals which are references to scalars are represented
1064 // with allocas holding the pointer.
1065 return RValue::get(Builder.CreateLoad(Local));
1066 }
1067
1068 if (ArgType->isAnyComplexType())
1069 return RValue::getComplex(LoadComplexFromAddr(Local, /*volatile*/ false));
1070
1071 if (hasAggregateLLVMType(ArgType))
1072 return RValue::getAggregate(Local);
1073
1074 return RValue::get(EmitLoadOfScalar(Local, false, ArgType));
1075}
1076
Anders Carlsson0139bb92009-04-08 20:47:54 +00001077RValue CodeGenFunction::EmitCallArg(const Expr *E, QualType ArgType) {
Anders Carlsson4029ca72009-05-20 00:24:07 +00001078 if (ArgType->isReferenceType())
Anders Carlsson32f36ba2010-06-26 16:35:32 +00001079 return EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Mike Stump1eb44332009-09-09 15:08:12 +00001080
Anders Carlsson0139bb92009-04-08 20:47:54 +00001081 return EmitAnyExprToTemp(E);
1082}
1083
John McCallf1549f62010-07-06 01:34:17 +00001084/// Emits a call or invoke instruction to the given function, depending
1085/// on the current state of the EH stack.
1086llvm::CallSite
1087CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
1088 llvm::Value * const *ArgBegin,
1089 llvm::Value * const *ArgEnd,
1090 const llvm::Twine &Name) {
1091 llvm::BasicBlock *InvokeDest = getInvokeDest();
1092 if (!InvokeDest)
1093 return Builder.CreateCall(Callee, ArgBegin, ArgEnd, Name);
1094
1095 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
1096 llvm::InvokeInst *Invoke = Builder.CreateInvoke(Callee, ContBB, InvokeDest,
1097 ArgBegin, ArgEnd, Name);
1098 EmitBlock(ContBB);
1099 return Invoke;
1100}
1101
Daniel Dunbar88b53962009-02-02 22:03:45 +00001102RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
Mike Stump1eb44332009-09-09 15:08:12 +00001103 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00001104 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001105 const CallArgList &CallArgs,
David Chisnalldd5c98f2010-05-01 11:15:56 +00001106 const Decl *TargetDecl,
David Chisnall4b02afc2010-05-02 13:41:58 +00001107 llvm::Instruction **callOrInvoke) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001108 // FIXME: We no longer need the types from CallArgs; lift up and simplify.
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001109 llvm::SmallVector<llvm::Value*, 16> Args;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001110
1111 // Handle struct-return functions by passing a pointer to the
1112 // location that we would like to return into.
Daniel Dunbarbb36d332009-02-02 21:43:58 +00001113 QualType RetTy = CallInfo.getReturnType();
Daniel Dunbarb225be42009-02-03 05:59:18 +00001114 const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00001115
1116
Chris Lattner5db7ae52009-06-13 00:26:38 +00001117 // If the call returns a temporary with struct return, create a temporary
Anders Carlssond2490a92009-12-24 20:40:36 +00001118 // alloca to hold the result, unless one is given to us.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001119 if (CGM.ReturnTypeUsesSRet(CallInfo)) {
Anders Carlssond2490a92009-12-24 20:40:36 +00001120 llvm::Value *Value = ReturnValue.getValue();
1121 if (!Value)
Daniel Dunbar195337d2010-02-09 02:48:28 +00001122 Value = CreateMemTemp(RetTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00001123 Args.push_back(Value);
1124 }
Mike Stump1eb44332009-09-09 15:08:12 +00001125
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00001126 assert(CallInfo.arg_size() == CallArgs.size() &&
1127 "Mismatch between function signature & arguments.");
Daniel Dunbarb225be42009-02-03 05:59:18 +00001128 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001129 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
Daniel Dunbarb225be42009-02-03 05:59:18 +00001130 I != E; ++I, ++info_it) {
1131 const ABIArgInfo &ArgInfo = info_it->info;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001132 RValue RV = I->first;
Daniel Dunbar56273772008-09-17 00:51:38 +00001133
1134 switch (ArgInfo.getKind()) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +00001135 case ABIArgInfo::Indirect:
Daniel Dunbar1f745982009-02-05 09:16:39 +00001136 if (RV.isScalar() || RV.isComplex()) {
1137 // Make a temporary alloca to pass the argument.
Daniel Dunbar195337d2010-02-09 02:48:28 +00001138 Args.push_back(CreateMemTemp(I->second));
Daniel Dunbar1f745982009-02-05 09:16:39 +00001139 if (RV.isScalar())
Anders Carlssonb4aa4662009-05-19 18:50:41 +00001140 EmitStoreOfScalar(RV.getScalarVal(), Args.back(), false, I->second);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001141 else
Mike Stump1eb44332009-09-09 15:08:12 +00001142 StoreComplexToAddr(RV.getComplexVal(), Args.back(), false);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001143 } else {
1144 Args.push_back(RV.getAggregateAddr());
1145 }
1146 break;
1147
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001148 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001149 case ABIArgInfo::Direct:
Daniel Dunbar56273772008-09-17 00:51:38 +00001150 if (RV.isScalar()) {
1151 Args.push_back(RV.getScalarVal());
1152 } else if (RV.isComplex()) {
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +00001153 llvm::Value *Tmp = llvm::UndefValue::get(ConvertType(I->second));
1154 Tmp = Builder.CreateInsertValue(Tmp, RV.getComplexVal().first, 0);
1155 Tmp = Builder.CreateInsertValue(Tmp, RV.getComplexVal().second, 1);
1156 Args.push_back(Tmp);
Daniel Dunbar56273772008-09-17 00:51:38 +00001157 } else {
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +00001158 Args.push_back(Builder.CreateLoad(RV.getAggregateAddr()));
Daniel Dunbar56273772008-09-17 00:51:38 +00001159 }
1160 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001161
Daniel Dunbar11434922009-01-26 21:26:08 +00001162 case ABIArgInfo::Ignore:
1163 break;
1164
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001165 case ABIArgInfo::Coerce: {
1166 // FIXME: Avoid the conversion through memory if possible.
1167 llvm::Value *SrcPtr;
1168 if (RV.isScalar()) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00001169 SrcPtr = CreateMemTemp(I->second, "coerce");
Anders Carlssonb4aa4662009-05-19 18:50:41 +00001170 EmitStoreOfScalar(RV.getScalarVal(), SrcPtr, false, I->second);
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001171 } else if (RV.isComplex()) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00001172 SrcPtr = CreateMemTemp(I->second, "coerce");
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001173 StoreComplexToAddr(RV.getComplexVal(), SrcPtr, false);
Mike Stump1eb44332009-09-09 15:08:12 +00001174 } else
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001175 SrcPtr = RV.getAggregateAddr();
Chris Lattnerce700162010-06-28 23:44:11 +00001176
Chris Lattnerce700162010-06-28 23:44:11 +00001177 // If the coerce-to type is a first class aggregate, we flatten it and
1178 // pass the elements. Either way is semantically identical, but fast-isel
1179 // and the optimizer generally likes scalar values better than FCAs.
1180 if (const llvm::StructType *STy =
Chris Lattner309c59f2010-06-29 00:06:42 +00001181 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType())) {
Chris Lattner92826882010-07-05 20:41:41 +00001182 SrcPtr = Builder.CreateBitCast(SrcPtr,
1183 llvm::PointerType::getUnqual(STy));
1184 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1185 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i);
Chris Lattnerdeabde22010-07-28 18:24:28 +00001186 llvm::LoadInst *LI = Builder.CreateLoad(EltPtr);
1187 // We don't know what we're loading from.
1188 LI->setAlignment(1);
1189 Args.push_back(LI);
Chris Lattner309c59f2010-06-29 00:06:42 +00001190 }
Chris Lattnerce700162010-06-28 23:44:11 +00001191 } else {
Chris Lattner309c59f2010-06-29 00:06:42 +00001192 // In the simple case, just pass the coerced loaded value.
1193 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(),
1194 *this));
Chris Lattnerce700162010-06-28 23:44:11 +00001195 }
1196
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001197 break;
1198 }
1199
Daniel Dunbar56273772008-09-17 00:51:38 +00001200 case ABIArgInfo::Expand:
1201 ExpandTypeToArgs(I->second, RV, Args);
1202 break;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001203 }
1204 }
Mike Stump1eb44332009-09-09 15:08:12 +00001205
Chris Lattner5db7ae52009-06-13 00:26:38 +00001206 // If the callee is a bitcast of a function to a varargs pointer to function
1207 // type, check to see if we can remove the bitcast. This handles some cases
1208 // with unprototyped functions.
1209 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee))
1210 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
1211 const llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType());
1212 const llvm::FunctionType *CurFT =
1213 cast<llvm::FunctionType>(CurPT->getElementType());
1214 const llvm::FunctionType *ActualFT = CalleeF->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +00001215
Chris Lattner5db7ae52009-06-13 00:26:38 +00001216 if (CE->getOpcode() == llvm::Instruction::BitCast &&
1217 ActualFT->getReturnType() == CurFT->getReturnType() &&
Chris Lattnerd6bebbf2009-06-23 01:38:41 +00001218 ActualFT->getNumParams() == CurFT->getNumParams() &&
1219 ActualFT->getNumParams() == Args.size()) {
Chris Lattner5db7ae52009-06-13 00:26:38 +00001220 bool ArgsMatch = true;
1221 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i)
1222 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) {
1223 ArgsMatch = false;
1224 break;
1225 }
Mike Stump1eb44332009-09-09 15:08:12 +00001226
Chris Lattner5db7ae52009-06-13 00:26:38 +00001227 // Strip the cast if we can get away with it. This is a nice cleanup,
1228 // but also allows us to inline the function at -O0 if it is marked
1229 // always_inline.
1230 if (ArgsMatch)
1231 Callee = CalleeF;
1232 }
1233 }
Mike Stump1eb44332009-09-09 15:08:12 +00001234
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001235
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001236 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +00001237 CodeGen::AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001238 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, CallingConv);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001239 llvm::AttrListPtr Attrs = llvm::AttrListPtr::get(AttributeList.begin(),
1240 AttributeList.end());
Mike Stump1eb44332009-09-09 15:08:12 +00001241
John McCallf1549f62010-07-06 01:34:17 +00001242 llvm::BasicBlock *InvokeDest = 0;
1243 if (!(Attrs.getFnAttributes() & llvm::Attribute::NoUnwind))
1244 InvokeDest = getInvokeDest();
1245
Daniel Dunbard14151d2009-03-02 04:32:35 +00001246 llvm::CallSite CS;
John McCallf1549f62010-07-06 01:34:17 +00001247 if (!InvokeDest) {
Jay Foadbeaaccd2009-05-21 09:52:38 +00001248 CS = Builder.CreateCall(Callee, Args.data(), Args.data()+Args.size());
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001249 } else {
1250 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Mike Stump1eb44332009-09-09 15:08:12 +00001251 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest,
Jay Foadbeaaccd2009-05-21 09:52:38 +00001252 Args.data(), Args.data()+Args.size());
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001253 EmitBlock(Cont);
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00001254 }
Chris Lattnerce933992010-06-29 16:40:28 +00001255 if (callOrInvoke)
David Chisnall4b02afc2010-05-02 13:41:58 +00001256 *callOrInvoke = CS.getInstruction();
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00001257
Daniel Dunbard14151d2009-03-02 04:32:35 +00001258 CS.setAttributes(Attrs);
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001259 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbard14151d2009-03-02 04:32:35 +00001260
1261 // If the call doesn't return, finish the basic block and clear the
1262 // insertion point; this allows the rest of IRgen to discard
1263 // unreachable code.
1264 if (CS.doesNotReturn()) {
1265 Builder.CreateUnreachable();
1266 Builder.ClearInsertionPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00001267
Mike Stumpf5408fe2009-05-16 07:57:57 +00001268 // FIXME: For now, emit a dummy basic block because expr emitters in
1269 // generally are not ready to handle emitting expressions at unreachable
1270 // points.
Daniel Dunbard14151d2009-03-02 04:32:35 +00001271 EnsureInsertPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00001272
Daniel Dunbard14151d2009-03-02 04:32:35 +00001273 // Return a reasonable RValue.
1274 return GetUndefRValue(RetTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001275 }
Daniel Dunbard14151d2009-03-02 04:32:35 +00001276
1277 llvm::Instruction *CI = CS.getInstruction();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00001278 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy())
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001279 CI->setName("call");
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001280
1281 switch (RetAI.getKind()) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +00001282 case ABIArgInfo::Indirect:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001283 if (RetTy->isAnyComplexType())
Daniel Dunbar56273772008-09-17 00:51:38 +00001284 return RValue::getComplex(LoadComplexFromAddr(Args[0], false));
Chris Lattner34030842009-03-22 00:32:22 +00001285 if (CodeGenFunction::hasAggregateLLVMType(RetTy))
Daniel Dunbar56273772008-09-17 00:51:38 +00001286 return RValue::getAggregate(Args[0]);
Chris Lattner34030842009-03-22 00:32:22 +00001287 return RValue::get(EmitLoadOfScalar(Args[0], false, RetTy));
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001288
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001289 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001290 case ABIArgInfo::Direct:
Daniel Dunbar2fbf2f52009-02-05 11:13:54 +00001291 if (RetTy->isAnyComplexType()) {
1292 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
1293 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
1294 return RValue::getComplex(std::make_pair(Real, Imag));
Chris Lattner34030842009-03-22 00:32:22 +00001295 }
1296 if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
Anders Carlssond2490a92009-12-24 20:40:36 +00001297 llvm::Value *DestPtr = ReturnValue.getValue();
1298 bool DestIsVolatile = ReturnValue.isVolatile();
1299
1300 if (!DestPtr) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00001301 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
Anders Carlssond2490a92009-12-24 20:40:36 +00001302 DestIsVolatile = false;
1303 }
1304 Builder.CreateStore(CI, DestPtr, DestIsVolatile);
1305 return RValue::getAggregate(DestPtr);
Chris Lattner34030842009-03-22 00:32:22 +00001306 }
1307 return RValue::get(CI);
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001308
Daniel Dunbar11434922009-01-26 21:26:08 +00001309 case ABIArgInfo::Ignore:
Daniel Dunbar0bcc5212009-02-03 06:30:17 +00001310 // If we are ignoring an argument that had a result, make sure to
1311 // construct the appropriate return value for our caller.
Daniel Dunbar13e81732009-02-05 07:09:07 +00001312 return GetUndefRValue(RetTy);
Daniel Dunbar11434922009-01-26 21:26:08 +00001313
Daniel Dunbar639ffe42008-09-10 07:04:09 +00001314 case ABIArgInfo::Coerce: {
Anders Carlssond2490a92009-12-24 20:40:36 +00001315 llvm::Value *DestPtr = ReturnValue.getValue();
1316 bool DestIsVolatile = ReturnValue.isVolatile();
1317
1318 if (!DestPtr) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00001319 DestPtr = CreateMemTemp(RetTy, "coerce");
Anders Carlssond2490a92009-12-24 20:40:36 +00001320 DestIsVolatile = false;
1321 }
1322
1323 CreateCoercedStore(CI, DestPtr, DestIsVolatile, *this);
Anders Carlssonad3d6912008-11-25 22:21:48 +00001324 if (RetTy->isAnyComplexType())
Anders Carlssond2490a92009-12-24 20:40:36 +00001325 return RValue::getComplex(LoadComplexFromAddr(DestPtr, false));
Chris Lattner34030842009-03-22 00:32:22 +00001326 if (CodeGenFunction::hasAggregateLLVMType(RetTy))
Anders Carlssond2490a92009-12-24 20:40:36 +00001327 return RValue::getAggregate(DestPtr);
1328 return RValue::get(EmitLoadOfScalar(DestPtr, false, RetTy));
Daniel Dunbar639ffe42008-09-10 07:04:09 +00001329 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001330
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001331 case ABIArgInfo::Expand:
Mike Stump1eb44332009-09-09 15:08:12 +00001332 assert(0 && "Invalid ABI kind for return argument");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001333 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001334
1335 assert(0 && "Unhandled ABIArgInfo::Kind");
1336 return RValue::get(0);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001337}
Daniel Dunbarb4094ea2009-02-10 20:44:09 +00001338
1339/* VarArg handling */
1340
1341llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) {
1342 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this);
1343}