blob: 8f61f466e74efb8d012ff30b8b0739c4a942c917 [file] [log] [blame]
Nick Lewycky5fa40c32013-10-01 21:51:38 +00001//===--- CGCall.cpp - Encapsulate calling convention details --------------===//
Daniel Dunbar3d7c90b2008-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 Lattnere70a0072010-06-29 16:40:28 +000016#include "ABIInfo.h"
Akira Hatanaka9d8ac612016-02-17 21:09:50 +000017#include "CGBlocks.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "CGCXXABI.h"
David Majnemer4e52d6f2015-12-12 05:39:21 +000019#include "CGCleanup.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000020#include "CodeGenFunction.h"
Daniel Dunbarc68897d2008-09-10 00:41:16 +000021#include "CodeGenModule.h"
John McCalla729c622012-02-17 03:33:10 +000022#include "TargetInfo.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000023#include "clang/AST/Decl.h"
Anders Carlssonb15b55c2009-04-03 22:48:58 +000024#include "clang/AST/DeclCXX.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000025#include "clang/AST/DeclObjC.h"
Eric Christopher15709992015-10-15 23:47:11 +000026#include "clang/Basic/TargetBuiltins.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000027#include "clang/Basic/TargetInfo.h"
Mark Laceya8e7df32013-10-30 21:53:58 +000028#include "clang/CodeGen/CGFunctionInfo.h"
John McCall12f23522016-04-04 18:33:08 +000029#include "clang/CodeGen/SwiftCallingConv.h"
Saleem Abdulrasool10a49722016-04-08 16:52:00 +000030#include "clang/Frontend/CodeGenOptions.h"
Bill Wendling706469b2013-02-28 22:49:57 +000031#include "llvm/ADT/StringExtras.h"
Nick Lewyckyd9bce502016-09-20 15:49:58 +000032#include "llvm/Analysis/ValueTracking.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000033#include "llvm/IR/Attributes.h"
Nikolay Haustov8c6538b2016-06-30 09:06:33 +000034#include "llvm/IR/CallingConv.h"
Chandler Carruthc80ceea2014-03-04 11:02:08 +000035#include "llvm/IR/CallSite.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000036#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/InlineAsm.h"
Saleem Abdulrasool94cfc602016-04-07 17:49:44 +000038#include "llvm/IR/Intrinsics.h"
Saleem Abdulrasool10a49722016-04-08 16:52:00 +000039#include "llvm/IR/IntrinsicInst.h"
Eli Friedmanf7456192011-06-15 22:09:18 +000040#include "llvm/Transforms/Utils/Local.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000041using namespace clang;
42using namespace CodeGen;
43
44/***/
45
Nikolay Haustov8c6538b2016-06-30 09:06:33 +000046unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
John McCallab26cfa2010-02-05 21:31:56 +000047 switch (CC) {
48 default: return llvm::CallingConv::C;
49 case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
50 case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
Erich Keane757d3172016-11-02 18:29:35 +000051 case CC_X86RegCall: return llvm::CallingConv::X86_RegCall;
Douglas Gregora941dca2010-05-18 16:57:00 +000052 case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
Charles Davisb5a214e2013-08-30 04:39:01 +000053 case CC_X86_64Win64: return llvm::CallingConv::X86_64_Win64;
54 case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV;
Anton Korobeynikov231e8752011-04-14 20:06:49 +000055 case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
56 case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
Guy Benyeif0a014b2012-12-25 08:53:55 +000057 case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;
Reid Klecknerd7857f02014-10-24 17:42:17 +000058 // TODO: Add support for __pascal to LLVM.
59 case CC_X86Pascal: return llvm::CallingConv::C;
60 // TODO: Add support for __vectorcall to LLVM.
Reid Kleckner80944df2014-10-31 22:00:51 +000061 case CC_X86VectorCall: return llvm::CallingConv::X86_VectorCall;
Alexander Kornienko21de0ae2015-01-20 11:20:41 +000062 case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC;
Nikolay Haustov8c6538b2016-06-30 09:06:33 +000063 case CC_OpenCLKernel: return CGM.getTargetCodeGenInfo().getOpenCLKernelCallingConv();
Roman Levenstein35aa5ce2016-03-16 18:00:46 +000064 case CC_PreserveMost: return llvm::CallingConv::PreserveMost;
65 case CC_PreserveAll: return llvm::CallingConv::PreserveAll;
John McCall12f23522016-04-04 18:33:08 +000066 case CC_Swift: return llvm::CallingConv::Swift;
John McCallab26cfa2010-02-05 21:31:56 +000067 }
68}
69
John McCall8ee376f2010-02-24 07:14:12 +000070/// Derives the 'this' type for codegen purposes, i.e. ignoring method
71/// qualification.
72/// FIXME: address space qualification?
John McCall2da83a32010-02-26 00:48:12 +000073static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) {
74 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
75 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
Daniel Dunbar7a95ca32008-09-10 04:01:49 +000076}
77
John McCall8ee376f2010-02-24 07:14:12 +000078/// Returns the canonical formal type of the given C++ method.
John McCall2da83a32010-02-26 00:48:12 +000079static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
80 return MD->getType()->getCanonicalTypeUnqualified()
81 .getAs<FunctionProtoType>();
John McCall8ee376f2010-02-24 07:14:12 +000082}
83
84/// Returns the "extra-canonicalized" return type, which discards
85/// qualifiers on the return type. Codegen doesn't care about them,
86/// and it makes ABI code a little easier to be able to assume that
87/// all parameter and return types are top-level unqualified.
John McCall2da83a32010-02-26 00:48:12 +000088static CanQualType GetReturnType(QualType RetTy) {
89 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
John McCall8ee376f2010-02-24 07:14:12 +000090}
91
John McCall8dda7b22012-07-07 06:41:13 +000092/// Arrange the argument and result information for a value of the given
93/// unprototyped freestanding function type.
John McCall8ee376f2010-02-24 07:14:12 +000094const CGFunctionInfo &
John McCall8dda7b22012-07-07 06:41:13 +000095CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
John McCalla729c622012-02-17 03:33:10 +000096 // When translating an unprototyped function type, always use a
97 // variadic type.
Alp Toker314cc812014-01-25 16:55:45 +000098 return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(),
Peter Collingbournef7706832014-12-12 23:41:25 +000099 /*instanceMethod=*/false,
100 /*chainCall=*/false, None,
John McCallc56a8b32016-03-11 04:30:31 +0000101 FTNP->getExtInfo(), {}, RequiredArgs(0));
John McCall8ee376f2010-02-24 07:14:12 +0000102}
103
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000104/// Adds the formal paramaters in FPT to the given prefix. If any parameter in
105/// FPT has pass_object_size attrs, then we'll add parameters for those, too.
106static void appendParameterTypes(const CodeGenTypes &CGT,
107 SmallVectorImpl<CanQualType> &prefix,
John McCallc56a8b32016-03-11 04:30:31 +0000108 SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &paramInfos,
109 CanQual<FunctionProtoType> FPT,
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000110 const FunctionDecl *FD) {
John McCallc56a8b32016-03-11 04:30:31 +0000111 // Fill out paramInfos.
112 if (FPT->hasExtParameterInfos() || !paramInfos.empty()) {
113 assert(paramInfos.size() <= prefix.size());
114 auto protoParamInfos = FPT->getExtParameterInfos();
115 paramInfos.reserve(prefix.size() + protoParamInfos.size());
116 paramInfos.resize(prefix.size());
John McCall12f23522016-04-04 18:33:08 +0000117 paramInfos.append(protoParamInfos.begin(), protoParamInfos.end());
John McCallc56a8b32016-03-11 04:30:31 +0000118 }
119
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000120 // Fast path: unknown target.
121 if (FD == nullptr) {
122 prefix.append(FPT->param_type_begin(), FPT->param_type_end());
123 return;
124 }
125
126 // In the vast majority cases, we'll have precisely FPT->getNumParams()
127 // parameters; the only thing that can change this is the presence of
128 // pass_object_size. So, we preallocate for the common case.
129 prefix.reserve(prefix.size() + FPT->getNumParams());
130
131 assert(FD->getNumParams() == FPT->getNumParams());
132 for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) {
133 prefix.push_back(FPT->getParamType(I));
134 if (FD->getParamDecl(I)->hasAttr<PassObjectSizeAttr>())
135 prefix.push_back(CGT.getContext().getSizeType());
136 }
137}
138
John McCall8dda7b22012-07-07 06:41:13 +0000139/// Arrange the LLVM function layout for a value of the given function
Alexey Samsonove5ef3ca2014-08-13 23:55:54 +0000140/// type, on top of any implicit parameters already stored.
141static const CGFunctionInfo &
Peter Collingbournef7706832014-12-12 23:41:25 +0000142arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
Alexey Samsonove5ef3ca2014-08-13 23:55:54 +0000143 SmallVectorImpl<CanQualType> &prefix,
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000144 CanQual<FunctionProtoType> FTP,
145 const FunctionDecl *FD) {
John McCallc56a8b32016-03-11 04:30:31 +0000146 SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
George Burgess IV419996c2016-06-16 23:06:04 +0000147 RequiredArgs Required =
148 RequiredArgs::forPrototypePlus(FTP, prefix.size(), FD);
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +0000149 // FIXME: Kill copy.
John McCallc56a8b32016-03-11 04:30:31 +0000150 appendParameterTypes(CGT, prefix, paramInfos, FTP, FD);
Alp Toker314cc812014-01-25 16:55:45 +0000151 CanQualType resultType = FTP->getReturnType().getUnqualifiedType();
John McCallc56a8b32016-03-11 04:30:31 +0000152
Peter Collingbournef7706832014-12-12 23:41:25 +0000153 return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod,
154 /*chainCall=*/false, prefix,
John McCallc56a8b32016-03-11 04:30:31 +0000155 FTP->getExtInfo(), paramInfos,
George Burgess IV419996c2016-06-16 23:06:04 +0000156 Required);
John McCall8ee376f2010-02-24 07:14:12 +0000157}
158
John McCalla729c622012-02-17 03:33:10 +0000159/// Arrange the argument and result information for a value of the
John McCall8dda7b22012-07-07 06:41:13 +0000160/// given freestanding function type.
John McCall8ee376f2010-02-24 07:14:12 +0000161const CGFunctionInfo &
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000162CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP,
163 const FunctionDecl *FD) {
John McCalla729c622012-02-17 03:33:10 +0000164 SmallVector<CanQualType, 16> argTypes;
Peter Collingbournef7706832014-12-12 23:41:25 +0000165 return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes,
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000166 FTP, FD);
Daniel Dunbar7feafc72009-09-11 22:24:53 +0000167}
168
Aaron Ballman0362a6d2013-12-18 16:23:37 +0000169static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) {
Daniel Dunbar7feafc72009-09-11 22:24:53 +0000170 // Set the appropriate calling convention for the Function.
171 if (D->hasAttr<StdCallAttr>())
John McCallab26cfa2010-02-05 21:31:56 +0000172 return CC_X86StdCall;
Daniel Dunbar7feafc72009-09-11 22:24:53 +0000173
174 if (D->hasAttr<FastCallAttr>())
John McCallab26cfa2010-02-05 21:31:56 +0000175 return CC_X86FastCall;
Daniel Dunbar7feafc72009-09-11 22:24:53 +0000176
Erich Keane757d3172016-11-02 18:29:35 +0000177 if (D->hasAttr<RegCallAttr>())
178 return CC_X86RegCall;
179
Douglas Gregora941dca2010-05-18 16:57:00 +0000180 if (D->hasAttr<ThisCallAttr>())
181 return CC_X86ThisCall;
182
Reid Klecknerd7857f02014-10-24 17:42:17 +0000183 if (D->hasAttr<VectorCallAttr>())
184 return CC_X86VectorCall;
185
Dawn Perchik335e16b2010-09-03 01:29:35 +0000186 if (D->hasAttr<PascalAttr>())
187 return CC_X86Pascal;
188
Anton Korobeynikov231e8752011-04-14 20:06:49 +0000189 if (PcsAttr *PCS = D->getAttr<PcsAttr>())
190 return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
191
Guy Benyeif0a014b2012-12-25 08:53:55 +0000192 if (D->hasAttr<IntelOclBiccAttr>())
193 return CC_IntelOclBicc;
194
Aaron Ballman0362a6d2013-12-18 16:23:37 +0000195 if (D->hasAttr<MSABIAttr>())
196 return IsWindows ? CC_C : CC_X86_64Win64;
197
198 if (D->hasAttr<SysVABIAttr>())
199 return IsWindows ? CC_X86_64SysV : CC_C;
200
Roman Levenstein35aa5ce2016-03-16 18:00:46 +0000201 if (D->hasAttr<PreserveMostAttr>())
202 return CC_PreserveMost;
203
204 if (D->hasAttr<PreserveAllAttr>())
205 return CC_PreserveAll;
206
John McCallab26cfa2010-02-05 21:31:56 +0000207 return CC_C;
Daniel Dunbar7a95ca32008-09-10 04:01:49 +0000208}
209
John McCalla729c622012-02-17 03:33:10 +0000210/// Arrange the argument and result information for a call to an
211/// unknown C++ non-static member function of the given abstract type.
Timur Iskhodzhanov88fd4392013-08-21 06:25:03 +0000212/// (Zero value of RD means we don't have any meaningful "this" argument type,
213/// so fall back to a generic pointer type).
John McCalla729c622012-02-17 03:33:10 +0000214/// The member function must be an ordinary function, i.e. not a
215/// constructor or destructor.
216const CGFunctionInfo &
217CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD,
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000218 const FunctionProtoType *FTP,
219 const CXXMethodDecl *MD) {
John McCalla729c622012-02-17 03:33:10 +0000220 SmallVector<CanQualType, 16> argTypes;
John McCall8ee376f2010-02-24 07:14:12 +0000221
Anders Carlsson2ee3c012009-10-03 19:43:08 +0000222 // Add the 'this' pointer.
Timur Iskhodzhanov88fd4392013-08-21 06:25:03 +0000223 if (RD)
224 argTypes.push_back(GetThisType(Context, RD));
225 else
226 argTypes.push_back(Context.VoidPtrTy);
John McCall8ee376f2010-02-24 07:14:12 +0000227
Alexey Samsonove5ef3ca2014-08-13 23:55:54 +0000228 return ::arrangeLLVMFunctionInfo(
229 *this, true, argTypes,
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000230 FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>(), MD);
Anders Carlsson2ee3c012009-10-03 19:43:08 +0000231}
232
John McCalla729c622012-02-17 03:33:10 +0000233/// Arrange the argument and result information for a declaration or
234/// definition of the given C++ non-static member function. The
235/// member function must be an ordinary function, i.e. not a
236/// constructor or destructor.
237const CGFunctionInfo &
238CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) {
Benjamin Kramer60509af2013-09-09 14:48:42 +0000239 assert(!isa<CXXConstructorDecl>(MD) && "wrong method for constructors!");
John McCall0d635f52010-09-03 01:26:39 +0000240 assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!");
241
John McCalla729c622012-02-17 03:33:10 +0000242 CanQual<FunctionProtoType> prototype = GetFormalType(MD);
Mike Stump11289f42009-09-09 15:08:12 +0000243
John McCalla729c622012-02-17 03:33:10 +0000244 if (MD->isInstance()) {
245 // The abstract case is perfectly fine.
Mark Lacey5ea993b2013-10-02 20:35:23 +0000246 const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD);
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000247 return arrangeCXXMethodType(ThisType, prototype.getTypePtr(), MD);
John McCalla729c622012-02-17 03:33:10 +0000248 }
249
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000250 return arrangeFreeFunctionType(prototype, MD);
Anders Carlssonb15b55c2009-04-03 22:48:58 +0000251}
252
Richard Smith5179eb72016-06-28 19:03:57 +0000253bool CodeGenTypes::inheritingCtorHasParams(
254 const InheritedConstructor &Inherited, CXXCtorType Type) {
255 // Parameters are unnecessary if we're constructing a base class subobject
256 // and the inherited constructor lives in a virtual base.
257 return Type == Ctor_Complete ||
258 !Inherited.getShadowDecl()->constructsVirtualBase() ||
259 !Target.getCXXABI().hasConstructorVariants();
260 }
261
John McCalla729c622012-02-17 03:33:10 +0000262const CGFunctionInfo &
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000263CodeGenTypes::arrangeCXXStructorDeclaration(const CXXMethodDecl *MD,
264 StructorType Type) {
265
John McCalla729c622012-02-17 03:33:10 +0000266 SmallVector<CanQualType, 16> argTypes;
John McCallc56a8b32016-03-11 04:30:31 +0000267 SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000268 argTypes.push_back(GetThisType(Context, MD->getParent()));
Stephen Lin9dc6eef2013-06-30 20:40:16 +0000269
Richard Smith5179eb72016-06-28 19:03:57 +0000270 bool PassParams = true;
271
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000272 GlobalDecl GD;
273 if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
274 GD = GlobalDecl(CD, toCXXCtorType(Type));
Richard Smith5179eb72016-06-28 19:03:57 +0000275
276 // A base class inheriting constructor doesn't get forwarded arguments
277 // needed to construct a virtual base (or base class thereof).
278 if (auto Inherited = CD->getInheritedConstructor())
279 PassParams = inheritingCtorHasParams(Inherited, toCXXCtorType(Type));
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000280 } else {
281 auto *DD = dyn_cast<CXXDestructorDecl>(MD);
282 GD = GlobalDecl(DD, toCXXDtorType(Type));
283 }
Anders Carlsson82ba57c2009-11-25 03:15:49 +0000284
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000285 CanQual<FunctionProtoType> FTP = GetFormalType(MD);
John McCall5d865c322010-08-31 07:33:07 +0000286
287 // Add the formal parameters.
Richard Smith5179eb72016-06-28 19:03:57 +0000288 if (PassParams)
289 appendParameterTypes(*this, argTypes, paramInfos, FTP, MD);
John McCall5d865c322010-08-31 07:33:07 +0000290
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000291 TheCXXABI.buildStructorSignature(MD, Type, argTypes);
Reid Kleckner89077a12013-12-17 19:46:40 +0000292
293 RequiredArgs required =
Richard Smith5179eb72016-06-28 19:03:57 +0000294 (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size())
295 : RequiredArgs::All);
Reid Kleckner89077a12013-12-17 19:46:40 +0000296
John McCall8dda7b22012-07-07 06:41:13 +0000297 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
David Majnemer0c0b6d92014-10-31 20:09:12 +0000298 CanQualType resultType = TheCXXABI.HasThisReturn(GD)
299 ? argTypes.front()
300 : TheCXXABI.hasMostDerivedReturn(GD)
301 ? CGM.getContext().VoidPtrTy
302 : Context.VoidTy;
Peter Collingbournef7706832014-12-12 23:41:25 +0000303 return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true,
304 /*chainCall=*/false, argTypes, extInfo,
John McCallc56a8b32016-03-11 04:30:31 +0000305 paramInfos, required);
306}
307
308static SmallVector<CanQualType, 16>
309getArgTypesForCall(ASTContext &ctx, const CallArgList &args) {
310 SmallVector<CanQualType, 16> argTypes;
311 for (auto &arg : args)
312 argTypes.push_back(ctx.getCanonicalParamType(arg.Ty));
313 return argTypes;
314}
315
316static SmallVector<CanQualType, 16>
317getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) {
318 SmallVector<CanQualType, 16> argTypes;
319 for (auto &arg : args)
320 argTypes.push_back(ctx.getCanonicalParamType(arg->getType()));
321 return argTypes;
322}
323
324static void addExtParameterInfosForCall(
325 llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &paramInfos,
326 const FunctionProtoType *proto,
327 unsigned prefixArgs,
328 unsigned totalArgs) {
329 assert(proto->hasExtParameterInfos());
330 assert(paramInfos.size() <= prefixArgs);
331 assert(proto->getNumParams() + prefixArgs <= totalArgs);
332
333 // Add default infos for any prefix args that don't already have infos.
334 paramInfos.resize(prefixArgs);
335
336 // Add infos for the prototype.
337 auto protoInfos = proto->getExtParameterInfos();
338 paramInfos.append(protoInfos.begin(), protoInfos.end());
339
340 // Add default infos for the variadic arguments.
341 paramInfos.resize(totalArgs);
342}
343
344static llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16>
345getExtParameterInfosForCall(const FunctionProtoType *proto,
346 unsigned prefixArgs, unsigned totalArgs) {
347 llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> result;
348 if (proto->hasExtParameterInfos()) {
349 addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs);
350 }
351 return result;
Anders Carlsson82ba57c2009-11-25 03:15:49 +0000352}
353
Reid Kleckner314ef7b2014-02-01 00:04:45 +0000354/// Arrange a call to a C++ method, passing the given arguments.
355const CGFunctionInfo &
356CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args,
357 const CXXConstructorDecl *D,
358 CXXCtorType CtorKind,
359 unsigned ExtraArgs) {
360 // FIXME: Kill copy.
361 SmallVector<CanQualType, 16> ArgTypes;
Alexey Samsonov3551e312014-08-13 20:06:24 +0000362 for (const auto &Arg : args)
363 ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
Reid Kleckner314ef7b2014-02-01 00:04:45 +0000364
365 CanQual<FunctionProtoType> FPT = GetFormalType(D);
George Burgess IV419996c2016-06-16 23:06:04 +0000366 RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs, D);
Reid Kleckner314ef7b2014-02-01 00:04:45 +0000367 GlobalDecl GD(D, CtorKind);
David Majnemer0c0b6d92014-10-31 20:09:12 +0000368 CanQualType ResultType = TheCXXABI.HasThisReturn(GD)
369 ? ArgTypes.front()
370 : TheCXXABI.hasMostDerivedReturn(GD)
371 ? CGM.getContext().VoidPtrTy
372 : Context.VoidTy;
Reid Kleckner314ef7b2014-02-01 00:04:45 +0000373
374 FunctionType::ExtInfo Info = FPT->getExtInfo();
John McCallc56a8b32016-03-11 04:30:31 +0000375 auto ParamInfos = getExtParameterInfosForCall(FPT.getTypePtr(), 1 + ExtraArgs,
376 ArgTypes.size());
Peter Collingbournef7706832014-12-12 23:41:25 +0000377 return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true,
378 /*chainCall=*/false, ArgTypes, Info,
John McCallc56a8b32016-03-11 04:30:31 +0000379 ParamInfos, Required);
Reid Kleckner314ef7b2014-02-01 00:04:45 +0000380}
381
John McCalla729c622012-02-17 03:33:10 +0000382/// Arrange the argument and result information for the declaration or
383/// definition of the given function.
384const CGFunctionInfo &
385CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
Chris Lattnerbea5b622009-05-12 20:27:19 +0000386 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
Anders Carlssonb15b55c2009-04-03 22:48:58 +0000387 if (MD->isInstance())
John McCalla729c622012-02-17 03:33:10 +0000388 return arrangeCXXMethodDeclaration(MD);
Mike Stump11289f42009-09-09 15:08:12 +0000389
John McCall2da83a32010-02-26 00:48:12 +0000390 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
John McCalla729c622012-02-17 03:33:10 +0000391
John McCall2da83a32010-02-26 00:48:12 +0000392 assert(isa<FunctionType>(FTy));
John McCalla729c622012-02-17 03:33:10 +0000393
394 // When declaring a function without a prototype, always use a
395 // non-variadic type.
396 if (isa<FunctionNoProtoType>(FTy)) {
397 CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>();
Peter Collingbournef7706832014-12-12 23:41:25 +0000398 return arrangeLLVMFunctionInfo(
399 noProto->getReturnType(), /*instanceMethod=*/false,
John McCallc56a8b32016-03-11 04:30:31 +0000400 /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All);
John McCalla729c622012-02-17 03:33:10 +0000401 }
402
John McCall2da83a32010-02-26 00:48:12 +0000403 assert(isa<FunctionProtoType>(FTy));
George Burgess IV3e3bb95b2015-12-02 21:58:08 +0000404 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>(), FD);
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +0000405}
406
John McCalla729c622012-02-17 03:33:10 +0000407/// Arrange the argument and result information for the declaration or
408/// definition of an Objective-C method.
409const CGFunctionInfo &
410CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) {
411 // It happens that this is the same as a call with no optional
412 // arguments, except also using the formal 'self' type.
413 return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType());
414}
415
416/// Arrange the argument and result information for the function type
417/// through which to perform a send to the given Objective-C method,
418/// using the given receiver type. The receiver type is not always
419/// the 'self' type of the method or even an Objective-C pointer type.
420/// This is *not* the right method for actually performing such a
421/// message send, due to the possibility of optional arguments.
422const CGFunctionInfo &
423CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
424 QualType receiverType) {
425 SmallVector<CanQualType, 16> argTys;
426 argTys.push_back(Context.getCanonicalParamType(receiverType));
427 argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +0000428 // FIXME: Kill copy?
David Majnemer59f77922016-06-24 04:05:48 +0000429 for (const auto *I : MD->parameters()) {
Aaron Ballman43b68be2014-03-07 17:50:17 +0000430 argTys.push_back(Context.getCanonicalParamType(I->getType()));
John McCall8ee376f2010-02-24 07:14:12 +0000431 }
John McCall31168b02011-06-15 23:02:42 +0000432
433 FunctionType::ExtInfo einfo;
Aaron Ballman0362a6d2013-12-18 16:23:37 +0000434 bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows();
435 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows));
John McCall31168b02011-06-15 23:02:42 +0000436
David Blaikiebbafb8a2012-03-11 07:00:24 +0000437 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +0000438 MD->hasAttr<NSReturnsRetainedAttr>())
439 einfo = einfo.withProducesResult(true);
440
John McCalla729c622012-02-17 03:33:10 +0000441 RequiredArgs required =
442 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
443
Peter Collingbournef7706832014-12-12 23:41:25 +0000444 return arrangeLLVMFunctionInfo(
445 GetReturnType(MD->getReturnType()), /*instanceMethod=*/false,
John McCallc56a8b32016-03-11 04:30:31 +0000446 /*chainCall=*/false, argTys, einfo, {}, required);
447}
448
449const CGFunctionInfo &
450CodeGenTypes::arrangeUnprototypedObjCMessageSend(QualType returnType,
451 const CallArgList &args) {
452 auto argTypes = getArgTypesForCall(Context, args);
453 FunctionType::ExtInfo einfo;
454
455 return arrangeLLVMFunctionInfo(
456 GetReturnType(returnType), /*instanceMethod=*/false,
457 /*chainCall=*/false, argTypes, einfo, {}, RequiredArgs::All);
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +0000458}
459
John McCalla729c622012-02-17 03:33:10 +0000460const CGFunctionInfo &
461CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
Anders Carlsson6710c532010-02-06 02:44:09 +0000462 // FIXME: Do we need to handle ObjCMethodDecl?
463 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000464
Anders Carlsson6710c532010-02-06 02:44:09 +0000465 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000466 return arrangeCXXStructorDeclaration(CD, getFromCtorType(GD.getCtorType()));
Anders Carlsson6710c532010-02-06 02:44:09 +0000467
468 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
Rafael Espindola8d2a19b2014-09-08 16:01:27 +0000469 return arrangeCXXStructorDeclaration(DD, getFromDtorType(GD.getDtorType()));
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000470
John McCalla729c622012-02-17 03:33:10 +0000471 return arrangeFunctionDeclaration(FD);
Anders Carlsson6710c532010-02-06 02:44:09 +0000472}
473
Reid Klecknerc3473512014-08-29 21:43:29 +0000474/// Arrange a thunk that takes 'this' as the first parameter followed by
475/// varargs. Return a void pointer, regardless of the actual return type.
476/// The body of the thunk will end in a musttail call to a function of the
477/// correct type, and the caller will bitcast the function to the correct
478/// prototype.
479const CGFunctionInfo &
480CodeGenTypes::arrangeMSMemberPointerThunk(const CXXMethodDecl *MD) {
481 assert(MD->isVirtual() && "only virtual memptrs have thunks");
482 CanQual<FunctionProtoType> FTP = GetFormalType(MD);
483 CanQualType ArgTys[] = { GetThisType(Context, MD->getParent()) };
Peter Collingbournef7706832014-12-12 23:41:25 +0000484 return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false,
485 /*chainCall=*/false, ArgTys,
John McCallc56a8b32016-03-11 04:30:31 +0000486 FTP->getExtInfo(), {}, RequiredArgs(1));
Reid Klecknerc3473512014-08-29 21:43:29 +0000487}
488
David Majnemerdfa6d202015-03-11 18:36:39 +0000489const CGFunctionInfo &
David Majnemer37fd66e2015-03-13 22:36:55 +0000490CodeGenTypes::arrangeMSCtorClosure(const CXXConstructorDecl *CD,
491 CXXCtorType CT) {
492 assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure);
493
David Majnemerdfa6d202015-03-11 18:36:39 +0000494 CanQual<FunctionProtoType> FTP = GetFormalType(CD);
495 SmallVector<CanQualType, 2> ArgTys;
496 const CXXRecordDecl *RD = CD->getParent();
497 ArgTys.push_back(GetThisType(Context, RD));
David Majnemer37fd66e2015-03-13 22:36:55 +0000498 if (CT == Ctor_CopyingClosure)
499 ArgTys.push_back(*FTP->param_type_begin());
David Majnemerdfa6d202015-03-11 18:36:39 +0000500 if (RD->getNumVBases() > 0)
501 ArgTys.push_back(Context.IntTy);
502 CallingConv CC = Context.getDefaultCallingConvention(
503 /*IsVariadic=*/false, /*IsCXXMethod=*/true);
504 return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/true,
505 /*chainCall=*/false, ArgTys,
John McCallc56a8b32016-03-11 04:30:31 +0000506 FunctionType::ExtInfo(CC), {},
507 RequiredArgs::All);
David Majnemerdfa6d202015-03-11 18:36:39 +0000508}
509
John McCallc818bbb2012-12-07 07:03:17 +0000510/// Arrange a call as unto a free function, except possibly with an
511/// additional number of formal parameters considered required.
512static const CGFunctionInfo &
513arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
Mark Lacey23455752013-10-10 20:57:00 +0000514 CodeGenModule &CGM,
John McCallc818bbb2012-12-07 07:03:17 +0000515 const CallArgList &args,
516 const FunctionType *fnType,
Peter Collingbournef7706832014-12-12 23:41:25 +0000517 unsigned numExtraRequiredArgs,
518 bool chainCall) {
John McCallc818bbb2012-12-07 07:03:17 +0000519 assert(args.size() >= numExtraRequiredArgs);
520
John McCallc56a8b32016-03-11 04:30:31 +0000521 llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
522
John McCallc818bbb2012-12-07 07:03:17 +0000523 // In most cases, there are no optional arguments.
524 RequiredArgs required = RequiredArgs::All;
525
526 // If we have a variadic prototype, the required arguments are the
527 // extra prefix plus the arguments in the prototype.
528 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
529 if (proto->isVariadic())
Alp Toker9cacbab2014-01-20 20:26:09 +0000530 required = RequiredArgs(proto->getNumParams() + numExtraRequiredArgs);
John McCallc818bbb2012-12-07 07:03:17 +0000531
John McCallc56a8b32016-03-11 04:30:31 +0000532 if (proto->hasExtParameterInfos())
533 addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs,
534 args.size());
535
John McCallc818bbb2012-12-07 07:03:17 +0000536 // If we don't have a prototype at all, but we're supposed to
537 // explicitly use the variadic convention for unprototyped calls,
538 // treat all of the arguments as required but preserve the nominal
539 // possibility of variadics.
Mark Lacey23455752013-10-10 20:57:00 +0000540 } else if (CGM.getTargetCodeGenInfo()
541 .isNoProtoCallVariadic(args,
542 cast<FunctionNoProtoType>(fnType))) {
John McCallc818bbb2012-12-07 07:03:17 +0000543 required = RequiredArgs(args.size());
544 }
545
Peter Collingbournef7706832014-12-12 23:41:25 +0000546 // FIXME: Kill copy.
547 SmallVector<CanQualType, 16> argTypes;
548 for (const auto &arg : args)
549 argTypes.push_back(CGT.getContext().getCanonicalParamType(arg.Ty));
550 return CGT.arrangeLLVMFunctionInfo(GetReturnType(fnType->getReturnType()),
551 /*instanceMethod=*/false, chainCall,
John McCallc56a8b32016-03-11 04:30:31 +0000552 argTypes, fnType->getExtInfo(), paramInfos,
553 required);
John McCallc818bbb2012-12-07 07:03:17 +0000554}
555
John McCalla729c622012-02-17 03:33:10 +0000556/// Figure out the rules for calling a function with the given formal
557/// type using the given arguments. The arguments are necessary
558/// because the function might be unprototyped, in which case it's
559/// target-dependent in crazy ways.
560const CGFunctionInfo &
John McCall8dda7b22012-07-07 06:41:13 +0000561CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
Peter Collingbournef7706832014-12-12 23:41:25 +0000562 const FunctionType *fnType,
563 bool chainCall) {
564 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType,
565 chainCall ? 1 : 0, chainCall);
John McCallc818bbb2012-12-07 07:03:17 +0000566}
John McCalla729c622012-02-17 03:33:10 +0000567
John McCallc56a8b32016-03-11 04:30:31 +0000568/// A block function is essentially a free function with an
John McCallc818bbb2012-12-07 07:03:17 +0000569/// extra implicit argument.
570const CGFunctionInfo &
571CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
572 const FunctionType *fnType) {
Peter Collingbournef7706832014-12-12 23:41:25 +0000573 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1,
574 /*chainCall=*/false);
John McCalla729c622012-02-17 03:33:10 +0000575}
576
577const CGFunctionInfo &
John McCallc56a8b32016-03-11 04:30:31 +0000578CodeGenTypes::arrangeBlockFunctionDeclaration(const FunctionProtoType *proto,
579 const FunctionArgList &params) {
580 auto paramInfos = getExtParameterInfosForCall(proto, 1, params.size());
581 auto argTypes = getArgTypesForDeclaration(Context, params);
582
George Burgess IV419996c2016-06-16 23:06:04 +0000583 return arrangeLLVMFunctionInfo(
584 GetReturnType(proto->getReturnType()),
585 /*instanceMethod*/ false, /*chainCall*/ false, argTypes,
586 proto->getExtInfo(), paramInfos,
587 RequiredArgs::forPrototypePlus(proto, 1, nullptr));
John McCallc56a8b32016-03-11 04:30:31 +0000588}
589
590const CGFunctionInfo &
591CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType,
592 const CallArgList &args) {
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +0000593 // FIXME: Kill copy.
John McCalla729c622012-02-17 03:33:10 +0000594 SmallVector<CanQualType, 16> argTypes;
Alexey Samsonov3551e312014-08-13 20:06:24 +0000595 for (const auto &Arg : args)
596 argTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
Peter Collingbournef7706832014-12-12 23:41:25 +0000597 return arrangeLLVMFunctionInfo(
598 GetReturnType(resultType), /*instanceMethod=*/false,
John McCallc56a8b32016-03-11 04:30:31 +0000599 /*chainCall=*/false, argTypes, FunctionType::ExtInfo(),
600 /*paramInfos=*/ {}, RequiredArgs::All);
John McCall8dda7b22012-07-07 06:41:13 +0000601}
602
John McCallc56a8b32016-03-11 04:30:31 +0000603const CGFunctionInfo &
604CodeGenTypes::arrangeBuiltinFunctionDeclaration(QualType resultType,
605 const FunctionArgList &args) {
606 auto argTypes = getArgTypesForDeclaration(Context, args);
607
608 return arrangeLLVMFunctionInfo(
609 GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false,
610 argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
611}
612
613const CGFunctionInfo &
614CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType,
615 ArrayRef<CanQualType> argTypes) {
616 return arrangeLLVMFunctionInfo(
617 resultType, /*instanceMethod=*/false, /*chainCall=*/false,
618 argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
619}
620
John McCall8dda7b22012-07-07 06:41:13 +0000621/// Arrange a call to a C++ method, passing the given arguments.
622const CGFunctionInfo &
623CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
John McCallc56a8b32016-03-11 04:30:31 +0000624 const FunctionProtoType *proto,
John McCall8dda7b22012-07-07 06:41:13 +0000625 RequiredArgs required) {
John McCallc56a8b32016-03-11 04:30:31 +0000626 unsigned numRequiredArgs =
627 (proto->isVariadic() ? required.getNumRequiredArgs() : args.size());
628 unsigned numPrefixArgs = numRequiredArgs - proto->getNumParams();
629 auto paramInfos =
630 getExtParameterInfosForCall(proto, numPrefixArgs, args.size());
631
John McCall8dda7b22012-07-07 06:41:13 +0000632 // FIXME: Kill copy.
John McCallc56a8b32016-03-11 04:30:31 +0000633 auto argTypes = getArgTypesForCall(Context, args);
John McCall8dda7b22012-07-07 06:41:13 +0000634
John McCallc56a8b32016-03-11 04:30:31 +0000635 FunctionType::ExtInfo info = proto->getExtInfo();
Peter Collingbournef7706832014-12-12 23:41:25 +0000636 return arrangeLLVMFunctionInfo(
John McCallc56a8b32016-03-11 04:30:31 +0000637 GetReturnType(proto->getReturnType()), /*instanceMethod=*/true,
638 /*chainCall=*/false, argTypes, info, paramInfos, required);
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +0000639}
640
John McCalla729c622012-02-17 03:33:10 +0000641const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
Peter Collingbournef7706832014-12-12 23:41:25 +0000642 return arrangeLLVMFunctionInfo(
643 getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false,
John McCallc56a8b32016-03-11 04:30:31 +0000644 None, FunctionType::ExtInfo(), {}, RequiredArgs::All);
645}
646
647const CGFunctionInfo &
648CodeGenTypes::arrangeCall(const CGFunctionInfo &signature,
649 const CallArgList &args) {
650 assert(signature.arg_size() <= args.size());
651 if (signature.arg_size() == args.size())
652 return signature;
653
654 SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
655 auto sigParamInfos = signature.getExtParameterInfos();
656 if (!sigParamInfos.empty()) {
657 paramInfos.append(sigParamInfos.begin(), sigParamInfos.end());
658 paramInfos.resize(args.size());
659 }
660
661 auto argTypes = getArgTypesForCall(Context, args);
662
663 assert(signature.getRequiredArgs().allowsOptionalArgs());
664 return arrangeLLVMFunctionInfo(signature.getReturnType(),
665 signature.isInstanceMethod(),
666 signature.isChainCall(),
667 argTypes,
668 signature.getExtInfo(),
669 paramInfos,
670 signature.getRequiredArgs());
John McCalla738c252011-03-09 04:27:21 +0000671}
672
John McCalla729c622012-02-17 03:33:10 +0000673/// Arrange the argument and result information for an abstract value
674/// of a given function type. This is the method which all of the
675/// above functions ultimately defer to.
676const CGFunctionInfo &
John McCall8dda7b22012-07-07 06:41:13 +0000677CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
Peter Collingbournef7706832014-12-12 23:41:25 +0000678 bool instanceMethod,
679 bool chainCall,
John McCall8dda7b22012-07-07 06:41:13 +0000680 ArrayRef<CanQualType> argTypes,
681 FunctionType::ExtInfo info,
John McCallc56a8b32016-03-11 04:30:31 +0000682 ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos,
John McCall8dda7b22012-07-07 06:41:13 +0000683 RequiredArgs required) {
Saleem Abdulrasool32d1a962014-11-25 03:49:50 +0000684 assert(std::all_of(argTypes.begin(), argTypes.end(),
685 std::mem_fun_ref(&CanQualType::isCanonicalAsParam)));
John McCall2da83a32010-02-26 00:48:12 +0000686
Daniel Dunbare0be8292009-02-03 00:07:12 +0000687 // Lookup or create unique function info.
688 llvm::FoldingSetNodeID ID;
John McCallc56a8b32016-03-11 04:30:31 +0000689 CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos,
690 required, resultType, argTypes);
Daniel Dunbare0be8292009-02-03 00:07:12 +0000691
Craig Topper8a13c412014-05-21 05:09:00 +0000692 void *insertPos = nullptr;
John McCalla729c622012-02-17 03:33:10 +0000693 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
Daniel Dunbare0be8292009-02-03 00:07:12 +0000694 if (FI)
695 return *FI;
696
John McCallc56a8b32016-03-11 04:30:31 +0000697 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
698
John McCalla729c622012-02-17 03:33:10 +0000699 // Construct the function info. We co-allocate the ArgInfos.
Peter Collingbournef7706832014-12-12 23:41:25 +0000700 FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info,
John McCallc56a8b32016-03-11 04:30:31 +0000701 paramInfos, resultType, argTypes, required);
John McCalla729c622012-02-17 03:33:10 +0000702 FunctionInfos.InsertNode(FI, insertPos);
Daniel Dunbar313321e2009-02-03 05:31:23 +0000703
David Blaikie82e95a32014-11-19 07:49:47 +0000704 bool inserted = FunctionsBeingProcessed.insert(FI).second;
705 (void)inserted;
John McCalla729c622012-02-17 03:33:10 +0000706 assert(inserted && "Recursively being processed?");
Chris Lattner6fb0ccf2011-07-15 05:16:14 +0000707
Daniel Dunbar313321e2009-02-03 05:31:23 +0000708 // Compute ABI information.
John McCall12f23522016-04-04 18:33:08 +0000709 if (info.getCC() != CC_Swift) {
710 getABIInfo().computeInfo(*FI);
711 } else {
712 swiftcall::computeABIInfo(CGM, *FI);
713 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000714
Chris Lattnerfe34c1d2010-07-29 06:26:06 +0000715 // Loop over all of the computed argument and return value info. If any of
716 // them are direct or extend without a specified coerce type, specify the
717 // default now.
John McCalla729c622012-02-17 03:33:10 +0000718 ABIArgInfo &retInfo = FI->getReturnInfo();
Craig Topper8a13c412014-05-21 05:09:00 +0000719 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr)
John McCalla729c622012-02-17 03:33:10 +0000720 retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000721
Aaron Ballmanec47bc22014-03-17 18:10:01 +0000722 for (auto &I : FI->arguments())
Craig Topper8a13c412014-05-21 05:09:00 +0000723 if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr)
Aaron Ballmanec47bc22014-03-17 18:10:01 +0000724 I.info.setCoerceToType(ConvertType(I.type));
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000725
John McCalla729c622012-02-17 03:33:10 +0000726 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
727 assert(erased && "Not in set?");
Chris Lattner1a651332011-07-15 06:41:05 +0000728
Daniel Dunbare0be8292009-02-03 00:07:12 +0000729 return *FI;
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +0000730}
731
John McCalla729c622012-02-17 03:33:10 +0000732CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
Peter Collingbournef7706832014-12-12 23:41:25 +0000733 bool instanceMethod,
734 bool chainCall,
John McCalla729c622012-02-17 03:33:10 +0000735 const FunctionType::ExtInfo &info,
John McCallc56a8b32016-03-11 04:30:31 +0000736 ArrayRef<ExtParameterInfo> paramInfos,
John McCalla729c622012-02-17 03:33:10 +0000737 CanQualType resultType,
738 ArrayRef<CanQualType> argTypes,
739 RequiredArgs required) {
John McCallc56a8b32016-03-11 04:30:31 +0000740 assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
741
742 void *buffer =
743 operator new(totalSizeToAlloc<ArgInfo, ExtParameterInfo>(
744 argTypes.size() + 1, paramInfos.size()));
745
John McCalla729c622012-02-17 03:33:10 +0000746 CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
747 FI->CallingConvention = llvmCC;
748 FI->EffectiveCallingConvention = llvmCC;
749 FI->ASTCallingConvention = info.getCC();
Peter Collingbournef7706832014-12-12 23:41:25 +0000750 FI->InstanceMethod = instanceMethod;
751 FI->ChainCall = chainCall;
John McCalla729c622012-02-17 03:33:10 +0000752 FI->NoReturn = info.getNoReturn();
753 FI->ReturnsRetained = info.getProducesResult();
754 FI->Required = required;
755 FI->HasRegParm = info.getHasRegParm();
756 FI->RegParm = info.getRegParm();
Craig Topper8a13c412014-05-21 05:09:00 +0000757 FI->ArgStruct = nullptr;
John McCall7f416cc2015-09-08 08:05:57 +0000758 FI->ArgStructAlign = 0;
John McCalla729c622012-02-17 03:33:10 +0000759 FI->NumArgs = argTypes.size();
John McCallc56a8b32016-03-11 04:30:31 +0000760 FI->HasExtParameterInfos = !paramInfos.empty();
John McCalla729c622012-02-17 03:33:10 +0000761 FI->getArgsBuffer()[0].type = resultType;
762 for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
763 FI->getArgsBuffer()[i + 1].type = argTypes[i];
John McCallc56a8b32016-03-11 04:30:31 +0000764 for (unsigned i = 0, e = paramInfos.size(); i != e; ++i)
765 FI->getExtParameterInfosBuffer()[i] = paramInfos[i];
John McCalla729c622012-02-17 03:33:10 +0000766 return FI;
Daniel Dunbar313321e2009-02-03 05:31:23 +0000767}
768
769/***/
770
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000771namespace {
772// ABIArgInfo::Expand implementation.
773
774// Specifies the way QualType passed as ABIArgInfo::Expand is expanded.
775struct TypeExpansion {
776 enum TypeExpansionKind {
777 // Elements of constant arrays are expanded recursively.
778 TEK_ConstantArray,
779 // Record fields are expanded recursively (but if record is a union, only
780 // the field with the largest size is expanded).
781 TEK_Record,
782 // For complex types, real and imaginary parts are expanded recursively.
783 TEK_Complex,
784 // All other types are not expandable.
785 TEK_None
786 };
787
788 const TypeExpansionKind Kind;
789
790 TypeExpansion(TypeExpansionKind K) : Kind(K) {}
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +0000791 virtual ~TypeExpansion() {}
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000792};
793
794struct ConstantArrayExpansion : TypeExpansion {
795 QualType EltTy;
796 uint64_t NumElts;
797
798 ConstantArrayExpansion(QualType EltTy, uint64_t NumElts)
799 : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}
800 static bool classof(const TypeExpansion *TE) {
801 return TE->Kind == TEK_ConstantArray;
802 }
803};
804
805struct RecordExpansion : TypeExpansion {
Reid Klecknere9f6a712014-10-31 17:10:41 +0000806 SmallVector<const CXXBaseSpecifier *, 1> Bases;
807
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000808 SmallVector<const FieldDecl *, 1> Fields;
809
Reid Klecknere9f6a712014-10-31 17:10:41 +0000810 RecordExpansion(SmallVector<const CXXBaseSpecifier *, 1> &&Bases,
811 SmallVector<const FieldDecl *, 1> &&Fields)
Benjamin Kramer0bb97742016-02-13 16:00:13 +0000812 : TypeExpansion(TEK_Record), Bases(std::move(Bases)),
813 Fields(std::move(Fields)) {}
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000814 static bool classof(const TypeExpansion *TE) {
815 return TE->Kind == TEK_Record;
816 }
817};
818
819struct ComplexExpansion : TypeExpansion {
820 QualType EltTy;
821
822 ComplexExpansion(QualType EltTy) : TypeExpansion(TEK_Complex), EltTy(EltTy) {}
823 static bool classof(const TypeExpansion *TE) {
824 return TE->Kind == TEK_Complex;
825 }
826};
827
828struct NoExpansion : TypeExpansion {
829 NoExpansion() : TypeExpansion(TEK_None) {}
830 static bool classof(const TypeExpansion *TE) {
831 return TE->Kind == TEK_None;
832 }
833};
834} // namespace
835
836static std::unique_ptr<TypeExpansion>
837getTypeExpansion(QualType Ty, const ASTContext &Context) {
838 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
839 return llvm::make_unique<ConstantArrayExpansion>(
840 AT->getElementType(), AT->getSize().getZExtValue());
841 }
842 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Reid Klecknere9f6a712014-10-31 17:10:41 +0000843 SmallVector<const CXXBaseSpecifier *, 1> Bases;
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000844 SmallVector<const FieldDecl *, 1> Fields;
Bob Wilsone826a2a2011-08-03 05:58:22 +0000845 const RecordDecl *RD = RT->getDecl();
846 assert(!RD->hasFlexibleArrayMember() &&
847 "Cannot expand structure with flexible array.");
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000848 if (RD->isUnion()) {
849 // Unions can be here only in degenerative cases - all the fields are same
850 // after flattening. Thus we have to use the "largest" field.
Craig Topper8a13c412014-05-21 05:09:00 +0000851 const FieldDecl *LargestFD = nullptr;
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000852 CharUnits UnionSize = CharUnits::Zero();
853
Aaron Ballmane8a8bae2014-03-08 20:12:42 +0000854 for (const auto *FD : RD->fields()) {
Reid Kleckner80944df2014-10-31 22:00:51 +0000855 // Skip zero length bitfields.
856 if (FD->isBitField() && FD->getBitWidthValue(Context) == 0)
857 continue;
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000858 assert(!FD->isBitField() &&
859 "Cannot expand structure with bit-field members.");
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000860 CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType());
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000861 if (UnionSize < FieldSize) {
862 UnionSize = FieldSize;
863 LargestFD = FD;
864 }
865 }
866 if (LargestFD)
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000867 Fields.push_back(LargestFD);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000868 } else {
Reid Klecknere9f6a712014-10-31 17:10:41 +0000869 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
870 assert(!CXXRD->isDynamicClass() &&
871 "cannot expand vtable pointers in dynamic classes");
872 for (const CXXBaseSpecifier &BS : CXXRD->bases())
873 Bases.push_back(&BS);
874 }
875
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000876 for (const auto *FD : RD->fields()) {
Reid Kleckner80944df2014-10-31 22:00:51 +0000877 // Skip zero length bitfields.
878 if (FD->isBitField() && FD->getBitWidthValue(Context) == 0)
879 continue;
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000880 assert(!FD->isBitField() &&
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000881 "Cannot expand structure with bit-field members.");
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000882 Fields.push_back(FD);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +0000883 }
Bob Wilsone826a2a2011-08-03 05:58:22 +0000884 }
Reid Klecknere9f6a712014-10-31 17:10:41 +0000885 return llvm::make_unique<RecordExpansion>(std::move(Bases),
886 std::move(Fields));
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000887 }
888 if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
889 return llvm::make_unique<ComplexExpansion>(CT->getElementType());
890 }
891 return llvm::make_unique<NoExpansion>();
892}
893
Alexey Samsonov52c0f6a2014-09-29 20:30:22 +0000894static int getExpansionSize(QualType Ty, const ASTContext &Context) {
895 auto Exp = getTypeExpansion(Ty, Context);
896 if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
897 return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context);
898 }
899 if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
900 int Res = 0;
Reid Klecknere9f6a712014-10-31 17:10:41 +0000901 for (auto BS : RExp->Bases)
902 Res += getExpansionSize(BS->getType(), Context);
Alexey Samsonov52c0f6a2014-09-29 20:30:22 +0000903 for (auto FD : RExp->Fields)
904 Res += getExpansionSize(FD->getType(), Context);
905 return Res;
906 }
907 if (isa<ComplexExpansion>(Exp.get()))
908 return 2;
909 assert(isa<NoExpansion>(Exp.get()));
910 return 1;
911}
912
Alexey Samsonov153004f2014-09-29 22:08:00 +0000913void
914CodeGenTypes::getExpandedTypes(QualType Ty,
915 SmallVectorImpl<llvm::Type *>::iterator &TI) {
916 auto Exp = getTypeExpansion(Ty, Context);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000917 if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
918 for (int i = 0, n = CAExp->NumElts; i < n; i++) {
Alexey Samsonov153004f2014-09-29 22:08:00 +0000919 getExpandedTypes(CAExp->EltTy, TI);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000920 }
921 } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
Reid Klecknere9f6a712014-10-31 17:10:41 +0000922 for (auto BS : RExp->Bases)
923 getExpandedTypes(BS->getType(), TI);
924 for (auto FD : RExp->Fields)
Alexey Samsonov153004f2014-09-29 22:08:00 +0000925 getExpandedTypes(FD->getType(), TI);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000926 } else if (auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
927 llvm::Type *EltTy = ConvertType(CExp->EltTy);
Alexey Samsonov153004f2014-09-29 22:08:00 +0000928 *TI++ = EltTy;
929 *TI++ = EltTy;
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000930 } else {
931 assert(isa<NoExpansion>(Exp.get()));
Alexey Samsonov153004f2014-09-29 22:08:00 +0000932 *TI++ = ConvertType(Ty);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000933 }
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000934}
935
John McCall7f416cc2015-09-08 08:05:57 +0000936static void forConstantArrayExpansion(CodeGenFunction &CGF,
937 ConstantArrayExpansion *CAE,
938 Address BaseAddr,
939 llvm::function_ref<void(Address)> Fn) {
940 CharUnits EltSize = CGF.getContext().getTypeSizeInChars(CAE->EltTy);
941 CharUnits EltAlign =
942 BaseAddr.getAlignment().alignmentOfArrayElement(EltSize);
943
944 for (int i = 0, n = CAE->NumElts; i < n; i++) {
945 llvm::Value *EltAddr =
946 CGF.Builder.CreateConstGEP2_32(nullptr, BaseAddr.getPointer(), 0, i);
947 Fn(Address(EltAddr, EltAlign));
948 }
949}
950
Alexey Samsonov91cf4552014-08-22 01:06:06 +0000951void CodeGenFunction::ExpandTypeFromArgs(
John McCall12f23522016-04-04 18:33:08 +0000952 QualType Ty, LValue LV, SmallVectorImpl<llvm::Value *>::iterator &AI) {
Mike Stump11289f42009-09-09 15:08:12 +0000953 assert(LV.isSimple() &&
954 "Unexpected non-simple lvalue during struct expansion.");
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000955
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000956 auto Exp = getTypeExpansion(Ty, getContext());
957 if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
John McCall7f416cc2015-09-08 08:05:57 +0000958 forConstantArrayExpansion(*this, CAExp, LV.getAddress(),
959 [&](Address EltAddr) {
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000960 LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);
961 ExpandTypeFromArgs(CAExp->EltTy, LV, AI);
John McCall7f416cc2015-09-08 08:05:57 +0000962 });
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000963 } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
John McCall7f416cc2015-09-08 08:05:57 +0000964 Address This = LV.getAddress();
Reid Klecknere9f6a712014-10-31 17:10:41 +0000965 for (const CXXBaseSpecifier *BS : RExp->Bases) {
966 // Perform a single step derived-to-base conversion.
John McCall7f416cc2015-09-08 08:05:57 +0000967 Address Base =
Reid Klecknere9f6a712014-10-31 17:10:41 +0000968 GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
969 /*NullCheckValue=*/false, SourceLocation());
970 LValue SubLV = MakeAddrLValue(Base, BS->getType());
971
972 // Recurse onto bases.
973 ExpandTypeFromArgs(BS->getType(), SubLV, AI);
974 }
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000975 for (auto FD : RExp->Fields) {
976 // FIXME: What are the right qualifiers here?
Reid Kleckner9d031092016-05-02 22:42:34 +0000977 LValue SubLV = EmitLValueForFieldInitialization(LV, FD);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000978 ExpandTypeFromArgs(FD->getType(), SubLV, AI);
Bob Wilsone826a2a2011-08-03 05:58:22 +0000979 }
John McCall7f416cc2015-09-08 08:05:57 +0000980 } else if (isa<ComplexExpansion>(Exp.get())) {
981 auto realValue = *AI++;
982 auto imagValue = *AI++;
983 EmitStoreOfComplex(ComplexPairTy(realValue, imagValue), LV, /*init*/ true);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000984 } else {
985 assert(isa<NoExpansion>(Exp.get()));
986 EmitStoreThroughLValue(RValue::get(*AI++), LV);
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000987 }
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000988}
989
990void CodeGenFunction::ExpandTypeToArgs(
991 QualType Ty, RValue RV, llvm::FunctionType *IRFuncTy,
992 SmallVectorImpl<llvm::Value *> &IRCallArgs, unsigned &IRCallArgPos) {
993 auto Exp = getTypeExpansion(Ty, getContext());
994 if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
John McCall7f416cc2015-09-08 08:05:57 +0000995 forConstantArrayExpansion(*this, CAExp, RV.getAggregateAddress(),
996 [&](Address EltAddr) {
Alexey Samsonov8a0bad02014-09-29 18:41:28 +0000997 RValue EltRV =
998 convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation());
999 ExpandTypeToArgs(CAExp->EltTy, EltRV, IRFuncTy, IRCallArgs, IRCallArgPos);
John McCall7f416cc2015-09-08 08:05:57 +00001000 });
Alexey Samsonov8a0bad02014-09-29 18:41:28 +00001001 } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
John McCall7f416cc2015-09-08 08:05:57 +00001002 Address This = RV.getAggregateAddress();
Reid Klecknere9f6a712014-10-31 17:10:41 +00001003 for (const CXXBaseSpecifier *BS : RExp->Bases) {
1004 // Perform a single step derived-to-base conversion.
John McCall7f416cc2015-09-08 08:05:57 +00001005 Address Base =
Reid Klecknere9f6a712014-10-31 17:10:41 +00001006 GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
1007 /*NullCheckValue=*/false, SourceLocation());
1008 RValue BaseRV = RValue::getAggregate(Base);
1009
1010 // Recurse onto bases.
1011 ExpandTypeToArgs(BS->getType(), BaseRV, IRFuncTy, IRCallArgs,
1012 IRCallArgPos);
1013 }
1014
1015 LValue LV = MakeAddrLValue(This, Ty);
Alexey Samsonov8a0bad02014-09-29 18:41:28 +00001016 for (auto FD : RExp->Fields) {
1017 RValue FldRV = EmitRValueForField(LV, FD, SourceLocation());
1018 ExpandTypeToArgs(FD->getType(), FldRV, IRFuncTy, IRCallArgs,
1019 IRCallArgPos);
1020 }
1021 } else if (isa<ComplexExpansion>(Exp.get())) {
1022 ComplexPairTy CV = RV.getComplexVal();
1023 IRCallArgs[IRCallArgPos++] = CV.first;
1024 IRCallArgs[IRCallArgPos++] = CV.second;
1025 } else {
1026 assert(isa<NoExpansion>(Exp.get()));
1027 assert(RV.isScalar() &&
1028 "Unexpected non-scalar rvalue during struct expansion.");
1029
1030 // Insert a bitcast as needed.
1031 llvm::Value *V = RV.getScalarVal();
1032 if (IRCallArgPos < IRFuncTy->getNumParams() &&
1033 V->getType() != IRFuncTy->getParamType(IRCallArgPos))
1034 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
1035
1036 IRCallArgs[IRCallArgPos++] = V;
1037 }
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00001038}
1039
John McCall7f416cc2015-09-08 08:05:57 +00001040/// Create a temporary allocation for the purposes of coercion.
1041static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty,
1042 CharUnits MinAlign) {
1043 // Don't use an alignment that's worse than what LLVM would prefer.
1044 auto PrefAlign = CGF.CGM.getDataLayout().getPrefTypeAlignment(Ty);
1045 CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
1046
1047 return CGF.CreateTempAlloca(Ty, Align);
1048}
1049
Chris Lattner895c52b2010-06-27 06:04:18 +00001050/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
Chris Lattner1cd66982010-06-27 05:56:15 +00001051/// accessing some number of bytes out of it, try to gep into the struct to get
1052/// at its inner goodness. Dive as deep as possible without entering an element
1053/// with an in-memory size smaller than DstSize.
John McCall7f416cc2015-09-08 08:05:57 +00001054static Address
1055EnterStructPointerForCoercedAccess(Address SrcPtr,
Chris Lattner2192fe52011-07-18 04:24:23 +00001056 llvm::StructType *SrcSTy,
Chris Lattner895c52b2010-06-27 06:04:18 +00001057 uint64_t DstSize, CodeGenFunction &CGF) {
Chris Lattner1cd66982010-06-27 05:56:15 +00001058 // We can't dive into a zero-element struct.
1059 if (SrcSTy->getNumElements() == 0) return SrcPtr;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001060
Chris Lattner2192fe52011-07-18 04:24:23 +00001061 llvm::Type *FirstElt = SrcSTy->getElementType(0);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001062
Chris Lattner1cd66982010-06-27 05:56:15 +00001063 // If the first elt is at least as large as what we're looking for, or if the
James Molloy90d61012014-08-29 10:17:52 +00001064 // first element is the same size as the whole struct, we can enter it. The
1065 // comparison must be made on the store size and not the alloca size. Using
1066 // the alloca size may overstate the size of the load.
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001067 uint64_t FirstEltSize =
James Molloy90d61012014-08-29 10:17:52 +00001068 CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001069 if (FirstEltSize < DstSize &&
James Molloy90d61012014-08-29 10:17:52 +00001070 FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy))
Chris Lattner1cd66982010-06-27 05:56:15 +00001071 return SrcPtr;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001072
Chris Lattner1cd66982010-06-27 05:56:15 +00001073 // GEP into the first element.
John McCall7f416cc2015-09-08 08:05:57 +00001074 SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, CharUnits(), "coerce.dive");
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001075
Chris Lattner1cd66982010-06-27 05:56:15 +00001076 // If the first element is a struct, recurse.
John McCall7f416cc2015-09-08 08:05:57 +00001077 llvm::Type *SrcTy = SrcPtr.getElementType();
Chris Lattner2192fe52011-07-18 04:24:23 +00001078 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
Chris Lattner895c52b2010-06-27 06:04:18 +00001079 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
Chris Lattner1cd66982010-06-27 05:56:15 +00001080
1081 return SrcPtr;
1082}
1083
Chris Lattner055097f2010-06-27 06:26:04 +00001084/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
1085/// are either integers or pointers. This does a truncation of the value if it
1086/// is too large or a zero extension if it is too small.
Jakob Stoklund Olesen36af2522013-06-05 03:00:13 +00001087///
1088/// This behaves as if the value were coerced through memory, so on big-endian
1089/// targets the high bits are preserved in a truncation, while little-endian
1090/// targets preserve the low bits.
Chris Lattner055097f2010-06-27 06:26:04 +00001091static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
Chris Lattner2192fe52011-07-18 04:24:23 +00001092 llvm::Type *Ty,
Chris Lattner055097f2010-06-27 06:26:04 +00001093 CodeGenFunction &CGF) {
1094 if (Val->getType() == Ty)
1095 return Val;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001096
Chris Lattner055097f2010-06-27 06:26:04 +00001097 if (isa<llvm::PointerType>(Val->getType())) {
1098 // If this is Pointer->Pointer avoid conversion to and from int.
1099 if (isa<llvm::PointerType>(Ty))
1100 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001101
Chris Lattner055097f2010-06-27 06:26:04 +00001102 // Convert the pointer to an integer so we can play with its width.
Chris Lattner5e016ae2010-06-27 07:15:29 +00001103 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
Chris Lattner055097f2010-06-27 06:26:04 +00001104 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001105
Chris Lattner2192fe52011-07-18 04:24:23 +00001106 llvm::Type *DestIntTy = Ty;
Chris Lattner055097f2010-06-27 06:26:04 +00001107 if (isa<llvm::PointerType>(DestIntTy))
Chris Lattner5e016ae2010-06-27 07:15:29 +00001108 DestIntTy = CGF.IntPtrTy;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001109
Jakob Stoklund Olesen36af2522013-06-05 03:00:13 +00001110 if (Val->getType() != DestIntTy) {
1111 const llvm::DataLayout &DL = CGF.CGM.getDataLayout();
1112 if (DL.isBigEndian()) {
1113 // Preserve the high bits on big-endian targets.
1114 // That is what memory coercion does.
James Molloy491cefb2014-05-07 17:41:15 +00001115 uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType());
1116 uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy);
1117
Jakob Stoklund Olesen36af2522013-06-05 03:00:13 +00001118 if (SrcSize > DstSize) {
1119 Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits");
1120 Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii");
1121 } else {
1122 Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii");
1123 Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits");
1124 }
1125 } else {
1126 // Little-endian targets preserve the low bits. No shifts required.
1127 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
1128 }
1129 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001130
Chris Lattner055097f2010-06-27 06:26:04 +00001131 if (isa<llvm::PointerType>(Ty))
1132 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
1133 return Val;
1134}
1135
Chris Lattner1cd66982010-06-27 05:56:15 +00001136
1137
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001138/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
Ulrich Weigand6e2cea62015-07-10 11:31:43 +00001139/// a pointer to an object of type \arg Ty, known to be aligned to
1140/// \arg SrcAlign bytes.
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001141///
1142/// This safely handles the case when the src type is smaller than the
1143/// destination type; in this situation the values of bits which not
1144/// present in the src are undefined.
John McCall7f416cc2015-09-08 08:05:57 +00001145static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty,
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001146 CodeGenFunction &CGF) {
John McCall7f416cc2015-09-08 08:05:57 +00001147 llvm::Type *SrcTy = Src.getElementType();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001148
Chris Lattnerd200eda2010-06-28 22:51:39 +00001149 // If SrcTy and Ty are the same, just do a load.
1150 if (SrcTy == Ty)
John McCall7f416cc2015-09-08 08:05:57 +00001151 return CGF.Builder.CreateLoad(Src);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001152
Micah Villmowdd31ca12012-10-08 16:25:52 +00001153 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001154
Chris Lattner2192fe52011-07-18 04:24:23 +00001155 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
John McCall7f416cc2015-09-08 08:05:57 +00001156 Src = EnterStructPointerForCoercedAccess(Src, SrcSTy, DstSize, CGF);
1157 SrcTy = Src.getType()->getElementType();
Chris Lattner1cd66982010-06-27 05:56:15 +00001158 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001159
Micah Villmowdd31ca12012-10-08 16:25:52 +00001160 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001161
Chris Lattner055097f2010-06-27 06:26:04 +00001162 // If the source and destination are integer or pointer types, just do an
1163 // extension or truncation to the desired type.
1164 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
1165 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
John McCall7f416cc2015-09-08 08:05:57 +00001166 llvm::Value *Load = CGF.Builder.CreateLoad(Src);
Chris Lattner055097f2010-06-27 06:26:04 +00001167 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
1168 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001169
Daniel Dunbarb52d0772009-02-03 05:59:18 +00001170 // If load is legal, just bitcast the src pointer.
Daniel Dunbarffdb8432009-05-13 18:54:26 +00001171 if (SrcSize >= DstSize) {
Mike Stump18bb9282009-05-16 07:57:57 +00001172 // Generally SrcSize is never greater than DstSize, since this means we are
1173 // losing bits. However, this can happen in cases where the structure has
1174 // additional padding, for example due to a user specified alignment.
Daniel Dunbarffdb8432009-05-13 18:54:26 +00001175 //
Mike Stump18bb9282009-05-16 07:57:57 +00001176 // FIXME: Assert that we aren't truncating non-padding bits when have access
1177 // to that information.
John McCall7f416cc2015-09-08 08:05:57 +00001178 Src = CGF.Builder.CreateBitCast(Src, llvm::PointerType::getUnqual(Ty));
1179 return CGF.Builder.CreateLoad(Src);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001180 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001181
John McCall7f416cc2015-09-08 08:05:57 +00001182 // Otherwise do coercion through memory. This is stupid, but simple.
1183 Address Tmp = CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment());
1184 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.Int8PtrTy);
1185 Address SrcCasted = CGF.Builder.CreateBitCast(Src, CGF.Int8PtrTy);
Manman Ren84b921f2012-11-28 22:08:52 +00001186 CGF.Builder.CreateMemCpy(Casted, SrcCasted,
1187 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
John McCall7f416cc2015-09-08 08:05:57 +00001188 false);
1189 return CGF.Builder.CreateLoad(Tmp);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001190}
1191
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001192// Function to store a first-class aggregate into memory. We prefer to
1193// store the elements rather than the aggregate to be more friendly to
1194// fast-isel.
1195// FIXME: Do we need to recurse here?
1196static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
John McCall7f416cc2015-09-08 08:05:57 +00001197 Address Dest, bool DestIsVolatile) {
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001198 // Prefer scalar stores to first-class aggregate stores.
Chris Lattner2192fe52011-07-18 04:24:23 +00001199 if (llvm::StructType *STy =
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001200 dyn_cast<llvm::StructType>(Val->getType())) {
Ulrich Weigand6e2cea62015-07-10 11:31:43 +00001201 const llvm::StructLayout *Layout =
1202 CGF.CGM.getDataLayout().getStructLayout(STy);
1203
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001204 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
John McCall7f416cc2015-09-08 08:05:57 +00001205 auto EltOffset = CharUnits::fromQuantity(Layout->getElementOffset(i));
1206 Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i, EltOffset);
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001207 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
John McCall7f416cc2015-09-08 08:05:57 +00001208 CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile);
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001209 }
1210 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001211 CGF.Builder.CreateStore(Val, Dest, DestIsVolatile);
Eli Friedmanaf9b3252011-05-17 21:08:01 +00001212 }
1213}
1214
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001215/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
Ulrich Weigand6e2cea62015-07-10 11:31:43 +00001216/// where the source and destination may have different types. The
1217/// destination is known to be aligned to \arg DstAlign bytes.
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001218///
1219/// This safely handles the case when the src type is larger than the
1220/// destination type; the upper bits of the src will be lost.
1221static void CreateCoercedStore(llvm::Value *Src,
John McCall7f416cc2015-09-08 08:05:57 +00001222 Address Dst,
Anders Carlsson17490832009-12-24 20:40:36 +00001223 bool DstIsVolatile,
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001224 CodeGenFunction &CGF) {
Chris Lattner2192fe52011-07-18 04:24:23 +00001225 llvm::Type *SrcTy = Src->getType();
John McCall7f416cc2015-09-08 08:05:57 +00001226 llvm::Type *DstTy = Dst.getType()->getElementType();
Chris Lattnerd200eda2010-06-28 22:51:39 +00001227 if (SrcTy == DstTy) {
John McCall7f416cc2015-09-08 08:05:57 +00001228 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
Chris Lattnerd200eda2010-06-28 22:51:39 +00001229 return;
1230 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001231
Micah Villmowdd31ca12012-10-08 16:25:52 +00001232 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001233
Chris Lattner2192fe52011-07-18 04:24:23 +00001234 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
John McCall7f416cc2015-09-08 08:05:57 +00001235 Dst = EnterStructPointerForCoercedAccess(Dst, DstSTy, SrcSize, CGF);
1236 DstTy = Dst.getType()->getElementType();
Chris Lattner895c52b2010-06-27 06:04:18 +00001237 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001238
Chris Lattner055097f2010-06-27 06:26:04 +00001239 // If the source and destination are integer or pointer types, just do an
1240 // extension or truncation to the desired type.
1241 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
1242 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
1243 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
John McCall7f416cc2015-09-08 08:05:57 +00001244 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
Chris Lattner055097f2010-06-27 06:26:04 +00001245 return;
1246 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001247
Micah Villmowdd31ca12012-10-08 16:25:52 +00001248 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001249
Daniel Dunbar313321e2009-02-03 05:31:23 +00001250 // If store is legal, just bitcast the src pointer.
Daniel Dunbar4be99ff2009-06-05 07:58:54 +00001251 if (SrcSize <= DstSize) {
John McCall7f416cc2015-09-08 08:05:57 +00001252 Dst = CGF.Builder.CreateBitCast(Dst, llvm::PointerType::getUnqual(SrcTy));
1253 BuildAggStore(CGF, Src, Dst, DstIsVolatile);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001254 } else {
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001255 // Otherwise do coercion through memory. This is stupid, but
1256 // simple.
Daniel Dunbar4be99ff2009-06-05 07:58:54 +00001257
1258 // Generally SrcSize is never greater than DstSize, since this means we are
1259 // losing bits. However, this can happen in cases where the structure has
1260 // additional padding, for example due to a user specified alignment.
1261 //
1262 // FIXME: Assert that we aren't truncating non-padding bits when have access
1263 // to that information.
John McCall7f416cc2015-09-08 08:05:57 +00001264 Address Tmp = CreateTempAllocaForCoercion(CGF, SrcTy, Dst.getAlignment());
1265 CGF.Builder.CreateStore(Src, Tmp);
1266 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.Int8PtrTy);
1267 Address DstCasted = CGF.Builder.CreateBitCast(Dst, CGF.Int8PtrTy);
Manman Ren84b921f2012-11-28 22:08:52 +00001268 CGF.Builder.CreateMemCpy(DstCasted, Casted,
1269 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
John McCall7f416cc2015-09-08 08:05:57 +00001270 false);
Daniel Dunbarf5589ac2009-02-02 19:06:38 +00001271 }
1272}
1273
John McCall7f416cc2015-09-08 08:05:57 +00001274static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr,
1275 const ABIArgInfo &info) {
1276 if (unsigned offset = info.getDirectOffset()) {
1277 addr = CGF.Builder.CreateElementBitCast(addr, CGF.Int8Ty);
1278 addr = CGF.Builder.CreateConstInBoundsByteGEP(addr,
1279 CharUnits::fromQuantity(offset));
1280 addr = CGF.Builder.CreateElementBitCast(addr, info.getCoerceToType());
1281 }
1282 return addr;
1283}
1284
Alexey Samsonov153004f2014-09-29 22:08:00 +00001285namespace {
1286
1287/// Encapsulates information about the way function arguments from
1288/// CGFunctionInfo should be passed to actual LLVM IR function.
1289class ClangToLLVMArgMapping {
1290 static const unsigned InvalidIndex = ~0U;
1291 unsigned InallocaArgNo;
1292 unsigned SRetArgNo;
1293 unsigned TotalIRArgs;
1294
1295 /// Arguments of LLVM IR function corresponding to single Clang argument.
1296 struct IRArgs {
1297 unsigned PaddingArgIndex;
1298 // Argument is expanded to IR arguments at positions
1299 // [FirstArgIndex, FirstArgIndex + NumberOfArgs).
1300 unsigned FirstArgIndex;
1301 unsigned NumberOfArgs;
1302
1303 IRArgs()
1304 : PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex),
1305 NumberOfArgs(0) {}
1306 };
1307
1308 SmallVector<IRArgs, 8> ArgInfo;
1309
1310public:
1311 ClangToLLVMArgMapping(const ASTContext &Context, const CGFunctionInfo &FI,
1312 bool OnlyRequiredArgs = false)
1313 : InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0),
1314 ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) {
1315 construct(Context, FI, OnlyRequiredArgs);
1316 }
1317
1318 bool hasInallocaArg() const { return InallocaArgNo != InvalidIndex; }
1319 unsigned getInallocaArgNo() const {
1320 assert(hasInallocaArg());
1321 return InallocaArgNo;
1322 }
1323
1324 bool hasSRetArg() const { return SRetArgNo != InvalidIndex; }
1325 unsigned getSRetArgNo() const {
1326 assert(hasSRetArg());
1327 return SRetArgNo;
1328 }
1329
1330 unsigned totalIRArgs() const { return TotalIRArgs; }
1331
1332 bool hasPaddingArg(unsigned ArgNo) const {
1333 assert(ArgNo < ArgInfo.size());
1334 return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;
1335 }
1336 unsigned getPaddingArgNo(unsigned ArgNo) const {
1337 assert(hasPaddingArg(ArgNo));
1338 return ArgInfo[ArgNo].PaddingArgIndex;
1339 }
1340
1341 /// Returns index of first IR argument corresponding to ArgNo, and their
1342 /// quantity.
1343 std::pair<unsigned, unsigned> getIRArgs(unsigned ArgNo) const {
1344 assert(ArgNo < ArgInfo.size());
1345 return std::make_pair(ArgInfo[ArgNo].FirstArgIndex,
1346 ArgInfo[ArgNo].NumberOfArgs);
1347 }
1348
1349private:
1350 void construct(const ASTContext &Context, const CGFunctionInfo &FI,
1351 bool OnlyRequiredArgs);
1352};
1353
1354void ClangToLLVMArgMapping::construct(const ASTContext &Context,
1355 const CGFunctionInfo &FI,
1356 bool OnlyRequiredArgs) {
1357 unsigned IRArgNo = 0;
1358 bool SwapThisWithSRet = false;
1359 const ABIArgInfo &RetAI = FI.getReturnInfo();
1360
1361 if (RetAI.getKind() == ABIArgInfo::Indirect) {
1362 SwapThisWithSRet = RetAI.isSRetAfterThis();
1363 SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++;
1364 }
1365
1366 unsigned ArgNo = 0;
1367 unsigned NumArgs = OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size();
1368 for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(); ArgNo < NumArgs;
1369 ++I, ++ArgNo) {
1370 assert(I != FI.arg_end());
1371 QualType ArgType = I->type;
1372 const ABIArgInfo &AI = I->info;
1373 // Collect data about IR arguments corresponding to Clang argument ArgNo.
1374 auto &IRArgs = ArgInfo[ArgNo];
1375
1376 if (AI.getPaddingType())
1377 IRArgs.PaddingArgIndex = IRArgNo++;
1378
1379 switch (AI.getKind()) {
1380 case ABIArgInfo::Extend:
1381 case ABIArgInfo::Direct: {
1382 // FIXME: handle sseregparm someday...
1383 llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.getCoerceToType());
1384 if (AI.isDirect() && AI.getCanBeFlattened() && STy) {
1385 IRArgs.NumberOfArgs = STy->getNumElements();
1386 } else {
1387 IRArgs.NumberOfArgs = 1;
1388 }
1389 break;
1390 }
1391 case ABIArgInfo::Indirect:
1392 IRArgs.NumberOfArgs = 1;
1393 break;
1394 case ABIArgInfo::Ignore:
1395 case ABIArgInfo::InAlloca:
1396 // ignore and inalloca doesn't have matching LLVM parameters.
1397 IRArgs.NumberOfArgs = 0;
1398 break;
John McCallf26e73d2016-03-11 04:30:43 +00001399 case ABIArgInfo::CoerceAndExpand:
1400 IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size();
1401 break;
1402 case ABIArgInfo::Expand:
Alexey Samsonov153004f2014-09-29 22:08:00 +00001403 IRArgs.NumberOfArgs = getExpansionSize(ArgType, Context);
1404 break;
1405 }
Alexey Samsonov153004f2014-09-29 22:08:00 +00001406
1407 if (IRArgs.NumberOfArgs > 0) {
1408 IRArgs.FirstArgIndex = IRArgNo;
1409 IRArgNo += IRArgs.NumberOfArgs;
1410 }
1411
1412 // Skip over the sret parameter when it comes second. We already handled it
1413 // above.
1414 if (IRArgNo == 1 && SwapThisWithSRet)
1415 IRArgNo++;
1416 }
1417 assert(ArgNo == ArgInfo.size());
1418
1419 if (FI.usesInAlloca())
1420 InallocaArgNo = IRArgNo++;
1421
1422 TotalIRArgs = IRArgNo;
1423}
1424} // namespace
1425
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00001426/***/
1427
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001428bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
Daniel Dunbarb8b1c672009-02-05 08:00:50 +00001429 return FI.getReturnInfo().isIndirect();
Daniel Dunbar7633cbf2009-02-02 21:43:58 +00001430}
1431
Tim Northovere77cc392014-03-29 13:28:05 +00001432bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) {
1433 return ReturnTypeUsesSRet(FI) &&
1434 getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs();
1435}
1436
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001437bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
1438 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
1439 switch (BT->getKind()) {
1440 default:
1441 return false;
1442 case BuiltinType::Float:
John McCallc8e01702013-04-16 22:48:15 +00001443 return getTarget().useObjCFPRetForRealType(TargetInfo::Float);
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001444 case BuiltinType::Double:
John McCallc8e01702013-04-16 22:48:15 +00001445 return getTarget().useObjCFPRetForRealType(TargetInfo::Double);
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001446 case BuiltinType::LongDouble:
John McCallc8e01702013-04-16 22:48:15 +00001447 return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble);
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001448 }
1449 }
1450
1451 return false;
1452}
1453
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00001454bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) {
1455 if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
1456 if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
1457 if (BT->getKind() == BuiltinType::LongDouble)
John McCallc8e01702013-04-16 22:48:15 +00001458 return getTarget().useObjCFP2RetForComplexLongDouble();
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00001459 }
1460 }
1461
1462 return false;
1463}
1464
Chris Lattnera5f58b02011-07-09 17:41:47 +00001465llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
John McCalla729c622012-02-17 03:33:10 +00001466 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
1467 return GetFunctionType(FI);
John McCallf8ff7b92010-02-23 00:48:20 +00001468}
1469
Chris Lattnera5f58b02011-07-09 17:41:47 +00001470llvm::FunctionType *
John McCalla729c622012-02-17 03:33:10 +00001471CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
Alexey Samsonov153004f2014-09-29 22:08:00 +00001472
David Blaikie82e95a32014-11-19 07:49:47 +00001473 bool Inserted = FunctionsBeingProcessed.insert(&FI).second;
1474 (void)Inserted;
Chris Lattner6fb0ccf2011-07-15 05:16:14 +00001475 assert(Inserted && "Recursively being processed?");
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00001476
Alexey Samsonov153004f2014-09-29 22:08:00 +00001477 llvm::Type *resultType = nullptr;
John McCall85dd2c52011-05-15 02:19:42 +00001478 const ABIArgInfo &retAI = FI.getReturnInfo();
1479 switch (retAI.getKind()) {
Daniel Dunbard3674e62008-09-11 01:48:57 +00001480 case ABIArgInfo::Expand:
John McCall85dd2c52011-05-15 02:19:42 +00001481 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbard3674e62008-09-11 01:48:57 +00001482
Anton Korobeynikov18adbf52009-06-06 09:36:29 +00001483 case ABIArgInfo::Extend:
Daniel Dunbar67dace892009-02-03 06:17:37 +00001484 case ABIArgInfo::Direct:
John McCall85dd2c52011-05-15 02:19:42 +00001485 resultType = retAI.getCoerceToType();
Daniel Dunbar67dace892009-02-03 06:17:37 +00001486 break;
1487
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001488 case ABIArgInfo::InAlloca:
Reid Klecknerfab1e892014-02-25 00:59:14 +00001489 if (retAI.getInAllocaSRet()) {
1490 // sret things on win32 aren't void, they return the sret pointer.
1491 QualType ret = FI.getReturnType();
1492 llvm::Type *ty = ConvertType(ret);
1493 unsigned addressSpace = Context.getTargetAddressSpace(ret);
1494 resultType = llvm::PointerType::get(ty, addressSpace);
1495 } else {
1496 resultType = llvm::Type::getVoidTy(getLLVMContext());
1497 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001498 break;
1499
John McCall7f416cc2015-09-08 08:05:57 +00001500 case ABIArgInfo::Indirect:
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001501 case ABIArgInfo::Ignore:
John McCall85dd2c52011-05-15 02:19:42 +00001502 resultType = llvm::Type::getVoidTy(getLLVMContext());
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001503 break;
John McCallf26e73d2016-03-11 04:30:43 +00001504
1505 case ABIArgInfo::CoerceAndExpand:
1506 resultType = retAI.getUnpaddedCoerceAndExpandType();
1507 break;
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00001508 }
Mike Stump11289f42009-09-09 15:08:12 +00001509
Alexey Samsonov153004f2014-09-29 22:08:00 +00001510 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true);
1511 SmallVector<llvm::Type*, 8> ArgTypes(IRFunctionArgs.totalIRArgs());
1512
1513 // Add type for sret argument.
1514 if (IRFunctionArgs.hasSRetArg()) {
1515 QualType Ret = FI.getReturnType();
1516 llvm::Type *Ty = ConvertType(Ret);
1517 unsigned AddressSpace = Context.getTargetAddressSpace(Ret);
1518 ArgTypes[IRFunctionArgs.getSRetArgNo()] =
1519 llvm::PointerType::get(Ty, AddressSpace);
1520 }
1521
1522 // Add type for inalloca argument.
1523 if (IRFunctionArgs.hasInallocaArg()) {
1524 auto ArgStruct = FI.getArgStruct();
1525 assert(ArgStruct);
1526 ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo();
1527 }
1528
John McCallc818bbb2012-12-07 07:03:17 +00001529 // Add in all of the required arguments.
Alexey Samsonov153004f2014-09-29 22:08:00 +00001530 unsigned ArgNo = 0;
Alexey Samsonov34625dd2014-09-29 21:21:48 +00001531 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
1532 ie = it + FI.getNumRequiredArgs();
Alexey Samsonov153004f2014-09-29 22:08:00 +00001533 for (; it != ie; ++it, ++ArgNo) {
1534 const ABIArgInfo &ArgInfo = it->info;
Mike Stump11289f42009-09-09 15:08:12 +00001535
Rafael Espindolafad28de2012-10-24 01:59:00 +00001536 // Insert a padding type to ensure proper alignment.
Alexey Samsonov153004f2014-09-29 22:08:00 +00001537 if (IRFunctionArgs.hasPaddingArg(ArgNo))
1538 ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
1539 ArgInfo.getPaddingType();
Rafael Espindolafad28de2012-10-24 01:59:00 +00001540
Alexey Samsonov153004f2014-09-29 22:08:00 +00001541 unsigned FirstIRArg, NumIRArgs;
1542 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1543
1544 switch (ArgInfo.getKind()) {
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001545 case ABIArgInfo::Ignore:
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001546 case ABIArgInfo::InAlloca:
Alexey Samsonov153004f2014-09-29 22:08:00 +00001547 assert(NumIRArgs == 0);
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001548 break;
1549
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001550 case ABIArgInfo::Indirect: {
Alexey Samsonov153004f2014-09-29 22:08:00 +00001551 assert(NumIRArgs == 1);
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001552 // indirect arguments are always on the stack, which is addr space #0.
Chris Lattner2192fe52011-07-18 04:24:23 +00001553 llvm::Type *LTy = ConvertTypeForMem(it->type);
Alexey Samsonov153004f2014-09-29 22:08:00 +00001554 ArgTypes[FirstIRArg] = LTy->getPointerTo();
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001555 break;
1556 }
1557
1558 case ABIArgInfo::Extend:
Chris Lattner2cdfda42010-07-29 06:44:09 +00001559 case ABIArgInfo::Direct: {
Oliver Stannard2bfdc5b2014-08-27 10:43:15 +00001560 // Fast-isel and the optimizer generally like scalar values better than
1561 // FCAs, so we flatten them if this is safe to do for this argument.
Alexey Samsonov153004f2014-09-29 22:08:00 +00001562 llvm::Type *argType = ArgInfo.getCoerceToType();
James Molloy6f244b62014-05-09 16:21:39 +00001563 llvm::StructType *st = dyn_cast<llvm::StructType>(argType);
Alexey Samsonov153004f2014-09-29 22:08:00 +00001564 if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
1565 assert(NumIRArgs == st->getNumElements());
John McCall85dd2c52011-05-15 02:19:42 +00001566 for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
Alexey Samsonov153004f2014-09-29 22:08:00 +00001567 ArgTypes[FirstIRArg + i] = st->getElementType(i);
Chris Lattner3dd716c2010-06-28 23:44:11 +00001568 } else {
Alexey Samsonov153004f2014-09-29 22:08:00 +00001569 assert(NumIRArgs == 1);
1570 ArgTypes[FirstIRArg] = argType;
Chris Lattner3dd716c2010-06-28 23:44:11 +00001571 }
Daniel Dunbar2f219b02009-02-03 19:12:28 +00001572 break;
Chris Lattner2cdfda42010-07-29 06:44:09 +00001573 }
Mike Stump11289f42009-09-09 15:08:12 +00001574
John McCallf26e73d2016-03-11 04:30:43 +00001575 case ABIArgInfo::CoerceAndExpand: {
1576 auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1577 for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) {
1578 *ArgTypesIter++ = EltTy;
1579 }
1580 assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1581 break;
1582 }
1583
Daniel Dunbard3674e62008-09-11 01:48:57 +00001584 case ABIArgInfo::Expand:
Alexey Samsonov153004f2014-09-29 22:08:00 +00001585 auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1586 getExpandedTypes(it->type, ArgTypesIter);
1587 assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
Daniel Dunbard3674e62008-09-11 01:48:57 +00001588 break;
1589 }
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00001590 }
1591
Chris Lattner6fb0ccf2011-07-15 05:16:14 +00001592 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
1593 assert(Erased && "Not in set?");
Alexey Samsonov153004f2014-09-29 22:08:00 +00001594
1595 return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic());
Daniel Dunbar81cf67f2008-09-09 23:48:28 +00001596}
1597
Chris Lattner2192fe52011-07-18 04:24:23 +00001598llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
John McCall5d865c322010-08-31 07:33:07 +00001599 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlsson64457732009-11-24 05:08:52 +00001600 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001601
Chris Lattner8806e322011-07-10 00:18:59 +00001602 if (!isFuncTypeConvertible(FPT))
1603 return llvm::StructType::get(getLLVMContext());
1604
1605 const CGFunctionInfo *Info;
1606 if (isa<CXXDestructorDecl>(MD))
Rafael Espindola8d2a19b2014-09-08 16:01:27 +00001607 Info =
1608 &arrangeCXXStructorDeclaration(MD, getFromDtorType(GD.getDtorType()));
Chris Lattner8806e322011-07-10 00:18:59 +00001609 else
John McCalla729c622012-02-17 03:33:10 +00001610 Info = &arrangeCXXMethodDeclaration(MD);
1611 return GetFunctionType(*Info);
Anders Carlsson64457732009-11-24 05:08:52 +00001612}
1613
Samuel Antao798f11c2015-11-23 22:04:44 +00001614static void AddAttributesFromFunctionProtoType(ASTContext &Ctx,
1615 llvm::AttrBuilder &FuncAttrs,
1616 const FunctionProtoType *FPT) {
1617 if (!FPT)
1618 return;
1619
1620 if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
1621 FPT->isNothrow(Ctx))
1622 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1623}
1624
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00001625void CodeGenModule::ConstructAttributeList(
1626 StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo,
1627 AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) {
Bill Wendlinga514ebc2012-10-15 20:36:26 +00001628 llvm::AttrBuilder FuncAttrs;
1629 llvm::AttrBuilder RetAttrs;
Paul Robinson08556952014-12-11 20:14:04 +00001630 bool HasOptnone = false;
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00001631
Daniel Dunbar0ef34792009-09-12 00:59:20 +00001632 CallingConv = FI.getEffectiveCallingConvention();
1633
John McCallab26cfa2010-02-05 21:31:56 +00001634 if (FI.isNoReturn())
Bill Wendling207f0532012-12-20 19:27:06 +00001635 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCallab26cfa2010-02-05 21:31:56 +00001636
Samuel Antao798f11c2015-11-23 22:04:44 +00001637 // If we have information about the function prototype, we can learn
1638 // attributes form there.
1639 AddAttributesFromFunctionProtoType(getContext(), FuncAttrs,
1640 CalleeInfo.getCalleeFunctionProtoType());
1641
1642 const Decl *TargetDecl = CalleeInfo.getCalleeDecl();
1643
Amjad Aboudfaea5602016-03-07 14:22:46 +00001644 bool HasAnyX86InterruptAttr = false;
Anton Korobeynikovc8478242009-04-04 00:49:24 +00001645 // FIXME: handle sseregparm someday...
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00001646 if (TargetDecl) {
Rafael Espindola2d21ab02011-10-12 19:51:18 +00001647 if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +00001648 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001649 if (TargetDecl->hasAttr<NoThrowAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +00001650 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Richard Smithdebc59d2013-01-30 05:45:05 +00001651 if (TargetDecl->hasAttr<NoReturnAttr>())
1652 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
Aaron Ballman7c19ab12014-02-22 16:59:24 +00001653 if (TargetDecl->hasAttr<NoDuplicateAttr>())
1654 FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate);
Yaxun Liu7d07ae72016-11-01 18:45:32 +00001655 if (TargetDecl->hasAttr<ConvergentAttr>())
1656 FuncAttrs.addAttribute(llvm::Attribute::Convergent);
Richard Smithdebc59d2013-01-30 05:45:05 +00001657
1658 if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
Samuel Antao798f11c2015-11-23 22:04:44 +00001659 AddAttributesFromFunctionProtoType(
1660 getContext(), FuncAttrs, Fn->getType()->getAs<FunctionProtoType>());
Richard Smith49af6292013-03-05 08:30:04 +00001661 // Don't use [[noreturn]] or _Noreturn for a call to a virtual function.
1662 // These attributes are not inherited by overloads.
1663 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
1664 if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual()))
Richard Smithdebc59d2013-01-30 05:45:05 +00001665 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
John McCallbe349de2010-07-08 06:48:12 +00001666 }
1667
David Majnemer1bf0f8e2015-07-20 22:51:52 +00001668 // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
Eric Christopherbf005ec2011-08-15 22:38:22 +00001669 if (TargetDecl->hasAttr<ConstAttr>()) {
Bill Wendling207f0532012-12-20 19:27:06 +00001670 FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1671 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopherbf005ec2011-08-15 22:38:22 +00001672 } else if (TargetDecl->hasAttr<PureAttr>()) {
Bill Wendling207f0532012-12-20 19:27:06 +00001673 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1674 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
David Majnemer1bf0f8e2015-07-20 22:51:52 +00001675 } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
1676 FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly);
1677 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
Eric Christopherbf005ec2011-08-15 22:38:22 +00001678 }
David Majnemer631a90b2015-02-04 07:23:21 +00001679 if (TargetDecl->hasAttr<RestrictAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +00001680 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
Hal Finkeld8442b12014-07-12 04:51:04 +00001681 if (TargetDecl->hasAttr<ReturnsNonNullAttr>())
1682 RetAttrs.addAttribute(llvm::Attribute::NonNull);
Paul Robinson08556952014-12-11 20:14:04 +00001683
Amjad Aboudfaea5602016-03-07 14:22:46 +00001684 HasAnyX86InterruptAttr = TargetDecl->hasAttr<AnyX86InterruptAttr>();
Paul Robinson08556952014-12-11 20:14:04 +00001685 HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00001686 }
1687
Paul Robinson08556952014-12-11 20:14:04 +00001688 // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed.
1689 if (!HasOptnone) {
1690 if (CodeGenOpts.OptimizeSize)
1691 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
1692 if (CodeGenOpts.OptimizeSize == 2)
1693 FuncAttrs.addAttribute(llvm::Attribute::MinSize);
1694 }
1695
Chandler Carruthbc55fe22009-11-12 17:24:48 +00001696 if (CodeGenOpts.DisableRedZone)
Bill Wendling207f0532012-12-20 19:27:06 +00001697 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
Chandler Carruthbc55fe22009-11-12 17:24:48 +00001698 if (CodeGenOpts.NoImplicitFloat)
Bill Wendling207f0532012-12-20 19:27:06 +00001699 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
Peter Collingbourneb4728c12014-05-19 22:14:34 +00001700 if (CodeGenOpts.EnableSegmentedStacks &&
1701 !(TargetDecl && TargetDecl->hasAttr<NoSplitStackAttr>()))
Reid Klecknerfb873af2014-04-10 22:59:13 +00001702 FuncAttrs.addAttribute("split-stack");
Devang Patel6e467b12009-06-04 23:32:02 +00001703
Bill Wendling2f81db62013-02-22 20:53:29 +00001704 if (AttrOnCallSite) {
1705 // Attributes that should go on the call site only.
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00001706 if (!CodeGenOpts.SimplifyLibCalls ||
1707 CodeGenOpts.isNoBuiltinFunc(Name.data()))
Bill Wendling2f81db62013-02-22 20:53:29 +00001708 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
Akira Hatanaka85365cd2015-07-02 22:15:41 +00001709 if (!CodeGenOpts.TrapFuncName.empty())
1710 FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName);
Bill Wendling706469b2013-02-28 22:49:57 +00001711 } else {
1712 // Attributes that should go on the function, but not the call site.
Bill Wendling706469b2013-02-28 22:49:57 +00001713 if (!CodeGenOpts.DisableFPElim) {
Bill Wendlingdabafea2013-03-13 22:24:33 +00001714 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
Bill Wendling706469b2013-02-28 22:49:57 +00001715 } else if (CodeGenOpts.OmitLeafFramePointer) {
Bill Wendlingdabafea2013-03-13 22:24:33 +00001716 FuncAttrs.addAttribute("no-frame-pointer-elim", "false");
Bill Wendling17d1b6142013-08-22 21:16:51 +00001717 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf");
Bill Wendling706469b2013-02-28 22:49:57 +00001718 } else {
Bill Wendlingdabafea2013-03-13 22:24:33 +00001719 FuncAttrs.addAttribute("no-frame-pointer-elim", "true");
Bill Wendling17d1b6142013-08-22 21:16:51 +00001720 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf");
Bill Wendling706469b2013-02-28 22:49:57 +00001721 }
1722
Akira Hatanaka7828b1e2015-11-13 00:42:21 +00001723 bool DisableTailCalls =
Amjad Aboudfaea5602016-03-07 14:22:46 +00001724 CodeGenOpts.DisableTailCalls || HasAnyX86InterruptAttr ||
Akira Hatanaka7828b1e2015-11-13 00:42:21 +00001725 (TargetDecl && TargetDecl->hasAttr<DisableTailCallsAttr>());
Amjad Aboudfaea5602016-03-07 14:22:46 +00001726 FuncAttrs.addAttribute(
1727 "disable-tail-calls",
1728 llvm::toStringRef(DisableTailCalls));
Akira Hatanaka7828b1e2015-11-13 00:42:21 +00001729
Bill Wendlingdabafea2013-03-13 22:24:33 +00001730 FuncAttrs.addAttribute("less-precise-fpmad",
Bill Wendlingf69f5942013-07-26 21:51:11 +00001731 llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
Sjoerd Meijer0a8d4212016-08-30 08:09:45 +00001732
1733 if (!CodeGenOpts.FPDenormalMode.empty())
1734 FuncAttrs.addAttribute("denormal-fp-math",
1735 CodeGenOpts.FPDenormalMode);
1736
1737 FuncAttrs.addAttribute("no-trapping-math",
1738 llvm::toStringRef(CodeGenOpts.NoTrappingMath));
Sanjay Patel0bb72c12016-10-04 20:44:05 +00001739
1740 // TODO: Are these all needed?
1741 // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
Bill Wendlingdabafea2013-03-13 22:24:33 +00001742 FuncAttrs.addAttribute("no-infs-fp-math",
Bill Wendlingf69f5942013-07-26 21:51:11 +00001743 llvm::toStringRef(CodeGenOpts.NoInfsFPMath));
Bill Wendlingdabafea2013-03-13 22:24:33 +00001744 FuncAttrs.addAttribute("no-nans-fp-math",
Bill Wendlingf69f5942013-07-26 21:51:11 +00001745 llvm::toStringRef(CodeGenOpts.NoNaNsFPMath));
Bill Wendlingdabafea2013-03-13 22:24:33 +00001746 FuncAttrs.addAttribute("unsafe-fp-math",
Bill Wendlingf69f5942013-07-26 21:51:11 +00001747 llvm::toStringRef(CodeGenOpts.UnsafeFPMath));
Bill Wendlingdabafea2013-03-13 22:24:33 +00001748 FuncAttrs.addAttribute("use-soft-float",
Bill Wendlingf69f5942013-07-26 21:51:11 +00001749 llvm::toStringRef(CodeGenOpts.SoftFloat));
Bill Wendlingb3219722013-07-22 20:15:41 +00001750 FuncAttrs.addAttribute("stack-protector-buffer-size",
Bill Wendling021c8de2013-07-12 22:26:07 +00001751 llvm::utostr(CodeGenOpts.SSPBufferSize));
Yaxun Liu79c99fb2016-07-08 20:28:29 +00001752 FuncAttrs.addAttribute("no-signed-zeros-fp-math",
1753 llvm::toStringRef(CodeGenOpts.NoSignedZeros));
Yaxun Liuffb60902016-08-09 20:10:18 +00001754 FuncAttrs.addAttribute(
1755 "correctly-rounded-divide-sqrt-fp-math",
1756 llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt));
Bill Wendlinga9cc8c02013-07-25 00:32:41 +00001757
Sanjay Patel0bb72c12016-10-04 20:44:05 +00001758 // TODO: Reciprocal estimate codegen options should apply to instructions?
1759 std::vector<std::string> &Recips = getTarget().getTargetOpts().Reciprocals;
1760 if (!Recips.empty())
1761 FuncAttrs.addAttribute("reciprocal-estimates",
1762 llvm::join(Recips.begin(), Recips.end(), ","));
1763
Akira Hatanakaaecca042015-09-11 18:55:09 +00001764 if (CodeGenOpts.StackRealignment)
1765 FuncAttrs.addAttribute("stackrealign");
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +00001766 if (CodeGenOpts.Backchain)
1767 FuncAttrs.addAttribute("backchain");
Eric Christopher70c16652015-03-25 23:14:47 +00001768
Eric Christopher11acf732015-06-12 01:35:52 +00001769 // Add target-cpu and target-features attributes to functions. If
1770 // we have a decl for the function and it has a target attribute then
1771 // parse that and add it to the feature set.
1772 StringRef TargetCPU = getTarget().getTargetOpts().CPU;
Eric Christopher11acf732015-06-12 01:35:52 +00001773 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl);
Eric Christopherb57804a2015-09-01 22:03:56 +00001774 if (FD && FD->hasAttr<TargetAttr>()) {
Eric Christopher3a98b3c2015-08-27 19:59:34 +00001775 llvm::StringMap<bool> FeatureMap;
Eric Christopher2b90a642015-11-11 23:05:08 +00001776 getFunctionFeatureMap(FeatureMap, FD);
Eric Christopher11acf732015-06-12 01:35:52 +00001777
Eric Christopher3a98b3c2015-08-27 19:59:34 +00001778 // Produce the canonical string for this set of features.
1779 std::vector<std::string> Features;
1780 for (llvm::StringMap<bool>::const_iterator it = FeatureMap.begin(),
1781 ie = FeatureMap.end();
1782 it != ie; ++it)
1783 Features.push_back((it->second ? "+" : "-") + it->first().str());
Eric Christopher2249b812015-07-01 00:08:29 +00001784
Eric Christopher3a98b3c2015-08-27 19:59:34 +00001785 // Now add the target-cpu and target-features to the function.
Eric Christopher2b90a642015-11-11 23:05:08 +00001786 // While we populated the feature map above, we still need to
1787 // get and parse the target attribute so we can get the cpu for
1788 // the function.
1789 const auto *TD = FD->getAttr<TargetAttr>();
1790 TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
1791 if (ParsedAttr.second != "")
1792 TargetCPU = ParsedAttr.second;
Eric Christopher3a98b3c2015-08-27 19:59:34 +00001793 if (TargetCPU != "")
1794 FuncAttrs.addAttribute("target-cpu", TargetCPU);
1795 if (!Features.empty()) {
1796 std::sort(Features.begin(), Features.end());
1797 FuncAttrs.addAttribute(
1798 "target-features",
1799 llvm::join(Features.begin(), Features.end(), ","));
1800 }
1801 } else {
1802 // Otherwise just add the existing target cpu and target features to the
1803 // function.
1804 std::vector<std::string> &Features = getTarget().getTargetOpts().Features;
1805 if (TargetCPU != "")
1806 FuncAttrs.addAttribute("target-cpu", TargetCPU);
1807 if (!Features.empty()) {
1808 std::sort(Features.begin(), Features.end());
1809 FuncAttrs.addAttribute(
1810 "target-features",
1811 llvm::join(Features.begin(), Features.end(), ","));
1812 }
Eric Christopher70c16652015-03-25 23:14:47 +00001813 }
Bill Wendling985d1c52013-02-15 21:30:01 +00001814 }
1815
Justin Lebarddd97fa2016-02-24 21:55:11 +00001816 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
1817 // Conservatively, mark all functions and calls in CUDA as convergent
1818 // (meaning, they may call an intrinsically convergent op, such as
1819 // __syncthreads(), and so can't have certain optimizations applied around
1820 // them). LLVM will remove this attribute where it safely can.
1821 FuncAttrs.addAttribute(llvm::Attribute::Convergent);
Justin Lebard3a44f62016-04-05 18:26:20 +00001822
Justin Lebar3e6449b2016-10-04 23:41:49 +00001823 // Exceptions aren't supported in CUDA device code.
1824 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1825
Justin Lebard3a44f62016-04-05 18:26:20 +00001826 // Respect -fcuda-flush-denormals-to-zero.
1827 if (getLangOpts().CUDADeviceFlushDenormalsToZero)
1828 FuncAttrs.addAttribute("nvptx-f32ftz", "true");
Justin Lebarddd97fa2016-02-24 21:55:11 +00001829 }
1830
Alexey Samsonov153004f2014-09-29 22:08:00 +00001831 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI);
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001832
Daniel Dunbar3668cb22009-02-02 23:43:58 +00001833 QualType RetTy = FI.getReturnType();
Daniel Dunbarb52d0772009-02-03 05:59:18 +00001834 const ABIArgInfo &RetAI = FI.getReturnInfo();
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00001835 switch (RetAI.getKind()) {
Anton Korobeynikov18adbf52009-06-06 09:36:29 +00001836 case ABIArgInfo::Extend:
Jakob Stoklund Olesend7bf2932013-05-29 03:57:23 +00001837 if (RetTy->hasSignedIntegerRepresentation())
1838 RetAttrs.addAttribute(llvm::Attribute::SExt);
1839 else if (RetTy->hasUnsignedIntegerRepresentation())
1840 RetAttrs.addAttribute(llvm::Attribute::ZExt);
Jakob Stoklund Olesena3661142013-06-05 03:00:09 +00001841 // FALL THROUGH
Daniel Dunbar67dace892009-02-03 06:17:37 +00001842 case ABIArgInfo::Direct:
Jakob Stoklund Olesena3661142013-06-05 03:00:09 +00001843 if (RetAI.getInReg())
1844 RetAttrs.addAttribute(llvm::Attribute::InReg);
1845 break;
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001846 case ABIArgInfo::Ignore:
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00001847 break;
1848
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001849 case ABIArgInfo::InAlloca:
Rafael Espindola06b2b4a2012-07-31 02:44:24 +00001850 case ABIArgInfo::Indirect: {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001851 // inalloca and sret disable readnone and readonly
Bill Wendling207f0532012-12-20 19:27:06 +00001852 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1853 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00001854 break;
Rafael Espindola06b2b4a2012-07-31 02:44:24 +00001855 }
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00001856
John McCallf26e73d2016-03-11 04:30:43 +00001857 case ABIArgInfo::CoerceAndExpand:
1858 break;
1859
Daniel Dunbard3674e62008-09-11 01:48:57 +00001860 case ABIArgInfo::Expand:
David Blaikie83d382b2011-09-23 05:06:16 +00001861 llvm_unreachable("Invalid ABI kind for return argument");
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00001862 }
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00001863
Hal Finkela2347ba2014-07-18 15:52:10 +00001864 if (const auto *RefTy = RetTy->getAs<ReferenceType>()) {
1865 QualType PTy = RefTy->getPointeeType();
David Majnemer9df56372015-09-10 21:52:00 +00001866 if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
Hal Finkela2347ba2014-07-18 15:52:10 +00001867 RetAttrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy)
1868 .getQuantity());
1869 else if (getContext().getTargetAddressSpace(PTy) == 0)
1870 RetAttrs.addAttribute(llvm::Attribute::NonNull);
1871 }
Nick Lewycky9b46eb82014-05-28 09:56:42 +00001872
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001873 // Attach return attributes.
1874 if (RetAttrs.hasAttributes()) {
1875 PAL.push_back(llvm::AttributeSet::get(
1876 getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs));
1877 }
Anton Korobeynikovc8478242009-04-04 00:49:24 +00001878
John McCall12f23522016-04-04 18:33:08 +00001879 bool hasUsedSRet = false;
1880
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001881 // Attach attributes to sret.
1882 if (IRFunctionArgs.hasSRetArg()) {
1883 llvm::AttrBuilder SRETAttrs;
1884 SRETAttrs.addAttribute(llvm::Attribute::StructRet);
John McCall12f23522016-04-04 18:33:08 +00001885 hasUsedSRet = true;
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001886 if (RetAI.getInReg())
1887 SRETAttrs.addAttribute(llvm::Attribute::InReg);
1888 PAL.push_back(llvm::AttributeSet::get(
1889 getLLVMContext(), IRFunctionArgs.getSRetArgNo() + 1, SRETAttrs));
1890 }
1891
1892 // Attach attributes to inalloca argument.
1893 if (IRFunctionArgs.hasInallocaArg()) {
1894 llvm::AttrBuilder Attrs;
1895 Attrs.addAttribute(llvm::Attribute::InAlloca);
1896 PAL.push_back(llvm::AttributeSet::get(
1897 getLLVMContext(), IRFunctionArgs.getInallocaArgNo() + 1, Attrs));
1898 }
1899
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001900 unsigned ArgNo = 0;
1901 for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(),
1902 E = FI.arg_end();
1903 I != E; ++I, ++ArgNo) {
1904 QualType ParamType = I->type;
1905 const ABIArgInfo &AI = I->info;
Bill Wendlinga514ebc2012-10-15 20:36:26 +00001906 llvm::AttrBuilder Attrs;
Anton Korobeynikovc8478242009-04-04 00:49:24 +00001907
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001908 // Add attribute for padding argument, if necessary.
1909 if (IRFunctionArgs.hasPaddingArg(ArgNo)) {
Bill Wendling290d9522013-01-27 02:46:53 +00001910 if (AI.getPaddingInReg())
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001911 PAL.push_back(llvm::AttributeSet::get(
1912 getLLVMContext(), IRFunctionArgs.getPaddingArgNo(ArgNo) + 1,
1913 llvm::Attribute::InReg));
Rafael Espindolafad28de2012-10-24 01:59:00 +00001914 }
1915
John McCall39ec71f2010-03-27 00:47:27 +00001916 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
1917 // have the corresponding parameter variable. It doesn't make
Daniel Dunbarcb2b3d02011-02-10 18:10:07 +00001918 // sense to do it here because parameters are so messed up.
Daniel Dunbard3674e62008-09-11 01:48:57 +00001919 switch (AI.getKind()) {
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001920 case ABIArgInfo::Extend:
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00001921 if (ParamType->isSignedIntegerOrEnumerationType())
Bill Wendling207f0532012-12-20 19:27:06 +00001922 Attrs.addAttribute(llvm::Attribute::SExt);
Petar Jovanovic1a3f9652015-05-26 21:07:19 +00001923 else if (ParamType->isUnsignedIntegerOrEnumerationType()) {
1924 if (getTypes().getABIInfo().shouldSignExtUnsignedType(ParamType))
1925 Attrs.addAttribute(llvm::Attribute::SExt);
1926 else
1927 Attrs.addAttribute(llvm::Attribute::ZExt);
1928 }
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001929 // FALL THROUGH
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001930 case ABIArgInfo::Direct:
Peter Collingbournef7706832014-12-12 23:41:25 +00001931 if (ArgNo == 0 && FI.isChainCall())
1932 Attrs.addAttribute(llvm::Attribute::Nest);
1933 else if (AI.getInReg())
Bill Wendling207f0532012-12-20 19:27:06 +00001934 Attrs.addAttribute(llvm::Attribute::InReg);
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00001935 break;
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001936
James Y Knight71608572015-08-21 18:19:06 +00001937 case ABIArgInfo::Indirect: {
Rafael Espindola703c47f2012-10-19 05:04:37 +00001938 if (AI.getInReg())
Bill Wendling207f0532012-12-20 19:27:06 +00001939 Attrs.addAttribute(llvm::Attribute::InReg);
Rafael Espindola703c47f2012-10-19 05:04:37 +00001940
Anders Carlsson20759ad2009-09-16 15:53:40 +00001941 if (AI.getIndirectByVal())
Bill Wendling207f0532012-12-20 19:27:06 +00001942 Attrs.addAttribute(llvm::Attribute::ByVal);
Anders Carlsson20759ad2009-09-16 15:53:40 +00001943
John McCall7f416cc2015-09-08 08:05:57 +00001944 CharUnits Align = AI.getIndirectAlign();
James Y Knight71608572015-08-21 18:19:06 +00001945
1946 // In a byval argument, it is important that the required
1947 // alignment of the type is honored, as LLVM might be creating a
1948 // *new* stack object, and needs to know what alignment to give
1949 // it. (Sometimes it can deduce a sensible alignment on its own,
1950 // but not if clang decides it must emit a packed struct, or the
1951 // user specifies increased alignment requirements.)
1952 //
1953 // This is different from indirect *not* byval, where the object
1954 // exists already, and the align attribute is purely
1955 // informative.
John McCall7f416cc2015-09-08 08:05:57 +00001956 assert(!Align.isZero());
James Y Knight71608572015-08-21 18:19:06 +00001957
John McCall7f416cc2015-09-08 08:05:57 +00001958 // For now, only add this when we have a byval argument.
1959 // TODO: be less lazy about updating test cases.
1960 if (AI.getIndirectByVal())
1961 Attrs.addAlignmentAttr(Align.getQuantity());
Bill Wendlinga7912f82012-10-10 07:36:56 +00001962
Daniel Dunbarc2304432009-03-18 19:51:01 +00001963 // byval disables readnone and readonly.
Bill Wendling207f0532012-12-20 19:27:06 +00001964 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1965 .removeAttribute(llvm::Attribute::ReadNone);
Daniel Dunbard3674e62008-09-11 01:48:57 +00001966 break;
James Y Knight71608572015-08-21 18:19:06 +00001967 }
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001968 case ABIArgInfo::Ignore:
Alexey Samsonov91cf4552014-08-22 01:06:06 +00001969 case ABIArgInfo::Expand:
John McCallf26e73d2016-03-11 04:30:43 +00001970 case ABIArgInfo::CoerceAndExpand:
1971 break;
Daniel Dunbar94a6f252009-01-26 21:26:08 +00001972
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001973 case ABIArgInfo::InAlloca:
1974 // inalloca disables readnone and readonly.
1975 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1976 .removeAttribute(llvm::Attribute::ReadNone);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001977 continue;
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00001978 }
Mike Stump11289f42009-09-09 15:08:12 +00001979
Hal Finkela2347ba2014-07-18 15:52:10 +00001980 if (const auto *RefTy = ParamType->getAs<ReferenceType>()) {
1981 QualType PTy = RefTy->getPointeeType();
David Majnemer9df56372015-09-10 21:52:00 +00001982 if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
Hal Finkela2347ba2014-07-18 15:52:10 +00001983 Attrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy)
1984 .getQuantity());
1985 else if (getContext().getTargetAddressSpace(PTy) == 0)
1986 Attrs.addAttribute(llvm::Attribute::NonNull);
1987 }
Nick Lewycky9b46eb82014-05-28 09:56:42 +00001988
John McCall12f23522016-04-04 18:33:08 +00001989 switch (FI.getExtParameterInfo(ArgNo).getABI()) {
1990 case ParameterABI::Ordinary:
1991 break;
1992
1993 case ParameterABI::SwiftIndirectResult: {
1994 // Add 'sret' if we haven't already used it for something, but
1995 // only if the result is void.
1996 if (!hasUsedSRet && RetTy->isVoidType()) {
1997 Attrs.addAttribute(llvm::Attribute::StructRet);
1998 hasUsedSRet = true;
1999 }
2000
2001 // Add 'noalias' in either case.
2002 Attrs.addAttribute(llvm::Attribute::NoAlias);
2003
2004 // Add 'dereferenceable' and 'alignment'.
2005 auto PTy = ParamType->getPointeeType();
2006 if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) {
2007 auto info = getContext().getTypeInfoInChars(PTy);
2008 Attrs.addDereferenceableAttr(info.first.getQuantity());
2009 Attrs.addAttribute(llvm::Attribute::getWithAlignment(getLLVMContext(),
2010 info.second.getQuantity()));
2011 }
2012 break;
2013 }
2014
2015 case ParameterABI::SwiftErrorResult:
2016 Attrs.addAttribute(llvm::Attribute::SwiftError);
2017 break;
2018
2019 case ParameterABI::SwiftContext:
2020 Attrs.addAttribute(llvm::Attribute::SwiftSelf);
2021 break;
2022 }
2023
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002024 if (Attrs.hasAttributes()) {
2025 unsigned FirstIRArg, NumIRArgs;
2026 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
2027 for (unsigned i = 0; i < NumIRArgs; i++)
2028 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(),
2029 FirstIRArg + i + 1, Attrs));
2030 }
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00002031 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002032 assert(ArgNo == FI.arg_size());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002033
Bill Wendlinga7912f82012-10-10 07:36:56 +00002034 if (FuncAttrs.hasAttributes())
Bill Wendling4f0c0802012-10-15 07:31:59 +00002035 PAL.push_back(llvm::
Bill Wendling290d9522013-01-27 02:46:53 +00002036 AttributeSet::get(getLLVMContext(),
2037 llvm::AttributeSet::FunctionIndex,
2038 FuncAttrs));
Daniel Dunbar76c8eb72008-09-10 00:32:18 +00002039}
2040
John McCalla738c252011-03-09 04:27:21 +00002041/// An argument came in as a promoted argument; demote it back to its
2042/// declared type.
2043static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
2044 const VarDecl *var,
2045 llvm::Value *value) {
Chris Lattner2192fe52011-07-18 04:24:23 +00002046 llvm::Type *varType = CGF.ConvertType(var->getType());
John McCalla738c252011-03-09 04:27:21 +00002047
2048 // This can happen with promotions that actually don't change the
2049 // underlying type, like the enum promotions.
2050 if (value->getType() == varType) return value;
2051
2052 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
2053 && "unexpected promotion type");
2054
2055 if (isa<llvm::IntegerType>(varType))
2056 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
2057
2058 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
2059}
2060
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002061/// Returns the attribute (either parameter attribute, or function
2062/// attribute), which declares argument ArgNo to be non-null.
2063static const NonNullAttr *getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD,
2064 QualType ArgType, unsigned ArgNo) {
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002065 // FIXME: __attribute__((nonnull)) can also be applied to:
2066 // - references to pointers, where the pointee is known to be
2067 // nonnull (apparently a Clang extension)
2068 // - transparent unions containing pointers
2069 // In the former case, LLVM IR cannot represent the constraint. In
2070 // the latter case, we have no guarantee that the transparent union
2071 // is in fact passed as a pointer.
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002072 if (!ArgType->isAnyPointerType() && !ArgType->isBlockPointerType())
2073 return nullptr;
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002074 // First, check attribute on parameter itself.
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002075 if (PVD) {
2076 if (auto ParmNNAttr = PVD->getAttr<NonNullAttr>())
2077 return ParmNNAttr;
2078 }
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002079 // Check function attributes.
2080 if (!FD)
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002081 return nullptr;
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002082 for (const auto *NNAttr : FD->specific_attrs<NonNullAttr>()) {
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002083 if (NNAttr->isNonNull(ArgNo))
2084 return NNAttr;
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002085 }
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002086 return nullptr;
Alexey Samsonov9fc9bf82014-08-28 00:53:20 +00002087}
2088
John McCall12f23522016-04-04 18:33:08 +00002089namespace {
2090 struct CopyBackSwiftError final : EHScopeStack::Cleanup {
2091 Address Temp;
2092 Address Arg;
2093 CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}
2094 void Emit(CodeGenFunction &CGF, Flags flags) override {
2095 llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp);
2096 CGF.Builder.CreateStore(errorValue, Arg);
2097 }
2098 };
2099}
2100
Daniel Dunbard931a872009-02-02 22:03:45 +00002101void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
2102 llvm::Function *Fn,
Daniel Dunbar613855c2008-09-09 23:27:19 +00002103 const FunctionArgList &Args) {
Hans Wennborgd71907d2014-09-04 22:16:33 +00002104 if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>())
2105 // Naked functions don't have prologues.
2106 return;
2107
John McCallcaa19452009-07-28 01:00:58 +00002108 // If this is an implicit-return-zero function, go ahead and
2109 // initialize the return value. TODO: it might be nice to have
2110 // a more general mechanism for this that didn't require synthesized
2111 // return statements.
John McCalldec348f72013-05-03 07:33:41 +00002112 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
John McCallcaa19452009-07-28 01:00:58 +00002113 if (FD->hasImplicitReturnZero()) {
Alp Toker314cc812014-01-25 16:55:45 +00002114 QualType RetTy = FD->getReturnType().getUnqualifiedType();
Chris Lattner2192fe52011-07-18 04:24:23 +00002115 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
Owen Anderson0b75f232009-07-31 20:28:54 +00002116 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
John McCallcaa19452009-07-28 01:00:58 +00002117 Builder.CreateStore(Zero, ReturnValue);
2118 }
2119 }
2120
Mike Stump18bb9282009-05-16 07:57:57 +00002121 // FIXME: We no longer need the types from FunctionArgList; lift up and
2122 // simplify.
Daniel Dunbar5a0acdc92009-02-03 06:02:10 +00002123
Alexey Samsonov153004f2014-09-29 22:08:00 +00002124 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI);
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002125 // Flattened function arguments.
John McCall12f23522016-04-04 18:33:08 +00002126 SmallVector<llvm::Value *, 16> FnArgs;
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002127 FnArgs.reserve(IRFunctionArgs.totalIRArgs());
2128 for (auto &Arg : Fn->args()) {
2129 FnArgs.push_back(&Arg);
2130 }
2131 assert(FnArgs.size() == IRFunctionArgs.totalIRArgs());
Mike Stump11289f42009-09-09 15:08:12 +00002132
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002133 // If we're using inalloca, all the memory arguments are GEPs off of the last
2134 // parameter, which is a pointer to the complete memory area.
John McCall7f416cc2015-09-08 08:05:57 +00002135 Address ArgStruct = Address::invalid();
2136 const llvm::StructLayout *ArgStructLayout = nullptr;
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002137 if (IRFunctionArgs.hasInallocaArg()) {
John McCall7f416cc2015-09-08 08:05:57 +00002138 ArgStructLayout = CGM.getDataLayout().getStructLayout(FI.getArgStruct());
2139 ArgStruct = Address(FnArgs[IRFunctionArgs.getInallocaArgNo()],
2140 FI.getArgStructAlignment());
2141
2142 assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002143 }
2144
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002145 // Name the struct return parameter.
2146 if (IRFunctionArgs.hasSRetArg()) {
John McCall12f23522016-04-04 18:33:08 +00002147 auto AI = cast<llvm::Argument>(FnArgs[IRFunctionArgs.getSRetArgNo()]);
Daniel Dunbar613855c2008-09-09 23:27:19 +00002148 AI->setName("agg.result");
Reid Kleckner37abaca2014-05-09 22:46:15 +00002149 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1,
Bill Wendlingce2f9c52013-01-23 06:15:10 +00002150 llvm::Attribute::NoAlias));
Daniel Dunbar613855c2008-09-09 23:27:19 +00002151 }
Mike Stump11289f42009-09-09 15:08:12 +00002152
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002153 // Track if we received the parameter as a pointer (indirect, byval, or
2154 // inalloca). If already have a pointer, EmitParmDecl doesn't need to copy it
2155 // into a local alloca for us.
John McCall7f416cc2015-09-08 08:05:57 +00002156 SmallVector<ParamValue, 16> ArgVals;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002157 ArgVals.reserve(Args.size());
2158
Reid Kleckner739756c2013-12-04 19:23:12 +00002159 // Create a pointer value for every parameter declaration. This usually
2160 // entails copying one or more LLVM IR arguments into an alloca. Don't push
2161 // any cleanups or do anything that might unwind. We do that separately, so
2162 // we can push the cleanups in the correct order for the ABI.
Daniel Dunbara45bdbb2009-02-04 21:17:21 +00002163 assert(FI.arg_size() == Args.size() &&
2164 "Mismatch between function signature & arguments.");
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002165 unsigned ArgNo = 0;
Daniel Dunbarb52d0772009-02-03 05:59:18 +00002166 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002167 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
Devang Patel68a15252011-03-03 20:13:15 +00002168 i != e; ++i, ++info_it, ++ArgNo) {
John McCalla738c252011-03-09 04:27:21 +00002169 const VarDecl *Arg = *i;
Daniel Dunbarb52d0772009-02-03 05:59:18 +00002170 QualType Ty = info_it->type;
2171 const ABIArgInfo &ArgI = info_it->info;
Daniel Dunbard3674e62008-09-11 01:48:57 +00002172
John McCalla738c252011-03-09 04:27:21 +00002173 bool isPromoted =
2174 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
2175
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002176 unsigned FirstIRArg, NumIRArgs;
2177 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
Rafael Espindolafad28de2012-10-24 01:59:00 +00002178
Daniel Dunbard3674e62008-09-11 01:48:57 +00002179 switch (ArgI.getKind()) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002180 case ABIArgInfo::InAlloca: {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002181 assert(NumIRArgs == 0);
John McCall7f416cc2015-09-08 08:05:57 +00002182 auto FieldIndex = ArgI.getInAllocaFieldIndex();
2183 CharUnits FieldOffset =
2184 CharUnits::fromQuantity(ArgStructLayout->getElementOffset(FieldIndex));
2185 Address V = Builder.CreateStructGEP(ArgStruct, FieldIndex, FieldOffset,
2186 Arg->getName());
2187 ArgVals.push_back(ParamValue::forIndirect(V));
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002188 break;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002189 }
2190
Daniel Dunbar747865a2009-02-05 09:16:39 +00002191 case ABIArgInfo::Indirect: {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002192 assert(NumIRArgs == 1);
John McCall7f416cc2015-09-08 08:05:57 +00002193 Address ParamAddr = Address(FnArgs[FirstIRArg], ArgI.getIndirectAlign());
Daniel Dunbar7b7c2932010-09-16 20:42:02 +00002194
John McCall47fb9502013-03-07 21:37:08 +00002195 if (!hasScalarEvaluationKind(Ty)) {
Daniel Dunbar7b7c2932010-09-16 20:42:02 +00002196 // Aggregates and complex variables are accessed by reference. All we
John McCall7f416cc2015-09-08 08:05:57 +00002197 // need to do is realign the value, if requested.
2198 Address V = ParamAddr;
Daniel Dunbar7b7c2932010-09-16 20:42:02 +00002199 if (ArgI.getIndirectRealign()) {
John McCall7f416cc2015-09-08 08:05:57 +00002200 Address AlignedTemp = CreateMemTemp(Ty, "coerce");
Daniel Dunbar7b7c2932010-09-16 20:42:02 +00002201
2202 // Copy from the incoming argument pointer to the temporary with the
2203 // appropriate alignment.
2204 //
2205 // FIXME: We should have a common utility for generating an aggregate
2206 // copy.
Ken Dyck705ba072011-01-19 01:58:38 +00002207 CharUnits Size = getContext().getTypeSizeInChars(Ty);
John McCall7f416cc2015-09-08 08:05:57 +00002208 auto SizeVal = llvm::ConstantInt::get(IntPtrTy, Size.getQuantity());
2209 Address Dst = Builder.CreateBitCast(AlignedTemp, Int8PtrTy);
2210 Address Src = Builder.CreateBitCast(ParamAddr, Int8PtrTy);
2211 Builder.CreateMemCpy(Dst, Src, SizeVal, false);
Daniel Dunbar7b7c2932010-09-16 20:42:02 +00002212 V = AlignedTemp;
2213 }
John McCall7f416cc2015-09-08 08:05:57 +00002214 ArgVals.push_back(ParamValue::forIndirect(V));
Daniel Dunbar747865a2009-02-05 09:16:39 +00002215 } else {
2216 // Load scalar value from indirect argument.
John McCall7f416cc2015-09-08 08:05:57 +00002217 llvm::Value *V =
2218 EmitLoadOfScalar(ParamAddr, false, Ty, Arg->getLocStart());
John McCalla738c252011-03-09 04:27:21 +00002219
2220 if (isPromoted)
2221 V = emitArgumentDemotion(*this, Arg, V);
John McCall7f416cc2015-09-08 08:05:57 +00002222 ArgVals.push_back(ParamValue::forDirect(V));
Daniel Dunbar747865a2009-02-05 09:16:39 +00002223 }
Daniel Dunbar747865a2009-02-05 09:16:39 +00002224 break;
2225 }
Anton Korobeynikov18adbf52009-06-06 09:36:29 +00002226
2227 case ABIArgInfo::Extend:
Daniel Dunbar67dace892009-02-03 06:17:37 +00002228 case ABIArgInfo::Direct: {
Akira Hatanaka18334dd2012-01-09 19:08:06 +00002229
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002230 // If we have the trivial case, handle it with no muss and fuss.
2231 if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
Chris Lattner8a2f3c72010-07-30 04:02:24 +00002232 ArgI.getCoerceToType() == ConvertType(Ty) &&
2233 ArgI.getDirectOffset() == 0) {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002234 assert(NumIRArgs == 1);
John McCall12f23522016-04-04 18:33:08 +00002235 llvm::Value *V = FnArgs[FirstIRArg];
2236 auto AI = cast<llvm::Argument>(V);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002237
Hal Finkel48d53e22014-07-19 01:41:07 +00002238 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002239 if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(),
2240 PVD->getFunctionScopeIndex()))
Hal Finkel82504f02014-07-11 17:35:21 +00002241 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2242 AI->getArgNo() + 1,
2243 llvm::Attribute::NonNull));
2244
Hal Finkel48d53e22014-07-19 01:41:07 +00002245 QualType OTy = PVD->getOriginalType();
2246 if (const auto *ArrTy =
2247 getContext().getAsConstantArrayType(OTy)) {
2248 // A C99 array parameter declaration with the static keyword also
2249 // indicates dereferenceability, and if the size is constant we can
2250 // use the dereferenceable attribute (which requires the size in
2251 // bytes).
Hal Finkel16e394a2014-07-19 02:13:40 +00002252 if (ArrTy->getSizeModifier() == ArrayType::Static) {
Hal Finkel48d53e22014-07-19 01:41:07 +00002253 QualType ETy = ArrTy->getElementType();
2254 uint64_t ArrSize = ArrTy->getSize().getZExtValue();
2255 if (!ETy->isIncompleteType() && ETy->isConstantSizeType() &&
2256 ArrSize) {
2257 llvm::AttrBuilder Attrs;
2258 Attrs.addDereferenceableAttr(
2259 getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize);
2260 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2261 AI->getArgNo() + 1, Attrs));
2262 } else if (getContext().getTargetAddressSpace(ETy) == 0) {
2263 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2264 AI->getArgNo() + 1,
2265 llvm::Attribute::NonNull));
2266 }
2267 }
2268 } else if (const auto *ArrTy =
2269 getContext().getAsVariableArrayType(OTy)) {
2270 // For C99 VLAs with the static keyword, we don't know the size so
2271 // we can't use the dereferenceable attribute, but in addrspace(0)
2272 // we know that it must be nonnull.
2273 if (ArrTy->getSizeModifier() == VariableArrayType::Static &&
2274 !getContext().getTargetAddressSpace(ArrTy->getElementType()))
2275 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2276 AI->getArgNo() + 1,
2277 llvm::Attribute::NonNull));
2278 }
Hal Finkel1b0d24e2014-10-02 21:21:25 +00002279
2280 const auto *AVAttr = PVD->getAttr<AlignValueAttr>();
2281 if (!AVAttr)
2282 if (const auto *TOTy = dyn_cast<TypedefType>(OTy))
2283 AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>();
2284 if (AVAttr) {
2285 llvm::Value *AlignmentValue =
2286 EmitScalarExpr(AVAttr->getAlignment());
2287 llvm::ConstantInt *AlignmentCI =
2288 cast<llvm::ConstantInt>(AlignmentValue);
2289 unsigned Alignment =
2290 std::min((unsigned) AlignmentCI->getZExtValue(),
2291 +llvm::Value::MaximumAlignment);
2292
2293 llvm::AttrBuilder Attrs;
2294 Attrs.addAlignmentAttr(Alignment);
2295 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2296 AI->getArgNo() + 1, Attrs));
2297 }
Hal Finkel48d53e22014-07-19 01:41:07 +00002298 }
2299
Bill Wendling507c3512012-10-16 05:23:44 +00002300 if (Arg->getType().isRestrictQualified())
Bill Wendlingce2f9c52013-01-23 06:15:10 +00002301 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
2302 AI->getArgNo() + 1,
2303 llvm::Attribute::NoAlias));
John McCall39ec71f2010-03-27 00:47:27 +00002304
John McCall12f23522016-04-04 18:33:08 +00002305 // LLVM expects swifterror parameters to be used in very restricted
2306 // ways. Copy the value into a less-restricted temporary.
2307 if (FI.getExtParameterInfo(ArgNo).getABI()
2308 == ParameterABI::SwiftErrorResult) {
2309 QualType pointeeTy = Ty->getPointeeType();
2310 assert(pointeeTy->isPointerType());
2311 Address temp =
2312 CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");
2313 Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy));
2314 llvm::Value *incomingErrorValue = Builder.CreateLoad(arg);
2315 Builder.CreateStore(incomingErrorValue, temp);
2316 V = temp.getPointer();
2317
2318 // Push a cleanup to copy the value back at the end of the function.
2319 // The convention does not guarantee that the value will be written
2320 // back if the function exits with an unwind exception.
2321 EHStack.pushCleanup<CopyBackSwiftError>(NormalCleanup, temp, arg);
2322 }
2323
Chris Lattner7369c142011-07-20 06:29:00 +00002324 // Ensure the argument is the correct type.
2325 if (V->getType() != ArgI.getCoerceToType())
2326 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
2327
John McCalla738c252011-03-09 04:27:21 +00002328 if (isPromoted)
2329 V = emitArgumentDemotion(*this, Arg, V);
Rafael Espindola8778c282012-11-29 16:09:03 +00002330
2331 // Because of merging of function types from multiple decls it is
2332 // possible for the type of an argument to not match the corresponding
2333 // type in the function type. Since we are codegening the callee
2334 // in here, add a cast to the argument type.
2335 llvm::Type *LTy = ConvertType(Arg->getType());
2336 if (V->getType() != LTy)
2337 V = Builder.CreateBitCast(V, LTy);
2338
John McCall7f416cc2015-09-08 08:05:57 +00002339 ArgVals.push_back(ParamValue::forDirect(V));
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002340 break;
Daniel Dunbard5f1f552009-02-10 00:06:49 +00002341 }
Mike Stump11289f42009-09-09 15:08:12 +00002342
John McCall7f416cc2015-09-08 08:05:57 +00002343 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg),
2344 Arg->getName());
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002345
John McCall7f416cc2015-09-08 08:05:57 +00002346 // Pointer to store into.
2347 Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002348
Oliver Stannard2bfdc5b2014-08-27 10:43:15 +00002349 // Fast-isel and the optimizer generally like scalar values better than
2350 // FCAs, so we flatten them if this is safe to do for this argument.
Evgeniy Stepanov3fae4ae2012-02-10 09:30:15 +00002351 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
Oliver Stannard2bfdc5b2014-08-27 10:43:15 +00002352 if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy &&
2353 STy->getNumElements() > 1) {
John McCall7f416cc2015-09-08 08:05:57 +00002354 auto SrcLayout = CGM.getDataLayout().getStructLayout(STy);
Micah Villmowdd31ca12012-10-08 16:25:52 +00002355 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
John McCall7f416cc2015-09-08 08:05:57 +00002356 llvm::Type *DstTy = Ptr.getElementType();
Micah Villmowdd31ca12012-10-08 16:25:52 +00002357 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002358
John McCall7f416cc2015-09-08 08:05:57 +00002359 Address AddrToStoreInto = Address::invalid();
Evgeniy Stepanov3fae4ae2012-02-10 09:30:15 +00002360 if (SrcSize <= DstSize) {
John McCall7f416cc2015-09-08 08:05:57 +00002361 AddrToStoreInto =
2362 Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
Evgeniy Stepanov3fae4ae2012-02-10 09:30:15 +00002363 } else {
John McCall7f416cc2015-09-08 08:05:57 +00002364 AddrToStoreInto =
2365 CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
Chris Lattner15ec3612010-06-29 00:06:42 +00002366 }
John McCall7f416cc2015-09-08 08:05:57 +00002367
2368 assert(STy->getNumElements() == NumIRArgs);
2369 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2370 auto AI = FnArgs[FirstIRArg + i];
2371 AI->setName(Arg->getName() + ".coerce" + Twine(i));
2372 auto Offset = CharUnits::fromQuantity(SrcLayout->getElementOffset(i));
2373 Address EltPtr =
2374 Builder.CreateStructGEP(AddrToStoreInto, i, Offset);
2375 Builder.CreateStore(AI, EltPtr);
2376 }
2377
2378 if (SrcSize > DstSize) {
2379 Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize);
2380 }
2381
Chris Lattner15ec3612010-06-29 00:06:42 +00002382 } else {
2383 // Simple case, just do a coerced store of the argument into the alloca.
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002384 assert(NumIRArgs == 1);
2385 auto AI = FnArgs[FirstIRArg];
Chris Lattner9e748e92010-06-29 00:14:52 +00002386 AI->setName(Arg->getName() + ".coerce");
John McCall7f416cc2015-09-08 08:05:57 +00002387 CreateCoercedStore(AI, Ptr, /*DestIsVolatile=*/false, *this);
Chris Lattner15ec3612010-06-29 00:06:42 +00002388 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002389
Daniel Dunbar2f219b02009-02-03 19:12:28 +00002390 // Match to what EmitParmDecl is expecting for this type.
John McCall47fb9502013-03-07 21:37:08 +00002391 if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
John McCall7f416cc2015-09-08 08:05:57 +00002392 llvm::Value *V =
2393 EmitLoadOfScalar(Alloca, false, Ty, Arg->getLocStart());
John McCalla738c252011-03-09 04:27:21 +00002394 if (isPromoted)
2395 V = emitArgumentDemotion(*this, Arg, V);
John McCall7f416cc2015-09-08 08:05:57 +00002396 ArgVals.push_back(ParamValue::forDirect(V));
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002397 } else {
John McCall7f416cc2015-09-08 08:05:57 +00002398 ArgVals.push_back(ParamValue::forIndirect(Alloca));
Daniel Dunbar6e3b7df2009-02-04 07:22:24 +00002399 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002400 break;
Daniel Dunbar2f219b02009-02-03 19:12:28 +00002401 }
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002402
John McCallf26e73d2016-03-11 04:30:43 +00002403 case ABIArgInfo::CoerceAndExpand: {
2404 // Reconstruct into a temporary.
2405 Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2406 ArgVals.push_back(ParamValue::forIndirect(alloca));
2407
2408 auto coercionType = ArgI.getCoerceAndExpandType();
2409 alloca = Builder.CreateElementBitCast(alloca, coercionType);
2410 auto layout = CGM.getDataLayout().getStructLayout(coercionType);
2411
2412 unsigned argIndex = FirstIRArg;
2413 for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
2414 llvm::Type *eltType = coercionType->getElementType(i);
2415 if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType))
2416 continue;
2417
2418 auto eltAddr = Builder.CreateStructGEP(alloca, i, layout);
2419 auto elt = FnArgs[argIndex++];
2420 Builder.CreateStore(elt, eltAddr);
2421 }
2422 assert(argIndex == FirstIRArg + NumIRArgs);
2423 break;
2424 }
2425
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002426 case ABIArgInfo::Expand: {
2427 // If this structure was expanded into multiple arguments then
2428 // we need to create a temporary and reconstruct it from the
2429 // arguments.
John McCall7f416cc2015-09-08 08:05:57 +00002430 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2431 LValue LV = MakeAddrLValue(Alloca, Ty);
2432 ArgVals.push_back(ParamValue::forIndirect(Alloca));
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002433
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002434 auto FnArgIter = FnArgs.begin() + FirstIRArg;
2435 ExpandTypeFromArgs(Ty, LV, FnArgIter);
2436 assert(FnArgIter == FnArgs.begin() + FirstIRArg + NumIRArgs);
2437 for (unsigned i = 0, e = NumIRArgs; i != e; ++i) {
2438 auto AI = FnArgs[FirstIRArg + i];
2439 AI->setName(Arg->getName() + "." + Twine(i));
2440 }
2441 break;
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002442 }
2443
2444 case ABIArgInfo::Ignore:
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002445 assert(NumIRArgs == 0);
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002446 // Initialize the local variable appropriately.
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002447 if (!hasScalarEvaluationKind(Ty)) {
John McCall7f416cc2015-09-08 08:05:57 +00002448 ArgVals.push_back(ParamValue::forIndirect(CreateMemTemp(Ty)));
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002449 } else {
2450 llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType()));
John McCall7f416cc2015-09-08 08:05:57 +00002451 ArgVals.push_back(ParamValue::forDirect(U));
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002452 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00002453 break;
Daniel Dunbard3674e62008-09-11 01:48:57 +00002454 }
Daniel Dunbar613855c2008-09-09 23:27:19 +00002455 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002456
Reid Kleckner739756c2013-12-04 19:23:12 +00002457 if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {
2458 for (int I = Args.size() - 1; I >= 0; --I)
John McCall7f416cc2015-09-08 08:05:57 +00002459 EmitParmDecl(*Args[I], ArgVals[I], I + 1);
Reid Kleckner739756c2013-12-04 19:23:12 +00002460 } else {
2461 for (unsigned I = 0, E = Args.size(); I != E; ++I)
John McCall7f416cc2015-09-08 08:05:57 +00002462 EmitParmDecl(*Args[I], ArgVals[I], I + 1);
Reid Kleckner739756c2013-12-04 19:23:12 +00002463 }
Daniel Dunbar613855c2008-09-09 23:27:19 +00002464}
2465
John McCallffa2c1a2012-01-29 07:46:59 +00002466static void eraseUnusedBitCasts(llvm::Instruction *insn) {
2467 while (insn->use_empty()) {
2468 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
2469 if (!bitcast) return;
2470
2471 // This is "safe" because we would have used a ConstantExpr otherwise.
2472 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
2473 bitcast->eraseFromParent();
2474 }
2475}
2476
John McCall31168b02011-06-15 23:02:42 +00002477/// Try to emit a fused autorelease of a return result.
2478static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF,
2479 llvm::Value *result) {
2480 // We must be immediately followed the cast.
2481 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
Craig Topper8a13c412014-05-21 05:09:00 +00002482 if (BB->empty()) return nullptr;
2483 if (&BB->back() != result) return nullptr;
John McCall31168b02011-06-15 23:02:42 +00002484
Chris Lattner2192fe52011-07-18 04:24:23 +00002485 llvm::Type *resultType = result->getType();
John McCall31168b02011-06-15 23:02:42 +00002486
2487 // result is in a BasicBlock and is therefore an Instruction.
2488 llvm::Instruction *generator = cast<llvm::Instruction>(result);
2489
Justin Bogner882f8612016-08-18 21:46:54 +00002490 SmallVector<llvm::Instruction *, 4> InstsToKill;
John McCall31168b02011-06-15 23:02:42 +00002491
2492 // Look for:
2493 // %generator = bitcast %type1* %generator2 to %type2*
2494 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
2495 // We would have emitted this as a constant if the operand weren't
2496 // an Instruction.
2497 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
2498
2499 // Require the generator to be immediately followed by the cast.
2500 if (generator->getNextNode() != bitcast)
Craig Topper8a13c412014-05-21 05:09:00 +00002501 return nullptr;
John McCall31168b02011-06-15 23:02:42 +00002502
Justin Bogner882f8612016-08-18 21:46:54 +00002503 InstsToKill.push_back(bitcast);
John McCall31168b02011-06-15 23:02:42 +00002504 }
2505
2506 // Look for:
2507 // %generator = call i8* @objc_retain(i8* %originalResult)
2508 // or
2509 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
2510 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
Craig Topper8a13c412014-05-21 05:09:00 +00002511 if (!call) return nullptr;
John McCall31168b02011-06-15 23:02:42 +00002512
2513 bool doRetainAutorelease;
2514
John McCallb04ecb72015-10-21 18:06:43 +00002515 if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints().objc_retain) {
John McCall31168b02011-06-15 23:02:42 +00002516 doRetainAutorelease = true;
John McCallb04ecb72015-10-21 18:06:43 +00002517 } else if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints()
John McCall31168b02011-06-15 23:02:42 +00002518 .objc_retainAutoreleasedReturnValue) {
2519 doRetainAutorelease = false;
2520
John McCallcfa4e9b2012-09-07 23:30:50 +00002521 // If we emitted an assembly marker for this call (and the
2522 // ARCEntrypoints field should have been set if so), go looking
2523 // for that call. If we can't find it, we can't do this
2524 // optimization. But it should always be the immediately previous
2525 // instruction, unless we needed bitcasts around the call.
John McCallb04ecb72015-10-21 18:06:43 +00002526 if (CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker) {
John McCallcfa4e9b2012-09-07 23:30:50 +00002527 llvm::Instruction *prev = call->getPrevNode();
2528 assert(prev);
2529 if (isa<llvm::BitCastInst>(prev)) {
2530 prev = prev->getPrevNode();
2531 assert(prev);
2532 }
2533 assert(isa<llvm::CallInst>(prev));
2534 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
John McCallb04ecb72015-10-21 18:06:43 +00002535 CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker);
Justin Bogner882f8612016-08-18 21:46:54 +00002536 InstsToKill.push_back(prev);
John McCallcfa4e9b2012-09-07 23:30:50 +00002537 }
John McCall31168b02011-06-15 23:02:42 +00002538 } else {
Craig Topper8a13c412014-05-21 05:09:00 +00002539 return nullptr;
John McCall31168b02011-06-15 23:02:42 +00002540 }
2541
2542 result = call->getArgOperand(0);
Justin Bogner882f8612016-08-18 21:46:54 +00002543 InstsToKill.push_back(call);
John McCall31168b02011-06-15 23:02:42 +00002544
2545 // Keep killing bitcasts, for sanity. Note that we no longer care
2546 // about precise ordering as long as there's exactly one use.
2547 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
2548 if (!bitcast->hasOneUse()) break;
Justin Bogner882f8612016-08-18 21:46:54 +00002549 InstsToKill.push_back(bitcast);
John McCall31168b02011-06-15 23:02:42 +00002550 result = bitcast->getOperand(0);
2551 }
2552
2553 // Delete all the unnecessary instructions, from latest to earliest.
Justin Bogner882f8612016-08-18 21:46:54 +00002554 for (auto *I : InstsToKill)
Saleem Abdulrasoolbe25c482016-08-18 21:40:06 +00002555 I->eraseFromParent();
John McCall31168b02011-06-15 23:02:42 +00002556
2557 // Do the fused retain/autorelease if we were asked to.
2558 if (doRetainAutorelease)
2559 result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
2560
2561 // Cast back to the result type.
2562 return CGF.Builder.CreateBitCast(result, resultType);
2563}
2564
John McCallffa2c1a2012-01-29 07:46:59 +00002565/// If this is a +1 of the value of an immutable 'self', remove it.
2566static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF,
2567 llvm::Value *result) {
2568 // This is only applicable to a method with an immutable 'self'.
John McCallff755cd2012-07-31 00:33:55 +00002569 const ObjCMethodDecl *method =
2570 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
Craig Topper8a13c412014-05-21 05:09:00 +00002571 if (!method) return nullptr;
John McCallffa2c1a2012-01-29 07:46:59 +00002572 const VarDecl *self = method->getSelfDecl();
Craig Topper8a13c412014-05-21 05:09:00 +00002573 if (!self->getType().isConstQualified()) return nullptr;
John McCallffa2c1a2012-01-29 07:46:59 +00002574
2575 // Look for a retain call.
2576 llvm::CallInst *retainCall =
2577 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
2578 if (!retainCall ||
John McCallb04ecb72015-10-21 18:06:43 +00002579 retainCall->getCalledValue() != CGF.CGM.getObjCEntrypoints().objc_retain)
Craig Topper8a13c412014-05-21 05:09:00 +00002580 return nullptr;
John McCallffa2c1a2012-01-29 07:46:59 +00002581
2582 // Look for an ordinary load of 'self'.
2583 llvm::Value *retainedValue = retainCall->getArgOperand(0);
2584 llvm::LoadInst *load =
2585 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
2586 if (!load || load->isAtomic() || load->isVolatile() ||
John McCall7f416cc2015-09-08 08:05:57 +00002587 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self).getPointer())
Craig Topper8a13c412014-05-21 05:09:00 +00002588 return nullptr;
John McCallffa2c1a2012-01-29 07:46:59 +00002589
2590 // Okay! Burn it all down. This relies for correctness on the
2591 // assumption that the retain is emitted as part of the return and
2592 // that thereafter everything is used "linearly".
2593 llvm::Type *resultType = result->getType();
2594 eraseUnusedBitCasts(cast<llvm::Instruction>(result));
2595 assert(retainCall->use_empty());
2596 retainCall->eraseFromParent();
2597 eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
2598
2599 return CGF.Builder.CreateBitCast(load, resultType);
2600}
2601
John McCall31168b02011-06-15 23:02:42 +00002602/// Emit an ARC autorelease of the result of a function.
John McCallffa2c1a2012-01-29 07:46:59 +00002603///
2604/// \return the value to actually return from the function
John McCall31168b02011-06-15 23:02:42 +00002605static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF,
2606 llvm::Value *result) {
John McCallffa2c1a2012-01-29 07:46:59 +00002607 // If we're returning 'self', kill the initial retain. This is a
2608 // heuristic attempt to "encourage correctness" in the really unfortunate
2609 // case where we have a return of self during a dealloc and we desperately
2610 // need to avoid the possible autorelease.
2611 if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
2612 return self;
2613
John McCall31168b02011-06-15 23:02:42 +00002614 // At -O0, try to emit a fused retain/autorelease.
2615 if (CGF.shouldUseFusedARCCalls())
2616 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
2617 return fused;
2618
2619 return CGF.EmitARCAutoreleaseReturnValue(result);
2620}
2621
John McCall6e1c0122012-01-29 02:35:02 +00002622/// Heuristically search for a dominating store to the return-value slot.
2623static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
Jakub Kuderskif50ab0f2015-09-08 10:36:42 +00002624 // Check if a User is a store which pointerOperand is the ReturnValue.
2625 // We are looking for stores to the ReturnValue, not for stores of the
2626 // ReturnValue to some other location.
2627 auto GetStoreIfValid = [&CGF](llvm::User *U) -> llvm::StoreInst * {
2628 auto *SI = dyn_cast<llvm::StoreInst>(U);
2629 if (!SI || SI->getPointerOperand() != CGF.ReturnValue.getPointer())
2630 return nullptr;
2631 // These aren't actually possible for non-coerced returns, and we
2632 // only care about non-coerced returns on this code path.
2633 assert(!SI->isAtomic() && !SI->isVolatile());
2634 return SI;
2635 };
John McCall6e1c0122012-01-29 02:35:02 +00002636 // If there are multiple uses of the return-value slot, just check
2637 // for something immediately preceding the IP. Sometimes this can
2638 // happen with how we generate implicit-returns; it can also happen
2639 // with noreturn cleanups.
John McCall7f416cc2015-09-08 08:05:57 +00002640 if (!CGF.ReturnValue.getPointer()->hasOneUse()) {
John McCall6e1c0122012-01-29 02:35:02 +00002641 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
Craig Topper8a13c412014-05-21 05:09:00 +00002642 if (IP->empty()) return nullptr;
David Majnemerdc012fa2015-04-22 21:38:15 +00002643 llvm::Instruction *I = &IP->back();
2644
2645 // Skip lifetime markers
2646 for (llvm::BasicBlock::reverse_iterator II = IP->rbegin(),
2647 IE = IP->rend();
2648 II != IE; ++II) {
2649 if (llvm::IntrinsicInst *Intrinsic =
2650 dyn_cast<llvm::IntrinsicInst>(&*II)) {
2651 if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) {
2652 const llvm::Value *CastAddr = Intrinsic->getArgOperand(1);
2653 ++II;
Alexey Samsonov10544202015-06-12 21:05:32 +00002654 if (II == IE)
2655 break;
2656 if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
2657 continue;
David Majnemerdc012fa2015-04-22 21:38:15 +00002658 }
2659 }
2660 I = &*II;
2661 break;
2662 }
2663
Jakub Kuderskif50ab0f2015-09-08 10:36:42 +00002664 return GetStoreIfValid(I);
John McCall6e1c0122012-01-29 02:35:02 +00002665 }
2666
2667 llvm::StoreInst *store =
Jakub Kuderskif50ab0f2015-09-08 10:36:42 +00002668 GetStoreIfValid(CGF.ReturnValue.getPointer()->user_back());
Craig Topper8a13c412014-05-21 05:09:00 +00002669 if (!store) return nullptr;
John McCall6e1c0122012-01-29 02:35:02 +00002670
John McCall6e1c0122012-01-29 02:35:02 +00002671 // Now do a first-and-dirty dominance check: just walk up the
2672 // single-predecessors chain from the current insertion point.
2673 llvm::BasicBlock *StoreBB = store->getParent();
2674 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2675 while (IP != StoreBB) {
2676 if (!(IP = IP->getSinglePredecessor()))
Craig Topper8a13c412014-05-21 05:09:00 +00002677 return nullptr;
John McCall6e1c0122012-01-29 02:35:02 +00002678 }
2679
2680 // Okay, the store's basic block dominates the insertion point; we
2681 // can do our thing.
2682 return store;
2683}
2684
Adrian Prantl3be10542013-05-02 17:30:20 +00002685void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
Nick Lewycky2d84e842013-10-02 02:29:49 +00002686 bool EmitRetDbgLoc,
2687 SourceLocation EndLoc) {
Hans Wennborgd71907d2014-09-04 22:16:33 +00002688 if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) {
2689 // Naked functions don't have epilogues.
2690 Builder.CreateUnreachable();
2691 return;
2692 }
2693
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00002694 // Functions with no result always return void.
John McCall7f416cc2015-09-08 08:05:57 +00002695 if (!ReturnValue.isValid()) {
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00002696 Builder.CreateRetVoid();
Chris Lattner726b3d02010-06-26 23:13:19 +00002697 return;
Daniel Dunbara72d4ae2008-09-10 02:41:04 +00002698 }
Daniel Dunbar6696e222010-06-30 21:27:58 +00002699
Dan Gohman481e40c2010-07-20 20:13:52 +00002700 llvm::DebugLoc RetDbgLoc;
Craig Topper8a13c412014-05-21 05:09:00 +00002701 llvm::Value *RV = nullptr;
Chris Lattner726b3d02010-06-26 23:13:19 +00002702 QualType RetTy = FI.getReturnType();
2703 const ABIArgInfo &RetAI = FI.getReturnInfo();
2704
2705 switch (RetAI.getKind()) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002706 case ABIArgInfo::InAlloca:
Reid Klecknerfab1e892014-02-25 00:59:14 +00002707 // Aggregrates get evaluated directly into the destination. Sometimes we
2708 // need to return the sret value in a register, though.
2709 assert(hasAggregateEvaluationKind(RetTy));
2710 if (RetAI.getInAllocaSRet()) {
2711 llvm::Function::arg_iterator EI = CurFn->arg_end();
2712 --EI;
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +00002713 llvm::Value *ArgStruct = &*EI;
David Blaikie2e804282015-04-05 22:47:07 +00002714 llvm::Value *SRet = Builder.CreateStructGEP(
2715 nullptr, ArgStruct, RetAI.getInAllocaFieldIndex());
John McCall7f416cc2015-09-08 08:05:57 +00002716 RV = Builder.CreateAlignedLoad(SRet, getPointerAlign(), "sret");
Reid Klecknerfab1e892014-02-25 00:59:14 +00002717 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002718 break;
2719
Daniel Dunbar03816342010-08-21 02:24:36 +00002720 case ABIArgInfo::Indirect: {
Reid Kleckner37abaca2014-05-09 22:46:15 +00002721 auto AI = CurFn->arg_begin();
2722 if (RetAI.isSRetAfterThis())
2723 ++AI;
John McCall47fb9502013-03-07 21:37:08 +00002724 switch (getEvaluationKind(RetTy)) {
2725 case TEK_Complex: {
2726 ComplexPairTy RT =
John McCall7f416cc2015-09-08 08:05:57 +00002727 EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc);
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +00002728 EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),
John McCall47fb9502013-03-07 21:37:08 +00002729 /*isInit*/ true);
2730 break;
2731 }
2732 case TEK_Aggregate:
Chris Lattner726b3d02010-06-26 23:13:19 +00002733 // Do nothing; aggregrates get evaluated directly into the destination.
John McCall47fb9502013-03-07 21:37:08 +00002734 break;
2735 case TEK_Scalar:
2736 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
Duncan P. N. Exon Smith9f5260a2015-11-06 23:00:41 +00002737 MakeNaturalAlignAddrLValue(&*AI, RetTy),
John McCall47fb9502013-03-07 21:37:08 +00002738 /*isInit*/ true);
2739 break;
Chris Lattner726b3d02010-06-26 23:13:19 +00002740 }
2741 break;
Daniel Dunbar03816342010-08-21 02:24:36 +00002742 }
Chris Lattner726b3d02010-06-26 23:13:19 +00002743
2744 case ABIArgInfo::Extend:
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002745 case ABIArgInfo::Direct:
Chris Lattner8a2f3c72010-07-30 04:02:24 +00002746 if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
2747 RetAI.getDirectOffset() == 0) {
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002748 // The internal return value temp always will have pointer-to-return-type
2749 // type, just do a load.
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002750
John McCall6e1c0122012-01-29 02:35:02 +00002751 // If there is a dominating store to ReturnValue, we can elide
2752 // the load, zap the store, and usually zap the alloca.
David Majnemerdc012fa2015-04-22 21:38:15 +00002753 if (llvm::StoreInst *SI =
2754 findDominatingStoreToReturnValue(*this)) {
Adrian Prantl4c9a38a2013-05-30 18:12:23 +00002755 // Reuse the debug location from the store unless there is
2756 // cleanup code to be emitted between the store and return
2757 // instruction.
2758 if (EmitRetDbgLoc && !AutoreleaseResult)
Adrian Prantl3be10542013-05-02 17:30:20 +00002759 RetDbgLoc = SI->getDebugLoc();
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002760 // Get the stored value and nuke the now-dead store.
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002761 RV = SI->getValueOperand();
2762 SI->eraseFromParent();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002763
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002764 // If that was the only use of the return value, nuke it as well now.
John McCall7f416cc2015-09-08 08:05:57 +00002765 auto returnValueInst = ReturnValue.getPointer();
2766 if (returnValueInst->use_empty()) {
2767 if (auto alloca = dyn_cast<llvm::AllocaInst>(returnValueInst)) {
2768 alloca->eraseFromParent();
2769 ReturnValue = Address::invalid();
2770 }
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002771 }
John McCall6e1c0122012-01-29 02:35:02 +00002772
2773 // Otherwise, we have to do a simple load.
2774 } else {
2775 RV = Builder.CreateLoad(ReturnValue);
Chris Lattner3fcc7902010-06-27 01:06:27 +00002776 }
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002777 } else {
Chris Lattner8a2f3c72010-07-30 04:02:24 +00002778 // If the value is offset in memory, apply the offset now.
John McCall7f416cc2015-09-08 08:05:57 +00002779 Address V = emitAddressAtOffset(*this, ReturnValue, RetAI);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002780
John McCall7f416cc2015-09-08 08:05:57 +00002781 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
Chris Lattner3fcc7902010-06-27 01:06:27 +00002782 }
John McCall31168b02011-06-15 23:02:42 +00002783
2784 // In ARC, end functions that return a retainable type with a call
2785 // to objc_autoreleaseReturnValue.
2786 if (AutoreleaseResult) {
Akira Hatanaka9d8ac612016-02-17 21:09:50 +00002787#ifndef NDEBUG
2788 // Type::isObjCRetainabletype has to be called on a QualType that hasn't
2789 // been stripped of the typedefs, so we cannot use RetTy here. Get the
2790 // original return type of FunctionDecl, CurCodeDecl, and BlockDecl from
2791 // CurCodeDecl or BlockInfo.
2792 QualType RT;
2793
2794 if (auto *FD = dyn_cast<FunctionDecl>(CurCodeDecl))
2795 RT = FD->getReturnType();
2796 else if (auto *MD = dyn_cast<ObjCMethodDecl>(CurCodeDecl))
2797 RT = MD->getReturnType();
2798 else if (isa<BlockDecl>(CurCodeDecl))
2799 RT = BlockInfo->BlockExpression->getFunctionType()->getReturnType();
2800 else
2801 llvm_unreachable("Unexpected function/method type");
2802
David Blaikiebbafb8a2012-03-11 07:00:24 +00002803 assert(getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00002804 !FI.isReturnsRetained() &&
Akira Hatanaka9d8ac612016-02-17 21:09:50 +00002805 RT->isObjCRetainableType());
2806#endif
John McCall31168b02011-06-15 23:02:42 +00002807 RV = emitAutoreleaseOfResult(*this, RV);
2808 }
2809
Chris Lattner726b3d02010-06-26 23:13:19 +00002810 break;
Chris Lattner726b3d02010-06-26 23:13:19 +00002811
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00002812 case ABIArgInfo::Ignore:
Chris Lattner726b3d02010-06-26 23:13:19 +00002813 break;
2814
John McCallf26e73d2016-03-11 04:30:43 +00002815 case ABIArgInfo::CoerceAndExpand: {
2816 auto coercionType = RetAI.getCoerceAndExpandType();
2817 auto layout = CGM.getDataLayout().getStructLayout(coercionType);
2818
2819 // Load all of the coerced elements out into results.
2820 llvm::SmallVector<llvm::Value*, 4> results;
2821 Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType);
2822 for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
2823 auto coercedEltType = coercionType->getElementType(i);
2824 if (ABIArgInfo::isPaddingForCoerceAndExpand(coercedEltType))
2825 continue;
2826
2827 auto eltAddr = Builder.CreateStructGEP(addr, i, layout);
2828 auto elt = Builder.CreateLoad(eltAddr);
2829 results.push_back(elt);
2830 }
2831
2832 // If we have one result, it's the single direct result type.
2833 if (results.size() == 1) {
2834 RV = results[0];
2835
2836 // Otherwise, we need to make a first-class aggregate.
2837 } else {
2838 // Construct a return type that lacks padding elements.
2839 llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType();
2840
2841 RV = llvm::UndefValue::get(returnType);
2842 for (unsigned i = 0, e = results.size(); i != e; ++i) {
2843 RV = Builder.CreateInsertValue(RV, results[i], i);
2844 }
2845 }
2846 break;
2847 }
2848
Chris Lattner726b3d02010-06-26 23:13:19 +00002849 case ABIArgInfo::Expand:
David Blaikie83d382b2011-09-23 05:06:16 +00002850 llvm_unreachable("Invalid ABI kind for return argument");
Chris Lattner726b3d02010-06-26 23:13:19 +00002851 }
2852
Alexey Samsonovde443c52014-08-13 00:26:40 +00002853 llvm::Instruction *Ret;
2854 if (RV) {
John McCall9a2c1c92015-09-10 00:57:46 +00002855 if (CurCodeDecl && SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) {
2856 if (auto RetNNAttr = CurCodeDecl->getAttr<ReturnsNonNullAttr>()) {
Alexey Samsonov90452df2014-09-08 20:17:19 +00002857 SanitizerScope SanScope(this);
2858 llvm::Value *Cond = Builder.CreateICmpNE(
2859 RV, llvm::Constant::getNullValue(RV->getType()));
2860 llvm::Constant *StaticData[] = {
2861 EmitCheckSourceLocation(EndLoc),
2862 EmitCheckSourceLocation(RetNNAttr->getLocation()),
2863 };
Alexey Samsonove396bfc2014-11-11 22:03:54 +00002864 EmitCheck(std::make_pair(Cond, SanitizerKind::ReturnsNonnullAttribute),
2865 "nonnull_return", StaticData, None);
Alexey Samsonov90452df2014-09-08 20:17:19 +00002866 }
Alexey Samsonovde443c52014-08-13 00:26:40 +00002867 }
2868 Ret = Builder.CreateRet(RV);
2869 } else {
2870 Ret = Builder.CreateRetVoid();
2871 }
2872
Duncan P. N. Exon Smith2809cc72015-03-30 20:01:41 +00002873 if (RetDbgLoc)
Benjamin Kramer03278662015-02-07 13:15:54 +00002874 Ret->setDebugLoc(std::move(RetDbgLoc));
Daniel Dunbar613855c2008-09-09 23:27:19 +00002875}
2876
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002877static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) {
2878 const CXXRecordDecl *RD = type->getAsCXXRecordDecl();
2879 return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory;
2880}
2881
John McCall7f416cc2015-09-08 08:05:57 +00002882static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF,
2883 QualType Ty) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002884 // FIXME: Generate IR in one pass, rather than going back and fixing up these
2885 // placeholders.
2886 llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty);
Peter Collingbourneb367c562016-11-28 22:30:21 +00002887 llvm::Type *IRPtrTy = IRTy->getPointerTo();
2888 llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo());
John McCall7f416cc2015-09-08 08:05:57 +00002889
2890 // FIXME: When we generate this IR in one pass, we shouldn't need
2891 // this win32-specific alignment hack.
2892 CharUnits Align = CharUnits::fromQuantity(4);
Peter Collingbourneb367c562016-11-28 22:30:21 +00002893 Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align);
John McCall7f416cc2015-09-08 08:05:57 +00002894
2895 return AggValueSlot::forAddr(Address(Placeholder, Align),
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002896 Ty.getQualifiers(),
2897 AggValueSlot::IsNotDestructed,
2898 AggValueSlot::DoesNotNeedGCBarriers,
2899 AggValueSlot::IsNotAliased);
2900}
2901
John McCall32ea9692011-03-11 20:59:21 +00002902void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
Nick Lewycky2d84e842013-10-02 02:29:49 +00002903 const VarDecl *param,
2904 SourceLocation loc) {
John McCall23f66262010-05-26 22:34:26 +00002905 // StartFunction converted the ABI-lowered parameter(s) into a
2906 // local alloca. We need to turn that into an r-value suitable
2907 // for EmitCall.
John McCall7f416cc2015-09-08 08:05:57 +00002908 Address local = GetAddrOfLocalVar(param);
John McCall23f66262010-05-26 22:34:26 +00002909
John McCall32ea9692011-03-11 20:59:21 +00002910 QualType type = param->getType();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002911
Reid Klecknerab2090d2014-07-26 01:34:32 +00002912 assert(!isInAllocaArgument(CGM.getCXXABI(), type) &&
2913 "cannot emit delegate call arguments for inalloca arguments!");
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002914
John McCall811b2912016-11-18 01:08:24 +00002915 // GetAddrOfLocalVar returns a pointer-to-pointer for references,
2916 // but the argument needs to be the original pointer.
2917 if (type->isReferenceType()) {
2918 args.add(RValue::get(Builder.CreateLoad(local)), type);
2919
2920 // In ARC, move out of consumed arguments so that the release cleanup
2921 // entered by StartFunction doesn't cause an over-release. This isn't
2922 // optimal -O0 code generation, but it should get cleaned up when
2923 // optimization is enabled. This also assumes that delegate calls are
2924 // performed exactly once for a set of arguments, but that should be safe.
2925 } else if (getLangOpts().ObjCAutoRefCount &&
2926 param->hasAttr<NSConsumedAttr>() &&
2927 type->isObjCRetainableType()) {
2928 llvm::Value *ptr = Builder.CreateLoad(local);
2929 auto null =
2930 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(ptr->getType()));
2931 Builder.CreateStore(null, local);
2932 args.add(RValue::get(ptr), type);
2933
Richard Smithd62d4982016-06-14 01:13:21 +00002934 // For the most part, we just need to load the alloca, except that
2935 // aggregate r-values are actually pointers to temporaries.
John McCall811b2912016-11-18 01:08:24 +00002936 } else {
Richard Smithd62d4982016-06-14 01:13:21 +00002937 args.add(convertTempToRValue(local, type, loc), type);
John McCall811b2912016-11-18 01:08:24 +00002938 }
John McCall23f66262010-05-26 22:34:26 +00002939}
2940
John McCall31168b02011-06-15 23:02:42 +00002941static bool isProvablyNull(llvm::Value *addr) {
2942 return isa<llvm::ConstantPointerNull>(addr);
2943}
2944
John McCall31168b02011-06-15 23:02:42 +00002945/// Emit the actual writing-back of a writeback.
2946static void emitWriteback(CodeGenFunction &CGF,
2947 const CallArgList::Writeback &writeback) {
John McCalleff18842013-03-23 02:35:54 +00002948 const LValue &srcLV = writeback.Source;
John McCall7f416cc2015-09-08 08:05:57 +00002949 Address srcAddr = srcLV.getAddress();
2950 assert(!isProvablyNull(srcAddr.getPointer()) &&
John McCall31168b02011-06-15 23:02:42 +00002951 "shouldn't have writeback for provably null argument");
2952
Craig Topper8a13c412014-05-21 05:09:00 +00002953 llvm::BasicBlock *contBB = nullptr;
John McCall31168b02011-06-15 23:02:42 +00002954
2955 // If the argument wasn't provably non-null, we need to null check
2956 // before doing the store.
Nick Lewyckyd9bce502016-09-20 15:49:58 +00002957 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer());
John McCall31168b02011-06-15 23:02:42 +00002958 if (!provablyNonNull) {
2959 llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
2960 contBB = CGF.createBasicBlock("icr.done");
2961
John McCall7f416cc2015-09-08 08:05:57 +00002962 llvm::Value *isNull =
2963 CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
John McCall31168b02011-06-15 23:02:42 +00002964 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
2965 CGF.EmitBlock(writebackBB);
2966 }
2967
2968 // Load the value to writeback.
2969 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
2970
2971 // Cast it back, in case we're writing an id to a Foo* or something.
John McCall7f416cc2015-09-08 08:05:57 +00002972 value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(),
2973 "icr.writeback-cast");
John McCall31168b02011-06-15 23:02:42 +00002974
2975 // Perform the writeback.
John McCalleff18842013-03-23 02:35:54 +00002976
2977 // If we have a "to use" value, it's something we need to emit a use
2978 // of. This has to be carefully threaded in: if it's done after the
2979 // release it's potentially undefined behavior (and the optimizer
2980 // will ignore it), and if it happens before the retain then the
2981 // optimizer could move the release there.
2982 if (writeback.ToUse) {
2983 assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong);
2984
2985 // Retain the new value. No need to block-copy here: the block's
2986 // being passed up the stack.
2987 value = CGF.EmitARCRetainNonBlock(value);
2988
2989 // Emit the intrinsic use here.
2990 CGF.EmitARCIntrinsicUse(writeback.ToUse);
2991
2992 // Load the old value (primitively).
Nick Lewycky2d84e842013-10-02 02:29:49 +00002993 llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation());
John McCalleff18842013-03-23 02:35:54 +00002994
2995 // Put the new value in place (primitively).
2996 CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
2997
2998 // Release the old value.
2999 CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
3000
3001 // Otherwise, we can just do a normal lvalue store.
3002 } else {
3003 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
3004 }
John McCall31168b02011-06-15 23:02:42 +00003005
3006 // Jump to the continuation block.
3007 if (!provablyNonNull)
3008 CGF.EmitBlock(contBB);
3009}
3010
3011static void emitWritebacks(CodeGenFunction &CGF,
3012 const CallArgList &args) {
Aaron Ballman36a7fa82014-03-17 17:22:27 +00003013 for (const auto &I : args.writebacks())
3014 emitWriteback(CGF, I);
John McCall31168b02011-06-15 23:02:42 +00003015}
3016
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003017static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF,
3018 const CallArgList &CallArgs) {
Reid Kleckner739756c2013-12-04 19:23:12 +00003019 assert(CGF.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee());
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003020 ArrayRef<CallArgList::CallArgCleanup> Cleanups =
3021 CallArgs.getCleanupsToDeactivate();
3022 // Iterate in reverse to increase the likelihood of popping the cleanup.
Pete Cooper57d3f142015-07-30 17:22:52 +00003023 for (const auto &I : llvm::reverse(Cleanups)) {
3024 CGF.DeactivateCleanupBlock(I.Cleanup, I.IsActiveIP);
3025 I.IsActiveIP->eraseFromParent();
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003026 }
3027}
3028
John McCalleff18842013-03-23 02:35:54 +00003029static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
3030 if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens()))
3031 if (uop->getOpcode() == UO_AddrOf)
3032 return uop->getSubExpr();
Craig Topper8a13c412014-05-21 05:09:00 +00003033 return nullptr;
John McCalleff18842013-03-23 02:35:54 +00003034}
3035
John McCall31168b02011-06-15 23:02:42 +00003036/// Emit an argument that's being passed call-by-writeback. That is,
John McCall7f416cc2015-09-08 08:05:57 +00003037/// we are passing the address of an __autoreleased temporary; it
3038/// might be copy-initialized with the current value of the given
3039/// address, but it will definitely be copied out of after the call.
John McCall31168b02011-06-15 23:02:42 +00003040static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
3041 const ObjCIndirectCopyRestoreExpr *CRE) {
John McCalleff18842013-03-23 02:35:54 +00003042 LValue srcLV;
3043
3044 // Make an optimistic effort to emit the address as an l-value.
Eric Christopher2c4555a2015-06-19 01:52:53 +00003045 // This can fail if the argument expression is more complicated.
John McCalleff18842013-03-23 02:35:54 +00003046 if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
3047 srcLV = CGF.EmitLValue(lvExpr);
3048
3049 // Otherwise, just emit it as a scalar.
3050 } else {
John McCall7f416cc2015-09-08 08:05:57 +00003051 Address srcAddr = CGF.EmitPointerWithAlignment(CRE->getSubExpr());
John McCalleff18842013-03-23 02:35:54 +00003052
3053 QualType srcAddrType =
3054 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
John McCall7f416cc2015-09-08 08:05:57 +00003055 srcLV = CGF.MakeAddrLValue(srcAddr, srcAddrType);
John McCalleff18842013-03-23 02:35:54 +00003056 }
John McCall7f416cc2015-09-08 08:05:57 +00003057 Address srcAddr = srcLV.getAddress();
John McCall31168b02011-06-15 23:02:42 +00003058
3059 // The dest and src types don't necessarily match in LLVM terms
3060 // because of the crazy ObjC compatibility rules.
3061
Chris Lattner2192fe52011-07-18 04:24:23 +00003062 llvm::PointerType *destType =
John McCall31168b02011-06-15 23:02:42 +00003063 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
3064
3065 // If the address is a constant null, just pass the appropriate null.
John McCall7f416cc2015-09-08 08:05:57 +00003066 if (isProvablyNull(srcAddr.getPointer())) {
John McCall31168b02011-06-15 23:02:42 +00003067 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
3068 CRE->getType());
3069 return;
3070 }
3071
John McCall31168b02011-06-15 23:02:42 +00003072 // Create the temporary.
John McCall7f416cc2015-09-08 08:05:57 +00003073 Address temp = CGF.CreateTempAlloca(destType->getElementType(),
3074 CGF.getPointerAlign(),
3075 "icr.temp");
Fariborz Jahanianfbd19742012-11-27 23:02:53 +00003076 // Loading an l-value can introduce a cleanup if the l-value is __weak,
3077 // and that cleanup will be conditional if we can't prove that the l-value
3078 // isn't null, so we need to register a dominating point so that the cleanups
3079 // system will make valid IR.
3080 CodeGenFunction::ConditionalEvaluation condEval(CGF);
3081
John McCall31168b02011-06-15 23:02:42 +00003082 // Zero-initialize it if we're not doing a copy-initialization.
3083 bool shouldCopy = CRE->shouldCopy();
3084 if (!shouldCopy) {
3085 llvm::Value *null =
3086 llvm::ConstantPointerNull::get(
3087 cast<llvm::PointerType>(destType->getElementType()));
3088 CGF.Builder.CreateStore(null, temp);
3089 }
Craig Topper8a13c412014-05-21 05:09:00 +00003090
3091 llvm::BasicBlock *contBB = nullptr;
3092 llvm::BasicBlock *originBB = nullptr;
John McCall31168b02011-06-15 23:02:42 +00003093
3094 // If the address is *not* known to be non-null, we need to switch.
3095 llvm::Value *finalArgument;
3096
Nick Lewyckyd9bce502016-09-20 15:49:58 +00003097 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer());
John McCall31168b02011-06-15 23:02:42 +00003098 if (provablyNonNull) {
John McCall7f416cc2015-09-08 08:05:57 +00003099 finalArgument = temp.getPointer();
John McCall31168b02011-06-15 23:02:42 +00003100 } else {
John McCall7f416cc2015-09-08 08:05:57 +00003101 llvm::Value *isNull =
3102 CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
John McCall31168b02011-06-15 23:02:42 +00003103
3104 finalArgument = CGF.Builder.CreateSelect(isNull,
3105 llvm::ConstantPointerNull::get(destType),
John McCall7f416cc2015-09-08 08:05:57 +00003106 temp.getPointer(), "icr.argument");
John McCall31168b02011-06-15 23:02:42 +00003107
3108 // If we need to copy, then the load has to be conditional, which
3109 // means we need control flow.
3110 if (shouldCopy) {
John McCalleff18842013-03-23 02:35:54 +00003111 originBB = CGF.Builder.GetInsertBlock();
John McCall31168b02011-06-15 23:02:42 +00003112 contBB = CGF.createBasicBlock("icr.cont");
3113 llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy");
3114 CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
3115 CGF.EmitBlock(copyBB);
Fariborz Jahanianfbd19742012-11-27 23:02:53 +00003116 condEval.begin(CGF);
John McCall31168b02011-06-15 23:02:42 +00003117 }
3118 }
3119
Craig Topper8a13c412014-05-21 05:09:00 +00003120 llvm::Value *valueToUse = nullptr;
John McCalleff18842013-03-23 02:35:54 +00003121
John McCall31168b02011-06-15 23:02:42 +00003122 // Perform a copy if necessary.
3123 if (shouldCopy) {
Nick Lewycky2d84e842013-10-02 02:29:49 +00003124 RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation());
John McCall31168b02011-06-15 23:02:42 +00003125 assert(srcRV.isScalar());
3126
3127 llvm::Value *src = srcRV.getScalarVal();
3128 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
3129 "icr.cast");
3130
3131 // Use an ordinary store, not a store-to-lvalue.
3132 CGF.Builder.CreateStore(src, temp);
John McCalleff18842013-03-23 02:35:54 +00003133
3134 // If optimization is enabled, and the value was held in a
3135 // __strong variable, we need to tell the optimizer that this
3136 // value has to stay alive until we're doing the store back.
3137 // This is because the temporary is effectively unretained,
3138 // and so otherwise we can violate the high-level semantics.
3139 if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 &&
3140 srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) {
3141 valueToUse = src;
3142 }
John McCall31168b02011-06-15 23:02:42 +00003143 }
Fariborz Jahanianfbd19742012-11-27 23:02:53 +00003144
John McCall31168b02011-06-15 23:02:42 +00003145 // Finish the control flow if we needed it.
Fariborz Jahanianfbd19742012-11-27 23:02:53 +00003146 if (shouldCopy && !provablyNonNull) {
John McCalleff18842013-03-23 02:35:54 +00003147 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
John McCall31168b02011-06-15 23:02:42 +00003148 CGF.EmitBlock(contBB);
John McCalleff18842013-03-23 02:35:54 +00003149
3150 // Make a phi for the value to intrinsically use.
3151 if (valueToUse) {
3152 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
3153 "icr.to-use");
3154 phiToUse->addIncoming(valueToUse, copyBB);
3155 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
3156 originBB);
3157 valueToUse = phiToUse;
3158 }
3159
Fariborz Jahanianfbd19742012-11-27 23:02:53 +00003160 condEval.end(CGF);
3161 }
John McCall31168b02011-06-15 23:02:42 +00003162
John McCalleff18842013-03-23 02:35:54 +00003163 args.addWriteback(srcLV, temp, valueToUse);
John McCall31168b02011-06-15 23:02:42 +00003164 args.add(RValue::get(finalArgument), CRE->getType());
3165}
3166
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003167void CallArgList::allocateArgumentMemory(CodeGenFunction &CGF) {
Richard Smith762672a2016-09-28 19:09:10 +00003168 assert(!StackBase);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003169
3170 // Save the stack.
3171 llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave);
David Blaikie43f9bb72015-05-18 22:14:03 +00003172 StackBase = CGF.Builder.CreateCall(F, {}, "inalloca.save");
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003173}
3174
Nico Weber8cdb3f92015-08-25 18:43:32 +00003175void CallArgList::freeArgumentMemory(CodeGenFunction &CGF) const {
3176 if (StackBase) {
Reid Kleckner7c2f9e82015-10-08 00:17:45 +00003177 // Restore the stack after the call.
Nico Weber8cdb3f92015-08-25 18:43:32 +00003178 llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
Nico Weber8cdb3f92015-08-25 18:43:32 +00003179 CGF.Builder.CreateCall(F, StackBase);
3180 }
3181}
3182
Nuno Lopes1ba2d782015-05-30 16:11:40 +00003183void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType,
3184 SourceLocation ArgLoc,
3185 const FunctionDecl *FD,
3186 unsigned ParmNum) {
3187 if (!SanOpts.has(SanitizerKind::NonnullAttribute) || !FD)
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00003188 return;
3189 auto PVD = ParmNum < FD->getNumParams() ? FD->getParamDecl(ParmNum) : nullptr;
3190 unsigned ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum;
3191 auto NNAttr = getNonNullAttr(FD, PVD, ArgType, ArgNo);
3192 if (!NNAttr)
3193 return;
Nuno Lopes1ba2d782015-05-30 16:11:40 +00003194 SanitizerScope SanScope(this);
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00003195 assert(RV.isScalar());
3196 llvm::Value *V = RV.getScalarVal();
3197 llvm::Value *Cond =
Nuno Lopes1ba2d782015-05-30 16:11:40 +00003198 Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType()));
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00003199 llvm::Constant *StaticData[] = {
Nuno Lopes1ba2d782015-05-30 16:11:40 +00003200 EmitCheckSourceLocation(ArgLoc),
3201 EmitCheckSourceLocation(NNAttr->getLocation()),
3202 llvm::ConstantInt::get(Int32Ty, ArgNo + 1),
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00003203 };
Nuno Lopes1ba2d782015-05-30 16:11:40 +00003204 EmitCheck(std::make_pair(Cond, SanitizerKind::NonnullAttribute),
Alexey Samsonove396bfc2014-11-11 22:03:54 +00003205 "nonnull_arg", StaticData, None);
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00003206}
3207
David Blaikief05779e2015-07-21 18:37:18 +00003208void CodeGenFunction::EmitCallArgs(
3209 CallArgList &Args, ArrayRef<QualType> ArgTypes,
3210 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
Richard Smith762672a2016-09-28 19:09:10 +00003211 const FunctionDecl *CalleeDecl, unsigned ParamsToSkip,
Richard Smitha560ccf2016-09-29 21:30:12 +00003212 EvaluationOrder Order) {
David Blaikief05779e2015-07-21 18:37:18 +00003213 assert((int)ArgTypes.size() == (ArgRange.end() - ArgRange.begin()));
George Burgess IV3e3bb95b2015-12-02 21:58:08 +00003214
3215 auto MaybeEmitImplicitObjectSize = [&](unsigned I, const Expr *Arg) {
3216 if (CalleeDecl == nullptr || I >= CalleeDecl->getNumParams())
3217 return;
3218 auto *PS = CalleeDecl->getParamDecl(I)->getAttr<PassObjectSizeAttr>();
3219 if (PS == nullptr)
3220 return;
3221
3222 const auto &Context = getContext();
3223 auto SizeTy = Context.getSizeType();
3224 auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
3225 llvm::Value *V = evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(), T);
3226 Args.add(RValue::get(V), SizeTy);
3227 };
3228
Reid Kleckner739756c2013-12-04 19:23:12 +00003229 // We *have* to evaluate arguments from right to left in the MS C++ ABI,
Richard Smitha560ccf2016-09-29 21:30:12 +00003230 // because arguments are destroyed left to right in the callee. As a special
3231 // case, there are certain language constructs that require left-to-right
3232 // evaluation, and in those cases we consider the evaluation order requirement
3233 // to trump the "destruction order is reverse construction order" guarantee.
3234 bool LeftToRight =
3235 CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()
3236 ? Order == EvaluationOrder::ForceLeftToRight
3237 : Order != EvaluationOrder::ForceRightToLeft;
3238
3239 // Insert a stack save if we're going to need any inalloca args.
3240 bool HasInAllocaArgs = false;
3241 if (CGM.getTarget().getCXXABI().isMicrosoft()) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003242 for (ArrayRef<QualType>::iterator I = ArgTypes.begin(), E = ArgTypes.end();
3243 I != E && !HasInAllocaArgs; ++I)
3244 HasInAllocaArgs = isInAllocaArgument(CGM.getCXXABI(), *I);
3245 if (HasInAllocaArgs) {
3246 assert(getTarget().getTriple().getArch() == llvm::Triple::x86);
3247 Args.allocateArgumentMemory(*this);
3248 }
Richard Smitha560ccf2016-09-29 21:30:12 +00003249 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003250
Richard Smitha560ccf2016-09-29 21:30:12 +00003251 // Evaluate each argument in the appropriate order.
3252 size_t CallArgsStart = Args.size();
3253 for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) {
3254 unsigned Idx = LeftToRight ? I : E - I - 1;
3255 CallExpr::const_arg_iterator Arg = ArgRange.begin() + Idx;
3256 if (!LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg);
3257 EmitCallArg(Args, *Arg, ArgTypes[Idx]);
3258 EmitNonNullArgCheck(Args.back().RV, ArgTypes[Idx], (*Arg)->getExprLoc(),
3259 CalleeDecl, ParamsToSkip + Idx);
3260 if (LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg);
3261 }
Reid Kleckner739756c2013-12-04 19:23:12 +00003262
Richard Smitha560ccf2016-09-29 21:30:12 +00003263 if (!LeftToRight) {
Reid Kleckner739756c2013-12-04 19:23:12 +00003264 // Un-reverse the arguments we just evaluated so they match up with the LLVM
3265 // IR function.
3266 std::reverse(Args.begin() + CallArgsStart, Args.end());
Reid Kleckner739756c2013-12-04 19:23:12 +00003267 }
3268}
3269
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003270namespace {
3271
David Blaikie7e70d682015-08-18 22:40:54 +00003272struct DestroyUnpassedArg final : EHScopeStack::Cleanup {
John McCall7f416cc2015-09-08 08:05:57 +00003273 DestroyUnpassedArg(Address Addr, QualType Ty)
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003274 : Addr(Addr), Ty(Ty) {}
3275
John McCall7f416cc2015-09-08 08:05:57 +00003276 Address Addr;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003277 QualType Ty;
3278
Craig Topper4f12f102014-03-12 06:41:41 +00003279 void Emit(CodeGenFunction &CGF, Flags flags) override {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003280 const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor();
3281 assert(!Dtor->isTrivial());
3282 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false,
3283 /*Delegating=*/false, Addr);
3284 }
3285};
3286
David Blaikie38b25912015-02-09 19:13:51 +00003287struct DisableDebugLocationUpdates {
3288 CodeGenFunction &CGF;
3289 bool disabledDebugInfo;
3290 DisableDebugLocationUpdates(CodeGenFunction &CGF, const Expr *E) : CGF(CGF) {
3291 if ((disabledDebugInfo = isa<CXXDefaultArgExpr>(E) && CGF.getDebugInfo()))
3292 CGF.disableDebugInfo();
3293 }
3294 ~DisableDebugLocationUpdates() {
3295 if (disabledDebugInfo)
3296 CGF.enableDebugInfo();
3297 }
3298};
3299
Benjamin Kramer5b4296a2015-10-28 17:16:26 +00003300} // end anonymous namespace
3301
John McCall32ea9692011-03-11 20:59:21 +00003302void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
3303 QualType type) {
David Blaikie38b25912015-02-09 19:13:51 +00003304 DisableDebugLocationUpdates Dis(*this, E);
John McCall31168b02011-06-15 23:02:42 +00003305 if (const ObjCIndirectCopyRestoreExpr *CRE
3306 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
Richard Smith9c6890a2012-11-01 22:30:59 +00003307 assert(getLangOpts().ObjCAutoRefCount);
Vedant Kumar30914f32016-10-03 15:29:22 +00003308 assert(getContext().hasSameUnqualifiedType(E->getType(), type));
John McCall31168b02011-06-15 23:02:42 +00003309 return emitWritebackArg(*this, args, CRE);
3310 }
3311
John McCall0a76c0c2011-08-26 18:42:59 +00003312 assert(type->isReferenceType() == E->isGLValue() &&
3313 "reference binding to unmaterialized r-value!");
3314
John McCall17054bd62011-08-26 21:08:13 +00003315 if (E->isGLValue()) {
3316 assert(E->getObjectKind() == OK_Ordinary);
Richard Smitha1c9d4d2013-06-12 23:38:09 +00003317 return args.add(EmitReferenceBindingToExpr(E), type);
John McCall17054bd62011-08-26 21:08:13 +00003318 }
Mike Stump11289f42009-09-09 15:08:12 +00003319
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003320 bool HasAggregateEvalKind = hasAggregateEvaluationKind(type);
3321
3322 // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee.
3323 // However, we still have to push an EH-only cleanup in case we unwind before
3324 // we make it to the call.
Reid Klecknerac640602014-05-01 03:07:18 +00003325 if (HasAggregateEvalKind &&
3326 CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {
3327 // If we're using inalloca, use the argument memory. Otherwise, use a
Reid Klecknere39ee212014-05-03 00:33:28 +00003328 // temporary.
Reid Klecknerac640602014-05-01 03:07:18 +00003329 AggValueSlot Slot;
3330 if (args.isUsingInAlloca())
3331 Slot = createPlaceholderSlot(*this, type);
3332 else
3333 Slot = CreateAggTemp(type, "agg.tmp");
Reid Klecknere39ee212014-05-03 00:33:28 +00003334
3335 const CXXRecordDecl *RD = type->getAsCXXRecordDecl();
3336 bool DestroyedInCallee =
3337 RD && RD->hasNonTrivialDestructor() &&
3338 CGM.getCXXABI().getRecordArgABI(RD) != CGCXXABI::RAA_Default;
3339 if (DestroyedInCallee)
3340 Slot.setExternallyDestructed();
3341
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003342 EmitAggExpr(E, Slot);
3343 RValue RV = Slot.asRValue();
3344 args.add(RV, type);
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003345
Reid Klecknere39ee212014-05-03 00:33:28 +00003346 if (DestroyedInCallee) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003347 // Create a no-op GEP between the placeholder and the cleanup so we can
3348 // RAUW it successfully. It also serves as a marker of the first
3349 // instruction where the cleanup is active.
John McCall7f416cc2015-09-08 08:05:57 +00003350 pushFullExprCleanup<DestroyUnpassedArg>(EHCleanup, Slot.getAddress(),
3351 type);
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003352 // This unreachable is a temporary marker which will be removed later.
3353 llvm::Instruction *IsActive = Builder.CreateUnreachable();
3354 args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive);
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003355 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003356 return;
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003357 }
3358
3359 if (HasAggregateEvalKind && isa<ImplicitCastExpr>(E) &&
Eli Friedmandf968192011-05-26 00:10:27 +00003360 cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
3361 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
3362 assert(L.isSimple());
Eli Friedman61f615a2013-06-11 01:08:22 +00003363 if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) {
3364 args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true);
3365 } else {
3366 // We can't represent a misaligned lvalue in the CallArgList, so copy
3367 // to an aligned temporary now.
John McCall7f416cc2015-09-08 08:05:57 +00003368 Address tmp = CreateMemTemp(type);
3369 EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile());
Eli Friedman61f615a2013-06-11 01:08:22 +00003370 args.add(RValue::getAggregate(tmp), type);
3371 }
Eli Friedmandf968192011-05-26 00:10:27 +00003372 return;
3373 }
3374
John McCall32ea9692011-03-11 20:59:21 +00003375 args.add(EmitAnyExprToTemp(E), type);
Anders Carlsson60ce3fe2009-04-08 20:47:54 +00003376}
3377
Reid Kleckner79b0fd72014-10-10 00:05:45 +00003378QualType CodeGenFunction::getVarArgType(const Expr *Arg) {
3379 // System headers on Windows define NULL to 0 instead of 0LL on Win64. MSVC
3380 // implicitly widens null pointer constants that are arguments to varargs
3381 // functions to pointer-sized ints.
3382 if (!getTarget().getTriple().isOSWindows())
3383 return Arg->getType();
3384
3385 if (Arg->getType()->isIntegerType() &&
3386 getContext().getTypeSize(Arg->getType()) <
3387 getContext().getTargetInfo().getPointerWidth(0) &&
3388 Arg->isNullPointerConstant(getContext(),
3389 Expr::NPC_ValueDependentIsNotNull)) {
3390 return getContext().getIntPtrType();
3391 }
3392
3393 return Arg->getType();
3394}
3395
Dan Gohman515a60d2012-02-16 00:57:37 +00003396// In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
3397// optimizer it can aggressively ignore unwind edges.
3398void
3399CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
3400 if (CGM.getCodeGenOpts().OptimizationLevel != 0 &&
3401 !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
3402 Inst->setMetadata("clang.arc.no_objc_arc_exceptions",
3403 CGM.getNoObjCARCExceptionsMetadata());
3404}
3405
John McCall882987f2013-02-28 19:01:20 +00003406/// Emits a call to the given no-arguments nounwind runtime function.
3407llvm::CallInst *
3408CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
3409 const llvm::Twine &name) {
Craig Topper5fc8fc22014-08-27 06:28:36 +00003410 return EmitNounwindRuntimeCall(callee, None, name);
John McCall882987f2013-02-28 19:01:20 +00003411}
3412
3413/// Emits a call to the given nounwind runtime function.
3414llvm::CallInst *
3415CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
3416 ArrayRef<llvm::Value*> args,
3417 const llvm::Twine &name) {
3418 llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
3419 call->setDoesNotThrow();
3420 return call;
3421}
3422
3423/// Emits a simple call (never an invoke) to the given no-arguments
3424/// runtime function.
3425llvm::CallInst *
3426CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
3427 const llvm::Twine &name) {
Craig Topper5fc8fc22014-08-27 06:28:36 +00003428 return EmitRuntimeCall(callee, None, name);
John McCall882987f2013-02-28 19:01:20 +00003429}
3430
David Majnemer0b17d442015-12-15 21:27:59 +00003431// Calls which may throw must have operand bundles indicating which funclet
3432// they are nested within.
3433static void
Sanjay Patel846b63b2016-01-18 22:15:33 +00003434getBundlesForFunclet(llvm::Value *Callee, llvm::Instruction *CurrentFuncletPad,
David Majnemer0b17d442015-12-15 21:27:59 +00003435 SmallVectorImpl<llvm::OperandBundleDef> &BundleList) {
Sanjay Patel846b63b2016-01-18 22:15:33 +00003436 // There is no need for a funclet operand bundle if we aren't inside a
3437 // funclet.
David Majnemer0b17d442015-12-15 21:27:59 +00003438 if (!CurrentFuncletPad)
3439 return;
3440
3441 // Skip intrinsics which cannot throw.
3442 auto *CalleeFn = dyn_cast<llvm::Function>(Callee->stripPointerCasts());
3443 if (CalleeFn && CalleeFn->isIntrinsic() && CalleeFn->doesNotThrow())
3444 return;
3445
3446 BundleList.emplace_back("funclet", CurrentFuncletPad);
3447}
3448
David Majnemer971d31b2016-02-24 17:02:45 +00003449/// Emits a simple call (never an invoke) to the given runtime function.
3450llvm::CallInst *
3451CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
3452 ArrayRef<llvm::Value*> args,
3453 const llvm::Twine &name) {
3454 SmallVector<llvm::OperandBundleDef, 1> BundleList;
3455 getBundlesForFunclet(callee, CurrentFuncletPad, BundleList);
3456
3457 llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList, name);
3458 call->setCallingConv(getRuntimeCC());
3459 return call;
3460}
3461
John McCall882987f2013-02-28 19:01:20 +00003462/// Emits a call or invoke to the given noreturn runtime function.
3463void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee,
3464 ArrayRef<llvm::Value*> args) {
David Majnemer0b17d442015-12-15 21:27:59 +00003465 SmallVector<llvm::OperandBundleDef, 1> BundleList;
3466 getBundlesForFunclet(callee, CurrentFuncletPad, BundleList);
3467
John McCall882987f2013-02-28 19:01:20 +00003468 if (getInvokeDest()) {
3469 llvm::InvokeInst *invoke =
3470 Builder.CreateInvoke(callee,
3471 getUnreachableBlock(),
3472 getInvokeDest(),
David Majnemer0b17d442015-12-15 21:27:59 +00003473 args,
3474 BundleList);
John McCall882987f2013-02-28 19:01:20 +00003475 invoke->setDoesNotReturn();
3476 invoke->setCallingConv(getRuntimeCC());
3477 } else {
David Majnemer0b17d442015-12-15 21:27:59 +00003478 llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList);
John McCall882987f2013-02-28 19:01:20 +00003479 call->setDoesNotReturn();
3480 call->setCallingConv(getRuntimeCC());
3481 Builder.CreateUnreachable();
3482 }
3483}
3484
Sanjay Patel846b63b2016-01-18 22:15:33 +00003485/// Emits a call or invoke instruction to the given nullary runtime function.
John McCall882987f2013-02-28 19:01:20 +00003486llvm::CallSite
3487CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
3488 const Twine &name) {
Craig Topper5fc8fc22014-08-27 06:28:36 +00003489 return EmitRuntimeCallOrInvoke(callee, None, name);
John McCall882987f2013-02-28 19:01:20 +00003490}
3491
3492/// Emits a call or invoke instruction to the given runtime function.
3493llvm::CallSite
3494CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
3495 ArrayRef<llvm::Value*> args,
3496 const Twine &name) {
3497 llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name);
3498 callSite.setCallingConv(getRuntimeCC());
3499 return callSite;
3500}
3501
John McCallbd309292010-07-06 01:34:17 +00003502/// Emits a call or invoke instruction to the given function, depending
3503/// on the current state of the EH stack.
3504llvm::CallSite
3505CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner54b16772011-07-23 17:14:25 +00003506 ArrayRef<llvm::Value *> Args,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003507 const Twine &Name) {
John McCallbd309292010-07-06 01:34:17 +00003508 llvm::BasicBlock *InvokeDest = getInvokeDest();
David Majnemer3df77bc2016-01-26 23:14:47 +00003509 SmallVector<llvm::OperandBundleDef, 1> BundleList;
3510 getBundlesForFunclet(Callee, CurrentFuncletPad, BundleList);
John McCallbd309292010-07-06 01:34:17 +00003511
Dan Gohman515a60d2012-02-16 00:57:37 +00003512 llvm::Instruction *Inst;
3513 if (!InvokeDest)
David Majnemer3df77bc2016-01-26 23:14:47 +00003514 Inst = Builder.CreateCall(Callee, Args, BundleList, Name);
Dan Gohman515a60d2012-02-16 00:57:37 +00003515 else {
3516 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
David Majnemer3df77bc2016-01-26 23:14:47 +00003517 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList,
3518 Name);
Dan Gohman515a60d2012-02-16 00:57:37 +00003519 EmitBlock(ContBB);
3520 }
3521
3522 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
3523 // optimizer it can aggressively ignore unwind edges.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003524 if (CGM.getLangOpts().ObjCAutoRefCount)
Dan Gohman515a60d2012-02-16 00:57:37 +00003525 AddObjCARCExceptionMetadata(Inst);
3526
Benjamin Kramerc19cde12015-04-10 14:49:31 +00003527 return llvm::CallSite(Inst);
John McCallbd309292010-07-06 01:34:17 +00003528}
3529
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003530/// \brief Store a non-aggregate value to an address to initialize it. For
3531/// initialization, a non-atomic store will be used.
3532static void EmitInitStoreOfNonAggregate(CodeGenFunction &CGF, RValue Src,
3533 LValue Dst) {
3534 if (Src.isScalar())
3535 CGF.EmitStoreOfScalar(Src.getScalarVal(), Dst, /*init=*/true);
3536 else
3537 CGF.EmitStoreOfComplex(Src.getComplexVal(), Dst, /*init=*/true);
3538}
3539
3540void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old,
3541 llvm::Value *New) {
3542 DeferredReplacements.push_back(std::make_pair(Old, New));
3543}
Chris Lattnerd59d8672011-07-12 06:29:11 +00003544
Daniel Dunbard931a872009-02-02 22:03:45 +00003545RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
John McCallb92ab1a2016-10-26 23:46:34 +00003546 const CGCallee &Callee,
Anders Carlsson61a401c2009-12-24 19:25:24 +00003547 ReturnValueSlot ReturnValue,
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00003548 const CallArgList &CallArgs,
David Chisnallff5f88c2010-05-02 13:41:58 +00003549 llvm::Instruction **callOrInvoke) {
Mike Stump18bb9282009-05-16 07:57:57 +00003550 // FIXME: We no longer need the types from CallArgs; lift up and simplify.
Daniel Dunbar613855c2008-09-09 23:27:19 +00003551
John McCallb92ab1a2016-10-26 23:46:34 +00003552 assert(Callee.isOrdinary());
3553
Daniel Dunbar613855c2008-09-09 23:27:19 +00003554 // Handle struct-return functions by passing a pointer to the
3555 // location that we would like to return into.
Daniel Dunbar7633cbf2009-02-02 21:43:58 +00003556 QualType RetTy = CallInfo.getReturnType();
Daniel Dunbarb52d0772009-02-03 05:59:18 +00003557 const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
Mike Stump11289f42009-09-09 15:08:12 +00003558
John McCallb92ab1a2016-10-26 23:46:34 +00003559 llvm::FunctionType *IRFuncTy = Callee.getFunctionType();
3560
3561 // 1. Set up the arguments.
Mike Stump11289f42009-09-09 15:08:12 +00003562
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003563 // If we're using inalloca, insert the allocation after the stack save.
3564 // FIXME: Do this earlier rather than hacking it in here!
John McCall7f416cc2015-09-08 08:05:57 +00003565 Address ArgMemory = Address::invalid();
3566 const llvm::StructLayout *ArgMemoryLayout = nullptr;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003567 if (llvm::StructType *ArgStruct = CallInfo.getArgStruct()) {
John McCall7f416cc2015-09-08 08:05:57 +00003568 ArgMemoryLayout = CGM.getDataLayout().getStructLayout(ArgStruct);
Reid Kleckner9df1d972014-04-10 01:40:15 +00003569 llvm::Instruction *IP = CallArgs.getStackBase();
3570 llvm::AllocaInst *AI;
3571 if (IP) {
3572 IP = IP->getNextNode();
3573 AI = new llvm::AllocaInst(ArgStruct, "argmem", IP);
3574 } else {
Reid Kleckner966abe72014-05-15 23:01:46 +00003575 AI = CreateTempAlloca(ArgStruct, "argmem");
Reid Kleckner9df1d972014-04-10 01:40:15 +00003576 }
John McCall7f416cc2015-09-08 08:05:57 +00003577 auto Align = CallInfo.getArgStructAlignment();
3578 AI->setAlignment(Align.getQuantity());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003579 AI->setUsedWithInAlloca(true);
3580 assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca());
John McCall7f416cc2015-09-08 08:05:57 +00003581 ArgMemory = Address(AI, Align);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003582 }
3583
John McCall7f416cc2015-09-08 08:05:57 +00003584 // Helper function to drill into the inalloca allocation.
3585 auto createInAllocaStructGEP = [&](unsigned FieldIndex) -> Address {
3586 auto FieldOffset =
3587 CharUnits::fromQuantity(ArgMemoryLayout->getElementOffset(FieldIndex));
3588 return Builder.CreateStructGEP(ArgMemory, FieldIndex, FieldOffset);
3589 };
3590
Alexey Samsonov153004f2014-09-29 22:08:00 +00003591 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003592 SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
3593
Chris Lattner4ca97c32009-06-13 00:26:38 +00003594 // If the call returns a temporary with struct return, create a temporary
Anders Carlsson17490832009-12-24 20:40:36 +00003595 // alloca to hold the result, unless one is given to us.
John McCall7f416cc2015-09-08 08:05:57 +00003596 Address SRetPtr = Address::invalid();
Leny Kholodov6aab1112015-06-08 10:23:49 +00003597 size_t UnusedReturnSize = 0;
John McCallf26e73d2016-03-11 04:30:43 +00003598 if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) {
John McCall7f416cc2015-09-08 08:05:57 +00003599 if (!ReturnValue.isNull()) {
3600 SRetPtr = ReturnValue.getValue();
3601 } else {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003602 SRetPtr = CreateMemTemp(RetTy);
Leny Kholodov6aab1112015-06-08 10:23:49 +00003603 if (HaveInsertPoint() && ReturnValue.isUnused()) {
3604 uint64_t size =
3605 CGM.getDataLayout().getTypeAllocSize(ConvertTypeForMem(RetTy));
John McCall7f416cc2015-09-08 08:05:57 +00003606 if (EmitLifetimeStart(size, SRetPtr.getPointer()))
Leny Kholodov6aab1112015-06-08 10:23:49 +00003607 UnusedReturnSize = size;
3608 }
3609 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003610 if (IRFunctionArgs.hasSRetArg()) {
John McCall7f416cc2015-09-08 08:05:57 +00003611 IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr.getPointer();
John McCallf26e73d2016-03-11 04:30:43 +00003612 } else if (RetAI.isInAlloca()) {
John McCall7f416cc2015-09-08 08:05:57 +00003613 Address Addr = createInAllocaStructGEP(RetAI.getInAllocaFieldIndex());
3614 Builder.CreateStore(SRetPtr.getPointer(), Addr);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003615 }
Anders Carlsson17490832009-12-24 20:40:36 +00003616 }
Mike Stump11289f42009-09-09 15:08:12 +00003617
John McCall12f23522016-04-04 18:33:08 +00003618 Address swiftErrorTemp = Address::invalid();
3619 Address swiftErrorArg = Address::invalid();
3620
John McCallb92ab1a2016-10-26 23:46:34 +00003621 // Translate all of the arguments as necessary to match the IR lowering.
Daniel Dunbara45bdbb2009-02-04 21:17:21 +00003622 assert(CallInfo.arg_size() == CallArgs.size() &&
3623 "Mismatch between function signature & arguments.");
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003624 unsigned ArgNo = 0;
Daniel Dunbarb52d0772009-02-03 05:59:18 +00003625 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
Mike Stump11289f42009-09-09 15:08:12 +00003626 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003627 I != E; ++I, ++info_it, ++ArgNo) {
Daniel Dunbarb52d0772009-02-03 05:59:18 +00003628 const ABIArgInfo &ArgInfo = info_it->info;
Eli Friedmanf4258eb2011-05-02 18:05:27 +00003629 RValue RV = I->RV;
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00003630
Rafael Espindolafad28de2012-10-24 01:59:00 +00003631 // Insert a padding argument to ensure proper alignment.
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003632 if (IRFunctionArgs.hasPaddingArg(ArgNo))
3633 IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
3634 llvm::UndefValue::get(ArgInfo.getPaddingType());
3635
3636 unsigned FirstIRArg, NumIRArgs;
3637 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
Rafael Espindolafad28de2012-10-24 01:59:00 +00003638
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00003639 switch (ArgInfo.getKind()) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003640 case ABIArgInfo::InAlloca: {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003641 assert(NumIRArgs == 0);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003642 assert(getTarget().getTriple().getArch() == llvm::Triple::x86);
3643 if (RV.isAggregate()) {
3644 // Replace the placeholder with the appropriate argument slot GEP.
3645 llvm::Instruction *Placeholder =
John McCall7f416cc2015-09-08 08:05:57 +00003646 cast<llvm::Instruction>(RV.getAggregatePointer());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003647 CGBuilderTy::InsertPoint IP = Builder.saveIP();
3648 Builder.SetInsertPoint(Placeholder);
John McCall7f416cc2015-09-08 08:05:57 +00003649 Address Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003650 Builder.restoreIP(IP);
John McCall7f416cc2015-09-08 08:05:57 +00003651 deferPlaceholderReplacement(Placeholder, Addr.getPointer());
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003652 } else {
3653 // Store the RValue into the argument struct.
John McCall7f416cc2015-09-08 08:05:57 +00003654 Address Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex());
3655 unsigned AS = Addr.getType()->getPointerAddressSpace();
David Majnemer32b57b02014-03-31 16:12:47 +00003656 llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS);
3657 // There are some cases where a trivial bitcast is not avoidable. The
3658 // definition of a type later in a translation unit may change it's type
3659 // from {}* to (%struct.foo*)*.
John McCall7f416cc2015-09-08 08:05:57 +00003660 if (Addr.getType() != MemType)
David Majnemer32b57b02014-03-31 16:12:47 +00003661 Addr = Builder.CreateBitCast(Addr, MemType);
John McCall7f416cc2015-09-08 08:05:57 +00003662 LValue argLV = MakeAddrLValue(Addr, I->Ty);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003663 EmitInitStoreOfNonAggregate(*this, RV, argLV);
3664 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003665 break;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003666 }
3667
Daniel Dunbar03816342010-08-21 02:24:36 +00003668 case ABIArgInfo::Indirect: {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003669 assert(NumIRArgs == 1);
Daniel Dunbar747865a2009-02-05 09:16:39 +00003670 if (RV.isScalar() || RV.isComplex()) {
3671 // Make a temporary alloca to pass the argument.
John McCall7f416cc2015-09-08 08:05:57 +00003672 Address Addr = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign());
3673 IRCallArgs[FirstIRArg] = Addr.getPointer();
John McCall47fb9502013-03-07 21:37:08 +00003674
John McCall7f416cc2015-09-08 08:05:57 +00003675 LValue argLV = MakeAddrLValue(Addr, I->Ty);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003676 EmitInitStoreOfNonAggregate(*this, RV, argLV);
Daniel Dunbar747865a2009-02-05 09:16:39 +00003677 } else {
Eli Friedmaneb7fab62011-06-14 01:37:52 +00003678 // We want to avoid creating an unnecessary temporary+copy here;
Guy Benyei3832bfd2013-03-10 12:59:00 +00003679 // however, we need one in three cases:
Eli Friedmaneb7fab62011-06-14 01:37:52 +00003680 // 1. If the argument is not byval, and we are required to copy the
3681 // source. (This case doesn't occur on any common architecture.)
3682 // 2. If the argument is byval, RV is not sufficiently aligned, and
3683 // we cannot force it to be sufficiently aligned.
Guy Benyei3832bfd2013-03-10 12:59:00 +00003684 // 3. If the argument is byval, but RV is located in an address space
3685 // different than that of the argument (0).
John McCall7f416cc2015-09-08 08:05:57 +00003686 Address Addr = RV.getAggregateAddress();
3687 CharUnits Align = ArgInfo.getIndirectAlign();
Micah Villmowdd31ca12012-10-08 16:25:52 +00003688 const llvm::DataLayout *TD = &CGM.getDataLayout();
John McCall7f416cc2015-09-08 08:05:57 +00003689 const unsigned RVAddrSpace = Addr.getType()->getAddressSpace();
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003690 const unsigned ArgAddrSpace =
3691 (FirstIRArg < IRFuncTy->getNumParams()
3692 ? IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace()
3693 : 0);
Eli Friedmanf7456192011-06-15 22:09:18 +00003694 if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) ||
John McCall7f416cc2015-09-08 08:05:57 +00003695 (ArgInfo.getIndirectByVal() && Addr.getAlignment() < Align &&
3696 llvm::getOrEnforceKnownAlignment(Addr.getPointer(),
3697 Align.getQuantity(), *TD)
3698 < Align.getQuantity()) ||
Mehdi Aminib3d52092015-03-10 02:36:43 +00003699 (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) {
Eli Friedmaneb7fab62011-06-14 01:37:52 +00003700 // Create an aligned temporary, and copy to it.
John McCall7f416cc2015-09-08 08:05:57 +00003701 Address AI = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign());
3702 IRCallArgs[FirstIRArg] = AI.getPointer();
Chad Rosier615ed1a2012-03-29 17:37:10 +00003703 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified());
Eli Friedmaneb7fab62011-06-14 01:37:52 +00003704 } else {
3705 // Skip the extra memcpy call.
John McCall7f416cc2015-09-08 08:05:57 +00003706 IRCallArgs[FirstIRArg] = Addr.getPointer();
Eli Friedmaneb7fab62011-06-14 01:37:52 +00003707 }
Daniel Dunbar747865a2009-02-05 09:16:39 +00003708 }
3709 break;
Daniel Dunbar03816342010-08-21 02:24:36 +00003710 }
Daniel Dunbar747865a2009-02-05 09:16:39 +00003711
Daniel Dunbar94a6f252009-01-26 21:26:08 +00003712 case ABIArgInfo::Ignore:
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003713 assert(NumIRArgs == 0);
Daniel Dunbar94a6f252009-01-26 21:26:08 +00003714 break;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00003715
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00003716 case ABIArgInfo::Extend:
3717 case ABIArgInfo::Direct: {
3718 if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
Chris Lattner8a2f3c72010-07-30 04:02:24 +00003719 ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
3720 ArgInfo.getDirectOffset() == 0) {
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003721 assert(NumIRArgs == 1);
Chris Lattnerbb1952c2011-07-12 04:46:18 +00003722 llvm::Value *V;
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00003723 if (RV.isScalar())
Chris Lattnerbb1952c2011-07-12 04:46:18 +00003724 V = RV.getScalarVal();
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00003725 else
John McCall7f416cc2015-09-08 08:05:57 +00003726 V = Builder.CreateLoad(RV.getAggregateAddress());
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003727
John McCall12f23522016-04-04 18:33:08 +00003728 // Implement swifterror by copying into a new swifterror argument.
3729 // We'll write back in the normal path out of the call.
3730 if (CallInfo.getExtParameterInfo(ArgNo).getABI()
3731 == ParameterABI::SwiftErrorResult) {
3732 assert(!swiftErrorTemp.isValid() && "multiple swifterror args");
3733
3734 QualType pointeeTy = I->Ty->getPointeeType();
3735 swiftErrorArg =
3736 Address(V, getContext().getTypeAlignInChars(pointeeTy));
3737
3738 swiftErrorTemp =
3739 CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");
3740 V = swiftErrorTemp.getPointer();
3741 cast<llvm::AllocaInst>(V)->setSwiftError(true);
3742
3743 llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg);
3744 Builder.CreateStore(errorValue, swiftErrorTemp);
3745 }
3746
Reid Kleckner79b0fd72014-10-10 00:05:45 +00003747 // We might have to widen integers, but we should never truncate.
3748 if (ArgInfo.getCoerceToType() != V->getType() &&
3749 V->getType()->isIntegerTy())
3750 V = Builder.CreateZExt(V, ArgInfo.getCoerceToType());
3751
Chris Lattner3ce86682011-07-12 04:53:39 +00003752 // If the argument doesn't match, perform a bitcast to coerce it. This
3753 // can happen due to trivial type mismatches.
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003754 if (FirstIRArg < IRFuncTy->getNumParams() &&
3755 V->getType() != IRFuncTy->getParamType(FirstIRArg))
3756 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));
John McCall12f23522016-04-04 18:33:08 +00003757
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003758 IRCallArgs[FirstIRArg] = V;
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00003759 break;
3760 }
Daniel Dunbar94a6f252009-01-26 21:26:08 +00003761
Daniel Dunbar2f219b02009-02-03 19:12:28 +00003762 // FIXME: Avoid the conversion through memory if possible.
John McCall7f416cc2015-09-08 08:05:57 +00003763 Address Src = Address::invalid();
John McCall47fb9502013-03-07 21:37:08 +00003764 if (RV.isScalar() || RV.isComplex()) {
John McCall7f416cc2015-09-08 08:05:57 +00003765 Src = CreateMemTemp(I->Ty, "coerce");
3766 LValue SrcLV = MakeAddrLValue(Src, I->Ty);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003767 EmitInitStoreOfNonAggregate(*this, RV, SrcLV);
Ulrich Weigand6e2cea62015-07-10 11:31:43 +00003768 } else {
John McCall7f416cc2015-09-08 08:05:57 +00003769 Src = RV.getAggregateAddress();
Ulrich Weigand6e2cea62015-07-10 11:31:43 +00003770 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00003771
Chris Lattner8a2f3c72010-07-30 04:02:24 +00003772 // If the value is offset in memory, apply the offset now.
John McCall7f416cc2015-09-08 08:05:57 +00003773 Src = emitAddressAtOffset(*this, Src, ArgInfo);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00003774
Oliver Stannard2bfdc5b2014-08-27 10:43:15 +00003775 // Fast-isel and the optimizer generally like scalar values better than
3776 // FCAs, so we flatten them if this is safe to do for this argument.
James Molloy6f244b62014-05-09 16:21:39 +00003777 llvm::StructType *STy =
3778 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType());
Oliver Stannard2bfdc5b2014-08-27 10:43:15 +00003779 if (STy && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
John McCall7f416cc2015-09-08 08:05:57 +00003780 llvm::Type *SrcTy = Src.getType()->getElementType();
Chandler Carrutha6399a52012-10-10 11:29:08 +00003781 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
3782 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
3783
3784 // If the source type is smaller than the destination type of the
3785 // coerce-to logic, copy the source value into a temp alloca the size
3786 // of the destination type to allow loading all of it. The bits past
3787 // the source value are left undef.
3788 if (SrcSize < DstSize) {
John McCall7f416cc2015-09-08 08:05:57 +00003789 Address TempAlloca
3790 = CreateTempAlloca(STy, Src.getAlignment(),
3791 Src.getName() + ".coerce");
3792 Builder.CreateMemCpy(TempAlloca, Src, SrcSize);
3793 Src = TempAlloca;
Chandler Carrutha6399a52012-10-10 11:29:08 +00003794 } else {
John McCall7f416cc2015-09-08 08:05:57 +00003795 Src = Builder.CreateBitCast(Src, llvm::PointerType::getUnqual(STy));
Chandler Carrutha6399a52012-10-10 11:29:08 +00003796 }
3797
John McCall7f416cc2015-09-08 08:05:57 +00003798 auto SrcLayout = CGM.getDataLayout().getStructLayout(STy);
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003799 assert(NumIRArgs == STy->getNumElements());
Chris Lattnerceddafb2010-07-05 20:41:41 +00003800 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
John McCall7f416cc2015-09-08 08:05:57 +00003801 auto Offset = CharUnits::fromQuantity(SrcLayout->getElementOffset(i));
3802 Address EltPtr = Builder.CreateStructGEP(Src, i, Offset);
3803 llvm::Value *LI = Builder.CreateLoad(EltPtr);
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003804 IRCallArgs[FirstIRArg + i] = LI;
Chris Lattner15ec3612010-06-29 00:06:42 +00003805 }
Chris Lattner3dd716c2010-06-28 23:44:11 +00003806 } else {
Chris Lattner15ec3612010-06-29 00:06:42 +00003807 // In the simple case, just pass the coerced loaded value.
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003808 assert(NumIRArgs == 1);
3809 IRCallArgs[FirstIRArg] =
John McCall7f416cc2015-09-08 08:05:57 +00003810 CreateCoercedLoad(Src, ArgInfo.getCoerceToType(), *this);
Chris Lattner3dd716c2010-06-28 23:44:11 +00003811 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00003812
Daniel Dunbar2f219b02009-02-03 19:12:28 +00003813 break;
3814 }
3815
John McCallf26e73d2016-03-11 04:30:43 +00003816 case ABIArgInfo::CoerceAndExpand: {
John McCallf26e73d2016-03-11 04:30:43 +00003817 auto coercionType = ArgInfo.getCoerceAndExpandType();
3818 auto layout = CGM.getDataLayout().getStructLayout(coercionType);
3819
John McCall12f23522016-04-04 18:33:08 +00003820 llvm::Value *tempSize = nullptr;
3821 Address addr = Address::invalid();
3822 if (RV.isAggregate()) {
3823 addr = RV.getAggregateAddress();
3824 } else {
3825 assert(RV.isScalar()); // complex should always just be direct
3826
3827 llvm::Type *scalarType = RV.getScalarVal()->getType();
3828 auto scalarSize = CGM.getDataLayout().getTypeAllocSize(scalarType);
3829 auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType);
3830
3831 tempSize = llvm::ConstantInt::get(CGM.Int64Ty, scalarSize);
3832
3833 // Materialize to a temporary.
3834 addr = CreateTempAlloca(RV.getScalarVal()->getType(),
3835 CharUnits::fromQuantity(std::max(layout->getAlignment(),
3836 scalarAlign)));
3837 EmitLifetimeStart(scalarSize, addr.getPointer());
3838
3839 Builder.CreateStore(RV.getScalarVal(), addr);
3840 }
3841
John McCallf26e73d2016-03-11 04:30:43 +00003842 addr = Builder.CreateElementBitCast(addr, coercionType);
3843
3844 unsigned IRArgPos = FirstIRArg;
3845 for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
3846 llvm::Type *eltType = coercionType->getElementType(i);
3847 if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue;
3848 Address eltAddr = Builder.CreateStructGEP(addr, i, layout);
3849 llvm::Value *elt = Builder.CreateLoad(eltAddr);
3850 IRCallArgs[IRArgPos++] = elt;
3851 }
3852 assert(IRArgPos == FirstIRArg + NumIRArgs);
3853
John McCall12f23522016-04-04 18:33:08 +00003854 if (tempSize) {
3855 EmitLifetimeEnd(tempSize, addr.getPointer());
3856 }
3857
John McCallf26e73d2016-03-11 04:30:43 +00003858 break;
3859 }
3860
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00003861 case ABIArgInfo::Expand:
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003862 unsigned IRArgPos = FirstIRArg;
3863 ExpandTypeToArgs(I->Ty, RV, IRFuncTy, IRCallArgs, IRArgPos);
3864 assert(IRArgPos == FirstIRArg + NumIRArgs);
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00003865 break;
Daniel Dunbar613855c2008-09-09 23:27:19 +00003866 }
3867 }
Mike Stump11289f42009-09-09 15:08:12 +00003868
John McCallb92ab1a2016-10-26 23:46:34 +00003869 llvm::Value *CalleePtr = Callee.getFunctionPointer();
3870
3871 // If we're using inalloca, set up that argument.
John McCall7f416cc2015-09-08 08:05:57 +00003872 if (ArgMemory.isValid()) {
3873 llvm::Value *Arg = ArgMemory.getPointer();
Reid Klecknerafba553e2014-07-08 02:24:27 +00003874 if (CallInfo.isVariadic()) {
3875 // When passing non-POD arguments by value to variadic functions, we will
3876 // end up with a variadic prototype and an inalloca call site. In such
3877 // cases, we can't do any parameter mismatch checks. Give up and bitcast
3878 // the callee.
John McCallb92ab1a2016-10-26 23:46:34 +00003879 unsigned CalleeAS = CalleePtr->getType()->getPointerAddressSpace();
3880 auto FnTy = getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS);
3881 CalleePtr = Builder.CreateBitCast(CalleePtr, FnTy);
Reid Klecknerafba553e2014-07-08 02:24:27 +00003882 } else {
3883 llvm::Type *LastParamTy =
3884 IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1);
3885 if (Arg->getType() != LastParamTy) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003886#ifndef NDEBUG
Reid Klecknerafba553e2014-07-08 02:24:27 +00003887 // Assert that these structs have equivalent element types.
3888 llvm::StructType *FullTy = CallInfo.getArgStruct();
3889 llvm::StructType *DeclaredTy = cast<llvm::StructType>(
3890 cast<llvm::PointerType>(LastParamTy)->getElementType());
3891 assert(DeclaredTy->getNumElements() == FullTy->getNumElements());
3892 for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(),
3893 DE = DeclaredTy->element_end(),
3894 FI = FullTy->element_begin();
3895 DI != DE; ++DI, ++FI)
3896 assert(*DI == *FI);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003897#endif
Reid Klecknerafba553e2014-07-08 02:24:27 +00003898 Arg = Builder.CreateBitCast(Arg, LastParamTy);
3899 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003900 }
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003901 assert(IRFunctionArgs.hasInallocaArg());
3902 IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg;
Reid Kleckner314ef7b2014-02-01 00:04:45 +00003903 }
3904
John McCallb92ab1a2016-10-26 23:46:34 +00003905 // 2. Prepare the function pointer.
3906
3907 // If the callee is a bitcast of a non-variadic function to have a
3908 // variadic function pointer type, check to see if we can remove the
3909 // bitcast. This comes up with unprototyped functions.
3910 //
3911 // This makes the IR nicer, but more importantly it ensures that we
3912 // can inline the function at -O0 if it is marked always_inline.
3913 auto simplifyVariadicCallee = [](llvm::Value *Ptr) -> llvm::Value* {
3914 llvm::FunctionType *CalleeFT =
3915 cast<llvm::FunctionType>(Ptr->getType()->getPointerElementType());
3916 if (!CalleeFT->isVarArg())
3917 return Ptr;
3918
3919 llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Ptr);
3920 if (!CE || CE->getOpcode() != llvm::Instruction::BitCast)
3921 return Ptr;
3922
3923 llvm::Function *OrigFn = dyn_cast<llvm::Function>(CE->getOperand(0));
3924 if (!OrigFn)
3925 return Ptr;
3926
3927 llvm::FunctionType *OrigFT = OrigFn->getFunctionType();
3928
3929 // If the original type is variadic, or if any of the component types
3930 // disagree, we cannot remove the cast.
3931 if (OrigFT->isVarArg() ||
3932 OrigFT->getNumParams() != CalleeFT->getNumParams() ||
3933 OrigFT->getReturnType() != CalleeFT->getReturnType())
3934 return Ptr;
3935
3936 for (unsigned i = 0, e = OrigFT->getNumParams(); i != e; ++i)
3937 if (OrigFT->getParamType(i) != CalleeFT->getParamType(i))
3938 return Ptr;
3939
3940 return OrigFn;
3941 };
3942 CalleePtr = simplifyVariadicCallee(CalleePtr);
3943
3944 // 3. Perform the actual call.
3945
3946 // Deactivate any cleanups that we're supposed to do immediately before
3947 // the call.
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00003948 if (!CallArgs.getCleanupsToDeactivate().empty())
3949 deactivateArgCleanupsBeforeCall(*this, CallArgs);
3950
John McCallb92ab1a2016-10-26 23:46:34 +00003951 // Assert that the arguments we computed match up. The IR verifier
3952 // will catch this, but this is a common enough source of problems
3953 // during IRGen changes that it's way better for debugging to catch
3954 // it ourselves here.
3955#ifndef NDEBUG
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003956 assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg());
3957 for (unsigned i = 0; i < IRCallArgs.size(); ++i) {
3958 // Inalloca argument can have different type.
3959 if (IRFunctionArgs.hasInallocaArg() &&
3960 i == IRFunctionArgs.getInallocaArgNo())
3961 continue;
3962 if (i < IRFuncTy->getNumParams())
3963 assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i));
3964 }
John McCallb92ab1a2016-10-26 23:46:34 +00003965#endif
Alexey Samsonov91cf4552014-08-22 01:06:06 +00003966
John McCallb92ab1a2016-10-26 23:46:34 +00003967 // Compute the calling convention and attributes.
Daniel Dunbar0ef34792009-09-12 00:59:20 +00003968 unsigned CallingConv;
Devang Patel322300d2008-09-25 21:02:23 +00003969 CodeGen::AttributeListType AttributeList;
John McCallb92ab1a2016-10-26 23:46:34 +00003970 CGM.ConstructAttributeList(CalleePtr->getName(), CallInfo,
3971 Callee.getAbstractInfo(),
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00003972 AttributeList, CallingConv,
3973 /*AttrOnCallSite=*/true);
Bill Wendling3087d022012-12-07 23:17:26 +00003974 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
Bill Wendlingf4d64cb2013-02-22 00:13:35 +00003975 AttributeList);
Mike Stump11289f42009-09-09 15:08:12 +00003976
John McCallb92ab1a2016-10-26 23:46:34 +00003977 // Apply some call-site-specific attributes.
3978 // TODO: work this into building the attribute set.
3979
3980 // Apply always_inline to all calls within flatten functions.
3981 // FIXME: should this really take priority over __try, below?
3982 if (CurCodeDecl && CurCodeDecl->hasAttr<FlattenAttr>() &&
3983 !(Callee.getAbstractInfo().getCalleeDecl() &&
3984 Callee.getAbstractInfo().getCalleeDecl()->hasAttr<NoInlineAttr>())) {
3985 Attrs =
3986 Attrs.addAttribute(getLLVMContext(),
3987 llvm::AttributeSet::FunctionIndex,
3988 llvm::Attribute::AlwaysInline);
3989 }
3990
3991 // Disable inlining inside SEH __try blocks.
3992 if (isSEHTryScope()) {
3993 Attrs =
3994 Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex,
3995 llvm::Attribute::NoInline);
3996 }
3997
3998 // Decide whether to use a call or an invoke.
David Majnemer4e52d6f2015-12-12 05:39:21 +00003999 bool CannotThrow;
4000 if (currentFunctionUsesSEHTry()) {
John McCallb92ab1a2016-10-26 23:46:34 +00004001 // SEH cares about asynchronous exceptions, so everything can "throw."
David Majnemer4e52d6f2015-12-12 05:39:21 +00004002 CannotThrow = false;
4003 } else if (isCleanupPadScope() &&
4004 EHPersonality::get(*this).isMSVCXXPersonality()) {
4005 // The MSVC++ personality will implicitly terminate the program if an
John McCallb92ab1a2016-10-26 23:46:34 +00004006 // exception is thrown during a cleanup outside of a try/catch.
4007 // We don't need to model anything in IR to get this behavior.
David Majnemer4e52d6f2015-12-12 05:39:21 +00004008 CannotThrow = true;
4009 } else {
John McCallb92ab1a2016-10-26 23:46:34 +00004010 // Otherwise, nounwind call sites will never throw.
David Majnemer4e52d6f2015-12-12 05:39:21 +00004011 CannotThrow = Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
4012 llvm::Attribute::NoUnwind);
4013 }
4014 llvm::BasicBlock *InvokeDest = CannotThrow ? nullptr : getInvokeDest();
John McCallbd309292010-07-06 01:34:17 +00004015
David Majnemer0b17d442015-12-15 21:27:59 +00004016 SmallVector<llvm::OperandBundleDef, 1> BundleList;
John McCallb92ab1a2016-10-26 23:46:34 +00004017 getBundlesForFunclet(CalleePtr, CurrentFuncletPad, BundleList);
David Majnemer0b17d442015-12-15 21:27:59 +00004018
John McCallb92ab1a2016-10-26 23:46:34 +00004019 // Emit the actual call/invoke instruction.
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004020 llvm::CallSite CS;
John McCallbd309292010-07-06 01:34:17 +00004021 if (!InvokeDest) {
John McCallb92ab1a2016-10-26 23:46:34 +00004022 CS = Builder.CreateCall(CalleePtr, IRCallArgs, BundleList);
Daniel Dunbar12347492009-02-23 17:26:39 +00004023 } else {
4024 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
John McCallb92ab1a2016-10-26 23:46:34 +00004025 CS = Builder.CreateInvoke(CalleePtr, Cont, InvokeDest, IRCallArgs,
David Majnemer0b17d442015-12-15 21:27:59 +00004026 BundleList);
Daniel Dunbar12347492009-02-23 17:26:39 +00004027 EmitBlock(Cont);
Daniel Dunbar5006f4a2009-02-20 18:54:31 +00004028 }
John McCallb92ab1a2016-10-26 23:46:34 +00004029 llvm::Instruction *CI = CS.getInstruction();
Chris Lattnere70a0072010-06-29 16:40:28 +00004030 if (callOrInvoke)
John McCallb92ab1a2016-10-26 23:46:34 +00004031 *callOrInvoke = CI;
Daniel Dunbar5006f4a2009-02-20 18:54:31 +00004032
John McCallb92ab1a2016-10-26 23:46:34 +00004033 // Apply the attributes and calling convention.
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004034 CS.setAttributes(Attrs);
Daniel Dunbar0ef34792009-09-12 00:59:20 +00004035 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004036
John McCallb92ab1a2016-10-26 23:46:34 +00004037 // Apply various metadata.
4038
4039 if (!CI->getType()->isVoidTy())
4040 CI->setName("call");
4041
Adam Nemet1e217bc2016-03-28 22:18:53 +00004042 // Insert instrumentation or attach profile metadata at indirect call sites.
4043 // For more details, see the comment before the definition of
4044 // IPVK_IndirectCallTarget in InstrProfData.inc.
Betul Buyukkurt518276a2016-01-23 22:50:44 +00004045 if (!CS.getCalledFunction())
4046 PGO.valueProfile(Builder, llvm::IPVK_IndirectCallTarget,
John McCallb92ab1a2016-10-26 23:46:34 +00004047 CI, CalleePtr);
Betul Buyukkurt518276a2016-01-23 22:50:44 +00004048
Dan Gohman515a60d2012-02-16 00:57:37 +00004049 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
4050 // optimizer it can aggressively ignore unwind edges.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004051 if (CGM.getLangOpts().ObjCAutoRefCount)
John McCallb92ab1a2016-10-26 23:46:34 +00004052 AddObjCARCExceptionMetadata(CI);
4053
4054 // Suppress tail calls if requested.
4055 if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(CI)) {
4056 const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl();
4057 if (TargetDecl && TargetDecl->hasAttr<NotTailCalledAttr>())
4058 Call->setTailCallKind(llvm::CallInst::TCK_NoTail);
4059 }
4060
4061 // 4. Finish the call.
Dan Gohman515a60d2012-02-16 00:57:37 +00004062
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004063 // If the call doesn't return, finish the basic block and clear the
John McCallb92ab1a2016-10-26 23:46:34 +00004064 // insertion point; this allows the rest of IRGen to discard
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004065 // unreachable code.
4066 if (CS.doesNotReturn()) {
Leny Kholodov6aab1112015-06-08 10:23:49 +00004067 if (UnusedReturnSize)
4068 EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),
John McCall7f416cc2015-09-08 08:05:57 +00004069 SRetPtr.getPointer());
Leny Kholodov6aab1112015-06-08 10:23:49 +00004070
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004071 Builder.CreateUnreachable();
4072 Builder.ClearInsertionPoint();
Mike Stump11289f42009-09-09 15:08:12 +00004073
Mike Stump18bb9282009-05-16 07:57:57 +00004074 // FIXME: For now, emit a dummy basic block because expr emitters in
4075 // generally are not ready to handle emitting expressions at unreachable
4076 // points.
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004077 EnsureInsertPoint();
Mike Stump11289f42009-09-09 15:08:12 +00004078
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004079 // Return a reasonable RValue.
4080 return GetUndefRValue(RetTy);
Mike Stump11289f42009-09-09 15:08:12 +00004081 }
Daniel Dunbarb960b7b2009-03-02 04:32:35 +00004082
John McCall12f23522016-04-04 18:33:08 +00004083 // Perform the swifterror writeback.
4084 if (swiftErrorTemp.isValid()) {
4085 llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp);
4086 Builder.CreateStore(errorResult, swiftErrorArg);
4087 }
4088
John McCallb92ab1a2016-10-26 23:46:34 +00004089 // Emit any call-associated writebacks immediately. Arguably this
4090 // should happen after any return-value munging.
John McCall31168b02011-06-15 23:02:42 +00004091 if (CallArgs.hasWritebacks())
4092 emitWritebacks(*this, CallArgs);
4093
Nico Weber8cdb3f92015-08-25 18:43:32 +00004094 // The stack cleanup for inalloca arguments has to run out of the normal
4095 // lexical order, so deactivate it and run it manually here.
4096 CallArgs.freeArgumentMemory(*this);
4097
John McCallb92ab1a2016-10-26 23:46:34 +00004098 // Extract the return value.
Hal Finkelee90a222014-09-26 05:04:30 +00004099 RValue Ret = [&] {
4100 switch (RetAI.getKind()) {
John McCallf26e73d2016-03-11 04:30:43 +00004101 case ABIArgInfo::CoerceAndExpand: {
4102 auto coercionType = RetAI.getCoerceAndExpandType();
4103 auto layout = CGM.getDataLayout().getStructLayout(coercionType);
4104
4105 Address addr = SRetPtr;
4106 addr = Builder.CreateElementBitCast(addr, coercionType);
4107
John McCall12f23522016-04-04 18:33:08 +00004108 assert(CI->getType() == RetAI.getUnpaddedCoerceAndExpandType());
4109 bool requiresExtract = isa<llvm::StructType>(CI->getType());
4110
John McCallf26e73d2016-03-11 04:30:43 +00004111 unsigned unpaddedIndex = 0;
4112 for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
4113 llvm::Type *eltType = coercionType->getElementType(i);
4114 if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue;
4115 Address eltAddr = Builder.CreateStructGEP(addr, i, layout);
John McCall12f23522016-04-04 18:33:08 +00004116 llvm::Value *elt = CI;
4117 if (requiresExtract)
4118 elt = Builder.CreateExtractValue(elt, unpaddedIndex++);
4119 else
4120 assert(unpaddedIndex == 0);
John McCallf26e73d2016-03-11 04:30:43 +00004121 Builder.CreateStore(elt, eltAddr);
4122 }
John McCall12f23522016-04-04 18:33:08 +00004123 // FALLTHROUGH
4124 }
4125
4126 case ABIArgInfo::InAlloca:
4127 case ABIArgInfo::Indirect: {
4128 RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation());
4129 if (UnusedReturnSize)
4130 EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),
4131 SRetPtr.getPointer());
4132 return ret;
John McCallf26e73d2016-03-11 04:30:43 +00004133 }
4134
Hal Finkelee90a222014-09-26 05:04:30 +00004135 case ABIArgInfo::Ignore:
4136 // If we are ignoring an argument that had a result, make sure to
4137 // construct the appropriate return value for our caller.
4138 return GetUndefRValue(RetTy);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00004139
Hal Finkelee90a222014-09-26 05:04:30 +00004140 case ABIArgInfo::Extend:
4141 case ABIArgInfo::Direct: {
4142 llvm::Type *RetIRTy = ConvertType(RetTy);
4143 if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
4144 switch (getEvaluationKind(RetTy)) {
4145 case TEK_Complex: {
4146 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
4147 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
4148 return RValue::getComplex(std::make_pair(Real, Imag));
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00004149 }
Hal Finkelee90a222014-09-26 05:04:30 +00004150 case TEK_Aggregate: {
John McCall7f416cc2015-09-08 08:05:57 +00004151 Address DestPtr = ReturnValue.getValue();
Hal Finkelee90a222014-09-26 05:04:30 +00004152 bool DestIsVolatile = ReturnValue.isVolatile();
4153
John McCall7f416cc2015-09-08 08:05:57 +00004154 if (!DestPtr.isValid()) {
Hal Finkelee90a222014-09-26 05:04:30 +00004155 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
4156 DestIsVolatile = false;
4157 }
John McCall7f416cc2015-09-08 08:05:57 +00004158 BuildAggStore(*this, CI, DestPtr, DestIsVolatile);
Hal Finkelee90a222014-09-26 05:04:30 +00004159 return RValue::getAggregate(DestPtr);
4160 }
4161 case TEK_Scalar: {
4162 // If the argument doesn't match, perform a bitcast to coerce it. This
4163 // can happen due to trivial type mismatches.
4164 llvm::Value *V = CI;
4165 if (V->getType() != RetIRTy)
4166 V = Builder.CreateBitCast(V, RetIRTy);
4167 return RValue::get(V);
4168 }
4169 }
4170 llvm_unreachable("bad evaluation kind");
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00004171 }
Hal Finkelee90a222014-09-26 05:04:30 +00004172
John McCall7f416cc2015-09-08 08:05:57 +00004173 Address DestPtr = ReturnValue.getValue();
Hal Finkelee90a222014-09-26 05:04:30 +00004174 bool DestIsVolatile = ReturnValue.isVolatile();
4175
John McCall7f416cc2015-09-08 08:05:57 +00004176 if (!DestPtr.isValid()) {
Hal Finkelee90a222014-09-26 05:04:30 +00004177 DestPtr = CreateMemTemp(RetTy, "coerce");
4178 DestIsVolatile = false;
John McCall47fb9502013-03-07 21:37:08 +00004179 }
Hal Finkelee90a222014-09-26 05:04:30 +00004180
4181 // If the value is offset in memory, apply the offset now.
John McCall7f416cc2015-09-08 08:05:57 +00004182 Address StorePtr = emitAddressAtOffset(*this, DestPtr, RetAI);
4183 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
Hal Finkelee90a222014-09-26 05:04:30 +00004184
4185 return convertTempToRValue(DestPtr, RetTy, SourceLocation());
Chris Lattnerfe34c1d2010-07-29 06:26:06 +00004186 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00004187
Hal Finkelee90a222014-09-26 05:04:30 +00004188 case ABIArgInfo::Expand:
4189 llvm_unreachable("Invalid ABI kind for return argument");
Anders Carlsson17490832009-12-24 20:40:36 +00004190 }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00004191
Hal Finkelee90a222014-09-26 05:04:30 +00004192 llvm_unreachable("Unhandled ABIArgInfo::Kind");
4193 } ();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00004194
John McCallb92ab1a2016-10-26 23:46:34 +00004195 // Emit the assume_aligned check on the return value.
4196 const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl();
Hal Finkelee90a222014-09-26 05:04:30 +00004197 if (Ret.isScalar() && TargetDecl) {
4198 if (const auto *AA = TargetDecl->getAttr<AssumeAlignedAttr>()) {
4199 llvm::Value *OffsetValue = nullptr;
4200 if (const auto *Offset = AA->getOffset())
4201 OffsetValue = EmitScalarExpr(Offset);
4202
4203 llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment());
4204 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(Alignment);
4205 EmitAlignmentAssumption(Ret.getScalarVal(), AlignmentCI->getZExtValue(),
4206 OffsetValue);
4207 }
Daniel Dunbar573884e2008-09-10 07:04:09 +00004208 }
Daniel Dunbard3674e62008-09-11 01:48:57 +00004209
Hal Finkelee90a222014-09-26 05:04:30 +00004210 return Ret;
Daniel Dunbar613855c2008-09-09 23:27:19 +00004211}
Daniel Dunbar2d0746f2009-02-10 20:44:09 +00004212
4213/* VarArg handling */
4214
Charles Davisc7d5c942015-09-17 20:55:33 +00004215Address CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr) {
4216 VAListAddr = VE->isMicrosoftABI()
4217 ? EmitMSVAListRef(VE->getSubExpr())
4218 : EmitVAListRef(VE->getSubExpr());
4219 QualType Ty = VE->getType();
4220 if (VE->isMicrosoftABI())
4221 return CGM.getTypes().getABIInfo().EmitMSVAArg(*this, VAListAddr, Ty);
John McCall7f416cc2015-09-08 08:05:57 +00004222 return CGM.getTypes().getABIInfo().EmitVAArg(*this, VAListAddr, Ty);
Daniel Dunbar2d0746f2009-02-10 20:44:09 +00004223}