blob: 9a8edccdef0944ae3f7837de30d7b12ed1f3e5a3 [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()));
203 CanQualType resultType = Context.VoidTy;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000204
John McCallde5d3c72012-02-17 03:33:10 +0000205 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes);
John McCall0b0ef0a2010-02-24 07:14:12 +0000206
John McCall4c40d982010-08-31 07:33:07 +0000207 CanQual<FunctionProtoType> FTP = GetFormalType(D);
208
John McCallde5d3c72012-02-17 03:33:10 +0000209 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size());
210
John McCall4c40d982010-08-31 07:33:07 +0000211 // Add the formal parameters.
212 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000213 argTypes.push_back(FTP->getArgType(i));
John McCall4c40d982010-08-31 07:33:07 +0000214
John McCall0f3d0972012-07-07 06:41:13 +0000215 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000216 adjustCXXMethodInfo(*this, extInfo, FTP->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000217 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000218}
219
John McCallde5d3c72012-02-17 03:33:10 +0000220/// Arrange the argument and result information for a declaration,
221/// definition, or call to the given destructor variant. It so
222/// happens that all three cases produce the same information.
223const CGFunctionInfo &
224CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D,
225 CXXDtorType dtorKind) {
226 SmallVector<CanQualType, 2> argTypes;
227 argTypes.push_back(GetThisType(Context, D->getParent()));
228 CanQualType resultType = Context.VoidTy;
John McCall0b0ef0a2010-02-24 07:14:12 +0000229
John McCallde5d3c72012-02-17 03:33:10 +0000230 TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes);
John McCall4c40d982010-08-31 07:33:07 +0000231
232 CanQual<FunctionProtoType> FTP = GetFormalType(D);
233 assert(FTP->getNumArgs() == 0 && "dtor with formal parameters");
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000234 assert(FTP->isVariadic() == 0 && "dtor with formal parameters");
John McCall4c40d982010-08-31 07:33:07 +0000235
John McCall0f3d0972012-07-07 06:41:13 +0000236 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000237 adjustCXXMethodInfo(*this, extInfo, false);
John McCall0f3d0972012-07-07 06:41:13 +0000238 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo,
239 RequiredArgs::All);
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000240}
241
John McCallde5d3c72012-02-17 03:33:10 +0000242/// Arrange the argument and result information for the declaration or
243/// definition of the given function.
244const CGFunctionInfo &
245CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
Chris Lattner3eb67ca2009-05-12 20:27:19 +0000246 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
Anders Carlssonf6f8ae52009-04-03 22:48:58 +0000247 if (MD->isInstance())
John McCallde5d3c72012-02-17 03:33:10 +0000248 return arrangeCXXMethodDeclaration(MD);
Mike Stump1eb44332009-09-09 15:08:12 +0000249
John McCallead608a2010-02-26 00:48:12 +0000250 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
John McCallde5d3c72012-02-17 03:33:10 +0000251
John McCallead608a2010-02-26 00:48:12 +0000252 assert(isa<FunctionType>(FTy));
John McCallde5d3c72012-02-17 03:33:10 +0000253
254 // When declaring a function without a prototype, always use a
255 // non-variadic type.
256 if (isa<FunctionNoProtoType>(FTy)) {
257 CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>();
Dmitri Gribenko55431692013-05-05 00:41:58 +0000258 return arrangeLLVMFunctionInfo(noProto->getResultType(), None,
259 noProto->getExtInfo(), RequiredArgs::All);
John McCallde5d3c72012-02-17 03:33:10 +0000260 }
261
John McCallead608a2010-02-26 00:48:12 +0000262 assert(isa<FunctionProtoType>(FTy));
John McCall0f3d0972012-07-07 06:41:13 +0000263 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>());
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000264}
265
John McCallde5d3c72012-02-17 03:33:10 +0000266/// Arrange the argument and result information for the declaration or
267/// definition of an Objective-C method.
268const CGFunctionInfo &
269CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) {
270 // It happens that this is the same as a call with no optional
271 // arguments, except also using the formal 'self' type.
272 return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType());
273}
274
275/// Arrange the argument and result information for the function type
276/// through which to perform a send to the given Objective-C method,
277/// using the given receiver type. The receiver type is not always
278/// the 'self' type of the method or even an Objective-C pointer type.
279/// This is *not* the right method for actually performing such a
280/// message send, due to the possibility of optional arguments.
281const CGFunctionInfo &
282CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
283 QualType receiverType) {
284 SmallVector<CanQualType, 16> argTys;
285 argTys.push_back(Context.getCanonicalParamType(receiverType));
286 argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000287 // FIXME: Kill copy?
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000288 for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(),
John McCall0b0ef0a2010-02-24 07:14:12 +0000289 e = MD->param_end(); i != e; ++i) {
John McCallde5d3c72012-02-17 03:33:10 +0000290 argTys.push_back(Context.getCanonicalParamType((*i)->getType()));
John McCall0b0ef0a2010-02-24 07:14:12 +0000291 }
John McCallf85e1932011-06-15 23:02:42 +0000292
293 FunctionType::ExtInfo einfo;
294 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD));
295
David Blaikie4e4d0842012-03-11 07:00:24 +0000296 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +0000297 MD->hasAttr<NSReturnsRetainedAttr>())
298 einfo = einfo.withProducesResult(true);
299
John McCallde5d3c72012-02-17 03:33:10 +0000300 RequiredArgs required =
301 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
302
John McCall0f3d0972012-07-07 06:41:13 +0000303 return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys,
304 einfo, required);
Daniel Dunbar0dbe2272008-09-08 21:33:45 +0000305}
306
John McCallde5d3c72012-02-17 03:33:10 +0000307const CGFunctionInfo &
308CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000309 // FIXME: Do we need to handle ObjCMethodDecl?
310 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000311
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000312 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000313 return arrangeCXXConstructorDeclaration(CD, GD.getCtorType());
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000314
315 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
John McCallde5d3c72012-02-17 03:33:10 +0000316 return arrangeCXXDestructor(DD, GD.getDtorType());
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000317
John McCallde5d3c72012-02-17 03:33:10 +0000318 return arrangeFunctionDeclaration(FD);
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000319}
320
John McCalle56bb362012-12-07 07:03:17 +0000321/// Arrange a call as unto a free function, except possibly with an
322/// additional number of formal parameters considered required.
323static const CGFunctionInfo &
324arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
325 const CallArgList &args,
326 const FunctionType *fnType,
327 unsigned numExtraRequiredArgs) {
328 assert(args.size() >= numExtraRequiredArgs);
329
330 // In most cases, there are no optional arguments.
331 RequiredArgs required = RequiredArgs::All;
332
333 // If we have a variadic prototype, the required arguments are the
334 // extra prefix plus the arguments in the prototype.
335 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
336 if (proto->isVariadic())
337 required = RequiredArgs(proto->getNumArgs() + numExtraRequiredArgs);
338
339 // If we don't have a prototype at all, but we're supposed to
340 // explicitly use the variadic convention for unprototyped calls,
341 // treat all of the arguments as required but preserve the nominal
342 // possibility of variadics.
343 } else if (CGT.CGM.getTargetCodeGenInfo()
344 .isNoProtoCallVariadic(args, cast<FunctionNoProtoType>(fnType))) {
345 required = RequiredArgs(args.size());
346 }
347
348 return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args,
349 fnType->getExtInfo(), required);
350}
351
John McCallde5d3c72012-02-17 03:33:10 +0000352/// Figure out the rules for calling a function with the given formal
353/// type using the given arguments. The arguments are necessary
354/// because the function might be unprototyped, in which case it's
355/// target-dependent in crazy ways.
356const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000357CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
358 const FunctionType *fnType) {
John McCalle56bb362012-12-07 07:03:17 +0000359 return arrangeFreeFunctionLikeCall(*this, args, fnType, 0);
360}
John McCallde5d3c72012-02-17 03:33:10 +0000361
John McCalle56bb362012-12-07 07:03:17 +0000362/// A block function call is essentially a free-function call with an
363/// extra implicit argument.
364const CGFunctionInfo &
365CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
366 const FunctionType *fnType) {
367 return arrangeFreeFunctionLikeCall(*this, args, fnType, 1);
John McCallde5d3c72012-02-17 03:33:10 +0000368}
369
370const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000371CodeGenTypes::arrangeFreeFunctionCall(QualType resultType,
372 const CallArgList &args,
373 FunctionType::ExtInfo info,
374 RequiredArgs required) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000375 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000376 SmallVector<CanQualType, 16> argTypes;
377 for (CallArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbar725ad312009-01-31 02:19:00 +0000378 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000379 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
John McCall0f3d0972012-07-07 06:41:13 +0000380 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
381 required);
382}
383
384/// Arrange a call to a C++ method, passing the given arguments.
385const CGFunctionInfo &
386CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
387 const FunctionProtoType *FPT,
388 RequiredArgs required) {
389 // FIXME: Kill copy.
390 SmallVector<CanQualType, 16> argTypes;
391 for (CallArgList::const_iterator i = args.begin(), e = args.end();
392 i != e; ++i)
393 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
394
395 FunctionType::ExtInfo info = FPT->getExtInfo();
Timur Iskhodzhanov8f88a1d2012-07-12 09:50:54 +0000396 adjustCXXMethodInfo(*this, info, FPT->isVariadic());
John McCall0f3d0972012-07-07 06:41:13 +0000397 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()),
398 argTypes, info, required);
Daniel Dunbar725ad312009-01-31 02:19:00 +0000399}
400
John McCallde5d3c72012-02-17 03:33:10 +0000401const CGFunctionInfo &
402CodeGenTypes::arrangeFunctionDeclaration(QualType resultType,
403 const FunctionArgList &args,
404 const FunctionType::ExtInfo &info,
405 bool isVariadic) {
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000406 // FIXME: Kill copy.
John McCallde5d3c72012-02-17 03:33:10 +0000407 SmallVector<CanQualType, 16> argTypes;
408 for (FunctionArgList::const_iterator i = args.begin(), e = args.end();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000409 i != e; ++i)
John McCallde5d3c72012-02-17 03:33:10 +0000410 argTypes.push_back(Context.getCanonicalParamType((*i)->getType()));
411
412 RequiredArgs required =
413 (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All);
John McCall0f3d0972012-07-07 06:41:13 +0000414 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
415 required);
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000416}
417
John McCallde5d3c72012-02-17 03:33:10 +0000418const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000419 return arrangeLLVMFunctionInfo(getContext().VoidTy, None,
John McCall0f3d0972012-07-07 06:41:13 +0000420 FunctionType::ExtInfo(), RequiredArgs::All);
John McCalld26bc762011-03-09 04:27:21 +0000421}
422
John McCallde5d3c72012-02-17 03:33:10 +0000423/// Arrange the argument and result information for an abstract value
424/// of a given function type. This is the method which all of the
425/// above functions ultimately defer to.
426const CGFunctionInfo &
John McCall0f3d0972012-07-07 06:41:13 +0000427CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
428 ArrayRef<CanQualType> argTypes,
429 FunctionType::ExtInfo info,
430 RequiredArgs required) {
John McCallead608a2010-02-26 00:48:12 +0000431#ifndef NDEBUG
John McCallde5d3c72012-02-17 03:33:10 +0000432 for (ArrayRef<CanQualType>::const_iterator
433 I = argTypes.begin(), E = argTypes.end(); I != E; ++I)
John McCallead608a2010-02-26 00:48:12 +0000434 assert(I->isCanonicalAsParam());
435#endif
436
John McCallde5d3c72012-02-17 03:33:10 +0000437 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
John McCall04a67a62010-02-05 21:31:56 +0000438
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000439 // Lookup or create unique function info.
440 llvm::FoldingSetNodeID ID;
John McCallde5d3c72012-02-17 03:33:10 +0000441 CGFunctionInfo::Profile(ID, info, required, resultType, argTypes);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000442
John McCallde5d3c72012-02-17 03:33:10 +0000443 void *insertPos = 0;
444 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000445 if (FI)
446 return *FI;
447
John McCallde5d3c72012-02-17 03:33:10 +0000448 // Construct the function info. We co-allocate the ArgInfos.
449 FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required);
450 FunctionInfos.InsertNode(FI, insertPos);
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000451
John McCallde5d3c72012-02-17 03:33:10 +0000452 bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted;
453 assert(inserted && "Recursively being processed?");
Chris Lattner71305cc2011-07-15 05:16:14 +0000454
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000455 // Compute ABI information.
Chris Lattneree5dcd02010-07-29 02:31:05 +0000456 getABIInfo().computeInfo(*FI);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000457
Chris Lattner800588f2010-07-29 06:26:06 +0000458 // Loop over all of the computed argument and return value info. If any of
459 // them are direct or extend without a specified coerce type, specify the
460 // default now.
John McCallde5d3c72012-02-17 03:33:10 +0000461 ABIArgInfo &retInfo = FI->getReturnInfo();
462 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == 0)
463 retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000464
Chris Lattner800588f2010-07-29 06:26:06 +0000465 for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end();
466 I != E; ++I)
467 if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0)
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000468 I->info.setCoerceToType(ConvertType(I->type));
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000469
John McCallde5d3c72012-02-17 03:33:10 +0000470 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
471 assert(erased && "Not in set?");
Chris Lattnerd26c0712011-07-15 06:41:05 +0000472
Daniel Dunbar40a6be62009-02-03 00:07:12 +0000473 return *FI;
Daniel Dunbar541b63b2009-02-02 23:23:47 +0000474}
475
John McCallde5d3c72012-02-17 03:33:10 +0000476CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
477 const FunctionType::ExtInfo &info,
478 CanQualType resultType,
479 ArrayRef<CanQualType> argTypes,
480 RequiredArgs required) {
481 void *buffer = operator new(sizeof(CGFunctionInfo) +
482 sizeof(ArgInfo) * (argTypes.size() + 1));
483 CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
484 FI->CallingConvention = llvmCC;
485 FI->EffectiveCallingConvention = llvmCC;
486 FI->ASTCallingConvention = info.getCC();
487 FI->NoReturn = info.getNoReturn();
488 FI->ReturnsRetained = info.getProducesResult();
489 FI->Required = required;
490 FI->HasRegParm = info.getHasRegParm();
491 FI->RegParm = info.getRegParm();
492 FI->NumArgs = argTypes.size();
493 FI->getArgsBuffer()[0].type = resultType;
494 for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
495 FI->getArgsBuffer()[i + 1].type = argTypes[i];
496 return FI;
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000497}
498
499/***/
500
John McCall42e06112011-05-15 02:19:42 +0000501void CodeGenTypes::GetExpandedTypes(QualType type,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000502 SmallVectorImpl<llvm::Type*> &expandedTypes) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000503 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) {
504 uint64_t NumElts = AT->getSize().getZExtValue();
505 for (uint64_t Elt = 0; Elt < NumElts; ++Elt)
506 GetExpandedTypes(AT->getElementType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000507 } else if (const RecordType *RT = type->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000508 const RecordDecl *RD = RT->getDecl();
509 assert(!RD->hasFlexibleArrayMember() &&
510 "Cannot expand structure with flexible array.");
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000511 if (RD->isUnion()) {
512 // Unions can be here only in degenerative cases - all the fields are same
513 // after flattening. Thus we have to use the "largest" field.
514 const FieldDecl *LargestFD = 0;
515 CharUnits UnionSize = CharUnits::Zero();
516
517 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
518 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000519 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000520 assert(!FD->isBitField() &&
521 "Cannot expand structure with bit-field members.");
522 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
523 if (UnionSize < FieldSize) {
524 UnionSize = FieldSize;
525 LargestFD = FD;
526 }
527 }
528 if (LargestFD)
529 GetExpandedTypes(LargestFD->getType(), expandedTypes);
530 } else {
531 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
532 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000533 assert(!i->isBitField() &&
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000534 "Cannot expand structure with bit-field members.");
David Blaikie581deb32012-06-06 20:45:41 +0000535 GetExpandedTypes(i->getType(), expandedTypes);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000536 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000537 }
538 } else if (const ComplexType *CT = type->getAs<ComplexType>()) {
539 llvm::Type *EltTy = ConvertType(CT->getElementType());
540 expandedTypes.push_back(EltTy);
541 expandedTypes.push_back(EltTy);
542 } else
543 expandedTypes.push_back(ConvertType(type));
Daniel Dunbar56273772008-09-17 00:51:38 +0000544}
545
Mike Stump1eb44332009-09-09 15:08:12 +0000546llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +0000547CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
548 llvm::Function::arg_iterator AI) {
Mike Stump1eb44332009-09-09 15:08:12 +0000549 assert(LV.isSimple() &&
550 "Unexpected non-simple lvalue during struct expansion.");
Daniel Dunbar56273772008-09-17 00:51:38 +0000551
Bob Wilson194f06a2011-08-03 05:58:22 +0000552 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
553 unsigned NumElts = AT->getSize().getZExtValue();
554 QualType EltTy = AT->getElementType();
555 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
Eli Friedman377ecc72012-04-16 03:54:45 +0000556 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt);
Bob Wilson194f06a2011-08-03 05:58:22 +0000557 LValue LV = MakeAddrLValue(EltAddr, EltTy);
558 AI = ExpandTypeFromArgs(EltTy, LV, AI);
Daniel Dunbar56273772008-09-17 00:51:38 +0000559 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000560 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +0000561 RecordDecl *RD = RT->getDecl();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000562 if (RD->isUnion()) {
563 // Unions can be here only in degenerative cases - all the fields are same
564 // after flattening. Thus we have to use the "largest" field.
565 const FieldDecl *LargestFD = 0;
566 CharUnits UnionSize = CharUnits::Zero();
Bob Wilson194f06a2011-08-03 05:58:22 +0000567
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000568 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
569 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000570 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000571 assert(!FD->isBitField() &&
572 "Cannot expand structure with bit-field members.");
573 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
574 if (UnionSize < FieldSize) {
575 UnionSize = FieldSize;
576 LargestFD = FD;
577 }
578 }
579 if (LargestFD) {
580 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000581 LValue SubLV = EmitLValueForField(LV, LargestFD);
582 AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000583 }
584 } else {
585 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
586 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000587 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000588 QualType FT = FD->getType();
589
590 // FIXME: What are the right qualifiers here?
Eli Friedman377ecc72012-04-16 03:54:45 +0000591 LValue SubLV = EmitLValueForField(LV, FD);
592 AI = ExpandTypeFromArgs(FT, SubLV, AI);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +0000593 }
Bob Wilson194f06a2011-08-03 05:58:22 +0000594 }
595 } else if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
596 QualType EltTy = CT->getElementType();
Eli Friedman377ecc72012-04-16 03:54:45 +0000597 llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real");
Bob Wilson194f06a2011-08-03 05:58:22 +0000598 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy));
Eli Friedman377ecc72012-04-16 03:54:45 +0000599 llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag");
Bob Wilson194f06a2011-08-03 05:58:22 +0000600 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy));
601 } else {
602 EmitStoreThroughLValue(RValue::get(AI), LV);
603 ++AI;
Daniel Dunbar56273772008-09-17 00:51:38 +0000604 }
605
606 return AI;
607}
608
Chris Lattnere7bb7772010-06-27 06:04:18 +0000609/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
Chris Lattner08dd2a02010-06-27 05:56:15 +0000610/// accessing some number of bytes out of it, try to gep into the struct to get
611/// at its inner goodness. Dive as deep as possible without entering an element
612/// with an in-memory size smaller than DstSize.
613static llvm::Value *
Chris Lattnere7bb7772010-06-27 06:04:18 +0000614EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000615 llvm::StructType *SrcSTy,
Chris Lattnere7bb7772010-06-27 06:04:18 +0000616 uint64_t DstSize, CodeGenFunction &CGF) {
Chris Lattner08dd2a02010-06-27 05:56:15 +0000617 // We can't dive into a zero-element struct.
618 if (SrcSTy->getNumElements() == 0) return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000619
Chris Lattner2acc6e32011-07-18 04:24:23 +0000620 llvm::Type *FirstElt = SrcSTy->getElementType(0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000621
Chris Lattner08dd2a02010-06-27 05:56:15 +0000622 // If the first elt is at least as large as what we're looking for, or if the
623 // first element is the same size as the whole struct, we can enter it.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000624 uint64_t FirstEltSize =
Micah Villmow25a6a842012-10-08 16:25:52 +0000625 CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000626 if (FirstEltSize < DstSize &&
Micah Villmow25a6a842012-10-08 16:25:52 +0000627 FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy))
Chris Lattner08dd2a02010-06-27 05:56:15 +0000628 return SrcPtr;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000629
Chris Lattner08dd2a02010-06-27 05:56:15 +0000630 // GEP into the first element.
631 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000632
Chris Lattner08dd2a02010-06-27 05:56:15 +0000633 // If the first element is a struct, recurse.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000634 llvm::Type *SrcTy =
Chris Lattner08dd2a02010-06-27 05:56:15 +0000635 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000636 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
Chris Lattnere7bb7772010-06-27 06:04:18 +0000637 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000638
639 return SrcPtr;
640}
641
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000642/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
643/// are either integers or pointers. This does a truncation of the value if it
644/// is too large or a zero extension if it is too small.
645static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000646 llvm::Type *Ty,
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000647 CodeGenFunction &CGF) {
648 if (Val->getType() == Ty)
649 return Val;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000650
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000651 if (isa<llvm::PointerType>(Val->getType())) {
652 // If this is Pointer->Pointer avoid conversion to and from int.
653 if (isa<llvm::PointerType>(Ty))
654 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000655
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000656 // Convert the pointer to an integer so we can play with its width.
Chris Lattner77b89b82010-06-27 07:15:29 +0000657 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000658 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000659
Chris Lattner2acc6e32011-07-18 04:24:23 +0000660 llvm::Type *DestIntTy = Ty;
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000661 if (isa<llvm::PointerType>(DestIntTy))
Chris Lattner77b89b82010-06-27 07:15:29 +0000662 DestIntTy = CGF.IntPtrTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000663
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000664 if (Val->getType() != DestIntTy)
665 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000666
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000667 if (isa<llvm::PointerType>(Ty))
668 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
669 return Val;
670}
671
Chris Lattner08dd2a02010-06-27 05:56:15 +0000672
673
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000674/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
675/// a pointer to an object of type \arg Ty.
676///
677/// This safely handles the case when the src type is smaller than the
678/// destination type; in this situation the values of bits which not
679/// present in the src are undefined.
680static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000681 llvm::Type *Ty,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000682 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000683 llvm::Type *SrcTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000684 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000685
Chris Lattner6ae00692010-06-28 22:51:39 +0000686 // If SrcTy and Ty are the same, just do a load.
687 if (SrcTy == Ty)
688 return CGF.Builder.CreateLoad(SrcPtr);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000689
Micah Villmow25a6a842012-10-08 16:25:52 +0000690 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000691
Chris Lattner2acc6e32011-07-18 04:24:23 +0000692 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000693 SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner08dd2a02010-06-27 05:56:15 +0000694 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
695 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000696
Micah Villmow25a6a842012-10-08 16:25:52 +0000697 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000698
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000699 // If the source and destination are integer or pointer types, just do an
700 // extension or truncation to the desired type.
701 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
702 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
703 llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr);
704 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
705 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000706
Daniel Dunbarb225be42009-02-03 05:59:18 +0000707 // If load is legal, just bitcast the src pointer.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000708 if (SrcSize >= DstSize) {
Mike Stumpf5408fe2009-05-16 07:57:57 +0000709 // Generally SrcSize is never greater than DstSize, since this means we are
710 // losing bits. However, this can happen in cases where the structure has
711 // additional padding, for example due to a user specified alignment.
Daniel Dunbar7ef455b2009-05-13 18:54:26 +0000712 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000713 // FIXME: Assert that we aren't truncating non-padding bits when have access
714 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000715 llvm::Value *Casted =
716 CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000717 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted);
718 // FIXME: Use better alignment / avoid requiring aligned load.
719 Load->setAlignment(1);
720 return Load;
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000721 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000722
Chris Lattner35b21b82010-06-27 01:06:27 +0000723 // Otherwise do coercion through memory. This is stupid, but
724 // simple.
725 llvm::Value *Tmp = CGF.CreateTempAlloca(Ty);
Manman Renf51c61c2012-11-28 22:08:52 +0000726 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
727 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
728 llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000729 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000730 CGF.Builder.CreateMemCpy(Casted, SrcCasted,
731 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
732 1, false);
Chris Lattner35b21b82010-06-27 01:06:27 +0000733 return CGF.Builder.CreateLoad(Tmp);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000734}
735
Eli Friedmanbadea572011-05-17 21:08:01 +0000736// Function to store a first-class aggregate into memory. We prefer to
737// store the elements rather than the aggregate to be more friendly to
738// fast-isel.
739// FIXME: Do we need to recurse here?
740static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
741 llvm::Value *DestPtr, bool DestIsVolatile,
742 bool LowAlignment) {
743 // Prefer scalar stores to first-class aggregate stores.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000744 if (llvm::StructType *STy =
Eli Friedmanbadea572011-05-17 21:08:01 +0000745 dyn_cast<llvm::StructType>(Val->getType())) {
746 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
747 llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i);
748 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
749 llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr,
750 DestIsVolatile);
751 if (LowAlignment)
752 SI->setAlignment(1);
753 }
754 } else {
Bill Wendling08212632012-03-16 21:45:12 +0000755 llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile);
756 if (LowAlignment)
757 SI->setAlignment(1);
Eli Friedmanbadea572011-05-17 21:08:01 +0000758 }
759}
760
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000761/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
762/// where the source and destination may have different types.
763///
764/// This safely handles the case when the src type is larger than the
765/// destination type; the upper bits of the src will be lost.
766static void CreateCoercedStore(llvm::Value *Src,
767 llvm::Value *DstPtr,
Anders Carlssond2490a92009-12-24 20:40:36 +0000768 bool DstIsVolatile,
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000769 CodeGenFunction &CGF) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000770 llvm::Type *SrcTy = Src->getType();
771 llvm::Type *DstTy =
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000772 cast<llvm::PointerType>(DstPtr->getType())->getElementType();
Chris Lattner6ae00692010-06-28 22:51:39 +0000773 if (SrcTy == DstTy) {
774 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
775 return;
776 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000777
Micah Villmow25a6a842012-10-08 16:25:52 +0000778 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000779
Chris Lattner2acc6e32011-07-18 04:24:23 +0000780 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
Chris Lattnere7bb7772010-06-27 06:04:18 +0000781 DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF);
782 DstTy = cast<llvm::PointerType>(DstPtr->getType())->getElementType();
783 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000784
Chris Lattner6d11cdb2010-06-27 06:26:04 +0000785 // If the source and destination are integer or pointer types, just do an
786 // extension or truncation to the desired type.
787 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
788 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
789 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
790 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
791 return;
792 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000793
Micah Villmow25a6a842012-10-08 16:25:52 +0000794 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000795
Daniel Dunbar88c2fa92009-02-03 05:31:23 +0000796 // If store is legal, just bitcast the src pointer.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000797 if (SrcSize <= DstSize) {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000798 llvm::Value *Casted =
799 CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy));
Daniel Dunbar386621f2009-02-07 02:46:03 +0000800 // FIXME: Use better alignment / avoid requiring aligned store.
Eli Friedmanbadea572011-05-17 21:08:01 +0000801 BuildAggStore(CGF, Src, Casted, DstIsVolatile, true);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000802 } else {
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000803 // Otherwise do coercion through memory. This is stupid, but
804 // simple.
Daniel Dunbarfdf49862009-06-05 07:58:54 +0000805
806 // Generally SrcSize is never greater than DstSize, since this means we are
807 // losing bits. However, this can happen in cases where the structure has
808 // additional padding, for example due to a user specified alignment.
809 //
810 // FIXME: Assert that we aren't truncating non-padding bits when have access
811 // to that information.
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000812 llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy);
813 CGF.Builder.CreateStore(Src, Tmp);
Manman Renf51c61c2012-11-28 22:08:52 +0000814 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy();
815 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy);
816 llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy);
Manman Ren060f34d2012-11-28 22:29:41 +0000817 // FIXME: Use better alignment.
Manman Renf51c61c2012-11-28 22:08:52 +0000818 CGF.Builder.CreateMemCpy(DstCasted, Casted,
819 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
820 1, false);
Daniel Dunbar275e10d2009-02-02 19:06:38 +0000821 }
822}
823
Daniel Dunbar56273772008-09-17 00:51:38 +0000824/***/
825
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000826bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000827 return FI.getReturnInfo().isIndirect();
Daniel Dunbarbb36d332009-02-02 21:43:58 +0000828}
829
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000830bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
831 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
832 switch (BT->getKind()) {
833 default:
834 return false;
835 case BuiltinType::Float:
John McCall64aa4b32013-04-16 22:48:15 +0000836 return getTarget().useObjCFPRetForRealType(TargetInfo::Float);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000837 case BuiltinType::Double:
John McCall64aa4b32013-04-16 22:48:15 +0000838 return getTarget().useObjCFPRetForRealType(TargetInfo::Double);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000839 case BuiltinType::LongDouble:
John McCall64aa4b32013-04-16 22:48:15 +0000840 return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +0000841 }
842 }
843
844 return false;
845}
846
Anders Carlssoneea64802011-10-31 16:27:11 +0000847bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) {
848 if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
849 if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
850 if (BT->getKind() == BuiltinType::LongDouble)
John McCall64aa4b32013-04-16 22:48:15 +0000851 return getTarget().useObjCFP2RetForComplexLongDouble();
Anders Carlssoneea64802011-10-31 16:27:11 +0000852 }
853 }
854
855 return false;
856}
857
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000858llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
John McCallde5d3c72012-02-17 03:33:10 +0000859 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
860 return GetFunctionType(FI);
John McCallc0bf4622010-02-23 00:48:20 +0000861}
862
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000863llvm::FunctionType *
John McCallde5d3c72012-02-17 03:33:10 +0000864CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
Chris Lattner71305cc2011-07-15 05:16:14 +0000865
866 bool Inserted = FunctionsBeingProcessed.insert(&FI); (void)Inserted;
867 assert(Inserted && "Recursively being processed?");
868
Chris Lattner5f9e2722011-07-23 10:55:15 +0000869 SmallVector<llvm::Type*, 8> argTypes;
Chris Lattner2acc6e32011-07-18 04:24:23 +0000870 llvm::Type *resultType = 0;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000871
John McCall42e06112011-05-15 02:19:42 +0000872 const ABIArgInfo &retAI = FI.getReturnInfo();
873 switch (retAI.getKind()) {
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000874 case ABIArgInfo::Expand:
John McCall42e06112011-05-15 02:19:42 +0000875 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000876
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +0000877 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000878 case ABIArgInfo::Direct:
John McCall42e06112011-05-15 02:19:42 +0000879 resultType = retAI.getCoerceToType();
Daniel Dunbar46327aa2009-02-03 06:17:37 +0000880 break;
881
Daniel Dunbar11e383a2009-02-05 08:00:50 +0000882 case ABIArgInfo::Indirect: {
John McCall42e06112011-05-15 02:19:42 +0000883 assert(!retAI.getIndirectAlign() && "Align unused on indirect return.");
884 resultType = llvm::Type::getVoidTy(getLLVMContext());
885
886 QualType ret = FI.getReturnType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000887 llvm::Type *ty = ConvertType(ret);
John McCall42e06112011-05-15 02:19:42 +0000888 unsigned addressSpace = Context.getTargetAddressSpace(ret);
889 argTypes.push_back(llvm::PointerType::get(ty, addressSpace));
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000890 break;
891 }
892
Daniel Dunbar11434922009-01-26 21:26:08 +0000893 case ABIArgInfo::Ignore:
John McCall42e06112011-05-15 02:19:42 +0000894 resultType = llvm::Type::getVoidTy(getLLVMContext());
Daniel Dunbar11434922009-01-26 21:26:08 +0000895 break;
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000896 }
Mike Stump1eb44332009-09-09 15:08:12 +0000897
John McCalle56bb362012-12-07 07:03:17 +0000898 // Add in all of the required arguments.
899 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie;
900 if (FI.isVariadic()) {
901 ie = it + FI.getRequiredArgs().getNumRequiredArgs();
902 } else {
903 ie = FI.arg_end();
904 }
905 for (; it != ie; ++it) {
John McCall42e06112011-05-15 02:19:42 +0000906 const ABIArgInfo &argAI = it->info;
Mike Stump1eb44332009-09-09 15:08:12 +0000907
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +0000908 // Insert a padding type to ensure proper alignment.
909 if (llvm::Type *PaddingType = argAI.getPaddingType())
910 argTypes.push_back(PaddingType);
911
John McCall42e06112011-05-15 02:19:42 +0000912 switch (argAI.getKind()) {
Daniel Dunbar11434922009-01-26 21:26:08 +0000913 case ABIArgInfo::Ignore:
914 break;
915
Chris Lattner800588f2010-07-29 06:26:06 +0000916 case ABIArgInfo::Indirect: {
917 // indirect arguments are always on the stack, which is addr space #0.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000918 llvm::Type *LTy = ConvertTypeForMem(it->type);
John McCall42e06112011-05-15 02:19:42 +0000919 argTypes.push_back(LTy->getPointerTo());
Chris Lattner800588f2010-07-29 06:26:06 +0000920 break;
921 }
922
923 case ABIArgInfo::Extend:
Chris Lattner1ed72672010-07-29 06:44:09 +0000924 case ABIArgInfo::Direct: {
Chris Lattnerce700162010-06-28 23:44:11 +0000925 // If the coerce-to type is a first class aggregate, flatten it. Either
926 // way is semantically identical, but fast-isel and the optimizer
927 // generally likes scalar values better than FCAs.
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000928 llvm::Type *argType = argAI.getCoerceToType();
Chris Lattner2acc6e32011-07-18 04:24:23 +0000929 if (llvm::StructType *st = dyn_cast<llvm::StructType>(argType)) {
John McCall42e06112011-05-15 02:19:42 +0000930 for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
931 argTypes.push_back(st->getElementType(i));
Chris Lattnerce700162010-06-28 23:44:11 +0000932 } else {
John McCall42e06112011-05-15 02:19:42 +0000933 argTypes.push_back(argType);
Chris Lattnerce700162010-06-28 23:44:11 +0000934 }
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +0000935 break;
Chris Lattner1ed72672010-07-29 06:44:09 +0000936 }
Mike Stump1eb44332009-09-09 15:08:12 +0000937
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000938 case ABIArgInfo::Expand:
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000939 GetExpandedTypes(it->type, argTypes);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +0000940 break;
941 }
Daniel Dunbar45c25ba2008-09-10 04:01:49 +0000942 }
943
Chris Lattner71305cc2011-07-15 05:16:14 +0000944 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
945 assert(Erased && "Not in set?");
946
John McCallde5d3c72012-02-17 03:33:10 +0000947 return llvm::FunctionType::get(resultType, argTypes, FI.isVariadic());
Daniel Dunbar3913f182008-09-09 23:48:28 +0000948}
949
Chris Lattner2acc6e32011-07-18 04:24:23 +0000950llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
John McCall4c40d982010-08-31 07:33:07 +0000951 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlssonecf282b2009-11-24 05:08:52 +0000952 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000953
Chris Lattnerf742eb02011-07-10 00:18:59 +0000954 if (!isFuncTypeConvertible(FPT))
955 return llvm::StructType::get(getLLVMContext());
956
957 const CGFunctionInfo *Info;
958 if (isa<CXXDestructorDecl>(MD))
John McCallde5d3c72012-02-17 03:33:10 +0000959 Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType());
Chris Lattnerf742eb02011-07-10 00:18:59 +0000960 else
John McCallde5d3c72012-02-17 03:33:10 +0000961 Info = &arrangeCXXMethodDeclaration(MD);
962 return GetFunctionType(*Info);
Anders Carlssonecf282b2009-11-24 05:08:52 +0000963}
964
Daniel Dunbara0a99e02009-02-02 23:43:58 +0000965void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
Daniel Dunbar88b53962009-02-02 22:03:45 +0000966 const Decl *TargetDecl,
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000967 AttributeListType &PAL,
Bill Wendling94236e72013-02-22 00:13:35 +0000968 unsigned &CallingConv,
969 bool AttrOnCallSite) {
Bill Wendling0d583392012-10-15 20:36:26 +0000970 llvm::AttrBuilder FuncAttrs;
971 llvm::AttrBuilder RetAttrs;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000972
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000973 CallingConv = FI.getEffectiveCallingConvention();
974
John McCall04a67a62010-02-05 21:31:56 +0000975 if (FI.isNoReturn())
Bill Wendling72390b32012-12-20 19:27:06 +0000976 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCall04a67a62010-02-05 21:31:56 +0000977
Anton Korobeynikov1102f422009-04-04 00:49:24 +0000978 // FIXME: handle sseregparm someday...
Daniel Dunbar5323a4b2008-09-10 00:32:18 +0000979 if (TargetDecl) {
Rafael Espindola67004152011-10-12 19:51:18 +0000980 if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000981 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000982 if (TargetDecl->hasAttr<NoThrowAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000983 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Richard Smith7586a6e2013-01-30 05:45:05 +0000984 if (TargetDecl->hasAttr<NoReturnAttr>())
985 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
986
987 if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
John McCall9c0c1f32010-07-08 06:48:12 +0000988 const FunctionProtoType *FPT = Fn->getType()->getAs<FunctionProtoType>();
Sebastian Redl8026f6d2011-03-13 17:09:40 +0000989 if (FPT && FPT->isNothrow(getContext()))
Bill Wendling72390b32012-12-20 19:27:06 +0000990 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Richard Smith3c5cd152013-03-05 08:30:04 +0000991 // Don't use [[noreturn]] or _Noreturn for a call to a virtual function.
992 // These attributes are not inherited by overloads.
993 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
994 if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual()))
Richard Smith7586a6e2013-01-30 05:45:05 +0000995 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCall9c0c1f32010-07-08 06:48:12 +0000996 }
997
Eric Christopher041087c2011-08-15 22:38:22 +0000998 // 'const' and 'pure' attribute functions are also nounwind.
999 if (TargetDecl->hasAttr<ConstAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001000 FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1001 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001002 } else if (TargetDecl->hasAttr<PureAttr>()) {
Bill Wendling72390b32012-12-20 19:27:06 +00001003 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1004 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopher041087c2011-08-15 22:38:22 +00001005 }
Ryan Flynn76168e22009-08-09 20:07:29 +00001006 if (TargetDecl->hasAttr<MallocAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +00001007 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001008 }
1009
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001010 if (CodeGenOpts.OptimizeSize)
Bill Wendling72390b32012-12-20 19:27:06 +00001011 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
Quentin Colombet90467682012-10-26 00:29:48 +00001012 if (CodeGenOpts.OptimizeSize == 2)
Bill Wendling72390b32012-12-20 19:27:06 +00001013 FuncAttrs.addAttribute(llvm::Attribute::MinSize);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001014 if (CodeGenOpts.DisableRedZone)
Bill Wendling72390b32012-12-20 19:27:06 +00001015 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
Chandler Carruth2811ccf2009-11-12 17:24:48 +00001016 if (CodeGenOpts.NoImplicitFloat)
Bill Wendling72390b32012-12-20 19:27:06 +00001017 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
Devang Patel24095da2009-06-04 23:32:02 +00001018
Bill Wendling93e4bff2013-02-22 20:53:29 +00001019 if (AttrOnCallSite) {
1020 // Attributes that should go on the call site only.
1021 if (!CodeGenOpts.SimplifyLibCalls)
1022 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001023 } else {
1024 // Attributes that should go on the function, but not the call site.
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001025 if (!CodeGenOpts.DisableFPElim) {
Bill Wendling4159f052013-03-13 22:24:33 +00001026 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
1027 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "false");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001028 } else if (CodeGenOpts.OmitLeafFramePointer) {
Bill Wendling4159f052013-03-13 22:24:33 +00001029 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
1030 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "true");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001031 } else {
Bill Wendling4159f052013-03-13 22:24:33 +00001032 FuncAttrs.addAttribute("no-frame-pointer-elim", "true");
1033 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "true");
Bill Wendlingbe9e8bf2013-02-28 22:49:57 +00001034 }
1035
Bill Wendling4159f052013-03-13 22:24:33 +00001036 FuncAttrs.addAttribute("less-precise-fpmad",
1037 CodeGenOpts.LessPreciseFPMAD ? "true" : "false");
1038 FuncAttrs.addAttribute("no-infs-fp-math",
1039 CodeGenOpts.NoInfsFPMath ? "true" : "false");
1040 FuncAttrs.addAttribute("no-nans-fp-math",
1041 CodeGenOpts.NoNaNsFPMath ? "true" : "false");
1042 FuncAttrs.addAttribute("unsafe-fp-math",
1043 CodeGenOpts.UnsafeFPMath ? "true" : "false");
1044 FuncAttrs.addAttribute("use-soft-float",
1045 CodeGenOpts.SoftFloat ? "true" : "false");
Bill Wendlingc0dcc2d2013-02-15 21:30:01 +00001046 }
1047
Daniel Dunbara0a99e02009-02-02 23:43:58 +00001048 QualType RetTy = FI.getReturnType();
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001049 unsigned Index = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001050 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +00001051 switch (RetAI.getKind()) {
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001052 case ABIArgInfo::Extend:
Jakob Stoklund Olesen5baefa82013-05-29 03:57:23 +00001053 if (RetTy->hasSignedIntegerRepresentation())
1054 RetAttrs.addAttribute(llvm::Attribute::SExt);
1055 else if (RetTy->hasUnsignedIntegerRepresentation())
1056 RetAttrs.addAttribute(llvm::Attribute::ZExt);
Chris Lattner800588f2010-07-29 06:26:06 +00001057 break;
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001058 case ABIArgInfo::Direct:
Chris Lattner800588f2010-07-29 06:26:06 +00001059 case ABIArgInfo::Ignore:
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001060 break;
1061
Rafael Espindolab48280b2012-07-31 02:44:24 +00001062 case ABIArgInfo::Indirect: {
Bill Wendling0d583392012-10-15 20:36:26 +00001063 llvm::AttrBuilder SRETAttrs;
Bill Wendling72390b32012-12-20 19:27:06 +00001064 SRETAttrs.addAttribute(llvm::Attribute::StructRet);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001065 if (RetAI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001066 SRETAttrs.addAttribute(llvm::Attribute::InReg);
Bill Wendling603571a2012-10-10 07:36:56 +00001067 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001068 AttributeSet::get(getLLVMContext(), Index, SRETAttrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001069
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001070 ++Index;
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001071 // sret disables readnone and readonly
Bill Wendling72390b32012-12-20 19:27:06 +00001072 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1073 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001074 break;
Rafael Espindolab48280b2012-07-31 02:44:24 +00001075 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001076
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001077 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001078 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001079 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001080
Bill Wendling603571a2012-10-10 07:36:56 +00001081 if (RetAttrs.hasAttributes())
1082 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001083 AttributeSet::get(getLLVMContext(),
1084 llvm::AttributeSet::ReturnIndex,
1085 RetAttrs));
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001086
Mike Stump1eb44332009-09-09 15:08:12 +00001087 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
Daniel Dunbar88c2fa92009-02-03 05:31:23 +00001088 ie = FI.arg_end(); it != ie; ++it) {
1089 QualType ParamType = it->type;
1090 const ABIArgInfo &AI = it->info;
Bill Wendling0d583392012-10-15 20:36:26 +00001091 llvm::AttrBuilder Attrs;
Anton Korobeynikov1102f422009-04-04 00:49:24 +00001092
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001093 if (AI.getPaddingType()) {
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001094 if (AI.getPaddingInReg())
1095 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index,
1096 llvm::Attribute::InReg));
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001097 // Increment Index if there is padding.
1098 ++Index;
1099 }
1100
John McCalld8e10d22010-03-27 00:47:27 +00001101 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
1102 // have the corresponding parameter variable. It doesn't make
Daniel Dunbar7f6890e2011-02-10 18:10:07 +00001103 // sense to do it here because parameters are so messed up.
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001104 switch (AI.getKind()) {
Chris Lattner800588f2010-07-29 06:26:06 +00001105 case ABIArgInfo::Extend:
Douglas Gregor575a1c92011-05-20 16:38:50 +00001106 if (ParamType->isSignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001107 Attrs.addAttribute(llvm::Attribute::SExt);
Douglas Gregor575a1c92011-05-20 16:38:50 +00001108 else if (ParamType->isUnsignedIntegerOrEnumerationType())
Bill Wendling72390b32012-12-20 19:27:06 +00001109 Attrs.addAttribute(llvm::Attribute::ZExt);
Chris Lattner800588f2010-07-29 06:26:06 +00001110 // FALL THROUGH
1111 case ABIArgInfo::Direct:
Rafael Espindolab48280b2012-07-31 02:44:24 +00001112 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001113 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindolab48280b2012-07-31 02:44:24 +00001114
Chris Lattner800588f2010-07-29 06:26:06 +00001115 // FIXME: handle sseregparm someday...
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001116
Chris Lattner2acc6e32011-07-18 04:24:23 +00001117 if (llvm::StructType *STy =
Rafael Espindolab48280b2012-07-31 02:44:24 +00001118 dyn_cast<llvm::StructType>(AI.getCoerceToType())) {
1119 unsigned Extra = STy->getNumElements()-1; // 1 will be added below.
Bill Wendling603571a2012-10-10 07:36:56 +00001120 if (Attrs.hasAttributes())
Rafael Espindolab48280b2012-07-31 02:44:24 +00001121 for (unsigned I = 0; I < Extra; ++I)
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001122 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I,
1123 Attrs));
Rafael Espindolab48280b2012-07-31 02:44:24 +00001124 Index += Extra;
1125 }
Chris Lattner800588f2010-07-29 06:26:06 +00001126 break;
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001127
Daniel Dunbar11e383a2009-02-05 08:00:50 +00001128 case ABIArgInfo::Indirect:
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001129 if (AI.getInReg())
Bill Wendling72390b32012-12-20 19:27:06 +00001130 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindola0b4cc952012-10-19 05:04:37 +00001131
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001132 if (AI.getIndirectByVal())
Bill Wendling72390b32012-12-20 19:27:06 +00001133 Attrs.addAttribute(llvm::Attribute::ByVal);
Anders Carlsson0a8f8472009-09-16 15:53:40 +00001134
Bill Wendling603571a2012-10-10 07:36:56 +00001135 Attrs.addAlignmentAttr(AI.getIndirectAlign());
1136
Daniel Dunbar0ac86f02009-03-18 19:51:01 +00001137 // byval disables readnone and readonly.
Bill Wendling72390b32012-12-20 19:27:06 +00001138 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1139 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001140 break;
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001141
Daniel Dunbar11434922009-01-26 21:26:08 +00001142 case ABIArgInfo::Ignore:
1143 // Skip increment, no matching LLVM parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001144 continue;
Daniel Dunbar11434922009-01-26 21:26:08 +00001145
Daniel Dunbar56273772008-09-17 00:51:38 +00001146 case ABIArgInfo::Expand: {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001147 SmallVector<llvm::Type*, 8> types;
Mike Stumpf5408fe2009-05-16 07:57:57 +00001148 // FIXME: This is rather inefficient. Do we ever actually need to do
1149 // anything here? The result should be just reconstructed on the other
1150 // side, so extension should be a non-issue.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001151 getTypes().GetExpandedTypes(ParamType, types);
John McCall42e06112011-05-15 02:19:42 +00001152 Index += types.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00001153 continue;
1154 }
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001155 }
Mike Stump1eb44332009-09-09 15:08:12 +00001156
Bill Wendling603571a2012-10-10 07:36:56 +00001157 if (Attrs.hasAttributes())
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001158 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs));
Daniel Dunbar56273772008-09-17 00:51:38 +00001159 ++Index;
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001160 }
Bill Wendling603571a2012-10-10 07:36:56 +00001161 if (FuncAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001162 PAL.push_back(llvm::
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001163 AttributeSet::get(getLLVMContext(),
1164 llvm::AttributeSet::FunctionIndex,
1165 FuncAttrs));
Daniel Dunbar5323a4b2008-09-10 00:32:18 +00001166}
1167
John McCalld26bc762011-03-09 04:27:21 +00001168/// An argument came in as a promoted argument; demote it back to its
1169/// declared type.
1170static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
1171 const VarDecl *var,
1172 llvm::Value *value) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001173 llvm::Type *varType = CGF.ConvertType(var->getType());
John McCalld26bc762011-03-09 04:27:21 +00001174
1175 // This can happen with promotions that actually don't change the
1176 // underlying type, like the enum promotions.
1177 if (value->getType() == varType) return value;
1178
1179 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
1180 && "unexpected promotion type");
1181
1182 if (isa<llvm::IntegerType>(varType))
1183 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
1184
1185 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
1186}
1187
Daniel Dunbar88b53962009-02-02 22:03:45 +00001188void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
1189 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001190 const FunctionArgList &Args) {
John McCall0cfeb632009-07-28 01:00:58 +00001191 // If this is an implicit-return-zero function, go ahead and
1192 // initialize the return value. TODO: it might be nice to have
1193 // a more general mechanism for this that didn't require synthesized
1194 // return statements.
John McCallf5ebf9b2013-05-03 07:33:41 +00001195 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
John McCall0cfeb632009-07-28 01:00:58 +00001196 if (FD->hasImplicitReturnZero()) {
1197 QualType RetTy = FD->getResultType().getUnqualifiedType();
Chris Lattner2acc6e32011-07-18 04:24:23 +00001198 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
Owen Andersonc9c88b42009-07-31 20:28:54 +00001199 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
John McCall0cfeb632009-07-28 01:00:58 +00001200 Builder.CreateStore(Zero, ReturnValue);
1201 }
1202 }
1203
Mike Stumpf5408fe2009-05-16 07:57:57 +00001204 // FIXME: We no longer need the types from FunctionArgList; lift up and
1205 // simplify.
Daniel Dunbar5251afa2009-02-03 06:02:10 +00001206
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001207 // Emit allocs for param decls. Give the LLVM Argument nodes names.
1208 llvm::Function::arg_iterator AI = Fn->arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001209
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001210 // Name the struct return argument.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001211 if (CGM.ReturnTypeUsesSRet(FI)) {
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001212 AI->setName("agg.result");
Bill Wendling89530e42013-01-23 06:15:10 +00001213 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1214 AI->getArgNo() + 1,
1215 llvm::Attribute::NoAlias));
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001216 ++AI;
1217 }
Mike Stump1eb44332009-09-09 15:08:12 +00001218
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00001219 assert(FI.arg_size() == Args.size() &&
1220 "Mismatch between function signature & arguments.");
Devang Patel093ac462011-03-03 20:13:15 +00001221 unsigned ArgNo = 1;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001222 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
Devang Patel093ac462011-03-03 20:13:15 +00001223 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1224 i != e; ++i, ++info_it, ++ArgNo) {
John McCalld26bc762011-03-09 04:27:21 +00001225 const VarDecl *Arg = *i;
Daniel Dunbarb225be42009-02-03 05:59:18 +00001226 QualType Ty = info_it->type;
1227 const ABIArgInfo &ArgI = info_it->info;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001228
John McCalld26bc762011-03-09 04:27:21 +00001229 bool isPromoted =
1230 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
1231
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00001232 // Skip the dummy padding argument.
1233 if (ArgI.getPaddingType())
1234 ++AI;
1235
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001236 switch (ArgI.getKind()) {
Daniel Dunbar1f745982009-02-05 09:16:39 +00001237 case ABIArgInfo::Indirect: {
Chris Lattnerce700162010-06-28 23:44:11 +00001238 llvm::Value *V = AI;
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001239
John McCall9d232c82013-03-07 21:37:08 +00001240 if (!hasScalarEvaluationKind(Ty)) {
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001241 // Aggregates and complex variables are accessed by reference. All we
1242 // need to do is realign the value, if requested
1243 if (ArgI.getIndirectRealign()) {
1244 llvm::Value *AlignedTemp = CreateMemTemp(Ty, "coerce");
1245
1246 // Copy from the incoming argument pointer to the temporary with the
1247 // appropriate alignment.
1248 //
1249 // FIXME: We should have a common utility for generating an aggregate
1250 // copy.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001251 llvm::Type *I8PtrTy = Builder.getInt8PtrTy();
Ken Dyckfe710082011-01-19 01:58:38 +00001252 CharUnits Size = getContext().getTypeSizeInChars(Ty);
NAKAMURA Takumic95a8fc2011-03-10 14:02:21 +00001253 llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy);
1254 llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy);
1255 Builder.CreateMemCpy(Dst,
1256 Src,
Ken Dyckfe710082011-01-19 01:58:38 +00001257 llvm::ConstantInt::get(IntPtrTy,
1258 Size.getQuantity()),
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +00001259 ArgI.getIndirectAlign(),
1260 false);
Daniel Dunbarcf3b6f22010-09-16 20:42:02 +00001261 V = AlignedTemp;
1262 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00001263 } else {
1264 // Load scalar value from indirect argument.
Ken Dyckfe710082011-01-19 01:58:38 +00001265 CharUnits Alignment = getContext().getTypeAlignInChars(Ty);
1266 V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty);
John McCalld26bc762011-03-09 04:27:21 +00001267
1268 if (isPromoted)
1269 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001270 }
Devang Patel093ac462011-03-03 20:13:15 +00001271 EmitParmDecl(*Arg, V, ArgNo);
Daniel Dunbar1f745982009-02-05 09:16:39 +00001272 break;
1273 }
Anton Korobeynikovcc6fa882009-06-06 09:36:29 +00001274
1275 case ABIArgInfo::Extend:
Daniel Dunbar46327aa2009-02-03 06:17:37 +00001276 case ABIArgInfo::Direct: {
Akira Hatanaka4ba3fd42012-01-09 19:08:06 +00001277
Chris Lattner800588f2010-07-29 06:26:06 +00001278 // If we have the trivial case, handle it with no muss and fuss.
1279 if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00001280 ArgI.getCoerceToType() == ConvertType(Ty) &&
1281 ArgI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001282 assert(AI != Fn->arg_end() && "Argument mismatch!");
1283 llvm::Value *V = AI;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001284
Bill Wendlinga6375562012-10-16 05:23:44 +00001285 if (Arg->getType().isRestrictQualified())
Bill Wendling89530e42013-01-23 06:15:10 +00001286 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1287 AI->getArgNo() + 1,
1288 llvm::Attribute::NoAlias));
John McCalld8e10d22010-03-27 00:47:27 +00001289
Chris Lattnerb13eab92011-07-20 06:29:00 +00001290 // Ensure the argument is the correct type.
1291 if (V->getType() != ArgI.getCoerceToType())
1292 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
1293
John McCalld26bc762011-03-09 04:27:21 +00001294 if (isPromoted)
1295 V = emitArgumentDemotion(*this, Arg, V);
Rafael Espindola8b8a09e2012-11-29 16:09:03 +00001296
1297 // Because of merging of function types from multiple decls it is
1298 // possible for the type of an argument to not match the corresponding
1299 // type in the function type. Since we are codegening the callee
1300 // in here, add a cast to the argument type.
1301 llvm::Type *LTy = ConvertType(Arg->getType());
1302 if (V->getType() != LTy)
1303 V = Builder.CreateBitCast(V, LTy);
1304
Devang Patel093ac462011-03-03 20:13:15 +00001305 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001306 break;
Daniel Dunbar8b979d92009-02-10 00:06:49 +00001307 }
Mike Stump1eb44332009-09-09 15:08:12 +00001308
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001309 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001310
Chris Lattnerdeabde22010-07-28 18:24:28 +00001311 // The alignment we need to use is the max of the requested alignment for
1312 // the argument plus the alignment required by our access code below.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001313 unsigned AlignmentToUse =
Micah Villmow25a6a842012-10-08 16:25:52 +00001314 CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType());
Chris Lattnerdeabde22010-07-28 18:24:28 +00001315 AlignmentToUse = std::max(AlignmentToUse,
1316 (unsigned)getContext().getDeclAlign(Arg).getQuantity());
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001317
Chris Lattnerdeabde22010-07-28 18:24:28 +00001318 Alloca->setAlignment(AlignmentToUse);
Chris Lattner121b3fa2010-07-05 20:21:00 +00001319 llvm::Value *V = Alloca;
Chris Lattner117e3f42010-07-30 04:02:24 +00001320 llvm::Value *Ptr = V; // Pointer to store into.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001321
Chris Lattner117e3f42010-07-30 04:02:24 +00001322 // If the value is offset in memory, apply the offset now.
1323 if (unsigned Offs = ArgI.getDirectOffset()) {
1324 Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy());
1325 Ptr = Builder.CreateConstGEP1_32(Ptr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001326 Ptr = Builder.CreateBitCast(Ptr,
Chris Lattner117e3f42010-07-30 04:02:24 +00001327 llvm::PointerType::getUnqual(ArgI.getCoerceToType()));
1328 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001329
Chris Lattner309c59f2010-06-29 00:06:42 +00001330 // If the coerce-to type is a first class aggregate, we flatten it and
1331 // pass the elements. Either way is semantically identical, but fast-isel
1332 // and the optimizer generally likes scalar values better than FCAs.
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001333 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
1334 if (STy && STy->getNumElements() > 1) {
Micah Villmow25a6a842012-10-08 16:25:52 +00001335 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001336 llvm::Type *DstTy =
1337 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Micah Villmow25a6a842012-10-08 16:25:52 +00001338 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001339
Evgeniy Stepanova6ce20e2012-02-10 09:30:15 +00001340 if (SrcSize <= DstSize) {
1341 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
1342
1343 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1344 assert(AI != Fn->arg_end() && "Argument mismatch!");
1345 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1346 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i);
1347 Builder.CreateStore(AI++, EltPtr);
1348 }
1349 } else {
1350 llvm::AllocaInst *TempAlloca =
1351 CreateTempAlloca(ArgI.getCoerceToType(), "coerce");
1352 TempAlloca->setAlignment(AlignmentToUse);
1353 llvm::Value *TempV = TempAlloca;
1354
1355 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1356 assert(AI != Fn->arg_end() && "Argument mismatch!");
1357 AI->setName(Arg->getName() + ".coerce" + Twine(i));
1358 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i);
1359 Builder.CreateStore(AI++, EltPtr);
1360 }
1361
1362 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse);
Chris Lattner309c59f2010-06-29 00:06:42 +00001363 }
1364 } else {
1365 // Simple case, just do a coerced store of the argument into the alloca.
1366 assert(AI != Fn->arg_end() && "Argument mismatch!");
Chris Lattner225e2862010-06-29 00:14:52 +00001367 AI->setName(Arg->getName() + ".coerce");
Chris Lattner117e3f42010-07-30 04:02:24 +00001368 CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this);
Chris Lattner309c59f2010-06-29 00:06:42 +00001369 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001370
1371
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001372 // Match to what EmitParmDecl is expecting for this type.
John McCall9d232c82013-03-07 21:37:08 +00001373 if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001374 V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty);
John McCalld26bc762011-03-09 04:27:21 +00001375 if (isPromoted)
1376 V = emitArgumentDemotion(*this, Arg, V);
Daniel Dunbar8b29a382009-02-04 07:22:24 +00001377 }
Devang Patel093ac462011-03-03 20:13:15 +00001378 EmitParmDecl(*Arg, V, ArgNo);
Chris Lattnerce700162010-06-28 23:44:11 +00001379 continue; // Skip ++AI increment, already done.
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00001380 }
Chris Lattner800588f2010-07-29 06:26:06 +00001381
1382 case ABIArgInfo::Expand: {
1383 // If this structure was expanded into multiple arguments then
1384 // we need to create a temporary and reconstruct it from the
1385 // arguments.
Eli Friedman1bb94a42011-11-03 21:39:02 +00001386 llvm::AllocaInst *Alloca = CreateMemTemp(Ty);
Eli Friedman6da2c712011-12-03 04:14:32 +00001387 CharUnits Align = getContext().getDeclAlign(Arg);
1388 Alloca->setAlignment(Align.getQuantity());
1389 LValue LV = MakeAddrLValue(Alloca, Ty, Align);
Eli Friedman1bb94a42011-11-03 21:39:02 +00001390 llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI);
1391 EmitParmDecl(*Arg, Alloca, ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001392
1393 // Name the arguments used in expansion and increment AI.
1394 unsigned Index = 0;
1395 for (; AI != End; ++AI, ++Index)
Chris Lattner5f9e2722011-07-23 10:55:15 +00001396 AI->setName(Arg->getName() + "." + Twine(Index));
Chris Lattner800588f2010-07-29 06:26:06 +00001397 continue;
1398 }
1399
1400 case ABIArgInfo::Ignore:
1401 // Initialize the local variable appropriately.
John McCall9d232c82013-03-07 21:37:08 +00001402 if (!hasScalarEvaluationKind(Ty))
Devang Patel093ac462011-03-03 20:13:15 +00001403 EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001404 else
Devang Patel093ac462011-03-03 20:13:15 +00001405 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())),
1406 ArgNo);
Chris Lattner800588f2010-07-29 06:26:06 +00001407
1408 // Skip increment, no matching LLVM parameter.
1409 continue;
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00001410 }
Daniel Dunbar56273772008-09-17 00:51:38 +00001411
1412 ++AI;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001413 }
1414 assert(AI == Fn->arg_end() && "Argument mismatch!");
1415}
1416
John McCall77fe6cd2012-01-29 07:46:59 +00001417static void eraseUnusedBitCasts(llvm::Instruction *insn) {
1418 while (insn->use_empty()) {
1419 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
1420 if (!bitcast) return;
1421
1422 // This is "safe" because we would have used a ConstantExpr otherwise.
1423 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
1424 bitcast->eraseFromParent();
1425 }
1426}
1427
John McCallf85e1932011-06-15 23:02:42 +00001428/// Try to emit a fused autorelease of a return result.
1429static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF,
1430 llvm::Value *result) {
1431 // We must be immediately followed the cast.
1432 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
1433 if (BB->empty()) return 0;
1434 if (&BB->back() != result) return 0;
1435
Chris Lattner2acc6e32011-07-18 04:24:23 +00001436 llvm::Type *resultType = result->getType();
John McCallf85e1932011-06-15 23:02:42 +00001437
1438 // result is in a BasicBlock and is therefore an Instruction.
1439 llvm::Instruction *generator = cast<llvm::Instruction>(result);
1440
Chris Lattner5f9e2722011-07-23 10:55:15 +00001441 SmallVector<llvm::Instruction*,4> insnsToKill;
John McCallf85e1932011-06-15 23:02:42 +00001442
1443 // Look for:
1444 // %generator = bitcast %type1* %generator2 to %type2*
1445 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
1446 // We would have emitted this as a constant if the operand weren't
1447 // an Instruction.
1448 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
1449
1450 // Require the generator to be immediately followed by the cast.
1451 if (generator->getNextNode() != bitcast)
1452 return 0;
1453
1454 insnsToKill.push_back(bitcast);
1455 }
1456
1457 // Look for:
1458 // %generator = call i8* @objc_retain(i8* %originalResult)
1459 // or
1460 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
1461 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
1462 if (!call) return 0;
1463
1464 bool doRetainAutorelease;
1465
1466 if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) {
1467 doRetainAutorelease = true;
1468 } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints()
1469 .objc_retainAutoreleasedReturnValue) {
1470 doRetainAutorelease = false;
1471
John McCallf9fdcc02012-09-07 23:30:50 +00001472 // If we emitted an assembly marker for this call (and the
1473 // ARCEntrypoints field should have been set if so), go looking
1474 // for that call. If we can't find it, we can't do this
1475 // optimization. But it should always be the immediately previous
1476 // instruction, unless we needed bitcasts around the call.
1477 if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) {
1478 llvm::Instruction *prev = call->getPrevNode();
1479 assert(prev);
1480 if (isa<llvm::BitCastInst>(prev)) {
1481 prev = prev->getPrevNode();
1482 assert(prev);
1483 }
1484 assert(isa<llvm::CallInst>(prev));
1485 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
1486 CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker);
1487 insnsToKill.push_back(prev);
1488 }
John McCallf85e1932011-06-15 23:02:42 +00001489 } else {
1490 return 0;
1491 }
1492
1493 result = call->getArgOperand(0);
1494 insnsToKill.push_back(call);
1495
1496 // Keep killing bitcasts, for sanity. Note that we no longer care
1497 // about precise ordering as long as there's exactly one use.
1498 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
1499 if (!bitcast->hasOneUse()) break;
1500 insnsToKill.push_back(bitcast);
1501 result = bitcast->getOperand(0);
1502 }
1503
1504 // Delete all the unnecessary instructions, from latest to earliest.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001505 for (SmallVectorImpl<llvm::Instruction*>::iterator
John McCallf85e1932011-06-15 23:02:42 +00001506 i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i)
1507 (*i)->eraseFromParent();
1508
1509 // Do the fused retain/autorelease if we were asked to.
1510 if (doRetainAutorelease)
1511 result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
1512
1513 // Cast back to the result type.
1514 return CGF.Builder.CreateBitCast(result, resultType);
1515}
1516
John McCall77fe6cd2012-01-29 07:46:59 +00001517/// If this is a +1 of the value of an immutable 'self', remove it.
1518static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF,
1519 llvm::Value *result) {
1520 // This is only applicable to a method with an immutable 'self'.
John McCallbd9b65a2012-07-31 00:33:55 +00001521 const ObjCMethodDecl *method =
1522 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
John McCall77fe6cd2012-01-29 07:46:59 +00001523 if (!method) return 0;
1524 const VarDecl *self = method->getSelfDecl();
1525 if (!self->getType().isConstQualified()) return 0;
1526
1527 // Look for a retain call.
1528 llvm::CallInst *retainCall =
1529 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
1530 if (!retainCall ||
1531 retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain)
1532 return 0;
1533
1534 // Look for an ordinary load of 'self'.
1535 llvm::Value *retainedValue = retainCall->getArgOperand(0);
1536 llvm::LoadInst *load =
1537 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
1538 if (!load || load->isAtomic() || load->isVolatile() ||
1539 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self))
1540 return 0;
1541
1542 // Okay! Burn it all down. This relies for correctness on the
1543 // assumption that the retain is emitted as part of the return and
1544 // that thereafter everything is used "linearly".
1545 llvm::Type *resultType = result->getType();
1546 eraseUnusedBitCasts(cast<llvm::Instruction>(result));
1547 assert(retainCall->use_empty());
1548 retainCall->eraseFromParent();
1549 eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
1550
1551 return CGF.Builder.CreateBitCast(load, resultType);
1552}
1553
John McCallf85e1932011-06-15 23:02:42 +00001554/// Emit an ARC autorelease of the result of a function.
John McCall77fe6cd2012-01-29 07:46:59 +00001555///
1556/// \return the value to actually return from the function
John McCallf85e1932011-06-15 23:02:42 +00001557static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF,
1558 llvm::Value *result) {
John McCall77fe6cd2012-01-29 07:46:59 +00001559 // If we're returning 'self', kill the initial retain. This is a
1560 // heuristic attempt to "encourage correctness" in the really unfortunate
1561 // case where we have a return of self during a dealloc and we desperately
1562 // need to avoid the possible autorelease.
1563 if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
1564 return self;
1565
John McCallf85e1932011-06-15 23:02:42 +00001566 // At -O0, try to emit a fused retain/autorelease.
1567 if (CGF.shouldUseFusedARCCalls())
1568 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
1569 return fused;
1570
1571 return CGF.EmitARCAutoreleaseReturnValue(result);
1572}
1573
John McCallf48f7962012-01-29 02:35:02 +00001574/// Heuristically search for a dominating store to the return-value slot.
1575static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
1576 // If there are multiple uses of the return-value slot, just check
1577 // for something immediately preceding the IP. Sometimes this can
1578 // happen with how we generate implicit-returns; it can also happen
1579 // with noreturn cleanups.
1580 if (!CGF.ReturnValue->hasOneUse()) {
1581 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1582 if (IP->empty()) return 0;
1583 llvm::StoreInst *store = dyn_cast<llvm::StoreInst>(&IP->back());
1584 if (!store) return 0;
1585 if (store->getPointerOperand() != CGF.ReturnValue) return 0;
1586 assert(!store->isAtomic() && !store->isVolatile()); // see below
1587 return store;
1588 }
1589
1590 llvm::StoreInst *store =
1591 dyn_cast<llvm::StoreInst>(CGF.ReturnValue->use_back());
1592 if (!store) return 0;
1593
1594 // These aren't actually possible for non-coerced returns, and we
1595 // only care about non-coerced returns on this code path.
1596 assert(!store->isAtomic() && !store->isVolatile());
1597
1598 // Now do a first-and-dirty dominance check: just walk up the
1599 // single-predecessors chain from the current insertion point.
1600 llvm::BasicBlock *StoreBB = store->getParent();
1601 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
1602 while (IP != StoreBB) {
1603 if (!(IP = IP->getSinglePredecessor()))
1604 return 0;
1605 }
1606
1607 // Okay, the store's basic block dominates the insertion point; we
1608 // can do our thing.
1609 return store;
1610}
1611
Manman Ren63fd4082013-03-20 16:59:38 +00001612/// Check whether 'this' argument of a callsite matches 'this' of the caller.
1613static bool checkThisPointer(llvm::Value *ThisArg, llvm::Value *This) {
1614 if (ThisArg == This)
1615 return true;
1616 // Check whether ThisArg is a bitcast of This.
1617 llvm::BitCastInst *Bitcast;
1618 if ((Bitcast = dyn_cast<llvm::BitCastInst>(ThisArg)) &&
1619 Bitcast->getOperand(0) == This)
1620 return true;
1621 return false;
1622}
1623
Adrian Prantlfa6b0792013-05-02 17:30:20 +00001624void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
1625 bool EmitRetDbgLoc) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001626 // Functions with no result always return void.
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001627 if (ReturnValue == 0) {
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001628 Builder.CreateRetVoid();
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001629 return;
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00001630 }
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001631
Dan Gohman4751a532010-07-20 20:13:52 +00001632 llvm::DebugLoc RetDbgLoc;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001633 llvm::Value *RV = 0;
1634 QualType RetTy = FI.getReturnType();
1635 const ABIArgInfo &RetAI = FI.getReturnInfo();
1636
1637 switch (RetAI.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001638 case ABIArgInfo::Indirect: {
John McCall9d232c82013-03-07 21:37:08 +00001639 switch (getEvaluationKind(RetTy)) {
1640 case TEK_Complex: {
1641 ComplexPairTy RT =
1642 EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy));
1643 EmitStoreOfComplex(RT,
1644 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
1645 /*isInit*/ true);
1646 break;
1647 }
1648 case TEK_Aggregate:
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001649 // Do nothing; aggregrates get evaluated directly into the destination.
John McCall9d232c82013-03-07 21:37:08 +00001650 break;
1651 case TEK_Scalar:
1652 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
1653 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
1654 /*isInit*/ true);
1655 break;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001656 }
1657 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001658 }
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001659
1660 case ABIArgInfo::Extend:
Chris Lattner800588f2010-07-29 06:26:06 +00001661 case ABIArgInfo::Direct:
Chris Lattner117e3f42010-07-30 04:02:24 +00001662 if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
1663 RetAI.getDirectOffset() == 0) {
Chris Lattner800588f2010-07-29 06:26:06 +00001664 // The internal return value temp always will have pointer-to-return-type
1665 // type, just do a load.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001666
John McCallf48f7962012-01-29 02:35:02 +00001667 // If there is a dominating store to ReturnValue, we can elide
1668 // the load, zap the store, and usually zap the alloca.
1669 if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) {
Adrian Prantl7c731f52013-05-30 18:12:23 +00001670 // Reuse the debug location from the store unless there is
1671 // cleanup code to be emitted between the store and return
1672 // instruction.
1673 if (EmitRetDbgLoc && !AutoreleaseResult)
Adrian Prantlfa6b0792013-05-02 17:30:20 +00001674 RetDbgLoc = SI->getDebugLoc();
Chris Lattner800588f2010-07-29 06:26:06 +00001675 // Get the stored value and nuke the now-dead store.
Chris Lattner800588f2010-07-29 06:26:06 +00001676 RV = SI->getValueOperand();
1677 SI->eraseFromParent();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001678
Chris Lattner800588f2010-07-29 06:26:06 +00001679 // If that was the only use of the return value, nuke it as well now.
1680 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) {
1681 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent();
1682 ReturnValue = 0;
1683 }
John McCallf48f7962012-01-29 02:35:02 +00001684
1685 // Otherwise, we have to do a simple load.
1686 } else {
1687 RV = Builder.CreateLoad(ReturnValue);
Chris Lattner35b21b82010-06-27 01:06:27 +00001688 }
Chris Lattner800588f2010-07-29 06:26:06 +00001689 } else {
Chris Lattner117e3f42010-07-30 04:02:24 +00001690 llvm::Value *V = ReturnValue;
1691 // If the value is offset in memory, apply the offset now.
1692 if (unsigned Offs = RetAI.getDirectOffset()) {
1693 V = Builder.CreateBitCast(V, Builder.getInt8PtrTy());
1694 V = Builder.CreateConstGEP1_32(V, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001695 V = Builder.CreateBitCast(V,
Chris Lattner117e3f42010-07-30 04:02:24 +00001696 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
1697 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001698
Chris Lattner117e3f42010-07-30 04:02:24 +00001699 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
Chris Lattner35b21b82010-06-27 01:06:27 +00001700 }
John McCallf85e1932011-06-15 23:02:42 +00001701
1702 // In ARC, end functions that return a retainable type with a call
1703 // to objc_autoreleaseReturnValue.
1704 if (AutoreleaseResult) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001705 assert(getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001706 !FI.isReturnsRetained() &&
1707 RetTy->isObjCRetainableType());
1708 RV = emitAutoreleaseOfResult(*this, RV);
1709 }
1710
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001711 break;
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001712
Chris Lattner800588f2010-07-29 06:26:06 +00001713 case ABIArgInfo::Ignore:
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001714 break;
1715
1716 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00001717 llvm_unreachable("Invalid ABI kind for return argument");
Chris Lattnerc6e6dd22010-06-26 23:13:19 +00001718 }
1719
Manman Ren63fd4082013-03-20 16:59:38 +00001720 // If this function returns 'this', the last instruction is a CallInst
1721 // that returns 'this', and 'this' argument of the CallInst points to
1722 // the same object as CXXThisValue, use the return value from the CallInst.
1723 // We will not need to keep 'this' alive through the callsite. It also enables
1724 // optimizations in the backend, such as tail call optimization.
Manman Ren94d46b52013-03-26 18:29:15 +00001725 if (CalleeWithThisReturn && CGM.getCXXABI().HasThisReturn(CurGD)) {
Manman Ren63fd4082013-03-20 16:59:38 +00001726 llvm::BasicBlock *IP = Builder.GetInsertBlock();
1727 llvm::CallInst *Callsite;
1728 if (!IP->empty() && (Callsite = dyn_cast<llvm::CallInst>(&IP->back())) &&
1729 Callsite->getCalledFunction() == CalleeWithThisReturn &&
1730 checkThisPointer(Callsite->getOperand(0), CXXThisValue))
1731 RV = Builder.CreateBitCast(Callsite, RetAI.getCoerceToType());
1732 }
Daniel Dunbar21fcc8f2010-06-30 21:27:58 +00001733 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid();
Devang Pateld3f265d2010-07-21 18:08:50 +00001734 if (!RetDbgLoc.isUnknown())
1735 Ret->setDebugLoc(RetDbgLoc);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001736}
1737
John McCall413ebdb2011-03-11 20:59:21 +00001738void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
1739 const VarDecl *param) {
John McCall27360712010-05-26 22:34:26 +00001740 // StartFunction converted the ABI-lowered parameter(s) into a
1741 // local alloca. We need to turn that into an r-value suitable
1742 // for EmitCall.
John McCall413ebdb2011-03-11 20:59:21 +00001743 llvm::Value *local = GetAddrOfLocalVar(param);
John McCall27360712010-05-26 22:34:26 +00001744
John McCall413ebdb2011-03-11 20:59:21 +00001745 QualType type = param->getType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001746
John McCall27360712010-05-26 22:34:26 +00001747 // For the most part, we just need to load the alloca, except:
1748 // 1) aggregate r-values are actually pointers to temporaries, and
John McCall9d232c82013-03-07 21:37:08 +00001749 // 2) references to non-scalars are pointers directly to the aggregate.
1750 // I don't know why references to scalars are different here.
John McCall413ebdb2011-03-11 20:59:21 +00001751 if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
John McCall9d232c82013-03-07 21:37:08 +00001752 if (!hasScalarEvaluationKind(ref->getPointeeType()))
John McCall413ebdb2011-03-11 20:59:21 +00001753 return args.add(RValue::getAggregate(local), type);
John McCall27360712010-05-26 22:34:26 +00001754
1755 // Locals which are references to scalars are represented
1756 // with allocas holding the pointer.
John McCall413ebdb2011-03-11 20:59:21 +00001757 return args.add(RValue::get(Builder.CreateLoad(local)), type);
John McCall27360712010-05-26 22:34:26 +00001758 }
1759
John McCall9d232c82013-03-07 21:37:08 +00001760 args.add(convertTempToRValue(local, type), type);
John McCall27360712010-05-26 22:34:26 +00001761}
1762
John McCallf85e1932011-06-15 23:02:42 +00001763static bool isProvablyNull(llvm::Value *addr) {
1764 return isa<llvm::ConstantPointerNull>(addr);
1765}
1766
1767static bool isProvablyNonNull(llvm::Value *addr) {
1768 return isa<llvm::AllocaInst>(addr);
1769}
1770
1771/// Emit the actual writing-back of a writeback.
1772static void emitWriteback(CodeGenFunction &CGF,
1773 const CallArgList::Writeback &writeback) {
John McCallb6a60792013-03-23 02:35:54 +00001774 const LValue &srcLV = writeback.Source;
1775 llvm::Value *srcAddr = srcLV.getAddress();
John McCallf85e1932011-06-15 23:02:42 +00001776 assert(!isProvablyNull(srcAddr) &&
1777 "shouldn't have writeback for provably null argument");
1778
1779 llvm::BasicBlock *contBB = 0;
1780
1781 // If the argument wasn't provably non-null, we need to null check
1782 // before doing the store.
1783 bool provablyNonNull = isProvablyNonNull(srcAddr);
1784 if (!provablyNonNull) {
1785 llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
1786 contBB = CGF.createBasicBlock("icr.done");
1787
1788 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1789 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
1790 CGF.EmitBlock(writebackBB);
1791 }
1792
1793 // Load the value to writeback.
1794 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
1795
1796 // Cast it back, in case we're writing an id to a Foo* or something.
1797 value = CGF.Builder.CreateBitCast(value,
1798 cast<llvm::PointerType>(srcAddr->getType())->getElementType(),
1799 "icr.writeback-cast");
1800
1801 // Perform the writeback.
John McCallb6a60792013-03-23 02:35:54 +00001802
1803 // If we have a "to use" value, it's something we need to emit a use
1804 // of. This has to be carefully threaded in: if it's done after the
1805 // release it's potentially undefined behavior (and the optimizer
1806 // will ignore it), and if it happens before the retain then the
1807 // optimizer could move the release there.
1808 if (writeback.ToUse) {
1809 assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong);
1810
1811 // Retain the new value. No need to block-copy here: the block's
1812 // being passed up the stack.
1813 value = CGF.EmitARCRetainNonBlock(value);
1814
1815 // Emit the intrinsic use here.
1816 CGF.EmitARCIntrinsicUse(writeback.ToUse);
1817
1818 // Load the old value (primitively).
1819 llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV);
1820
1821 // Put the new value in place (primitively).
1822 CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
1823
1824 // Release the old value.
1825 CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
1826
1827 // Otherwise, we can just do a normal lvalue store.
1828 } else {
1829 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
1830 }
John McCallf85e1932011-06-15 23:02:42 +00001831
1832 // Jump to the continuation block.
1833 if (!provablyNonNull)
1834 CGF.EmitBlock(contBB);
1835}
1836
1837static void emitWritebacks(CodeGenFunction &CGF,
1838 const CallArgList &args) {
1839 for (CallArgList::writeback_iterator
1840 i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i)
1841 emitWriteback(CGF, *i);
1842}
1843
John McCallb6a60792013-03-23 02:35:54 +00001844static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
1845 if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens()))
1846 if (uop->getOpcode() == UO_AddrOf)
1847 return uop->getSubExpr();
1848 return 0;
1849}
1850
John McCallf85e1932011-06-15 23:02:42 +00001851/// Emit an argument that's being passed call-by-writeback. That is,
1852/// we are passing the address of
1853static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
1854 const ObjCIndirectCopyRestoreExpr *CRE) {
John McCallb6a60792013-03-23 02:35:54 +00001855 LValue srcLV;
1856
1857 // Make an optimistic effort to emit the address as an l-value.
1858 // This can fail if the the argument expression is more complicated.
1859 if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
1860 srcLV = CGF.EmitLValue(lvExpr);
1861
1862 // Otherwise, just emit it as a scalar.
1863 } else {
1864 llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr());
1865
1866 QualType srcAddrType =
1867 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
1868 srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType);
1869 }
1870 llvm::Value *srcAddr = srcLV.getAddress();
John McCallf85e1932011-06-15 23:02:42 +00001871
1872 // The dest and src types don't necessarily match in LLVM terms
1873 // because of the crazy ObjC compatibility rules.
1874
Chris Lattner2acc6e32011-07-18 04:24:23 +00001875 llvm::PointerType *destType =
John McCallf85e1932011-06-15 23:02:42 +00001876 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
1877
1878 // If the address is a constant null, just pass the appropriate null.
1879 if (isProvablyNull(srcAddr)) {
1880 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
1881 CRE->getType());
1882 return;
1883 }
1884
John McCallf85e1932011-06-15 23:02:42 +00001885 // Create the temporary.
1886 llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(),
1887 "icr.temp");
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001888 // Loading an l-value can introduce a cleanup if the l-value is __weak,
1889 // and that cleanup will be conditional if we can't prove that the l-value
1890 // isn't null, so we need to register a dominating point so that the cleanups
1891 // system will make valid IR.
1892 CodeGenFunction::ConditionalEvaluation condEval(CGF);
1893
John McCallf85e1932011-06-15 23:02:42 +00001894 // Zero-initialize it if we're not doing a copy-initialization.
1895 bool shouldCopy = CRE->shouldCopy();
1896 if (!shouldCopy) {
1897 llvm::Value *null =
1898 llvm::ConstantPointerNull::get(
1899 cast<llvm::PointerType>(destType->getElementType()));
1900 CGF.Builder.CreateStore(null, temp);
1901 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001902
John McCallf85e1932011-06-15 23:02:42 +00001903 llvm::BasicBlock *contBB = 0;
John McCallb6a60792013-03-23 02:35:54 +00001904 llvm::BasicBlock *originBB = 0;
John McCallf85e1932011-06-15 23:02:42 +00001905
1906 // If the address is *not* known to be non-null, we need to switch.
1907 llvm::Value *finalArgument;
1908
1909 bool provablyNonNull = isProvablyNonNull(srcAddr);
1910 if (provablyNonNull) {
1911 finalArgument = temp;
1912 } else {
1913 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1914
1915 finalArgument = CGF.Builder.CreateSelect(isNull,
1916 llvm::ConstantPointerNull::get(destType),
1917 temp, "icr.argument");
1918
1919 // If we need to copy, then the load has to be conditional, which
1920 // means we need control flow.
1921 if (shouldCopy) {
John McCallb6a60792013-03-23 02:35:54 +00001922 originBB = CGF.Builder.GetInsertBlock();
John McCallf85e1932011-06-15 23:02:42 +00001923 contBB = CGF.createBasicBlock("icr.cont");
1924 llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy");
1925 CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
1926 CGF.EmitBlock(copyBB);
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001927 condEval.begin(CGF);
John McCallf85e1932011-06-15 23:02:42 +00001928 }
1929 }
1930
John McCallb6a60792013-03-23 02:35:54 +00001931 llvm::Value *valueToUse = 0;
1932
John McCallf85e1932011-06-15 23:02:42 +00001933 // Perform a copy if necessary.
1934 if (shouldCopy) {
John McCall545d9962011-06-25 02:11:03 +00001935 RValue srcRV = CGF.EmitLoadOfLValue(srcLV);
John McCallf85e1932011-06-15 23:02:42 +00001936 assert(srcRV.isScalar());
1937
1938 llvm::Value *src = srcRV.getScalarVal();
1939 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
1940 "icr.cast");
1941
1942 // Use an ordinary store, not a store-to-lvalue.
1943 CGF.Builder.CreateStore(src, temp);
John McCallb6a60792013-03-23 02:35:54 +00001944
1945 // If optimization is enabled, and the value was held in a
1946 // __strong variable, we need to tell the optimizer that this
1947 // value has to stay alive until we're doing the store back.
1948 // This is because the temporary is effectively unretained,
1949 // and so otherwise we can violate the high-level semantics.
1950 if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 &&
1951 srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) {
1952 valueToUse = src;
1953 }
John McCallf85e1932011-06-15 23:02:42 +00001954 }
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001955
John McCallf85e1932011-06-15 23:02:42 +00001956 // Finish the control flow if we needed it.
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001957 if (shouldCopy && !provablyNonNull) {
John McCallb6a60792013-03-23 02:35:54 +00001958 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
John McCallf85e1932011-06-15 23:02:42 +00001959 CGF.EmitBlock(contBB);
John McCallb6a60792013-03-23 02:35:54 +00001960
1961 // Make a phi for the value to intrinsically use.
1962 if (valueToUse) {
1963 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
1964 "icr.to-use");
1965 phiToUse->addIncoming(valueToUse, copyBB);
1966 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
1967 originBB);
1968 valueToUse = phiToUse;
1969 }
1970
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00001971 condEval.end(CGF);
1972 }
John McCallf85e1932011-06-15 23:02:42 +00001973
John McCallb6a60792013-03-23 02:35:54 +00001974 args.addWriteback(srcLV, temp, valueToUse);
John McCallf85e1932011-06-15 23:02:42 +00001975 args.add(RValue::get(finalArgument), CRE->getType());
1976}
1977
John McCall413ebdb2011-03-11 20:59:21 +00001978void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
1979 QualType type) {
John McCallf85e1932011-06-15 23:02:42 +00001980 if (const ObjCIndirectCopyRestoreExpr *CRE
1981 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
Richard Smith7edf9e32012-11-01 22:30:59 +00001982 assert(getLangOpts().ObjCAutoRefCount);
John McCallf85e1932011-06-15 23:02:42 +00001983 assert(getContext().hasSameType(E->getType(), type));
1984 return emitWritebackArg(*this, args, CRE);
1985 }
1986
John McCall8affed52011-08-26 18:42:59 +00001987 assert(type->isReferenceType() == E->isGLValue() &&
1988 "reference binding to unmaterialized r-value!");
1989
John McCallcec52f02011-08-26 21:08:13 +00001990 if (E->isGLValue()) {
1991 assert(E->getObjectKind() == OK_Ordinary);
John McCall413ebdb2011-03-11 20:59:21 +00001992 return args.add(EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0),
1993 type);
John McCallcec52f02011-08-26 21:08:13 +00001994 }
Mike Stump1eb44332009-09-09 15:08:12 +00001995
John McCall9d232c82013-03-07 21:37:08 +00001996 if (hasAggregateEvaluationKind(type) &&
Eli Friedman70cbd2a2011-06-15 18:26:32 +00001997 isa<ImplicitCastExpr>(E) &&
Eli Friedman55d48482011-05-26 00:10:27 +00001998 cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
1999 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
2000 assert(L.isSimple());
Eli Friedman51f51202011-12-03 03:08:40 +00002001 args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true);
Eli Friedman55d48482011-05-26 00:10:27 +00002002 return;
2003 }
2004
John McCall413ebdb2011-03-11 20:59:21 +00002005 args.add(EmitAnyExprToTemp(E), type);
Anders Carlsson0139bb92009-04-08 20:47:54 +00002006}
2007
Dan Gohmanb49bd272012-02-16 00:57:37 +00002008// In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2009// optimizer it can aggressively ignore unwind edges.
2010void
2011CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
2012 if (CGM.getCodeGenOpts().OptimizationLevel != 0 &&
2013 !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
2014 Inst->setMetadata("clang.arc.no_objc_arc_exceptions",
2015 CGM.getNoObjCARCExceptionsMetadata());
2016}
2017
John McCallbd7370a2013-02-28 19:01:20 +00002018/// Emits a call to the given no-arguments nounwind runtime function.
2019llvm::CallInst *
2020CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
2021 const llvm::Twine &name) {
2022 return EmitNounwindRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2023}
2024
2025/// Emits a call to the given nounwind runtime function.
2026llvm::CallInst *
2027CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
2028 ArrayRef<llvm::Value*> args,
2029 const llvm::Twine &name) {
2030 llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
2031 call->setDoesNotThrow();
2032 return call;
2033}
2034
2035/// Emits a simple call (never an invoke) to the given no-arguments
2036/// runtime function.
2037llvm::CallInst *
2038CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
2039 const llvm::Twine &name) {
2040 return EmitRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2041}
2042
2043/// Emits a simple call (never an invoke) to the given runtime
2044/// function.
2045llvm::CallInst *
2046CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
2047 ArrayRef<llvm::Value*> args,
2048 const llvm::Twine &name) {
2049 llvm::CallInst *call = Builder.CreateCall(callee, args, name);
2050 call->setCallingConv(getRuntimeCC());
2051 return call;
2052}
2053
2054/// Emits a call or invoke to the given noreturn runtime function.
2055void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee,
2056 ArrayRef<llvm::Value*> args) {
2057 if (getInvokeDest()) {
2058 llvm::InvokeInst *invoke =
2059 Builder.CreateInvoke(callee,
2060 getUnreachableBlock(),
2061 getInvokeDest(),
2062 args);
2063 invoke->setDoesNotReturn();
2064 invoke->setCallingConv(getRuntimeCC());
2065 } else {
2066 llvm::CallInst *call = Builder.CreateCall(callee, args);
2067 call->setDoesNotReturn();
2068 call->setCallingConv(getRuntimeCC());
2069 Builder.CreateUnreachable();
2070 }
2071}
2072
2073/// Emits a call or invoke instruction to the given nullary runtime
2074/// function.
2075llvm::CallSite
2076CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
2077 const Twine &name) {
2078 return EmitRuntimeCallOrInvoke(callee, ArrayRef<llvm::Value*>(), name);
2079}
2080
2081/// Emits a call or invoke instruction to the given runtime function.
2082llvm::CallSite
2083CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
2084 ArrayRef<llvm::Value*> args,
2085 const Twine &name) {
2086 llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name);
2087 callSite.setCallingConv(getRuntimeCC());
2088 return callSite;
2089}
2090
2091llvm::CallSite
2092CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
2093 const Twine &Name) {
2094 return EmitCallOrInvoke(Callee, ArrayRef<llvm::Value *>(), Name);
2095}
2096
John McCallf1549f62010-07-06 01:34:17 +00002097/// Emits a call or invoke instruction to the given function, depending
2098/// on the current state of the EH stack.
2099llvm::CallSite
2100CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00002101 ArrayRef<llvm::Value *> Args,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002102 const Twine &Name) {
John McCallf1549f62010-07-06 01:34:17 +00002103 llvm::BasicBlock *InvokeDest = getInvokeDest();
John McCallf1549f62010-07-06 01:34:17 +00002104
Dan Gohmanb49bd272012-02-16 00:57:37 +00002105 llvm::Instruction *Inst;
2106 if (!InvokeDest)
2107 Inst = Builder.CreateCall(Callee, Args, Name);
2108 else {
2109 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
2110 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name);
2111 EmitBlock(ContBB);
2112 }
2113
2114 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2115 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00002116 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00002117 AddObjCARCExceptionMetadata(Inst);
2118
2119 return Inst;
John McCallf1549f62010-07-06 01:34:17 +00002120}
2121
Chris Lattner70855442011-07-12 04:46:18 +00002122static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo,
2123 llvm::FunctionType *FTy) {
2124 if (ArgNo < FTy->getNumParams())
2125 assert(Elt->getType() == FTy->getParamType(ArgNo));
2126 else
2127 assert(FTy->isVarArg());
2128 ++ArgNo;
2129}
2130
Chris Lattner811bf362011-07-12 06:29:11 +00002131void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002132 SmallVector<llvm::Value*,16> &Args,
Chris Lattner811bf362011-07-12 06:29:11 +00002133 llvm::FunctionType *IRFuncTy) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002134 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
2135 unsigned NumElts = AT->getSize().getZExtValue();
2136 QualType EltTy = AT->getElementType();
2137 llvm::Value *Addr = RV.getAggregateAddr();
2138 for (unsigned Elt = 0; Elt < NumElts; ++Elt) {
2139 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt);
John McCall9d232c82013-03-07 21:37:08 +00002140 RValue EltRV = convertTempToRValue(EltAddr, EltTy);
Bob Wilson194f06a2011-08-03 05:58:22 +00002141 ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy);
Chris Lattner811bf362011-07-12 06:29:11 +00002142 }
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002143 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002144 RecordDecl *RD = RT->getDecl();
2145 assert(RV.isAggregate() && "Unexpected rvalue during struct expansion");
Eli Friedman377ecc72012-04-16 03:54:45 +00002146 LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002147
2148 if (RD->isUnion()) {
2149 const FieldDecl *LargestFD = 0;
2150 CharUnits UnionSize = CharUnits::Zero();
2151
2152 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2153 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002154 const FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002155 assert(!FD->isBitField() &&
2156 "Cannot expand structure with bit-field members.");
2157 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType());
2158 if (UnionSize < FieldSize) {
2159 UnionSize = FieldSize;
2160 LargestFD = FD;
2161 }
2162 }
2163 if (LargestFD) {
Eli Friedman377ecc72012-04-16 03:54:45 +00002164 RValue FldRV = EmitRValueForField(LV, LargestFD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002165 ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy);
2166 }
2167 } else {
2168 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2169 i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002170 FieldDecl *FD = *i;
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002171
Eli Friedman377ecc72012-04-16 03:54:45 +00002172 RValue FldRV = EmitRValueForField(LV, FD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002173 ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy);
2174 }
Bob Wilson194f06a2011-08-03 05:58:22 +00002175 }
Eli Friedmanca3d3fc2011-11-15 02:46:03 +00002176 } else if (Ty->isAnyComplexType()) {
Bob Wilson194f06a2011-08-03 05:58:22 +00002177 ComplexPairTy CV = RV.getComplexVal();
2178 Args.push_back(CV.first);
2179 Args.push_back(CV.second);
2180 } else {
Chris Lattner811bf362011-07-12 06:29:11 +00002181 assert(RV.isScalar() &&
2182 "Unexpected non-scalar rvalue during struct expansion.");
2183
2184 // Insert a bitcast as needed.
2185 llvm::Value *V = RV.getScalarVal();
2186 if (Args.size() < IRFuncTy->getNumParams() &&
2187 V->getType() != IRFuncTy->getParamType(Args.size()))
2188 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size()));
2189
2190 Args.push_back(V);
2191 }
2192}
2193
2194
Daniel Dunbar88b53962009-02-02 22:03:45 +00002195RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
Mike Stump1eb44332009-09-09 15:08:12 +00002196 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00002197 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00002198 const CallArgList &CallArgs,
David Chisnalldd5c98f2010-05-01 11:15:56 +00002199 const Decl *TargetDecl,
David Chisnall4b02afc2010-05-02 13:41:58 +00002200 llvm::Instruction **callOrInvoke) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00002201 // FIXME: We no longer need the types from CallArgs; lift up and simplify.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002202 SmallVector<llvm::Value*, 16> Args;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002203
2204 // Handle struct-return functions by passing a pointer to the
2205 // location that we would like to return into.
Daniel Dunbarbb36d332009-02-02 21:43:58 +00002206 QualType RetTy = CallInfo.getReturnType();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002207 const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
Mike Stump1eb44332009-09-09 15:08:12 +00002208
Chris Lattner70855442011-07-12 04:46:18 +00002209 // IRArgNo - Keep track of the argument number in the callee we're looking at.
2210 unsigned IRArgNo = 0;
2211 llvm::FunctionType *IRFuncTy =
2212 cast<llvm::FunctionType>(
2213 cast<llvm::PointerType>(Callee->getType())->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +00002214
Chris Lattner5db7ae52009-06-13 00:26:38 +00002215 // If the call returns a temporary with struct return, create a temporary
Anders Carlssond2490a92009-12-24 20:40:36 +00002216 // alloca to hold the result, unless one is given to us.
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002217 if (CGM.ReturnTypeUsesSRet(CallInfo)) {
Anders Carlssond2490a92009-12-24 20:40:36 +00002218 llvm::Value *Value = ReturnValue.getValue();
2219 if (!Value)
Daniel Dunbar195337d2010-02-09 02:48:28 +00002220 Value = CreateMemTemp(RetTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002221 Args.push_back(Value);
Chris Lattner70855442011-07-12 04:46:18 +00002222 checkArgMatches(Value, IRArgNo, IRFuncTy);
Anders Carlssond2490a92009-12-24 20:40:36 +00002223 }
Mike Stump1eb44332009-09-09 15:08:12 +00002224
Daniel Dunbar4b5f0a42009-02-04 21:17:21 +00002225 assert(CallInfo.arg_size() == CallArgs.size() &&
2226 "Mismatch between function signature & arguments.");
Daniel Dunbarb225be42009-02-03 05:59:18 +00002227 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00002228 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
Daniel Dunbarb225be42009-02-03 05:59:18 +00002229 I != E; ++I, ++info_it) {
2230 const ABIArgInfo &ArgInfo = info_it->info;
Eli Friedmanc6d07822011-05-02 18:05:27 +00002231 RValue RV = I->RV;
Daniel Dunbar56273772008-09-17 00:51:38 +00002232
John McCall9d232c82013-03-07 21:37:08 +00002233 CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty);
Rafael Espindolae4aeeaa2012-10-24 01:59:00 +00002234
2235 // Insert a padding argument to ensure proper alignment.
2236 if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) {
2237 Args.push_back(llvm::UndefValue::get(PaddingType));
2238 ++IRArgNo;
2239 }
2240
Daniel Dunbar56273772008-09-17 00:51:38 +00002241 switch (ArgInfo.getKind()) {
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002242 case ABIArgInfo::Indirect: {
Daniel Dunbar1f745982009-02-05 09:16:39 +00002243 if (RV.isScalar() || RV.isComplex()) {
2244 // Make a temporary alloca to pass the argument.
Eli Friedman70cbd2a2011-06-15 18:26:32 +00002245 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2246 if (ArgInfo.getIndirectAlign() > AI->getAlignment())
2247 AI->setAlignment(ArgInfo.getIndirectAlign());
2248 Args.push_back(AI);
John McCall9d232c82013-03-07 21:37:08 +00002249
2250 LValue argLV =
2251 MakeAddrLValue(Args.back(), I->Ty, TypeAlign);
Chris Lattner70855442011-07-12 04:46:18 +00002252
Daniel Dunbar1f745982009-02-05 09:16:39 +00002253 if (RV.isScalar())
John McCall9d232c82013-03-07 21:37:08 +00002254 EmitStoreOfScalar(RV.getScalarVal(), argLV, /*init*/ true);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002255 else
John McCall9d232c82013-03-07 21:37:08 +00002256 EmitStoreOfComplex(RV.getComplexVal(), argLV, /*init*/ true);
Chris Lattner70855442011-07-12 04:46:18 +00002257
2258 // Validate argument match.
2259 checkArgMatches(AI, IRArgNo, IRFuncTy);
Daniel Dunbar1f745982009-02-05 09:16:39 +00002260 } else {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002261 // We want to avoid creating an unnecessary temporary+copy here;
Guy Benyeid436c992013-03-10 12:59:00 +00002262 // however, we need one in three cases:
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002263 // 1. If the argument is not byval, and we are required to copy the
2264 // source. (This case doesn't occur on any common architecture.)
2265 // 2. If the argument is byval, RV is not sufficiently aligned, and
2266 // we cannot force it to be sufficiently aligned.
Guy Benyeid436c992013-03-10 12:59:00 +00002267 // 3. If the argument is byval, but RV is located in an address space
2268 // different than that of the argument (0).
Eli Friedman97cb5a42011-06-15 22:09:18 +00002269 llvm::Value *Addr = RV.getAggregateAddr();
2270 unsigned Align = ArgInfo.getIndirectAlign();
Micah Villmow25a6a842012-10-08 16:25:52 +00002271 const llvm::DataLayout *TD = &CGM.getDataLayout();
Guy Benyeid436c992013-03-10 12:59:00 +00002272 const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace();
2273 const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ?
2274 IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0);
Eli Friedman97cb5a42011-06-15 22:09:18 +00002275 if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) ||
John McCall9d232c82013-03-07 21:37:08 +00002276 (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align &&
Guy Benyeid436c992013-03-10 12:59:00 +00002277 llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) ||
2278 (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) {
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002279 // Create an aligned temporary, and copy to it.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002280 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
2281 if (Align > AI->getAlignment())
2282 AI->setAlignment(Align);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002283 Args.push_back(AI);
Chad Rosier649b4a12012-03-29 17:37:10 +00002284 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified());
Chris Lattner70855442011-07-12 04:46:18 +00002285
2286 // Validate argument match.
2287 checkArgMatches(AI, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002288 } else {
2289 // Skip the extra memcpy call.
Eli Friedman97cb5a42011-06-15 22:09:18 +00002290 Args.push_back(Addr);
Chris Lattner70855442011-07-12 04:46:18 +00002291
2292 // Validate argument match.
2293 checkArgMatches(Addr, IRArgNo, IRFuncTy);
Eli Friedmanea5e4da2011-06-14 01:37:52 +00002294 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002295 }
2296 break;
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00002297 }
Daniel Dunbar1f745982009-02-05 09:16:39 +00002298
Daniel Dunbar11434922009-01-26 21:26:08 +00002299 case ABIArgInfo::Ignore:
2300 break;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002301
Chris Lattner800588f2010-07-29 06:26:06 +00002302 case ABIArgInfo::Extend:
2303 case ABIArgInfo::Direct: {
2304 if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
Chris Lattner117e3f42010-07-30 04:02:24 +00002305 ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
2306 ArgInfo.getDirectOffset() == 0) {
Chris Lattner70855442011-07-12 04:46:18 +00002307 llvm::Value *V;
Chris Lattner800588f2010-07-29 06:26:06 +00002308 if (RV.isScalar())
Chris Lattner70855442011-07-12 04:46:18 +00002309 V = RV.getScalarVal();
Chris Lattner800588f2010-07-29 06:26:06 +00002310 else
Chris Lattner70855442011-07-12 04:46:18 +00002311 V = Builder.CreateLoad(RV.getAggregateAddr());
2312
Chris Lattner21ca1fd2011-07-12 04:53:39 +00002313 // If the argument doesn't match, perform a bitcast to coerce it. This
2314 // can happen due to trivial type mismatches.
2315 if (IRArgNo < IRFuncTy->getNumParams() &&
2316 V->getType() != IRFuncTy->getParamType(IRArgNo))
2317 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo));
Chris Lattner70855442011-07-12 04:46:18 +00002318 Args.push_back(V);
2319
Chris Lattner70855442011-07-12 04:46:18 +00002320 checkArgMatches(V, IRArgNo, IRFuncTy);
Chris Lattner800588f2010-07-29 06:26:06 +00002321 break;
2322 }
Daniel Dunbar11434922009-01-26 21:26:08 +00002323
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002324 // FIXME: Avoid the conversion through memory if possible.
2325 llvm::Value *SrcPtr;
John McCall9d232c82013-03-07 21:37:08 +00002326 if (RV.isScalar() || RV.isComplex()) {
Eli Friedmanc6d07822011-05-02 18:05:27 +00002327 SrcPtr = CreateMemTemp(I->Ty, "coerce");
John McCall9d232c82013-03-07 21:37:08 +00002328 LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign);
2329 if (RV.isScalar()) {
2330 EmitStoreOfScalar(RV.getScalarVal(), SrcLV, /*init*/ true);
2331 } else {
2332 EmitStoreOfComplex(RV.getComplexVal(), SrcLV, /*init*/ true);
2333 }
Mike Stump1eb44332009-09-09 15:08:12 +00002334 } else
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002335 SrcPtr = RV.getAggregateAddr();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002336
Chris Lattner117e3f42010-07-30 04:02:24 +00002337 // If the value is offset in memory, apply the offset now.
2338 if (unsigned Offs = ArgInfo.getDirectOffset()) {
2339 SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy());
2340 SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002341 SrcPtr = Builder.CreateBitCast(SrcPtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002342 llvm::PointerType::getUnqual(ArgInfo.getCoerceToType()));
2343
2344 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002345
Chris Lattnerce700162010-06-28 23:44:11 +00002346 // If the coerce-to type is a first class aggregate, we flatten it and
2347 // pass the elements. Either way is semantically identical, but fast-isel
2348 // and the optimizer generally likes scalar values better than FCAs.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002349 if (llvm::StructType *STy =
Chris Lattner309c59f2010-06-29 00:06:42 +00002350 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType())) {
Chandler Carruthf82232c2012-10-10 11:29:08 +00002351 llvm::Type *SrcTy =
2352 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
2353 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
2354 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
2355
2356 // If the source type is smaller than the destination type of the
2357 // coerce-to logic, copy the source value into a temp alloca the size
2358 // of the destination type to allow loading all of it. The bits past
2359 // the source value are left undef.
2360 if (SrcSize < DstSize) {
2361 llvm::AllocaInst *TempAlloca
2362 = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce");
2363 Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0);
2364 SrcPtr = TempAlloca;
2365 } else {
2366 SrcPtr = Builder.CreateBitCast(SrcPtr,
2367 llvm::PointerType::getUnqual(STy));
2368 }
2369
Chris Lattner92826882010-07-05 20:41:41 +00002370 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2371 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i);
Chris Lattnerdeabde22010-07-28 18:24:28 +00002372 llvm::LoadInst *LI = Builder.CreateLoad(EltPtr);
2373 // We don't know what we're loading from.
2374 LI->setAlignment(1);
2375 Args.push_back(LI);
Chris Lattner70855442011-07-12 04:46:18 +00002376
2377 // Validate argument match.
2378 checkArgMatches(LI, IRArgNo, IRFuncTy);
Chris Lattner309c59f2010-06-29 00:06:42 +00002379 }
Chris Lattnerce700162010-06-28 23:44:11 +00002380 } else {
Chris Lattner309c59f2010-06-29 00:06:42 +00002381 // In the simple case, just pass the coerced loaded value.
2382 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(),
2383 *this));
Chris Lattner70855442011-07-12 04:46:18 +00002384
2385 // Validate argument match.
2386 checkArgMatches(Args.back(), IRArgNo, IRFuncTy);
Chris Lattnerce700162010-06-28 23:44:11 +00002387 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002388
Daniel Dunbar89c9d8e2009-02-03 19:12:28 +00002389 break;
2390 }
2391
Daniel Dunbar56273772008-09-17 00:51:38 +00002392 case ABIArgInfo::Expand:
Chris Lattner811bf362011-07-12 06:29:11 +00002393 ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy);
Chris Lattner70855442011-07-12 04:46:18 +00002394 IRArgNo = Args.size();
Daniel Dunbar56273772008-09-17 00:51:38 +00002395 break;
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002396 }
2397 }
Mike Stump1eb44332009-09-09 15:08:12 +00002398
Chris Lattner5db7ae52009-06-13 00:26:38 +00002399 // If the callee is a bitcast of a function to a varargs pointer to function
2400 // type, check to see if we can remove the bitcast. This handles some cases
2401 // with unprototyped functions.
2402 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee))
2403 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002404 llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType());
2405 llvm::FunctionType *CurFT =
Chris Lattner5db7ae52009-06-13 00:26:38 +00002406 cast<llvm::FunctionType>(CurPT->getElementType());
Chris Lattner2acc6e32011-07-18 04:24:23 +00002407 llvm::FunctionType *ActualFT = CalleeF->getFunctionType();
Mike Stump1eb44332009-09-09 15:08:12 +00002408
Chris Lattner5db7ae52009-06-13 00:26:38 +00002409 if (CE->getOpcode() == llvm::Instruction::BitCast &&
2410 ActualFT->getReturnType() == CurFT->getReturnType() &&
Chris Lattnerd6bebbf2009-06-23 01:38:41 +00002411 ActualFT->getNumParams() == CurFT->getNumParams() &&
Fariborz Jahanianc0ddef22011-03-01 17:28:13 +00002412 ActualFT->getNumParams() == Args.size() &&
2413 (CurFT->isVarArg() || !ActualFT->isVarArg())) {
Chris Lattner5db7ae52009-06-13 00:26:38 +00002414 bool ArgsMatch = true;
2415 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i)
2416 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) {
2417 ArgsMatch = false;
2418 break;
2419 }
Mike Stump1eb44332009-09-09 15:08:12 +00002420
Chris Lattner5db7ae52009-06-13 00:26:38 +00002421 // Strip the cast if we can get away with it. This is a nice cleanup,
2422 // but also allows us to inline the function at -O0 if it is marked
2423 // always_inline.
2424 if (ArgsMatch)
2425 Callee = CalleeF;
2426 }
2427 }
Mike Stump1eb44332009-09-09 15:08:12 +00002428
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002429 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +00002430 CodeGen::AttributeListType AttributeList;
Bill Wendling94236e72013-02-22 00:13:35 +00002431 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList,
2432 CallingConv, true);
Bill Wendling785b7782012-12-07 23:17:26 +00002433 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
Bill Wendling94236e72013-02-22 00:13:35 +00002434 AttributeList);
Mike Stump1eb44332009-09-09 15:08:12 +00002435
John McCallf1549f62010-07-06 01:34:17 +00002436 llvm::BasicBlock *InvokeDest = 0;
Bill Wendling01ad9542012-12-30 10:32:17 +00002437 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
2438 llvm::Attribute::NoUnwind))
John McCallf1549f62010-07-06 01:34:17 +00002439 InvokeDest = getInvokeDest();
2440
Daniel Dunbard14151d2009-03-02 04:32:35 +00002441 llvm::CallSite CS;
John McCallf1549f62010-07-06 01:34:17 +00002442 if (!InvokeDest) {
Jay Foad4c7d9f12011-07-15 08:37:34 +00002443 CS = Builder.CreateCall(Callee, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002444 } else {
2445 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Jay Foad4c7d9f12011-07-15 08:37:34 +00002446 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args);
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00002447 EmitBlock(Cont);
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002448 }
Chris Lattnerce933992010-06-29 16:40:28 +00002449 if (callOrInvoke)
David Chisnall4b02afc2010-05-02 13:41:58 +00002450 *callOrInvoke = CS.getInstruction();
Daniel Dunbarf4fe0f02009-02-20 18:54:31 +00002451
Daniel Dunbard14151d2009-03-02 04:32:35 +00002452 CS.setAttributes(Attrs);
Daniel Dunbarca6408c2009-09-12 00:59:20 +00002453 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbard14151d2009-03-02 04:32:35 +00002454
Dan Gohmanb49bd272012-02-16 00:57:37 +00002455 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2456 // optimizer it can aggressively ignore unwind edges.
David Blaikie4e4d0842012-03-11 07:00:24 +00002457 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohmanb49bd272012-02-16 00:57:37 +00002458 AddObjCARCExceptionMetadata(CS.getInstruction());
2459
Daniel Dunbard14151d2009-03-02 04:32:35 +00002460 // If the call doesn't return, finish the basic block and clear the
2461 // insertion point; this allows the rest of IRgen to discard
2462 // unreachable code.
2463 if (CS.doesNotReturn()) {
2464 Builder.CreateUnreachable();
2465 Builder.ClearInsertionPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002466
Mike Stumpf5408fe2009-05-16 07:57:57 +00002467 // FIXME: For now, emit a dummy basic block because expr emitters in
2468 // generally are not ready to handle emitting expressions at unreachable
2469 // points.
Daniel Dunbard14151d2009-03-02 04:32:35 +00002470 EnsureInsertPoint();
Mike Stump1eb44332009-09-09 15:08:12 +00002471
Daniel Dunbard14151d2009-03-02 04:32:35 +00002472 // Return a reasonable RValue.
2473 return GetUndefRValue(RetTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002474 }
Daniel Dunbard14151d2009-03-02 04:32:35 +00002475
2476 llvm::Instruction *CI = CS.getInstruction();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00002477 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy())
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002478 CI->setName("call");
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002479
John McCallf85e1932011-06-15 23:02:42 +00002480 // Emit any writebacks immediately. Arguably this should happen
2481 // after any return-value munging.
2482 if (CallArgs.hasWritebacks())
2483 emitWritebacks(*this, CallArgs);
2484
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002485 switch (RetAI.getKind()) {
John McCall9d232c82013-03-07 21:37:08 +00002486 case ABIArgInfo::Indirect:
2487 return convertTempToRValue(Args[0], RetTy);
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002488
Daniel Dunbar11434922009-01-26 21:26:08 +00002489 case ABIArgInfo::Ignore:
Daniel Dunbar0bcc5212009-02-03 06:30:17 +00002490 // If we are ignoring an argument that had a result, make sure to
2491 // construct the appropriate return value for our caller.
Daniel Dunbar13e81732009-02-05 07:09:07 +00002492 return GetUndefRValue(RetTy);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002493
Chris Lattner800588f2010-07-29 06:26:06 +00002494 case ABIArgInfo::Extend:
2495 case ABIArgInfo::Direct: {
Chris Lattner6af13f32011-07-13 03:59:32 +00002496 llvm::Type *RetIRTy = ConvertType(RetTy);
2497 if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
John McCall9d232c82013-03-07 21:37:08 +00002498 switch (getEvaluationKind(RetTy)) {
2499 case TEK_Complex: {
Chris Lattner800588f2010-07-29 06:26:06 +00002500 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
2501 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
2502 return RValue::getComplex(std::make_pair(Real, Imag));
2503 }
John McCall9d232c82013-03-07 21:37:08 +00002504 case TEK_Aggregate: {
Chris Lattner800588f2010-07-29 06:26:06 +00002505 llvm::Value *DestPtr = ReturnValue.getValue();
2506 bool DestIsVolatile = ReturnValue.isVolatile();
Daniel Dunbar11434922009-01-26 21:26:08 +00002507
Chris Lattner800588f2010-07-29 06:26:06 +00002508 if (!DestPtr) {
2509 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
2510 DestIsVolatile = false;
2511 }
Eli Friedmanbadea572011-05-17 21:08:01 +00002512 BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false);
Chris Lattner800588f2010-07-29 06:26:06 +00002513 return RValue::getAggregate(DestPtr);
2514 }
John McCall9d232c82013-03-07 21:37:08 +00002515 case TEK_Scalar: {
2516 // If the argument doesn't match, perform a bitcast to coerce it. This
2517 // can happen due to trivial type mismatches.
2518 llvm::Value *V = CI;
2519 if (V->getType() != RetIRTy)
2520 V = Builder.CreateBitCast(V, RetIRTy);
2521 return RValue::get(V);
2522 }
2523 }
2524 llvm_unreachable("bad evaluation kind");
Chris Lattner800588f2010-07-29 06:26:06 +00002525 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002526
Anders Carlssond2490a92009-12-24 20:40:36 +00002527 llvm::Value *DestPtr = ReturnValue.getValue();
2528 bool DestIsVolatile = ReturnValue.isVolatile();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002529
Anders Carlssond2490a92009-12-24 20:40:36 +00002530 if (!DestPtr) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00002531 DestPtr = CreateMemTemp(RetTy, "coerce");
Anders Carlssond2490a92009-12-24 20:40:36 +00002532 DestIsVolatile = false;
2533 }
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002534
Chris Lattner117e3f42010-07-30 04:02:24 +00002535 // If the value is offset in memory, apply the offset now.
2536 llvm::Value *StorePtr = DestPtr;
2537 if (unsigned Offs = RetAI.getDirectOffset()) {
2538 StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy());
2539 StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002540 StorePtr = Builder.CreateBitCast(StorePtr,
Chris Lattner117e3f42010-07-30 04:02:24 +00002541 llvm::PointerType::getUnqual(RetAI.getCoerceToType()));
2542 }
2543 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002544
John McCall9d232c82013-03-07 21:37:08 +00002545 return convertTempToRValue(DestPtr, RetTy);
Daniel Dunbar639ffe42008-09-10 07:04:09 +00002546 }
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002547
Daniel Dunbar8951dbd2008-09-11 01:48:57 +00002548 case ABIArgInfo::Expand:
David Blaikieb219cfc2011-09-23 05:06:16 +00002549 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002550 }
Daniel Dunbar2c8e0f32008-09-10 02:41:04 +00002551
David Blaikieb219cfc2011-09-23 05:06:16 +00002552 llvm_unreachable("Unhandled ABIArgInfo::Kind");
Daniel Dunbar17b708d2008-09-09 23:27:19 +00002553}
Daniel Dunbarb4094ea2009-02-10 20:44:09 +00002554
2555/* VarArg handling */
2556
2557llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) {
2558 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this);
2559}