blob: 9a38771aa45c204573083daea6e623ef65eda660 [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"
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +000026#include "llvm/ADT/StringExtras.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000027#include "llvm/IR/Attributes.h"
28#include "llvm/IR/DataLayout.h"
29#include "llvm/IR/InlineAsm.h"
Bill Wendlingc0dcc2d2013-02-15 21:30:01 +000030#include "llvm/MC/SubtargetFeature.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000031#include "llvm/Support/CallSite.h"
Eli Friedman97cb5a42011-06-15 22:09:18 +000032#include "llvm/Transforms/Utils/Local.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000033using namespace clang;
34using namespace CodeGen;
35
36/***/
37
John McCall04a67a62010-02-05 21:31:56 +000038static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) {
39 switch (CC) {
40 default: return llvm::CallingConv::C;
41 case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
42 case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
Douglas Gregorf813a2c2010-05-18 16:57:00 +000043 case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
Anton Korobeynikov414d8962011-04-14 20:06:49 +000044 case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
45 case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
Guy Benyei38980082012-12-25 08:53:55 +000046 case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;
Dawn Perchik52fc3142010-09-03 01:29:35 +000047 // TODO: add support for CC_X86Pascal to llvm
John McCall04a67a62010-02-05 21:31:56 +000048 }
49}
50
John McCall0b0ef0a2010-02-24 07:14:12 +000051/// Derives the 'this' type for codegen purposes, i.e. ignoring method
52/// qualification.
53/// FIXME: address space qualification?
John McCallead608a2010-02-26 00:48:12 +000054static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) {
55 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
56 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +000057}
58
John McCall0b0ef0a2010-02-24 07:14:12 +000059/// Returns the canonical formal type of the given C++ method.
John McCallead608a2010-02-26 00:48:12 +000060static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
61 return MD->getType()->getCanonicalTypeUnqualified()
62 .getAs<FunctionProtoType>();
John McCall0b0ef0a2010-02-24 07:14:12 +000063}
64
65/// Returns the "extra-canonicalized" return type, which discards
66/// qualifiers on the return type. Codegen doesn't care about them,
67/// and it makes ABI code a little easier to be able to assume that
68/// all parameter and return types are top-level unqualified.
John McCallead608a2010-02-26 00:48:12 +000069static CanQualType GetReturnType(QualType RetTy) {
70 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
John McCall0b0ef0a2010-02-24 07:14:12 +000071}
72
John McCall0f3d0972012-07-07 06:41:13 +000073/// Arrange the argument and result information for a value of the given
74/// unprototyped freestanding function type.
John McCall0b0ef0a2010-02-24 07:14:12 +000075const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +000076CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
John McCallde5d3c72012-02-17 03:33:10 +000077 // When translating an unprototyped function type, always use a
78 // variadic type.
John McCall0f3d0972012-07-07 06:41:13 +000079 return arrangeLLVMFunctionInfo(FTNP->getResultType().getUnqualifiedType(),
Dmitri Gribenko55431692013-05-05 00:41:58 +000080 None, FTNP->getExtInfo(), 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()));
Stephen Lin3b50e8d2013-06-30 20:40:16 +0000203
204 GlobalDecl GD(D, ctorKind);
205 CanQualType resultType =
206 TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000207
John McCallde5d3c72012-02-17 03:33:10 +0000208 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes);
John McCall0b0ef0a2010-02-24 07:14:12 +0000209
John McCall4c40d982010-08-31 07:33:07 +0000210 CanQual<FunctionProtoType> FTP = GetFormalType(D);
211
John McCallde5d3c72012-02-17 03:33:10 +0000212 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size());
213
John McCall4c40d982010-08-31 07:33:07 +0000214 // Add the formal parameters.
215 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000216 argTypes.push_back(FTP->getArgType(i));
John McCall4c40d982010-08-31 07:33:07 +0000217
John McCall0f3d0972012-07-07 06:41:13 +0000218 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000219 adjustCXXMethodInfo(*this, extInfo, FTP->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000220 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000221}
222
John McCallde5d3c72012-02-17 03:33:10 +0000223/// Arrange the argument and result information for a declaration,
224/// definition, or call to the given destructor variant. It so
225/// happens that all three cases produce the same information.
226const CGFunctionInfo &
227CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D,
228 CXXDtorType dtorKind) {
229 SmallVector<CanQualType, 2> argTypes;
230 argTypes.push_back(GetThisType(Context, D->getParent()));
Stephen Lin3b50e8d2013-06-30 20:40:16 +0000231
232 GlobalDecl GD(D, dtorKind);
233 CanQualType resultType =
234 TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy;
John McCall0b0ef0a2010-02-24 07:14:12 +0000235
John McCallde5d3c72012-02-17 03:33:10 +0000236 TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes);
John McCall4c40d982010-08-31 07:33:07 +0000237
238 CanQual<FunctionProtoType> FTP = GetFormalType(D);
239 assert(FTP->getNumArgs() == 0 && "dtor with formal parameters");
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000240 assert(FTP->isVariadic() == 0 && "dtor with formal parameters");
John McCall4c40d982010-08-31 07:33:07 +0000241
John McCall0f3d0972012-07-07 06:41:13 +0000242 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000243 adjustCXXMethodInfo(*this, extInfo, false);
John McCall0f3d0972012-07-07 06:41:13 +0000244 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo,
245 RequiredArgs::All);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000246}
247
John McCallde5d3c72012-02-17 03:33:10 +0000248/// Arrange the argument and result information for the declaration or
249/// definition of the given function.
250const CGFunctionInfo &
251CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
Chris Lattner3eb67ca2009-05-12 20:27:19 +0000252 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000253 if (MD->isInstance())
John McCallde5d3c72012-02-17 03:33:10 +0000254 return arrangeCXXMethodDeclaration(MD);
Mike Stump1eb44332009-09-09 15:08:12 +0000255
John McCallead608a2010-02-26 00:48:12 +0000256 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
John McCallde5d3c72012-02-17 03:33:10 +0000257
John McCallead608a2010-02-26 00:48:12 +0000258 assert(isa<FunctionType>(FTy));
John McCallde5d3c72012-02-17 03:33:10 +0000259
260 // When declaring a function without a prototype, always use a
261 // non-variadic type.
262 if (isa<FunctionNoProtoType>(FTy)) {
263 CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>();
Dmitri Gribenko55431692013-05-05 00:41:58 +0000264 return arrangeLLVMFunctionInfo(noProto->getResultType(), None,
265 noProto->getExtInfo(), RequiredArgs::All);
John McCallde5d3c72012-02-17 03:33:10 +0000266 }
267
John McCallead608a2010-02-26 00:48:12 +0000268 assert(isa<FunctionProtoType>(FTy));
John McCall0f3d0972012-07-07 06:41:13 +0000269 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>());
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000270}
271
John McCallde5d3c72012-02-17 03:33:10 +0000272/// Arrange the argument and result information for the declaration or
273/// definition of an Objective-C method.
274const CGFunctionInfo &
275CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) {
276 // It happens that this is the same as a call with no optional
277 // arguments, except also using the formal 'self' type.
278 return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType());
279}
280
281/// Arrange the argument and result information for the function type
282/// through which to perform a send to the given Objective-C method,
283/// using the given receiver type. The receiver type is not always
284/// the 'self' type of the method or even an Objective-C pointer type.
285/// This is *not* the right method for actually performing such a
286/// message send, due to the possibility of optional arguments.
287const CGFunctionInfo &
288CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
289 QualType receiverType) {
290 SmallVector<CanQualType, 16> argTys;
291 argTys.push_back(Context.getCanonicalParamType(receiverType));
292 argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000293 // FIXME: Kill copy?
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000294 for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(),
John McCall0b0ef0a2010-02-24 07:14:12 +0000295 e = MD->param_end(); i != e; ++i) {
John McCallde5d3c72012-02-17 03:33:10 +0000296 argTys.push_back(Context.getCanonicalParamType((*i)->getType()));
John McCall0b0ef0a2010-02-24 07:14:12 +0000297 }
John McCallf85e1932011-06-15 23:02:42 +0000298
299 FunctionType::ExtInfo einfo;
300 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD));
301
David Blaikie4e4d0842012-03-11 07:00:24 +0000302 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +0000303 MD->hasAttr<NSReturnsRetainedAttr>())
304 einfo = einfo.withProducesResult(true);
305
John McCallde5d3c72012-02-17 03:33:10 +0000306 RequiredArgs required =
307 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
308
John McCall0f3d0972012-07-07 06:41:13 +0000309 return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys,
310 einfo, required);
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000311}
312
John McCallde5d3c72012-02-17 03:33:10 +0000313const CGFunctionInfo &
314CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000315 // FIXME: Do we need to handle ObjCMethodDecl?
316 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000317
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000318 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000319 return arrangeCXXConstructorDeclaration(CD, GD.getCtorType());
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000320
321 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000322 return arrangeCXXDestructor(DD, GD.getDtorType());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000323
John McCallde5d3c72012-02-17 03:33:10 +0000324 return arrangeFunctionDeclaration(FD);
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000325}
326
John McCalle56bb362012-12-07 07:03:17 +0000327/// Arrange a call as unto a free function, except possibly with an
328/// additional number of formal parameters considered required.
329static const CGFunctionInfo &
330arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
331 const CallArgList &args,
332 const FunctionType *fnType,
333 unsigned numExtraRequiredArgs) {
334 assert(args.size() >= numExtraRequiredArgs);
335
336 // In most cases, there are no optional arguments.
337 RequiredArgs required = RequiredArgs::All;
338
339 // If we have a variadic prototype, the required arguments are the
340 // extra prefix plus the arguments in the prototype.
341 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
342 if (proto->isVariadic())
343 required = RequiredArgs(proto->getNumArgs() + numExtraRequiredArgs);
344
345 // If we don't have a prototype at all, but we're supposed to
346 // explicitly use the variadic convention for unprototyped calls,
347 // treat all of the arguments as required but preserve the nominal
348 // possibility of variadics.
349 } else if (CGT.CGM.getTargetCodeGenInfo()
350 .isNoProtoCallVariadic(args, cast<FunctionNoProtoType>(fnType))) {
351 required = RequiredArgs(args.size());
352 }
353
354 return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args,
355 fnType->getExtInfo(), required);
356}
357
John McCallde5d3c72012-02-17 03:33:10 +0000358/// Figure out the rules for calling a function with the given formal
359/// type using the given arguments. The arguments are necessary
360/// because the function might be unprototyped, in which case it's
361/// target-dependent in crazy ways.
362const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000363CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
364 const FunctionType *fnType) {
John McCalle56bb362012-12-07 07:03:17 +0000365 return arrangeFreeFunctionLikeCall(*this, args, fnType, 0);
366}
John McCallde5d3c72012-02-17 03:33:10 +0000367
John McCalle56bb362012-12-07 07:03:17 +0000368/// A block function call is essentially a free-function call with an
369/// extra implicit argument.
370const CGFunctionInfo &
371CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
372 const FunctionType *fnType) {
373 return arrangeFreeFunctionLikeCall(*this, args, fnType, 1);
John McCallde5d3c72012-02-17 03:33:10 +0000374}
375
376const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000377CodeGenTypes::arrangeFreeFunctionCall(QualType resultType,
378 const CallArgList &args,
379 FunctionType::ExtInfo info,
380 RequiredArgs required) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000381 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000382 SmallVector<CanQualType, 16> argTypes;
383 for (CallArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbar725ad312009-01-31 02:19:00 +0000384 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000385 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
John McCall0f3d0972012-07-07 06:41:13 +0000386 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
387 required);
388}
389
390/// Arrange a call to a C++ method, passing the given arguments.
391const CGFunctionInfo &
392CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
393 const FunctionProtoType *FPT,
394 RequiredArgs required) {
395 // FIXME: Kill copy.
396 SmallVector<CanQualType, 16> argTypes;
397 for (CallArgList::const_iterator i = args.begin(), e = args.end();
398 i != e; ++i)
399 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
400
401 FunctionType::ExtInfo info = FPT->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000402 adjustCXXMethodInfo(*this, info, FPT->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000403 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()),
404 argTypes, info, required);
Daniel Dunbar725ad312009-01-31 02:19:00 +0000405}
406
John McCallde5d3c72012-02-17 03:33:10 +0000407const CGFunctionInfo &
408CodeGenTypes::arrangeFunctionDeclaration(QualType resultType,
409 const FunctionArgList &args,
410 const FunctionType::ExtInfo &info,
411 bool isVariadic) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000412 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000413 SmallVector<CanQualType, 16> argTypes;
414 for (FunctionArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000415 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000416 argTypes.push_back(Context.getCanonicalParamType((*i)->getType()));
417
418 RequiredArgs required =
419 (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All);
John McCall0f3d0972012-07-07 06:41:13 +0000420 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
421 required);
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000422}
423
John McCallde5d3c72012-02-17 03:33:10 +0000424const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000425 return arrangeLLVMFunctionInfo(getContext().VoidTy, None,
John McCall0f3d0972012-07-07 06:41:13 +0000426 FunctionType::ExtInfo(), RequiredArgs::All);
John McCalld26bc762011-03-09 04:27:21 +0000427}
428
John McCallde5d3c72012-02-17 03:33:10 +0000429/// Arrange the argument and result information for an abstract value
430/// of a given function type. This is the method which all of the
431/// above functions ultimately defer to.
432const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000433CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
434 ArrayRef<CanQualType> argTypes,
435 FunctionType::ExtInfo info,
436 RequiredArgs required) {
John McCallead608a2010-02-26 00:48:12 +0000437#ifndef NDEBUG
John McCallde5d3c72012-02-17 03:33:10 +0000438 for (ArrayRef<CanQualType>::const_iterator
439 I = argTypes.begin(), E = argTypes.end(); I != E; ++I)
John McCallead608a2010-02-26 00:48:12 +0000440 assert(I->isCanonicalAsParam());
441#endif
442
John McCallde5d3c72012-02-17 03:33:10 +0000443 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
John McCall04a67a62010-02-05 21:31:56 +0000444
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000445 // Lookup or create unique function info.
446 llvm::FoldingSetNodeID ID;
John McCallde5d3c72012-02-17 03:33:10 +0000447 CGFunctionInfo::Profile(ID, info, required, resultType, argTypes);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000448
John McCallde5d3c72012-02-17 03:33:10 +0000449 void *insertPos = 0;
450 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000451 if (FI)
452 return *FI;
453
John McCallde5d3c72012-02-17 03:33:10 +0000454 // Construct the function info. We co-allocate the ArgInfos.
455 FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required);
456 FunctionInfos.InsertNode(FI, insertPos);
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000457
John McCallde5d3c72012-02-17 03:33:10 +0000458 bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted;
459 assert(inserted && "Recursively being processed?");
Chris Lattner71305cc2011-07-15 05:16:14 +0000460
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000461 // Compute ABI information.
Chris Lattneree5dcd02010-07-29 02:31:05 +0000462 getABIInfo().computeInfo(*FI);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000463
Chris Lattner800588f2010-07-29 06:26:06 +0000464 // Loop over all of the computed argument and return value info. If any of
465 // them are direct or extend without a specified coerce type, specify the
466 // default now.
John McCallde5d3c72012-02-17 03:33:10 +0000467 ABIArgInfo &retInfo = FI->getReturnInfo();
468 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == 0)
469 retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000470
Chris Lattner800588f2010-07-29 06:26:06 +0000471 for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end();
472 I != E; ++I)
473 if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0)
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000474 I->info.setCoerceToType(ConvertType(I->type));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000475
John McCallde5d3c72012-02-17 03:33:10 +0000476 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
477 assert(erased && "Not in set?");
Chris Lattnerd26c0712011-07-15 06:41:05 +0000478
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000479 return *FI;
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000480}
481
John McCallde5d3c72012-02-17 03:33:10 +0000482CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
483 const FunctionType::ExtInfo &info,
484 CanQualType resultType,
485 ArrayRef<CanQualType> argTypes,
486 RequiredArgs required) {
487 void *buffer = operator new(sizeof(CGFunctionInfo) +
488 sizeof(ArgInfo) * (argTypes.size() + 1));
489 CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
490 FI->CallingConvention = llvmCC;
491 FI->EffectiveCallingConvention = llvmCC;
492 FI->ASTCallingConvention = info.getCC();
493 FI->NoReturn = info.getNoReturn();
494 FI->ReturnsRetained = info.getProducesResult();
495 FI->Required = required;
496 FI->HasRegParm = info.getHasRegParm();
497 FI->RegParm = info.getRegParm();
498 FI->NumArgs = argTypes.size();
499 FI->getArgsBuffer()[0].type = resultType;
500 for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
501 FI->getArgsBuffer()[i + 1].type = argTypes[i];
502 return FI;
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000503}
504
505/***/
506
John McCall42e06112011-05-15 02:19:42 +0000507void CodeGenTypes::GetExpandedTypes(QualType type,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000508 SmallVectorImpl<llvm::Type*> &expandedTypes) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000509 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) {
510 uint64_t NumElts = AT->getSize().getZExtValue();
511 for (uint64_t Elt = 0; Elt < NumElts; ++Elt)
512 GetExpandedTypes(AT->getElementType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000513 } else if (const RecordType *RT = type->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000514 const RecordDecl *RD = RT->getDecl();
515 assert(!RD->hasFlexibleArrayMember() &&
516 "Cannot expand structure with flexible array.");
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000517 if (RD->isUnion()) {
518 // Unions can be here only in degenerative cases - all the fields are same
519 // after flattening. Thus we have to use the "largest" field.
520 const FieldDecl *LargestFD = 0;
521 CharUnits UnionSize = CharUnits::Zero();
522
523 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
524 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000525 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000526 assert(!FD->isBitField() &&
527 "Cannot expand structure with bit-field members.");
528 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
529 if (UnionSize < FieldSize) {
530 UnionSize = FieldSize;
531 LargestFD = FD;
532 }
533 }
534 if (LargestFD)
535 GetExpandedTypes(LargestFD->getType(), expandedTypes);
536 } else {
537 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
538 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000539 assert(!i->isBitField() &&
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000540 "Cannot expand structure with bit-field members.");
David Blaikie581deb32012-06-06 20:45:41 +0000541 GetExpandedTypes(i->getType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000542 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000543 }
544 } else if (const ComplexType *CT = type->getAs<ComplexType>()) {
545 llvm::Type *EltTy = ConvertType(CT->getElementType());
546 expandedTypes.push_back(EltTy);
547 expandedTypes.push_back(EltTy);
548 } else
549 expandedTypes.push_back(ConvertType(type));
Daniel Dunbar56273772008-09-17 00:51:38 +0000550}
551
Mike Stump1eb44332009-09-09 15:08:12 +0000552llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +0000553CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
554 llvm::Function::arg_iterator AI) {
Mike Stump1eb44332009-09-09 15:08:12 +0000555 assert(LV.isSimple() &&
556 "Unexpected non-simple lvalue during struct expansion.");
Daniel Dunbar56273772008-09-17 00:51:38 +0000557
Bob Wilson194f06a2011-08-03 05:58:22 +0000558 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
559 unsigned NumElts = AT->getSize().getZExtValue();
560 QualType EltTy = AT->getElementType();
561 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
Eli Friedman377ecc72012-04-16 03:54:45 +0000562 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt);
Bob Wilson194f06a2011-08-03 05:58:22 +0000563 LValue LV = MakeAddrLValue(EltAddr, EltTy);
564 AI = ExpandTypeFromArgs(EltTy, LV, AI);
Daniel Dunbar56273772008-09-17 00:51:38 +0000565 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000566 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000567 RecordDecl *RD = RT->getDecl();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000568 if (RD->isUnion()) {
569 // Unions can be here only in degenerative cases - all the fields are same
570 // after flattening. Thus we have to use the "largest" field.
571 const FieldDecl *LargestFD = 0;
572 CharUnits UnionSize = CharUnits::Zero();
Bob Wilson194f06a2011-08-03 05:58:22 +0000573
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000574 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
575 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000576 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000577 assert(!FD->isBitField() &&
578 "Cannot expand structure with bit-field members.");
579 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
580 if (UnionSize < FieldSize) {
581 UnionSize = FieldSize;
582 LargestFD = FD;
583 }
584 }
585 if (LargestFD) {
586 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000587 LValue SubLV = EmitLValueForField(LV, LargestFD);
588 AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000589 }
590 } else {
591 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
592 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000593 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000594 QualType FT = FD->getType();
595
596 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000597 LValue SubLV = EmitLValueForField(LV, FD);
598 AI = ExpandTypeFromArgs(FT, SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000599 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000600 }
601 } else if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
602 QualType EltTy = CT->getElementType();
Eli Friedman377ecc72012-04-16 03:54:45 +0000603 llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real");
Bob Wilson194f06a2011-08-03 05:58:22 +0000604 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy));
Eli Friedman377ecc72012-04-16 03:54:45 +0000605 llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag");
Bob Wilson194f06a2011-08-03 05:58:22 +0000606 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy));
607 } else {
608 EmitStoreThroughLValue(RValue::get(AI), LV);
609 ++AI;
Daniel Dunbar56273772008-09-17 00:51:38 +0000610 }
611
612 return AI;
613}
614
Chris Lattnere7bb7772010-06-27 06:04:18 +0000615/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
Chris Lattner08dd2a02010-06-27 05:56:15 +0000616/// accessing some number of bytes out of it, try to gep into the struct to get
617/// at its inner goodness. Dive as deep as possible without entering an element
618/// with an in-memory size smaller than DstSize.
619static llvm::Value *
Chris Lattnere7bb7772010-06-27 06:04:18 +0000620EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000621 llvm::StructType *SrcSTy,
Chris Lattnere7bb7772010-06-27 06:04:18 +0000622 uint64_t DstSize, CodeGenFunction &CGF) {
Chris Lattner08dd2a02010-06-27 05:56:15 +0000623 // We can't dive into a zero-element struct.
624 if (SrcSTy->getNumElements() == 0) return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000625
Chris Lattner2acc6e32011-07-18 04:24:23 +0000626 llvm::Type *FirstElt = SrcSTy->getElementType(0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000627
Chris Lattner08dd2a02010-06-27 05:56:15 +0000628 // If the first elt is at least as large as what we're looking for, or if the
629 // first element is the same size as the whole struct, we can enter it.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000630 uint64_t FirstEltSize =
Micah Villmow25a6a842012-10-08 16:25:52 +0000631 CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000632 if (FirstEltSize < DstSize &&
Micah Villmow25a6a842012-10-08 16:25:52 +0000633 FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy))
Chris Lattner08dd2a02010-06-27 05:56:15 +0000634 return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000635
Chris Lattner08dd2a02010-06-27 05:56:15 +0000636 // GEP into the first element.
637 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000638
Chris Lattner08dd2a02010-06-27 05:56:15 +0000639 // If the first element is a struct, recurse.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000640 llvm::Type *SrcTy =
Chris Lattner08dd2a02010-06-27 05:56:15 +0000641 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000642 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
Chris Lattnere7bb7772010-06-27 06:04:18 +0000643 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000644
645 return SrcPtr;
646}
647
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000648/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
649/// are either integers or pointers. This does a truncation of the value if it
650/// is too large or a zero extension if it is too small.
Jakob Stoklund Olesen7e9f52f2013-06-05 03:00:13 +0000651///
652/// This behaves as if the value were coerced through memory, so on big-endian
653/// targets the high bits are preserved in a truncation, while little-endian
654/// targets preserve the low bits.
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000655static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000656 llvm::Type *Ty,
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000657 CodeGenFunction &CGF) {
658 if (Val->getType() == Ty)
659 return Val;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000660
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000661 if (isa<llvm::PointerType>(Val->getType())) {
662 // If this is Pointer->Pointer avoid conversion to and from int.
663 if (isa<llvm::PointerType>(Ty))
664 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000665
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000666 // Convert the pointer to an integer so we can play with its width.
Chris Lattner77b89b82010-06-27 07:15:29 +0000667 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000668 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000669
Chris Lattner2acc6e32011-07-18 04:24:23 +0000670 llvm::Type *DestIntTy = Ty;
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000671 if (isa<llvm::PointerType>(DestIntTy))
Chris Lattner77b89b82010-06-27 07:15:29 +0000672 DestIntTy = CGF.IntPtrTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000673
Jakob Stoklund Olesen7e9f52f2013-06-05 03:00:13 +0000674 if (Val->getType() != DestIntTy) {
675 const llvm::DataLayout &DL = CGF.CGM.getDataLayout();
676 if (DL.isBigEndian()) {
677 // Preserve the high bits on big-endian targets.
678 // That is what memory coercion does.
679 uint64_t SrcSize = DL.getTypeAllocSizeInBits(Val->getType());
680 uint64_t DstSize = DL.getTypeAllocSizeInBits(DestIntTy);
681 if (SrcSize > DstSize) {
682 Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits");
683 Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii");
684 } else {
685 Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii");
686 Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits");
687 }
688 } else {
689 // Little-endian targets preserve the low bits. No shifts required.
690 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
691 }
692 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000693
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000694 if (isa<llvm::PointerType>(Ty))
695 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
696 return Val;
697}
698
Chris Lattner08dd2a02010-06-27 05:56:15 +0000699
700
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000701/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
702/// a pointer to an object of type \arg Ty.
703///
704/// This safely handles the case when the src type is smaller than the
705/// destination type; in this situation the values of bits which not
706/// present in the src are undefined.
707static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000708 llvm::Type *Ty,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000709 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000710 llvm::Type *SrcTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000711 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000712
Chris Lattner6ae00692010-06-28 22:51:39 +0000713 // If SrcTy and Ty are the same, just do a load.
714 if (SrcTy == Ty)
715 return CGF.Builder.CreateLoad(SrcPtr);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000716
Micah Villmow25a6a842012-10-08 16:25:52 +0000717 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000718
Chris Lattner2acc6e32011-07-18 04:24:23 +0000719 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000720 SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000721 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
722 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000723
Micah Villmow25a6a842012-10-08 16:25:52 +0000724 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000725
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000726 // If the source and destination are integer or pointer types, just do an
727 // extension or truncation to the desired type.
728 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
729 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
730 llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr);
731 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
732 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000733
Daniel Dunbarb225be42009-02-03 05:59:18 +0000734 // If load is legal, just bitcast the src pointer.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000735 if (SrcSize >= DstSize) {
Mike Stumpf5408fe2009-05-16 07:57:57 +0000736 // Generally SrcSize is never greater than DstSize, since this means we are
737 // losing bits. However, this can happen in cases where the structure has
738 // additional padding, for example due to a user specified alignment.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000739 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000740 // FIXME: Assert that we aren't truncating non-padding bits when have access
741 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000742 llvm::Value *Casted =
743 CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000744 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted);
745 // FIXME: Use better alignment / avoid requiring aligned load.
746 Load->setAlignment(1);
747 return Load;
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000748 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000749
Chris Lattner35b21b82010-06-27 01:06:27 +0000750 // Otherwise do coercion through memory. This is stupid, but
751 // simple.
752 llvm::Value *Tmp = CGF.CreateTempAlloca(Ty);
Manman Renf51c61c2012-11-28 22:08:52 +0000753 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
754 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
755 llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000756 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000757 CGF.Builder.CreateMemCpy(Casted, SrcCasted,
758 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
759 1, false);
Chris Lattner35b21b82010-06-27 01:06:27 +0000760 return CGF.Builder.CreateLoad(Tmp);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000761}
762
Eli Friedmanbadea572011-05-17 21:08:01 +0000763// Function to store a first-class aggregate into memory. We prefer to
764// store the elements rather than the aggregate to be more friendly to
765// fast-isel.
766// FIXME: Do we need to recurse here?
767static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
768 llvm::Value *DestPtr, bool DestIsVolatile,
769 bool LowAlignment) {
770 // Prefer scalar stores to first-class aggregate stores.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000771 if (llvm::StructType *STy =
Eli Friedmanbadea572011-05-17 21:08:01 +0000772 dyn_cast<llvm::StructType>(Val->getType())) {
773 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
774 llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i);
775 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
776 llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr,
777 DestIsVolatile);
778 if (LowAlignment)
779 SI->setAlignment(1);
780 }
781 } else {
Bill Wendling08212632012-03-16 21:45:12 +0000782 llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile);
783 if (LowAlignment)
784 SI->setAlignment(1);
Eli Friedmanbadea572011-05-17 21:08:01 +0000785 }
786}
787
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000788/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
789/// where the source and destination may have different types.
790///
791/// This safely handles the case when the src type is larger than the
792/// destination type; the upper bits of the src will be lost.
793static void CreateCoercedStore(llvm::Value *Src,
794 llvm::Value *DstPtr,
Anders Carlssond2490a92009-12-24 20:40:36 +0000795 bool DstIsVolatile,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000796 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000797 llvm::Type *SrcTy = Src->getType();
798 llvm::Type *DstTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000799 cast<llvm::PointerType>(DstPtr->getType())->getElementType();
Chris Lattner6ae00692010-06-28 22:51:39 +0000800 if (SrcTy == DstTy) {
801 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
802 return;
803 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000804
Micah Villmow25a6a842012-10-08 16:25:52 +0000805 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000806
Chris Lattner2acc6e32011-07-18 04:24:23 +0000807 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000808 DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF);
809 DstTy = cast<llvm::PointerType>(DstPtr->getType())->getElementType();
810 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000811
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000812 // If the source and destination are integer or pointer types, just do an
813 // extension or truncation to the desired type.
814 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
815 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
816 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
817 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
818 return;
819 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000820
Micah Villmow25a6a842012-10-08 16:25:52 +0000821 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000822
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000823 // If store is legal, just bitcast the src pointer.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000824 if (SrcSize <= DstSize) {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000825 llvm::Value *Casted =
826 CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000827 // FIXME: Use better alignment / avoid requiring aligned store.
Eli Friedmanbadea572011-05-17 21:08:01 +0000828 BuildAggStore(CGF, Src, Casted, DstIsVolatile, true);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000829 } else {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000830 // Otherwise do coercion through memory. This is stupid, but
831 // simple.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000832
833 // Generally SrcSize is never greater than DstSize, since this means we are
834 // losing bits. However, this can happen in cases where the structure has
835 // additional padding, for example due to a user specified alignment.
836 //
837 // FIXME: Assert that we aren't truncating non-padding bits when have access
838 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000839 llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy);
840 CGF.Builder.CreateStore(Src, Tmp);
Manman Renf51c61c2012-11-28 22:08:52 +0000841 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
842 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
843 llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000844 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000845 CGF.Builder.CreateMemCpy(DstCasted, Casted,
846 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
847 1, false);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000848 }
849}
850
Daniel Dunbar56273772008-09-17 00:51:38 +0000851/***/
852
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000853bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000854 return FI.getReturnInfo().isIndirect();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000855}
856
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000857bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
858 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
859 switch (BT->getKind()) {
860 default:
861 return false;
862 case BuiltinType::Float:
John McCall64aa4b32013-04-16 22:48:15 +0000863 return getTarget().useObjCFPRetForRealType(TargetInfo::Float);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000864 case BuiltinType::Double:
John McCall64aa4b32013-04-16 22:48:15 +0000865 return getTarget().useObjCFPRetForRealType(TargetInfo::Double);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000866 case BuiltinType::LongDouble:
John McCall64aa4b32013-04-16 22:48:15 +0000867 return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000868 }
869 }
870
871 return false;
872}
873
Anders Carlssoneea64802011-10-31 16:27:11 +0000874bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) {
875 if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
876 if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
877 if (BT->getKind() == BuiltinType::LongDouble)
John McCall64aa4b32013-04-16 22:48:15 +0000878 return getTarget().useObjCFP2RetForComplexLongDouble();
Anders Carlssoneea64802011-10-31 16:27:11 +0000879 }
880 }
881
882 return false;
883}
884
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000885llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
John McCallde5d3c72012-02-17 03:33:10 +0000886 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
887 return GetFunctionType(FI);
John McCallc0bf4622010-02-23 00:48:20 +0000888}
889
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000890llvm::FunctionType *
John McCallde5d3c72012-02-17 03:33:10 +0000891CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
Chris Lattner71305cc2011-07-15 05:16:14 +0000892
893 bool Inserted = FunctionsBeingProcessed.insert(&FI); (void)Inserted;
894 assert(Inserted && "Recursively being processed?");
895
Chris Lattner5f9e2722011-07-23 10:55:15 +0000896 SmallVector<llvm::Type*, 8> argTypes;
Chris Lattner2acc6e32011-07-18 04:24:23 +0000897 llvm::Type *resultType = 0;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000898
John McCall42e06112011-05-15 02:19:42 +0000899 const ABIArgInfo &retAI = FI.getReturnInfo();
900 switch (retAI.getKind()) {
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000901 case ABIArgInfo::Expand:
John McCall42e06112011-05-15 02:19:42 +0000902 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000903
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000904 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000905 case ABIArgInfo::Direct:
John McCall42e06112011-05-15 02:19:42 +0000906 resultType = retAI.getCoerceToType();
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000907 break;
908
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000909 case ABIArgInfo::Indirect: {
John McCall42e06112011-05-15 02:19:42 +0000910 assert(!retAI.getIndirectAlign() && "Align unused on indirect return.");
911 resultType = llvm::Type::getVoidTy(getLLVMContext());
912
913 QualType ret = FI.getReturnType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000914 llvm::Type *ty = ConvertType(ret);
John McCall42e06112011-05-15 02:19:42 +0000915 unsigned addressSpace = Context.getTargetAddressSpace(ret);
916 argTypes.push_back(llvm::PointerType::get(ty, addressSpace));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000917 break;
918 }
919
Daniel Dunbar11434922009-01-26 21:26:08 +0000920 case ABIArgInfo::Ignore:
John McCall42e06112011-05-15 02:19:42 +0000921 resultType = llvm::Type::getVoidTy(getLLVMContext());
Daniel Dunbar11434922009-01-26 21:26:08 +0000922 break;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000923 }
Mike Stump1eb44332009-09-09 15:08:12 +0000924
John McCalle56bb362012-12-07 07:03:17 +0000925 // Add in all of the required arguments.
926 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie;
927 if (FI.isVariadic()) {
928 ie = it + FI.getRequiredArgs().getNumRequiredArgs();
929 } else {
930 ie = FI.arg_end();
931 }
932 for (; it != ie; ++it) {
John McCall42e06112011-05-15 02:19:42 +0000933 const ABIArgInfo &argAI = it->info;
Mike Stump1eb44332009-09-09 15:08:12 +0000934
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +0000935 // Insert a padding type to ensure proper alignment.
936 if (llvm::Type *PaddingType = argAI.getPaddingType())
937 argTypes.push_back(PaddingType);
938
John McCall42e06112011-05-15 02:19:42 +0000939 switch (argAI.getKind()) {
Daniel Dunbar11434922009-01-26 21:26:08 +0000940 case ABIArgInfo::Ignore:
941 break;
942
Chris Lattner800588f2010-07-29 06:26:06 +0000943 case ABIArgInfo::Indirect: {
944 // indirect arguments are always on the stack, which is addr space #0.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000945 llvm::Type *LTy = ConvertTypeForMem(it->type);
John McCall42e06112011-05-15 02:19:42 +0000946 argTypes.push_back(LTy->getPointerTo());
Chris Lattner800588f2010-07-29 06:26:06 +0000947 break;
948 }
949
950 case ABIArgInfo::Extend:
Chris Lattner1ed72672010-07-29 06:44:09 +0000951 case ABIArgInfo::Direct: {
Chris Lattnerce700162010-06-28 23:44:11 +0000952 // If the coerce-to type is a first class aggregate, flatten it. Either
953 // way is semantically identical, but fast-isel and the optimizer
954 // generally likes scalar values better than FCAs.
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000955 llvm::Type *argType = argAI.getCoerceToType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000956 if (llvm::StructType *st = dyn_cast<llvm::StructType>(argType)) {
John McCall42e06112011-05-15 02:19:42 +0000957 for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
958 argTypes.push_back(st->getElementType(i));
Chris Lattnerce700162010-06-28 23:44:11 +0000959 } else {
John McCall42e06112011-05-15 02:19:42 +0000960 argTypes.push_back(argType);
Chris Lattnerce700162010-06-28 23:44:11 +0000961 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000962 break;
Chris Lattner1ed72672010-07-29 06:44:09 +0000963 }
Mike Stump1eb44332009-09-09 15:08:12 +0000964
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000965 case ABIArgInfo::Expand:
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000966 GetExpandedTypes(it->type, argTypes);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000967 break;
968 }
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000969 }
970
Chris Lattner71305cc2011-07-15 05:16:14 +0000971 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
972 assert(Erased && "Not in set?");
973
John McCallde5d3c72012-02-17 03:33:10 +0000974 return llvm::FunctionType::get(resultType, argTypes, FI.isVariadic());
Daniel Dunbar3913f182008-09-09 23:48:28 +0000975}
976
Chris Lattner2acc6e32011-07-18 04:24:23 +0000977llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
John McCall4c40d982010-08-31 07:33:07 +0000978 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlssonecf282b2009-11-24 05:08:52 +0000979 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000980
Chris Lattnerf742eb02011-07-10 00:18:59 +0000981 if (!isFuncTypeConvertible(FPT))
982 return llvm::StructType::get(getLLVMContext());
983
984 const CGFunctionInfo *Info;
985 if (isa<CXXDestructorDecl>(MD))
John McCallde5d3c72012-02-17 03:33:10 +0000986 Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType());
Chris Lattnerf742eb02011-07-10 00:18:59 +0000987 else
John McCallde5d3c72012-02-17 03:33:10 +0000988 Info = &arrangeCXXMethodDeclaration(MD);
989 return GetFunctionType(*Info);
Anders Carlssonecf282b2009-11-24 05:08:52 +0000990}
991
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000992void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
Daniel Dunbar88b53962009-02-02 22:03:45 +0000993 const Decl *TargetDecl,
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000994 AttributeListType &PAL,
Bill Wendling94236e72013-02-22 00:13:35 +0000995 unsigned &CallingConv,
996 bool AttrOnCallSite) {
Bill Wendling0d583392012-10-15 20:36:26 +0000997 llvm::AttrBuilder FuncAttrs;
998 llvm::AttrBuilder RetAttrs;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000999
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001000 CallingConv = FI.getEffectiveCallingConvention();
1001
John McCall04a67a62010-02-05 21:31:56 +00001002 if (FI.isNoReturn())
Bill Wendling72390b32012-12-20 19:27:06 +00001003 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCall04a67a62010-02-05 21:31:56 +00001004
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001005 // FIXME: handle sseregparm someday...
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001006 if (TargetDecl) {
Rafael Espindola67004152011-10-12 19:51:18 +00001007 if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +00001008 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001009 if (TargetDecl->hasAttr<NoThrowAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +00001010 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Richard Smith7586a6e2013-01-30 05:45:05 +00001011 if (TargetDecl->hasAttr<NoReturnAttr>())
1012 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1013
1014 if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
John McCall9c0c1f32010-07-08 06:48:12 +00001015 const FunctionProtoType *FPT = Fn->getType()->getAs<FunctionProtoType>();
Sebastian Redl8026f6d2011-03-13 17:09:40 +00001016 if (FPT && FPT->isNothrow(getContext()))
Bill Wendling72390b32012-12-20 19:27:06 +00001017 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Richard Smith3c5cd152013-03-05 08:30:04 +00001018 // Don't use [[noreturn]] or _Noreturn for a call to a virtual function.
1019 // These attributes are not inherited by overloads.
1020 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
1021 if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual()))
Richard Smith7586a6e2013-01-30 05:45:05 +00001022 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCall9c0c1f32010-07-08 06:48:12 +00001023 }
1024
Eric Christopher041087c2011-08-15 22:38:22 +00001025 // 'const' and 'pure' attribute functions are also nounwind.
1026 if (TargetDecl->hasAttr<ConstAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001027 FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1028 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001029 } else if (TargetDecl->hasAttr<PureAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001030 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1031 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001032 }
Ryan Flynn76168e22009-08-09 20:07:29 +00001033 if (TargetDecl->hasAttr<MallocAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +00001034 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001035 }
1036
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001037 if (CodeGenOpts.OptimizeSize)
Bill Wendling72390b32012-12-20 19:27:06 +00001038 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
Quentin Colombet90467682012-10-26 00:29:48 +00001039 if (CodeGenOpts.OptimizeSize == 2)
Bill Wendling72390b32012-12-20 19:27:06 +00001040 FuncAttrs.addAttribute(llvm::Attribute::MinSize);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001041 if (CodeGenOpts.DisableRedZone)
Bill Wendling72390b32012-12-20 19:27:06 +00001042 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001043 if (CodeGenOpts.NoImplicitFloat)
Bill Wendling72390b32012-12-20 19:27:06 +00001044 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
Devang Patel24095da2009-06-04 23:32:02 +00001045
Bill Wendling93e4bff2013-02-22 20:53:29 +00001046 if (AttrOnCallSite) {
1047 // Attributes that should go on the call site only.
1048 if (!CodeGenOpts.SimplifyLibCalls)
1049 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001050 } else {
1051 // Attributes that should go on the function, but not the call site.
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001052 if (!CodeGenOpts.DisableFPElim) {
Bill Wendling4159f052013-03-13 22:24:33 +00001053 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
1054 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "false");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001055 } else if (CodeGenOpts.OmitLeafFramePointer) {
Bill Wendling4159f052013-03-13 22:24:33 +00001056 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
1057 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "true");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001058 } else {
Bill Wendling4159f052013-03-13 22:24:33 +00001059 FuncAttrs.addAttribute("no-frame-pointer-elim", "true");
1060 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "true");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001061 }
1062
Bill Wendling4159f052013-03-13 22:24:33 +00001063 FuncAttrs.addAttribute("less-precise-fpmad",
1064 CodeGenOpts.LessPreciseFPMAD ? "true" : "false");
1065 FuncAttrs.addAttribute("no-infs-fp-math",
1066 CodeGenOpts.NoInfsFPMath ? "true" : "false");
1067 FuncAttrs.addAttribute("no-nans-fp-math",
1068 CodeGenOpts.NoNaNsFPMath ? "true" : "false");
1069 FuncAttrs.addAttribute("unsafe-fp-math",
1070 CodeGenOpts.UnsafeFPMath ? "true" : "false");
1071 FuncAttrs.addAttribute("use-soft-float",
1072 CodeGenOpts.SoftFloat ? "true" : "false");
Bill Wendling45ccf282013-07-22 20:15:41 +00001073 FuncAttrs.addAttribute("stack-protector-buffer-size",
Bill Wendling8d230b42013-07-12 22:26:07 +00001074 llvm::utostr(CodeGenOpts.SSPBufferSize));
Bill Wendlingcab4a092013-07-25 00:32:41 +00001075
1076 bool NoFramePointerElimNonLeaf;
1077 if (!CodeGenOpts.DisableFPElim) {
1078 NoFramePointerElimNonLeaf = false;
1079 } else if (CodeGenOpts.OmitLeafFramePointer) {
1080 NoFramePointerElimNonLeaf = true;
1081 } else {
1082 NoFramePointerElimNonLeaf = true;
1083 }
1084
1085 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf",
1086 NoFramePointerElimNonLeaf ? "true" : "false");
Bill Wendlingc0dcc2d2013-02-15 21:30:01 +00001087 }
1088
Daniel Dunbara0a99e02009-02-02 23:43:58 +00001089 QualType RetTy = FI.getReturnType();
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001090 unsigned Index = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001091 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +00001092 switch (RetAI.getKind()) {
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001093 case ABIArgInfo::Extend:
Jakob Stoklund Olesen5baefa82013-05-29 03:57:23 +00001094 if (RetTy->hasSignedIntegerRepresentation())
1095 RetAttrs.addAttribute(llvm::Attribute::SExt);
1096 else if (RetTy->hasUnsignedIntegerRepresentation())
1097 RetAttrs.addAttribute(llvm::Attribute::ZExt);
Jakob Stoklund Olesen90f9ec02013-06-05 03:00:09 +00001098 // FALL THROUGH
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001099 case ABIArgInfo::Direct:
Jakob Stoklund Olesen90f9ec02013-06-05 03:00:09 +00001100 if (RetAI.getInReg())
1101 RetAttrs.addAttribute(llvm::Attribute::InReg);
1102 break;
Chris Lattner800588f2010-07-29 06:26:06 +00001103 case ABIArgInfo::Ignore:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001104 break;
1105
Rafael Espindolab48280b2012-07-31 02:44:24 +00001106 case ABIArgInfo::Indirect: {
Bill Wendling0d583392012-10-15 20:36:26 +00001107 llvm::AttrBuilder SRETAttrs;
Bill Wendling72390b32012-12-20 19:27:06 +00001108 SRETAttrs.addAttribute(llvm::Attribute::StructRet);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001109 if (RetAI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001110 SRETAttrs.addAttribute(llvm::Attribute::InReg);
Bill Wendling603571a2012-10-10 07:36:56 +00001111 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001112 AttributeSet::get(getLLVMContext(), Index, SRETAttrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001113
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001114 ++Index;
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001115 // sret disables readnone and readonly
Bill Wendling72390b32012-12-20 19:27:06 +00001116 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1117 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001118 break;
Rafael Espindolab48280b2012-07-31 02:44:24 +00001119 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001120
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001121 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001122 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001123 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001124
Bill Wendling603571a2012-10-10 07:36:56 +00001125 if (RetAttrs.hasAttributes())
1126 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001127 AttributeSet::get(getLLVMContext(),
1128 llvm::AttributeSet::ReturnIndex,
1129 RetAttrs));
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001130
Mike Stump1eb44332009-09-09 15:08:12 +00001131 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
Daniel Dunbar88c2fa92009-02-03 05:31:23 +00001132 ie = FI.arg_end(); it != ie; ++it) {
1133 QualType ParamType = it->type;
1134 const ABIArgInfo &AI = it->info;
Bill Wendling0d583392012-10-15 20:36:26 +00001135 llvm::AttrBuilder Attrs;
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001136
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001137 if (AI.getPaddingType()) {
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001138 if (AI.getPaddingInReg())
1139 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index,
1140 llvm::Attribute::InReg));
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001141 // Increment Index if there is padding.
1142 ++Index;
1143 }
1144
John McCalld8e10d22010-03-27 00:47:27 +00001145 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
1146 // have the corresponding parameter variable. It doesn't make
Daniel Dunbar7f6890e2011-02-10 18:10:07 +00001147 // sense to do it here because parameters are so messed up.
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001148 switch (AI.getKind()) {
Chris Lattner800588f2010-07-29 06:26:06 +00001149 case ABIArgInfo::Extend:
Douglas Gregor575a1c92011-05-20 16:38:50 +00001150 if (ParamType->isSignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001151 Attrs.addAttribute(llvm::Attribute::SExt);
Douglas Gregor575a1c92011-05-20 16:38:50 +00001152 else if (ParamType->isUnsignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001153 Attrs.addAttribute(llvm::Attribute::ZExt);
Chris Lattner800588f2010-07-29 06:26:06 +00001154 // FALL THROUGH
1155 case ABIArgInfo::Direct:
Rafael Espindolab48280b2012-07-31 02:44:24 +00001156 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001157 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001158
Chris Lattner800588f2010-07-29 06:26:06 +00001159 // FIXME: handle sseregparm someday...
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001160
Chris Lattner2acc6e32011-07-18 04:24:23 +00001161 if (llvm::StructType *STy =
Rafael Espindolab48280b2012-07-31 02:44:24 +00001162 dyn_cast<llvm::StructType>(AI.getCoerceToType())) {
1163 unsigned Extra = STy->getNumElements()-1; // 1 will be added below.
Bill Wendling603571a2012-10-10 07:36:56 +00001164 if (Attrs.hasAttributes())
Rafael Espindolab48280b2012-07-31 02:44:24 +00001165 for (unsigned I = 0; I < Extra; ++I)
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001166 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I,
1167 Attrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001168 Index += Extra;
1169 }
Chris Lattner800588f2010-07-29 06:26:06 +00001170 break;
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001171
Daniel Dunbar11e383a2009-02-05 08:00:50 +00001172 case ABIArgInfo::Indirect:
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001173 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001174 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001175
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001176 if (AI.getIndirectByVal())
Bill Wendling72390b32012-12-20 19:27:06 +00001177 Attrs.addAttribute(llvm::Attribute::ByVal);
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001178
Bill Wendling603571a2012-10-10 07:36:56 +00001179 Attrs.addAlignmentAttr(AI.getIndirectAlign());
1180
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001181 // byval disables readnone and readonly.
Bill Wendling72390b32012-12-20 19:27:06 +00001182 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1183 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001184 break;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001185
Daniel Dunbar11434922009-01-26 21:26:08 +00001186 case ABIArgInfo::Ignore:
1187 // Skip increment, no matching LLVM parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001188 continue;
Daniel Dunbar11434922009-01-26 21:26:08 +00001189
Daniel Dunbar56273772008-09-17 00:51:38 +00001190 case ABIArgInfo::Expand: {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001191 SmallVector<llvm::Type*, 8> types;
Mike Stumpf5408fe2009-05-16 07:57:57 +00001192 // FIXME: This is rather inefficient. Do we ever actually need to do
1193 // anything here? The result should be just reconstructed on the other
1194 // side, so extension should be a non-issue.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001195 getTypes().GetExpandedTypes(ParamType, types);
John McCall42e06112011-05-15 02:19:42 +00001196 Index += types.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00001197 continue;
1198 }
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001199 }
Mike Stump1eb44332009-09-09 15:08:12 +00001200
Bill Wendling603571a2012-10-10 07:36:56 +00001201 if (Attrs.hasAttributes())
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001202 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs));
Daniel Dunbar56273772008-09-17 00:51:38 +00001203 ++Index;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001204 }
Bill Wendling603571a2012-10-10 07:36:56 +00001205 if (FuncAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001206 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001207 AttributeSet::get(getLLVMContext(),
1208 llvm::AttributeSet::FunctionIndex,
1209 FuncAttrs));
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001210}
1211
John McCalld26bc762011-03-09 04:27:21 +00001212/// An argument came in as a promoted argument; demote it back to its
1213/// declared type.
1214static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
1215 const VarDecl *var,
1216 llvm::Value *value) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001217 llvm::Type *varType = CGF.ConvertType(var->getType());
John McCalld26bc762011-03-09 04:27:21 +00001218
1219 // This can happen with promotions that actually don't change the
1220 // underlying type, like the enum promotions.
1221 if (value->getType() == varType) return value;
1222
1223 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
1224 && "unexpected promotion type");
1225
1226 if (isa<llvm::IntegerType>(varType))
1227 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
1228
1229 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
1230}
1231
Daniel Dunbar88b53962009-02-02 22:03:45 +00001232void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
1233 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001234 const FunctionArgList &Args) {
John McCall0cfeb632009-07-28 01:00:58 +00001235 // If this is an implicit-return-zero function, go ahead and
1236 // initialize the return value. TODO: it might be nice to have
1237 // a more general mechanism for this that didn't require synthesized
1238 // return statements.
John McCallf5ebf9b2013-05-03 07:33:41 +00001239 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
John McCall0cfeb632009-07-28 01:00:58 +00001240 if (FD->hasImplicitReturnZero()) {
1241 QualType RetTy = FD->getResultType().getUnqualifiedType();
Chris Lattner2acc6e32011-07-18 04:24:23 +00001242 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
Owen Andersonc9c88b42009-07-31 20:28:54 +00001243 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
John McCall0cfeb632009-07-28 01:00:58 +00001244 Builder.CreateStore(Zero, ReturnValue);
1245 }
1246 }
1247
Mike Stumpf5408fe2009-05-16 07:57:57 +00001248 // FIXME: We no longer need the types from FunctionArgList; lift up and
1249 // simplify.
Daniel Dunbar5251afa2009-02-03 06:02:10 +00001250
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001251 // Emit allocs for param decls. Give the LLVM Argument nodes names.
1252 llvm::Function::arg_iterator AI = Fn->arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001253
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001254 // Name the struct return argument.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001255 if (CGM.ReturnTypeUsesSRet(FI)) {
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001256 AI->setName("agg.result");
Bill Wendling89530e42013-01-23 06:15:10 +00001257 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1258 AI->getArgNo() + 1,
1259 llvm::Attribute::NoAlias));
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001260 ++AI;
1261 }
Mike Stump1eb44332009-09-09 15:08:12 +00001262
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00001263 assert(FI.arg_size() == Args.size() &&
1264 "Mismatch between function signature & arguments.");
Devang Patel093ac462011-03-03 20:13:15 +00001265 unsigned ArgNo = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001266 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
Devang Patel093ac462011-03-03 20:13:15 +00001267 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1268 i != e; ++i, ++info_it, ++ArgNo) {
John McCalld26bc762011-03-09 04:27:21 +00001269 const VarDecl *Arg = *i;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001270 QualType Ty = info_it->type;
1271 const ABIArgInfo &ArgI = info_it->info;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001272
John McCalld26bc762011-03-09 04:27:21 +00001273 bool isPromoted =
1274 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
1275
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001276 // Skip the dummy padding argument.
1277 if (ArgI.getPaddingType())
1278 ++AI;
1279
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001280 switch (ArgI.getKind()) {
Daniel Dunbar1f745982009-02-05 09:16:39 +00001281 case ABIArgInfo::Indirect: {
Chris Lattnerce700162010-06-28 23:44:11 +00001282 llvm::Value *V = AI;
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001283
John McCall9d232c82013-03-07 21:37:08 +00001284 if (!hasScalarEvaluationKind(Ty)) {
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001285 // Aggregates and complex variables are accessed by reference. All we
1286 // need to do is realign the value, if requested
1287 if (ArgI.getIndirectRealign()) {
1288 llvm::Value *AlignedTemp = CreateMemTemp(Ty, "coerce");
1289
1290 // Copy from the incoming argument pointer to the temporary with the
1291 // appropriate alignment.
1292 //
1293 // FIXME: We should have a common utility for generating an aggregate
1294 // copy.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001295 llvm::Type *I8PtrTy = Builder.getInt8PtrTy();
Ken Dyckfe710082011-01-19 01:58:38 +00001296 CharUnits Size = getContext().getTypeSizeInChars(Ty);
NAKAMURA Takumic95a8fc2011-03-10 14:02:21 +00001297 llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy);
1298 llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy);
1299 Builder.CreateMemCpy(Dst,
1300 Src,
Ken Dyckfe710082011-01-19 01:58:38 +00001301 llvm::ConstantInt::get(IntPtrTy,
1302 Size.getQuantity()),
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +00001303 ArgI.getIndirectAlign(),
1304 false);
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001305 V = AlignedTemp;
1306 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00001307 } else {
1308 // Load scalar value from indirect argument.
Ken Dyckfe710082011-01-19 01:58:38 +00001309 CharUnits Alignment = getContext().getTypeAlignInChars(Ty);
1310 V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty);
John McCalld26bc762011-03-09 04:27:21 +00001311
1312 if (isPromoted)
1313 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001314 }
Devang Patel093ac462011-03-03 20:13:15 +00001315 EmitParmDecl(*Arg, V, ArgNo);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001316 break;
1317 }
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001318
1319 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001320 case ABIArgInfo::Direct: {
Akira Hatanaka4ba3fd42012-01-09 19:08:06 +00001321
Chris Lattner800588f2010-07-29 06:26:06 +00001322 // If we have the trivial case, handle it with no muss and fuss.
1323 if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00001324 ArgI.getCoerceToType() == ConvertType(Ty) &&
1325 ArgI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001326 assert(AI != Fn->arg_end() && "Argument mismatch!");
1327 llvm::Value *V = AI;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001328
Bill Wendlinga6375562012-10-16 05:23:44 +00001329 if (Arg->getType().isRestrictQualified())
Bill Wendling89530e42013-01-23 06:15:10 +00001330 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1331 AI->getArgNo() + 1,
1332 llvm::Attribute::NoAlias));
John McCalld8e10d22010-03-27 00:47:27 +00001333
Chris Lattnerb13eab92011-07-20 06:29:00 +00001334 // Ensure the argument is the correct type.
1335 if (V->getType() != ArgI.getCoerceToType())
1336 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
1337
John McCalld26bc762011-03-09 04:27:21 +00001338 if (isPromoted)
1339 V = emitArgumentDemotion(*this, Arg, V);
Rafael Espindola8b8a09e2012-11-29 16:09:03 +00001340
1341 // Because of merging of function types from multiple decls it is
1342 // possible for the type of an argument to not match the corresponding
1343 // type in the function type. Since we are codegening the callee
1344 // in here, add a cast to the argument type.
1345 llvm::Type *LTy = ConvertType(Arg->getType());
1346 if (V->getType() != LTy)
1347 V = Builder.CreateBitCast(V, LTy);
1348
Devang Patel093ac462011-03-03 20:13:15 +00001349 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001350 break;
Daniel Dunbar8b979d92009-02-10 00:06:49 +00001351 }
Mike Stump1eb44332009-09-09 15:08:12 +00001352
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001353 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001354
Chris Lattnerdeabde22010-07-28 18:24:28 +00001355 // The alignment we need to use is the max of the requested alignment for
1356 // the argument plus the alignment required by our access code below.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001357 unsigned AlignmentToUse =
Micah Villmow25a6a842012-10-08 16:25:52 +00001358 CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType());
Chris Lattnerdeabde22010-07-28 18:24:28 +00001359 AlignmentToUse = std::max(AlignmentToUse,
1360 (unsigned)getContext().getDeclAlign(Arg).getQuantity());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001361
Chris Lattnerdeabde22010-07-28 18:24:28 +00001362 Alloca->setAlignment(AlignmentToUse);
Chris Lattner121b3fa2010-07-05 20:21:00 +00001363 llvm::Value *V = Alloca;
Chris Lattner117e3f42010-07-30 04:02:24 +00001364 llvm::Value *Ptr = V; // Pointer to store into.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001365
Chris Lattner117e3f42010-07-30 04:02:24 +00001366 // If the value is offset in memory, apply the offset now.
1367 if (unsigned Offs = ArgI.getDirectOffset()) {
1368 Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy());
1369 Ptr = Builder.CreateConstGEP1_32(Ptr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001370 Ptr = Builder.CreateBitCast(Ptr,
Chris Lattner117e3f42010-07-30 04:02:24 +00001371 llvm::PointerType::getUnqual(ArgI.getCoerceToType()));
1372 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001373
Chris Lattner309c59f2010-06-29 00:06:42 +00001374 // If the coerce-to type is a first class aggregate, we flatten it and
1375 // pass the elements. Either way is semantically identical, but fast-isel
1376 // and the optimizer generally likes scalar values better than FCAs.
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001377 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
1378 if (STy && STy->getNumElements() > 1) {
Micah Villmow25a6a842012-10-08 16:25:52 +00001379 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001380 llvm::Type *DstTy =
1381 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Micah Villmow25a6a842012-10-08 16:25:52 +00001382 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001383
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001384 if (SrcSize <= DstSize) {
1385 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
1386
1387 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1388 assert(AI != Fn->arg_end() && "Argument mismatch!");
1389 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1390 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i);
1391 Builder.CreateStore(AI++, EltPtr);
1392 }
1393 } else {
1394 llvm::AllocaInst *TempAlloca =
1395 CreateTempAlloca(ArgI.getCoerceToType(), "coerce");
1396 TempAlloca->setAlignment(AlignmentToUse);
1397 llvm::Value *TempV = TempAlloca;
1398
1399 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1400 assert(AI != Fn->arg_end() && "Argument mismatch!");
1401 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1402 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i);
1403 Builder.CreateStore(AI++, EltPtr);
1404 }
1405
1406 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse);
Chris Lattner309c59f2010-06-29 00:06:42 +00001407 }
1408 } else {
1409 // Simple case, just do a coerced store of the argument into the alloca.
1410 assert(AI != Fn->arg_end() && "Argument mismatch!");
Chris Lattner225e2862010-06-29 00:14:52 +00001411 AI->setName(Arg->getName() + ".coerce");
Chris Lattner117e3f42010-07-30 04:02:24 +00001412 CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this);
Chris Lattner309c59f2010-06-29 00:06:42 +00001413 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001414
1415
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001416 // Match to what EmitParmDecl is expecting for this type.
John McCall9d232c82013-03-07 21:37:08 +00001417 if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001418 V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty);
John McCalld26bc762011-03-09 04:27:21 +00001419 if (isPromoted)
1420 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar8b29a382009-02-04 07:22:24 +00001421 }
Devang Patel093ac462011-03-03 20:13:15 +00001422 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattnerce700162010-06-28 23:44:11 +00001423 continue; // Skip ++AI increment, already done.
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001424 }
Chris Lattner800588f2010-07-29 06:26:06 +00001425
1426 case ABIArgInfo::Expand: {
1427 // If this structure was expanded into multiple arguments then
1428 // we need to create a temporary and reconstruct it from the
1429 // arguments.
Eli Friedman1bb94a42011-11-03 21:39:02 +00001430 llvm::AllocaInst *Alloca = CreateMemTemp(Ty);
Eli Friedman6da2c712011-12-03 04:14:32 +00001431 CharUnits Align = getContext().getDeclAlign(Arg);
1432 Alloca->setAlignment(Align.getQuantity());
1433 LValue LV = MakeAddrLValue(Alloca, Ty, Align);
Eli Friedman1bb94a42011-11-03 21:39:02 +00001434 llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI);
1435 EmitParmDecl(*Arg, Alloca, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001436
1437 // Name the arguments used in expansion and increment AI.
1438 unsigned Index = 0;
1439 for (; AI != End; ++AI, ++Index)
Chris Lattner5f9e2722011-07-23 10:55:15 +00001440 AI->setName(Arg->getName() + "." + Twine(Index));
Chris Lattner800588f2010-07-29 06:26:06 +00001441 continue;
1442 }
1443
1444 case ABIArgInfo::Ignore:
1445 // Initialize the local variable appropriately.
John McCall9d232c82013-03-07 21:37:08 +00001446 if (!hasScalarEvaluationKind(Ty))
Devang Patel093ac462011-03-03 20:13:15 +00001447 EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001448 else
Devang Patel093ac462011-03-03 20:13:15 +00001449 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())),
1450 ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001451
1452 // Skip increment, no matching LLVM parameter.
1453 continue;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001454 }
Daniel Dunbar56273772008-09-17 00:51:38 +00001455
1456 ++AI;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001457 }
1458 assert(AI == Fn->arg_end() && "Argument mismatch!");
1459}
1460
John McCall77fe6cd2012-01-29 07:46:59 +00001461static void eraseUnusedBitCasts(llvm::Instruction *insn) {
1462 while (insn->use_empty()) {
1463 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
1464 if (!bitcast) return;
1465
1466 // This is "safe" because we would have used a ConstantExpr otherwise.
1467 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
1468 bitcast->eraseFromParent();
1469 }
1470}
1471
John McCallf85e1932011-06-15 23:02:42 +00001472/// Try to emit a fused autorelease of a return result.
1473static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF,
1474 llvm::Value *result) {
1475 // We must be immediately followed the cast.
1476 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
1477 if (BB->empty()) return 0;
1478 if (&BB->back() != result) return 0;
1479
Chris Lattner2acc6e32011-07-18 04:24:23 +00001480 llvm::Type *resultType = result->getType();
John McCallf85e1932011-06-15 23:02:42 +00001481
1482 // result is in a BasicBlock and is therefore an Instruction.
1483 llvm::Instruction *generator = cast<llvm::Instruction>(result);
1484
Chris Lattner5f9e2722011-07-23 10:55:15 +00001485 SmallVector<llvm::Instruction*,4> insnsToKill;
John McCallf85e1932011-06-15 23:02:42 +00001486
1487 // Look for:
1488 // %generator = bitcast %type1* %generator2 to %type2*
1489 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
1490 // We would have emitted this as a constant if the operand weren't
1491 // an Instruction.
1492 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
1493
1494 // Require the generator to be immediately followed by the cast.
1495 if (generator->getNextNode() != bitcast)
1496 return 0;
1497
1498 insnsToKill.push_back(bitcast);
1499 }
1500
1501 // Look for:
1502 // %generator = call i8* @objc_retain(i8* %originalResult)
1503 // or
1504 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
1505 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
1506 if (!call) return 0;
1507
1508 bool doRetainAutorelease;
1509
1510 if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) {
1511 doRetainAutorelease = true;
1512 } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints()
1513 .objc_retainAutoreleasedReturnValue) {
1514 doRetainAutorelease = false;
1515
John McCallf9fdcc02012-09-07 23:30:50 +00001516 // If we emitted an assembly marker for this call (and the
1517 // ARCEntrypoints field should have been set if so), go looking
1518 // for that call. If we can't find it, we can't do this
1519 // optimization. But it should always be the immediately previous
1520 // instruction, unless we needed bitcasts around the call.
1521 if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) {
1522 llvm::Instruction *prev = call->getPrevNode();
1523 assert(prev);
1524 if (isa<llvm::BitCastInst>(prev)) {
1525 prev = prev->getPrevNode();
1526 assert(prev);
1527 }
1528 assert(isa<llvm::CallInst>(prev));
1529 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
1530 CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker);
1531 insnsToKill.push_back(prev);
1532 }
John McCallf85e1932011-06-15 23:02:42 +00001533 } else {
1534 return 0;
1535 }
1536
1537 result = call->getArgOperand(0);
1538 insnsToKill.push_back(call);
1539
1540 // Keep killing bitcasts, for sanity. Note that we no longer care
1541 // about precise ordering as long as there's exactly one use.
1542 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
1543 if (!bitcast->hasOneUse()) break;
1544 insnsToKill.push_back(bitcast);
1545 result = bitcast->getOperand(0);
1546 }
1547
1548 // Delete all the unnecessary instructions, from latest to earliest.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001549 for (SmallVectorImpl<llvm::Instruction*>::iterator
John McCallf85e1932011-06-15 23:02:42 +00001550 i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i)
1551 (*i)->eraseFromParent();
1552
1553 // Do the fused retain/autorelease if we were asked to.
1554 if (doRetainAutorelease)
1555 result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
1556
1557 // Cast back to the result type.
1558 return CGF.Builder.CreateBitCast(result, resultType);
1559}
1560
John McCall77fe6cd2012-01-29 07:46:59 +00001561/// If this is a +1 of the value of an immutable 'self', remove it.
1562static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF,
1563 llvm::Value *result) {
1564 // This is only applicable to a method with an immutable 'self'.
John McCallbd9b65a2012-07-31 00:33:55 +00001565 const ObjCMethodDecl *method =
1566 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
John McCall77fe6cd2012-01-29 07:46:59 +00001567 if (!method) return 0;
1568 const VarDecl *self = method->getSelfDecl();
1569 if (!self->getType().isConstQualified()) return 0;
1570
1571 // Look for a retain call.
1572 llvm::CallInst *retainCall =
1573 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
1574 if (!retainCall ||
1575 retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain)
1576 return 0;
1577
1578 // Look for an ordinary load of 'self'.
1579 llvm::Value *retainedValue = retainCall->getArgOperand(0);
1580 llvm::LoadInst *load =
1581 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
1582 if (!load || load->isAtomic() || load->isVolatile() ||
1583 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self))
1584 return 0;
1585
1586 // Okay! Burn it all down. This relies for correctness on the
1587 // assumption that the retain is emitted as part of the return and
1588 // that thereafter everything is used "linearly".
1589 llvm::Type *resultType = result->getType();
1590 eraseUnusedBitCasts(cast<llvm::Instruction>(result));
1591 assert(retainCall->use_empty());
1592 retainCall->eraseFromParent();
1593 eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
1594
1595 return CGF.Builder.CreateBitCast(load, resultType);
1596}
1597
John McCallf85e1932011-06-15 23:02:42 +00001598/// Emit an ARC autorelease of the result of a function.
John McCall77fe6cd2012-01-29 07:46:59 +00001599///
1600/// \return the value to actually return from the function
John McCallf85e1932011-06-15 23:02:42 +00001601static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF,
1602 llvm::Value *result) {
John McCall77fe6cd2012-01-29 07:46:59 +00001603 // If we're returning 'self', kill the initial retain. This is a
1604 // heuristic attempt to "encourage correctness" in the really unfortunate
1605 // case where we have a return of self during a dealloc and we desperately
1606 // need to avoid the possible autorelease.
1607 if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
1608 return self;
1609
John McCallf85e1932011-06-15 23:02:42 +00001610 // At -O0, try to emit a fused retain/autorelease.
1611 if (CGF.shouldUseFusedARCCalls())
1612 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
1613 return fused;
1614
1615 return CGF.EmitARCAutoreleaseReturnValue(result);
1616}
1617
John McCallf48f7962012-01-29 02:35:02 +00001618/// Heuristically search for a dominating store to the return-value slot.
1619static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
1620 // If there are multiple uses of the return-value slot, just check
1621 // for something immediately preceding the IP. Sometimes this can
1622 // happen with how we generate implicit-returns; it can also happen
1623 // with noreturn cleanups.
1624 if (!CGF.ReturnValue->hasOneUse()) {
1625 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1626 if (IP->empty()) return 0;
1627 llvm::StoreInst *store = dyn_cast<llvm::StoreInst>(&IP->back());
1628 if (!store) return 0;
1629 if (store->getPointerOperand() != CGF.ReturnValue) return 0;
1630 assert(!store->isAtomic() && !store->isVolatile()); // see below
1631 return store;
1632 }
1633
1634 llvm::StoreInst *store =
1635 dyn_cast<llvm::StoreInst>(CGF.ReturnValue->use_back());
1636 if (!store) return 0;
1637
1638 // These aren't actually possible for non-coerced returns, and we
1639 // only care about non-coerced returns on this code path.
1640 assert(!store->isAtomic() && !store->isVolatile());
1641
1642 // Now do a first-and-dirty dominance check: just walk up the
1643 // single-predecessors chain from the current insertion point.
1644 llvm::BasicBlock *StoreBB = store->getParent();
1645 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1646 while (IP != StoreBB) {
1647 if (!(IP = IP->getSinglePredecessor()))
1648 return 0;
1649 }
1650
1651 // Okay, the store's basic block dominates the insertion point; we
1652 // can do our thing.
1653 return store;
1654}
1655
Adrian Prantlfa6b0792013-05-02 17:30:20 +00001656void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
1657 bool EmitRetDbgLoc) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001658 // Functions with no result always return void.
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001659 if (ReturnValue == 0) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001660 Builder.CreateRetVoid();
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001661 return;
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001662 }
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001663
Dan Gohman4751a532010-07-20 20:13:52 +00001664 llvm::DebugLoc RetDbgLoc;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001665 llvm::Value *RV = 0;
1666 QualType RetTy = FI.getReturnType();
1667 const ABIArgInfo &RetAI = FI.getReturnInfo();
1668
1669 switch (RetAI.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001670 case ABIArgInfo::Indirect: {
John McCall9d232c82013-03-07 21:37:08 +00001671 switch (getEvaluationKind(RetTy)) {
1672 case TEK_Complex: {
1673 ComplexPairTy RT =
1674 EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy));
1675 EmitStoreOfComplex(RT,
1676 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
1677 /*isInit*/ true);
1678 break;
1679 }
1680 case TEK_Aggregate:
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001681 // Do nothing; aggregrates get evaluated directly into the destination.
John McCall9d232c82013-03-07 21:37:08 +00001682 break;
1683 case TEK_Scalar:
1684 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
1685 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
1686 /*isInit*/ true);
1687 break;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001688 }
1689 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001690 }
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001691
1692 case ABIArgInfo::Extend:
Chris Lattner800588f2010-07-29 06:26:06 +00001693 case ABIArgInfo::Direct:
Chris Lattner117e3f42010-07-30 04:02:24 +00001694 if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
1695 RetAI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001696 // The internal return value temp always will have pointer-to-return-type
1697 // type, just do a load.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001698
John McCallf48f7962012-01-29 02:35:02 +00001699 // If there is a dominating store to ReturnValue, we can elide
1700 // the load, zap the store, and usually zap the alloca.
1701 if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) {
Adrian Prantl7c731f52013-05-30 18:12:23 +00001702 // Reuse the debug location from the store unless there is
1703 // cleanup code to be emitted between the store and return
1704 // instruction.
1705 if (EmitRetDbgLoc && !AutoreleaseResult)
Adrian Prantlfa6b0792013-05-02 17:30:20 +00001706 RetDbgLoc = SI->getDebugLoc();
Chris Lattner800588f2010-07-29 06:26:06 +00001707 // Get the stored value and nuke the now-dead store.
Chris Lattner800588f2010-07-29 06:26:06 +00001708 RV = SI->getValueOperand();
1709 SI->eraseFromParent();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001710
Chris Lattner800588f2010-07-29 06:26:06 +00001711 // If that was the only use of the return value, nuke it as well now.
1712 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) {
1713 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent();
1714 ReturnValue = 0;
1715 }
John McCallf48f7962012-01-29 02:35:02 +00001716
1717 // Otherwise, we have to do a simple load.
1718 } else {
1719 RV = Builder.CreateLoad(ReturnValue);
Chris Lattner35b21b82010-06-27 01:06:27 +00001720 }
Chris Lattner800588f2010-07-29 06:26:06 +00001721 } else {
Chris Lattner117e3f42010-07-30 04:02:24 +00001722 llvm::Value *V = ReturnValue;
1723 // If the value is offset in memory, apply the offset now.
1724 if (unsigned Offs = RetAI.getDirectOffset()) {
1725 V = Builder.CreateBitCast(V, Builder.getInt8PtrTy());
1726 V = Builder.CreateConstGEP1_32(V, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001727 V = Builder.CreateBitCast(V,
Chris Lattner117e3f42010-07-30 04:02:24 +00001728 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
1729 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001730
Chris Lattner117e3f42010-07-30 04:02:24 +00001731 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
Chris Lattner35b21b82010-06-27 01:06:27 +00001732 }
John McCallf85e1932011-06-15 23:02:42 +00001733
1734 // In ARC, end functions that return a retainable type with a call
1735 // to objc_autoreleaseReturnValue.
1736 if (AutoreleaseResult) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001737 assert(getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001738 !FI.isReturnsRetained() &&
1739 RetTy->isObjCRetainableType());
1740 RV = emitAutoreleaseOfResult(*this, RV);
1741 }
1742
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001743 break;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001744
Chris Lattner800588f2010-07-29 06:26:06 +00001745 case ABIArgInfo::Ignore:
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001746 break;
1747
1748 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001749 llvm_unreachable("Invalid ABI kind for return argument");
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001750 }
1751
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001752 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid();
Devang Pateld3f265d2010-07-21 18:08:50 +00001753 if (!RetDbgLoc.isUnknown())
1754 Ret->setDebugLoc(RetDbgLoc);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001755}
1756
John McCall413ebdb2011-03-11 20:59:21 +00001757void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
1758 const VarDecl *param) {
John McCall27360712010-05-26 22:34:26 +00001759 // StartFunction converted the ABI-lowered parameter(s) into a
1760 // local alloca. We need to turn that into an r-value suitable
1761 // for EmitCall.
John McCall413ebdb2011-03-11 20:59:21 +00001762 llvm::Value *local = GetAddrOfLocalVar(param);
John McCall27360712010-05-26 22:34:26 +00001763
John McCall413ebdb2011-03-11 20:59:21 +00001764 QualType type = param->getType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001765
John McCall27360712010-05-26 22:34:26 +00001766 // For the most part, we just need to load the alloca, except:
1767 // 1) aggregate r-values are actually pointers to temporaries, and
John McCall9d232c82013-03-07 21:37:08 +00001768 // 2) references to non-scalars are pointers directly to the aggregate.
1769 // I don't know why references to scalars are different here.
John McCall413ebdb2011-03-11 20:59:21 +00001770 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
John McCall9d232c82013-03-07 21:37:08 +00001771 if (!hasScalarEvaluationKind(ref->getPointeeType()))
John McCall413ebdb2011-03-11 20:59:21 +00001772 return args.add(RValue::getAggregate(local), type);
John McCall27360712010-05-26 22:34:26 +00001773
1774 // Locals which are references to scalars are represented
1775 // with allocas holding the pointer.
John McCall413ebdb2011-03-11 20:59:21 +00001776 return args.add(RValue::get(Builder.CreateLoad(local)), type);
John McCall27360712010-05-26 22:34:26 +00001777 }
1778
John McCall9d232c82013-03-07 21:37:08 +00001779 args.add(convertTempToRValue(local, type), type);
John McCall27360712010-05-26 22:34:26 +00001780}
1781
John McCallf85e1932011-06-15 23:02:42 +00001782static bool isProvablyNull(llvm::Value *addr) {
1783 return isa<llvm::ConstantPointerNull>(addr);
1784}
1785
1786static bool isProvablyNonNull(llvm::Value *addr) {
1787 return isa<llvm::AllocaInst>(addr);
1788}
1789
1790/// Emit the actual writing-back of a writeback.
1791static void emitWriteback(CodeGenFunction &CGF,
1792 const CallArgList::Writeback &writeback) {
John McCallb6a60792013-03-23 02:35:54 +00001793 const LValue &srcLV = writeback.Source;
1794 llvm::Value *srcAddr = srcLV.getAddress();
John McCallf85e1932011-06-15 23:02:42 +00001795 assert(!isProvablyNull(srcAddr) &&
1796 "shouldn't have writeback for provably null argument");
1797
1798 llvm::BasicBlock *contBB = 0;
1799
1800 // If the argument wasn't provably non-null, we need to null check
1801 // before doing the store.
1802 bool provablyNonNull = isProvablyNonNull(srcAddr);
1803 if (!provablyNonNull) {
1804 llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
1805 contBB = CGF.createBasicBlock("icr.done");
1806
1807 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1808 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
1809 CGF.EmitBlock(writebackBB);
1810 }
1811
1812 // Load the value to writeback.
1813 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
1814
1815 // Cast it back, in case we're writing an id to a Foo* or something.
1816 value = CGF.Builder.CreateBitCast(value,
1817 cast<llvm::PointerType>(srcAddr->getType())->getElementType(),
1818 "icr.writeback-cast");
1819
1820 // Perform the writeback.
John McCallb6a60792013-03-23 02:35:54 +00001821
1822 // If we have a "to use" value, it's something we need to emit a use
1823 // of. This has to be carefully threaded in: if it's done after the
1824 // release it's potentially undefined behavior (and the optimizer
1825 // will ignore it), and if it happens before the retain then the
1826 // optimizer could move the release there.
1827 if (writeback.ToUse) {
1828 assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong);
1829
1830 // Retain the new value. No need to block-copy here: the block's
1831 // being passed up the stack.
1832 value = CGF.EmitARCRetainNonBlock(value);
1833
1834 // Emit the intrinsic use here.
1835 CGF.EmitARCIntrinsicUse(writeback.ToUse);
1836
1837 // Load the old value (primitively).
1838 llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV);
1839
1840 // Put the new value in place (primitively).
1841 CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
1842
1843 // Release the old value.
1844 CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
1845
1846 // Otherwise, we can just do a normal lvalue store.
1847 } else {
1848 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
1849 }
John McCallf85e1932011-06-15 23:02:42 +00001850
1851 // Jump to the continuation block.
1852 if (!provablyNonNull)
1853 CGF.EmitBlock(contBB);
1854}
1855
1856static void emitWritebacks(CodeGenFunction &CGF,
1857 const CallArgList &args) {
1858 for (CallArgList::writeback_iterator
1859 i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i)
1860 emitWriteback(CGF, *i);
1861}
1862
Reid Kleckner9b601952013-06-21 12:45:15 +00001863static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF,
1864 const CallArgList &CallArgs) {
1865 assert(CGF.getTarget().getCXXABI().isArgumentDestroyedByCallee());
1866 ArrayRef<CallArgList::CallArgCleanup> Cleanups =
1867 CallArgs.getCleanupsToDeactivate();
1868 // Iterate in reverse to increase the likelihood of popping the cleanup.
1869 for (ArrayRef<CallArgList::CallArgCleanup>::reverse_iterator
1870 I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) {
1871 CGF.DeactivateCleanupBlock(I->Cleanup, I->IsActiveIP);
1872 I->IsActiveIP->eraseFromParent();
1873 }
1874}
1875
John McCallb6a60792013-03-23 02:35:54 +00001876static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
1877 if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens()))
1878 if (uop->getOpcode() == UO_AddrOf)
1879 return uop->getSubExpr();
1880 return 0;
1881}
1882
John McCallf85e1932011-06-15 23:02:42 +00001883/// Emit an argument that's being passed call-by-writeback. That is,
1884/// we are passing the address of
1885static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
1886 const ObjCIndirectCopyRestoreExpr *CRE) {
John McCallb6a60792013-03-23 02:35:54 +00001887 LValue srcLV;
1888
1889 // Make an optimistic effort to emit the address as an l-value.
1890 // This can fail if the the argument expression is more complicated.
1891 if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
1892 srcLV = CGF.EmitLValue(lvExpr);
1893
1894 // Otherwise, just emit it as a scalar.
1895 } else {
1896 llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr());
1897
1898 QualType srcAddrType =
1899 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
1900 srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType);
1901 }
1902 llvm::Value *srcAddr = srcLV.getAddress();
John McCallf85e1932011-06-15 23:02:42 +00001903
1904 // The dest and src types don't necessarily match in LLVM terms
1905 // because of the crazy ObjC compatibility rules.
1906
Chris Lattner2acc6e32011-07-18 04:24:23 +00001907 llvm::PointerType *destType =
John McCallf85e1932011-06-15 23:02:42 +00001908 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
1909
1910 // If the address is a constant null, just pass the appropriate null.
1911 if (isProvablyNull(srcAddr)) {
1912 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
1913 CRE->getType());
1914 return;
1915 }
1916
John McCallf85e1932011-06-15 23:02:42 +00001917 // Create the temporary.
1918 llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(),
1919 "icr.temp");
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001920 // Loading an l-value can introduce a cleanup if the l-value is __weak,
1921 // and that cleanup will be conditional if we can't prove that the l-value
1922 // isn't null, so we need to register a dominating point so that the cleanups
1923 // system will make valid IR.
1924 CodeGenFunction::ConditionalEvaluation condEval(CGF);
1925
John McCallf85e1932011-06-15 23:02:42 +00001926 // Zero-initialize it if we're not doing a copy-initialization.
1927 bool shouldCopy = CRE->shouldCopy();
1928 if (!shouldCopy) {
1929 llvm::Value *null =
1930 llvm::ConstantPointerNull::get(
1931 cast<llvm::PointerType>(destType->getElementType()));
1932 CGF.Builder.CreateStore(null, temp);
1933 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001934
John McCallf85e1932011-06-15 23:02:42 +00001935 llvm::BasicBlock *contBB = 0;
John McCallb6a60792013-03-23 02:35:54 +00001936 llvm::BasicBlock *originBB = 0;
John McCallf85e1932011-06-15 23:02:42 +00001937
1938 // If the address is *not* known to be non-null, we need to switch.
1939 llvm::Value *finalArgument;
1940
1941 bool provablyNonNull = isProvablyNonNull(srcAddr);
1942 if (provablyNonNull) {
1943 finalArgument = temp;
1944 } else {
1945 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1946
1947 finalArgument = CGF.Builder.CreateSelect(isNull,
1948 llvm::ConstantPointerNull::get(destType),
1949 temp, "icr.argument");
1950
1951 // If we need to copy, then the load has to be conditional, which
1952 // means we need control flow.
1953 if (shouldCopy) {
John McCallb6a60792013-03-23 02:35:54 +00001954 originBB = CGF.Builder.GetInsertBlock();
John McCallf85e1932011-06-15 23:02:42 +00001955 contBB = CGF.createBasicBlock("icr.cont");
1956 llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy");
1957 CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
1958 CGF.EmitBlock(copyBB);
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001959 condEval.begin(CGF);
John McCallf85e1932011-06-15 23:02:42 +00001960 }
1961 }
1962
John McCallb6a60792013-03-23 02:35:54 +00001963 llvm::Value *valueToUse = 0;
1964
John McCallf85e1932011-06-15 23:02:42 +00001965 // Perform a copy if necessary.
1966 if (shouldCopy) {
John McCall545d9962011-06-25 02:11:03 +00001967 RValue srcRV = CGF.EmitLoadOfLValue(srcLV);
John McCallf85e1932011-06-15 23:02:42 +00001968 assert(srcRV.isScalar());
1969
1970 llvm::Value *src = srcRV.getScalarVal();
1971 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
1972 "icr.cast");
1973
1974 // Use an ordinary store, not a store-to-lvalue.
1975 CGF.Builder.CreateStore(src, temp);
John McCallb6a60792013-03-23 02:35:54 +00001976
1977 // If optimization is enabled, and the value was held in a
1978 // __strong variable, we need to tell the optimizer that this
1979 // value has to stay alive until we're doing the store back.
1980 // This is because the temporary is effectively unretained,
1981 // and so otherwise we can violate the high-level semantics.
1982 if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 &&
1983 srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) {
1984 valueToUse = src;
1985 }
John McCallf85e1932011-06-15 23:02:42 +00001986 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001987
John McCallf85e1932011-06-15 23:02:42 +00001988 // Finish the control flow if we needed it.
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001989 if (shouldCopy && !provablyNonNull) {
John McCallb6a60792013-03-23 02:35:54 +00001990 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
John McCallf85e1932011-06-15 23:02:42 +00001991 CGF.EmitBlock(contBB);
John McCallb6a60792013-03-23 02:35:54 +00001992
1993 // Make a phi for the value to intrinsically use.
1994 if (valueToUse) {
1995 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
1996 "icr.to-use");
1997 phiToUse->addIncoming(valueToUse, copyBB);
1998 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
1999 originBB);
2000 valueToUse = phiToUse;
2001 }
2002
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00002003 condEval.end(CGF);
2004 }
John McCallf85e1932011-06-15 23:02:42 +00002005
John McCallb6a60792013-03-23 02:35:54 +00002006 args.addWriteback(srcLV, temp, valueToUse);
John McCallf85e1932011-06-15 23:02:42 +00002007 args.add(RValue::get(finalArgument), CRE->getType());
2008}
2009
John McCall413ebdb2011-03-11 20:59:21 +00002010void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
2011 QualType type) {
John McCallf85e1932011-06-15 23:02:42 +00002012 if (const ObjCIndirectCopyRestoreExpr *CRE
2013 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
Richard Smith7edf9e32012-11-01 22:30:59 +00002014 assert(getLangOpts().ObjCAutoRefCount);
John McCallf85e1932011-06-15 23:02:42 +00002015 assert(getContext().hasSameType(E->getType(), type));
2016 return emitWritebackArg(*this, args, CRE);
2017 }
2018
John McCall8affed52011-08-26 18:42:59 +00002019 assert(type->isReferenceType() == E->isGLValue() &&
2020 "reference binding to unmaterialized r-value!");
2021
John McCallcec52f02011-08-26 21:08:13 +00002022 if (E->isGLValue()) {
2023 assert(E->getObjectKind() == OK_Ordinary);
Richard Smithd4ec5622013-06-12 23:38:09 +00002024 return args.add(EmitReferenceBindingToExpr(E), type);
John McCallcec52f02011-08-26 21:08:13 +00002025 }
Mike Stump1eb44332009-09-09 15:08:12 +00002026
Reid Kleckner9b601952013-06-21 12:45:15 +00002027 bool HasAggregateEvalKind = hasAggregateEvaluationKind(type);
2028
2029 // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee.
2030 // However, we still have to push an EH-only cleanup in case we unwind before
2031 // we make it to the call.
2032 if (HasAggregateEvalKind &&
2033 CGM.getTarget().getCXXABI().isArgumentDestroyedByCallee()) {
2034 const CXXRecordDecl *RD = type->getAsCXXRecordDecl();
2035 if (RD && RD->hasNonTrivialDestructor()) {
2036 AggValueSlot Slot = CreateAggTemp(type, "agg.arg.tmp");
2037 Slot.setExternallyDestructed();
2038 EmitAggExpr(E, Slot);
2039 RValue RV = Slot.asRValue();
2040 args.add(RV, type);
2041
2042 pushDestroy(EHCleanup, RV.getAggregateAddr(), type, destroyCXXObject,
2043 /*useEHCleanupForArray*/ true);
2044 // This unreachable is a temporary marker which will be removed later.
2045 llvm::Instruction *IsActive = Builder.CreateUnreachable();
2046 args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive);
2047 return;
2048 }
2049 }
2050
2051 if (HasAggregateEvalKind && isa<ImplicitCastExpr>(E) &&
Eli Friedman55d48482011-05-26 00:10:27 +00002052 cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
2053 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
2054 assert(L.isSimple());
Eli Friedmand39083d2013-06-11 01:08:22 +00002055 if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) {
2056 args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true);
2057 } else {
2058 // We can't represent a misaligned lvalue in the CallArgList, so copy
2059 // to an aligned temporary now.
2060 llvm::Value *tmp = CreateMemTemp(type);
2061 EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile(),
2062 L.getAlignment());
2063 args.add(RValue::getAggregate(tmp), type);
2064 }
Eli Friedman55d48482011-05-26 00:10:27 +00002065 return;
2066 }
2067
John McCall413ebdb2011-03-11 20:59:21 +00002068 args.add(EmitAnyExprToTemp(E), type);
Anders Carlsson0139bb92009-04-08 20:47:54 +00002069}
2070
Dan Gohmanb49bd272012-02-16 00:57:37 +00002071// In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2072// optimizer it can aggressively ignore unwind edges.
2073void
2074CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
2075 if (CGM.getCodeGenOpts().OptimizationLevel != 0 &&
2076 !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
2077 Inst->setMetadata("clang.arc.no_objc_arc_exceptions",
2078 CGM.getNoObjCARCExceptionsMetadata());
2079}
2080
John McCallbd7370a2013-02-28 19:01:20 +00002081/// Emits a call to the given no-arguments nounwind runtime function.
2082llvm::CallInst *
2083CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
2084 const llvm::Twine &name) {
2085 return EmitNounwindRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2086}
2087
2088/// Emits a call to the given nounwind runtime function.
2089llvm::CallInst *
2090CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
2091 ArrayRef<llvm::Value*> args,
2092 const llvm::Twine &name) {
2093 llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
2094 call->setDoesNotThrow();
2095 return call;
2096}
2097
2098/// Emits a simple call (never an invoke) to the given no-arguments
2099/// runtime function.
2100llvm::CallInst *
2101CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
2102 const llvm::Twine &name) {
2103 return EmitRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2104}
2105
2106/// Emits a simple call (never an invoke) to the given runtime
2107/// function.
2108llvm::CallInst *
2109CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
2110 ArrayRef<llvm::Value*> args,
2111 const llvm::Twine &name) {
2112 llvm::CallInst *call = Builder.CreateCall(callee, args, name);
2113 call->setCallingConv(getRuntimeCC());
2114 return call;
2115}
2116
2117/// Emits a call or invoke to the given noreturn runtime function.
2118void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee,
2119 ArrayRef<llvm::Value*> args) {
2120 if (getInvokeDest()) {
2121 llvm::InvokeInst *invoke =
2122 Builder.CreateInvoke(callee,
2123 getUnreachableBlock(),
2124 getInvokeDest(),
2125 args);
2126 invoke->setDoesNotReturn();
2127 invoke->setCallingConv(getRuntimeCC());
2128 } else {
2129 llvm::CallInst *call = Builder.CreateCall(callee, args);
2130 call->setDoesNotReturn();
2131 call->setCallingConv(getRuntimeCC());
2132 Builder.CreateUnreachable();
2133 }
2134}
2135
2136/// Emits a call or invoke instruction to the given nullary runtime
2137/// function.
2138llvm::CallSite
2139CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
2140 const Twine &name) {
2141 return EmitRuntimeCallOrInvoke(callee, ArrayRef<llvm::Value*>(), name);
2142}
2143
2144/// Emits a call or invoke instruction to the given runtime function.
2145llvm::CallSite
2146CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
2147 ArrayRef<llvm::Value*> args,
2148 const Twine &name) {
2149 llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name);
2150 callSite.setCallingConv(getRuntimeCC());
2151 return callSite;
2152}
2153
2154llvm::CallSite
2155CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
2156 const Twine &Name) {
2157 return EmitCallOrInvoke(Callee, ArrayRef<llvm::Value *>(), Name);
2158}
2159
John McCallf1549f62010-07-06 01:34:17 +00002160/// Emits a call or invoke instruction to the given function, depending
2161/// on the current state of the EH stack.
2162llvm::CallSite
2163CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00002164 ArrayRef<llvm::Value *> Args,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002165 const Twine &Name) {
John McCallf1549f62010-07-06 01:34:17 +00002166 llvm::BasicBlock *InvokeDest = getInvokeDest();
John McCallf1549f62010-07-06 01:34:17 +00002167
Dan Gohmanb49bd272012-02-16 00:57:37 +00002168 llvm::Instruction *Inst;
2169 if (!InvokeDest)
2170 Inst = Builder.CreateCall(Callee, Args, Name);
2171 else {
2172 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
2173 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name);
2174 EmitBlock(ContBB);
2175 }
2176
2177 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2178 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00002179 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00002180 AddObjCARCExceptionMetadata(Inst);
2181
2182 return Inst;
John McCallf1549f62010-07-06 01:34:17 +00002183}
2184
Chris Lattner70855442011-07-12 04:46:18 +00002185static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo,
2186 llvm::FunctionType *FTy) {
2187 if (ArgNo < FTy->getNumParams())
2188 assert(Elt->getType() == FTy->getParamType(ArgNo));
2189 else
2190 assert(FTy->isVarArg());
2191 ++ArgNo;
2192}
2193
Chris Lattner811bf362011-07-12 06:29:11 +00002194void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
Craig Topper6b9240e2013-07-05 19:34:19 +00002195 SmallVectorImpl<llvm::Value *> &Args,
Chris Lattner811bf362011-07-12 06:29:11 +00002196 llvm::FunctionType *IRFuncTy) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002197 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
2198 unsigned NumElts = AT->getSize().getZExtValue();
2199 QualType EltTy = AT->getElementType();
2200 llvm::Value *Addr = RV.getAggregateAddr();
2201 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
2202 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt);
John McCall9d232c82013-03-07 21:37:08 +00002203 RValue EltRV = convertTempToRValue(EltAddr, EltTy);
Bob Wilson194f06a2011-08-03 05:58:22 +00002204 ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy);
Chris Lattner811bf362011-07-12 06:29:11 +00002205 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002206 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002207 RecordDecl *RD = RT->getDecl();
2208 assert(RV.isAggregate() && "Unexpected rvalue during struct expansion");
Eli Friedman377ecc72012-04-16 03:54:45 +00002209 LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002210
2211 if (RD->isUnion()) {
2212 const FieldDecl *LargestFD = 0;
2213 CharUnits UnionSize = CharUnits::Zero();
2214
2215 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2216 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002217 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002218 assert(!FD->isBitField() &&
2219 "Cannot expand structure with bit-field members.");
2220 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
2221 if (UnionSize < FieldSize) {
2222 UnionSize = FieldSize;
2223 LargestFD = FD;
2224 }
2225 }
2226 if (LargestFD) {
Eli Friedman377ecc72012-04-16 03:54:45 +00002227 RValue FldRV = EmitRValueForField(LV, LargestFD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002228 ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy);
2229 }
2230 } else {
2231 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2232 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002233 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002234
Eli Friedman377ecc72012-04-16 03:54:45 +00002235 RValue FldRV = EmitRValueForField(LV, FD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002236 ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy);
2237 }
Bob Wilson194f06a2011-08-03 05:58:22 +00002238 }
Eli Friedmanca3d3fc2011-11-15 02:46:03 +00002239 } else if (Ty->isAnyComplexType()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002240 ComplexPairTy CV = RV.getComplexVal();
2241 Args.push_back(CV.first);
2242 Args.push_back(CV.second);
2243 } else {
Chris Lattner811bf362011-07-12 06:29:11 +00002244 assert(RV.isScalar() &&
2245 "Unexpected non-scalar rvalue during struct expansion.");
2246
2247 // Insert a bitcast as needed.
2248 llvm::Value *V = RV.getScalarVal();
2249 if (Args.size() < IRFuncTy->getNumParams() &&
2250 V->getType() != IRFuncTy->getParamType(Args.size()))
2251 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size()));
2252
2253 Args.push_back(V);
2254 }
2255}
2256
2257
Daniel Dunbar88b53962009-02-02 22:03:45 +00002258RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
Mike Stump1eb44332009-09-09 15:08:12 +00002259 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00002260 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00002261 const CallArgList &CallArgs,
David Chisnalldd5c98f2010-05-01 11:15:56 +00002262 const Decl *TargetDecl,
David Chisnall4b02afc2010-05-02 13:41:58 +00002263 llvm::Instruction **callOrInvoke) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00002264 // FIXME: We no longer need the types from CallArgs; lift up and simplify.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002265 SmallVector<llvm::Value*, 16> Args;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002266
2267 // Handle struct-return functions by passing a pointer to the
2268 // location that we would like to return into.
Daniel Dunbarbb36d332009-02-02 21:43:58 +00002269 QualType RetTy = CallInfo.getReturnType();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002270 const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00002271
Chris Lattner70855442011-07-12 04:46:18 +00002272 // IRArgNo - Keep track of the argument number in the callee we're looking at.
2273 unsigned IRArgNo = 0;
2274 llvm::FunctionType *IRFuncTy =
2275 cast<llvm::FunctionType>(
2276 cast<llvm::PointerType>(Callee->getType())->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +00002277
Chris Lattner5db7ae52009-06-13 00:26:38 +00002278 // If the call returns a temporary with struct return, create a temporary
Anders Carlssond2490a92009-12-24 20:40:36 +00002279 // alloca to hold the result, unless one is given to us.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002280 if (CGM.ReturnTypeUsesSRet(CallInfo)) {
Anders Carlssond2490a92009-12-24 20:40:36 +00002281 llvm::Value *Value = ReturnValue.getValue();
2282 if (!Value)
Daniel Dunbar195337d2010-02-09 02:48:28 +00002283 Value = CreateMemTemp(RetTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002284 Args.push_back(Value);
Chris Lattner70855442011-07-12 04:46:18 +00002285 checkArgMatches(Value, IRArgNo, IRFuncTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002286 }
Mike Stump1eb44332009-09-09 15:08:12 +00002287
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00002288 assert(CallInfo.arg_size() == CallArgs.size() &&
2289 "Mismatch between function signature & arguments.");
Daniel Dunbarb225be42009-02-03 05:59:18 +00002290 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00002291 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002292 I != E; ++I, ++info_it) {
2293 const ABIArgInfo &ArgInfo = info_it->info;
Eli Friedmanc6d07822011-05-02 18:05:27 +00002294 RValue RV = I->RV;
Daniel Dunbar56273772008-09-17 00:51:38 +00002295
John McCall9d232c82013-03-07 21:37:08 +00002296 CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty);
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00002297
2298 // Insert a padding argument to ensure proper alignment.
2299 if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) {
2300 Args.push_back(llvm::UndefValue::get(PaddingType));
2301 ++IRArgNo;
2302 }
2303
Daniel Dunbar56273772008-09-17 00:51:38 +00002304 switch (ArgInfo.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002305 case ABIArgInfo::Indirect: {
Daniel Dunbar1f745982009-02-05 09:16:39 +00002306 if (RV.isScalar() || RV.isComplex()) {
2307 // Make a temporary alloca to pass the argument.
Eli Friedman70cbd2a2011-06-15 18:26:32 +00002308 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2309 if (ArgInfo.getIndirectAlign() > AI->getAlignment())
2310 AI->setAlignment(ArgInfo.getIndirectAlign());
2311 Args.push_back(AI);
John McCall9d232c82013-03-07 21:37:08 +00002312
2313 LValue argLV =
2314 MakeAddrLValue(Args.back(), I->Ty, TypeAlign);
Chris Lattner70855442011-07-12 04:46:18 +00002315
Daniel Dunbar1f745982009-02-05 09:16:39 +00002316 if (RV.isScalar())
John McCall9d232c82013-03-07 21:37:08 +00002317 EmitStoreOfScalar(RV.getScalarVal(), argLV, /*init*/ true);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002318 else
John McCall9d232c82013-03-07 21:37:08 +00002319 EmitStoreOfComplex(RV.getComplexVal(), argLV, /*init*/ true);
Chris Lattner70855442011-07-12 04:46:18 +00002320
2321 // Validate argument match.
2322 checkArgMatches(AI, IRArgNo, IRFuncTy);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002323 } else {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002324 // We want to avoid creating an unnecessary temporary+copy here;
Guy Benyeid436c992013-03-10 12:59:00 +00002325 // however, we need one in three cases:
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002326 // 1. If the argument is not byval, and we are required to copy the
2327 // source. (This case doesn't occur on any common architecture.)
2328 // 2. If the argument is byval, RV is not sufficiently aligned, and
2329 // we cannot force it to be sufficiently aligned.
Guy Benyeid436c992013-03-10 12:59:00 +00002330 // 3. If the argument is byval, but RV is located in an address space
2331 // different than that of the argument (0).
Eli Friedman97cb5a42011-06-15 22:09:18 +00002332 llvm::Value *Addr = RV.getAggregateAddr();
2333 unsigned Align = ArgInfo.getIndirectAlign();
Micah Villmow25a6a842012-10-08 16:25:52 +00002334 const llvm::DataLayout *TD = &CGM.getDataLayout();
Guy Benyeid436c992013-03-10 12:59:00 +00002335 const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace();
2336 const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ?
2337 IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0);
Eli Friedman97cb5a42011-06-15 22:09:18 +00002338 if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) ||
John McCall9d232c82013-03-07 21:37:08 +00002339 (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align &&
Guy Benyeid436c992013-03-10 12:59:00 +00002340 llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) ||
2341 (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002342 // Create an aligned temporary, and copy to it.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002343 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2344 if (Align > AI->getAlignment())
2345 AI->setAlignment(Align);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002346 Args.push_back(AI);
Chad Rosier649b4a12012-03-29 17:37:10 +00002347 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified());
Chris Lattner70855442011-07-12 04:46:18 +00002348
2349 // Validate argument match.
2350 checkArgMatches(AI, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002351 } else {
2352 // Skip the extra memcpy call.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002353 Args.push_back(Addr);
Chris Lattner70855442011-07-12 04:46:18 +00002354
2355 // Validate argument match.
2356 checkArgMatches(Addr, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002357 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002358 }
2359 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002360 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002361
Daniel Dunbar11434922009-01-26 21:26:08 +00002362 case ABIArgInfo::Ignore:
2363 break;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002364
Chris Lattner800588f2010-07-29 06:26:06 +00002365 case ABIArgInfo::Extend:
2366 case ABIArgInfo::Direct: {
2367 if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00002368 ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
2369 ArgInfo.getDirectOffset() == 0) {
Chris Lattner70855442011-07-12 04:46:18 +00002370 llvm::Value *V;
Chris Lattner800588f2010-07-29 06:26:06 +00002371 if (RV.isScalar())
Chris Lattner70855442011-07-12 04:46:18 +00002372 V = RV.getScalarVal();
Chris Lattner800588f2010-07-29 06:26:06 +00002373 else
Chris Lattner70855442011-07-12 04:46:18 +00002374 V = Builder.CreateLoad(RV.getAggregateAddr());
2375
Chris Lattner21ca1fd2011-07-12 04:53:39 +00002376 // If the argument doesn't match, perform a bitcast to coerce it. This
2377 // can happen due to trivial type mismatches.
2378 if (IRArgNo < IRFuncTy->getNumParams() &&
2379 V->getType() != IRFuncTy->getParamType(IRArgNo))
2380 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo));
Chris Lattner70855442011-07-12 04:46:18 +00002381 Args.push_back(V);
2382
Chris Lattner70855442011-07-12 04:46:18 +00002383 checkArgMatches(V, IRArgNo, IRFuncTy);
Chris Lattner800588f2010-07-29 06:26:06 +00002384 break;
2385 }
Daniel Dunbar11434922009-01-26 21:26:08 +00002386
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002387 // FIXME: Avoid the conversion through memory if possible.
2388 llvm::Value *SrcPtr;
John McCall9d232c82013-03-07 21:37:08 +00002389 if (RV.isScalar() || RV.isComplex()) {
Eli Friedmanc6d07822011-05-02 18:05:27 +00002390 SrcPtr = CreateMemTemp(I->Ty, "coerce");
John McCall9d232c82013-03-07 21:37:08 +00002391 LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign);
2392 if (RV.isScalar()) {
2393 EmitStoreOfScalar(RV.getScalarVal(), SrcLV, /*init*/ true);
2394 } else {
2395 EmitStoreOfComplex(RV.getComplexVal(), SrcLV, /*init*/ true);
2396 }
Mike Stump1eb44332009-09-09 15:08:12 +00002397 } else
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002398 SrcPtr = RV.getAggregateAddr();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002399
Chris Lattner117e3f42010-07-30 04:02:24 +00002400 // If the value is offset in memory, apply the offset now.
2401 if (unsigned Offs = ArgInfo.getDirectOffset()) {
2402 SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy());
2403 SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002404 SrcPtr = Builder.CreateBitCast(SrcPtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002405 llvm::PointerType::getUnqual(ArgInfo.getCoerceToType()));
2406
2407 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002408
Chris Lattnerce700162010-06-28 23:44:11 +00002409 // If the coerce-to type is a first class aggregate, we flatten it and
2410 // pass the elements. Either way is semantically identical, but fast-isel
2411 // and the optimizer generally likes scalar values better than FCAs.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002412 if (llvm::StructType *STy =
Chris Lattner309c59f2010-06-29 00:06:42 +00002413 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType())) {
Chandler Carruthf82232c2012-10-10 11:29:08 +00002414 llvm::Type *SrcTy =
2415 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
2416 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
2417 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
2418
2419 // If the source type is smaller than the destination type of the
2420 // coerce-to logic, copy the source value into a temp alloca the size
2421 // of the destination type to allow loading all of it. The bits past
2422 // the source value are left undef.
2423 if (SrcSize < DstSize) {
2424 llvm::AllocaInst *TempAlloca
2425 = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce");
2426 Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0);
2427 SrcPtr = TempAlloca;
2428 } else {
2429 SrcPtr = Builder.CreateBitCast(SrcPtr,
2430 llvm::PointerType::getUnqual(STy));
2431 }
2432
Chris Lattner92826882010-07-05 20:41:41 +00002433 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2434 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i);
Chris Lattnerdeabde22010-07-28 18:24:28 +00002435 llvm::LoadInst *LI = Builder.CreateLoad(EltPtr);
2436 // We don't know what we're loading from.
2437 LI->setAlignment(1);
2438 Args.push_back(LI);
Chris Lattner70855442011-07-12 04:46:18 +00002439
2440 // Validate argument match.
2441 checkArgMatches(LI, IRArgNo, IRFuncTy);
Chris Lattner309c59f2010-06-29 00:06:42 +00002442 }
Chris Lattnerce700162010-06-28 23:44:11 +00002443 } else {
Chris Lattner309c59f2010-06-29 00:06:42 +00002444 // In the simple case, just pass the coerced loaded value.
2445 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(),
2446 *this));
Chris Lattner70855442011-07-12 04:46:18 +00002447
2448 // Validate argument match.
2449 checkArgMatches(Args.back(), IRArgNo, IRFuncTy);
Chris Lattnerce700162010-06-28 23:44:11 +00002450 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002451
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002452 break;
2453 }
2454
Daniel Dunbar56273772008-09-17 00:51:38 +00002455 case ABIArgInfo::Expand:
Chris Lattner811bf362011-07-12 06:29:11 +00002456 ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy);
Chris Lattner70855442011-07-12 04:46:18 +00002457 IRArgNo = Args.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00002458 break;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002459 }
2460 }
Mike Stump1eb44332009-09-09 15:08:12 +00002461
Reid Kleckner9b601952013-06-21 12:45:15 +00002462 if (!CallArgs.getCleanupsToDeactivate().empty())
2463 deactivateArgCleanupsBeforeCall(*this, CallArgs);
2464
Chris Lattner5db7ae52009-06-13 00:26:38 +00002465 // If the callee is a bitcast of a function to a varargs pointer to function
2466 // type, check to see if we can remove the bitcast. This handles some cases
2467 // with unprototyped functions.
2468 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee))
2469 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002470 llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType());
2471 llvm::FunctionType *CurFT =
Chris Lattner5db7ae52009-06-13 00:26:38 +00002472 cast<llvm::FunctionType>(CurPT->getElementType());
Chris Lattner2acc6e32011-07-18 04:24:23 +00002473 llvm::FunctionType *ActualFT = CalleeF->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +00002474
Chris Lattner5db7ae52009-06-13 00:26:38 +00002475 if (CE->getOpcode() == llvm::Instruction::BitCast &&
2476 ActualFT->getReturnType() == CurFT->getReturnType() &&
Chris Lattnerd6bebbf2009-06-23 01:38:41 +00002477 ActualFT->getNumParams() == CurFT->getNumParams() &&
Fariborz Jahanianc0ddef22011-03-01 17:28:13 +00002478 ActualFT->getNumParams() == Args.size() &&
2479 (CurFT->isVarArg() || !ActualFT->isVarArg())) {
Chris Lattner5db7ae52009-06-13 00:26:38 +00002480 bool ArgsMatch = true;
2481 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i)
2482 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) {
2483 ArgsMatch = false;
2484 break;
2485 }
Mike Stump1eb44332009-09-09 15:08:12 +00002486
Chris Lattner5db7ae52009-06-13 00:26:38 +00002487 // Strip the cast if we can get away with it. This is a nice cleanup,
2488 // but also allows us to inline the function at -O0 if it is marked
2489 // always_inline.
2490 if (ArgsMatch)
2491 Callee = CalleeF;
2492 }
2493 }
Mike Stump1eb44332009-09-09 15:08:12 +00002494
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002495 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +00002496 CodeGen::AttributeListType AttributeList;
Bill Wendling94236e72013-02-22 00:13:35 +00002497 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList,
2498 CallingConv, true);
Bill Wendling785b7782012-12-07 23:17:26 +00002499 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
Bill Wendling94236e72013-02-22 00:13:35 +00002500 AttributeList);
Mike Stump1eb44332009-09-09 15:08:12 +00002501
John McCallf1549f62010-07-06 01:34:17 +00002502 llvm::BasicBlock *InvokeDest = 0;
Bill Wendling01ad9542012-12-30 10:32:17 +00002503 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
2504 llvm::Attribute::NoUnwind))
John McCallf1549f62010-07-06 01:34:17 +00002505 InvokeDest = getInvokeDest();
2506
Daniel Dunbard14151d2009-03-02 04:32:35 +00002507 llvm::CallSite CS;
John McCallf1549f62010-07-06 01:34:17 +00002508 if (!InvokeDest) {
Jay Foad4c7d9f12011-07-15 08:37:34 +00002509 CS = Builder.CreateCall(Callee, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002510 } else {
2511 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Jay Foad4c7d9f12011-07-15 08:37:34 +00002512 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002513 EmitBlock(Cont);
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002514 }
Chris Lattnerce933992010-06-29 16:40:28 +00002515 if (callOrInvoke)
David Chisnall4b02afc2010-05-02 13:41:58 +00002516 *callOrInvoke = CS.getInstruction();
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002517
Daniel Dunbard14151d2009-03-02 04:32:35 +00002518 CS.setAttributes(Attrs);
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002519 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbard14151d2009-03-02 04:32:35 +00002520
Dan Gohmanb49bd272012-02-16 00:57:37 +00002521 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2522 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00002523 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00002524 AddObjCARCExceptionMetadata(CS.getInstruction());
2525
Daniel Dunbard14151d2009-03-02 04:32:35 +00002526 // If the call doesn't return, finish the basic block and clear the
2527 // insertion point; this allows the rest of IRgen to discard
2528 // unreachable code.
2529 if (CS.doesNotReturn()) {
2530 Builder.CreateUnreachable();
2531 Builder.ClearInsertionPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002532
Mike Stumpf5408fe2009-05-16 07:57:57 +00002533 // FIXME: For now, emit a dummy basic block because expr emitters in
2534 // generally are not ready to handle emitting expressions at unreachable
2535 // points.
Daniel Dunbard14151d2009-03-02 04:32:35 +00002536 EnsureInsertPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002537
Daniel Dunbard14151d2009-03-02 04:32:35 +00002538 // Return a reasonable RValue.
2539 return GetUndefRValue(RetTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002540 }
Daniel Dunbard14151d2009-03-02 04:32:35 +00002541
2542 llvm::Instruction *CI = CS.getInstruction();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00002543 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy())
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002544 CI->setName("call");
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002545
John McCallf85e1932011-06-15 23:02:42 +00002546 // Emit any writebacks immediately. Arguably this should happen
2547 // after any return-value munging.
2548 if (CallArgs.hasWritebacks())
2549 emitWritebacks(*this, CallArgs);
2550
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002551 switch (RetAI.getKind()) {
John McCall9d232c82013-03-07 21:37:08 +00002552 case ABIArgInfo::Indirect:
2553 return convertTempToRValue(Args[0], RetTy);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002554
Daniel Dunbar11434922009-01-26 21:26:08 +00002555 case ABIArgInfo::Ignore:
Daniel Dunbar0bcc5212009-02-03 06:30:17 +00002556 // If we are ignoring an argument that had a result, make sure to
2557 // construct the appropriate return value for our caller.
Daniel Dunbar13e81732009-02-05 07:09:07 +00002558 return GetUndefRValue(RetTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002559
Chris Lattner800588f2010-07-29 06:26:06 +00002560 case ABIArgInfo::Extend:
2561 case ABIArgInfo::Direct: {
Chris Lattner6af13f32011-07-13 03:59:32 +00002562 llvm::Type *RetIRTy = ConvertType(RetTy);
2563 if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
John McCall9d232c82013-03-07 21:37:08 +00002564 switch (getEvaluationKind(RetTy)) {
2565 case TEK_Complex: {
Chris Lattner800588f2010-07-29 06:26:06 +00002566 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
2567 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
2568 return RValue::getComplex(std::make_pair(Real, Imag));
2569 }
John McCall9d232c82013-03-07 21:37:08 +00002570 case TEK_Aggregate: {
Chris Lattner800588f2010-07-29 06:26:06 +00002571 llvm::Value *DestPtr = ReturnValue.getValue();
2572 bool DestIsVolatile = ReturnValue.isVolatile();
Daniel Dunbar11434922009-01-26 21:26:08 +00002573
Chris Lattner800588f2010-07-29 06:26:06 +00002574 if (!DestPtr) {
2575 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
2576 DestIsVolatile = false;
2577 }
Eli Friedmanbadea572011-05-17 21:08:01 +00002578 BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false);
Chris Lattner800588f2010-07-29 06:26:06 +00002579 return RValue::getAggregate(DestPtr);
2580 }
John McCall9d232c82013-03-07 21:37:08 +00002581 case TEK_Scalar: {
2582 // If the argument doesn't match, perform a bitcast to coerce it. This
2583 // can happen due to trivial type mismatches.
2584 llvm::Value *V = CI;
2585 if (V->getType() != RetIRTy)
2586 V = Builder.CreateBitCast(V, RetIRTy);
2587 return RValue::get(V);
2588 }
2589 }
2590 llvm_unreachable("bad evaluation kind");
Chris Lattner800588f2010-07-29 06:26:06 +00002591 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002592
Anders Carlssond2490a92009-12-24 20:40:36 +00002593 llvm::Value *DestPtr = ReturnValue.getValue();
2594 bool DestIsVolatile = ReturnValue.isVolatile();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002595
Anders Carlssond2490a92009-12-24 20:40:36 +00002596 if (!DestPtr) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00002597 DestPtr = CreateMemTemp(RetTy, "coerce");
Anders Carlssond2490a92009-12-24 20:40:36 +00002598 DestIsVolatile = false;
2599 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002600
Chris Lattner117e3f42010-07-30 04:02:24 +00002601 // If the value is offset in memory, apply the offset now.
2602 llvm::Value *StorePtr = DestPtr;
2603 if (unsigned Offs = RetAI.getDirectOffset()) {
2604 StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy());
2605 StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002606 StorePtr = Builder.CreateBitCast(StorePtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002607 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
2608 }
2609 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002610
John McCall9d232c82013-03-07 21:37:08 +00002611 return convertTempToRValue(DestPtr, RetTy);
Daniel Dunbar639ffe42008-09-10 07:04:09 +00002612 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002613
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002614 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00002615 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002616 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002617
David Blaikieb219cfc2011-09-23 05:06:16 +00002618 llvm_unreachable("Unhandled ABIArgInfo::Kind");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002619}
Daniel Dunbarb4094ea2009-02-10 20:44:09 +00002620
2621/* VarArg handling */
2622
2623llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) {
2624 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this);
2625}