[codeview] Put !heapallocsite on calls to operator new
[lldb.git] / clang / lib / CodeGen / CGCall.cpp
1 //===--- CGCall.cpp - Encapsulate calling convention details --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // These classes wrap the information about a call or function
10 // definition used to handle ABI compliancy.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CGCall.h"
15 #include "ABIInfo.h"
16 #include "CGBlocks.h"
17 #include "CGCXXABI.h"
18 #include "CGCleanup.h"
19 #include "CGRecordLayout.h"
20 #include "CodeGenFunction.h"
21 #include "CodeGenModule.h"
22 #include "TargetInfo.h"
23 #include "clang/AST/Attr.h"
24 #include "clang/AST/Decl.h"
25 #include "clang/AST/DeclCXX.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/Basic/CodeGenOptions.h"
28 #include "clang/Basic/TargetBuiltins.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/CodeGen/CGFunctionInfo.h"
31 #include "clang/CodeGen/SwiftCallingConv.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/Analysis/ValueTracking.h"
34 #include "llvm/IR/Attributes.h"
35 #include "llvm/IR/CallingConv.h"
36 #include "llvm/IR/DataLayout.h"
37 #include "llvm/IR/InlineAsm.h"
38 #include "llvm/IR/IntrinsicInst.h"
39 #include "llvm/IR/Intrinsics.h"
40 #include "llvm/Transforms/Utils/Local.h"
41 using namespace clang;
42 using namespace CodeGen;
43
44 /***/
45
46 unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
47   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;
51   case CC_X86RegCall: return llvm::CallingConv::X86_RegCall;
52   case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
53   case CC_Win64: return llvm::CallingConv::Win64;
54   case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV;
55   case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
56   case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
57   case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;
58   // TODO: Add support for __pascal to LLVM.
59   case CC_X86Pascal: return llvm::CallingConv::C;
60   // TODO: Add support for __vectorcall to LLVM.
61   case CC_X86VectorCall: return llvm::CallingConv::X86_VectorCall;
62   case CC_AArch64VectorCall: return llvm::CallingConv::AArch64_VectorCall;
63   case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC;
64   case CC_OpenCLKernel: return CGM.getTargetCodeGenInfo().getOpenCLKernelCallingConv();
65   case CC_PreserveMost: return llvm::CallingConv::PreserveMost;
66   case CC_PreserveAll: return llvm::CallingConv::PreserveAll;
67   case CC_Swift: return llvm::CallingConv::Swift;
68   }
69 }
70
71 /// Derives the 'this' type for codegen purposes, i.e. ignoring method CVR
72 /// qualification. Either or both of RD and MD may be null. A null RD indicates
73 /// that there is no meaningful 'this' type, and a null MD can occur when
74 /// calling a method pointer.
75 CanQualType CodeGenTypes::DeriveThisType(const CXXRecordDecl *RD,
76                                          const CXXMethodDecl *MD) {
77   QualType RecTy;
78   if (RD)
79     RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
80   else
81     RecTy = Context.VoidTy;
82
83   if (MD)
84     RecTy = Context.getAddrSpaceQualType(RecTy, MD->getMethodQualifiers().getAddressSpace());
85   return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
86 }
87
88 /// Returns the canonical formal type of the given C++ method.
89 static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
90   return MD->getType()->getCanonicalTypeUnqualified()
91            .getAs<FunctionProtoType>();
92 }
93
94 /// Returns the "extra-canonicalized" return type, which discards
95 /// qualifiers on the return type.  Codegen doesn't care about them,
96 /// and it makes ABI code a little easier to be able to assume that
97 /// all parameter and return types are top-level unqualified.
98 static CanQualType GetReturnType(QualType RetTy) {
99   return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
100 }
101
102 /// Arrange the argument and result information for a value of the given
103 /// unprototyped freestanding function type.
104 const CGFunctionInfo &
105 CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
106   // When translating an unprototyped function type, always use a
107   // variadic type.
108   return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(),
109                                  /*instanceMethod=*/false,
110                                  /*chainCall=*/false, None,
111                                  FTNP->getExtInfo(), {}, RequiredArgs(0));
112 }
113
114 static void addExtParameterInfosForCall(
115          llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &paramInfos,
116                                         const FunctionProtoType *proto,
117                                         unsigned prefixArgs,
118                                         unsigned totalArgs) {
119   assert(proto->hasExtParameterInfos());
120   assert(paramInfos.size() <= prefixArgs);
121   assert(proto->getNumParams() + prefixArgs <= totalArgs);
122
123   paramInfos.reserve(totalArgs);
124
125   // Add default infos for any prefix args that don't already have infos.
126   paramInfos.resize(prefixArgs);
127
128   // Add infos for the prototype.
129   for (const auto &ParamInfo : proto->getExtParameterInfos()) {
130     paramInfos.push_back(ParamInfo);
131     // pass_object_size params have no parameter info.
132     if (ParamInfo.hasPassObjectSize())
133       paramInfos.emplace_back();
134   }
135
136   assert(paramInfos.size() <= totalArgs &&
137          "Did we forget to insert pass_object_size args?");
138   // Add default infos for the variadic and/or suffix arguments.
139   paramInfos.resize(totalArgs);
140 }
141
142 /// Adds the formal parameters in FPT to the given prefix. If any parameter in
143 /// FPT has pass_object_size attrs, then we'll add parameters for those, too.
144 static void appendParameterTypes(const CodeGenTypes &CGT,
145                                  SmallVectorImpl<CanQualType> &prefix,
146               SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &paramInfos,
147                                  CanQual<FunctionProtoType> FPT) {
148   // Fast path: don't touch param info if we don't need to.
149   if (!FPT->hasExtParameterInfos()) {
150     assert(paramInfos.empty() &&
151            "We have paramInfos, but the prototype doesn't?");
152     prefix.append(FPT->param_type_begin(), FPT->param_type_end());
153     return;
154   }
155
156   unsigned PrefixSize = prefix.size();
157   // In the vast majority of cases, we'll have precisely FPT->getNumParams()
158   // parameters; the only thing that can change this is the presence of
159   // pass_object_size. So, we preallocate for the common case.
160   prefix.reserve(prefix.size() + FPT->getNumParams());
161
162   auto ExtInfos = FPT->getExtParameterInfos();
163   assert(ExtInfos.size() == FPT->getNumParams());
164   for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) {
165     prefix.push_back(FPT->getParamType(I));
166     if (ExtInfos[I].hasPassObjectSize())
167       prefix.push_back(CGT.getContext().getSizeType());
168   }
169
170   addExtParameterInfosForCall(paramInfos, FPT.getTypePtr(), PrefixSize,
171                               prefix.size());
172 }
173
174 /// Arrange the LLVM function layout for a value of the given function
175 /// type, on top of any implicit parameters already stored.
176 static const CGFunctionInfo &
177 arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
178                         SmallVectorImpl<CanQualType> &prefix,
179                         CanQual<FunctionProtoType> FTP) {
180   SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
181   RequiredArgs Required = RequiredArgs::forPrototypePlus(FTP, prefix.size());
182   // FIXME: Kill copy.
183   appendParameterTypes(CGT, prefix, paramInfos, FTP);
184   CanQualType resultType = FTP->getReturnType().getUnqualifiedType();
185
186   return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod,
187                                      /*chainCall=*/false, prefix,
188                                      FTP->getExtInfo(), paramInfos,
189                                      Required);
190 }
191
192 /// Arrange the argument and result information for a value of the
193 /// given freestanding function type.
194 const CGFunctionInfo &
195 CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
196   SmallVector<CanQualType, 16> argTypes;
197   return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes,
198                                    FTP);
199 }
200
201 static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) {
202   // Set the appropriate calling convention for the Function.
203   if (D->hasAttr<StdCallAttr>())
204     return CC_X86StdCall;
205
206   if (D->hasAttr<FastCallAttr>())
207     return CC_X86FastCall;
208
209   if (D->hasAttr<RegCallAttr>())
210     return CC_X86RegCall;
211
212   if (D->hasAttr<ThisCallAttr>())
213     return CC_X86ThisCall;
214
215   if (D->hasAttr<VectorCallAttr>())
216     return CC_X86VectorCall;
217
218   if (D->hasAttr<PascalAttr>())
219     return CC_X86Pascal;
220
221   if (PcsAttr *PCS = D->getAttr<PcsAttr>())
222     return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
223
224   if (D->hasAttr<AArch64VectorPcsAttr>())
225     return CC_AArch64VectorCall;
226
227   if (D->hasAttr<IntelOclBiccAttr>())
228     return CC_IntelOclBicc;
229
230   if (D->hasAttr<MSABIAttr>())
231     return IsWindows ? CC_C : CC_Win64;
232
233   if (D->hasAttr<SysVABIAttr>())
234     return IsWindows ? CC_X86_64SysV : CC_C;
235
236   if (D->hasAttr<PreserveMostAttr>())
237     return CC_PreserveMost;
238
239   if (D->hasAttr<PreserveAllAttr>())
240     return CC_PreserveAll;
241
242   return CC_C;
243 }
244
245 /// Arrange the argument and result information for a call to an
246 /// unknown C++ non-static member function of the given abstract type.
247 /// (A null RD means we don't have any meaningful "this" argument type,
248 ///  so fall back to a generic pointer type).
249 /// The member function must be an ordinary function, i.e. not a
250 /// constructor or destructor.
251 const CGFunctionInfo &
252 CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD,
253                                    const FunctionProtoType *FTP,
254                                    const CXXMethodDecl *MD) {
255   SmallVector<CanQualType, 16> argTypes;
256
257   // Add the 'this' pointer.
258   argTypes.push_back(DeriveThisType(RD, MD));
259
260   return ::arrangeLLVMFunctionInfo(
261       *this, true, argTypes,
262       FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>());
263 }
264
265 /// Set calling convention for CUDA/HIP kernel.
266 static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM,
267                                            const FunctionDecl *FD) {
268   if (FD->hasAttr<CUDAGlobalAttr>()) {
269     const FunctionType *FT = FTy->getAs<FunctionType>();
270     CGM.getTargetCodeGenInfo().setCUDAKernelCallingConvention(FT);
271     FTy = FT->getCanonicalTypeUnqualified();
272   }
273 }
274
275 /// Arrange the argument and result information for a declaration or
276 /// definition of the given C++ non-static member function.  The
277 /// member function must be an ordinary function, i.e. not a
278 /// constructor or destructor.
279 const CGFunctionInfo &
280 CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) {
281   assert(!isa<CXXConstructorDecl>(MD) && "wrong method for constructors!");
282   assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!");
283
284   CanQualType FT = GetFormalType(MD).getAs<Type>();
285   setCUDAKernelCallingConvention(FT, CGM, MD);
286   auto prototype = FT.getAs<FunctionProtoType>();
287
288   if (MD->isInstance()) {
289     // The abstract case is perfectly fine.
290     const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD);
291     return arrangeCXXMethodType(ThisType, prototype.getTypePtr(), MD);
292   }
293
294   return arrangeFreeFunctionType(prototype);
295 }
296
297 bool CodeGenTypes::inheritingCtorHasParams(
298     const InheritedConstructor &Inherited, CXXCtorType Type) {
299   // Parameters are unnecessary if we're constructing a base class subobject
300   // and the inherited constructor lives in a virtual base.
301   return Type == Ctor_Complete ||
302          !Inherited.getShadowDecl()->constructsVirtualBase() ||
303          !Target.getCXXABI().hasConstructorVariants();
304 }
305
306 const CGFunctionInfo &
307 CodeGenTypes::arrangeCXXStructorDeclaration(GlobalDecl GD) {
308   auto *MD = cast<CXXMethodDecl>(GD.getDecl());
309
310   SmallVector<CanQualType, 16> argTypes;
311   SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
312   argTypes.push_back(DeriveThisType(MD->getParent(), MD));
313
314   bool PassParams = true;
315
316   if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
317     // A base class inheriting constructor doesn't get forwarded arguments
318     // needed to construct a virtual base (or base class thereof).
319     if (auto Inherited = CD->getInheritedConstructor())
320       PassParams = inheritingCtorHasParams(Inherited, GD.getCtorType());
321   }
322
323   CanQual<FunctionProtoType> FTP = GetFormalType(MD);
324
325   // Add the formal parameters.
326   if (PassParams)
327     appendParameterTypes(*this, argTypes, paramInfos, FTP);
328
329   CGCXXABI::AddedStructorArgCounts AddedArgs =
330       TheCXXABI.buildStructorSignature(GD, argTypes);
331   if (!paramInfos.empty()) {
332     // Note: prefix implies after the first param.
333     if (AddedArgs.Prefix)
334       paramInfos.insert(paramInfos.begin() + 1, AddedArgs.Prefix,
335                         FunctionProtoType::ExtParameterInfo{});
336     if (AddedArgs.Suffix)
337       paramInfos.append(AddedArgs.Suffix,
338                         FunctionProtoType::ExtParameterInfo{});
339   }
340
341   RequiredArgs required =
342       (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size())
343                                       : RequiredArgs::All);
344
345   FunctionType::ExtInfo extInfo = FTP->getExtInfo();
346   CanQualType resultType = TheCXXABI.HasThisReturn(GD)
347                                ? argTypes.front()
348                                : TheCXXABI.hasMostDerivedReturn(GD)
349                                      ? CGM.getContext().VoidPtrTy
350                                      : Context.VoidTy;
351   return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true,
352                                  /*chainCall=*/false, argTypes, extInfo,
353                                  paramInfos, required);
354 }
355
356 static SmallVector<CanQualType, 16>
357 getArgTypesForCall(ASTContext &ctx, const CallArgList &args) {
358   SmallVector<CanQualType, 16> argTypes;
359   for (auto &arg : args)
360     argTypes.push_back(ctx.getCanonicalParamType(arg.Ty));
361   return argTypes;
362 }
363
364 static SmallVector<CanQualType, 16>
365 getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) {
366   SmallVector<CanQualType, 16> argTypes;
367   for (auto &arg : args)
368     argTypes.push_back(ctx.getCanonicalParamType(arg->getType()));
369   return argTypes;
370 }
371
372 static llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16>
373 getExtParameterInfosForCall(const FunctionProtoType *proto,
374                             unsigned prefixArgs, unsigned totalArgs) {
375   llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> result;
376   if (proto->hasExtParameterInfos()) {
377     addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs);
378   }
379   return result;
380 }
381
382 /// Arrange a call to a C++ method, passing the given arguments.
383 ///
384 /// ExtraPrefixArgs is the number of ABI-specific args passed after the `this`
385 /// parameter.
386 /// ExtraSuffixArgs is the number of ABI-specific args passed at the end of
387 /// args.
388 /// PassProtoArgs indicates whether `args` has args for the parameters in the
389 /// given CXXConstructorDecl.
390 const CGFunctionInfo &
391 CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args,
392                                         const CXXConstructorDecl *D,
393                                         CXXCtorType CtorKind,
394                                         unsigned ExtraPrefixArgs,
395                                         unsigned ExtraSuffixArgs,
396                                         bool PassProtoArgs) {
397   // FIXME: Kill copy.
398   SmallVector<CanQualType, 16> ArgTypes;
399   for (const auto &Arg : args)
400     ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
401
402   // +1 for implicit this, which should always be args[0].
403   unsigned TotalPrefixArgs = 1 + ExtraPrefixArgs;
404
405   CanQual<FunctionProtoType> FPT = GetFormalType(D);
406   RequiredArgs Required = PassProtoArgs
407                               ? RequiredArgs::forPrototypePlus(
408                                     FPT, TotalPrefixArgs + ExtraSuffixArgs)
409                               : RequiredArgs::All;
410
411   GlobalDecl GD(D, CtorKind);
412   CanQualType ResultType = TheCXXABI.HasThisReturn(GD)
413                                ? ArgTypes.front()
414                                : TheCXXABI.hasMostDerivedReturn(GD)
415                                      ? CGM.getContext().VoidPtrTy
416                                      : Context.VoidTy;
417
418   FunctionType::ExtInfo Info = FPT->getExtInfo();
419   llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> ParamInfos;
420   // If the prototype args are elided, we should only have ABI-specific args,
421   // which never have param info.
422   if (PassProtoArgs && FPT->hasExtParameterInfos()) {
423     // ABI-specific suffix arguments are treated the same as variadic arguments.
424     addExtParameterInfosForCall(ParamInfos, FPT.getTypePtr(), TotalPrefixArgs,
425                                 ArgTypes.size());
426   }
427   return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true,
428                                  /*chainCall=*/false, ArgTypes, Info,
429                                  ParamInfos, Required);
430 }
431
432 /// Arrange the argument and result information for the declaration or
433 /// definition of the given function.
434 const CGFunctionInfo &
435 CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
436   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
437     if (MD->isInstance())
438       return arrangeCXXMethodDeclaration(MD);
439
440   CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
441
442   assert(isa<FunctionType>(FTy));
443   setCUDAKernelCallingConvention(FTy, CGM, FD);
444
445   // When declaring a function without a prototype, always use a
446   // non-variadic type.
447   if (CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>()) {
448     return arrangeLLVMFunctionInfo(
449         noProto->getReturnType(), /*instanceMethod=*/false,
450         /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All);
451   }
452
453   return arrangeFreeFunctionType(FTy.castAs<FunctionProtoType>());
454 }
455
456 /// Arrange the argument and result information for the declaration or
457 /// definition of an Objective-C method.
458 const CGFunctionInfo &
459 CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) {
460   // It happens that this is the same as a call with no optional
461   // arguments, except also using the formal 'self' type.
462   return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType());
463 }
464
465 /// Arrange the argument and result information for the function type
466 /// through which to perform a send to the given Objective-C method,
467 /// using the given receiver type.  The receiver type is not always
468 /// the 'self' type of the method or even an Objective-C pointer type.
469 /// This is *not* the right method for actually performing such a
470 /// message send, due to the possibility of optional arguments.
471 const CGFunctionInfo &
472 CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
473                                               QualType receiverType) {
474   SmallVector<CanQualType, 16> argTys;
475   SmallVector<FunctionProtoType::ExtParameterInfo, 4> extParamInfos(2);
476   argTys.push_back(Context.getCanonicalParamType(receiverType));
477   argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
478   // FIXME: Kill copy?
479   for (const auto *I : MD->parameters()) {
480     argTys.push_back(Context.getCanonicalParamType(I->getType()));
481     auto extParamInfo = FunctionProtoType::ExtParameterInfo().withIsNoEscape(
482         I->hasAttr<NoEscapeAttr>());
483     extParamInfos.push_back(extParamInfo);
484   }
485
486   FunctionType::ExtInfo einfo;
487   bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows();
488   einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows));
489
490   if (getContext().getLangOpts().ObjCAutoRefCount &&
491       MD->hasAttr<NSReturnsRetainedAttr>())
492     einfo = einfo.withProducesResult(true);
493
494   RequiredArgs required =
495     (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
496
497   return arrangeLLVMFunctionInfo(
498       GetReturnType(MD->getReturnType()), /*instanceMethod=*/false,
499       /*chainCall=*/false, argTys, einfo, extParamInfos, required);
500 }
501
502 const CGFunctionInfo &
503 CodeGenTypes::arrangeUnprototypedObjCMessageSend(QualType returnType,
504                                                  const CallArgList &args) {
505   auto argTypes = getArgTypesForCall(Context, args);
506   FunctionType::ExtInfo einfo;
507
508   return arrangeLLVMFunctionInfo(
509       GetReturnType(returnType), /*instanceMethod=*/false,
510       /*chainCall=*/false, argTypes, einfo, {}, RequiredArgs::All);
511 }
512
513 const CGFunctionInfo &
514 CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
515   // FIXME: Do we need to handle ObjCMethodDecl?
516   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
517
518   if (isa<CXXConstructorDecl>(GD.getDecl()) ||
519       isa<CXXDestructorDecl>(GD.getDecl()))
520     return arrangeCXXStructorDeclaration(GD);
521
522   return arrangeFunctionDeclaration(FD);
523 }
524
525 /// Arrange a thunk that takes 'this' as the first parameter followed by
526 /// varargs.  Return a void pointer, regardless of the actual return type.
527 /// The body of the thunk will end in a musttail call to a function of the
528 /// correct type, and the caller will bitcast the function to the correct
529 /// prototype.
530 const CGFunctionInfo &
531 CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) {
532   assert(MD->isVirtual() && "only methods have thunks");
533   CanQual<FunctionProtoType> FTP = GetFormalType(MD);
534   CanQualType ArgTys[] = {DeriveThisType(MD->getParent(), MD)};
535   return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false,
536                                  /*chainCall=*/false, ArgTys,
537                                  FTP->getExtInfo(), {}, RequiredArgs(1));
538 }
539
540 const CGFunctionInfo &
541 CodeGenTypes::arrangeMSCtorClosure(const CXXConstructorDecl *CD,
542                                    CXXCtorType CT) {
543   assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure);
544
545   CanQual<FunctionProtoType> FTP = GetFormalType(CD);
546   SmallVector<CanQualType, 2> ArgTys;
547   const CXXRecordDecl *RD = CD->getParent();
548   ArgTys.push_back(DeriveThisType(RD, CD));
549   if (CT == Ctor_CopyingClosure)
550     ArgTys.push_back(*FTP->param_type_begin());
551   if (RD->getNumVBases() > 0)
552     ArgTys.push_back(Context.IntTy);
553   CallingConv CC = Context.getDefaultCallingConvention(
554       /*IsVariadic=*/false, /*IsCXXMethod=*/true);
555   return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/true,
556                                  /*chainCall=*/false, ArgTys,
557                                  FunctionType::ExtInfo(CC), {},
558                                  RequiredArgs::All);
559 }
560
561 /// Arrange a call as unto a free function, except possibly with an
562 /// additional number of formal parameters considered required.
563 static const CGFunctionInfo &
564 arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
565                             CodeGenModule &CGM,
566                             const CallArgList &args,
567                             const FunctionType *fnType,
568                             unsigned numExtraRequiredArgs,
569                             bool chainCall) {
570   assert(args.size() >= numExtraRequiredArgs);
571
572   llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
573
574   // In most cases, there are no optional arguments.
575   RequiredArgs required = RequiredArgs::All;
576
577   // If we have a variadic prototype, the required arguments are the
578   // extra prefix plus the arguments in the prototype.
579   if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
580     if (proto->isVariadic())
581       required = RequiredArgs::forPrototypePlus(proto, numExtraRequiredArgs);
582
583     if (proto->hasExtParameterInfos())
584       addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs,
585                                   args.size());
586
587   // If we don't have a prototype at all, but we're supposed to
588   // explicitly use the variadic convention for unprototyped calls,
589   // treat all of the arguments as required but preserve the nominal
590   // possibility of variadics.
591   } else if (CGM.getTargetCodeGenInfo()
592                 .isNoProtoCallVariadic(args,
593                                        cast<FunctionNoProtoType>(fnType))) {
594     required = RequiredArgs(args.size());
595   }
596
597   // FIXME: Kill copy.
598   SmallVector<CanQualType, 16> argTypes;
599   for (const auto &arg : args)
600     argTypes.push_back(CGT.getContext().getCanonicalParamType(arg.Ty));
601   return CGT.arrangeLLVMFunctionInfo(GetReturnType(fnType->getReturnType()),
602                                      /*instanceMethod=*/false, chainCall,
603                                      argTypes, fnType->getExtInfo(), paramInfos,
604                                      required);
605 }
606
607 /// Figure out the rules for calling a function with the given formal
608 /// type using the given arguments.  The arguments are necessary
609 /// because the function might be unprototyped, in which case it's
610 /// target-dependent in crazy ways.
611 const CGFunctionInfo &
612 CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
613                                       const FunctionType *fnType,
614                                       bool chainCall) {
615   return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType,
616                                      chainCall ? 1 : 0, chainCall);
617 }
618
619 /// A block function is essentially a free function with an
620 /// extra implicit argument.
621 const CGFunctionInfo &
622 CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
623                                        const FunctionType *fnType) {
624   return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1,
625                                      /*chainCall=*/false);
626 }
627
628 const CGFunctionInfo &
629 CodeGenTypes::arrangeBlockFunctionDeclaration(const FunctionProtoType *proto,
630                                               const FunctionArgList &params) {
631   auto paramInfos = getExtParameterInfosForCall(proto, 1, params.size());
632   auto argTypes = getArgTypesForDeclaration(Context, params);
633
634   return arrangeLLVMFunctionInfo(GetReturnType(proto->getReturnType()),
635                                  /*instanceMethod*/ false, /*chainCall*/ false,
636                                  argTypes, proto->getExtInfo(), paramInfos,
637                                  RequiredArgs::forPrototypePlus(proto, 1));
638 }
639
640 const CGFunctionInfo &
641 CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType,
642                                          const CallArgList &args) {
643   // FIXME: Kill copy.
644   SmallVector<CanQualType, 16> argTypes;
645   for (const auto &Arg : args)
646     argTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
647   return arrangeLLVMFunctionInfo(
648       GetReturnType(resultType), /*instanceMethod=*/false,
649       /*chainCall=*/false, argTypes, FunctionType::ExtInfo(),
650       /*paramInfos=*/ {}, RequiredArgs::All);
651 }
652
653 const CGFunctionInfo &
654 CodeGenTypes::arrangeBuiltinFunctionDeclaration(QualType resultType,
655                                                 const FunctionArgList &args) {
656   auto argTypes = getArgTypesForDeclaration(Context, args);
657
658   return arrangeLLVMFunctionInfo(
659       GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false,
660       argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
661 }
662
663 const CGFunctionInfo &
664 CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType,
665                                               ArrayRef<CanQualType> argTypes) {
666   return arrangeLLVMFunctionInfo(
667       resultType, /*instanceMethod=*/false, /*chainCall=*/false,
668       argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
669 }
670
671 /// Arrange a call to a C++ method, passing the given arguments.
672 ///
673 /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It
674 /// does not count `this`.
675 const CGFunctionInfo &
676 CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
677                                    const FunctionProtoType *proto,
678                                    RequiredArgs required,
679                                    unsigned numPrefixArgs) {
680   assert(numPrefixArgs + 1 <= args.size() &&
681          "Emitting a call with less args than the required prefix?");
682   // Add one to account for `this`. It's a bit awkward here, but we don't count
683   // `this` in similar places elsewhere.
684   auto paramInfos =
685     getExtParameterInfosForCall(proto, numPrefixArgs + 1, args.size());
686
687   // FIXME: Kill copy.
688   auto argTypes = getArgTypesForCall(Context, args);
689
690   FunctionType::ExtInfo info = proto->getExtInfo();
691   return arrangeLLVMFunctionInfo(
692       GetReturnType(proto->getReturnType()), /*instanceMethod=*/true,
693       /*chainCall=*/false, argTypes, info, paramInfos, required);
694 }
695
696 const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
697   return arrangeLLVMFunctionInfo(
698       getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false,
699       None, FunctionType::ExtInfo(), {}, RequiredArgs::All);
700 }
701
702 const CGFunctionInfo &
703 CodeGenTypes::arrangeCall(const CGFunctionInfo &signature,
704                           const CallArgList &args) {
705   assert(signature.arg_size() <= args.size());
706   if (signature.arg_size() == args.size())
707     return signature;
708
709   SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
710   auto sigParamInfos = signature.getExtParameterInfos();
711   if (!sigParamInfos.empty()) {
712     paramInfos.append(sigParamInfos.begin(), sigParamInfos.end());
713     paramInfos.resize(args.size());
714   }
715
716   auto argTypes = getArgTypesForCall(Context, args);
717
718   assert(signature.getRequiredArgs().allowsOptionalArgs());
719   return arrangeLLVMFunctionInfo(signature.getReturnType(),
720                                  signature.isInstanceMethod(),
721                                  signature.isChainCall(),
722                                  argTypes,
723                                  signature.getExtInfo(),
724                                  paramInfos,
725                                  signature.getRequiredArgs());
726 }
727
728 namespace clang {
729 namespace CodeGen {
730 void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
731 }
732 }
733
734 /// Arrange the argument and result information for an abstract value
735 /// of a given function type.  This is the method which all of the
736 /// above functions ultimately defer to.
737 const CGFunctionInfo &
738 CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
739                                       bool instanceMethod,
740                                       bool chainCall,
741                                       ArrayRef<CanQualType> argTypes,
742                                       FunctionType::ExtInfo info,
743                      ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos,
744                                       RequiredArgs required) {
745   assert(llvm::all_of(argTypes,
746                       [](CanQualType T) { return T.isCanonicalAsParam(); }));
747
748   // Lookup or create unique function info.
749   llvm::FoldingSetNodeID ID;
750   CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos,
751                           required, resultType, argTypes);
752
753   void *insertPos = nullptr;
754   CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
755   if (FI)
756     return *FI;
757
758   unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
759
760   // Construct the function info.  We co-allocate the ArgInfos.
761   FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info,
762                               paramInfos, resultType, argTypes, required);
763   FunctionInfos.InsertNode(FI, insertPos);
764
765   bool inserted = FunctionsBeingProcessed.insert(FI).second;
766   (void)inserted;
767   assert(inserted && "Recursively being processed?");
768
769   // Compute ABI information.
770   if (CC == llvm::CallingConv::SPIR_KERNEL) {
771     // Force target independent argument handling for the host visible
772     // kernel functions.
773     computeSPIRKernelABIInfo(CGM, *FI);
774   } else if (info.getCC() == CC_Swift) {
775     swiftcall::computeABIInfo(CGM, *FI);
776   } else {
777     getABIInfo().computeInfo(*FI);
778   }
779
780   // Loop over all of the computed argument and return value info.  If any of
781   // them are direct or extend without a specified coerce type, specify the
782   // default now.
783   ABIArgInfo &retInfo = FI->getReturnInfo();
784   if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr)
785     retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
786
787   for (auto &I : FI->arguments())
788     if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr)
789       I.info.setCoerceToType(ConvertType(I.type));
790
791   bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
792   assert(erased && "Not in set?");
793
794   return *FI;
795 }
796
797 CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC,
798                                        bool instanceMethod,
799                                        bool chainCall,
800                                        const FunctionType::ExtInfo &info,
801                                        ArrayRef<ExtParameterInfo> paramInfos,
802                                        CanQualType resultType,
803                                        ArrayRef<CanQualType> argTypes,
804                                        RequiredArgs required) {
805   assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
806   assert(!required.allowsOptionalArgs() ||
807          required.getNumRequiredArgs() <= argTypes.size());
808
809   void *buffer =
810     operator new(totalSizeToAlloc<ArgInfo,             ExtParameterInfo>(
811                                   argTypes.size() + 1, paramInfos.size()));
812
813   CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
814   FI->CallingConvention = llvmCC;
815   FI->EffectiveCallingConvention = llvmCC;
816   FI->ASTCallingConvention = info.getCC();
817   FI->InstanceMethod = instanceMethod;
818   FI->ChainCall = chainCall;
819   FI->CmseNSCall = info.getCmseNSCall();
820   FI->NoReturn = info.getNoReturn();
821   FI->ReturnsRetained = info.getProducesResult();
822   FI->NoCallerSavedRegs = info.getNoCallerSavedRegs();
823   FI->NoCfCheck = info.getNoCfCheck();
824   FI->Required = required;
825   FI->HasRegParm = info.getHasRegParm();
826   FI->RegParm = info.getRegParm();
827   FI->ArgStruct = nullptr;
828   FI->ArgStructAlign = 0;
829   FI->NumArgs = argTypes.size();
830   FI->HasExtParameterInfos = !paramInfos.empty();
831   FI->getArgsBuffer()[0].type = resultType;
832   for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
833     FI->getArgsBuffer()[i + 1].type = argTypes[i];
834   for (unsigned i = 0, e = paramInfos.size(); i != e; ++i)
835     FI->getExtParameterInfosBuffer()[i] = paramInfos[i];
836   return FI;
837 }
838
839 /***/
840
841 namespace {
842 // ABIArgInfo::Expand implementation.
843
844 // Specifies the way QualType passed as ABIArgInfo::Expand is expanded.
845 struct TypeExpansion {
846   enum TypeExpansionKind {
847     // Elements of constant arrays are expanded recursively.
848     TEK_ConstantArray,
849     // Record fields are expanded recursively (but if record is a union, only
850     // the field with the largest size is expanded).
851     TEK_Record,
852     // For complex types, real and imaginary parts are expanded recursively.
853     TEK_Complex,
854     // All other types are not expandable.
855     TEK_None
856   };
857
858   const TypeExpansionKind Kind;
859
860   TypeExpansion(TypeExpansionKind K) : Kind(K) {}
861   virtual ~TypeExpansion() {}
862 };
863
864 struct ConstantArrayExpansion : TypeExpansion {
865   QualType EltTy;
866   uint64_t NumElts;
867
868   ConstantArrayExpansion(QualType EltTy, uint64_t NumElts)
869       : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}
870   static bool classof(const TypeExpansion *TE) {
871     return TE->Kind == TEK_ConstantArray;
872   }
873 };
874
875 struct RecordExpansion : TypeExpansion {
876   SmallVector<const CXXBaseSpecifier *, 1> Bases;
877
878   SmallVector<const FieldDecl *, 1> Fields;
879
880   RecordExpansion(SmallVector<const CXXBaseSpecifier *, 1> &&Bases,
881                   SmallVector<const FieldDecl *, 1> &&Fields)
882       : TypeExpansion(TEK_Record), Bases(std::move(Bases)),
883         Fields(std::move(Fields)) {}
884   static bool classof(const TypeExpansion *TE) {
885     return TE->Kind == TEK_Record;
886   }
887 };
888
889 struct ComplexExpansion : TypeExpansion {
890   QualType EltTy;
891
892   ComplexExpansion(QualType EltTy) : TypeExpansion(TEK_Complex), EltTy(EltTy) {}
893   static bool classof(const TypeExpansion *TE) {
894     return TE->Kind == TEK_Complex;
895   }
896 };
897
898 struct NoExpansion : TypeExpansion {
899   NoExpansion() : TypeExpansion(TEK_None) {}
900   static bool classof(const TypeExpansion *TE) {
901     return TE->Kind == TEK_None;
902   }
903 };
904 }  // namespace
905
906 static std::unique_ptr<TypeExpansion>
907 getTypeExpansion(QualType Ty, const ASTContext &Context) {
908   if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
909     return std::make_unique<ConstantArrayExpansion>(
910         AT->getElementType(), AT->getSize().getZExtValue());
911   }
912   if (const RecordType *RT = Ty->getAs<RecordType>()) {
913     SmallVector<const CXXBaseSpecifier *, 1> Bases;
914     SmallVector<const FieldDecl *, 1> Fields;
915     const RecordDecl *RD = RT->getDecl();
916     assert(!RD->hasFlexibleArrayMember() &&
917            "Cannot expand structure with flexible array.");
918     if (RD->isUnion()) {
919       // Unions can be here only in degenerative cases - all the fields are same
920       // after flattening. Thus we have to use the "largest" field.
921       const FieldDecl *LargestFD = nullptr;
922       CharUnits UnionSize = CharUnits::Zero();
923
924       for (const auto *FD : RD->fields()) {
925         if (FD->isZeroLengthBitField(Context))
926           continue;
927         assert(!FD->isBitField() &&
928                "Cannot expand structure with bit-field members.");
929         CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType());
930         if (UnionSize < FieldSize) {
931           UnionSize = FieldSize;
932           LargestFD = FD;
933         }
934       }
935       if (LargestFD)
936         Fields.push_back(LargestFD);
937     } else {
938       if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
939         assert(!CXXRD->isDynamicClass() &&
940                "cannot expand vtable pointers in dynamic classes");
941         for (const CXXBaseSpecifier &BS : CXXRD->bases())
942           Bases.push_back(&BS);
943       }
944
945       for (const auto *FD : RD->fields()) {
946         if (FD->isZeroLengthBitField(Context))
947           continue;
948         assert(!FD->isBitField() &&
949                "Cannot expand structure with bit-field members.");
950         Fields.push_back(FD);
951       }
952     }
953     return std::make_unique<RecordExpansion>(std::move(Bases),
954                                               std::move(Fields));
955   }
956   if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
957     return std::make_unique<ComplexExpansion>(CT->getElementType());
958   }
959   return std::make_unique<NoExpansion>();
960 }
961
962 static int getExpansionSize(QualType Ty, const ASTContext &Context) {
963   auto Exp = getTypeExpansion(Ty, Context);
964   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
965     return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context);
966   }
967   if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
968     int Res = 0;
969     for (auto BS : RExp->Bases)
970       Res += getExpansionSize(BS->getType(), Context);
971     for (auto FD : RExp->Fields)
972       Res += getExpansionSize(FD->getType(), Context);
973     return Res;
974   }
975   if (isa<ComplexExpansion>(Exp.get()))
976     return 2;
977   assert(isa<NoExpansion>(Exp.get()));
978   return 1;
979 }
980
981 void
982 CodeGenTypes::getExpandedTypes(QualType Ty,
983                                SmallVectorImpl<llvm::Type *>::iterator &TI) {
984   auto Exp = getTypeExpansion(Ty, Context);
985   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
986     for (int i = 0, n = CAExp->NumElts; i < n; i++) {
987       getExpandedTypes(CAExp->EltTy, TI);
988     }
989   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
990     for (auto BS : RExp->Bases)
991       getExpandedTypes(BS->getType(), TI);
992     for (auto FD : RExp->Fields)
993       getExpandedTypes(FD->getType(), TI);
994   } else if (auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
995     llvm::Type *EltTy = ConvertType(CExp->EltTy);
996     *TI++ = EltTy;
997     *TI++ = EltTy;
998   } else {
999     assert(isa<NoExpansion>(Exp.get()));
1000     *TI++ = ConvertType(Ty);
1001   }
1002 }
1003
1004 static void forConstantArrayExpansion(CodeGenFunction &CGF,
1005                                       ConstantArrayExpansion *CAE,
1006                                       Address BaseAddr,
1007                                       llvm::function_ref<void(Address)> Fn) {
1008   CharUnits EltSize = CGF.getContext().getTypeSizeInChars(CAE->EltTy);
1009   CharUnits EltAlign =
1010     BaseAddr.getAlignment().alignmentOfArrayElement(EltSize);
1011
1012   for (int i = 0, n = CAE->NumElts; i < n; i++) {
1013     llvm::Value *EltAddr =
1014       CGF.Builder.CreateConstGEP2_32(nullptr, BaseAddr.getPointer(), 0, i);
1015     Fn(Address(EltAddr, EltAlign));
1016   }
1017 }
1018
1019 void CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
1020                                          llvm::Function::arg_iterator &AI) {
1021   assert(LV.isSimple() &&
1022          "Unexpected non-simple lvalue during struct expansion.");
1023
1024   auto Exp = getTypeExpansion(Ty, getContext());
1025   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
1026     forConstantArrayExpansion(
1027         *this, CAExp, LV.getAddress(*this), [&](Address EltAddr) {
1028           LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);
1029           ExpandTypeFromArgs(CAExp->EltTy, LV, AI);
1030         });
1031   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
1032     Address This = LV.getAddress(*this);
1033     for (const CXXBaseSpecifier *BS : RExp->Bases) {
1034       // Perform a single step derived-to-base conversion.
1035       Address Base =
1036           GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
1037                                 /*NullCheckValue=*/false, SourceLocation());
1038       LValue SubLV = MakeAddrLValue(Base, BS->getType());
1039
1040       // Recurse onto bases.
1041       ExpandTypeFromArgs(BS->getType(), SubLV, AI);
1042     }
1043     for (auto FD : RExp->Fields) {
1044       // FIXME: What are the right qualifiers here?
1045       LValue SubLV = EmitLValueForFieldInitialization(LV, FD);
1046       ExpandTypeFromArgs(FD->getType(), SubLV, AI);
1047     }
1048   } else if (isa<ComplexExpansion>(Exp.get())) {
1049     auto realValue = &*AI++;
1050     auto imagValue = &*AI++;
1051     EmitStoreOfComplex(ComplexPairTy(realValue, imagValue), LV, /*init*/ true);
1052   } else {
1053     // Call EmitStoreOfScalar except when the lvalue is a bitfield to emit a
1054     // primitive store.
1055     assert(isa<NoExpansion>(Exp.get()));
1056     if (LV.isBitField())
1057       EmitStoreThroughLValue(RValue::get(&*AI++), LV);
1058     else
1059       EmitStoreOfScalar(&*AI++, LV);
1060   }
1061 }
1062
1063 void CodeGenFunction::ExpandTypeToArgs(
1064     QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
1065     SmallVectorImpl<llvm::Value *> &IRCallArgs, unsigned &IRCallArgPos) {
1066   auto Exp = getTypeExpansion(Ty, getContext());
1067   if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
1068     Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this)
1069                                    : Arg.getKnownRValue().getAggregateAddress();
1070     forConstantArrayExpansion(
1071         *this, CAExp, Addr, [&](Address EltAddr) {
1072           CallArg EltArg = CallArg(
1073               convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation()),
1074               CAExp->EltTy);
1075           ExpandTypeToArgs(CAExp->EltTy, EltArg, IRFuncTy, IRCallArgs,
1076                            IRCallArgPos);
1077         });
1078   } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
1079     Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this)
1080                                    : Arg.getKnownRValue().getAggregateAddress();
1081     for (const CXXBaseSpecifier *BS : RExp->Bases) {
1082       // Perform a single step derived-to-base conversion.
1083       Address Base =
1084           GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
1085                                 /*NullCheckValue=*/false, SourceLocation());
1086       CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType());
1087
1088       // Recurse onto bases.
1089       ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs,
1090                        IRCallArgPos);
1091     }
1092
1093     LValue LV = MakeAddrLValue(This, Ty);
1094     for (auto FD : RExp->Fields) {
1095       CallArg FldArg =
1096           CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType());
1097       ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs,
1098                        IRCallArgPos);
1099     }
1100   } else if (isa<ComplexExpansion>(Exp.get())) {
1101     ComplexPairTy CV = Arg.getKnownRValue().getComplexVal();
1102     IRCallArgs[IRCallArgPos++] = CV.first;
1103     IRCallArgs[IRCallArgPos++] = CV.second;
1104   } else {
1105     assert(isa<NoExpansion>(Exp.get()));
1106     auto RV = Arg.getKnownRValue();
1107     assert(RV.isScalar() &&
1108            "Unexpected non-scalar rvalue during struct expansion.");
1109
1110     // Insert a bitcast as needed.
1111     llvm::Value *V = RV.getScalarVal();
1112     if (IRCallArgPos < IRFuncTy->getNumParams() &&
1113         V->getType() != IRFuncTy->getParamType(IRCallArgPos))
1114       V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
1115
1116     IRCallArgs[IRCallArgPos++] = V;
1117   }
1118 }
1119
1120 /// Create a temporary allocation for the purposes of coercion.
1121 static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty,
1122                                            CharUnits MinAlign) {
1123   // Don't use an alignment that's worse than what LLVM would prefer.
1124   auto PrefAlign = CGF.CGM.getDataLayout().getPrefTypeAlignment(Ty);
1125   CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
1126
1127   return CGF.CreateTempAlloca(Ty, Align);
1128 }
1129
1130 /// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
1131 /// accessing some number of bytes out of it, try to gep into the struct to get
1132 /// at its inner goodness.  Dive as deep as possible without entering an element
1133 /// with an in-memory size smaller than DstSize.
1134 static Address
1135 EnterStructPointerForCoercedAccess(Address SrcPtr,
1136                                    llvm::StructType *SrcSTy,
1137                                    uint64_t DstSize, CodeGenFunction &CGF) {
1138   // We can't dive into a zero-element struct.
1139   if (SrcSTy->getNumElements() == 0) return SrcPtr;
1140
1141   llvm::Type *FirstElt = SrcSTy->getElementType(0);
1142
1143   // If the first elt is at least as large as what we're looking for, or if the
1144   // first element is the same size as the whole struct, we can enter it. The
1145   // comparison must be made on the store size and not the alloca size. Using
1146   // the alloca size may overstate the size of the load.
1147   uint64_t FirstEltSize =
1148     CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt);
1149   if (FirstEltSize < DstSize &&
1150       FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy))
1151     return SrcPtr;
1152
1153   // GEP into the first element.
1154   SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, "coerce.dive");
1155
1156   // If the first element is a struct, recurse.
1157   llvm::Type *SrcTy = SrcPtr.getElementType();
1158   if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
1159     return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
1160
1161   return SrcPtr;
1162 }
1163
1164 /// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
1165 /// are either integers or pointers.  This does a truncation of the value if it
1166 /// is too large or a zero extension if it is too small.
1167 ///
1168 /// This behaves as if the value were coerced through memory, so on big-endian
1169 /// targets the high bits are preserved in a truncation, while little-endian
1170 /// targets preserve the low bits.
1171 static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
1172                                              llvm::Type *Ty,
1173                                              CodeGenFunction &CGF) {
1174   if (Val->getType() == Ty)
1175     return Val;
1176
1177   if (isa<llvm::PointerType>(Val->getType())) {
1178     // If this is Pointer->Pointer avoid conversion to and from int.
1179     if (isa<llvm::PointerType>(Ty))
1180       return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
1181
1182     // Convert the pointer to an integer so we can play with its width.
1183     Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
1184   }
1185
1186   llvm::Type *DestIntTy = Ty;
1187   if (isa<llvm::PointerType>(DestIntTy))
1188     DestIntTy = CGF.IntPtrTy;
1189
1190   if (Val->getType() != DestIntTy) {
1191     const llvm::DataLayout &DL = CGF.CGM.getDataLayout();
1192     if (DL.isBigEndian()) {
1193       // Preserve the high bits on big-endian targets.
1194       // That is what memory coercion does.
1195       uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType());
1196       uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy);
1197
1198       if (SrcSize > DstSize) {
1199         Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits");
1200         Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii");
1201       } else {
1202         Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii");
1203         Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits");
1204       }
1205     } else {
1206       // Little-endian targets preserve the low bits. No shifts required.
1207       Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
1208     }
1209   }
1210
1211   if (isa<llvm::PointerType>(Ty))
1212     Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
1213   return Val;
1214 }
1215
1216
1217
1218 /// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
1219 /// a pointer to an object of type \arg Ty, known to be aligned to
1220 /// \arg SrcAlign bytes.
1221 ///
1222 /// This safely handles the case when the src type is smaller than the
1223 /// destination type; in this situation the values of bits which not
1224 /// present in the src are undefined.
1225 static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty,
1226                                       CodeGenFunction &CGF) {
1227   llvm::Type *SrcTy = Src.getElementType();
1228
1229   // If SrcTy and Ty are the same, just do a load.
1230   if (SrcTy == Ty)
1231     return CGF.Builder.CreateLoad(Src);
1232
1233   uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
1234
1235   if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
1236     Src = EnterStructPointerForCoercedAccess(Src, SrcSTy, DstSize, CGF);
1237     SrcTy = Src.getElementType();
1238   }
1239
1240   uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
1241
1242   // If the source and destination are integer or pointer types, just do an
1243   // extension or truncation to the desired type.
1244   if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
1245       (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
1246     llvm::Value *Load = CGF.Builder.CreateLoad(Src);
1247     return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
1248   }
1249
1250   // If load is legal, just bitcast the src pointer.
1251   if (SrcSize >= DstSize) {
1252     // Generally SrcSize is never greater than DstSize, since this means we are
1253     // losing bits. However, this can happen in cases where the structure has
1254     // additional padding, for example due to a user specified alignment.
1255     //
1256     // FIXME: Assert that we aren't truncating non-padding bits when have access
1257     // to that information.
1258     Src = CGF.Builder.CreateBitCast(Src,
1259                                     Ty->getPointerTo(Src.getAddressSpace()));
1260     return CGF.Builder.CreateLoad(Src);
1261   }
1262
1263   // Otherwise do coercion through memory. This is stupid, but simple.
1264   Address Tmp = CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment());
1265   CGF.Builder.CreateMemCpy(Tmp.getPointer(), Tmp.getAlignment().getAsAlign(),
1266                            Src.getPointer(), Src.getAlignment().getAsAlign(),
1267                            llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize));
1268   return CGF.Builder.CreateLoad(Tmp);
1269 }
1270
1271 // Function to store a first-class aggregate into memory.  We prefer to
1272 // store the elements rather than the aggregate to be more friendly to
1273 // fast-isel.
1274 // FIXME: Do we need to recurse here?
1275 static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
1276                           Address Dest, bool DestIsVolatile) {
1277   // Prefer scalar stores to first-class aggregate stores.
1278   if (llvm::StructType *STy =
1279         dyn_cast<llvm::StructType>(Val->getType())) {
1280     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1281       Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i);
1282       llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
1283       CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile);
1284     }
1285   } else {
1286     CGF.Builder.CreateStore(Val, Dest, DestIsVolatile);
1287   }
1288 }
1289
1290 /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
1291 /// where the source and destination may have different types.  The
1292 /// destination is known to be aligned to \arg DstAlign bytes.
1293 ///
1294 /// This safely handles the case when the src type is larger than the
1295 /// destination type; the upper bits of the src will be lost.
1296 static void CreateCoercedStore(llvm::Value *Src,
1297                                Address Dst,
1298                                bool DstIsVolatile,
1299                                CodeGenFunction &CGF) {
1300   llvm::Type *SrcTy = Src->getType();
1301   llvm::Type *DstTy = Dst.getElementType();
1302   if (SrcTy == DstTy) {
1303     CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
1304     return;
1305   }
1306
1307   uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
1308
1309   if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
1310     Dst = EnterStructPointerForCoercedAccess(Dst, DstSTy, SrcSize, CGF);
1311     DstTy = Dst.getElementType();
1312   }
1313
1314   llvm::PointerType *SrcPtrTy = llvm::dyn_cast<llvm::PointerType>(SrcTy);
1315   llvm::PointerType *DstPtrTy = llvm::dyn_cast<llvm::PointerType>(DstTy);
1316   if (SrcPtrTy && DstPtrTy &&
1317       SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace()) {
1318     Src = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy);
1319     CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
1320     return;
1321   }
1322
1323   // If the source and destination are integer or pointer types, just do an
1324   // extension or truncation to the desired type.
1325   if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
1326       (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
1327     Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF);
1328     CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
1329     return;
1330   }
1331
1332   uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
1333
1334   // If store is legal, just bitcast the src pointer.
1335   if (SrcSize <= DstSize) {
1336     Dst = CGF.Builder.CreateElementBitCast(Dst, SrcTy);
1337     BuildAggStore(CGF, Src, Dst, DstIsVolatile);
1338   } else {
1339     // Otherwise do coercion through memory. This is stupid, but
1340     // simple.
1341
1342     // Generally SrcSize is never greater than DstSize, since this means we are
1343     // losing bits. However, this can happen in cases where the structure has
1344     // additional padding, for example due to a user specified alignment.
1345     //
1346     // FIXME: Assert that we aren't truncating non-padding bits when have access
1347     // to that information.
1348     Address Tmp = CreateTempAllocaForCoercion(CGF, SrcTy, Dst.getAlignment());
1349     CGF.Builder.CreateStore(Src, Tmp);
1350     CGF.Builder.CreateMemCpy(Dst.getPointer(), Dst.getAlignment().getAsAlign(),
1351                              Tmp.getPointer(), Tmp.getAlignment().getAsAlign(),
1352                              llvm::ConstantInt::get(CGF.IntPtrTy, DstSize));
1353   }
1354 }
1355
1356 static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr,
1357                                    const ABIArgInfo &info) {
1358   if (unsigned offset = info.getDirectOffset()) {
1359     addr = CGF.Builder.CreateElementBitCast(addr, CGF.Int8Ty);
1360     addr = CGF.Builder.CreateConstInBoundsByteGEP(addr,
1361                                              CharUnits::fromQuantity(offset));
1362     addr = CGF.Builder.CreateElementBitCast(addr, info.getCoerceToType());
1363   }
1364   return addr;
1365 }
1366
1367 namespace {
1368
1369 /// Encapsulates information about the way function arguments from
1370 /// CGFunctionInfo should be passed to actual LLVM IR function.
1371 class ClangToLLVMArgMapping {
1372   static const unsigned InvalidIndex = ~0U;
1373   unsigned InallocaArgNo;
1374   unsigned SRetArgNo;
1375   unsigned TotalIRArgs;
1376
1377   /// Arguments of LLVM IR function corresponding to single Clang argument.
1378   struct IRArgs {
1379     unsigned PaddingArgIndex;
1380     // Argument is expanded to IR arguments at positions
1381     // [FirstArgIndex, FirstArgIndex + NumberOfArgs).
1382     unsigned FirstArgIndex;
1383     unsigned NumberOfArgs;
1384
1385     IRArgs()
1386         : PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex),
1387           NumberOfArgs(0) {}
1388   };
1389
1390   SmallVector<IRArgs, 8> ArgInfo;
1391
1392 public:
1393   ClangToLLVMArgMapping(const ASTContext &Context, const CGFunctionInfo &FI,
1394                         bool OnlyRequiredArgs = false)
1395       : InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0),
1396         ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) {
1397     construct(Context, FI, OnlyRequiredArgs);
1398   }
1399
1400   bool hasInallocaArg() const { return InallocaArgNo != InvalidIndex; }
1401   unsigned getInallocaArgNo() const {
1402     assert(hasInallocaArg());
1403     return InallocaArgNo;
1404   }
1405
1406   bool hasSRetArg() const { return SRetArgNo != InvalidIndex; }
1407   unsigned getSRetArgNo() const {
1408     assert(hasSRetArg());
1409     return SRetArgNo;
1410   }
1411
1412   unsigned totalIRArgs() const { return TotalIRArgs; }
1413
1414   bool hasPaddingArg(unsigned ArgNo) const {
1415     assert(ArgNo < ArgInfo.size());
1416     return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;
1417   }
1418   unsigned getPaddingArgNo(unsigned ArgNo) const {
1419     assert(hasPaddingArg(ArgNo));
1420     return ArgInfo[ArgNo].PaddingArgIndex;
1421   }
1422
1423   /// Returns index of first IR argument corresponding to ArgNo, and their
1424   /// quantity.
1425   std::pair<unsigned, unsigned> getIRArgs(unsigned ArgNo) const {
1426     assert(ArgNo < ArgInfo.size());
1427     return std::make_pair(ArgInfo[ArgNo].FirstArgIndex,
1428                           ArgInfo[ArgNo].NumberOfArgs);
1429   }
1430
1431 private:
1432   void construct(const ASTContext &Context, const CGFunctionInfo &FI,
1433                  bool OnlyRequiredArgs);
1434 };
1435
1436 void ClangToLLVMArgMapping::construct(const ASTContext &Context,
1437                                       const CGFunctionInfo &FI,
1438                                       bool OnlyRequiredArgs) {
1439   unsigned IRArgNo = 0;
1440   bool SwapThisWithSRet = false;
1441   const ABIArgInfo &RetAI = FI.getReturnInfo();
1442
1443   if (RetAI.getKind() == ABIArgInfo::Indirect) {
1444     SwapThisWithSRet = RetAI.isSRetAfterThis();
1445     SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++;
1446   }
1447
1448   unsigned ArgNo = 0;
1449   unsigned NumArgs = OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size();
1450   for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(); ArgNo < NumArgs;
1451        ++I, ++ArgNo) {
1452     assert(I != FI.arg_end());
1453     QualType ArgType = I->type;
1454     const ABIArgInfo &AI = I->info;
1455     // Collect data about IR arguments corresponding to Clang argument ArgNo.
1456     auto &IRArgs = ArgInfo[ArgNo];
1457
1458     if (AI.getPaddingType())
1459       IRArgs.PaddingArgIndex = IRArgNo++;
1460
1461     switch (AI.getKind()) {
1462     case ABIArgInfo::Extend:
1463     case ABIArgInfo::Direct: {
1464       // FIXME: handle sseregparm someday...
1465       llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.getCoerceToType());
1466       if (AI.isDirect() && AI.getCanBeFlattened() && STy) {
1467         IRArgs.NumberOfArgs = STy->getNumElements();
1468       } else {
1469         IRArgs.NumberOfArgs = 1;
1470       }
1471       break;
1472     }
1473     case ABIArgInfo::Indirect:
1474       IRArgs.NumberOfArgs = 1;
1475       break;
1476     case ABIArgInfo::Ignore:
1477     case ABIArgInfo::InAlloca:
1478       // ignore and inalloca doesn't have matching LLVM parameters.
1479       IRArgs.NumberOfArgs = 0;
1480       break;
1481     case ABIArgInfo::CoerceAndExpand:
1482       IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size();
1483       break;
1484     case ABIArgInfo::Expand:
1485       IRArgs.NumberOfArgs = getExpansionSize(ArgType, Context);
1486       break;
1487     }
1488
1489     if (IRArgs.NumberOfArgs > 0) {
1490       IRArgs.FirstArgIndex = IRArgNo;
1491       IRArgNo += IRArgs.NumberOfArgs;
1492     }
1493
1494     // Skip over the sret parameter when it comes second.  We already handled it
1495     // above.
1496     if (IRArgNo == 1 && SwapThisWithSRet)
1497       IRArgNo++;
1498   }
1499   assert(ArgNo == ArgInfo.size());
1500
1501   if (FI.usesInAlloca())
1502     InallocaArgNo = IRArgNo++;
1503
1504   TotalIRArgs = IRArgNo;
1505 }
1506 }  // namespace
1507
1508 /***/
1509
1510 bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
1511   const auto &RI = FI.getReturnInfo();
1512   return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet());
1513 }
1514
1515 bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) {
1516   return ReturnTypeUsesSRet(FI) &&
1517          getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs();
1518 }
1519
1520 bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
1521   if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
1522     switch (BT->getKind()) {
1523     default:
1524       return false;
1525     case BuiltinType::Float:
1526       return getTarget().useObjCFPRetForRealType(TargetInfo::Float);
1527     case BuiltinType::Double:
1528       return getTarget().useObjCFPRetForRealType(TargetInfo::Double);
1529     case BuiltinType::LongDouble:
1530       return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble);
1531     }
1532   }
1533
1534   return false;
1535 }
1536
1537 bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) {
1538   if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
1539     if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
1540       if (BT->getKind() == BuiltinType::LongDouble)
1541         return getTarget().useObjCFP2RetForComplexLongDouble();
1542     }
1543   }
1544
1545   return false;
1546 }
1547
1548 llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
1549   const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
1550   return GetFunctionType(FI);
1551 }
1552
1553 llvm::FunctionType *
1554 CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
1555
1556   bool Inserted = FunctionsBeingProcessed.insert(&FI).second;
1557   (void)Inserted;
1558   assert(Inserted && "Recursively being processed?");
1559
1560   llvm::Type *resultType = nullptr;
1561   const ABIArgInfo &retAI = FI.getReturnInfo();
1562   switch (retAI.getKind()) {
1563   case ABIArgInfo::Expand:
1564     llvm_unreachable("Invalid ABI kind for return argument");
1565
1566   case ABIArgInfo::Extend:
1567   case ABIArgInfo::Direct:
1568     resultType = retAI.getCoerceToType();
1569     break;
1570
1571   case ABIArgInfo::InAlloca:
1572     if (retAI.getInAllocaSRet()) {
1573       // sret things on win32 aren't void, they return the sret pointer.
1574       QualType ret = FI.getReturnType();
1575       llvm::Type *ty = ConvertType(ret);
1576       unsigned addressSpace = Context.getTargetAddressSpace(ret);
1577       resultType = llvm::PointerType::get(ty, addressSpace);
1578     } else {
1579       resultType = llvm::Type::getVoidTy(getLLVMContext());
1580     }
1581     break;
1582
1583   case ABIArgInfo::Indirect:
1584   case ABIArgInfo::Ignore:
1585     resultType = llvm::Type::getVoidTy(getLLVMContext());
1586     break;
1587
1588   case ABIArgInfo::CoerceAndExpand:
1589     resultType = retAI.getUnpaddedCoerceAndExpandType();
1590     break;
1591   }
1592
1593   ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true);
1594   SmallVector<llvm::Type*, 8> ArgTypes(IRFunctionArgs.totalIRArgs());
1595
1596   // Add type for sret argument.
1597   if (IRFunctionArgs.hasSRetArg()) {
1598     QualType Ret = FI.getReturnType();
1599     llvm::Type *Ty = ConvertType(Ret);
1600     unsigned AddressSpace = Context.getTargetAddressSpace(Ret);
1601     ArgTypes[IRFunctionArgs.getSRetArgNo()] =
1602         llvm::PointerType::get(Ty, AddressSpace);
1603   }
1604
1605   // Add type for inalloca argument.
1606   if (IRFunctionArgs.hasInallocaArg()) {
1607     auto ArgStruct = FI.getArgStruct();
1608     assert(ArgStruct);
1609     ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo();
1610   }
1611
1612   // Add in all of the required arguments.
1613   unsigned ArgNo = 0;
1614   CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
1615                                      ie = it + FI.getNumRequiredArgs();
1616   for (; it != ie; ++it, ++ArgNo) {
1617     const ABIArgInfo &ArgInfo = it->info;
1618
1619     // Insert a padding type to ensure proper alignment.
1620     if (IRFunctionArgs.hasPaddingArg(ArgNo))
1621       ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
1622           ArgInfo.getPaddingType();
1623
1624     unsigned FirstIRArg, NumIRArgs;
1625     std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1626
1627     switch (ArgInfo.getKind()) {
1628     case ABIArgInfo::Ignore:
1629     case ABIArgInfo::InAlloca:
1630       assert(NumIRArgs == 0);
1631       break;
1632
1633     case ABIArgInfo::Indirect: {
1634       assert(NumIRArgs == 1);
1635       // indirect arguments are always on the stack, which is alloca addr space.
1636       llvm::Type *LTy = ConvertTypeForMem(it->type);
1637       ArgTypes[FirstIRArg] = LTy->getPointerTo(
1638           CGM.getDataLayout().getAllocaAddrSpace());
1639       break;
1640     }
1641
1642     case ABIArgInfo::Extend:
1643     case ABIArgInfo::Direct: {
1644       // Fast-isel and the optimizer generally like scalar values better than
1645       // FCAs, so we flatten them if this is safe to do for this argument.
1646       llvm::Type *argType = ArgInfo.getCoerceToType();
1647       llvm::StructType *st = dyn_cast<llvm::StructType>(argType);
1648       if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
1649         assert(NumIRArgs == st->getNumElements());
1650         for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
1651           ArgTypes[FirstIRArg + i] = st->getElementType(i);
1652       } else {
1653         assert(NumIRArgs == 1);
1654         ArgTypes[FirstIRArg] = argType;
1655       }
1656       break;
1657     }
1658
1659     case ABIArgInfo::CoerceAndExpand: {
1660       auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1661       for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) {
1662         *ArgTypesIter++ = EltTy;
1663       }
1664       assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1665       break;
1666     }
1667
1668     case ABIArgInfo::Expand:
1669       auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1670       getExpandedTypes(it->type, ArgTypesIter);
1671       assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1672       break;
1673     }
1674   }
1675
1676   bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
1677   assert(Erased && "Not in set?");
1678
1679   return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic());
1680 }
1681
1682 llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
1683   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1684   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1685
1686   if (!isFuncTypeConvertible(FPT))
1687     return llvm::StructType::get(getLLVMContext());
1688
1689   return GetFunctionType(GD);
1690 }
1691
1692 static void AddAttributesFromFunctionProtoType(ASTContext &Ctx,
1693                                                llvm::AttrBuilder &FuncAttrs,
1694                                                const FunctionProtoType *FPT) {
1695   if (!FPT)
1696     return;
1697
1698   if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
1699       FPT->isNothrow())
1700     FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1701 }
1702
1703 void CodeGenModule::getDefaultFunctionAttributes(StringRef Name,
1704                                                  bool HasOptnone,
1705                                                  bool AttrOnCallSite,
1706                                                llvm::AttrBuilder &FuncAttrs) {
1707   // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed.
1708   if (!HasOptnone) {
1709     if (CodeGenOpts.OptimizeSize)
1710       FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
1711     if (CodeGenOpts.OptimizeSize == 2)
1712       FuncAttrs.addAttribute(llvm::Attribute::MinSize);
1713   }
1714
1715   if (CodeGenOpts.DisableRedZone)
1716     FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
1717   if (CodeGenOpts.IndirectTlsSegRefs)
1718     FuncAttrs.addAttribute("indirect-tls-seg-refs");
1719   if (CodeGenOpts.NoImplicitFloat)
1720     FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
1721
1722   if (AttrOnCallSite) {
1723     // Attributes that should go on the call site only.
1724     if (!CodeGenOpts.SimplifyLibCalls ||
1725         CodeGenOpts.isNoBuiltinFunc(Name.data()))
1726       FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
1727     if (!CodeGenOpts.TrapFuncName.empty())
1728       FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName);
1729   } else {
1730     StringRef FpKind;
1731     switch (CodeGenOpts.getFramePointer()) {
1732     case CodeGenOptions::FramePointerKind::None:
1733       FpKind = "none";
1734       break;
1735     case CodeGenOptions::FramePointerKind::NonLeaf:
1736       FpKind = "non-leaf";
1737       break;
1738     case CodeGenOptions::FramePointerKind::All:
1739       FpKind = "all";
1740       break;
1741     }
1742     FuncAttrs.addAttribute("frame-pointer", FpKind);
1743
1744     FuncAttrs.addAttribute("less-precise-fpmad",
1745                            llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
1746
1747     if (CodeGenOpts.NullPointerIsValid)
1748       FuncAttrs.addAttribute(llvm::Attribute::NullPointerIsValid);
1749
1750     if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE())
1751       FuncAttrs.addAttribute("denormal-fp-math",
1752                              CodeGenOpts.FPDenormalMode.str());
1753     if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) {
1754       FuncAttrs.addAttribute(
1755           "denormal-fp-math-f32",
1756           CodeGenOpts.FP32DenormalMode.str());
1757     }
1758
1759     FuncAttrs.addAttribute("no-trapping-math",
1760                            llvm::toStringRef(LangOpts.getFPExceptionMode() ==
1761                                              LangOptions::FPE_Ignore));
1762
1763     // Strict (compliant) code is the default, so only add this attribute to
1764     // indicate that we are trying to workaround a problem case.
1765     if (!CodeGenOpts.StrictFloatCastOverflow)
1766       FuncAttrs.addAttribute("strict-float-cast-overflow", "false");
1767
1768     // TODO: Are these all needed?
1769     // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
1770     FuncAttrs.addAttribute("no-infs-fp-math",
1771                            llvm::toStringRef(LangOpts.NoHonorInfs));
1772     FuncAttrs.addAttribute("no-nans-fp-math",
1773                            llvm::toStringRef(LangOpts.NoHonorNaNs));
1774     FuncAttrs.addAttribute("unsafe-fp-math",
1775                            llvm::toStringRef(LangOpts.UnsafeFPMath));
1776     FuncAttrs.addAttribute("use-soft-float",
1777                            llvm::toStringRef(CodeGenOpts.SoftFloat));
1778     FuncAttrs.addAttribute("stack-protector-buffer-size",
1779                            llvm::utostr(CodeGenOpts.SSPBufferSize));
1780     FuncAttrs.addAttribute("no-signed-zeros-fp-math",
1781                            llvm::toStringRef(LangOpts.NoSignedZero));
1782     FuncAttrs.addAttribute(
1783         "correctly-rounded-divide-sqrt-fp-math",
1784         llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt));
1785
1786     // TODO: Reciprocal estimate codegen options should apply to instructions?
1787     const std::vector<std::string> &Recips = CodeGenOpts.Reciprocals;
1788     if (!Recips.empty())
1789       FuncAttrs.addAttribute("reciprocal-estimates",
1790                              llvm::join(Recips, ","));
1791
1792     if (!CodeGenOpts.PreferVectorWidth.empty() &&
1793         CodeGenOpts.PreferVectorWidth != "none")
1794       FuncAttrs.addAttribute("prefer-vector-width",
1795                              CodeGenOpts.PreferVectorWidth);
1796
1797     if (CodeGenOpts.StackRealignment)
1798       FuncAttrs.addAttribute("stackrealign");
1799     if (CodeGenOpts.Backchain)
1800       FuncAttrs.addAttribute("backchain");
1801     if (CodeGenOpts.EnableSegmentedStacks)
1802       FuncAttrs.addAttribute("split-stack");
1803
1804     if (CodeGenOpts.SpeculativeLoadHardening)
1805       FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
1806   }
1807
1808   if (getLangOpts().assumeFunctionsAreConvergent()) {
1809     // Conservatively, mark all functions and calls in CUDA and OpenCL as
1810     // convergent (meaning, they may call an intrinsically convergent op, such
1811     // as __syncthreads() / barrier(), and so can't have certain optimizations
1812     // applied around them).  LLVM will remove this attribute where it safely
1813     // can.
1814     FuncAttrs.addAttribute(llvm::Attribute::Convergent);
1815   }
1816
1817   if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
1818     // Exceptions aren't supported in CUDA device code.
1819     FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1820   }
1821
1822   for (StringRef Attr : CodeGenOpts.DefaultFunctionAttrs) {
1823     StringRef Var, Value;
1824     std::tie(Var, Value) = Attr.split('=');
1825     FuncAttrs.addAttribute(Var, Value);
1826   }
1827 }
1828
1829 void CodeGenModule::addDefaultFunctionDefinitionAttributes(llvm::Function &F) {
1830   llvm::AttrBuilder FuncAttrs;
1831   getDefaultFunctionAttributes(F.getName(), F.hasOptNone(),
1832                                /* AttrOnCallSite = */ false, FuncAttrs);
1833   // TODO: call GetCPUAndFeaturesAttributes?
1834   F.addAttributes(llvm::AttributeList::FunctionIndex, FuncAttrs);
1835 }
1836
1837 void CodeGenModule::addDefaultFunctionDefinitionAttributes(
1838                                                    llvm::AttrBuilder &attrs) {
1839   getDefaultFunctionAttributes(/*function name*/ "", /*optnone*/ false,
1840                                /*for call*/ false, attrs);
1841   GetCPUAndFeaturesAttributes(GlobalDecl(), attrs);
1842 }
1843
1844 static void addNoBuiltinAttributes(llvm::AttrBuilder &FuncAttrs,
1845                                    const LangOptions &LangOpts,
1846                                    const NoBuiltinAttr *NBA = nullptr) {
1847   auto AddNoBuiltinAttr = [&FuncAttrs](StringRef BuiltinName) {
1848     SmallString<32> AttributeName;
1849     AttributeName += "no-builtin-";
1850     AttributeName += BuiltinName;
1851     FuncAttrs.addAttribute(AttributeName);
1852   };
1853
1854   // First, handle the language options passed through -fno-builtin.
1855   if (LangOpts.NoBuiltin) {
1856     // -fno-builtin disables them all.
1857     FuncAttrs.addAttribute("no-builtins");
1858     return;
1859   }
1860
1861   // Then, add attributes for builtins specified through -fno-builtin-<name>.
1862   llvm::for_each(LangOpts.NoBuiltinFuncs, AddNoBuiltinAttr);
1863
1864   // Now, let's check the __attribute__((no_builtin("...")) attribute added to
1865   // the source.
1866   if (!NBA)
1867     return;
1868
1869   // If there is a wildcard in the builtin names specified through the
1870   // attribute, disable them all.
1871   if (llvm::is_contained(NBA->builtinNames(), "*")) {
1872     FuncAttrs.addAttribute("no-builtins");
1873     return;
1874   }
1875
1876   // And last, add the rest of the builtin names.
1877   llvm::for_each(NBA->builtinNames(), AddNoBuiltinAttr);
1878 }
1879
1880 /// Construct the IR attribute list of a function or call.
1881 ///
1882 /// When adding an attribute, please consider where it should be handled:
1883 ///
1884 ///   - getDefaultFunctionAttributes is for attributes that are essentially
1885 ///     part of the global target configuration (but perhaps can be
1886 ///     overridden on a per-function basis).  Adding attributes there
1887 ///     will cause them to also be set in frontends that build on Clang's
1888 ///     target-configuration logic, as well as for code defined in library
1889 ///     modules such as CUDA's libdevice.
1890 ///
1891 ///   - ConstructAttributeList builds on top of getDefaultFunctionAttributes
1892 ///     and adds declaration-specific, convention-specific, and
1893 ///     frontend-specific logic.  The last is of particular importance:
1894 ///     attributes that restrict how the frontend generates code must be
1895 ///     added here rather than getDefaultFunctionAttributes.
1896 ///
1897 void CodeGenModule::ConstructAttributeList(
1898     StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo,
1899     llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite) {
1900   llvm::AttrBuilder FuncAttrs;
1901   llvm::AttrBuilder RetAttrs;
1902
1903   // Collect function IR attributes from the CC lowering.
1904   // We'll collect the paramete and result attributes later.
1905   CallingConv = FI.getEffectiveCallingConvention();
1906   if (FI.isNoReturn())
1907     FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1908   if (FI.isCmseNSCall())
1909     FuncAttrs.addAttribute("cmse_nonsecure_call");
1910
1911   // Collect function IR attributes from the callee prototype if we have one.
1912   AddAttributesFromFunctionProtoType(getContext(), FuncAttrs,
1913                                      CalleeInfo.getCalleeFunctionProtoType());
1914
1915   const Decl *TargetDecl = CalleeInfo.getCalleeDecl().getDecl();
1916
1917   bool HasOptnone = false;
1918   // The NoBuiltinAttr attached to the target FunctionDecl.
1919   const NoBuiltinAttr *NBA = nullptr;
1920
1921   // Collect function IR attributes based on declaration-specific
1922   // information.
1923   // FIXME: handle sseregparm someday...
1924   if (TargetDecl) {
1925     if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
1926       FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
1927     if (TargetDecl->hasAttr<NoThrowAttr>())
1928       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1929     if (TargetDecl->hasAttr<NoReturnAttr>())
1930       FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1931     if (TargetDecl->hasAttr<ColdAttr>())
1932       FuncAttrs.addAttribute(llvm::Attribute::Cold);
1933     if (TargetDecl->hasAttr<NoDuplicateAttr>())
1934       FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate);
1935     if (TargetDecl->hasAttr<ConvergentAttr>())
1936       FuncAttrs.addAttribute(llvm::Attribute::Convergent);
1937
1938     if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
1939       AddAttributesFromFunctionProtoType(
1940           getContext(), FuncAttrs, Fn->getType()->getAs<FunctionProtoType>());
1941       if (AttrOnCallSite && Fn->isReplaceableGlobalAllocationFunction()) {
1942         // A sane operator new returns a non-aliasing pointer.
1943         auto Kind = Fn->getDeclName().getCXXOverloadedOperator();
1944         if (getCodeGenOpts().AssumeSaneOperatorNew &&
1945             (Kind == OO_New || Kind == OO_Array_New))
1946           RetAttrs.addAttribute(llvm::Attribute::NoAlias);
1947       }
1948       const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
1949       const bool IsVirtualCall = MD && MD->isVirtual();
1950       // Don't use [[noreturn]], _Noreturn or [[no_builtin]] for a call to a
1951       // virtual function. These attributes are not inherited by overloads.
1952       if (!(AttrOnCallSite && IsVirtualCall)) {
1953         if (Fn->isNoReturn())
1954           FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1955         NBA = Fn->getAttr<NoBuiltinAttr>();
1956       }
1957     }
1958
1959     // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
1960     if (TargetDecl->hasAttr<ConstAttr>()) {
1961       FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1962       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1963     } else if (TargetDecl->hasAttr<PureAttr>()) {
1964       FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1965       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1966     } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
1967       FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly);
1968       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1969     }
1970     if (TargetDecl->hasAttr<RestrictAttr>())
1971       RetAttrs.addAttribute(llvm::Attribute::NoAlias);
1972     if (TargetDecl->hasAttr<ReturnsNonNullAttr>() &&
1973         !CodeGenOpts.NullPointerIsValid)
1974       RetAttrs.addAttribute(llvm::Attribute::NonNull);
1975     if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>())
1976       FuncAttrs.addAttribute("no_caller_saved_registers");
1977     if (TargetDecl->hasAttr<AnyX86NoCfCheckAttr>())
1978       FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck);
1979
1980     HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
1981     if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) {
1982       Optional<unsigned> NumElemsParam;
1983       if (AllocSize->getNumElemsParam().isValid())
1984         NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex();
1985       FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(),
1986                                  NumElemsParam);
1987     }
1988
1989     if (TargetDecl->hasAttr<OpenCLKernelAttr>()) {
1990       if (getLangOpts().OpenCLVersion <= 120) {
1991         // OpenCL v1.2 Work groups are always uniform
1992         FuncAttrs.addAttribute("uniform-work-group-size", "true");
1993       } else {
1994         // OpenCL v2.0 Work groups may be whether uniform or not.
1995         // '-cl-uniform-work-group-size' compile option gets a hint
1996         // to the compiler that the global work-size be a multiple of
1997         // the work-group size specified to clEnqueueNDRangeKernel
1998         // (i.e. work groups are uniform).
1999         FuncAttrs.addAttribute("uniform-work-group-size",
2000                                llvm::toStringRef(CodeGenOpts.UniformWGSize));
2001       }
2002     }
2003   }
2004
2005   // Attach "no-builtins" attributes to:
2006   // * call sites: both `nobuiltin` and "no-builtins" or "no-builtin-<name>".
2007   // * definitions: "no-builtins" or "no-builtin-<name>" only.
2008   // The attributes can come from:
2009   // * LangOpts: -ffreestanding, -fno-builtin, -fno-builtin-<name>
2010   // * FunctionDecl attributes: __attribute__((no_builtin(...)))
2011   addNoBuiltinAttributes(FuncAttrs, getLangOpts(), NBA);
2012
2013   // Collect function IR attributes based on global settiings.
2014   getDefaultFunctionAttributes(Name, HasOptnone, AttrOnCallSite, FuncAttrs);
2015
2016   // Override some default IR attributes based on declaration-specific
2017   // information.
2018   if (TargetDecl) {
2019     if (TargetDecl->hasAttr<NoSpeculativeLoadHardeningAttr>())
2020       FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening);
2021     if (TargetDecl->hasAttr<SpeculativeLoadHardeningAttr>())
2022       FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
2023     if (TargetDecl->hasAttr<NoSplitStackAttr>())
2024       FuncAttrs.removeAttribute("split-stack");
2025
2026     // Add NonLazyBind attribute to function declarations when -fno-plt
2027     // is used.
2028     // FIXME: what if we just haven't processed the function definition
2029     // yet, or if it's an external definition like C99 inline?
2030     if (CodeGenOpts.NoPLT) {
2031       if (auto *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
2032         if (!Fn->isDefined() && !AttrOnCallSite) {
2033           FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind);
2034         }
2035       }
2036     }
2037   }
2038
2039   // Collect non-call-site function IR attributes from declaration-specific
2040   // information.
2041   if (!AttrOnCallSite) {
2042     if (TargetDecl && TargetDecl->hasAttr<CmseNSEntryAttr>())
2043       FuncAttrs.addAttribute("cmse_nonsecure_entry");
2044
2045     // Whether tail calls are enabled.
2046     auto shouldDisableTailCalls = [&] {
2047       // Should this be honored in getDefaultFunctionAttributes?
2048       if (CodeGenOpts.DisableTailCalls)
2049         return true;
2050
2051       if (!TargetDecl)
2052         return false;
2053
2054       if (TargetDecl->hasAttr<DisableTailCallsAttr>() ||
2055           TargetDecl->hasAttr<AnyX86InterruptAttr>())
2056         return true;
2057
2058       if (CodeGenOpts.NoEscapingBlockTailCalls) {
2059         if (const auto *BD = dyn_cast<BlockDecl>(TargetDecl))
2060           if (!BD->doesNotEscape())
2061             return true;
2062       }
2063
2064       return false;
2065     };
2066     FuncAttrs.addAttribute("disable-tail-calls",
2067                            llvm::toStringRef(shouldDisableTailCalls()));
2068
2069     // CPU/feature overrides.  addDefaultFunctionDefinitionAttributes
2070     // handles these separately to set them based on the global defaults.
2071     GetCPUAndFeaturesAttributes(CalleeInfo.getCalleeDecl(), FuncAttrs);
2072   }
2073
2074   // Collect attributes from arguments and return values.
2075   ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI);
2076
2077   QualType RetTy = FI.getReturnType();
2078   const ABIArgInfo &RetAI = FI.getReturnInfo();
2079   switch (RetAI.getKind()) {
2080   case ABIArgInfo::Extend:
2081     if (RetAI.isSignExt())
2082       RetAttrs.addAttribute(llvm::Attribute::SExt);
2083     else
2084       RetAttrs.addAttribute(llvm::Attribute::ZExt);
2085     LLVM_FALLTHROUGH;
2086   case ABIArgInfo::Direct:
2087     if (RetAI.getInReg())
2088       RetAttrs.addAttribute(llvm::Attribute::InReg);
2089     break;
2090   case ABIArgInfo::Ignore:
2091     break;
2092
2093   case ABIArgInfo::InAlloca:
2094   case ABIArgInfo::Indirect: {
2095     // inalloca and sret disable readnone and readonly
2096     FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2097       .removeAttribute(llvm::Attribute::ReadNone);
2098     break;
2099   }
2100
2101   case ABIArgInfo::CoerceAndExpand:
2102     break;
2103
2104   case ABIArgInfo::Expand:
2105     llvm_unreachable("Invalid ABI kind for return argument");
2106   }
2107
2108   if (const auto *RefTy = RetTy->getAs<ReferenceType>()) {
2109     QualType PTy = RefTy->getPointeeType();
2110     if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
2111       RetAttrs.addDereferenceableAttr(
2112           getMinimumObjectSize(PTy).getQuantity());
2113     if (getContext().getTargetAddressSpace(PTy) == 0 &&
2114         !CodeGenOpts.NullPointerIsValid)
2115       RetAttrs.addAttribute(llvm::Attribute::NonNull);
2116     if (PTy->isObjectType()) {
2117       llvm::Align Alignment =
2118           getNaturalPointeeTypeAlignment(RetTy).getAsAlign();
2119       RetAttrs.addAlignmentAttr(Alignment);
2120     }
2121   }
2122
2123   bool hasUsedSRet = false;
2124   SmallVector<llvm::AttributeSet, 4> ArgAttrs(IRFunctionArgs.totalIRArgs());
2125
2126   // Attach attributes to sret.
2127   if (IRFunctionArgs.hasSRetArg()) {
2128     llvm::AttrBuilder SRETAttrs;
2129     SRETAttrs.addAttribute(llvm::Attribute::StructRet);
2130     hasUsedSRet = true;
2131     if (RetAI.getInReg())
2132       SRETAttrs.addAttribute(llvm::Attribute::InReg);
2133     SRETAttrs.addAlignmentAttr(RetAI.getIndirectAlign().getQuantity());
2134     ArgAttrs[IRFunctionArgs.getSRetArgNo()] =
2135         llvm::AttributeSet::get(getLLVMContext(), SRETAttrs);
2136   }
2137
2138   // Attach attributes to inalloca argument.
2139   if (IRFunctionArgs.hasInallocaArg()) {
2140     llvm::AttrBuilder Attrs;
2141     Attrs.addAttribute(llvm::Attribute::InAlloca);
2142     ArgAttrs[IRFunctionArgs.getInallocaArgNo()] =
2143         llvm::AttributeSet::get(getLLVMContext(), Attrs);
2144   }
2145
2146   unsigned ArgNo = 0;
2147   for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(),
2148                                           E = FI.arg_end();
2149        I != E; ++I, ++ArgNo) {
2150     QualType ParamType = I->type;
2151     const ABIArgInfo &AI = I->info;
2152     llvm::AttrBuilder Attrs;
2153
2154     // Add attribute for padding argument, if necessary.
2155     if (IRFunctionArgs.hasPaddingArg(ArgNo)) {
2156       if (AI.getPaddingInReg()) {
2157         ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
2158             llvm::AttributeSet::get(
2159                 getLLVMContext(),
2160                 llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg));
2161       }
2162     }
2163
2164     // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
2165     // have the corresponding parameter variable.  It doesn't make
2166     // sense to do it here because parameters are so messed up.
2167     switch (AI.getKind()) {
2168     case ABIArgInfo::Extend:
2169       if (AI.isSignExt())
2170         Attrs.addAttribute(llvm::Attribute::SExt);
2171       else
2172         Attrs.addAttribute(llvm::Attribute::ZExt);
2173       LLVM_FALLTHROUGH;
2174     case ABIArgInfo::Direct:
2175       if (ArgNo == 0 && FI.isChainCall())
2176         Attrs.addAttribute(llvm::Attribute::Nest);
2177       else if (AI.getInReg())
2178         Attrs.addAttribute(llvm::Attribute::InReg);
2179       break;
2180
2181     case ABIArgInfo::Indirect: {
2182       if (AI.getInReg())
2183         Attrs.addAttribute(llvm::Attribute::InReg);
2184
2185       if (AI.getIndirectByVal())
2186         Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType));
2187
2188       CharUnits Align = AI.getIndirectAlign();
2189
2190       // In a byval argument, it is important that the required
2191       // alignment of the type is honored, as LLVM might be creating a
2192       // *new* stack object, and needs to know what alignment to give
2193       // it. (Sometimes it can deduce a sensible alignment on its own,
2194       // but not if clang decides it must emit a packed struct, or the
2195       // user specifies increased alignment requirements.)
2196       //
2197       // This is different from indirect *not* byval, where the object
2198       // exists already, and the align attribute is purely
2199       // informative.
2200       assert(!Align.isZero());
2201
2202       // For now, only add this when we have a byval argument.
2203       // TODO: be less lazy about updating test cases.
2204       if (AI.getIndirectByVal())
2205         Attrs.addAlignmentAttr(Align.getQuantity());
2206
2207       // byval disables readnone and readonly.
2208       FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2209         .removeAttribute(llvm::Attribute::ReadNone);
2210       break;
2211     }
2212     case ABIArgInfo::Ignore:
2213     case ABIArgInfo::Expand:
2214     case ABIArgInfo::CoerceAndExpand:
2215       break;
2216
2217     case ABIArgInfo::InAlloca:
2218       // inalloca disables readnone and readonly.
2219       FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2220           .removeAttribute(llvm::Attribute::ReadNone);
2221       continue;
2222     }
2223
2224     if (const auto *RefTy = ParamType->getAs<ReferenceType>()) {
2225       QualType PTy = RefTy->getPointeeType();
2226       if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
2227         Attrs.addDereferenceableAttr(
2228             getMinimumObjectSize(PTy).getQuantity());
2229       if (getContext().getTargetAddressSpace(PTy) == 0 &&
2230           !CodeGenOpts.NullPointerIsValid)
2231         Attrs.addAttribute(llvm::Attribute::NonNull);
2232       if (PTy->isObjectType()) {
2233         llvm::Align Alignment =
2234             getNaturalPointeeTypeAlignment(ParamType).getAsAlign();
2235         Attrs.addAlignmentAttr(Alignment);
2236       }
2237     }
2238
2239     switch (FI.getExtParameterInfo(ArgNo).getABI()) {
2240     case ParameterABI::Ordinary:
2241       break;
2242
2243     case ParameterABI::SwiftIndirectResult: {
2244       // Add 'sret' if we haven't already used it for something, but
2245       // only if the result is void.
2246       if (!hasUsedSRet && RetTy->isVoidType()) {
2247         Attrs.addAttribute(llvm::Attribute::StructRet);
2248         hasUsedSRet = true;
2249       }
2250
2251       // Add 'noalias' in either case.
2252       Attrs.addAttribute(llvm::Attribute::NoAlias);
2253
2254       // Add 'dereferenceable' and 'alignment'.
2255       auto PTy = ParamType->getPointeeType();
2256       if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) {
2257         auto info = getContext().getTypeInfoInChars(PTy);
2258         Attrs.addDereferenceableAttr(info.first.getQuantity());
2259         Attrs.addAlignmentAttr(info.second.getAsAlign());
2260       }
2261       break;
2262     }
2263
2264     case ParameterABI::SwiftErrorResult:
2265       Attrs.addAttribute(llvm::Attribute::SwiftError);
2266       break;
2267
2268     case ParameterABI::SwiftContext:
2269       Attrs.addAttribute(llvm::Attribute::SwiftSelf);
2270       break;
2271     }
2272
2273     if (FI.getExtParameterInfo(ArgNo).isNoEscape())
2274       Attrs.addAttribute(llvm::Attribute::NoCapture);
2275
2276     if (Attrs.hasAttributes()) {
2277       unsigned FirstIRArg, NumIRArgs;
2278       std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
2279       for (unsigned i = 0; i < NumIRArgs; i++)
2280         ArgAttrs[FirstIRArg + i] =
2281             llvm::AttributeSet::get(getLLVMContext(), Attrs);
2282     }
2283   }
2284   assert(ArgNo == FI.arg_size());
2285
2286   AttrList = llvm::AttributeList::get(
2287       getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), FuncAttrs),
2288       llvm::AttributeSet::get(getLLVMContext(), RetAttrs), ArgAttrs);
2289 }
2290
2291 /// An argument came in as a promoted argument; demote it back to its
2292 /// declared type.
2293 static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
2294                                          const VarDecl *var,
2295                                          llvm::Value *value) {
2296   llvm::Type *varType = CGF.ConvertType(var->getType());
2297
2298   // This can happen with promotions that actually don't change the
2299   // underlying type, like the enum promotions.
2300   if (value->getType() == varType) return value;
2301
2302   assert((varType->isIntegerTy() || varType->isFloatingPointTy())
2303          && "unexpected promotion type");
2304
2305   if (isa<llvm::IntegerType>(varType))
2306     return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
2307
2308   return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
2309 }
2310
2311 /// Returns the attribute (either parameter attribute, or function
2312 /// attribute), which declares argument ArgNo to be non-null.
2313 static const NonNullAttr *getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD,
2314                                          QualType ArgType, unsigned ArgNo) {
2315   // FIXME: __attribute__((nonnull)) can also be applied to:
2316   //   - references to pointers, where the pointee is known to be
2317   //     nonnull (apparently a Clang extension)
2318   //   - transparent unions containing pointers
2319   // In the former case, LLVM IR cannot represent the constraint. In
2320   // the latter case, we have no guarantee that the transparent union
2321   // is in fact passed as a pointer.
2322   if (!ArgType->isAnyPointerType() && !ArgType->isBlockPointerType())
2323     return nullptr;
2324   // First, check attribute on parameter itself.
2325   if (PVD) {
2326     if (auto ParmNNAttr = PVD->getAttr<NonNullAttr>())
2327       return ParmNNAttr;
2328   }
2329   // Check function attributes.
2330   if (!FD)
2331     return nullptr;
2332   for (const auto *NNAttr : FD->specific_attrs<NonNullAttr>()) {
2333     if (NNAttr->isNonNull(ArgNo))
2334       return NNAttr;
2335   }
2336   return nullptr;
2337 }
2338
2339 namespace {
2340   struct CopyBackSwiftError final : EHScopeStack::Cleanup {
2341     Address Temp;
2342     Address Arg;
2343     CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}
2344     void Emit(CodeGenFunction &CGF, Flags flags) override {
2345       llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp);
2346       CGF.Builder.CreateStore(errorValue, Arg);
2347     }
2348   };
2349 }
2350
2351 void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
2352                                          llvm::Function *Fn,
2353                                          const FunctionArgList &Args) {
2354   if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>())
2355     // Naked functions don't have prologues.
2356     return;
2357
2358   // If this is an implicit-return-zero function, go ahead and
2359   // initialize the return value.  TODO: it might be nice to have
2360   // a more general mechanism for this that didn't require synthesized
2361   // return statements.
2362   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
2363     if (FD->hasImplicitReturnZero()) {
2364       QualType RetTy = FD->getReturnType().getUnqualifiedType();
2365       llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
2366       llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
2367       Builder.CreateStore(Zero, ReturnValue);
2368     }
2369   }
2370
2371   // FIXME: We no longer need the types from FunctionArgList; lift up and
2372   // simplify.
2373
2374   ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI);
2375   assert(Fn->arg_size() == IRFunctionArgs.totalIRArgs());
2376
2377   // If we're using inalloca, all the memory arguments are GEPs off of the last
2378   // parameter, which is a pointer to the complete memory area.
2379   Address ArgStruct = Address::invalid();
2380   if (IRFunctionArgs.hasInallocaArg()) {
2381     ArgStruct = Address(Fn->getArg(IRFunctionArgs.getInallocaArgNo()),
2382                         FI.getArgStructAlignment());
2383
2384     assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo());
2385   }
2386
2387   // Name the struct return parameter.
2388   if (IRFunctionArgs.hasSRetArg()) {
2389     auto AI = Fn->getArg(IRFunctionArgs.getSRetArgNo());
2390     AI->setName("agg.result");
2391     AI->addAttr(llvm::Attribute::NoAlias);
2392   }
2393
2394   // Track if we received the parameter as a pointer (indirect, byval, or
2395   // inalloca).  If already have a pointer, EmitParmDecl doesn't need to copy it
2396   // into a local alloca for us.
2397   SmallVector<ParamValue, 16> ArgVals;
2398   ArgVals.reserve(Args.size());
2399
2400   // Create a pointer value for every parameter declaration.  This usually
2401   // entails copying one or more LLVM IR arguments into an alloca.  Don't push
2402   // any cleanups or do anything that might unwind.  We do that separately, so
2403   // we can push the cleanups in the correct order for the ABI.
2404   assert(FI.arg_size() == Args.size() &&
2405          "Mismatch between function signature & arguments.");
2406   unsigned ArgNo = 0;
2407   CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin();
2408   for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
2409        i != e; ++i, ++info_it, ++ArgNo) {
2410     const VarDecl *Arg = *i;
2411     const ABIArgInfo &ArgI = info_it->info;
2412
2413     bool isPromoted =
2414       isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
2415     // We are converting from ABIArgInfo type to VarDecl type directly, unless
2416     // the parameter is promoted. In this case we convert to
2417     // CGFunctionInfo::ArgInfo type with subsequent argument demotion.
2418     QualType Ty = isPromoted ? info_it->type : Arg->getType();
2419     assert(hasScalarEvaluationKind(Ty) ==
2420            hasScalarEvaluationKind(Arg->getType()));
2421
2422     unsigned FirstIRArg, NumIRArgs;
2423     std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
2424
2425     switch (ArgI.getKind()) {
2426     case ABIArgInfo::InAlloca: {
2427       assert(NumIRArgs == 0);
2428       auto FieldIndex = ArgI.getInAllocaFieldIndex();
2429       Address V =
2430           Builder.CreateStructGEP(ArgStruct, FieldIndex, Arg->getName());
2431       if (ArgI.getInAllocaIndirect())
2432         V = Address(Builder.CreateLoad(V),
2433                     getContext().getTypeAlignInChars(Ty));
2434       ArgVals.push_back(ParamValue::forIndirect(V));
2435       break;
2436     }
2437
2438     case ABIArgInfo::Indirect: {
2439       assert(NumIRArgs == 1);
2440       Address ParamAddr =
2441           Address(Fn->getArg(FirstIRArg), ArgI.getIndirectAlign());
2442
2443       if (!hasScalarEvaluationKind(Ty)) {
2444         // Aggregates and complex variables are accessed by reference.  All we
2445         // need to do is realign the value, if requested.
2446         Address V = ParamAddr;
2447         if (ArgI.getIndirectRealign()) {
2448           Address AlignedTemp = CreateMemTemp(Ty, "coerce");
2449
2450           // Copy from the incoming argument pointer to the temporary with the
2451           // appropriate alignment.
2452           //
2453           // FIXME: We should have a common utility for generating an aggregate
2454           // copy.
2455           CharUnits Size = getContext().getTypeSizeInChars(Ty);
2456           Builder.CreateMemCpy(
2457               AlignedTemp.getPointer(), AlignedTemp.getAlignment().getAsAlign(),
2458               ParamAddr.getPointer(), ParamAddr.getAlignment().getAsAlign(),
2459               llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()));
2460           V = AlignedTemp;
2461         }
2462         ArgVals.push_back(ParamValue::forIndirect(V));
2463       } else {
2464         // Load scalar value from indirect argument.
2465         llvm::Value *V =
2466             EmitLoadOfScalar(ParamAddr, false, Ty, Arg->getBeginLoc());
2467
2468         if (isPromoted)
2469           V = emitArgumentDemotion(*this, Arg, V);
2470         ArgVals.push_back(ParamValue::forDirect(V));
2471       }
2472       break;
2473     }
2474
2475     case ABIArgInfo::Extend:
2476     case ABIArgInfo::Direct: {
2477       auto AI = Fn->getArg(FirstIRArg);
2478       llvm::Type *LTy = ConvertType(Arg->getType());
2479
2480       // Prepare parameter attributes. So far, only attributes for pointer
2481       // parameters are prepared. See
2482       // http://llvm.org/docs/LangRef.html#paramattrs.
2483       if (ArgI.getDirectOffset() == 0 && LTy->isPointerTy() &&
2484           ArgI.getCoerceToType()->isPointerTy()) {
2485         assert(NumIRArgs == 1);
2486
2487         if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {
2488           // Set `nonnull` attribute if any.
2489           if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(),
2490                              PVD->getFunctionScopeIndex()) &&
2491               !CGM.getCodeGenOpts().NullPointerIsValid)
2492             AI->addAttr(llvm::Attribute::NonNull);
2493
2494           QualType OTy = PVD->getOriginalType();
2495           if (const auto *ArrTy =
2496               getContext().getAsConstantArrayType(OTy)) {
2497             // A C99 array parameter declaration with the static keyword also
2498             // indicates dereferenceability, and if the size is constant we can
2499             // use the dereferenceable attribute (which requires the size in
2500             // bytes).
2501             if (ArrTy->getSizeModifier() == ArrayType::Static) {
2502               QualType ETy = ArrTy->getElementType();
2503               uint64_t ArrSize = ArrTy->getSize().getZExtValue();
2504               if (!ETy->isIncompleteType() && ETy->isConstantSizeType() &&
2505                   ArrSize) {
2506                 llvm::AttrBuilder Attrs;
2507                 Attrs.addDereferenceableAttr(
2508                   getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize);
2509                 AI->addAttrs(Attrs);
2510               } else if (getContext().getTargetAddressSpace(ETy) == 0 &&
2511                          !CGM.getCodeGenOpts().NullPointerIsValid) {
2512                 AI->addAttr(llvm::Attribute::NonNull);
2513               }
2514             }
2515           } else if (const auto *ArrTy =
2516                      getContext().getAsVariableArrayType(OTy)) {
2517             // For C99 VLAs with the static keyword, we don't know the size so
2518             // we can't use the dereferenceable attribute, but in addrspace(0)
2519             // we know that it must be nonnull.
2520             if (ArrTy->getSizeModifier() == VariableArrayType::Static &&
2521                 !getContext().getTargetAddressSpace(ArrTy->getElementType()) &&
2522                 !CGM.getCodeGenOpts().NullPointerIsValid)
2523               AI->addAttr(llvm::Attribute::NonNull);
2524           }
2525
2526           // Set `align` attribute if any.
2527           const auto *AVAttr = PVD->getAttr<AlignValueAttr>();
2528           if (!AVAttr)
2529             if (const auto *TOTy = dyn_cast<TypedefType>(OTy))
2530               AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>();
2531           if (AVAttr && !SanOpts.has(SanitizerKind::Alignment)) {
2532             // If alignment-assumption sanitizer is enabled, we do *not* add
2533             // alignment attribute here, but emit normal alignment assumption,
2534             // so the UBSAN check could function.
2535             llvm::ConstantInt *AlignmentCI =
2536                 cast<llvm::ConstantInt>(EmitScalarExpr(AVAttr->getAlignment()));
2537             unsigned AlignmentInt =
2538                 AlignmentCI->getLimitedValue(llvm::Value::MaximumAlignment);
2539             if (AI->getParamAlign().valueOrOne() < AlignmentInt) {
2540               AI->removeAttr(llvm::Attribute::AttrKind::Alignment);
2541               AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(
2542                   llvm::Align(AlignmentInt)));
2543             }
2544           }
2545         }
2546
2547         // Set 'noalias' if an argument type has the `restrict` qualifier.
2548         if (Arg->getType().isRestrictQualified())
2549           AI->addAttr(llvm::Attribute::NoAlias);
2550       }
2551
2552       // Prepare the argument value. If we have the trivial case, handle it
2553       // with no muss and fuss.
2554       if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
2555           ArgI.getCoerceToType() == ConvertType(Ty) &&
2556           ArgI.getDirectOffset() == 0) {
2557         assert(NumIRArgs == 1);
2558
2559         // LLVM expects swifterror parameters to be used in very restricted
2560         // ways.  Copy the value into a less-restricted temporary.
2561         llvm::Value *V = AI;
2562         if (FI.getExtParameterInfo(ArgNo).getABI()
2563               == ParameterABI::SwiftErrorResult) {
2564           QualType pointeeTy = Ty->getPointeeType();
2565           assert(pointeeTy->isPointerType());
2566           Address temp =
2567             CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");
2568           Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy));
2569           llvm::Value *incomingErrorValue = Builder.CreateLoad(arg);
2570           Builder.CreateStore(incomingErrorValue, temp);
2571           V = temp.getPointer();
2572
2573           // Push a cleanup to copy the value back at the end of the function.
2574           // The convention does not guarantee that the value will be written
2575           // back if the function exits with an unwind exception.
2576           EHStack.pushCleanup<CopyBackSwiftError>(NormalCleanup, temp, arg);
2577         }
2578
2579         // Ensure the argument is the correct type.
2580         if (V->getType() != ArgI.getCoerceToType())
2581           V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
2582
2583         if (isPromoted)
2584           V = emitArgumentDemotion(*this, Arg, V);
2585
2586         // Because of merging of function types from multiple decls it is
2587         // possible for the type of an argument to not match the corresponding
2588         // type in the function type. Since we are codegening the callee
2589         // in here, add a cast to the argument type.
2590         llvm::Type *LTy = ConvertType(Arg->getType());
2591         if (V->getType() != LTy)
2592           V = Builder.CreateBitCast(V, LTy);
2593
2594         ArgVals.push_back(ParamValue::forDirect(V));
2595         break;
2596       }
2597
2598       Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg),
2599                                      Arg->getName());
2600
2601       // Pointer to store into.
2602       Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI);
2603
2604       // Fast-isel and the optimizer generally like scalar values better than
2605       // FCAs, so we flatten them if this is safe to do for this argument.
2606       llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
2607       if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy &&
2608           STy->getNumElements() > 1) {
2609         uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
2610         llvm::Type *DstTy = Ptr.getElementType();
2611         uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
2612
2613         Address AddrToStoreInto = Address::invalid();
2614         if (SrcSize <= DstSize) {
2615           AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
2616         } else {
2617           AddrToStoreInto =
2618             CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
2619         }
2620
2621         assert(STy->getNumElements() == NumIRArgs);
2622         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2623           auto AI = Fn->getArg(FirstIRArg + i);
2624           AI->setName(Arg->getName() + ".coerce" + Twine(i));
2625           Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
2626           Builder.CreateStore(AI, EltPtr);
2627         }
2628
2629         if (SrcSize > DstSize) {
2630           Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize);
2631         }
2632
2633       } else {
2634         // Simple case, just do a coerced store of the argument into the alloca.
2635         assert(NumIRArgs == 1);
2636         auto AI = Fn->getArg(FirstIRArg);
2637         AI->setName(Arg->getName() + ".coerce");
2638         CreateCoercedStore(AI, Ptr, /*DstIsVolatile=*/false, *this);
2639       }
2640
2641       // Match to what EmitParmDecl is expecting for this type.
2642       if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
2643         llvm::Value *V =
2644             EmitLoadOfScalar(Alloca, false, Ty, Arg->getBeginLoc());
2645         if (isPromoted)
2646           V = emitArgumentDemotion(*this, Arg, V);
2647         ArgVals.push_back(ParamValue::forDirect(V));
2648       } else {
2649         ArgVals.push_back(ParamValue::forIndirect(Alloca));
2650       }
2651       break;
2652     }
2653
2654     case ABIArgInfo::CoerceAndExpand: {
2655       // Reconstruct into a temporary.
2656       Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2657       ArgVals.push_back(ParamValue::forIndirect(alloca));
2658
2659       auto coercionType = ArgI.getCoerceAndExpandType();
2660       alloca = Builder.CreateElementBitCast(alloca, coercionType);
2661
2662       unsigned argIndex = FirstIRArg;
2663       for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
2664         llvm::Type *eltType = coercionType->getElementType(i);
2665         if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType))
2666           continue;
2667
2668         auto eltAddr = Builder.CreateStructGEP(alloca, i);
2669         auto elt = Fn->getArg(argIndex++);
2670         Builder.CreateStore(elt, eltAddr);
2671       }
2672       assert(argIndex == FirstIRArg + NumIRArgs);
2673       break;
2674     }
2675
2676     case ABIArgInfo::Expand: {
2677       // If this structure was expanded into multiple arguments then
2678       // we need to create a temporary and reconstruct it from the
2679       // arguments.
2680       Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2681       LValue LV = MakeAddrLValue(Alloca, Ty);
2682       ArgVals.push_back(ParamValue::forIndirect(Alloca));
2683
2684       auto FnArgIter = Fn->arg_begin() + FirstIRArg;
2685       ExpandTypeFromArgs(Ty, LV, FnArgIter);
2686       assert(FnArgIter == Fn->arg_begin() + FirstIRArg + NumIRArgs);
2687       for (unsigned i = 0, e = NumIRArgs; i != e; ++i) {
2688         auto AI = Fn->getArg(FirstIRArg + i);
2689         AI->setName(Arg->getName() + "." + Twine(i));
2690       }
2691       break;
2692     }
2693
2694     case ABIArgInfo::Ignore:
2695       assert(NumIRArgs == 0);
2696       // Initialize the local variable appropriately.
2697       if (!hasScalarEvaluationKind(Ty)) {
2698         ArgVals.push_back(ParamValue::forIndirect(CreateMemTemp(Ty)));
2699       } else {
2700         llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType()));
2701         ArgVals.push_back(ParamValue::forDirect(U));
2702       }
2703       break;
2704     }
2705   }
2706
2707   if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {
2708     for (int I = Args.size() - 1; I >= 0; --I)
2709       EmitParmDecl(*Args[I], ArgVals[I], I + 1);
2710   } else {
2711     for (unsigned I = 0, E = Args.size(); I != E; ++I)
2712       EmitParmDecl(*Args[I], ArgVals[I], I + 1);
2713   }
2714 }
2715
2716 static void eraseUnusedBitCasts(llvm::Instruction *insn) {
2717   while (insn->use_empty()) {
2718     llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
2719     if (!bitcast) return;
2720
2721     // This is "safe" because we would have used a ConstantExpr otherwise.
2722     insn = cast<llvm::Instruction>(bitcast->getOperand(0));
2723     bitcast->eraseFromParent();
2724   }
2725 }
2726
2727 /// Try to emit a fused autorelease of a return result.
2728 static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF,
2729                                                     llvm::Value *result) {
2730   // We must be immediately followed the cast.
2731   llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
2732   if (BB->empty()) return nullptr;
2733   if (&BB->back() != result) return nullptr;
2734
2735   llvm::Type *resultType = result->getType();
2736
2737   // result is in a BasicBlock and is therefore an Instruction.
2738   llvm::Instruction *generator = cast<llvm::Instruction>(result);
2739
2740   SmallVector<llvm::Instruction *, 4> InstsToKill;
2741
2742   // Look for:
2743   //  %generator = bitcast %type1* %generator2 to %type2*
2744   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
2745     // We would have emitted this as a constant if the operand weren't
2746     // an Instruction.
2747     generator = cast<llvm::Instruction>(bitcast->getOperand(0));
2748
2749     // Require the generator to be immediately followed by the cast.
2750     if (generator->getNextNode() != bitcast)
2751       return nullptr;
2752
2753     InstsToKill.push_back(bitcast);
2754   }
2755
2756   // Look for:
2757   //   %generator = call i8* @objc_retain(i8* %originalResult)
2758   // or
2759   //   %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
2760   llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
2761   if (!call) return nullptr;
2762
2763   bool doRetainAutorelease;
2764
2765   if (call->getCalledOperand() == CGF.CGM.getObjCEntrypoints().objc_retain) {
2766     doRetainAutorelease = true;
2767   } else if (call->getCalledOperand() ==
2768              CGF.CGM.getObjCEntrypoints().objc_retainAutoreleasedReturnValue) {
2769     doRetainAutorelease = false;
2770
2771     // If we emitted an assembly marker for this call (and the
2772     // ARCEntrypoints field should have been set if so), go looking
2773     // for that call.  If we can't find it, we can't do this
2774     // optimization.  But it should always be the immediately previous
2775     // instruction, unless we needed bitcasts around the call.
2776     if (CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker) {
2777       llvm::Instruction *prev = call->getPrevNode();
2778       assert(prev);
2779       if (isa<llvm::BitCastInst>(prev)) {
2780         prev = prev->getPrevNode();
2781         assert(prev);
2782       }
2783       assert(isa<llvm::CallInst>(prev));
2784       assert(cast<llvm::CallInst>(prev)->getCalledOperand() ==
2785              CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker);
2786       InstsToKill.push_back(prev);
2787     }
2788   } else {
2789     return nullptr;
2790   }
2791
2792   result = call->getArgOperand(0);
2793   InstsToKill.push_back(call);
2794
2795   // Keep killing bitcasts, for sanity.  Note that we no longer care
2796   // about precise ordering as long as there's exactly one use.
2797   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
2798     if (!bitcast->hasOneUse()) break;
2799     InstsToKill.push_back(bitcast);
2800     result = bitcast->getOperand(0);
2801   }
2802
2803   // Delete all the unnecessary instructions, from latest to earliest.
2804   for (auto *I : InstsToKill)
2805     I->eraseFromParent();
2806
2807   // Do the fused retain/autorelease if we were asked to.
2808   if (doRetainAutorelease)
2809     result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
2810
2811   // Cast back to the result type.
2812   return CGF.Builder.CreateBitCast(result, resultType);
2813 }
2814
2815 /// If this is a +1 of the value of an immutable 'self', remove it.
2816 static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF,
2817                                           llvm::Value *result) {
2818   // This is only applicable to a method with an immutable 'self'.
2819   const ObjCMethodDecl *method =
2820     dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
2821   if (!method) return nullptr;
2822   const VarDecl *self = method->getSelfDecl();
2823   if (!self->getType().isConstQualified()) return nullptr;
2824
2825   // Look for a retain call.
2826   llvm::CallInst *retainCall =
2827     dyn_cast<llvm::CallInst>(result->stripPointerCasts());
2828   if (!retainCall || retainCall->getCalledOperand() !=
2829                          CGF.CGM.getObjCEntrypoints().objc_retain)
2830     return nullptr;
2831
2832   // Look for an ordinary load of 'self'.
2833   llvm::Value *retainedValue = retainCall->getArgOperand(0);
2834   llvm::LoadInst *load =
2835     dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
2836   if (!load || load->isAtomic() || load->isVolatile() ||
2837       load->getPointerOperand() != CGF.GetAddrOfLocalVar(self).getPointer())
2838     return nullptr;
2839
2840   // Okay!  Burn it all down.  This relies for correctness on the
2841   // assumption that the retain is emitted as part of the return and
2842   // that thereafter everything is used "linearly".
2843   llvm::Type *resultType = result->getType();
2844   eraseUnusedBitCasts(cast<llvm::Instruction>(result));
2845   assert(retainCall->use_empty());
2846   retainCall->eraseFromParent();
2847   eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
2848
2849   return CGF.Builder.CreateBitCast(load, resultType);
2850 }
2851
2852 /// Emit an ARC autorelease of the result of a function.
2853 ///
2854 /// \return the value to actually return from the function
2855 static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF,
2856                                             llvm::Value *result) {
2857   // If we're returning 'self', kill the initial retain.  This is a
2858   // heuristic attempt to "encourage correctness" in the really unfortunate
2859   // case where we have a return of self during a dealloc and we desperately
2860   // need to avoid the possible autorelease.
2861   if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
2862     return self;
2863
2864   // At -O0, try to emit a fused retain/autorelease.
2865   if (CGF.shouldUseFusedARCCalls())
2866     if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
2867       return fused;
2868
2869   return CGF.EmitARCAutoreleaseReturnValue(result);
2870 }
2871
2872 /// Heuristically search for a dominating store to the return-value slot.
2873 static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
2874   // Check if a User is a store which pointerOperand is the ReturnValue.
2875   // We are looking for stores to the ReturnValue, not for stores of the
2876   // ReturnValue to some other location.
2877   auto GetStoreIfValid = [&CGF](llvm::User *U) -> llvm::StoreInst * {
2878     auto *SI = dyn_cast<llvm::StoreInst>(U);
2879     if (!SI || SI->getPointerOperand() != CGF.ReturnValue.getPointer())
2880       return nullptr;
2881     // These aren't actually possible for non-coerced returns, and we
2882     // only care about non-coerced returns on this code path.
2883     assert(!SI->isAtomic() && !SI->isVolatile());
2884     return SI;
2885   };
2886   // If there are multiple uses of the return-value slot, just check
2887   // for something immediately preceding the IP.  Sometimes this can
2888   // happen with how we generate implicit-returns; it can also happen
2889   // with noreturn cleanups.
2890   if (!CGF.ReturnValue.getPointer()->hasOneUse()) {
2891     llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2892     if (IP->empty()) return nullptr;
2893     llvm::Instruction *I = &IP->back();
2894
2895     // Skip lifetime markers
2896     for (llvm::BasicBlock::reverse_iterator II = IP->rbegin(),
2897                                             IE = IP->rend();
2898          II != IE; ++II) {
2899       if (llvm::IntrinsicInst *Intrinsic =
2900               dyn_cast<llvm::IntrinsicInst>(&*II)) {
2901         if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) {
2902           const llvm::Value *CastAddr = Intrinsic->getArgOperand(1);
2903           ++II;
2904           if (II == IE)
2905             break;
2906           if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
2907             continue;
2908         }
2909       }
2910       I = &*II;
2911       break;
2912     }
2913
2914     return GetStoreIfValid(I);
2915   }
2916
2917   llvm::StoreInst *store =
2918       GetStoreIfValid(CGF.ReturnValue.getPointer()->user_back());
2919   if (!store) return nullptr;
2920
2921   // Now do a first-and-dirty dominance check: just walk up the
2922   // single-predecessors chain from the current insertion point.
2923   llvm::BasicBlock *StoreBB = store->getParent();
2924   llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2925   while (IP != StoreBB) {
2926     if (!(IP = IP->getSinglePredecessor()))
2927       return nullptr;
2928   }
2929
2930   // Okay, the store's basic block dominates the insertion point; we
2931   // can do our thing.
2932   return store;
2933 }
2934
2935 // Helper functions for EmitCMSEClearRecord
2936
2937 // Set the bits corresponding to a field having width `BitWidth` and located at
2938 // offset `BitOffset` (from the least significant bit) within a storage unit of
2939 // `Bits.size()` bytes. Each element of `Bits` corresponds to one target byte.
2940 // Use little-endian layout, i.e.`Bits[0]` is the LSB.
2941 static void setBitRange(SmallVectorImpl<uint64_t> &Bits, int BitOffset,
2942                         int BitWidth, int CharWidth) {
2943   assert(CharWidth <= 64);
2944   assert(static_cast<unsigned>(BitWidth) <= Bits.size() * CharWidth);
2945
2946   int Pos = 0;
2947   if (BitOffset >= CharWidth) {
2948     Pos += BitOffset / CharWidth;
2949     BitOffset = BitOffset % CharWidth;
2950   }
2951
2952   const uint64_t Used = (uint64_t(1) << CharWidth) - 1;
2953   if (BitOffset + BitWidth >= CharWidth) {
2954     Bits[Pos++] |= (Used << BitOffset) & Used;
2955     BitWidth -= CharWidth - BitOffset;
2956     BitOffset = 0;
2957   }
2958
2959   while (BitWidth >= CharWidth) {
2960     Bits[Pos++] = Used;
2961     BitWidth -= CharWidth;
2962   }
2963
2964   if (BitWidth > 0)
2965     Bits[Pos++] |= (Used >> (CharWidth - BitWidth)) << BitOffset;
2966 }
2967
2968 // Set the bits corresponding to a field having width `BitWidth` and located at
2969 // offset `BitOffset` (from the least significant bit) within a storage unit of
2970 // `StorageSize` bytes, located at `StorageOffset` in `Bits`. Each element of
2971 // `Bits` corresponds to one target byte. Use target endian layout.
2972 static void setBitRange(SmallVectorImpl<uint64_t> &Bits, int StorageOffset,
2973                         int StorageSize, int BitOffset, int BitWidth,
2974                         int CharWidth, bool BigEndian) {
2975
2976   SmallVector<uint64_t, 8> TmpBits(StorageSize);
2977   setBitRange(TmpBits, BitOffset, BitWidth, CharWidth);
2978
2979   if (BigEndian)
2980     std::reverse(TmpBits.begin(), TmpBits.end());
2981
2982   for (uint64_t V : TmpBits)
2983     Bits[StorageOffset++] |= V;
2984 }
2985
2986 static void setUsedBits(CodeGenModule &, QualType, int,
2987                         SmallVectorImpl<uint64_t> &);
2988
2989 // Set the bits in `Bits`, which correspond to the value representations of
2990 // the actual members of the record type `RTy`. Note that this function does
2991 // not handle base classes, virtual tables, etc, since they cannot happen in
2992 // CMSE function arguments or return. The bit mask corresponds to the target
2993 // memory layout, i.e. it's endian dependent.
2994 static void setUsedBits(CodeGenModule &CGM, const RecordType *RTy, int Offset,
2995                         SmallVectorImpl<uint64_t> &Bits) {
2996   ASTContext &Context = CGM.getContext();
2997   int CharWidth = Context.getCharWidth();
2998   const RecordDecl *RD = RTy->getDecl()->getDefinition();
2999   const ASTRecordLayout &ASTLayout = Context.getASTRecordLayout(RD);
3000   const CGRecordLayout &Layout = CGM.getTypes().getCGRecordLayout(RD);
3001
3002   int Idx = 0;
3003   for (auto I = RD->field_begin(), E = RD->field_end(); I != E; ++I, ++Idx) {
3004     const FieldDecl *F = *I;
3005
3006     if (F->isUnnamedBitfield() || F->isZeroLengthBitField(Context) ||
3007         F->getType()->isIncompleteArrayType())
3008       continue;
3009
3010     if (F->isBitField()) {
3011       const CGBitFieldInfo &BFI = Layout.getBitFieldInfo(F);
3012       setBitRange(Bits, Offset + BFI.StorageOffset.getQuantity(),
3013                   BFI.StorageSize / CharWidth, BFI.Offset,
3014                   BFI.Size, CharWidth,
3015                   CGM.getDataLayout().isBigEndian());
3016       continue;
3017     }
3018
3019     setUsedBits(CGM, F->getType(),
3020                 Offset + ASTLayout.getFieldOffset(Idx) / CharWidth, Bits);
3021   }
3022 }
3023
3024 // Set the bits in `Bits`, which correspond to the value representations of
3025 // the elements of an array type `ATy`.
3026 static void setUsedBits(CodeGenModule &CGM, const ConstantArrayType *ATy,
3027                         int Offset, SmallVectorImpl<uint64_t> &Bits) {
3028   const ASTContext &Context = CGM.getContext();
3029
3030   QualType ETy = Context.getBaseElementType(ATy);
3031   int Size = Context.getTypeSizeInChars(ETy).getQuantity();
3032   SmallVector<uint64_t, 4> TmpBits(Size);
3033   setUsedBits(CGM, ETy, 0, TmpBits);
3034
3035   for (int I = 0, N = Context.getConstantArrayElementCount(ATy); I < N; ++I) {
3036     auto Src = TmpBits.begin();
3037     auto Dst = Bits.begin() + Offset + I * Size;
3038     for (int J = 0; J < Size; ++J)
3039       *Dst++ |= *Src++;
3040   }
3041 }
3042
3043 // Set the bits in `Bits`, which correspond to the value representations of
3044 // the type `QTy`.
3045 static void setUsedBits(CodeGenModule &CGM, QualType QTy, int Offset,
3046                         SmallVectorImpl<uint64_t> &Bits) {
3047   if (const auto *RTy = QTy->getAs<RecordType>())
3048     return setUsedBits(CGM, RTy, Offset, Bits);
3049
3050   ASTContext &Context = CGM.getContext();
3051   if (const auto *ATy = Context.getAsConstantArrayType(QTy))
3052     return setUsedBits(CGM, ATy, Offset, Bits);
3053
3054   int Size = Context.getTypeSizeInChars(QTy).getQuantity();
3055   if (Size <= 0)
3056     return;
3057
3058   std::fill_n(Bits.begin() + Offset, Size,
3059               (uint64_t(1) << Context.getCharWidth()) - 1);
3060 }
3061
3062 static uint64_t buildMultiCharMask(const SmallVectorImpl<uint64_t> &Bits,
3063                                    int Pos, int Size, int CharWidth,
3064                                    bool BigEndian) {
3065   assert(Size > 0);
3066   uint64_t Mask = 0;
3067   if (BigEndian) {
3068     for (auto P = Bits.begin() + Pos, E = Bits.begin() + Pos + Size; P != E;
3069          ++P)
3070       Mask = (Mask << CharWidth) | *P;
3071   } else {
3072     auto P = Bits.begin() + Pos + Size, End = Bits.begin() + Pos;
3073     do
3074       Mask = (Mask << CharWidth) | *--P;
3075     while (P != End);
3076   }
3077   return Mask;
3078 }
3079
3080 // Emit code to clear the bits in a record, which aren't a part of any user
3081 // declared member, when the record is a function return.
3082 llvm::Value *CodeGenFunction::EmitCMSEClearRecord(llvm::Value *Src,
3083                                                   llvm::IntegerType *ITy,
3084                                                   QualType QTy) {
3085   assert(Src->getType() == ITy);
3086   assert(ITy->getScalarSizeInBits() <= 64);
3087
3088   const llvm::DataLayout &DataLayout = CGM.getDataLayout();
3089   int Size = DataLayout.getTypeStoreSize(ITy);
3090   SmallVector<uint64_t, 4> Bits(Size);
3091   setUsedBits(CGM, QTy->getAs<RecordType>(), 0, Bits);
3092
3093   int CharWidth = CGM.getContext().getCharWidth();
3094   uint64_t Mask =
3095       buildMultiCharMask(Bits, 0, Size, CharWidth, DataLayout.isBigEndian());
3096
3097   return Builder.CreateAnd(Src, Mask, "cmse.clear");
3098 }
3099
3100 // Emit code to clear the bits in a record, which aren't a part of any user
3101 // declared member, when the record is a function argument.
3102 llvm::Value *CodeGenFunction::EmitCMSEClearRecord(llvm::Value *Src,
3103                                                   llvm::ArrayType *ATy,
3104                                                   QualType QTy) {
3105   const llvm::DataLayout &DataLayout = CGM.getDataLayout();
3106   int Size = DataLayout.getTypeStoreSize(ATy);
3107   SmallVector<uint64_t, 16> Bits(Size);
3108   setUsedBits(CGM, QTy->getAs<RecordType>(), 0, Bits);
3109
3110   // Clear each element of the LLVM array.
3111   int CharWidth = CGM.getContext().getCharWidth();
3112   int CharsPerElt =
3113       ATy->getArrayElementType()->getScalarSizeInBits() / CharWidth;
3114   int MaskIndex = 0;
3115   llvm::Value *R = llvm::UndefValue::get(ATy);
3116   for (int I = 0, N = ATy->getArrayNumElements(); I != N; ++I) {
3117     uint64_t Mask = buildMultiCharMask(Bits, MaskIndex, CharsPerElt, CharWidth,
3118                                        DataLayout.isBigEndian());
3119     MaskIndex += CharsPerElt;
3120     llvm::Value *T0 = Builder.CreateExtractValue(Src, I);
3121     llvm::Value *T1 = Builder.CreateAnd(T0, Mask, "cmse.clear");
3122     R = Builder.CreateInsertValue(R, T1, I);
3123   }
3124
3125   return R;
3126 }
3127
3128 // Emit code to clear the padding bits when returning or passing as an argument
3129 // a 16-bit floating-point value.
3130 llvm::Value *CodeGenFunction::EmitCMSEClearFP16(llvm::Value *Src) {
3131   llvm::Type *RetTy = Src->getType();
3132   assert(RetTy->isFloatTy() ||
3133          (RetTy->isIntegerTy() && RetTy->getIntegerBitWidth() == 32));
3134   if (RetTy->isFloatTy()) {
3135     llvm::Value *T0 = Builder.CreateBitCast(Src, Builder.getIntNTy(32));
3136     llvm::Value *T1 = Builder.CreateAnd(T0, 0xffff, "cmse.clear");
3137     return Builder.CreateBitCast(T1, RetTy);
3138   }
3139   return Builder.CreateAnd(Src, 0xffff, "cmse.clear");
3140 }
3141
3142 void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
3143                                          bool EmitRetDbgLoc,
3144                                          SourceLocation EndLoc) {
3145   if (FI.isNoReturn()) {
3146     // Noreturn functions don't return.
3147     EmitUnreachable(EndLoc);
3148     return;
3149   }
3150
3151   if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) {
3152     // Naked functions don't have epilogues.
3153     Builder.CreateUnreachable();
3154     return;
3155   }
3156
3157   // Functions with no result always return void.
3158   if (!ReturnValue.isValid()) {
3159     Builder.CreateRetVoid();
3160     return;
3161   }
3162
3163   llvm::DebugLoc RetDbgLoc;
3164   llvm::Value *RV = nullptr;
3165   QualType RetTy = FI.getReturnType();
3166   const ABIArgInfo &RetAI = FI.getReturnInfo();
3167
3168   switch (RetAI.getKind()) {
3169   case ABIArgInfo::InAlloca:
3170     // Aggregrates get evaluated directly into the destination.  Sometimes we
3171     // need to return the sret value in a register, though.
3172     assert(hasAggregateEvaluationKind(RetTy));
3173     if (RetAI.getInAllocaSRet()) {
3174       llvm::Function::arg_iterator EI = CurFn->arg_end();
3175       --EI;
3176       llvm::Value *ArgStruct = &*EI;
3177       llvm::Value *SRet = Builder.CreateStructGEP(
3178           nullptr, ArgStruct, RetAI.getInAllocaFieldIndex());
3179       RV = Builder.CreateAlignedLoad(SRet, getPointerAlign(), "sret");
3180     }
3181     break;
3182
3183   case ABIArgInfo::Indirect: {
3184     auto AI = CurFn->arg_begin();
3185     if (RetAI.isSRetAfterThis())
3186       ++AI;
3187     switch (getEvaluationKind(RetTy)) {
3188     case TEK_Complex: {
3189       ComplexPairTy RT =
3190         EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc);
3191       EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),
3192                          /*isInit*/ true);
3193       break;
3194     }
3195     case TEK_Aggregate:
3196       // Do nothing; aggregrates get evaluated directly into the destination.
3197       break;
3198     case TEK_Scalar:
3199       EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
3200                         MakeNaturalAlignAddrLValue(&*AI, RetTy),
3201                         /*isInit*/ true);
3202       break;
3203     }
3204     break;
3205   }
3206
3207   case ABIArgInfo::Extend:
3208   case ABIArgInfo::Direct:
3209     if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
3210         RetAI.getDirectOffset() == 0) {
3211       // The internal return value temp always will have pointer-to-return-type
3212       // type, just do a load.
3213
3214       // If there is a dominating store to ReturnValue, we can elide
3215       // the load, zap the store, and usually zap the alloca.
3216       if (llvm::StoreInst *SI =
3217               findDominatingStoreToReturnValue(*this)) {
3218         // Reuse the debug location from the store unless there is
3219         // cleanup code to be emitted between the store and return
3220         // instruction.
3221         if (EmitRetDbgLoc && !AutoreleaseResult)
3222           RetDbgLoc = SI->getDebugLoc();
3223         // Get the stored value and nuke the now-dead store.
3224         RV = SI->getValueOperand();
3225         SI->eraseFromParent();
3226
3227       // Otherwise, we have to do a simple load.
3228       } else {
3229         RV = Builder.CreateLoad(ReturnValue);
3230       }
3231     } else {
3232       // If the value is offset in memory, apply the offset now.
3233       Address V = emitAddressAtOffset(*this, ReturnValue, RetAI);
3234
3235       RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
3236     }
3237
3238     // In ARC, end functions that return a retainable type with a call
3239     // to objc_autoreleaseReturnValue.
3240     if (AutoreleaseResult) {
3241 #ifndef NDEBUG
3242       // Type::isObjCRetainabletype has to be called on a QualType that hasn't
3243       // been stripped of the typedefs, so we cannot use RetTy here. Get the
3244       // original return type of FunctionDecl, CurCodeDecl, and BlockDecl from
3245       // CurCodeDecl or BlockInfo.
3246       QualType RT;
3247
3248       if (auto *FD = dyn_cast<FunctionDecl>(CurCodeDecl))
3249         RT = FD->getReturnType();
3250       else if (auto *MD = dyn_cast<ObjCMethodDecl>(CurCodeDecl))
3251         RT = MD->getReturnType();
3252       else if (isa<BlockDecl>(CurCodeDecl))
3253         RT = BlockInfo->BlockExpression->getFunctionType()->getReturnType();
3254       else
3255         llvm_unreachable("Unexpected function/method type");
3256
3257       assert(getLangOpts().ObjCAutoRefCount &&
3258              !FI.isReturnsRetained() &&
3259              RT->isObjCRetainableType());
3260 #endif
3261       RV = emitAutoreleaseOfResult(*this, RV);
3262     }
3263
3264     break;
3265
3266   case ABIArgInfo::Ignore:
3267     break;
3268
3269   case ABIArgInfo::CoerceAndExpand: {
3270     auto coercionType = RetAI.getCoerceAndExpandType();
3271
3272     // Load all of the coerced elements out into results.
3273     llvm::SmallVector<llvm::Value*, 4> results;
3274     Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType);
3275     for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
3276       auto coercedEltType = coercionType->getElementType(i);
3277       if (ABIArgInfo::isPaddingForCoerceAndExpand(coercedEltType))
3278         continue;
3279
3280       auto eltAddr = Builder.CreateStructGEP(addr, i);
3281       auto elt = Builder.CreateLoad(eltAddr);
3282       results.push_back(elt);
3283     }
3284
3285     // If we have one result, it's the single direct result type.
3286     if (results.size() == 1) {
3287       RV = results[0];
3288
3289     // Otherwise, we need to make a first-class aggregate.
3290     } else {
3291       // Construct a return type that lacks padding elements.
3292       llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType();
3293
3294       RV = llvm::UndefValue::get(returnType);
3295       for (unsigned i = 0, e = results.size(); i != e; ++i) {
3296         RV = Builder.CreateInsertValue(RV, results[i], i);
3297       }
3298     }
3299     break;
3300   }
3301
3302   case ABIArgInfo::Expand:
3303     llvm_unreachable("Invalid ABI kind for return argument");
3304   }
3305
3306   llvm::Instruction *Ret;
3307   if (RV) {
3308     if (CurFuncDecl && CurFuncDecl->hasAttr<CmseNSEntryAttr>()) {
3309       // For certain return types, clear padding bits, as they may reveal
3310       // sensitive information.
3311       const Type *RTy = RetTy.getCanonicalType().getTypePtr();
3312       if (RTy->isFloat16Type() || RTy->isHalfType()) {
3313         // 16-bit floating-point types are passed in a 32-bit integer or float,
3314         // with unspecified upper bits.
3315         RV = EmitCMSEClearFP16(RV);
3316       } else {
3317         // Small struct/union types are passed as integers.
3318         auto *ITy = dyn_cast<llvm::IntegerType>(RV->getType());
3319         if (ITy != nullptr && isa<RecordType>(RetTy.getCanonicalType()))
3320           RV = EmitCMSEClearRecord(RV, ITy, RetTy);
3321       }
3322     }
3323     EmitReturnValueCheck(RV);
3324     Ret = Builder.CreateRet(RV);
3325   } else {
3326     Ret = Builder.CreateRetVoid();
3327   }
3328
3329   if (RetDbgLoc)
3330     Ret->setDebugLoc(std::move(RetDbgLoc));
3331 }
3332
3333 void CodeGenFunction::EmitReturnValueCheck(llvm::Value *RV) {
3334   // A current decl may not be available when emitting vtable thunks.
3335   if (!CurCodeDecl)
3336     return;
3337
3338   // If the return block isn't reachable, neither is this check, so don't emit
3339   // it.
3340   if (ReturnBlock.isValid() && ReturnBlock.getBlock()->use_empty())
3341     return;
3342
3343   ReturnsNonNullAttr *RetNNAttr = nullptr;
3344   if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute))
3345     RetNNAttr = CurCodeDecl->getAttr<ReturnsNonNullAttr>();
3346
3347   if (!RetNNAttr && !requiresReturnValueNullabilityCheck())
3348     return;
3349
3350   // Prefer the returns_nonnull attribute if it's present.
3351   SourceLocation AttrLoc;
3352   SanitizerMask CheckKind;
3353   SanitizerHandler Handler;
3354   if (RetNNAttr) {
3355     assert(!requiresReturnValueNullabilityCheck() &&
3356            "Cannot check nullability and the nonnull attribute");
3357     AttrLoc = RetNNAttr->getLocation();
3358     CheckKind = SanitizerKind::ReturnsNonnullAttribute;
3359     Handler = SanitizerHandler::NonnullReturn;
3360   } else {
3361     if (auto *DD = dyn_cast<DeclaratorDecl>(CurCodeDecl))
3362       if (auto *TSI = DD->getTypeSourceInfo())
3363         if (auto FTL = TSI->getTypeLoc().getAsAdjusted<FunctionTypeLoc>())
3364           AttrLoc = FTL.getReturnLoc().findNullabilityLoc();
3365     CheckKind = SanitizerKind::NullabilityReturn;
3366     Handler = SanitizerHandler::NullabilityReturn;
3367   }
3368
3369   SanitizerScope SanScope(this);
3370
3371   // Make sure the "return" source location is valid. If we're checking a
3372   // nullability annotation, make sure the preconditions for the check are met.
3373   llvm::BasicBlock *Check = createBasicBlock("nullcheck");
3374   llvm::BasicBlock *NoCheck = createBasicBlock("no.nullcheck");
3375   llvm::Value *SLocPtr = Builder.CreateLoad(ReturnLocation, "return.sloc.load");
3376   llvm::Value *CanNullCheck = Builder.CreateIsNotNull(SLocPtr);
3377   if (requiresReturnValueNullabilityCheck())
3378     CanNullCheck =
3379         Builder.CreateAnd(CanNullCheck, RetValNullabilityPrecondition);
3380   Builder.CreateCondBr(CanNullCheck, Check, NoCheck);
3381   EmitBlock(Check);
3382
3383   // Now do the null check.
3384   llvm::Value *Cond = Builder.CreateIsNotNull(RV);
3385   llvm::Constant *StaticData[] = {EmitCheckSourceLocation(AttrLoc)};
3386   llvm::Value *DynamicData[] = {SLocPtr};
3387   EmitCheck(std::make_pair(Cond, CheckKind), Handler, StaticData, DynamicData);
3388
3389   EmitBlock(NoCheck);
3390
3391 #ifndef NDEBUG
3392   // The return location should not be used after the check has been emitted.
3393   ReturnLocation = Address::invalid();
3394 #endif
3395 }
3396
3397 static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) {
3398   const CXXRecordDecl *RD = type->getAsCXXRecordDecl();
3399   return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory;
3400 }
3401
3402 static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF,
3403                                           QualType Ty) {
3404   // FIXME: Generate IR in one pass, rather than going back and fixing up these
3405   // placeholders.
3406   llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty);
3407   llvm::Type *IRPtrTy = IRTy->getPointerTo();
3408   llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo());
3409
3410   // FIXME: When we generate this IR in one pass, we shouldn't need
3411   // this win32-specific alignment hack.
3412   CharUnits Align = CharUnits::fromQuantity(4);
3413   Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align);
3414
3415   return AggValueSlot::forAddr(Address(Placeholder, Align),
3416                                Ty.getQualifiers(),
3417                                AggValueSlot::IsNotDestructed,
3418                                AggValueSlot::DoesNotNeedGCBarriers,
3419                                AggValueSlot::IsNotAliased,
3420                                AggValueSlot::DoesNotOverlap);
3421 }
3422
3423 void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
3424                                           const VarDecl *param,
3425                                           SourceLocation loc) {
3426   // StartFunction converted the ABI-lowered parameter(s) into a
3427   // local alloca.  We need to turn that into an r-value suitable
3428   // for EmitCall.
3429   Address local = GetAddrOfLocalVar(param);
3430
3431   QualType type = param->getType();
3432
3433   if (isInAllocaArgument(CGM.getCXXABI(), type)) {
3434     CGM.ErrorUnsupported(param, "forwarded non-trivially copyable parameter");
3435   }
3436
3437   // GetAddrOfLocalVar returns a pointer-to-pointer for references,
3438   // but the argument needs to be the original pointer.
3439   if (type->isReferenceType()) {
3440     args.add(RValue::get(Builder.CreateLoad(local)), type);
3441
3442   // In ARC, move out of consumed arguments so that the release cleanup
3443   // entered by StartFunction doesn't cause an over-release.  This isn't
3444   // optimal -O0 code generation, but it should get cleaned up when
3445   // optimization is enabled.  This also assumes that delegate calls are
3446   // performed exactly once for a set of arguments, but that should be safe.
3447   } else if (getLangOpts().ObjCAutoRefCount &&
3448              param->hasAttr<NSConsumedAttr>() &&
3449              type->isObjCRetainableType()) {
3450     llvm::Value *ptr = Builder.CreateLoad(local);
3451     auto null =
3452       llvm::ConstantPointerNull::get(cast<llvm::PointerType>(ptr->getType()));
3453     Builder.CreateStore(null, local);
3454     args.add(RValue::get(ptr), type);
3455
3456   // For the most part, we just need to load the alloca, except that
3457   // aggregate r-values are actually pointers to temporaries.
3458   } else {
3459     args.add(convertTempToRValue(local, type, loc), type);
3460   }
3461
3462   // Deactivate the cleanup for the callee-destructed param that was pushed.
3463   if (hasAggregateEvaluationKind(type) && !CurFuncIsThunk &&
3464       type->castAs<RecordType>()->getDecl()->isParamDestroyedInCallee() &&
3465       param->needsDestruction(getContext())) {
3466     EHScopeStack::stable_iterator cleanup =
3467         CalleeDestructedParamCleanups.lookup(cast<ParmVarDecl>(param));
3468     assert(cleanup.isValid() &&
3469            "cleanup for callee-destructed param not recorded");
3470     // This unreachable is a temporary marker which will be removed later.
3471     llvm::Instruction *isActive = Builder.CreateUnreachable();
3472     args.addArgCleanupDeactivation(cleanup, isActive);
3473   }
3474 }
3475
3476 static bool isProvablyNull(llvm::Value *addr) {
3477   return isa<llvm::ConstantPointerNull>(addr);
3478 }
3479
3480 /// Emit the actual writing-back of a writeback.
3481 static void emitWriteback(CodeGenFunction &CGF,
3482                           const CallArgList::Writeback &writeback) {
3483   const LValue &srcLV = writeback.Source;
3484   Address srcAddr = srcLV.getAddress(CGF);
3485   assert(!isProvablyNull(srcAddr.getPointer()) &&
3486          "shouldn't have writeback for provably null argument");
3487
3488   llvm::BasicBlock *contBB = nullptr;
3489
3490   // If the argument wasn't provably non-null, we need to null check
3491   // before doing the store.
3492   bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(),
3493                                               CGF.CGM.getDataLayout());
3494   if (!provablyNonNull) {
3495     llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
3496     contBB = CGF.createBasicBlock("icr.done");
3497
3498     llvm::Value *isNull =
3499       CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
3500     CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
3501     CGF.EmitBlock(writebackBB);
3502   }
3503
3504   // Load the value to writeback.
3505   llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
3506
3507   // Cast it back, in case we're writing an id to a Foo* or something.
3508   value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(),
3509                                     "icr.writeback-cast");
3510
3511   // Perform the writeback.
3512
3513   // If we have a "to use" value, it's something we need to emit a use
3514   // of.  This has to be carefully threaded in: if it's done after the
3515   // release it's potentially undefined behavior (and the optimizer
3516   // will ignore it), and if it happens before the retain then the
3517   // optimizer could move the release there.
3518   if (writeback.ToUse) {
3519     assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong);
3520
3521     // Retain the new value.  No need to block-copy here:  the block's
3522     // being passed up the stack.
3523     value = CGF.EmitARCRetainNonBlock(value);
3524
3525     // Emit the intrinsic use here.
3526     CGF.EmitARCIntrinsicUse(writeback.ToUse);
3527
3528     // Load the old value (primitively).
3529     llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation());
3530
3531     // Put the new value in place (primitively).
3532     CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
3533
3534     // Release the old value.
3535     CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
3536
3537   // Otherwise, we can just do a normal lvalue store.
3538   } else {
3539     CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
3540   }
3541
3542   // Jump to the continuation block.
3543   if (!provablyNonNull)
3544     CGF.EmitBlock(contBB);
3545 }
3546
3547 static void emitWritebacks(CodeGenFunction &CGF,
3548                            const CallArgList &args) {
3549   for (const auto &I : args.writebacks())
3550     emitWriteback(CGF, I);
3551 }
3552
3553 static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF,
3554                                             const CallArgList &CallArgs) {
3555   ArrayRef<CallArgList::CallArgCleanup> Cleanups =
3556     CallArgs.getCleanupsToDeactivate();
3557   // Iterate in reverse to increase the likelihood of popping the cleanup.
3558   for (const auto &I : llvm::reverse(Cleanups)) {
3559     CGF.DeactivateCleanupBlock(I.Cleanup, I.IsActiveIP);
3560     I.IsActiveIP->eraseFromParent();
3561   }
3562 }
3563
3564 static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
3565   if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens()))
3566     if (uop->getOpcode() == UO_AddrOf)
3567       return uop->getSubExpr();
3568   return nullptr;
3569 }
3570
3571 /// Emit an argument that's being passed call-by-writeback.  That is,
3572 /// we are passing the address of an __autoreleased temporary; it
3573 /// might be copy-initialized with the current value of the given
3574 /// address, but it will definitely be copied out of after the call.
3575 static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
3576                              const ObjCIndirectCopyRestoreExpr *CRE) {
3577   LValue srcLV;
3578
3579   // Make an optimistic effort to emit the address as an l-value.
3580   // This can fail if the argument expression is more complicated.
3581   if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
3582     srcLV = CGF.EmitLValue(lvExpr);
3583
3584   // Otherwise, just emit it as a scalar.
3585   } else {
3586     Address srcAddr = CGF.EmitPointerWithAlignment(CRE->getSubExpr());
3587
3588  &