blob: c29230f75bf8450fa323a1eb2e494e84d0d55287 [file] [log] [blame]
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001//===--- CGCall.cpp - Encapsulate calling convention details ----*- C++ -*-===//
Daniel Dunbar0dbe2272008-09-08 21:33:45 +00002//
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"
Chandler Carruth55fc8732012-12-04 09:13:33 +000017#include "CGCXXABI.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000018#include "CodeGenFunction.h"
Daniel Dunbarb7688072008-09-10 00:41:16 +000019#include "CodeGenModule.h"
John McCallde5d3c72012-02-17 03:33:10 +000020#include "TargetInfo.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000021#include "clang/AST/Decl.h"
Anders Carlssonf6f8ae52009-04-03 22:48:58 +000022#include "clang/AST/DeclCXX.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000023#include "clang/AST/DeclObjC.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000024#include "clang/Basic/TargetInfo.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000025#include "clang/Frontend/CodeGenOptions.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000026#include "llvm/IR/Attributes.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/InlineAsm.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000029#include "llvm/Support/CallSite.h"
Eli Friedman97cb5a42011-06-15 22:09:18 +000030#include "llvm/Transforms/Utils/Local.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000031using namespace clang;
32using namespace CodeGen;
33
34/***/
35
John McCall04a67a62010-02-05 21:31:56 +000036static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) {
37 switch (CC) {
38 default: return llvm::CallingConv::C;
39 case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
40 case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
Douglas Gregorf813a2c2010-05-18 16:57:00 +000041 case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
Anton Korobeynikov414d8962011-04-14 20:06:49 +000042 case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
43 case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
Guy Benyei38980082012-12-25 08:53:55 +000044 case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;
Dawn Perchik52fc3142010-09-03 01:29:35 +000045 // TODO: add support for CC_X86Pascal to llvm
John McCall04a67a62010-02-05 21:31:56 +000046 }
47}
48
John McCall0b0ef0a2010-02-24 07:14:12 +000049/// Derives the 'this' type for codegen purposes, i.e. ignoring method
50/// qualification.
51/// FIXME: address space qualification?
John McCallead608a2010-02-26 00:48:12 +000052static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) {
53 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
54 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +000055}
56
John McCall0b0ef0a2010-02-24 07:14:12 +000057/// Returns the canonical formal type of the given C++ method.
John McCallead608a2010-02-26 00:48:12 +000058static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
59 return MD->getType()->getCanonicalTypeUnqualified()
60 .getAs<FunctionProtoType>();
John McCall0b0ef0a2010-02-24 07:14:12 +000061}
62
63/// Returns the "extra-canonicalized" return type, which discards
64/// qualifiers on the return type. Codegen doesn't care about them,
65/// and it makes ABI code a little easier to be able to assume that
66/// all parameter and return types are top-level unqualified.
John McCallead608a2010-02-26 00:48:12 +000067static CanQualType GetReturnType(QualType RetTy) {
68 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
John McCall0b0ef0a2010-02-24 07:14:12 +000069}
70
John McCall0f3d0972012-07-07 06:41:13 +000071/// Arrange the argument and result information for a value of the given
72/// unprototyped freestanding function type.
John McCall0b0ef0a2010-02-24 07:14:12 +000073const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +000074CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
John McCallde5d3c72012-02-17 03:33:10 +000075 // When translating an unprototyped function type, always use a
76 // variadic type.
John McCall0f3d0972012-07-07 06:41:13 +000077 return arrangeLLVMFunctionInfo(FTNP->getResultType().getUnqualifiedType(),
78 ArrayRef<CanQualType>(),
79 FTNP->getExtInfo(),
80 RequiredArgs(0));
John McCall0b0ef0a2010-02-24 07:14:12 +000081}
82
John McCall0f3d0972012-07-07 06:41:13 +000083/// Arrange the LLVM function layout for a value of the given function
84/// type, on top of any implicit parameters already stored. Use the
85/// given ExtInfo instead of the ExtInfo from the function type.
86static const CGFunctionInfo &arrangeLLVMFunctionInfo(CodeGenTypes &CGT,
87 SmallVectorImpl<CanQualType> &prefix,
88 CanQual<FunctionProtoType> FTP,
89 FunctionType::ExtInfo extInfo) {
90 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, prefix.size());
Daniel Dunbar541b63b2009-02-02 23:23:47 +000091 // FIXME: Kill copy.
Daniel Dunbar45c25ba2008-09-10 04:01:49 +000092 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
John McCall0f3d0972012-07-07 06:41:13 +000093 prefix.push_back(FTP->getArgType(i));
John McCallde5d3c72012-02-17 03:33:10 +000094 CanQualType resultType = FTP->getResultType().getUnqualifiedType();
John McCall0f3d0972012-07-07 06:41:13 +000095 return CGT.arrangeLLVMFunctionInfo(resultType, prefix, extInfo, required);
96}
97
98/// Arrange the argument and result information for a free function (i.e.
99/// not a C++ or ObjC instance method) of the given type.
100static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT,
101 SmallVectorImpl<CanQualType> &prefix,
102 CanQual<FunctionProtoType> FTP) {
103 return arrangeLLVMFunctionInfo(CGT, prefix, FTP, FTP->getExtInfo());
104}
105
106/// Given the formal ext-info of a C++ instance method, adjust it
107/// according to the C++ ABI in effect.
108static void adjustCXXMethodInfo(CodeGenTypes &CGT,
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000109 FunctionType::ExtInfo &extInfo,
110 bool isVariadic) {
111 if (extInfo.getCC() == CC_Default) {
112 CallingConv CC = CGT.getContext().getDefaultCXXMethodCallConv(isVariadic);
113 extInfo = extInfo.withCallingConv(CC);
114 }
John McCall0f3d0972012-07-07 06:41:13 +0000115}
116
117/// Arrange the argument and result information for a free function (i.e.
118/// not a C++ or ObjC instance method) of the given type.
119static const CGFunctionInfo &arrangeCXXMethodType(CodeGenTypes &CGT,
120 SmallVectorImpl<CanQualType> &prefix,
121 CanQual<FunctionProtoType> FTP) {
122 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000123 adjustCXXMethodInfo(CGT, extInfo, FTP->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000124 return arrangeLLVMFunctionInfo(CGT, prefix, FTP, extInfo);
John McCall0b0ef0a2010-02-24 07:14:12 +0000125}
126
John McCallde5d3c72012-02-17 03:33:10 +0000127/// Arrange the argument and result information for a value of the
John McCall0f3d0972012-07-07 06:41:13 +0000128/// given freestanding function type.
John McCall0b0ef0a2010-02-24 07:14:12 +0000129const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000130CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
John McCallde5d3c72012-02-17 03:33:10 +0000131 SmallVector<CanQualType, 16> argTypes;
John McCall0f3d0972012-07-07 06:41:13 +0000132 return ::arrangeFreeFunctionType(*this, argTypes, FTP);
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000133}
134
John McCall04a67a62010-02-05 21:31:56 +0000135static CallingConv getCallingConventionForDecl(const Decl *D) {
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000136 // Set the appropriate calling convention for the Function.
137 if (D->hasAttr<StdCallAttr>())
John McCall04a67a62010-02-05 21:31:56 +0000138 return CC_X86StdCall;
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000139
140 if (D->hasAttr<FastCallAttr>())
John McCall04a67a62010-02-05 21:31:56 +0000141 return CC_X86FastCall;
Daniel Dunbarbac7c252009-09-11 22:24:53 +0000142
Douglas Gregorf813a2c2010-05-18 16:57:00 +0000143 if (D->hasAttr<ThisCallAttr>())
144 return CC_X86ThisCall;
145
Dawn Perchik52fc3142010-09-03 01:29:35 +0000146 if (D->hasAttr<PascalAttr>())
147 return CC_X86Pascal;
148
Anton Korobeynikov414d8962011-04-14 20:06:49 +0000149 if (PcsAttr *PCS = D->getAttr<PcsAttr>())
150 return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
151
Derek Schuff263366f2012-10-16 22:30:41 +0000152 if (D->hasAttr<PnaclCallAttr>())
153 return CC_PnaclCall;
154
Guy Benyei38980082012-12-25 08:53:55 +0000155 if (D->hasAttr<IntelOclBiccAttr>())
156 return CC_IntelOclBicc;
157
John McCall04a67a62010-02-05 21:31:56 +0000158 return CC_C;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000159}
160
John McCallde5d3c72012-02-17 03:33:10 +0000161/// Arrange the argument and result information for a call to an
162/// unknown C++ non-static member function of the given abstract type.
163/// The member function must be an ordinary function, i.e. not a
164/// constructor or destructor.
165const CGFunctionInfo &
166CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD,
167 const FunctionProtoType *FTP) {
168 SmallVector<CanQualType, 16> argTypes;
John McCall0b0ef0a2010-02-24 07:14:12 +0000169
Anders Carlsson375c31c2009-10-03 19:43:08 +0000170 // Add the 'this' pointer.
John McCallde5d3c72012-02-17 03:33:10 +0000171 argTypes.push_back(GetThisType(Context, RD));
John McCall0b0ef0a2010-02-24 07:14:12 +0000172
John McCall0f3d0972012-07-07 06:41:13 +0000173 return ::arrangeCXXMethodType(*this, argTypes,
Tilmann Scheller9c6082f2011-03-02 21:36:49 +0000174 FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>());
Anders Carlsson375c31c2009-10-03 19:43:08 +0000175}
176
John McCallde5d3c72012-02-17 03:33:10 +0000177/// Arrange the argument and result information for a declaration or
178/// definition of the given C++ non-static member function. The
179/// member function must be an ordinary function, i.e. not a
180/// constructor or destructor.
181const CGFunctionInfo &
182CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) {
John McCallfc400282010-09-03 01:26:39 +0000183 assert(!isa<CXXConstructorDecl>(MD) && "wrong method for contructors!");
184 assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!");
185
John McCallde5d3c72012-02-17 03:33:10 +0000186 CanQual<FunctionProtoType> prototype = GetFormalType(MD);
Mike Stump1eb44332009-09-09 15:08:12 +0000187
John McCallde5d3c72012-02-17 03:33:10 +0000188 if (MD->isInstance()) {
189 // The abstract case is perfectly fine.
190 return arrangeCXXMethodType(MD->getParent(), prototype.getTypePtr());
191 }
192
John McCall0f3d0972012-07-07 06:41:13 +0000193 return arrangeFreeFunctionType(prototype);
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000194}
195
John McCallde5d3c72012-02-17 03:33:10 +0000196/// Arrange the argument and result information for a declaration
197/// or definition to the given constructor variant.
198const CGFunctionInfo &
199CodeGenTypes::arrangeCXXConstructorDeclaration(const CXXConstructorDecl *D,
200 CXXCtorType ctorKind) {
201 SmallVector<CanQualType, 16> argTypes;
202 argTypes.push_back(GetThisType(Context, D->getParent()));
203 CanQualType resultType = Context.VoidTy;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000204
John McCallde5d3c72012-02-17 03:33:10 +0000205 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes);
John McCall0b0ef0a2010-02-24 07:14:12 +0000206
John McCall4c40d982010-08-31 07:33:07 +0000207 CanQual<FunctionProtoType> FTP = GetFormalType(D);
208
John McCallde5d3c72012-02-17 03:33:10 +0000209 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size());
210
John McCall4c40d982010-08-31 07:33:07 +0000211 // Add the formal parameters.
212 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000213 argTypes.push_back(FTP->getArgType(i));
John McCall4c40d982010-08-31 07:33:07 +0000214
John McCall0f3d0972012-07-07 06:41:13 +0000215 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000216 adjustCXXMethodInfo(*this, extInfo, FTP->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000217 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000218}
219
John McCallde5d3c72012-02-17 03:33:10 +0000220/// Arrange the argument and result information for a declaration,
221/// definition, or call to the given destructor variant. It so
222/// happens that all three cases produce the same information.
223const CGFunctionInfo &
224CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D,
225 CXXDtorType dtorKind) {
226 SmallVector<CanQualType, 2> argTypes;
227 argTypes.push_back(GetThisType(Context, D->getParent()));
228 CanQualType resultType = Context.VoidTy;
John McCall0b0ef0a2010-02-24 07:14:12 +0000229
John McCallde5d3c72012-02-17 03:33:10 +0000230 TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes);
John McCall4c40d982010-08-31 07:33:07 +0000231
232 CanQual<FunctionProtoType> FTP = GetFormalType(D);
233 assert(FTP->getNumArgs() == 0 && "dtor with formal parameters");
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000234 assert(FTP->isVariadic() == 0 && "dtor with formal parameters");
John McCall4c40d982010-08-31 07:33:07 +0000235
John McCall0f3d0972012-07-07 06:41:13 +0000236 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000237 adjustCXXMethodInfo(*this, extInfo, false);
John McCall0f3d0972012-07-07 06:41:13 +0000238 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo,
239 RequiredArgs::All);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000240}
241
John McCallde5d3c72012-02-17 03:33:10 +0000242/// Arrange the argument and result information for the declaration or
243/// definition of the given function.
244const CGFunctionInfo &
245CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
Chris Lattner3eb67ca2009-05-12 20:27:19 +0000246 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000247 if (MD->isInstance())
John McCallde5d3c72012-02-17 03:33:10 +0000248 return arrangeCXXMethodDeclaration(MD);
Mike Stump1eb44332009-09-09 15:08:12 +0000249
John McCallead608a2010-02-26 00:48:12 +0000250 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
John McCallde5d3c72012-02-17 03:33:10 +0000251
John McCallead608a2010-02-26 00:48:12 +0000252 assert(isa<FunctionType>(FTy));
John McCallde5d3c72012-02-17 03:33:10 +0000253
254 // When declaring a function without a prototype, always use a
255 // non-variadic type.
256 if (isa<FunctionNoProtoType>(FTy)) {
257 CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>();
John McCall0f3d0972012-07-07 06:41:13 +0000258 return arrangeLLVMFunctionInfo(noProto->getResultType(),
259 ArrayRef<CanQualType>(),
260 noProto->getExtInfo(),
261 RequiredArgs::All);
John McCallde5d3c72012-02-17 03:33:10 +0000262 }
263
John McCallead608a2010-02-26 00:48:12 +0000264 assert(isa<FunctionProtoType>(FTy));
John McCall0f3d0972012-07-07 06:41:13 +0000265 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>());
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000266}
267
John McCallde5d3c72012-02-17 03:33:10 +0000268/// Arrange the argument and result information for the declaration or
269/// definition of an Objective-C method.
270const CGFunctionInfo &
271CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) {
272 // It happens that this is the same as a call with no optional
273 // arguments, except also using the formal 'self' type.
274 return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType());
275}
276
277/// Arrange the argument and result information for the function type
278/// through which to perform a send to the given Objective-C method,
279/// using the given receiver type. The receiver type is not always
280/// the 'self' type of the method or even an Objective-C pointer type.
281/// This is *not* the right method for actually performing such a
282/// message send, due to the possibility of optional arguments.
283const CGFunctionInfo &
284CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
285 QualType receiverType) {
286 SmallVector<CanQualType, 16> argTys;
287 argTys.push_back(Context.getCanonicalParamType(receiverType));
288 argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000289 // FIXME: Kill copy?
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000290 for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(),
John McCall0b0ef0a2010-02-24 07:14:12 +0000291 e = MD->param_end(); i != e; ++i) {
John McCallde5d3c72012-02-17 03:33:10 +0000292 argTys.push_back(Context.getCanonicalParamType((*i)->getType()));
John McCall0b0ef0a2010-02-24 07:14:12 +0000293 }
John McCallf85e1932011-06-15 23:02:42 +0000294
295 FunctionType::ExtInfo einfo;
296 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD));
297
David Blaikie4e4d0842012-03-11 07:00:24 +0000298 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +0000299 MD->hasAttr<NSReturnsRetainedAttr>())
300 einfo = einfo.withProducesResult(true);
301
John McCallde5d3c72012-02-17 03:33:10 +0000302 RequiredArgs required =
303 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
304
John McCall0f3d0972012-07-07 06:41:13 +0000305 return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys,
306 einfo, required);
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000307}
308
John McCallde5d3c72012-02-17 03:33:10 +0000309const CGFunctionInfo &
310CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000311 // FIXME: Do we need to handle ObjCMethodDecl?
312 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000313
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000314 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000315 return arrangeCXXConstructorDeclaration(CD, GD.getCtorType());
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000316
317 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000318 return arrangeCXXDestructor(DD, GD.getDtorType());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000319
John McCallde5d3c72012-02-17 03:33:10 +0000320 return arrangeFunctionDeclaration(FD);
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000321}
322
John McCalle56bb362012-12-07 07:03:17 +0000323/// Arrange a call as unto a free function, except possibly with an
324/// additional number of formal parameters considered required.
325static const CGFunctionInfo &
326arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
327 const CallArgList &args,
328 const FunctionType *fnType,
329 unsigned numExtraRequiredArgs) {
330 assert(args.size() >= numExtraRequiredArgs);
331
332 // In most cases, there are no optional arguments.
333 RequiredArgs required = RequiredArgs::All;
334
335 // If we have a variadic prototype, the required arguments are the
336 // extra prefix plus the arguments in the prototype.
337 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
338 if (proto->isVariadic())
339 required = RequiredArgs(proto->getNumArgs() + numExtraRequiredArgs);
340
341 // If we don't have a prototype at all, but we're supposed to
342 // explicitly use the variadic convention for unprototyped calls,
343 // treat all of the arguments as required but preserve the nominal
344 // possibility of variadics.
345 } else if (CGT.CGM.getTargetCodeGenInfo()
346 .isNoProtoCallVariadic(args, cast<FunctionNoProtoType>(fnType))) {
347 required = RequiredArgs(args.size());
348 }
349
350 return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args,
351 fnType->getExtInfo(), required);
352}
353
John McCallde5d3c72012-02-17 03:33:10 +0000354/// Figure out the rules for calling a function with the given formal
355/// type using the given arguments. The arguments are necessary
356/// because the function might be unprototyped, in which case it's
357/// target-dependent in crazy ways.
358const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000359CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
360 const FunctionType *fnType) {
John McCalle56bb362012-12-07 07:03:17 +0000361 return arrangeFreeFunctionLikeCall(*this, args, fnType, 0);
362}
John McCallde5d3c72012-02-17 03:33:10 +0000363
John McCalle56bb362012-12-07 07:03:17 +0000364/// A block function call is essentially a free-function call with an
365/// extra implicit argument.
366const CGFunctionInfo &
367CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
368 const FunctionType *fnType) {
369 return arrangeFreeFunctionLikeCall(*this, args, fnType, 1);
John McCallde5d3c72012-02-17 03:33:10 +0000370}
371
372const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000373CodeGenTypes::arrangeFreeFunctionCall(QualType resultType,
374 const CallArgList &args,
375 FunctionType::ExtInfo info,
376 RequiredArgs required) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000377 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000378 SmallVector<CanQualType, 16> argTypes;
379 for (CallArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbar725ad312009-01-31 02:19:00 +0000380 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000381 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
John McCall0f3d0972012-07-07 06:41:13 +0000382 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
383 required);
384}
385
386/// Arrange a call to a C++ method, passing the given arguments.
387const CGFunctionInfo &
388CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
389 const FunctionProtoType *FPT,
390 RequiredArgs required) {
391 // FIXME: Kill copy.
392 SmallVector<CanQualType, 16> argTypes;
393 for (CallArgList::const_iterator i = args.begin(), e = args.end();
394 i != e; ++i)
395 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
396
397 FunctionType::ExtInfo info = FPT->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000398 adjustCXXMethodInfo(*this, info, FPT->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000399 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()),
400 argTypes, info, required);
Daniel Dunbar725ad312009-01-31 02:19:00 +0000401}
402
John McCallde5d3c72012-02-17 03:33:10 +0000403const CGFunctionInfo &
404CodeGenTypes::arrangeFunctionDeclaration(QualType resultType,
405 const FunctionArgList &args,
406 const FunctionType::ExtInfo &info,
407 bool isVariadic) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000408 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000409 SmallVector<CanQualType, 16> argTypes;
410 for (FunctionArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000411 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000412 argTypes.push_back(Context.getCanonicalParamType((*i)->getType()));
413
414 RequiredArgs required =
415 (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All);
John McCall0f3d0972012-07-07 06:41:13 +0000416 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
417 required);
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000418}
419
John McCallde5d3c72012-02-17 03:33:10 +0000420const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
John McCall0f3d0972012-07-07 06:41:13 +0000421 return arrangeLLVMFunctionInfo(getContext().VoidTy, ArrayRef<CanQualType>(),
422 FunctionType::ExtInfo(), RequiredArgs::All);
John McCalld26bc762011-03-09 04:27:21 +0000423}
424
John McCallde5d3c72012-02-17 03:33:10 +0000425/// Arrange the argument and result information for an abstract value
426/// of a given function type. This is the method which all of the
427/// above functions ultimately defer to.
428const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000429CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
430 ArrayRef<CanQualType> argTypes,
431 FunctionType::ExtInfo info,
432 RequiredArgs required) {
John McCallead608a2010-02-26 00:48:12 +0000433#ifndef NDEBUG
John McCallde5d3c72012-02-17 03:33:10 +0000434 for (ArrayRef<CanQualType>::const_iterator
435 I = argTypes.begin(), E = argTypes.end(); I != E; ++I)
John McCallead608a2010-02-26 00:48:12 +0000436 assert(I->isCanonicalAsParam());
437#endif
438
John McCallde5d3c72012-02-17 03:33:10 +0000439 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
John McCall04a67a62010-02-05 21:31:56 +0000440
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000441 // Lookup or create unique function info.
442 llvm::FoldingSetNodeID ID;
John McCallde5d3c72012-02-17 03:33:10 +0000443 CGFunctionInfo::Profile(ID, info, required, resultType, argTypes);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000444
John McCallde5d3c72012-02-17 03:33:10 +0000445 void *insertPos = 0;
446 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000447 if (FI)
448 return *FI;
449
John McCallde5d3c72012-02-17 03:33:10 +0000450 // Construct the function info. We co-allocate the ArgInfos.
451 FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required);
452 FunctionInfos.InsertNode(FI, insertPos);
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000453
John McCallde5d3c72012-02-17 03:33:10 +0000454 bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted;
455 assert(inserted && "Recursively being processed?");
Chris Lattner71305cc2011-07-15 05:16:14 +0000456
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000457 // Compute ABI information.
Chris Lattneree5dcd02010-07-29 02:31:05 +0000458 getABIInfo().computeInfo(*FI);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000459
Chris Lattner800588f2010-07-29 06:26:06 +0000460 // Loop over all of the computed argument and return value info. If any of
461 // them are direct or extend without a specified coerce type, specify the
462 // default now.
John McCallde5d3c72012-02-17 03:33:10 +0000463 ABIArgInfo &retInfo = FI->getReturnInfo();
464 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == 0)
465 retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000466
Chris Lattner800588f2010-07-29 06:26:06 +0000467 for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end();
468 I != E; ++I)
469 if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0)
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000470 I->info.setCoerceToType(ConvertType(I->type));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000471
John McCallde5d3c72012-02-17 03:33:10 +0000472 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
473 assert(erased && "Not in set?");
Chris Lattnerd26c0712011-07-15 06:41:05 +0000474
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000475 return *FI;
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000476}
477
John McCallde5d3c72012-02-17 03:33:10 +0000478CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
479 const FunctionType::ExtInfo &info,
480 CanQualType resultType,
481 ArrayRef<CanQualType> argTypes,
482 RequiredArgs required) {
483 void *buffer = operator new(sizeof(CGFunctionInfo) +
484 sizeof(ArgInfo) * (argTypes.size() + 1));
485 CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
486 FI->CallingConvention = llvmCC;
487 FI->EffectiveCallingConvention = llvmCC;
488 FI->ASTCallingConvention = info.getCC();
489 FI->NoReturn = info.getNoReturn();
490 FI->ReturnsRetained = info.getProducesResult();
491 FI->Required = required;
492 FI->HasRegParm = info.getHasRegParm();
493 FI->RegParm = info.getRegParm();
494 FI->NumArgs = argTypes.size();
495 FI->getArgsBuffer()[0].type = resultType;
496 for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
497 FI->getArgsBuffer()[i + 1].type = argTypes[i];
498 return FI;
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000499}
500
501/***/
502
John McCall42e06112011-05-15 02:19:42 +0000503void CodeGenTypes::GetExpandedTypes(QualType type,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000504 SmallVectorImpl<llvm::Type*> &expandedTypes) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000505 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) {
506 uint64_t NumElts = AT->getSize().getZExtValue();
507 for (uint64_t Elt = 0; Elt < NumElts; ++Elt)
508 GetExpandedTypes(AT->getElementType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000509 } else if (const RecordType *RT = type->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000510 const RecordDecl *RD = RT->getDecl();
511 assert(!RD->hasFlexibleArrayMember() &&
512 "Cannot expand structure with flexible array.");
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000513 if (RD->isUnion()) {
514 // Unions can be here only in degenerative cases - all the fields are same
515 // after flattening. Thus we have to use the "largest" field.
516 const FieldDecl *LargestFD = 0;
517 CharUnits UnionSize = CharUnits::Zero();
518
519 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
520 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000521 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000522 assert(!FD->isBitField() &&
523 "Cannot expand structure with bit-field members.");
524 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
525 if (UnionSize < FieldSize) {
526 UnionSize = FieldSize;
527 LargestFD = FD;
528 }
529 }
530 if (LargestFD)
531 GetExpandedTypes(LargestFD->getType(), expandedTypes);
532 } else {
533 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
534 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000535 assert(!i->isBitField() &&
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000536 "Cannot expand structure with bit-field members.");
David Blaikie581deb32012-06-06 20:45:41 +0000537 GetExpandedTypes(i->getType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000538 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000539 }
540 } else if (const ComplexType *CT = type->getAs<ComplexType>()) {
541 llvm::Type *EltTy = ConvertType(CT->getElementType());
542 expandedTypes.push_back(EltTy);
543 expandedTypes.push_back(EltTy);
544 } else
545 expandedTypes.push_back(ConvertType(type));
Daniel Dunbar56273772008-09-17 00:51:38 +0000546}
547
Mike Stump1eb44332009-09-09 15:08:12 +0000548llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +0000549CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
550 llvm::Function::arg_iterator AI) {
Mike Stump1eb44332009-09-09 15:08:12 +0000551 assert(LV.isSimple() &&
552 "Unexpected non-simple lvalue during struct expansion.");
Daniel Dunbar56273772008-09-17 00:51:38 +0000553
Bob Wilson194f06a2011-08-03 05:58:22 +0000554 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
555 unsigned NumElts = AT->getSize().getZExtValue();
556 QualType EltTy = AT->getElementType();
557 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
Eli Friedman377ecc72012-04-16 03:54:45 +0000558 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt);
Bob Wilson194f06a2011-08-03 05:58:22 +0000559 LValue LV = MakeAddrLValue(EltAddr, EltTy);
560 AI = ExpandTypeFromArgs(EltTy, LV, AI);
Daniel Dunbar56273772008-09-17 00:51:38 +0000561 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000562 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000563 RecordDecl *RD = RT->getDecl();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000564 if (RD->isUnion()) {
565 // Unions can be here only in degenerative cases - all the fields are same
566 // after flattening. Thus we have to use the "largest" field.
567 const FieldDecl *LargestFD = 0;
568 CharUnits UnionSize = CharUnits::Zero();
Bob Wilson194f06a2011-08-03 05:58:22 +0000569
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000570 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
571 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000572 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000573 assert(!FD->isBitField() &&
574 "Cannot expand structure with bit-field members.");
575 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
576 if (UnionSize < FieldSize) {
577 UnionSize = FieldSize;
578 LargestFD = FD;
579 }
580 }
581 if (LargestFD) {
582 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000583 LValue SubLV = EmitLValueForField(LV, LargestFD);
584 AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000585 }
586 } else {
587 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
588 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000589 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000590 QualType FT = FD->getType();
591
592 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000593 LValue SubLV = EmitLValueForField(LV, FD);
594 AI = ExpandTypeFromArgs(FT, SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000595 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000596 }
597 } else if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
598 QualType EltTy = CT->getElementType();
Eli Friedman377ecc72012-04-16 03:54:45 +0000599 llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real");
Bob Wilson194f06a2011-08-03 05:58:22 +0000600 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy));
Eli Friedman377ecc72012-04-16 03:54:45 +0000601 llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag");
Bob Wilson194f06a2011-08-03 05:58:22 +0000602 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy));
603 } else {
604 EmitStoreThroughLValue(RValue::get(AI), LV);
605 ++AI;
Daniel Dunbar56273772008-09-17 00:51:38 +0000606 }
607
608 return AI;
609}
610
Chris Lattnere7bb7772010-06-27 06:04:18 +0000611/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
Chris Lattner08dd2a02010-06-27 05:56:15 +0000612/// accessing some number of bytes out of it, try to gep into the struct to get
613/// at its inner goodness. Dive as deep as possible without entering an element
614/// with an in-memory size smaller than DstSize.
615static llvm::Value *
Chris Lattnere7bb7772010-06-27 06:04:18 +0000616EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000617 llvm::StructType *SrcSTy,
Chris Lattnere7bb7772010-06-27 06:04:18 +0000618 uint64_t DstSize, CodeGenFunction &CGF) {
Chris Lattner08dd2a02010-06-27 05:56:15 +0000619 // We can't dive into a zero-element struct.
620 if (SrcSTy->getNumElements() == 0) return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000621
Chris Lattner2acc6e32011-07-18 04:24:23 +0000622 llvm::Type *FirstElt = SrcSTy->getElementType(0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000623
Chris Lattner08dd2a02010-06-27 05:56:15 +0000624 // If the first elt is at least as large as what we're looking for, or if the
625 // first element is the same size as the whole struct, we can enter it.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000626 uint64_t FirstEltSize =
Micah Villmow25a6a842012-10-08 16:25:52 +0000627 CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000628 if (FirstEltSize < DstSize &&
Micah Villmow25a6a842012-10-08 16:25:52 +0000629 FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy))
Chris Lattner08dd2a02010-06-27 05:56:15 +0000630 return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000631
Chris Lattner08dd2a02010-06-27 05:56:15 +0000632 // GEP into the first element.
633 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000634
Chris Lattner08dd2a02010-06-27 05:56:15 +0000635 // If the first element is a struct, recurse.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000636 llvm::Type *SrcTy =
Chris Lattner08dd2a02010-06-27 05:56:15 +0000637 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000638 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
Chris Lattnere7bb7772010-06-27 06:04:18 +0000639 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000640
641 return SrcPtr;
642}
643
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000644/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
645/// are either integers or pointers. This does a truncation of the value if it
646/// is too large or a zero extension if it is too small.
647static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000648 llvm::Type *Ty,
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000649 CodeGenFunction &CGF) {
650 if (Val->getType() == Ty)
651 return Val;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000652
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000653 if (isa<llvm::PointerType>(Val->getType())) {
654 // If this is Pointer->Pointer avoid conversion to and from int.
655 if (isa<llvm::PointerType>(Ty))
656 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000657
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000658 // Convert the pointer to an integer so we can play with its width.
Chris Lattner77b89b82010-06-27 07:15:29 +0000659 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000660 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000661
Chris Lattner2acc6e32011-07-18 04:24:23 +0000662 llvm::Type *DestIntTy = Ty;
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000663 if (isa<llvm::PointerType>(DestIntTy))
Chris Lattner77b89b82010-06-27 07:15:29 +0000664 DestIntTy = CGF.IntPtrTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000665
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000666 if (Val->getType() != DestIntTy)
667 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000668
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000669 if (isa<llvm::PointerType>(Ty))
670 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
671 return Val;
672}
673
Chris Lattner08dd2a02010-06-27 05:56:15 +0000674
675
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000676/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
677/// a pointer to an object of type \arg Ty.
678///
679/// This safely handles the case when the src type is smaller than the
680/// destination type; in this situation the values of bits which not
681/// present in the src are undefined.
682static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000683 llvm::Type *Ty,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000684 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000685 llvm::Type *SrcTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000686 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000687
Chris Lattner6ae00692010-06-28 22:51:39 +0000688 // If SrcTy and Ty are the same, just do a load.
689 if (SrcTy == Ty)
690 return CGF.Builder.CreateLoad(SrcPtr);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000691
Micah Villmow25a6a842012-10-08 16:25:52 +0000692 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000693
Chris Lattner2acc6e32011-07-18 04:24:23 +0000694 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000695 SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000696 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
697 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000698
Micah Villmow25a6a842012-10-08 16:25:52 +0000699 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000700
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000701 // If the source and destination are integer or pointer types, just do an
702 // extension or truncation to the desired type.
703 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
704 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
705 llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr);
706 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
707 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000708
Daniel Dunbarb225be42009-02-03 05:59:18 +0000709 // If load is legal, just bitcast the src pointer.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000710 if (SrcSize >= DstSize) {
Mike Stumpf5408fe2009-05-16 07:57:57 +0000711 // Generally SrcSize is never greater than DstSize, since this means we are
712 // losing bits. However, this can happen in cases where the structure has
713 // additional padding, for example due to a user specified alignment.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000714 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000715 // FIXME: Assert that we aren't truncating non-padding bits when have access
716 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000717 llvm::Value *Casted =
718 CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000719 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted);
720 // FIXME: Use better alignment / avoid requiring aligned load.
721 Load->setAlignment(1);
722 return Load;
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000723 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000724
Chris Lattner35b21b82010-06-27 01:06:27 +0000725 // Otherwise do coercion through memory. This is stupid, but
726 // simple.
727 llvm::Value *Tmp = CGF.CreateTempAlloca(Ty);
Manman Renf51c61c2012-11-28 22:08:52 +0000728 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
729 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
730 llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000731 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000732 CGF.Builder.CreateMemCpy(Casted, SrcCasted,
733 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
734 1, false);
Chris Lattner35b21b82010-06-27 01:06:27 +0000735 return CGF.Builder.CreateLoad(Tmp);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000736}
737
Eli Friedmanbadea572011-05-17 21:08:01 +0000738// Function to store a first-class aggregate into memory. We prefer to
739// store the elements rather than the aggregate to be more friendly to
740// fast-isel.
741// FIXME: Do we need to recurse here?
742static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
743 llvm::Value *DestPtr, bool DestIsVolatile,
744 bool LowAlignment) {
745 // Prefer scalar stores to first-class aggregate stores.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000746 if (llvm::StructType *STy =
Eli Friedmanbadea572011-05-17 21:08:01 +0000747 dyn_cast<llvm::StructType>(Val->getType())) {
748 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
749 llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i);
750 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
751 llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr,
752 DestIsVolatile);
753 if (LowAlignment)
754 SI->setAlignment(1);
755 }
756 } else {
Bill Wendling08212632012-03-16 21:45:12 +0000757 llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile);
758 if (LowAlignment)
759 SI->setAlignment(1);
Eli Friedmanbadea572011-05-17 21:08:01 +0000760 }
761}
762
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000763/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
764/// where the source and destination may have different types.
765///
766/// This safely handles the case when the src type is larger than the
767/// destination type; the upper bits of the src will be lost.
768static void CreateCoercedStore(llvm::Value *Src,
769 llvm::Value *DstPtr,
Anders Carlssond2490a92009-12-24 20:40:36 +0000770 bool DstIsVolatile,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000771 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000772 llvm::Type *SrcTy = Src->getType();
773 llvm::Type *DstTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000774 cast<llvm::PointerType>(DstPtr->getType())->getElementType();
Chris Lattner6ae00692010-06-28 22:51:39 +0000775 if (SrcTy == DstTy) {
776 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
777 return;
778 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000779
Micah Villmow25a6a842012-10-08 16:25:52 +0000780 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000781
Chris Lattner2acc6e32011-07-18 04:24:23 +0000782 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000783 DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF);
784 DstTy = cast<llvm::PointerType>(DstPtr->getType())->getElementType();
785 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000786
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000787 // If the source and destination are integer or pointer types, just do an
788 // extension or truncation to the desired type.
789 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
790 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
791 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
792 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
793 return;
794 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000795
Micah Villmow25a6a842012-10-08 16:25:52 +0000796 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000797
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000798 // If store is legal, just bitcast the src pointer.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000799 if (SrcSize <= DstSize) {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000800 llvm::Value *Casted =
801 CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000802 // FIXME: Use better alignment / avoid requiring aligned store.
Eli Friedmanbadea572011-05-17 21:08:01 +0000803 BuildAggStore(CGF, Src, Casted, DstIsVolatile, true);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000804 } else {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000805 // Otherwise do coercion through memory. This is stupid, but
806 // simple.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000807
808 // Generally SrcSize is never greater than DstSize, since this means we are
809 // losing bits. However, this can happen in cases where the structure has
810 // additional padding, for example due to a user specified alignment.
811 //
812 // FIXME: Assert that we aren't truncating non-padding bits when have access
813 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000814 llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy);
815 CGF.Builder.CreateStore(Src, Tmp);
Manman Renf51c61c2012-11-28 22:08:52 +0000816 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
817 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
818 llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000819 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000820 CGF.Builder.CreateMemCpy(DstCasted, Casted,
821 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
822 1, false);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000823 }
824}
825
Daniel Dunbar56273772008-09-17 00:51:38 +0000826/***/
827
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000828bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000829 return FI.getReturnInfo().isIndirect();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000830}
831
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000832bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
833 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
834 switch (BT->getKind()) {
835 default:
836 return false;
837 case BuiltinType::Float:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000838 return getContext().getTargetInfo().useObjCFPRetForRealType(TargetInfo::Float);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000839 case BuiltinType::Double:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000840 return getContext().getTargetInfo().useObjCFPRetForRealType(TargetInfo::Double);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000841 case BuiltinType::LongDouble:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000842 return getContext().getTargetInfo().useObjCFPRetForRealType(
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000843 TargetInfo::LongDouble);
844 }
845 }
846
847 return false;
848}
849
Anders Carlssoneea64802011-10-31 16:27:11 +0000850bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) {
851 if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
852 if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
853 if (BT->getKind() == BuiltinType::LongDouble)
854 return getContext().getTargetInfo().useObjCFP2RetForComplexLongDouble();
855 }
856 }
857
858 return false;
859}
860
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000861llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
John McCallde5d3c72012-02-17 03:33:10 +0000862 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
863 return GetFunctionType(FI);
John McCallc0bf4622010-02-23 00:48:20 +0000864}
865
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000866llvm::FunctionType *
John McCallde5d3c72012-02-17 03:33:10 +0000867CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
Chris Lattner71305cc2011-07-15 05:16:14 +0000868
869 bool Inserted = FunctionsBeingProcessed.insert(&FI); (void)Inserted;
870 assert(Inserted && "Recursively being processed?");
871
Chris Lattner5f9e2722011-07-23 10:55:15 +0000872 SmallVector<llvm::Type*, 8> argTypes;
Chris Lattner2acc6e32011-07-18 04:24:23 +0000873 llvm::Type *resultType = 0;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000874
John McCall42e06112011-05-15 02:19:42 +0000875 const ABIArgInfo &retAI = FI.getReturnInfo();
876 switch (retAI.getKind()) {
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000877 case ABIArgInfo::Expand:
John McCall42e06112011-05-15 02:19:42 +0000878 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000879
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000880 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000881 case ABIArgInfo::Direct:
John McCall42e06112011-05-15 02:19:42 +0000882 resultType = retAI.getCoerceToType();
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000883 break;
884
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000885 case ABIArgInfo::Indirect: {
John McCall42e06112011-05-15 02:19:42 +0000886 assert(!retAI.getIndirectAlign() && "Align unused on indirect return.");
887 resultType = llvm::Type::getVoidTy(getLLVMContext());
888
889 QualType ret = FI.getReturnType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000890 llvm::Type *ty = ConvertType(ret);
John McCall42e06112011-05-15 02:19:42 +0000891 unsigned addressSpace = Context.getTargetAddressSpace(ret);
892 argTypes.push_back(llvm::PointerType::get(ty, addressSpace));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000893 break;
894 }
895
Daniel Dunbar11434922009-01-26 21:26:08 +0000896 case ABIArgInfo::Ignore:
John McCall42e06112011-05-15 02:19:42 +0000897 resultType = llvm::Type::getVoidTy(getLLVMContext());
Daniel Dunbar11434922009-01-26 21:26:08 +0000898 break;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000899 }
Mike Stump1eb44332009-09-09 15:08:12 +0000900
John McCalle56bb362012-12-07 07:03:17 +0000901 // Add in all of the required arguments.
902 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie;
903 if (FI.isVariadic()) {
904 ie = it + FI.getRequiredArgs().getNumRequiredArgs();
905 } else {
906 ie = FI.arg_end();
907 }
908 for (; it != ie; ++it) {
John McCall42e06112011-05-15 02:19:42 +0000909 const ABIArgInfo &argAI = it->info;
Mike Stump1eb44332009-09-09 15:08:12 +0000910
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +0000911 // Insert a padding type to ensure proper alignment.
912 if (llvm::Type *PaddingType = argAI.getPaddingType())
913 argTypes.push_back(PaddingType);
914
John McCall42e06112011-05-15 02:19:42 +0000915 switch (argAI.getKind()) {
Daniel Dunbar11434922009-01-26 21:26:08 +0000916 case ABIArgInfo::Ignore:
917 break;
918
Chris Lattner800588f2010-07-29 06:26:06 +0000919 case ABIArgInfo::Indirect: {
920 // indirect arguments are always on the stack, which is addr space #0.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000921 llvm::Type *LTy = ConvertTypeForMem(it->type);
John McCall42e06112011-05-15 02:19:42 +0000922 argTypes.push_back(LTy->getPointerTo());
Chris Lattner800588f2010-07-29 06:26:06 +0000923 break;
924 }
925
926 case ABIArgInfo::Extend:
Chris Lattner1ed72672010-07-29 06:44:09 +0000927 case ABIArgInfo::Direct: {
Chris Lattnerce700162010-06-28 23:44:11 +0000928 // If the coerce-to type is a first class aggregate, flatten it. Either
929 // way is semantically identical, but fast-isel and the optimizer
930 // generally likes scalar values better than FCAs.
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000931 llvm::Type *argType = argAI.getCoerceToType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000932 if (llvm::StructType *st = dyn_cast<llvm::StructType>(argType)) {
John McCall42e06112011-05-15 02:19:42 +0000933 for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
934 argTypes.push_back(st->getElementType(i));
Chris Lattnerce700162010-06-28 23:44:11 +0000935 } else {
John McCall42e06112011-05-15 02:19:42 +0000936 argTypes.push_back(argType);
Chris Lattnerce700162010-06-28 23:44:11 +0000937 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000938 break;
Chris Lattner1ed72672010-07-29 06:44:09 +0000939 }
Mike Stump1eb44332009-09-09 15:08:12 +0000940
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000941 case ABIArgInfo::Expand:
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000942 GetExpandedTypes(it->type, argTypes);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000943 break;
944 }
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000945 }
946
Chris Lattner71305cc2011-07-15 05:16:14 +0000947 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
948 assert(Erased && "Not in set?");
949
John McCallde5d3c72012-02-17 03:33:10 +0000950 return llvm::FunctionType::get(resultType, argTypes, FI.isVariadic());
Daniel Dunbar3913f182008-09-09 23:48:28 +0000951}
952
Chris Lattner2acc6e32011-07-18 04:24:23 +0000953llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
John McCall4c40d982010-08-31 07:33:07 +0000954 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlssonecf282b2009-11-24 05:08:52 +0000955 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000956
Chris Lattnerf742eb02011-07-10 00:18:59 +0000957 if (!isFuncTypeConvertible(FPT))
958 return llvm::StructType::get(getLLVMContext());
959
960 const CGFunctionInfo *Info;
961 if (isa<CXXDestructorDecl>(MD))
John McCallde5d3c72012-02-17 03:33:10 +0000962 Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType());
Chris Lattnerf742eb02011-07-10 00:18:59 +0000963 else
John McCallde5d3c72012-02-17 03:33:10 +0000964 Info = &arrangeCXXMethodDeclaration(MD);
965 return GetFunctionType(*Info);
Anders Carlssonecf282b2009-11-24 05:08:52 +0000966}
967
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000968void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
Daniel Dunbar88b53962009-02-02 22:03:45 +0000969 const Decl *TargetDecl,
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000970 AttributeListType &PAL,
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000971 unsigned &CallingConv) {
Bill Wendling0d583392012-10-15 20:36:26 +0000972 llvm::AttrBuilder FuncAttrs;
973 llvm::AttrBuilder RetAttrs;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000974
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000975 CallingConv = FI.getEffectiveCallingConvention();
976
John McCall04a67a62010-02-05 21:31:56 +0000977 if (FI.isNoReturn())
Bill Wendling72390b32012-12-20 19:27:06 +0000978 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCall04a67a62010-02-05 21:31:56 +0000979
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000980 // FIXME: handle sseregparm someday...
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000981 if (TargetDecl) {
Rafael Espindola67004152011-10-12 19:51:18 +0000982 if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000983 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000984 if (TargetDecl->hasAttr<NoThrowAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000985 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
John McCall9c0c1f32010-07-08 06:48:12 +0000986 else if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
987 const FunctionProtoType *FPT = Fn->getType()->getAs<FunctionProtoType>();
Sebastian Redl8026f6d2011-03-13 17:09:40 +0000988 if (FPT && FPT->isNothrow(getContext()))
Bill Wendling72390b32012-12-20 19:27:06 +0000989 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
John McCall9c0c1f32010-07-08 06:48:12 +0000990 }
991
Richard Smithcd8ab512013-01-17 01:30:42 +0000992 if (TargetDecl->hasAttr<NoReturnAttr>() ||
993 TargetDecl->hasAttr<CXX11NoReturnAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000994 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
Eric Christopher041087c2011-08-15 22:38:22 +0000995
Rafael Espindolaf87cced2011-10-03 14:59:42 +0000996 if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000997 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
Rafael Espindolaf87cced2011-10-03 14:59:42 +0000998
Eric Christopher041087c2011-08-15 22:38:22 +0000999 // 'const' and 'pure' attribute functions are also nounwind.
1000 if (TargetDecl->hasAttr<ConstAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001001 FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1002 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001003 } else if (TargetDecl->hasAttr<PureAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001004 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1005 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001006 }
Ryan Flynn76168e22009-08-09 20:07:29 +00001007 if (TargetDecl->hasAttr<MallocAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +00001008 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001009 }
1010
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001011 if (CodeGenOpts.OptimizeSize)
Bill Wendling72390b32012-12-20 19:27:06 +00001012 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
Quentin Colombet90467682012-10-26 00:29:48 +00001013 if (CodeGenOpts.OptimizeSize == 2)
Bill Wendling72390b32012-12-20 19:27:06 +00001014 FuncAttrs.addAttribute(llvm::Attribute::MinSize);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001015 if (CodeGenOpts.DisableRedZone)
Bill Wendling72390b32012-12-20 19:27:06 +00001016 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001017 if (CodeGenOpts.NoImplicitFloat)
Bill Wendling72390b32012-12-20 19:27:06 +00001018 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
Devang Patel24095da2009-06-04 23:32:02 +00001019
Daniel Dunbara0a99e02009-02-02 23:43:58 +00001020 QualType RetTy = FI.getReturnType();
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001021 unsigned Index = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001022 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +00001023 switch (RetAI.getKind()) {
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001024 case ABIArgInfo::Extend:
Chris Lattner2eb9cdd2010-07-28 23:46:15 +00001025 if (RetTy->hasSignedIntegerRepresentation())
Bill Wendling72390b32012-12-20 19:27:06 +00001026 RetAttrs.addAttribute(llvm::Attribute::SExt);
Chris Lattner2eb9cdd2010-07-28 23:46:15 +00001027 else if (RetTy->hasUnsignedIntegerRepresentation())
Bill Wendling72390b32012-12-20 19:27:06 +00001028 RetAttrs.addAttribute(llvm::Attribute::ZExt);
Chris Lattner800588f2010-07-29 06:26:06 +00001029 break;
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001030 case ABIArgInfo::Direct:
Chris Lattner800588f2010-07-29 06:26:06 +00001031 case ABIArgInfo::Ignore:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001032 break;
1033
Rafael Espindolab48280b2012-07-31 02:44:24 +00001034 case ABIArgInfo::Indirect: {
Bill Wendling0d583392012-10-15 20:36:26 +00001035 llvm::AttrBuilder SRETAttrs;
Bill Wendling72390b32012-12-20 19:27:06 +00001036 SRETAttrs.addAttribute(llvm::Attribute::StructRet);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001037 if (RetAI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001038 SRETAttrs.addAttribute(llvm::Attribute::InReg);
Bill Wendling603571a2012-10-10 07:36:56 +00001039 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001040 AttributeSet::get(getLLVMContext(), Index, SRETAttrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001041
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001042 ++Index;
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001043 // sret disables readnone and readonly
Bill Wendling72390b32012-12-20 19:27:06 +00001044 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1045 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001046 break;
Rafael Espindolab48280b2012-07-31 02:44:24 +00001047 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001048
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001049 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001050 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001051 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001052
Bill Wendling603571a2012-10-10 07:36:56 +00001053 if (RetAttrs.hasAttributes())
1054 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001055 AttributeSet::get(getLLVMContext(),
1056 llvm::AttributeSet::ReturnIndex,
1057 RetAttrs));
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001058
Mike Stump1eb44332009-09-09 15:08:12 +00001059 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
Daniel Dunbar88c2fa92009-02-03 05:31:23 +00001060 ie = FI.arg_end(); it != ie; ++it) {
1061 QualType ParamType = it->type;
1062 const ABIArgInfo &AI = it->info;
Bill Wendling0d583392012-10-15 20:36:26 +00001063 llvm::AttrBuilder Attrs;
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001064
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001065 if (AI.getPaddingType()) {
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001066 if (AI.getPaddingInReg())
1067 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index,
1068 llvm::Attribute::InReg));
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001069 // Increment Index if there is padding.
1070 ++Index;
1071 }
1072
John McCalld8e10d22010-03-27 00:47:27 +00001073 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
1074 // have the corresponding parameter variable. It doesn't make
Daniel Dunbar7f6890e2011-02-10 18:10:07 +00001075 // sense to do it here because parameters are so messed up.
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001076 switch (AI.getKind()) {
Chris Lattner800588f2010-07-29 06:26:06 +00001077 case ABIArgInfo::Extend:
Douglas Gregor575a1c92011-05-20 16:38:50 +00001078 if (ParamType->isSignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001079 Attrs.addAttribute(llvm::Attribute::SExt);
Douglas Gregor575a1c92011-05-20 16:38:50 +00001080 else if (ParamType->isUnsignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001081 Attrs.addAttribute(llvm::Attribute::ZExt);
Chris Lattner800588f2010-07-29 06:26:06 +00001082 // FALL THROUGH
1083 case ABIArgInfo::Direct:
Rafael Espindolab48280b2012-07-31 02:44:24 +00001084 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001085 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001086
Chris Lattner800588f2010-07-29 06:26:06 +00001087 // FIXME: handle sseregparm someday...
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001088
Chris Lattner2acc6e32011-07-18 04:24:23 +00001089 if (llvm::StructType *STy =
Rafael Espindolab48280b2012-07-31 02:44:24 +00001090 dyn_cast<llvm::StructType>(AI.getCoerceToType())) {
1091 unsigned Extra = STy->getNumElements()-1; // 1 will be added below.
Bill Wendling603571a2012-10-10 07:36:56 +00001092 if (Attrs.hasAttributes())
Rafael Espindolab48280b2012-07-31 02:44:24 +00001093 for (unsigned I = 0; I < Extra; ++I)
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001094 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I,
1095 Attrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001096 Index += Extra;
1097 }
Chris Lattner800588f2010-07-29 06:26:06 +00001098 break;
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001099
Daniel Dunbar11e383a2009-02-05 08:00:50 +00001100 case ABIArgInfo::Indirect:
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001101 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001102 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001103
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001104 if (AI.getIndirectByVal())
Bill Wendling72390b32012-12-20 19:27:06 +00001105 Attrs.addAttribute(llvm::Attribute::ByVal);
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001106
Bill Wendling603571a2012-10-10 07:36:56 +00001107 Attrs.addAlignmentAttr(AI.getIndirectAlign());
1108
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001109 // byval disables readnone and readonly.
Bill Wendling72390b32012-12-20 19:27:06 +00001110 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1111 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001112 break;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001113
Daniel Dunbar11434922009-01-26 21:26:08 +00001114 case ABIArgInfo::Ignore:
1115 // Skip increment, no matching LLVM parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001116 continue;
Daniel Dunbar11434922009-01-26 21:26:08 +00001117
Daniel Dunbar56273772008-09-17 00:51:38 +00001118 case ABIArgInfo::Expand: {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001119 SmallVector<llvm::Type*, 8> types;
Mike Stumpf5408fe2009-05-16 07:57:57 +00001120 // FIXME: This is rather inefficient. Do we ever actually need to do
1121 // anything here? The result should be just reconstructed on the other
1122 // side, so extension should be a non-issue.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001123 getTypes().GetExpandedTypes(ParamType, types);
John McCall42e06112011-05-15 02:19:42 +00001124 Index += types.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00001125 continue;
1126 }
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001127 }
Mike Stump1eb44332009-09-09 15:08:12 +00001128
Bill Wendling603571a2012-10-10 07:36:56 +00001129 if (Attrs.hasAttributes())
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001130 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs));
Daniel Dunbar56273772008-09-17 00:51:38 +00001131 ++Index;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001132 }
Bill Wendling603571a2012-10-10 07:36:56 +00001133 if (FuncAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001134 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001135 AttributeSet::get(getLLVMContext(),
1136 llvm::AttributeSet::FunctionIndex,
1137 FuncAttrs));
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001138}
1139
John McCalld26bc762011-03-09 04:27:21 +00001140/// An argument came in as a promoted argument; demote it back to its
1141/// declared type.
1142static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
1143 const VarDecl *var,
1144 llvm::Value *value) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001145 llvm::Type *varType = CGF.ConvertType(var->getType());
John McCalld26bc762011-03-09 04:27:21 +00001146
1147 // This can happen with promotions that actually don't change the
1148 // underlying type, like the enum promotions.
1149 if (value->getType() == varType) return value;
1150
1151 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
1152 && "unexpected promotion type");
1153
1154 if (isa<llvm::IntegerType>(varType))
1155 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
1156
1157 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
1158}
1159
Daniel Dunbar88b53962009-02-02 22:03:45 +00001160void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
1161 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001162 const FunctionArgList &Args) {
John McCall0cfeb632009-07-28 01:00:58 +00001163 // If this is an implicit-return-zero function, go ahead and
1164 // initialize the return value. TODO: it might be nice to have
1165 // a more general mechanism for this that didn't require synthesized
1166 // return statements.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001167 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl)) {
John McCall0cfeb632009-07-28 01:00:58 +00001168 if (FD->hasImplicitReturnZero()) {
1169 QualType RetTy = FD->getResultType().getUnqualifiedType();
Chris Lattner2acc6e32011-07-18 04:24:23 +00001170 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
Owen Andersonc9c88b42009-07-31 20:28:54 +00001171 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
John McCall0cfeb632009-07-28 01:00:58 +00001172 Builder.CreateStore(Zero, ReturnValue);
1173 }
1174 }
1175
Mike Stumpf5408fe2009-05-16 07:57:57 +00001176 // FIXME: We no longer need the types from FunctionArgList; lift up and
1177 // simplify.
Daniel Dunbar5251afa2009-02-03 06:02:10 +00001178
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001179 // Emit allocs for param decls. Give the LLVM Argument nodes names.
1180 llvm::Function::arg_iterator AI = Fn->arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001181
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001182 // Name the struct return argument.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001183 if (CGM.ReturnTypeUsesSRet(FI)) {
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001184 AI->setName("agg.result");
Bill Wendling89530e42013-01-23 06:15:10 +00001185 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1186 AI->getArgNo() + 1,
1187 llvm::Attribute::NoAlias));
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001188 ++AI;
1189 }
Mike Stump1eb44332009-09-09 15:08:12 +00001190
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00001191 assert(FI.arg_size() == Args.size() &&
1192 "Mismatch between function signature & arguments.");
Devang Patel093ac462011-03-03 20:13:15 +00001193 unsigned ArgNo = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001194 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
Devang Patel093ac462011-03-03 20:13:15 +00001195 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1196 i != e; ++i, ++info_it, ++ArgNo) {
John McCalld26bc762011-03-09 04:27:21 +00001197 const VarDecl *Arg = *i;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001198 QualType Ty = info_it->type;
1199 const ABIArgInfo &ArgI = info_it->info;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001200
John McCalld26bc762011-03-09 04:27:21 +00001201 bool isPromoted =
1202 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
1203
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001204 // Skip the dummy padding argument.
1205 if (ArgI.getPaddingType())
1206 ++AI;
1207
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001208 switch (ArgI.getKind()) {
Daniel Dunbar1f745982009-02-05 09:16:39 +00001209 case ABIArgInfo::Indirect: {
Chris Lattnerce700162010-06-28 23:44:11 +00001210 llvm::Value *V = AI;
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001211
Daniel Dunbar1f745982009-02-05 09:16:39 +00001212 if (hasAggregateLLVMType(Ty)) {
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001213 // Aggregates and complex variables are accessed by reference. All we
1214 // need to do is realign the value, if requested
1215 if (ArgI.getIndirectRealign()) {
1216 llvm::Value *AlignedTemp = CreateMemTemp(Ty, "coerce");
1217
1218 // Copy from the incoming argument pointer to the temporary with the
1219 // appropriate alignment.
1220 //
1221 // FIXME: We should have a common utility for generating an aggregate
1222 // copy.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001223 llvm::Type *I8PtrTy = Builder.getInt8PtrTy();
Ken Dyckfe710082011-01-19 01:58:38 +00001224 CharUnits Size = getContext().getTypeSizeInChars(Ty);
NAKAMURA Takumic95a8fc2011-03-10 14:02:21 +00001225 llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy);
1226 llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy);
1227 Builder.CreateMemCpy(Dst,
1228 Src,
Ken Dyckfe710082011-01-19 01:58:38 +00001229 llvm::ConstantInt::get(IntPtrTy,
1230 Size.getQuantity()),
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +00001231 ArgI.getIndirectAlign(),
1232 false);
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001233 V = AlignedTemp;
1234 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00001235 } else {
1236 // Load scalar value from indirect argument.
Ken Dyckfe710082011-01-19 01:58:38 +00001237 CharUnits Alignment = getContext().getTypeAlignInChars(Ty);
1238 V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty);
John McCalld26bc762011-03-09 04:27:21 +00001239
1240 if (isPromoted)
1241 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001242 }
Devang Patel093ac462011-03-03 20:13:15 +00001243 EmitParmDecl(*Arg, V, ArgNo);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001244 break;
1245 }
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001246
1247 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001248 case ABIArgInfo::Direct: {
Akira Hatanaka4ba3fd42012-01-09 19:08:06 +00001249
Chris Lattner800588f2010-07-29 06:26:06 +00001250 // If we have the trivial case, handle it with no muss and fuss.
1251 if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00001252 ArgI.getCoerceToType() == ConvertType(Ty) &&
1253 ArgI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001254 assert(AI != Fn->arg_end() && "Argument mismatch!");
1255 llvm::Value *V = AI;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001256
Bill Wendlinga6375562012-10-16 05:23:44 +00001257 if (Arg->getType().isRestrictQualified())
Bill Wendling89530e42013-01-23 06:15:10 +00001258 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1259 AI->getArgNo() + 1,
1260 llvm::Attribute::NoAlias));
John McCalld8e10d22010-03-27 00:47:27 +00001261
Chris Lattnerb13eab92011-07-20 06:29:00 +00001262 // Ensure the argument is the correct type.
1263 if (V->getType() != ArgI.getCoerceToType())
1264 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
1265
John McCalld26bc762011-03-09 04:27:21 +00001266 if (isPromoted)
1267 V = emitArgumentDemotion(*this, Arg, V);
Rafael Espindola8b8a09e2012-11-29 16:09:03 +00001268
1269 // Because of merging of function types from multiple decls it is
1270 // possible for the type of an argument to not match the corresponding
1271 // type in the function type. Since we are codegening the callee
1272 // in here, add a cast to the argument type.
1273 llvm::Type *LTy = ConvertType(Arg->getType());
1274 if (V->getType() != LTy)
1275 V = Builder.CreateBitCast(V, LTy);
1276
Devang Patel093ac462011-03-03 20:13:15 +00001277 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001278 break;
Daniel Dunbar8b979d92009-02-10 00:06:49 +00001279 }
Mike Stump1eb44332009-09-09 15:08:12 +00001280
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001281 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001282
Chris Lattnerdeabde22010-07-28 18:24:28 +00001283 // The alignment we need to use is the max of the requested alignment for
1284 // the argument plus the alignment required by our access code below.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001285 unsigned AlignmentToUse =
Micah Villmow25a6a842012-10-08 16:25:52 +00001286 CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType());
Chris Lattnerdeabde22010-07-28 18:24:28 +00001287 AlignmentToUse = std::max(AlignmentToUse,
1288 (unsigned)getContext().getDeclAlign(Arg).getQuantity());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001289
Chris Lattnerdeabde22010-07-28 18:24:28 +00001290 Alloca->setAlignment(AlignmentToUse);
Chris Lattner121b3fa2010-07-05 20:21:00 +00001291 llvm::Value *V = Alloca;
Chris Lattner117e3f42010-07-30 04:02:24 +00001292 llvm::Value *Ptr = V; // Pointer to store into.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001293
Chris Lattner117e3f42010-07-30 04:02:24 +00001294 // If the value is offset in memory, apply the offset now.
1295 if (unsigned Offs = ArgI.getDirectOffset()) {
1296 Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy());
1297 Ptr = Builder.CreateConstGEP1_32(Ptr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001298 Ptr = Builder.CreateBitCast(Ptr,
Chris Lattner117e3f42010-07-30 04:02:24 +00001299 llvm::PointerType::getUnqual(ArgI.getCoerceToType()));
1300 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001301
Chris Lattner309c59f2010-06-29 00:06:42 +00001302 // If the coerce-to type is a first class aggregate, we flatten it and
1303 // pass the elements. Either way is semantically identical, but fast-isel
1304 // and the optimizer generally likes scalar values better than FCAs.
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001305 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
1306 if (STy && STy->getNumElements() > 1) {
Micah Villmow25a6a842012-10-08 16:25:52 +00001307 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001308 llvm::Type *DstTy =
1309 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Micah Villmow25a6a842012-10-08 16:25:52 +00001310 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001311
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001312 if (SrcSize <= DstSize) {
1313 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
1314
1315 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1316 assert(AI != Fn->arg_end() && "Argument mismatch!");
1317 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1318 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i);
1319 Builder.CreateStore(AI++, EltPtr);
1320 }
1321 } else {
1322 llvm::AllocaInst *TempAlloca =
1323 CreateTempAlloca(ArgI.getCoerceToType(), "coerce");
1324 TempAlloca->setAlignment(AlignmentToUse);
1325 llvm::Value *TempV = TempAlloca;
1326
1327 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1328 assert(AI != Fn->arg_end() && "Argument mismatch!");
1329 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1330 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i);
1331 Builder.CreateStore(AI++, EltPtr);
1332 }
1333
1334 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse);
Chris Lattner309c59f2010-06-29 00:06:42 +00001335 }
1336 } else {
1337 // Simple case, just do a coerced store of the argument into the alloca.
1338 assert(AI != Fn->arg_end() && "Argument mismatch!");
Chris Lattner225e2862010-06-29 00:14:52 +00001339 AI->setName(Arg->getName() + ".coerce");
Chris Lattner117e3f42010-07-30 04:02:24 +00001340 CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this);
Chris Lattner309c59f2010-06-29 00:06:42 +00001341 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001342
1343
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001344 // Match to what EmitParmDecl is expecting for this type.
Daniel Dunbar8b29a382009-02-04 07:22:24 +00001345 if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001346 V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty);
John McCalld26bc762011-03-09 04:27:21 +00001347 if (isPromoted)
1348 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar8b29a382009-02-04 07:22:24 +00001349 }
Devang Patel093ac462011-03-03 20:13:15 +00001350 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattnerce700162010-06-28 23:44:11 +00001351 continue; // Skip ++AI increment, already done.
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001352 }
Chris Lattner800588f2010-07-29 06:26:06 +00001353
1354 case ABIArgInfo::Expand: {
1355 // If this structure was expanded into multiple arguments then
1356 // we need to create a temporary and reconstruct it from the
1357 // arguments.
Eli Friedman1bb94a42011-11-03 21:39:02 +00001358 llvm::AllocaInst *Alloca = CreateMemTemp(Ty);
Eli Friedman6da2c712011-12-03 04:14:32 +00001359 CharUnits Align = getContext().getDeclAlign(Arg);
1360 Alloca->setAlignment(Align.getQuantity());
1361 LValue LV = MakeAddrLValue(Alloca, Ty, Align);
Eli Friedman1bb94a42011-11-03 21:39:02 +00001362 llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI);
1363 EmitParmDecl(*Arg, Alloca, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001364
1365 // Name the arguments used in expansion and increment AI.
1366 unsigned Index = 0;
1367 for (; AI != End; ++AI, ++Index)
Chris Lattner5f9e2722011-07-23 10:55:15 +00001368 AI->setName(Arg->getName() + "." + Twine(Index));
Chris Lattner800588f2010-07-29 06:26:06 +00001369 continue;
1370 }
1371
1372 case ABIArgInfo::Ignore:
1373 // Initialize the local variable appropriately.
1374 if (hasAggregateLLVMType(Ty))
Devang Patel093ac462011-03-03 20:13:15 +00001375 EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001376 else
Devang Patel093ac462011-03-03 20:13:15 +00001377 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())),
1378 ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001379
1380 // Skip increment, no matching LLVM parameter.
1381 continue;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001382 }
Daniel Dunbar56273772008-09-17 00:51:38 +00001383
1384 ++AI;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001385 }
1386 assert(AI == Fn->arg_end() && "Argument mismatch!");
1387}
1388
John McCall77fe6cd2012-01-29 07:46:59 +00001389static void eraseUnusedBitCasts(llvm::Instruction *insn) {
1390 while (insn->use_empty()) {
1391 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
1392 if (!bitcast) return;
1393
1394 // This is "safe" because we would have used a ConstantExpr otherwise.
1395 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
1396 bitcast->eraseFromParent();
1397 }
1398}
1399
John McCallf85e1932011-06-15 23:02:42 +00001400/// Try to emit a fused autorelease of a return result.
1401static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF,
1402 llvm::Value *result) {
1403 // We must be immediately followed the cast.
1404 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
1405 if (BB->empty()) return 0;
1406 if (&BB->back() != result) return 0;
1407
Chris Lattner2acc6e32011-07-18 04:24:23 +00001408 llvm::Type *resultType = result->getType();
John McCallf85e1932011-06-15 23:02:42 +00001409
1410 // result is in a BasicBlock and is therefore an Instruction.
1411 llvm::Instruction *generator = cast<llvm::Instruction>(result);
1412
Chris Lattner5f9e2722011-07-23 10:55:15 +00001413 SmallVector<llvm::Instruction*,4> insnsToKill;
John McCallf85e1932011-06-15 23:02:42 +00001414
1415 // Look for:
1416 // %generator = bitcast %type1* %generator2 to %type2*
1417 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
1418 // We would have emitted this as a constant if the operand weren't
1419 // an Instruction.
1420 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
1421
1422 // Require the generator to be immediately followed by the cast.
1423 if (generator->getNextNode() != bitcast)
1424 return 0;
1425
1426 insnsToKill.push_back(bitcast);
1427 }
1428
1429 // Look for:
1430 // %generator = call i8* @objc_retain(i8* %originalResult)
1431 // or
1432 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
1433 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
1434 if (!call) return 0;
1435
1436 bool doRetainAutorelease;
1437
1438 if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) {
1439 doRetainAutorelease = true;
1440 } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints()
1441 .objc_retainAutoreleasedReturnValue) {
1442 doRetainAutorelease = false;
1443
John McCallf9fdcc02012-09-07 23:30:50 +00001444 // If we emitted an assembly marker for this call (and the
1445 // ARCEntrypoints field should have been set if so), go looking
1446 // for that call. If we can't find it, we can't do this
1447 // optimization. But it should always be the immediately previous
1448 // instruction, unless we needed bitcasts around the call.
1449 if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) {
1450 llvm::Instruction *prev = call->getPrevNode();
1451 assert(prev);
1452 if (isa<llvm::BitCastInst>(prev)) {
1453 prev = prev->getPrevNode();
1454 assert(prev);
1455 }
1456 assert(isa<llvm::CallInst>(prev));
1457 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
1458 CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker);
1459 insnsToKill.push_back(prev);
1460 }
John McCallf85e1932011-06-15 23:02:42 +00001461 } else {
1462 return 0;
1463 }
1464
1465 result = call->getArgOperand(0);
1466 insnsToKill.push_back(call);
1467
1468 // Keep killing bitcasts, for sanity. Note that we no longer care
1469 // about precise ordering as long as there's exactly one use.
1470 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
1471 if (!bitcast->hasOneUse()) break;
1472 insnsToKill.push_back(bitcast);
1473 result = bitcast->getOperand(0);
1474 }
1475
1476 // Delete all the unnecessary instructions, from latest to earliest.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001477 for (SmallVectorImpl<llvm::Instruction*>::iterator
John McCallf85e1932011-06-15 23:02:42 +00001478 i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i)
1479 (*i)->eraseFromParent();
1480
1481 // Do the fused retain/autorelease if we were asked to.
1482 if (doRetainAutorelease)
1483 result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
1484
1485 // Cast back to the result type.
1486 return CGF.Builder.CreateBitCast(result, resultType);
1487}
1488
John McCall77fe6cd2012-01-29 07:46:59 +00001489/// If this is a +1 of the value of an immutable 'self', remove it.
1490static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF,
1491 llvm::Value *result) {
1492 // This is only applicable to a method with an immutable 'self'.
John McCallbd9b65a2012-07-31 00:33:55 +00001493 const ObjCMethodDecl *method =
1494 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
John McCall77fe6cd2012-01-29 07:46:59 +00001495 if (!method) return 0;
1496 const VarDecl *self = method->getSelfDecl();
1497 if (!self->getType().isConstQualified()) return 0;
1498
1499 // Look for a retain call.
1500 llvm::CallInst *retainCall =
1501 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
1502 if (!retainCall ||
1503 retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain)
1504 return 0;
1505
1506 // Look for an ordinary load of 'self'.
1507 llvm::Value *retainedValue = retainCall->getArgOperand(0);
1508 llvm::LoadInst *load =
1509 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
1510 if (!load || load->isAtomic() || load->isVolatile() ||
1511 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self))
1512 return 0;
1513
1514 // Okay! Burn it all down. This relies for correctness on the
1515 // assumption that the retain is emitted as part of the return and
1516 // that thereafter everything is used "linearly".
1517 llvm::Type *resultType = result->getType();
1518 eraseUnusedBitCasts(cast<llvm::Instruction>(result));
1519 assert(retainCall->use_empty());
1520 retainCall->eraseFromParent();
1521 eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
1522
1523 return CGF.Builder.CreateBitCast(load, resultType);
1524}
1525
John McCallf85e1932011-06-15 23:02:42 +00001526/// Emit an ARC autorelease of the result of a function.
John McCall77fe6cd2012-01-29 07:46:59 +00001527///
1528/// \return the value to actually return from the function
John McCallf85e1932011-06-15 23:02:42 +00001529static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF,
1530 llvm::Value *result) {
John McCall77fe6cd2012-01-29 07:46:59 +00001531 // If we're returning 'self', kill the initial retain. This is a
1532 // heuristic attempt to "encourage correctness" in the really unfortunate
1533 // case where we have a return of self during a dealloc and we desperately
1534 // need to avoid the possible autorelease.
1535 if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
1536 return self;
1537
John McCallf85e1932011-06-15 23:02:42 +00001538 // At -O0, try to emit a fused retain/autorelease.
1539 if (CGF.shouldUseFusedARCCalls())
1540 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
1541 return fused;
1542
1543 return CGF.EmitARCAutoreleaseReturnValue(result);
1544}
1545
John McCallf48f7962012-01-29 02:35:02 +00001546/// Heuristically search for a dominating store to the return-value slot.
1547static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
1548 // If there are multiple uses of the return-value slot, just check
1549 // for something immediately preceding the IP. Sometimes this can
1550 // happen with how we generate implicit-returns; it can also happen
1551 // with noreturn cleanups.
1552 if (!CGF.ReturnValue->hasOneUse()) {
1553 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1554 if (IP->empty()) return 0;
1555 llvm::StoreInst *store = dyn_cast<llvm::StoreInst>(&IP->back());
1556 if (!store) return 0;
1557 if (store->getPointerOperand() != CGF.ReturnValue) return 0;
1558 assert(!store->isAtomic() && !store->isVolatile()); // see below
1559 return store;
1560 }
1561
1562 llvm::StoreInst *store =
1563 dyn_cast<llvm::StoreInst>(CGF.ReturnValue->use_back());
1564 if (!store) return 0;
1565
1566 // These aren't actually possible for non-coerced returns, and we
1567 // only care about non-coerced returns on this code path.
1568 assert(!store->isAtomic() && !store->isVolatile());
1569
1570 // Now do a first-and-dirty dominance check: just walk up the
1571 // single-predecessors chain from the current insertion point.
1572 llvm::BasicBlock *StoreBB = store->getParent();
1573 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1574 while (IP != StoreBB) {
1575 if (!(IP = IP->getSinglePredecessor()))
1576 return 0;
1577 }
1578
1579 // Okay, the store's basic block dominates the insertion point; we
1580 // can do our thing.
1581 return store;
1582}
1583
Chris Lattner35b21b82010-06-27 01:06:27 +00001584void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001585 // Functions with no result always return void.
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001586 if (ReturnValue == 0) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001587 Builder.CreateRetVoid();
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001588 return;
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001589 }
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001590
Dan Gohman4751a532010-07-20 20:13:52 +00001591 llvm::DebugLoc RetDbgLoc;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001592 llvm::Value *RV = 0;
1593 QualType RetTy = FI.getReturnType();
1594 const ABIArgInfo &RetAI = FI.getReturnInfo();
1595
1596 switch (RetAI.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001597 case ABIArgInfo::Indirect: {
1598 unsigned Alignment = getContext().getTypeAlignInChars(RetTy).getQuantity();
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001599 if (RetTy->isAnyComplexType()) {
1600 ComplexPairTy RT = LoadComplexFromAddr(ReturnValue, false);
1601 StoreComplexToAddr(RT, CurFn->arg_begin(), false);
1602 } else if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
1603 // Do nothing; aggregrates get evaluated directly into the destination.
1604 } else {
1605 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), CurFn->arg_begin(),
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001606 false, Alignment, RetTy);
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001607 }
1608 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001609 }
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001610
1611 case ABIArgInfo::Extend:
Chris Lattner800588f2010-07-29 06:26:06 +00001612 case ABIArgInfo::Direct:
Chris Lattner117e3f42010-07-30 04:02:24 +00001613 if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
1614 RetAI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001615 // The internal return value temp always will have pointer-to-return-type
1616 // type, just do a load.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001617
John McCallf48f7962012-01-29 02:35:02 +00001618 // If there is a dominating store to ReturnValue, we can elide
1619 // the load, zap the store, and usually zap the alloca.
1620 if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) {
Chris Lattner800588f2010-07-29 06:26:06 +00001621 // Get the stored value and nuke the now-dead store.
1622 RetDbgLoc = SI->getDebugLoc();
1623 RV = SI->getValueOperand();
1624 SI->eraseFromParent();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001625
Chris Lattner800588f2010-07-29 06:26:06 +00001626 // If that was the only use of the return value, nuke it as well now.
1627 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) {
1628 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent();
1629 ReturnValue = 0;
1630 }
John McCallf48f7962012-01-29 02:35:02 +00001631
1632 // Otherwise, we have to do a simple load.
1633 } else {
1634 RV = Builder.CreateLoad(ReturnValue);
Chris Lattner35b21b82010-06-27 01:06:27 +00001635 }
Chris Lattner800588f2010-07-29 06:26:06 +00001636 } else {
Chris Lattner117e3f42010-07-30 04:02:24 +00001637 llvm::Value *V = ReturnValue;
1638 // If the value is offset in memory, apply the offset now.
1639 if (unsigned Offs = RetAI.getDirectOffset()) {
1640 V = Builder.CreateBitCast(V, Builder.getInt8PtrTy());
1641 V = Builder.CreateConstGEP1_32(V, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001642 V = Builder.CreateBitCast(V,
Chris Lattner117e3f42010-07-30 04:02:24 +00001643 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
1644 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001645
Chris Lattner117e3f42010-07-30 04:02:24 +00001646 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
Chris Lattner35b21b82010-06-27 01:06:27 +00001647 }
John McCallf85e1932011-06-15 23:02:42 +00001648
1649 // In ARC, end functions that return a retainable type with a call
1650 // to objc_autoreleaseReturnValue.
1651 if (AutoreleaseResult) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001652 assert(getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001653 !FI.isReturnsRetained() &&
1654 RetTy->isObjCRetainableType());
1655 RV = emitAutoreleaseOfResult(*this, RV);
1656 }
1657
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001658 break;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001659
Chris Lattner800588f2010-07-29 06:26:06 +00001660 case ABIArgInfo::Ignore:
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001661 break;
1662
1663 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001664 llvm_unreachable("Invalid ABI kind for return argument");
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001665 }
1666
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001667 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid();
Devang Pateld3f265d2010-07-21 18:08:50 +00001668 if (!RetDbgLoc.isUnknown())
1669 Ret->setDebugLoc(RetDbgLoc);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001670}
1671
John McCall413ebdb2011-03-11 20:59:21 +00001672void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
1673 const VarDecl *param) {
John McCall27360712010-05-26 22:34:26 +00001674 // StartFunction converted the ABI-lowered parameter(s) into a
1675 // local alloca. We need to turn that into an r-value suitable
1676 // for EmitCall.
John McCall413ebdb2011-03-11 20:59:21 +00001677 llvm::Value *local = GetAddrOfLocalVar(param);
John McCall27360712010-05-26 22:34:26 +00001678
John McCall413ebdb2011-03-11 20:59:21 +00001679 QualType type = param->getType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001680
John McCall27360712010-05-26 22:34:26 +00001681 // For the most part, we just need to load the alloca, except:
1682 // 1) aggregate r-values are actually pointers to temporaries, and
1683 // 2) references to aggregates are pointers directly to the aggregate.
1684 // I don't know why references to non-aggregates are different here.
John McCall413ebdb2011-03-11 20:59:21 +00001685 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
1686 if (hasAggregateLLVMType(ref->getPointeeType()))
1687 return args.add(RValue::getAggregate(local), type);
John McCall27360712010-05-26 22:34:26 +00001688
1689 // Locals which are references to scalars are represented
1690 // with allocas holding the pointer.
John McCall413ebdb2011-03-11 20:59:21 +00001691 return args.add(RValue::get(Builder.CreateLoad(local)), type);
John McCall27360712010-05-26 22:34:26 +00001692 }
1693
John McCall413ebdb2011-03-11 20:59:21 +00001694 if (type->isAnyComplexType()) {
1695 ComplexPairTy complex = LoadComplexFromAddr(local, /*volatile*/ false);
1696 return args.add(RValue::getComplex(complex), type);
1697 }
John McCall27360712010-05-26 22:34:26 +00001698
John McCall413ebdb2011-03-11 20:59:21 +00001699 if (hasAggregateLLVMType(type))
1700 return args.add(RValue::getAggregate(local), type);
John McCall27360712010-05-26 22:34:26 +00001701
John McCall413ebdb2011-03-11 20:59:21 +00001702 unsigned alignment = getContext().getDeclAlign(param).getQuantity();
1703 llvm::Value *value = EmitLoadOfScalar(local, false, alignment, type);
1704 return args.add(RValue::get(value), type);
John McCall27360712010-05-26 22:34:26 +00001705}
1706
John McCallf85e1932011-06-15 23:02:42 +00001707static bool isProvablyNull(llvm::Value *addr) {
1708 return isa<llvm::ConstantPointerNull>(addr);
1709}
1710
1711static bool isProvablyNonNull(llvm::Value *addr) {
1712 return isa<llvm::AllocaInst>(addr);
1713}
1714
1715/// Emit the actual writing-back of a writeback.
1716static void emitWriteback(CodeGenFunction &CGF,
1717 const CallArgList::Writeback &writeback) {
1718 llvm::Value *srcAddr = writeback.Address;
1719 assert(!isProvablyNull(srcAddr) &&
1720 "shouldn't have writeback for provably null argument");
1721
1722 llvm::BasicBlock *contBB = 0;
1723
1724 // If the argument wasn't provably non-null, we need to null check
1725 // before doing the store.
1726 bool provablyNonNull = isProvablyNonNull(srcAddr);
1727 if (!provablyNonNull) {
1728 llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
1729 contBB = CGF.createBasicBlock("icr.done");
1730
1731 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1732 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
1733 CGF.EmitBlock(writebackBB);
1734 }
1735
1736 // Load the value to writeback.
1737 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
1738
1739 // Cast it back, in case we're writing an id to a Foo* or something.
1740 value = CGF.Builder.CreateBitCast(value,
1741 cast<llvm::PointerType>(srcAddr->getType())->getElementType(),
1742 "icr.writeback-cast");
1743
1744 // Perform the writeback.
1745 QualType srcAddrType = writeback.AddressType;
1746 CGF.EmitStoreThroughLValue(RValue::get(value),
John McCall545d9962011-06-25 02:11:03 +00001747 CGF.MakeAddrLValue(srcAddr, srcAddrType));
John McCallf85e1932011-06-15 23:02:42 +00001748
1749 // Jump to the continuation block.
1750 if (!provablyNonNull)
1751 CGF.EmitBlock(contBB);
1752}
1753
1754static void emitWritebacks(CodeGenFunction &CGF,
1755 const CallArgList &args) {
1756 for (CallArgList::writeback_iterator
1757 i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i)
1758 emitWriteback(CGF, *i);
1759}
1760
1761/// Emit an argument that's being passed call-by-writeback. That is,
1762/// we are passing the address of
1763static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
1764 const ObjCIndirectCopyRestoreExpr *CRE) {
1765 llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr());
1766
1767 // The dest and src types don't necessarily match in LLVM terms
1768 // because of the crazy ObjC compatibility rules.
1769
Chris Lattner2acc6e32011-07-18 04:24:23 +00001770 llvm::PointerType *destType =
John McCallf85e1932011-06-15 23:02:42 +00001771 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
1772
1773 // If the address is a constant null, just pass the appropriate null.
1774 if (isProvablyNull(srcAddr)) {
1775 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
1776 CRE->getType());
1777 return;
1778 }
1779
1780 QualType srcAddrType =
1781 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
1782
1783 // Create the temporary.
1784 llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(),
1785 "icr.temp");
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001786 // Loading an l-value can introduce a cleanup if the l-value is __weak,
1787 // and that cleanup will be conditional if we can't prove that the l-value
1788 // isn't null, so we need to register a dominating point so that the cleanups
1789 // system will make valid IR.
1790 CodeGenFunction::ConditionalEvaluation condEval(CGF);
1791
John McCallf85e1932011-06-15 23:02:42 +00001792 // Zero-initialize it if we're not doing a copy-initialization.
1793 bool shouldCopy = CRE->shouldCopy();
1794 if (!shouldCopy) {
1795 llvm::Value *null =
1796 llvm::ConstantPointerNull::get(
1797 cast<llvm::PointerType>(destType->getElementType()));
1798 CGF.Builder.CreateStore(null, temp);
1799 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001800
John McCallf85e1932011-06-15 23:02:42 +00001801 llvm::BasicBlock *contBB = 0;
1802
1803 // If the address is *not* known to be non-null, we need to switch.
1804 llvm::Value *finalArgument;
1805
1806 bool provablyNonNull = isProvablyNonNull(srcAddr);
1807 if (provablyNonNull) {
1808 finalArgument = temp;
1809 } else {
1810 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1811
1812 finalArgument = CGF.Builder.CreateSelect(isNull,
1813 llvm::ConstantPointerNull::get(destType),
1814 temp, "icr.argument");
1815
1816 // If we need to copy, then the load has to be conditional, which
1817 // means we need control flow.
1818 if (shouldCopy) {
1819 contBB = CGF.createBasicBlock("icr.cont");
1820 llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy");
1821 CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
1822 CGF.EmitBlock(copyBB);
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001823 condEval.begin(CGF);
John McCallf85e1932011-06-15 23:02:42 +00001824 }
1825 }
1826
1827 // Perform a copy if necessary.
1828 if (shouldCopy) {
1829 LValue srcLV = CGF.MakeAddrLValue(srcAddr, srcAddrType);
John McCall545d9962011-06-25 02:11:03 +00001830 RValue srcRV = CGF.EmitLoadOfLValue(srcLV);
John McCallf85e1932011-06-15 23:02:42 +00001831 assert(srcRV.isScalar());
1832
1833 llvm::Value *src = srcRV.getScalarVal();
1834 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
1835 "icr.cast");
1836
1837 // Use an ordinary store, not a store-to-lvalue.
1838 CGF.Builder.CreateStore(src, temp);
1839 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001840
John McCallf85e1932011-06-15 23:02:42 +00001841 // Finish the control flow if we needed it.
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001842 if (shouldCopy && !provablyNonNull) {
John McCallf85e1932011-06-15 23:02:42 +00001843 CGF.EmitBlock(contBB);
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001844 condEval.end(CGF);
1845 }
John McCallf85e1932011-06-15 23:02:42 +00001846
1847 args.addWriteback(srcAddr, srcAddrType, temp);
1848 args.add(RValue::get(finalArgument), CRE->getType());
1849}
1850
John McCall413ebdb2011-03-11 20:59:21 +00001851void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
1852 QualType type) {
John McCallf85e1932011-06-15 23:02:42 +00001853 if (const ObjCIndirectCopyRestoreExpr *CRE
1854 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
Richard Smith7edf9e32012-11-01 22:30:59 +00001855 assert(getLangOpts().ObjCAutoRefCount);
John McCallf85e1932011-06-15 23:02:42 +00001856 assert(getContext().hasSameType(E->getType(), type));
1857 return emitWritebackArg(*this, args, CRE);
1858 }
1859
John McCall8affed52011-08-26 18:42:59 +00001860 assert(type->isReferenceType() == E->isGLValue() &&
1861 "reference binding to unmaterialized r-value!");
1862
John McCallcec52f02011-08-26 21:08:13 +00001863 if (E->isGLValue()) {
1864 assert(E->getObjectKind() == OK_Ordinary);
John McCall413ebdb2011-03-11 20:59:21 +00001865 return args.add(EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0),
1866 type);
John McCallcec52f02011-08-26 21:08:13 +00001867 }
Mike Stump1eb44332009-09-09 15:08:12 +00001868
Eli Friedman70cbd2a2011-06-15 18:26:32 +00001869 if (hasAggregateLLVMType(type) && !E->getType()->isAnyComplexType() &&
1870 isa<ImplicitCastExpr>(E) &&
Eli Friedman55d48482011-05-26 00:10:27 +00001871 cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
1872 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
1873 assert(L.isSimple());
Eli Friedman51f51202011-12-03 03:08:40 +00001874 args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true);
Eli Friedman55d48482011-05-26 00:10:27 +00001875 return;
1876 }
1877
John McCall413ebdb2011-03-11 20:59:21 +00001878 args.add(EmitAnyExprToTemp(E), type);
Anders Carlsson0139bb92009-04-08 20:47:54 +00001879}
1880
Dan Gohmanb49bd272012-02-16 00:57:37 +00001881// In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
1882// optimizer it can aggressively ignore unwind edges.
1883void
1884CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
1885 if (CGM.getCodeGenOpts().OptimizationLevel != 0 &&
1886 !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
1887 Inst->setMetadata("clang.arc.no_objc_arc_exceptions",
1888 CGM.getNoObjCARCExceptionsMetadata());
1889}
1890
John McCallf1549f62010-07-06 01:34:17 +00001891/// Emits a call or invoke instruction to the given function, depending
1892/// on the current state of the EH stack.
1893llvm::CallSite
1894CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00001895 ArrayRef<llvm::Value *> Args,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001896 const Twine &Name) {
John McCallf1549f62010-07-06 01:34:17 +00001897 llvm::BasicBlock *InvokeDest = getInvokeDest();
John McCallf1549f62010-07-06 01:34:17 +00001898
Dan Gohmanb49bd272012-02-16 00:57:37 +00001899 llvm::Instruction *Inst;
1900 if (!InvokeDest)
1901 Inst = Builder.CreateCall(Callee, Args, Name);
1902 else {
1903 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
1904 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name);
1905 EmitBlock(ContBB);
1906 }
1907
1908 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
1909 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00001910 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00001911 AddObjCARCExceptionMetadata(Inst);
1912
1913 return Inst;
John McCallf1549f62010-07-06 01:34:17 +00001914}
1915
Jay Foad4c7d9f12011-07-15 08:37:34 +00001916llvm::CallSite
1917CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001918 const Twine &Name) {
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00001919 return EmitCallOrInvoke(Callee, ArrayRef<llvm::Value *>(), Name);
Jay Foad4c7d9f12011-07-15 08:37:34 +00001920}
1921
Chris Lattner70855442011-07-12 04:46:18 +00001922static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo,
1923 llvm::FunctionType *FTy) {
1924 if (ArgNo < FTy->getNumParams())
1925 assert(Elt->getType() == FTy->getParamType(ArgNo));
1926 else
1927 assert(FTy->isVarArg());
1928 ++ArgNo;
1929}
1930
Chris Lattner811bf362011-07-12 06:29:11 +00001931void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001932 SmallVector<llvm::Value*,16> &Args,
Chris Lattner811bf362011-07-12 06:29:11 +00001933 llvm::FunctionType *IRFuncTy) {
Bob Wilson194f06a2011-08-03 05:58:22 +00001934 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
1935 unsigned NumElts = AT->getSize().getZExtValue();
1936 QualType EltTy = AT->getElementType();
1937 llvm::Value *Addr = RV.getAggregateAddr();
1938 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
1939 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt);
1940 LValue LV = MakeAddrLValue(EltAddr, EltTy);
1941 RValue EltRV;
Eli Friedmanca3d3fc2011-11-15 02:46:03 +00001942 if (EltTy->isAnyComplexType())
1943 // FIXME: Volatile?
1944 EltRV = RValue::getComplex(LoadComplexFromAddr(LV.getAddress(), false));
1945 else if (CodeGenFunction::hasAggregateLLVMType(EltTy))
Eli Friedman51f51202011-12-03 03:08:40 +00001946 EltRV = LV.asAggregateRValue();
Bob Wilson194f06a2011-08-03 05:58:22 +00001947 else
1948 EltRV = EmitLoadOfLValue(LV);
1949 ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy);
Chris Lattner811bf362011-07-12 06:29:11 +00001950 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001951 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00001952 RecordDecl *RD = RT->getDecl();
1953 assert(RV.isAggregate() && "Unexpected rvalue during struct expansion");
Eli Friedman377ecc72012-04-16 03:54:45 +00001954 LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001955
1956 if (RD->isUnion()) {
1957 const FieldDecl *LargestFD = 0;
1958 CharUnits UnionSize = CharUnits::Zero();
1959
1960 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1961 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00001962 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001963 assert(!FD->isBitField() &&
1964 "Cannot expand structure with bit-field members.");
1965 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
1966 if (UnionSize < FieldSize) {
1967 UnionSize = FieldSize;
1968 LargestFD = FD;
1969 }
1970 }
1971 if (LargestFD) {
Eli Friedman377ecc72012-04-16 03:54:45 +00001972 RValue FldRV = EmitRValueForField(LV, LargestFD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001973 ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy);
1974 }
1975 } else {
1976 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
1977 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00001978 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001979
Eli Friedman377ecc72012-04-16 03:54:45 +00001980 RValue FldRV = EmitRValueForField(LV, FD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00001981 ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy);
1982 }
Bob Wilson194f06a2011-08-03 05:58:22 +00001983 }
Eli Friedmanca3d3fc2011-11-15 02:46:03 +00001984 } else if (Ty->isAnyComplexType()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00001985 ComplexPairTy CV = RV.getComplexVal();
1986 Args.push_back(CV.first);
1987 Args.push_back(CV.second);
1988 } else {
Chris Lattner811bf362011-07-12 06:29:11 +00001989 assert(RV.isScalar() &&
1990 "Unexpected non-scalar rvalue during struct expansion.");
1991
1992 // Insert a bitcast as needed.
1993 llvm::Value *V = RV.getScalarVal();
1994 if (Args.size() < IRFuncTy->getNumParams() &&
1995 V->getType() != IRFuncTy->getParamType(Args.size()))
1996 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size()));
1997
1998 Args.push_back(V);
1999 }
2000}
2001
2002
Daniel Dunbar88b53962009-02-02 22:03:45 +00002003RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
Mike Stump1eb44332009-09-09 15:08:12 +00002004 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00002005 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00002006 const CallArgList &CallArgs,
David Chisnalldd5c98f2010-05-01 11:15:56 +00002007 const Decl *TargetDecl,
David Chisnall4b02afc2010-05-02 13:41:58 +00002008 llvm::Instruction **callOrInvoke) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00002009 // FIXME: We no longer need the types from CallArgs; lift up and simplify.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002010 SmallVector<llvm::Value*, 16> Args;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002011
2012 // Handle struct-return functions by passing a pointer to the
2013 // location that we would like to return into.
Daniel Dunbarbb36d332009-02-02 21:43:58 +00002014 QualType RetTy = CallInfo.getReturnType();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002015 const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00002016
Chris Lattner70855442011-07-12 04:46:18 +00002017 // IRArgNo - Keep track of the argument number in the callee we're looking at.
2018 unsigned IRArgNo = 0;
2019 llvm::FunctionType *IRFuncTy =
2020 cast<llvm::FunctionType>(
2021 cast<llvm::PointerType>(Callee->getType())->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +00002022
Chris Lattner5db7ae52009-06-13 00:26:38 +00002023 // If the call returns a temporary with struct return, create a temporary
Anders Carlssond2490a92009-12-24 20:40:36 +00002024 // alloca to hold the result, unless one is given to us.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002025 if (CGM.ReturnTypeUsesSRet(CallInfo)) {
Anders Carlssond2490a92009-12-24 20:40:36 +00002026 llvm::Value *Value = ReturnValue.getValue();
2027 if (!Value)
Daniel Dunbar195337d2010-02-09 02:48:28 +00002028 Value = CreateMemTemp(RetTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002029 Args.push_back(Value);
Chris Lattner70855442011-07-12 04:46:18 +00002030 checkArgMatches(Value, IRArgNo, IRFuncTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002031 }
Mike Stump1eb44332009-09-09 15:08:12 +00002032
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00002033 assert(CallInfo.arg_size() == CallArgs.size() &&
2034 "Mismatch between function signature & arguments.");
Daniel Dunbarb225be42009-02-03 05:59:18 +00002035 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00002036 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002037 I != E; ++I, ++info_it) {
2038 const ABIArgInfo &ArgInfo = info_it->info;
Eli Friedmanc6d07822011-05-02 18:05:27 +00002039 RValue RV = I->RV;
Daniel Dunbar56273772008-09-17 00:51:38 +00002040
Eli Friedman97cb5a42011-06-15 22:09:18 +00002041 unsigned TypeAlign =
Eli Friedmanc6d07822011-05-02 18:05:27 +00002042 getContext().getTypeAlignInChars(I->Ty).getQuantity();
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00002043
2044 // Insert a padding argument to ensure proper alignment.
2045 if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) {
2046 Args.push_back(llvm::UndefValue::get(PaddingType));
2047 ++IRArgNo;
2048 }
2049
Daniel Dunbar56273772008-09-17 00:51:38 +00002050 switch (ArgInfo.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002051 case ABIArgInfo::Indirect: {
Daniel Dunbar1f745982009-02-05 09:16:39 +00002052 if (RV.isScalar() || RV.isComplex()) {
2053 // Make a temporary alloca to pass the argument.
Eli Friedman70cbd2a2011-06-15 18:26:32 +00002054 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2055 if (ArgInfo.getIndirectAlign() > AI->getAlignment())
2056 AI->setAlignment(ArgInfo.getIndirectAlign());
2057 Args.push_back(AI);
Chris Lattner70855442011-07-12 04:46:18 +00002058
Daniel Dunbar1f745982009-02-05 09:16:39 +00002059 if (RV.isScalar())
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002060 EmitStoreOfScalar(RV.getScalarVal(), Args.back(), false,
Eli Friedman97cb5a42011-06-15 22:09:18 +00002061 TypeAlign, I->Ty);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002062 else
Mike Stump1eb44332009-09-09 15:08:12 +00002063 StoreComplexToAddr(RV.getComplexVal(), Args.back(), false);
Chris Lattner70855442011-07-12 04:46:18 +00002064
2065 // Validate argument match.
2066 checkArgMatches(AI, IRArgNo, IRFuncTy);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002067 } else {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002068 // We want to avoid creating an unnecessary temporary+copy here;
2069 // however, we need one in two cases:
2070 // 1. If the argument is not byval, and we are required to copy the
2071 // source. (This case doesn't occur on any common architecture.)
2072 // 2. If the argument is byval, RV is not sufficiently aligned, and
2073 // we cannot force it to be sufficiently aligned.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002074 llvm::Value *Addr = RV.getAggregateAddr();
2075 unsigned Align = ArgInfo.getIndirectAlign();
Micah Villmow25a6a842012-10-08 16:25:52 +00002076 const llvm::DataLayout *TD = &CGM.getDataLayout();
Eli Friedman97cb5a42011-06-15 22:09:18 +00002077 if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) ||
2078 (ArgInfo.getIndirectByVal() && TypeAlign < Align &&
2079 llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align)) {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002080 // Create an aligned temporary, and copy to it.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002081 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2082 if (Align > AI->getAlignment())
2083 AI->setAlignment(Align);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002084 Args.push_back(AI);
Chad Rosier649b4a12012-03-29 17:37:10 +00002085 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified());
Chris Lattner70855442011-07-12 04:46:18 +00002086
2087 // Validate argument match.
2088 checkArgMatches(AI, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002089 } else {
2090 // Skip the extra memcpy call.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002091 Args.push_back(Addr);
Chris Lattner70855442011-07-12 04:46:18 +00002092
2093 // Validate argument match.
2094 checkArgMatches(Addr, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002095 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002096 }
2097 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002098 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002099
Daniel Dunbar11434922009-01-26 21:26:08 +00002100 case ABIArgInfo::Ignore:
2101 break;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002102
Chris Lattner800588f2010-07-29 06:26:06 +00002103 case ABIArgInfo::Extend:
2104 case ABIArgInfo::Direct: {
2105 if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00002106 ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
2107 ArgInfo.getDirectOffset() == 0) {
Chris Lattner70855442011-07-12 04:46:18 +00002108 llvm::Value *V;
Chris Lattner800588f2010-07-29 06:26:06 +00002109 if (RV.isScalar())
Chris Lattner70855442011-07-12 04:46:18 +00002110 V = RV.getScalarVal();
Chris Lattner800588f2010-07-29 06:26:06 +00002111 else
Chris Lattner70855442011-07-12 04:46:18 +00002112 V = Builder.CreateLoad(RV.getAggregateAddr());
2113
Chris Lattner21ca1fd2011-07-12 04:53:39 +00002114 // If the argument doesn't match, perform a bitcast to coerce it. This
2115 // can happen due to trivial type mismatches.
2116 if (IRArgNo < IRFuncTy->getNumParams() &&
2117 V->getType() != IRFuncTy->getParamType(IRArgNo))
2118 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo));
Chris Lattner70855442011-07-12 04:46:18 +00002119 Args.push_back(V);
2120
Chris Lattner70855442011-07-12 04:46:18 +00002121 checkArgMatches(V, IRArgNo, IRFuncTy);
Chris Lattner800588f2010-07-29 06:26:06 +00002122 break;
2123 }
Daniel Dunbar11434922009-01-26 21:26:08 +00002124
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002125 // FIXME: Avoid the conversion through memory if possible.
2126 llvm::Value *SrcPtr;
2127 if (RV.isScalar()) {
Eli Friedmanc6d07822011-05-02 18:05:27 +00002128 SrcPtr = CreateMemTemp(I->Ty, "coerce");
Eli Friedman97cb5a42011-06-15 22:09:18 +00002129 EmitStoreOfScalar(RV.getScalarVal(), SrcPtr, false, TypeAlign, I->Ty);
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002130 } else if (RV.isComplex()) {
Eli Friedmanc6d07822011-05-02 18:05:27 +00002131 SrcPtr = CreateMemTemp(I->Ty, "coerce");
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002132 StoreComplexToAddr(RV.getComplexVal(), SrcPtr, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002133 } else
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002134 SrcPtr = RV.getAggregateAddr();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002135
Chris Lattner117e3f42010-07-30 04:02:24 +00002136 // If the value is offset in memory, apply the offset now.
2137 if (unsigned Offs = ArgInfo.getDirectOffset()) {
2138 SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy());
2139 SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002140 SrcPtr = Builder.CreateBitCast(SrcPtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002141 llvm::PointerType::getUnqual(ArgInfo.getCoerceToType()));
2142
2143 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002144
Chris Lattnerce700162010-06-28 23:44:11 +00002145 // If the coerce-to type is a first class aggregate, we flatten it and
2146 // pass the elements. Either way is semantically identical, but fast-isel
2147 // and the optimizer generally likes scalar values better than FCAs.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002148 if (llvm::StructType *STy =
Chris Lattner309c59f2010-06-29 00:06:42 +00002149 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType())) {
Chandler Carruthf82232c2012-10-10 11:29:08 +00002150 llvm::Type *SrcTy =
2151 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
2152 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
2153 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
2154
2155 // If the source type is smaller than the destination type of the
2156 // coerce-to logic, copy the source value into a temp alloca the size
2157 // of the destination type to allow loading all of it. The bits past
2158 // the source value are left undef.
2159 if (SrcSize < DstSize) {
2160 llvm::AllocaInst *TempAlloca
2161 = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce");
2162 Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0);
2163 SrcPtr = TempAlloca;
2164 } else {
2165 SrcPtr = Builder.CreateBitCast(SrcPtr,
2166 llvm::PointerType::getUnqual(STy));
2167 }
2168
Chris Lattner92826882010-07-05 20:41:41 +00002169 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2170 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i);
Chris Lattnerdeabde22010-07-28 18:24:28 +00002171 llvm::LoadInst *LI = Builder.CreateLoad(EltPtr);
2172 // We don't know what we're loading from.
2173 LI->setAlignment(1);
2174 Args.push_back(LI);
Chris Lattner70855442011-07-12 04:46:18 +00002175
2176 // Validate argument match.
2177 checkArgMatches(LI, IRArgNo, IRFuncTy);
Chris Lattner309c59f2010-06-29 00:06:42 +00002178 }
Chris Lattnerce700162010-06-28 23:44:11 +00002179 } else {
Chris Lattner309c59f2010-06-29 00:06:42 +00002180 // In the simple case, just pass the coerced loaded value.
2181 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(),
2182 *this));
Chris Lattner70855442011-07-12 04:46:18 +00002183
2184 // Validate argument match.
2185 checkArgMatches(Args.back(), IRArgNo, IRFuncTy);
Chris Lattnerce700162010-06-28 23:44:11 +00002186 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002187
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002188 break;
2189 }
2190
Daniel Dunbar56273772008-09-17 00:51:38 +00002191 case ABIArgInfo::Expand:
Chris Lattner811bf362011-07-12 06:29:11 +00002192 ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy);
Chris Lattner70855442011-07-12 04:46:18 +00002193 IRArgNo = Args.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00002194 break;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002195 }
2196 }
Mike Stump1eb44332009-09-09 15:08:12 +00002197
Chris Lattner5db7ae52009-06-13 00:26:38 +00002198 // If the callee is a bitcast of a function to a varargs pointer to function
2199 // type, check to see if we can remove the bitcast. This handles some cases
2200 // with unprototyped functions.
2201 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee))
2202 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002203 llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType());
2204 llvm::FunctionType *CurFT =
Chris Lattner5db7ae52009-06-13 00:26:38 +00002205 cast<llvm::FunctionType>(CurPT->getElementType());
Chris Lattner2acc6e32011-07-18 04:24:23 +00002206 llvm::FunctionType *ActualFT = CalleeF->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +00002207
Chris Lattner5db7ae52009-06-13 00:26:38 +00002208 if (CE->getOpcode() == llvm::Instruction::BitCast &&
2209 ActualFT->getReturnType() == CurFT->getReturnType() &&
Chris Lattnerd6bebbf2009-06-23 01:38:41 +00002210 ActualFT->getNumParams() == CurFT->getNumParams() &&
Fariborz Jahanianc0ddef22011-03-01 17:28:13 +00002211 ActualFT->getNumParams() == Args.size() &&
2212 (CurFT->isVarArg() || !ActualFT->isVarArg())) {
Chris Lattner5db7ae52009-06-13 00:26:38 +00002213 bool ArgsMatch = true;
2214 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i)
2215 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) {
2216 ArgsMatch = false;
2217 break;
2218 }
Mike Stump1eb44332009-09-09 15:08:12 +00002219
Chris Lattner5db7ae52009-06-13 00:26:38 +00002220 // Strip the cast if we can get away with it. This is a nice cleanup,
2221 // but also allows us to inline the function at -O0 if it is marked
2222 // always_inline.
2223 if (ArgsMatch)
2224 Callee = CalleeF;
2225 }
2226 }
Mike Stump1eb44332009-09-09 15:08:12 +00002227
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002228 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +00002229 CodeGen::AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002230 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, CallingConv);
Bill Wendling785b7782012-12-07 23:17:26 +00002231 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
Bill Wendlingdd851592012-11-20 05:09:43 +00002232 AttributeList);
Mike Stump1eb44332009-09-09 15:08:12 +00002233
John McCallf1549f62010-07-06 01:34:17 +00002234 llvm::BasicBlock *InvokeDest = 0;
Bill Wendling01ad9542012-12-30 10:32:17 +00002235 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
2236 llvm::Attribute::NoUnwind))
John McCallf1549f62010-07-06 01:34:17 +00002237 InvokeDest = getInvokeDest();
2238
Daniel Dunbard14151d2009-03-02 04:32:35 +00002239 llvm::CallSite CS;
John McCallf1549f62010-07-06 01:34:17 +00002240 if (!InvokeDest) {
Jay Foad4c7d9f12011-07-15 08:37:34 +00002241 CS = Builder.CreateCall(Callee, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002242 } else {
2243 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Jay Foad4c7d9f12011-07-15 08:37:34 +00002244 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002245 EmitBlock(Cont);
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002246 }
Chris Lattnerce933992010-06-29 16:40:28 +00002247 if (callOrInvoke)
David Chisnall4b02afc2010-05-02 13:41:58 +00002248 *callOrInvoke = CS.getInstruction();
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002249
Daniel Dunbard14151d2009-03-02 04:32:35 +00002250 CS.setAttributes(Attrs);
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002251 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbard14151d2009-03-02 04:32:35 +00002252
Dan Gohmanb49bd272012-02-16 00:57:37 +00002253 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2254 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00002255 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00002256 AddObjCARCExceptionMetadata(CS.getInstruction());
2257
Daniel Dunbard14151d2009-03-02 04:32:35 +00002258 // If the call doesn't return, finish the basic block and clear the
2259 // insertion point; this allows the rest of IRgen to discard
2260 // unreachable code.
2261 if (CS.doesNotReturn()) {
2262 Builder.CreateUnreachable();
2263 Builder.ClearInsertionPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002264
Mike Stumpf5408fe2009-05-16 07:57:57 +00002265 // FIXME: For now, emit a dummy basic block because expr emitters in
2266 // generally are not ready to handle emitting expressions at unreachable
2267 // points.
Daniel Dunbard14151d2009-03-02 04:32:35 +00002268 EnsureInsertPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002269
Daniel Dunbard14151d2009-03-02 04:32:35 +00002270 // Return a reasonable RValue.
2271 return GetUndefRValue(RetTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002272 }
Daniel Dunbard14151d2009-03-02 04:32:35 +00002273
2274 llvm::Instruction *CI = CS.getInstruction();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00002275 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy())
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002276 CI->setName("call");
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002277
John McCallf85e1932011-06-15 23:02:42 +00002278 // Emit any writebacks immediately. Arguably this should happen
2279 // after any return-value munging.
2280 if (CallArgs.hasWritebacks())
2281 emitWritebacks(*this, CallArgs);
2282
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002283 switch (RetAI.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002284 case ABIArgInfo::Indirect: {
2285 unsigned Alignment = getContext().getTypeAlignInChars(RetTy).getQuantity();
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002286 if (RetTy->isAnyComplexType())
Daniel Dunbar56273772008-09-17 00:51:38 +00002287 return RValue::getComplex(LoadComplexFromAddr(Args[0], false));
Chris Lattner34030842009-03-22 00:32:22 +00002288 if (CodeGenFunction::hasAggregateLLVMType(RetTy))
Daniel Dunbar56273772008-09-17 00:51:38 +00002289 return RValue::getAggregate(Args[0]);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002290 return RValue::get(EmitLoadOfScalar(Args[0], false, Alignment, RetTy));
2291 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002292
Daniel Dunbar11434922009-01-26 21:26:08 +00002293 case ABIArgInfo::Ignore:
Daniel Dunbar0bcc5212009-02-03 06:30:17 +00002294 // If we are ignoring an argument that had a result, make sure to
2295 // construct the appropriate return value for our caller.
Daniel Dunbar13e81732009-02-05 07:09:07 +00002296 return GetUndefRValue(RetTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002297
Chris Lattner800588f2010-07-29 06:26:06 +00002298 case ABIArgInfo::Extend:
2299 case ABIArgInfo::Direct: {
Chris Lattner6af13f32011-07-13 03:59:32 +00002300 llvm::Type *RetIRTy = ConvertType(RetTy);
2301 if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00002302 if (RetTy->isAnyComplexType()) {
2303 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
2304 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
2305 return RValue::getComplex(std::make_pair(Real, Imag));
2306 }
2307 if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
2308 llvm::Value *DestPtr = ReturnValue.getValue();
2309 bool DestIsVolatile = ReturnValue.isVolatile();
Daniel Dunbar11434922009-01-26 21:26:08 +00002310
Chris Lattner800588f2010-07-29 06:26:06 +00002311 if (!DestPtr) {
2312 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
2313 DestIsVolatile = false;
2314 }
Eli Friedmanbadea572011-05-17 21:08:01 +00002315 BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false);
Chris Lattner800588f2010-07-29 06:26:06 +00002316 return RValue::getAggregate(DestPtr);
2317 }
Chris Lattner6af13f32011-07-13 03:59:32 +00002318
2319 // If the argument doesn't match, perform a bitcast to coerce it. This
2320 // can happen due to trivial type mismatches.
2321 llvm::Value *V = CI;
2322 if (V->getType() != RetIRTy)
2323 V = Builder.CreateBitCast(V, RetIRTy);
2324 return RValue::get(V);
Chris Lattner800588f2010-07-29 06:26:06 +00002325 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002326
Anders Carlssond2490a92009-12-24 20:40:36 +00002327 llvm::Value *DestPtr = ReturnValue.getValue();
2328 bool DestIsVolatile = ReturnValue.isVolatile();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002329
Anders Carlssond2490a92009-12-24 20:40:36 +00002330 if (!DestPtr) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00002331 DestPtr = CreateMemTemp(RetTy, "coerce");
Anders Carlssond2490a92009-12-24 20:40:36 +00002332 DestIsVolatile = false;
2333 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002334
Chris Lattner117e3f42010-07-30 04:02:24 +00002335 // If the value is offset in memory, apply the offset now.
2336 llvm::Value *StorePtr = DestPtr;
2337 if (unsigned Offs = RetAI.getDirectOffset()) {
2338 StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy());
2339 StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002340 StorePtr = Builder.CreateBitCast(StorePtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002341 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
2342 }
2343 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002344
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002345 unsigned Alignment = getContext().getTypeAlignInChars(RetTy).getQuantity();
Anders Carlssonad3d6912008-11-25 22:21:48 +00002346 if (RetTy->isAnyComplexType())
Anders Carlssond2490a92009-12-24 20:40:36 +00002347 return RValue::getComplex(LoadComplexFromAddr(DestPtr, false));
Chris Lattner34030842009-03-22 00:32:22 +00002348 if (CodeGenFunction::hasAggregateLLVMType(RetTy))
Anders Carlssond2490a92009-12-24 20:40:36 +00002349 return RValue::getAggregate(DestPtr);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002350 return RValue::get(EmitLoadOfScalar(DestPtr, false, Alignment, RetTy));
Daniel Dunbar639ffe42008-09-10 07:04:09 +00002351 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002352
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002353 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00002354 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002355 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002356
David Blaikieb219cfc2011-09-23 05:06:16 +00002357 llvm_unreachable("Unhandled ABIArgInfo::Kind");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002358}
Daniel Dunbarb4094ea2009-02-10 20:44:09 +00002359
2360/* VarArg handling */
2361
2362llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) {
2363 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this);
2364}