clang  10.0.0git
CGCall.cpp
Go to the documentation of this file.
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 "CodeGenFunction.h"
20 #include "CodeGenModule.h"
21 #include "TargetInfo.h"
22 #include "clang/AST/Attr.h"
23 #include "clang/AST/Decl.h"
24 #include "clang/AST/DeclCXX.h"
25 #include "clang/AST/DeclObjC.h"
28 #include "clang/Basic/TargetInfo.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/Analysis/ValueTracking.h"
33 #include "llvm/IR/Attributes.h"
34 #include "llvm/IR/CallingConv.h"
35 #include "llvm/IR/DataLayout.h"
36 #include "llvm/IR/InlineAsm.h"
37 #include "llvm/IR/IntrinsicInst.h"
38 #include "llvm/IR/Intrinsics.h"
39 #include "llvm/Transforms/Utils/Local.h"
40 using namespace clang;
41 using namespace CodeGen;
42 
43 /***/
44 
46  switch (CC) {
47  default: return llvm::CallingConv::C;
48  case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
49  case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
50  case CC_X86RegCall: return llvm::CallingConv::X86_RegCall;
51  case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
52  case CC_Win64: return llvm::CallingConv::Win64;
53  case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV;
54  case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
55  case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
56  case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;
57  // TODO: Add support for __pascal to LLVM.
59  // TODO: Add support for __vectorcall to LLVM.
60  case CC_X86VectorCall: return llvm::CallingConv::X86_VectorCall;
61  case CC_AArch64VectorCall: return llvm::CallingConv::AArch64_VectorCall;
62  case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC;
64  case CC_PreserveMost: return llvm::CallingConv::PreserveMost;
65  case CC_PreserveAll: return llvm::CallingConv::PreserveAll;
66  case CC_Swift: return llvm::CallingConv::Swift;
67  }
68 }
69 
70 /// Derives the 'this' type for codegen purposes, i.e. ignoring method CVR
71 /// qualification. Either or both of RD and MD may be null. A null RD indicates
72 /// that there is no meaningful 'this' type, and a null MD can occur when
73 /// calling a method pointer.
75  const CXXMethodDecl *MD) {
76  QualType RecTy;
77  if (RD)
78  RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
79  else
80  RecTy = Context.VoidTy;
81 
82  if (MD)
83  RecTy = Context.getAddrSpaceQualType(RecTy, MD->getMethodQualifiers().getAddressSpace());
84  return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
85 }
86 
87 /// Returns the canonical formal type of the given C++ method.
89  return MD->getType()->getCanonicalTypeUnqualified()
91 }
92 
93 /// Returns the "extra-canonicalized" return type, which discards
94 /// qualifiers on the return type. Codegen doesn't care about them,
95 /// and it makes ABI code a little easier to be able to assume that
96 /// all parameter and return types are top-level unqualified.
99 }
100 
101 /// Arrange the argument and result information for a value of the given
102 /// unprototyped freestanding function type.
103 const CGFunctionInfo &
105  // When translating an unprototyped function type, always use a
106  // variadic type.
107  return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(),
108  /*instanceMethod=*/false,
109  /*chainCall=*/false, None,
110  FTNP->getExtInfo(), {}, RequiredArgs(0));
111 }
112 
115  const FunctionProtoType *proto,
116  unsigned prefixArgs,
117  unsigned totalArgs) {
118  assert(proto->hasExtParameterInfos());
119  assert(paramInfos.size() <= prefixArgs);
120  assert(proto->getNumParams() + prefixArgs <= totalArgs);
121 
122  paramInfos.reserve(totalArgs);
123 
124  // Add default infos for any prefix args that don't already have infos.
125  paramInfos.resize(prefixArgs);
126 
127  // Add infos for the prototype.
128  for (const auto &ParamInfo : proto->getExtParameterInfos()) {
129  paramInfos.push_back(ParamInfo);
130  // pass_object_size params have no parameter info.
131  if (ParamInfo.hasPassObjectSize())
132  paramInfos.emplace_back();
133  }
134 
135  assert(paramInfos.size() <= totalArgs &&
136  "Did we forget to insert pass_object_size args?");
137  // Add default infos for the variadic and/or suffix arguments.
138  paramInfos.resize(totalArgs);
139 }
140 
141 /// Adds the formal parameters in FPT to the given prefix. If any parameter in
142 /// FPT has pass_object_size attrs, then we'll add parameters for those, too.
143 static void appendParameterTypes(const CodeGenTypes &CGT,
147  // Fast path: don't touch param info if we don't need to.
148  if (!FPT->hasExtParameterInfos()) {
149  assert(paramInfos.empty() &&
150  "We have paramInfos, but the prototype doesn't?");
151  prefix.append(FPT->param_type_begin(), FPT->param_type_end());
152  return;
153  }
154 
155  unsigned PrefixSize = prefix.size();
156  // In the vast majority of cases, we'll have precisely FPT->getNumParams()
157  // parameters; the only thing that can change this is the presence of
158  // pass_object_size. So, we preallocate for the common case.
159  prefix.reserve(prefix.size() + FPT->getNumParams());
160 
161  auto ExtInfos = FPT->getExtParameterInfos();
162  assert(ExtInfos.size() == FPT->getNumParams());
163  for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) {
164  prefix.push_back(FPT->getParamType(I));
165  if (ExtInfos[I].hasPassObjectSize())
166  prefix.push_back(CGT.getContext().getSizeType());
167  }
168 
169  addExtParameterInfosForCall(paramInfos, FPT.getTypePtr(), PrefixSize,
170  prefix.size());
171 }
172 
173 /// Arrange the LLVM function layout for a value of the given function
174 /// type, on top of any implicit parameters already stored.
175 static const CGFunctionInfo &
176 arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
180  RequiredArgs Required = RequiredArgs::forPrototypePlus(FTP, prefix.size());
181  // FIXME: Kill copy.
182  appendParameterTypes(CGT, prefix, paramInfos, FTP);
183  CanQualType resultType = FTP->getReturnType().getUnqualifiedType();
184 
185  return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod,
186  /*chainCall=*/false, prefix,
187  FTP->getExtInfo(), paramInfos,
188  Required);
189 }
190 
191 /// Arrange the argument and result information for a value of the
192 /// given freestanding function type.
193 const CGFunctionInfo &
196  return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes,
197  FTP);
198 }
199 
200 static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) {
201  // Set the appropriate calling convention for the Function.
202  if (D->hasAttr<StdCallAttr>())
203  return CC_X86StdCall;
204 
205  if (D->hasAttr<FastCallAttr>())
206  return CC_X86FastCall;
207 
208  if (D->hasAttr<RegCallAttr>())
209  return CC_X86RegCall;
210 
211  if (D->hasAttr<ThisCallAttr>())
212  return CC_X86ThisCall;
213 
214  if (D->hasAttr<VectorCallAttr>())
215  return CC_X86VectorCall;
216 
217  if (D->hasAttr<PascalAttr>())
218  return CC_X86Pascal;
219 
220  if (PcsAttr *PCS = D->getAttr<PcsAttr>())
221  return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
222 
223  if (D->hasAttr<AArch64VectorPcsAttr>())
224  return CC_AArch64VectorCall;
225 
226  if (D->hasAttr<IntelOclBiccAttr>())
227  return CC_IntelOclBicc;
228 
229  if (D->hasAttr<MSABIAttr>())
230  return IsWindows ? CC_C : CC_Win64;
231 
232  if (D->hasAttr<SysVABIAttr>())
233  return IsWindows ? CC_X86_64SysV : CC_C;
234 
235  if (D->hasAttr<PreserveMostAttr>())
236  return CC_PreserveMost;
237 
238  if (D->hasAttr<PreserveAllAttr>())
239  return CC_PreserveAll;
240 
241  return CC_C;
242 }
243 
244 /// Arrange the argument and result information for a call to an
245 /// unknown C++ non-static member function of the given abstract type.
246 /// (A null RD means we don't have any meaningful "this" argument type,
247 /// so fall back to a generic pointer type).
248 /// The member function must be an ordinary function, i.e. not a
249 /// constructor or destructor.
250 const CGFunctionInfo &
252  const FunctionProtoType *FTP,
253  const CXXMethodDecl *MD) {
255 
256  // Add the 'this' pointer.
257  argTypes.push_back(DeriveThisType(RD, MD));
258 
260  *this, true, argTypes,
262 }
263 
264 /// Set calling convention for CUDA/HIP kernel.
266  const FunctionDecl *FD) {
267  if (FD->hasAttr<CUDAGlobalAttr>()) {
268  const FunctionType *FT = FTy->getAs<FunctionType>();
270  FTy = FT->getCanonicalTypeUnqualified();
271  }
272 }
273 
274 /// Arrange the argument and result information for a declaration or
275 /// definition of the given C++ non-static member function. The
276 /// member function must be an ordinary function, i.e. not a
277 /// constructor or destructor.
278 const CGFunctionInfo &
280  assert(!isa<CXXConstructorDecl>(MD) && "wrong method for constructors!");
281  assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!");
282 
283  CanQualType FT = GetFormalType(MD).getAs<Type>();
284  setCUDAKernelCallingConvention(FT, CGM, MD);
285  auto prototype = FT.getAs<FunctionProtoType>();
286 
287  if (MD->isInstance()) {
288  // The abstract case is perfectly fine.
289  const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD);
290  return arrangeCXXMethodType(ThisType, prototype.getTypePtr(), MD);
291  }
292 
293  return arrangeFreeFunctionType(prototype);
294 }
295 
297  const InheritedConstructor &Inherited, CXXCtorType Type) {
298  // Parameters are unnecessary if we're constructing a base class subobject
299  // and the inherited constructor lives in a virtual base.
300  return Type == Ctor_Complete ||
301  !Inherited.getShadowDecl()->constructsVirtualBase() ||
302  !Target.getCXXABI().hasConstructorVariants();
303 }
304 
305 const CGFunctionInfo &
307  auto *MD = cast<CXXMethodDecl>(GD.getDecl());
308 
311  argTypes.push_back(DeriveThisType(MD->getParent(), MD));
312 
313  bool PassParams = true;
314 
315  if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
316  // A base class inheriting constructor doesn't get forwarded arguments
317  // needed to construct a virtual base (or base class thereof).
318  if (auto Inherited = CD->getInheritedConstructor())
319  PassParams = inheritingCtorHasParams(Inherited, GD.getCtorType());
320  }
321 
323 
324  // Add the formal parameters.
325  if (PassParams)
326  appendParameterTypes(*this, argTypes, paramInfos, FTP);
327 
328  CGCXXABI::AddedStructorArgs AddedArgs =
329  TheCXXABI.buildStructorSignature(GD, argTypes);
330  if (!paramInfos.empty()) {
331  // Note: prefix implies after the first param.
332  if (AddedArgs.Prefix)
333  paramInfos.insert(paramInfos.begin() + 1, AddedArgs.Prefix,
335  if (AddedArgs.Suffix)
336  paramInfos.append(AddedArgs.Suffix,
338  }
339 
340  RequiredArgs required =
341  (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size())
343 
344  FunctionType::ExtInfo extInfo = FTP->getExtInfo();
345  CanQualType resultType = TheCXXABI.HasThisReturn(GD)
346  ? argTypes.front()
347  : TheCXXABI.hasMostDerivedReturn(GD)
348  ? CGM.getContext().VoidPtrTy
349  : Context.VoidTy;
350  return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true,
351  /*chainCall=*/false, argTypes, extInfo,
352  paramInfos, required);
353 }
354 
358  for (auto &arg : args)
359  argTypes.push_back(ctx.getCanonicalParamType(arg.Ty));
360  return argTypes;
361 }
362 
366  for (auto &arg : args)
367  argTypes.push_back(ctx.getCanonicalParamType(arg->getType()));
368  return argTypes;
369 }
370 
373  unsigned prefixArgs, unsigned totalArgs) {
375  if (proto->hasExtParameterInfos()) {
376  addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs);
377  }
378  return result;
379 }
380 
381 /// Arrange a call to a C++ method, passing the given arguments.
382 ///
383 /// ExtraPrefixArgs is the number of ABI-specific args passed after the `this`
384 /// parameter.
385 /// ExtraSuffixArgs is the number of ABI-specific args passed at the end of
386 /// args.
387 /// PassProtoArgs indicates whether `args` has args for the parameters in the
388 /// given CXXConstructorDecl.
389 const CGFunctionInfo &
391  const CXXConstructorDecl *D,
392  CXXCtorType CtorKind,
393  unsigned ExtraPrefixArgs,
394  unsigned ExtraSuffixArgs,
395  bool PassProtoArgs) {
396  // FIXME: Kill copy.
398  for (const auto &Arg : args)
399  ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
400 
401  // +1 for implicit this, which should always be args[0].
402  unsigned TotalPrefixArgs = 1 + ExtraPrefixArgs;
403 
405  RequiredArgs Required = PassProtoArgs
407  FPT, TotalPrefixArgs + ExtraSuffixArgs)
409 
410  GlobalDecl GD(D, CtorKind);
411  CanQualType ResultType = TheCXXABI.HasThisReturn(GD)
412  ? ArgTypes.front()
413  : TheCXXABI.hasMostDerivedReturn(GD)
414  ? CGM.getContext().VoidPtrTy
415  : Context.VoidTy;
416 
417  FunctionType::ExtInfo Info = FPT->getExtInfo();
419  // If the prototype args are elided, we should only have ABI-specific args,
420  // which never have param info.
421  if (PassProtoArgs && FPT->hasExtParameterInfos()) {
422  // ABI-specific suffix arguments are treated the same as variadic arguments.
423  addExtParameterInfosForCall(ParamInfos, FPT.getTypePtr(), TotalPrefixArgs,
424  ArgTypes.size());
425  }
426  return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true,
427  /*chainCall=*/false, ArgTypes, Info,
428  ParamInfos, Required);
429 }
430 
431 /// Arrange the argument and result information for the declaration or
432 /// definition of the given function.
433 const CGFunctionInfo &
435  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
436  if (MD->isInstance())
437  return arrangeCXXMethodDeclaration(MD);
438 
440 
441  assert(isa<FunctionType>(FTy));
442  setCUDAKernelCallingConvention(FTy, CGM, FD);
443 
444  // When declaring a function without a prototype, always use a
445  // non-variadic type.
448  noProto->getReturnType(), /*instanceMethod=*/false,
449  /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All);
450  }
451 
453 }
454 
455 /// Arrange the argument and result information for the declaration or
456 /// definition of an Objective-C method.
457 const CGFunctionInfo &
459  // It happens that this is the same as a call with no optional
460  // arguments, except also using the formal 'self' type.
462 }
463 
464 /// Arrange the argument and result information for the function type
465 /// through which to perform a send to the given Objective-C method,
466 /// using the given receiver type. The receiver type is not always
467 /// the 'self' type of the method or even an Objective-C pointer type.
468 /// This is *not* the right method for actually performing such a
469 /// message send, due to the possibility of optional arguments.
470 const CGFunctionInfo &
472  QualType receiverType) {
475  argTys.push_back(Context.getCanonicalParamType(receiverType));
476  argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType()));
477  // FIXME: Kill copy?
478  for (const auto *I : MD->parameters()) {
479  argTys.push_back(Context.getCanonicalParamType(I->getType()));
481  I->hasAttr<NoEscapeAttr>());
482  extParamInfos.push_back(extParamInfo);
483  }
484 
485  FunctionType::ExtInfo einfo;
486  bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows();
487  einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows));
488 
489  if (getContext().getLangOpts().ObjCAutoRefCount &&
490  MD->hasAttr<NSReturnsRetainedAttr>())
491  einfo = einfo.withProducesResult(true);
492 
493  RequiredArgs required =
494  (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
495 
497  GetReturnType(MD->getReturnType()), /*instanceMethod=*/false,
498  /*chainCall=*/false, argTys, einfo, extParamInfos, required);
499 }
500 
501 const CGFunctionInfo &
503  const CallArgList &args) {
504  auto argTypes = getArgTypesForCall(Context, args);
505  FunctionType::ExtInfo einfo;
506 
508  GetReturnType(returnType), /*instanceMethod=*/false,
509  /*chainCall=*/false, argTypes, einfo, {}, RequiredArgs::All);
510 }
511 
512 const CGFunctionInfo &
514  // FIXME: Do we need to handle ObjCMethodDecl?
515  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
516 
517  if (isa<CXXConstructorDecl>(GD.getDecl()) ||
518  isa<CXXDestructorDecl>(GD.getDecl()))
520 
521  return arrangeFunctionDeclaration(FD);
522 }
523 
524 /// Arrange a thunk that takes 'this' as the first parameter followed by
525 /// varargs. Return a void pointer, regardless of the actual return type.
526 /// The body of the thunk will end in a musttail call to a function of the
527 /// correct type, and the caller will bitcast the function to the correct
528 /// prototype.
529 const CGFunctionInfo &
531  assert(MD->isVirtual() && "only methods have thunks");
533  CanQualType ArgTys[] = {DeriveThisType(MD->getParent(), MD)};
534  return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false,
535  /*chainCall=*/false, ArgTys,
536  FTP->getExtInfo(), {}, RequiredArgs(1));
537 }
538 
539 const CGFunctionInfo &
541  CXXCtorType CT) {
542  assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure);
543 
546  const CXXRecordDecl *RD = CD->getParent();
547  ArgTys.push_back(DeriveThisType(RD, CD));
548  if (CT == Ctor_CopyingClosure)
549  ArgTys.push_back(*FTP->param_type_begin());
550  if (RD->getNumVBases() > 0)
551  ArgTys.push_back(Context.IntTy);
553  /*IsVariadic=*/false, /*IsCXXMethod=*/true);
554  return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/true,
555  /*chainCall=*/false, ArgTys,
556  FunctionType::ExtInfo(CC), {},
558 }
559 
560 /// Arrange a call as unto a free function, except possibly with an
561 /// additional number of formal parameters considered required.
562 static const CGFunctionInfo &
564  CodeGenModule &CGM,
565  const CallArgList &args,
566  const FunctionType *fnType,
567  unsigned numExtraRequiredArgs,
568  bool chainCall) {
569  assert(args.size() >= numExtraRequiredArgs);
570 
572 
573  // In most cases, there are no optional arguments.
574  RequiredArgs required = RequiredArgs::All;
575 
576  // If we have a variadic prototype, the required arguments are the
577  // extra prefix plus the arguments in the prototype.
578  if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
579  if (proto->isVariadic())
580  required = RequiredArgs::forPrototypePlus(proto, numExtraRequiredArgs);
581 
582  if (proto->hasExtParameterInfos())
583  addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs,
584  args.size());
585 
586  // If we don't have a prototype at all, but we're supposed to
587  // explicitly use the variadic convention for unprototyped calls,
588  // treat all of the arguments as required but preserve the nominal
589  // possibility of variadics.
590  } else if (CGM.getTargetCodeGenInfo()
591  .isNoProtoCallVariadic(args,
592  cast<FunctionNoProtoType>(fnType))) {
593  required = RequiredArgs(args.size());
594  }
595 
596  // FIXME: Kill copy.
598  for (const auto &arg : args)
599  argTypes.push_back(CGT.getContext().getCanonicalParamType(arg.Ty));
601  /*instanceMethod=*/false, chainCall,
602  argTypes, fnType->getExtInfo(), paramInfos,
603  required);
604 }
605 
606 /// Figure out the rules for calling a function with the given formal
607 /// type using the given arguments. The arguments are necessary
608 /// because the function might be unprototyped, in which case it's
609 /// target-dependent in crazy ways.
610 const CGFunctionInfo &
612  const FunctionType *fnType,
613  bool chainCall) {
614  return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType,
615  chainCall ? 1 : 0, chainCall);
616 }
617 
618 /// A block function is essentially a free function with an
619 /// extra implicit argument.
620 const CGFunctionInfo &
622  const FunctionType *fnType) {
623  return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1,
624  /*chainCall=*/false);
625 }
626 
627 const CGFunctionInfo &
629  const FunctionArgList &params) {
630  auto paramInfos = getExtParameterInfosForCall(proto, 1, params.size());
631  auto argTypes = getArgTypesForDeclaration(Context, params);
632 
634  /*instanceMethod*/ false, /*chainCall*/ false,
635  argTypes, proto->getExtInfo(), paramInfos,
637 }
638 
639 const CGFunctionInfo &
641  const CallArgList &args) {
642  // FIXME: Kill copy.
644  for (const auto &Arg : args)
645  argTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
647  GetReturnType(resultType), /*instanceMethod=*/false,
648  /*chainCall=*/false, argTypes, FunctionType::ExtInfo(),
649  /*paramInfos=*/ {}, RequiredArgs::All);
650 }
651 
652 const CGFunctionInfo &
654  const FunctionArgList &args) {
655  auto argTypes = getArgTypesForDeclaration(Context, args);
656 
658  GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false,
659  argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
660 }
661 
662 const CGFunctionInfo &
664  ArrayRef<CanQualType> argTypes) {
666  resultType, /*instanceMethod=*/false, /*chainCall=*/false,
667  argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
668 }
669 
670 /// Arrange a call to a C++ method, passing the given arguments.
671 ///
672 /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It
673 /// does not count `this`.
674 const CGFunctionInfo &
676  const FunctionProtoType *proto,
677  RequiredArgs required,
678  unsigned numPrefixArgs) {
679  assert(numPrefixArgs + 1 <= args.size() &&
680  "Emitting a call with less args than the required prefix?");
681  // Add one to account for `this`. It's a bit awkward here, but we don't count
682  // `this` in similar places elsewhere.
683  auto paramInfos =
684  getExtParameterInfosForCall(proto, numPrefixArgs + 1, args.size());
685 
686  // FIXME: Kill copy.
687  auto argTypes = getArgTypesForCall(Context, args);
688 
689  FunctionType::ExtInfo info = proto->getExtInfo();
691  GetReturnType(proto->getReturnType()), /*instanceMethod=*/true,
692  /*chainCall=*/false, argTypes, info, paramInfos, required);
693 }
694 
697  getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false,
699 }
700 
701 const CGFunctionInfo &
703  const CallArgList &args) {
704  assert(signature.arg_size() <= args.size());
705  if (signature.arg_size() == args.size())
706  return signature;
707 
709  auto sigParamInfos = signature.getExtParameterInfos();
710  if (!sigParamInfos.empty()) {
711  paramInfos.append(sigParamInfos.begin(), sigParamInfos.end());
712  paramInfos.resize(args.size());
713  }
714 
715  auto argTypes = getArgTypesForCall(Context, args);
716 
717  assert(signature.getRequiredArgs().allowsOptionalArgs());
718  return arrangeLLVMFunctionInfo(signature.getReturnType(),
719  signature.isInstanceMethod(),
720  signature.isChainCall(),
721  argTypes,
722  signature.getExtInfo(),
723  paramInfos,
724  signature.getRequiredArgs());
725 }
726 
727 namespace clang {
728 namespace CodeGen {
730 }
731 }
732 
733 /// Arrange the argument and result information for an abstract value
734 /// of a given function type. This is the method which all of the
735 /// above functions ultimately defer to.
736 const CGFunctionInfo &
738  bool instanceMethod,
739  bool chainCall,
740  ArrayRef<CanQualType> argTypes,
743  RequiredArgs required) {
744  assert(llvm::all_of(argTypes,
745  [](CanQualType T) { return T.isCanonicalAsParam(); }));
746 
747  // Lookup or create unique function info.
748  llvm::FoldingSetNodeID ID;
749  CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos,
750  required, resultType, argTypes);
751 
752  void *insertPos = nullptr;
753  CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
754  if (FI)
755  return *FI;
756 
757  unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
758 
759  // Construct the function info. We co-allocate the ArgInfos.
760  FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info,
761  paramInfos, resultType, argTypes, required);
762  FunctionInfos.InsertNode(FI, insertPos);
763 
764  bool inserted = FunctionsBeingProcessed.insert(FI).second;
765  (void)inserted;
766  assert(inserted && "Recursively being processed?");
767 
768  // Compute ABI information.
769  if (CC == llvm::CallingConv::SPIR_KERNEL) {
770  // Force target independent argument handling for the host visible
771  // kernel functions.
772  computeSPIRKernelABIInfo(CGM, *FI);
773  } else if (info.getCC() == CC_Swift) {
774  swiftcall::computeABIInfo(CGM, *FI);
775  } else {
776  getABIInfo().computeInfo(*FI);
777  }
778 
779  // Loop over all of the computed argument and return value info. If any of
780  // them are direct or extend without a specified coerce type, specify the
781  // default now.
782  ABIArgInfo &retInfo = FI->getReturnInfo();
783  if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr)
784  retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
785 
786  for (auto &I : FI->arguments())
787  if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr)
788  I.info.setCoerceToType(ConvertType(I.type));
789 
790  bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
791  assert(erased && "Not in set?");
792 
793  return *FI;
794 }
795 
797  bool instanceMethod,
798  bool chainCall,
799  const FunctionType::ExtInfo &info,
800  ArrayRef<ExtParameterInfo> paramInfos,
801  CanQualType resultType,
802  ArrayRef<CanQualType> argTypes,
803  RequiredArgs required) {
804  assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
805  assert(!required.allowsOptionalArgs() ||
806  required.getNumRequiredArgs() <= argTypes.size());
807 
808  void *buffer =
809  operator new(totalSizeToAlloc<ArgInfo, ExtParameterInfo>(
810  argTypes.size() + 1, paramInfos.size()));
811 
812  CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
813  FI->CallingConvention = llvmCC;
814  FI->EffectiveCallingConvention = llvmCC;
815  FI->ASTCallingConvention = info.getCC();
816  FI->InstanceMethod = instanceMethod;
817  FI->ChainCall = chainCall;
818  FI->NoReturn = info.getNoReturn();
819  FI->ReturnsRetained = info.getProducesResult();
820  FI->NoCallerSavedRegs = info.getNoCallerSavedRegs();
821  FI->NoCfCheck = info.getNoCfCheck();
822  FI->Required = required;
823  FI->HasRegParm = info.getHasRegParm();
824  FI->RegParm = info.getRegParm();
825  FI->ArgStruct = nullptr;
826  FI->ArgStructAlign = 0;
827  FI->NumArgs = argTypes.size();
828  FI->HasExtParameterInfos = !paramInfos.empty();
829  FI->getArgsBuffer()[0].type = resultType;
830  for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
831  FI->getArgsBuffer()[i + 1].type = argTypes[i];
832  for (unsigned i = 0, e = paramInfos.size(); i != e; ++i)
833  FI->getExtParameterInfosBuffer()[i] = paramInfos[i];
834  return FI;
835 }
836 
837 /***/
838 
839 namespace {
840 // ABIArgInfo::Expand implementation.
841 
842 // Specifies the way QualType passed as ABIArgInfo::Expand is expanded.
843 struct TypeExpansion {
844  enum TypeExpansionKind {
845  // Elements of constant arrays are expanded recursively.
846  TEK_ConstantArray,
847  // Record fields are expanded recursively (but if record is a union, only
848  // the field with the largest size is expanded).
849  TEK_Record,
850  // For complex types, real and imaginary parts are expanded recursively.
851  TEK_Complex,
852  // All other types are not expandable.
853  TEK_None
854  };
855 
856  const TypeExpansionKind Kind;
857 
858  TypeExpansion(TypeExpansionKind K) : Kind(K) {}
859  virtual ~TypeExpansion() {}
860 };
861 
862 struct ConstantArrayExpansion : TypeExpansion {
863  QualType EltTy;
864  uint64_t NumElts;
865 
866  ConstantArrayExpansion(QualType EltTy, uint64_t NumElts)
867  : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}
868  static bool classof(const TypeExpansion *TE) {
869  return TE->Kind == TEK_ConstantArray;
870  }
871 };
872 
873 struct RecordExpansion : TypeExpansion {
875 
877 
878  RecordExpansion(SmallVector<const CXXBaseSpecifier *, 1> &&Bases,
880  : TypeExpansion(TEK_Record), Bases(std::move(Bases)),
881  Fields(std::move(Fields)) {}
882  static bool classof(const TypeExpansion *TE) {
883  return TE->Kind == TEK_Record;
884  }
885 };
886 
887 struct ComplexExpansion : TypeExpansion {
888  QualType EltTy;
889 
890  ComplexExpansion(QualType EltTy) : TypeExpansion(TEK_Complex), EltTy(EltTy) {}
891  static bool classof(const TypeExpansion *TE) {
892  return TE->Kind == TEK_Complex;
893  }
894 };
895 
896 struct NoExpansion : TypeExpansion {
897  NoExpansion() : TypeExpansion(TEK_None) {}
898  static bool classof(const TypeExpansion *TE) {
899  return TE->Kind == TEK_None;
900  }
901 };
902 } // namespace
903 
904 static std::unique_ptr<TypeExpansion>
905 getTypeExpansion(QualType Ty, const ASTContext &Context) {
906  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) {
907  return std::make_unique<ConstantArrayExpansion>(
908  AT->getElementType(), AT->getSize().getZExtValue());
909  }
910  if (const RecordType *RT = Ty->getAs<RecordType>()) {
913  const RecordDecl *RD = RT->getDecl();
914  assert(!RD->hasFlexibleArrayMember() &&
915  "Cannot expand structure with flexible array.");
916  if (RD->isUnion()) {
917  // Unions can be here only in degenerative cases - all the fields are same
918  // after flattening. Thus we have to use the "largest" field.
919  const FieldDecl *LargestFD = nullptr;
920  CharUnits UnionSize = CharUnits::Zero();
921 
922  for (const auto *FD : RD->fields()) {
923  if (FD->isZeroLengthBitField(Context))
924  continue;
925  assert(!FD->isBitField() &&
926  "Cannot expand structure with bit-field members.");
927  CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType());
928  if (UnionSize < FieldSize) {
929  UnionSize = FieldSize;
930  LargestFD = FD;
931  }
932  }
933  if (LargestFD)
934  Fields.push_back(LargestFD);
935  } else {
936  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
937  assert(!CXXRD->isDynamicClass() &&
938  "cannot expand vtable pointers in dynamic classes");
939  for (const CXXBaseSpecifier &BS : CXXRD->bases())
940  Bases.push_back(&BS);
941  }
942 
943  for (const auto *FD : RD->fields()) {
944  if (FD->isZeroLengthBitField(Context))
945  continue;
946  assert(!FD->isBitField() &&
947  "Cannot expand structure with bit-field members.");
948  Fields.push_back(FD);
949  }
950  }
951  return std::make_unique<RecordExpansion>(std::move(Bases),
952  std::move(Fields));
953  }
954  if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
955  return std::make_unique<ComplexExpansion>(CT->getElementType());
956  }
957  return std::make_unique<NoExpansion>();
958 }
959 
960 static int getExpansionSize(QualType Ty, const ASTContext &Context) {
961  auto Exp = getTypeExpansion(Ty, Context);
962  if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
963  return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context);
964  }
965  if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
966  int Res = 0;
967  for (auto BS : RExp->Bases)
968  Res += getExpansionSize(BS->getType(), Context);
969  for (auto FD : RExp->Fields)
970  Res += getExpansionSize(FD->getType(), Context);
971  return Res;
972  }
973  if (isa<ComplexExpansion>(Exp.get()))
974  return 2;
975  assert(isa<NoExpansion>(Exp.get()));
976  return 1;
977 }
978 
979 void
982  auto Exp = getTypeExpansion(Ty, Context);
983  if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
984  for (int i = 0, n = CAExp->NumElts; i < n; i++) {
985  getExpandedTypes(CAExp->EltTy, TI);
986  }
987  } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
988  for (auto BS : RExp->Bases)
989  getExpandedTypes(BS->getType(), TI);
990  for (auto FD : RExp->Fields)
991  getExpandedTypes(FD->getType(), TI);
992  } else if (auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
993  llvm::Type *EltTy = ConvertType(CExp->EltTy);
994  *TI++ = EltTy;
995  *TI++ = EltTy;
996  } else {
997  assert(isa<NoExpansion>(Exp.get()));
998  *TI++ = ConvertType(Ty);
999  }
1000 }
1001 
1003  ConstantArrayExpansion *CAE,
1004  Address BaseAddr,
1005  llvm::function_ref<void(Address)> Fn) {
1006  CharUnits EltSize = CGF.getContext().getTypeSizeInChars(CAE->EltTy);
1007  CharUnits EltAlign =
1008  BaseAddr.getAlignment().alignmentOfArrayElement(EltSize);
1009 
1010  for (int i = 0, n = CAE->NumElts; i < n; i++) {
1011  llvm::Value *EltAddr =
1012  CGF.Builder.CreateConstGEP2_32(nullptr, BaseAddr.getPointer(), 0, i);
1013  Fn(Address(EltAddr, EltAlign));
1014  }
1015 }
1016 
1017 void CodeGenFunction::ExpandTypeFromArgs(
1019  assert(LV.isSimple() &&
1020  "Unexpected non-simple lvalue during struct expansion.");
1021 
1022  auto Exp = getTypeExpansion(Ty, getContext());
1023  if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
1025  *this, CAExp, LV.getAddress(*this), [&](Address EltAddr) {
1026  LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);
1027  ExpandTypeFromArgs(CAExp->EltTy, LV, AI);
1028  });
1029  } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
1030  Address This = LV.getAddress(*this);
1031  for (const CXXBaseSpecifier *BS : RExp->Bases) {
1032  // Perform a single step derived-to-base conversion.
1033  Address Base =
1034  GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
1035  /*NullCheckValue=*/false, SourceLocation());
1036  LValue SubLV = MakeAddrLValue(Base, BS->getType());
1037 
1038  // Recurse onto bases.
1039  ExpandTypeFromArgs(BS->getType(), SubLV, AI);
1040  }
1041  for (auto FD : RExp->Fields) {
1042  // FIXME: What are the right qualifiers here?
1043  LValue SubLV = EmitLValueForFieldInitialization(LV, FD);
1044  ExpandTypeFromArgs(FD->getType(), SubLV, AI);
1045  }
1046  } else if (isa<ComplexExpansion>(Exp.get())) {
1047  auto realValue = *AI++;
1048  auto imagValue = *AI++;
1049  EmitStoreOfComplex(ComplexPairTy(realValue, imagValue), LV, /*init*/ true);
1050  } else {
1051  // Call EmitStoreOfScalar except when the lvalue is a bitfield to emit a
1052  // primitive store.
1053  assert(isa<NoExpansion>(Exp.get()));
1054  if (LV.isBitField())
1055  EmitStoreThroughLValue(RValue::get(*AI++), LV);
1056  else
1057  EmitStoreOfScalar(*AI++, LV);
1058  }
1059 }
1060 
1061 void CodeGenFunction::ExpandTypeToArgs(
1062  QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
1063  SmallVectorImpl<llvm::Value *> &IRCallArgs, unsigned &IRCallArgPos) {
1064  auto Exp = getTypeExpansion(Ty, getContext());
1065  if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
1066  Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this)
1069  *this, CAExp, Addr, [&](Address EltAddr) {
1070  CallArg EltArg = CallArg(
1071  convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation()),
1072  CAExp->EltTy);
1073  ExpandTypeToArgs(CAExp->EltTy, EltArg, IRFuncTy, IRCallArgs,
1074  IRCallArgPos);
1075  });
1076  } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
1077  Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this)
1079  for (const CXXBaseSpecifier *BS : RExp->Bases) {
1080  // Perform a single step derived-to-base conversion.
1081  Address Base =
1082  GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1,
1083  /*NullCheckValue=*/false, SourceLocation());
1084  CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType());
1085 
1086  // Recurse onto bases.
1087  ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs,
1088  IRCallArgPos);
1089  }
1090 
1091  LValue LV = MakeAddrLValue(This, Ty);
1092  for (auto FD : RExp->Fields) {
1093  CallArg FldArg =
1094  CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType());
1095  ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs,
1096  IRCallArgPos);
1097  }
1098  } else if (isa<ComplexExpansion>(Exp.get())) {
1100  IRCallArgs[IRCallArgPos++] = CV.first;
1101  IRCallArgs[IRCallArgPos++] = CV.second;
1102  } else {
1103  assert(isa<NoExpansion>(Exp.get()));
1104  auto RV = Arg.getKnownRValue();
1105  assert(RV.isScalar() &&
1106  "Unexpected non-scalar rvalue during struct expansion.");
1107 
1108  // Insert a bitcast as needed.
1109  llvm::Value *V = RV.getScalarVal();
1110  if (IRCallArgPos < IRFuncTy->getNumParams() &&
1111  V->getType() != IRFuncTy->getParamType(IRCallArgPos))
1112  V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
1113 
1114  IRCallArgs[IRCallArgPos++] = V;
1115  }
1116 }
1117 
1118 /// Create a temporary allocation for the purposes of coercion.
1120  CharUnits MinAlign) {
1121  // Don't use an alignment that's worse than what LLVM would prefer.
1122  auto PrefAlign = CGF.CGM.getDataLayout().getPrefTypeAlignment(Ty);
1123  CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
1124 
1125  return CGF.CreateTempAlloca(Ty, Align);
1126 }
1127 
1128 /// EnterStructPointerForCoercedAccess - Given a struct pointer that we are
1129 /// accessing some number of bytes out of it, try to gep into the struct to get
1130 /// at its inner goodness. Dive as deep as possible without entering an element
1131 /// with an in-memory size smaller than DstSize.
1132 static Address
1134  llvm::StructType *SrcSTy,
1135  uint64_t DstSize, CodeGenFunction &CGF) {
1136  // We can't dive into a zero-element struct.
1137  if (SrcSTy->getNumElements() == 0) return SrcPtr;
1138 
1139  llvm::Type *FirstElt = SrcSTy->getElementType(0);
1140 
1141  // If the first elt is at least as large as what we're looking for, or if the
1142  // first element is the same size as the whole struct, we can enter it. The
1143  // comparison must be made on the store size and not the alloca size. Using
1144  // the alloca size may overstate the size of the load.
1145  uint64_t FirstEltSize =
1146  CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt);
1147  if (FirstEltSize < DstSize &&
1148  FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy))
1149  return SrcPtr;
1150 
1151  // GEP into the first element.
1152  SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, "coerce.dive");
1153 
1154  // If the first element is a struct, recurse.
1155  llvm::Type *SrcTy = SrcPtr.getElementType();
1156  if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
1157  return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
1158 
1159  return SrcPtr;
1160 }
1161 
1162 /// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both
1163 /// are either integers or pointers. This does a truncation of the value if it
1164 /// is too large or a zero extension if it is too small.
1165 ///
1166 /// This behaves as if the value were coerced through memory, so on big-endian
1167 /// targets the high bits are preserved in a truncation, while little-endian
1168 /// targets preserve the low bits.
1170  llvm::Type *Ty,
1171  CodeGenFunction &CGF) {
1172  if (Val->getType() == Ty)
1173  return Val;
1174 
1175  if (isa<llvm::PointerType>(Val->getType())) {
1176  // If this is Pointer->Pointer avoid conversion to and from int.
1177  if (isa<llvm::PointerType>(Ty))
1178  return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
1179 
1180  // Convert the pointer to an integer so we can play with its width.
1181  Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
1182  }
1183 
1184  llvm::Type *DestIntTy = Ty;
1185  if (isa<llvm::PointerType>(DestIntTy))
1186  DestIntTy = CGF.IntPtrTy;
1187 
1188  if (Val->getType() != DestIntTy) {
1189  const llvm::DataLayout &DL = CGF.CGM.getDataLayout();
1190  if (DL.isBigEndian()) {
1191  // Preserve the high bits on big-endian targets.
1192  // That is what memory coercion does.
1193  uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType());
1194  uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy);
1195 
1196  if (SrcSize > DstSize) {
1197  Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits");
1198  Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii");
1199  } else {
1200  Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii");
1201  Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits");
1202  }
1203  } else {
1204  // Little-endian targets preserve the low bits. No shifts required.
1205  Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
1206  }
1207  }
1208 
1209  if (isa<llvm::PointerType>(Ty))
1210  Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
1211  return Val;
1212 }
1213 
1214 
1215 
1216 /// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
1217 /// a pointer to an object of type \arg Ty, known to be aligned to
1218 /// \arg SrcAlign bytes.
1219 ///
1220 /// This safely handles the case when the src type is smaller than the
1221 /// destination type; in this situation the values of bits which not
1222 /// present in the src are undefined.
1224  CodeGenFunction &CGF) {
1225  llvm::Type *SrcTy = Src.getElementType();
1226 
1227  // If SrcTy and Ty are the same, just do a load.
1228  if (SrcTy == Ty)
1229  return CGF.Builder.CreateLoad(Src);
1230 
1231  uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
1232 
1233  if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
1234  Src = EnterStructPointerForCoercedAccess(Src, SrcSTy, DstSize, CGF);
1235  SrcTy = Src.getType()->getElementType();
1236  }
1237 
1238  uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
1239 
1240  // If the source and destination are integer or pointer types, just do an
1241  // extension or truncation to the desired type.
1242  if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
1243  (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
1244  llvm::Value *Load = CGF.Builder.CreateLoad(Src);
1245  return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF);
1246  }
1247 
1248  // If load is legal, just bitcast the src pointer.
1249  if (SrcSize >= DstSize) {
1250  // Generally SrcSize is never greater than DstSize, since this means we are
1251  // losing bits. However, this can happen in cases where the structure has
1252  // additional padding, for example due to a user specified alignment.
1253  //
1254  // FIXME: Assert that we aren't truncating non-padding bits when have access
1255  // to that information.
1256  Src = CGF.Builder.CreateBitCast(Src,
1257  Ty->getPointerTo(Src.getAddressSpace()));
1258  return CGF.Builder.CreateLoad(Src);
1259  }
1260 
1261  // Otherwise do coercion through memory. This is stupid, but simple.
1262  Address Tmp = CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment());
1263  Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1264  Address SrcCasted = CGF.Builder.CreateElementBitCast(Src,CGF.Int8Ty);
1265  CGF.Builder.CreateMemCpy(Casted, SrcCasted,
1266  llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
1267  false);
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?
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.
1297  Address Dst,
1298  bool DstIsVolatile,
1299  CodeGenFunction &CGF) {
1300  llvm::Type *SrcTy = Src->getType();
1301  llvm::Type *DstTy = Dst.getType()->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.getType()->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  Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1351  Address DstCasted = CGF.Builder.CreateElementBitCast(Dst,CGF.Int8Ty);
1352  CGF.Builder.CreateMemCpy(DstCasted, Casted,
1353  llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
1354  false);
1355  }
1356 }
1357 
1359  const ABIArgInfo &info) {
1360  if (unsigned offset = info.getDirectOffset()) {
1361  addr = CGF.Builder.CreateElementBitCast(addr, CGF.Int8Ty);
1362  addr = CGF.Builder.CreateConstInBoundsByteGEP(addr,
1363  CharUnits::fromQuantity(offset));
1364  addr = CGF.Builder.CreateElementBitCast(addr, info.getCoerceToType());
1365  }
1366  return addr;
1367 }
1368 
1369 namespace {
1370 
1371 /// Encapsulates information about the way function arguments from
1372 /// CGFunctionInfo should be passed to actual LLVM IR function.
1373 class ClangToLLVMArgMapping {
1374  static const unsigned InvalidIndex = ~0U;
1375  unsigned InallocaArgNo;
1376  unsigned SRetArgNo;
1377  unsigned TotalIRArgs;
1378 
1379  /// Arguments of LLVM IR function corresponding to single Clang argument.
1380  struct IRArgs {
1381  unsigned PaddingArgIndex;
1382  // Argument is expanded to IR arguments at positions
1383  // [FirstArgIndex, FirstArgIndex + NumberOfArgs).
1384  unsigned FirstArgIndex;
1385  unsigned NumberOfArgs;
1386 
1387  IRArgs()
1388  : PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex),
1389  NumberOfArgs(0) {}
1390  };
1391 
1392  SmallVector<IRArgs, 8> ArgInfo;
1393 
1394 public:
1395  ClangToLLVMArgMapping(const ASTContext &Context, const CGFunctionInfo &FI,
1396  bool OnlyRequiredArgs = false)
1397  : InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0),
1398  ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) {
1399  construct(Context, FI, OnlyRequiredArgs);
1400  }
1401 
1402  bool hasInallocaArg() const { return InallocaArgNo != InvalidIndex; }
1403  unsigned getInallocaArgNo() const {
1404  assert(hasInallocaArg());
1405  return InallocaArgNo;
1406  }
1407 
1408  bool hasSRetArg() const { return SRetArgNo != InvalidIndex; }
1409  unsigned getSRetArgNo() const {
1410  assert(hasSRetArg());
1411  return SRetArgNo;
1412  }
1413 
1414  unsigned totalIRArgs() const { return TotalIRArgs; }
1415 
1416  bool hasPaddingArg(unsigned ArgNo) const {
1417  assert(ArgNo < ArgInfo.size());
1418  return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;
1419  }
1420  unsigned getPaddingArgNo(unsigned ArgNo) const {
1421  assert(hasPaddingArg(ArgNo));
1422  return ArgInfo[ArgNo].PaddingArgIndex;
1423  }
1424 
1425  /// Returns index of first IR argument corresponding to ArgNo, and their
1426  /// quantity.
1427  std::pair<unsigned, unsigned> getIRArgs(unsigned ArgNo) const {
1428  assert(ArgNo < ArgInfo.size());
1429  return std::make_pair(ArgInfo[ArgNo].FirstArgIndex,
1430  ArgInfo[ArgNo].NumberOfArgs);
1431  }
1432 
1433 private:
1434  void construct(const ASTContext &Context, const CGFunctionInfo &FI,
1435  bool OnlyRequiredArgs);
1436 };
1437 
1438 void ClangToLLVMArgMapping::construct(const ASTContext &Context,
1439  const CGFunctionInfo &FI,
1440  bool OnlyRequiredArgs) {
1441  unsigned IRArgNo = 0;
1442  bool SwapThisWithSRet = false;
1443  const ABIArgInfo &RetAI = FI.getReturnInfo();
1444 
1445  if (RetAI.getKind() == ABIArgInfo::Indirect) {
1446  SwapThisWithSRet = RetAI.isSRetAfterThis();
1447  SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++;
1448  }
1449 
1450  unsigned ArgNo = 0;
1451  unsigned NumArgs = OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size();
1452  for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(); ArgNo < NumArgs;
1453  ++I, ++ArgNo) {
1454  assert(I != FI.arg_end());
1455  QualType ArgType = I->type;
1456  const ABIArgInfo &AI = I->info;
1457  // Collect data about IR arguments corresponding to Clang argument ArgNo.
1458  auto &IRArgs = ArgInfo[ArgNo];
1459 
1460  if (AI.getPaddingType())
1461  IRArgs.PaddingArgIndex = IRArgNo++;
1462 
1463  switch (AI.getKind()) {
1464  case ABIArgInfo::Extend:
1465  case ABIArgInfo::Direct: {
1466  // FIXME: handle sseregparm someday...
1467  llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.getCoerceToType());
1468  if (AI.isDirect() && AI.getCanBeFlattened() && STy) {
1469  IRArgs.NumberOfArgs = STy->getNumElements();
1470  } else {
1471  IRArgs.NumberOfArgs = 1;
1472  }
1473  break;
1474  }
1475  case ABIArgInfo::Indirect:
1476  IRArgs.NumberOfArgs = 1;
1477  break;
1478  case ABIArgInfo::Ignore:
1479  case ABIArgInfo::InAlloca:
1480  // ignore and inalloca doesn't have matching LLVM parameters.
1481  IRArgs.NumberOfArgs = 0;
1482  break;
1484  IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size();
1485  break;
1486  case ABIArgInfo::Expand:
1487  IRArgs.NumberOfArgs = getExpansionSize(ArgType, Context);
1488  break;
1489  }
1490 
1491  if (IRArgs.NumberOfArgs > 0) {
1492  IRArgs.FirstArgIndex = IRArgNo;
1493  IRArgNo += IRArgs.NumberOfArgs;
1494  }
1495 
1496  // Skip over the sret parameter when it comes second. We already handled it
1497  // above.
1498  if (IRArgNo == 1 && SwapThisWithSRet)
1499  IRArgNo++;
1500  }
1501  assert(ArgNo == ArgInfo.size());
1502 
1503  if (FI.usesInAlloca())
1504  InallocaArgNo = IRArgNo++;
1505 
1506  TotalIRArgs = IRArgNo;
1507 }
1508 } // namespace
1509 
1510 /***/
1511 
1513  const auto &RI = FI.getReturnInfo();
1514  return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet());
1515 }
1516 
1518  return ReturnTypeUsesSRet(FI) &&
1519  getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs();
1520 }
1521 
1523  if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
1524  switch (BT->getKind()) {
1525  default:
1526  return false;
1527  case BuiltinType::Float:
1529  case BuiltinType::Double:
1531  case BuiltinType::LongDouble:
1533  }
1534  }
1535 
1536  return false;
1537 }
1538 
1540  if (const ComplexType *CT = ResultType->getAs<ComplexType>()) {
1541  if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) {
1542  if (BT->getKind() == BuiltinType::LongDouble)
1544  }
1545  }
1546 
1547  return false;
1548 }
1549 
1551  const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
1552  return GetFunctionType(FI);
1553 }
1554 
1555 llvm::FunctionType *
1557 
1558  bool Inserted = FunctionsBeingProcessed.insert(&FI).second;
1559  (void)Inserted;
1560  assert(Inserted && "Recursively being processed?");
1561 
1562  llvm::Type *resultType = nullptr;
1563  const ABIArgInfo &retAI = FI.getReturnInfo();
1564  switch (retAI.getKind()) {
1565  case ABIArgInfo::Expand:
1566  llvm_unreachable("Invalid ABI kind for return argument");
1567 
1568  case ABIArgInfo::Extend:
1569  case ABIArgInfo::Direct:
1570  resultType = retAI.getCoerceToType();
1571  break;
1572 
1573  case ABIArgInfo::InAlloca:
1574  if (retAI.getInAllocaSRet()) {
1575  // sret things on win32 aren't void, they return the sret pointer.
1576  QualType ret = FI.getReturnType();
1577  llvm::Type *ty = ConvertType(ret);
1578  unsigned addressSpace = Context.getTargetAddressSpace(ret);
1579  resultType = llvm::PointerType::get(ty, addressSpace);
1580  } else {
1581  resultType = llvm::Type::getVoidTy(getLLVMContext());
1582  }
1583  break;
1584 
1585  case ABIArgInfo::Indirect:
1586  case ABIArgInfo::Ignore:
1587  resultType = llvm::Type::getVoidTy(getLLVMContext());
1588  break;
1589 
1591  resultType = retAI.getUnpaddedCoerceAndExpandType();
1592  break;
1593  }
1594 
1595  ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true);
1596  SmallVector<llvm::Type*, 8> ArgTypes(IRFunctionArgs.totalIRArgs());
1597 
1598  // Add type for sret argument.
1599  if (IRFunctionArgs.hasSRetArg()) {
1600  QualType Ret = FI.getReturnType();
1601  llvm::Type *Ty = ConvertType(Ret);
1602  unsigned AddressSpace = Context.getTargetAddressSpace(Ret);
1603  ArgTypes[IRFunctionArgs.getSRetArgNo()] =
1604  llvm::PointerType::get(Ty, AddressSpace);
1605  }
1606 
1607  // Add type for inalloca argument.
1608  if (IRFunctionArgs.hasInallocaArg()) {
1609  auto ArgStruct = FI.getArgStruct();
1610  assert(ArgStruct);
1611  ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo();
1612  }
1613 
1614  // Add in all of the required arguments.
1615  unsigned ArgNo = 0;
1617  ie = it + FI.getNumRequiredArgs();
1618  for (; it != ie; ++it, ++ArgNo) {
1619  const ABIArgInfo &ArgInfo = it->info;
1620 
1621  // Insert a padding type to ensure proper alignment.
1622  if (IRFunctionArgs.hasPaddingArg(ArgNo))
1623  ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
1624  ArgInfo.getPaddingType();
1625 
1626  unsigned FirstIRArg, NumIRArgs;
1627  std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1628 
1629  switch (ArgInfo.getKind()) {
1630  case ABIArgInfo::Ignore:
1631  case ABIArgInfo::InAlloca:
1632  assert(NumIRArgs == 0);
1633  break;
1634 
1635  case ABIArgInfo::Indirect: {
1636  assert(NumIRArgs == 1);
1637  // indirect arguments are always on the stack, which is alloca addr space.
1638  llvm::Type *LTy = ConvertTypeForMem(it->type);
1639  ArgTypes[FirstIRArg] = LTy->getPointerTo(
1640  CGM.getDataLayout().getAllocaAddrSpace());
1641  break;
1642  }
1643 
1644  case ABIArgInfo::Extend:
1645  case ABIArgInfo::Direct: {
1646  // Fast-isel and the optimizer generally like scalar values better than
1647  // FCAs, so we flatten them if this is safe to do for this argument.
1648  llvm::Type *argType = ArgInfo.getCoerceToType();
1649  llvm::StructType *st = dyn_cast<llvm::StructType>(argType);
1650  if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
1651  assert(NumIRArgs == st->getNumElements());
1652  for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
1653  ArgTypes[FirstIRArg + i] = st->getElementType(i);
1654  } else {
1655  assert(NumIRArgs == 1);
1656  ArgTypes[FirstIRArg] = argType;
1657  }
1658  break;
1659  }
1660 
1662  auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1663  for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) {
1664  *ArgTypesIter++ = EltTy;
1665  }
1666  assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1667  break;
1668  }
1669 
1670  case ABIArgInfo::Expand:
1671  auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1672  getExpandedTypes(it->type, ArgTypesIter);
1673  assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1674  break;
1675  }
1676  }
1677 
1678  bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
1679  assert(Erased && "Not in set?");
1680 
1681  return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic());
1682 }
1683 
1685  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1686  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1687 
1688  if (!isFuncTypeConvertible(FPT))
1689  return llvm::StructType::get(getLLVMContext());
1690 
1691  return GetFunctionType(GD);
1692 }
1693 
1695  llvm::AttrBuilder &FuncAttrs,
1696  const FunctionProtoType *FPT) {
1697  if (!FPT)
1698  return;
1699 
1701  FPT->isNothrow())
1702  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1703 }
1704 
1705 void CodeGenModule::ConstructDefaultFnAttrList(StringRef Name, bool HasOptnone,
1706  bool AttrOnCallSite,
1707  llvm::AttrBuilder &FuncAttrs) {
1708  // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed.
1709  if (!HasOptnone) {
1710  if (CodeGenOpts.OptimizeSize)
1711  FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
1712  if (CodeGenOpts.OptimizeSize == 2)
1713  FuncAttrs.addAttribute(llvm::Attribute::MinSize);
1714  }
1715 
1716  if (CodeGenOpts.DisableRedZone)
1717  FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
1718  if (CodeGenOpts.IndirectTlsSegRefs)
1719  FuncAttrs.addAttribute("indirect-tls-seg-refs");
1720  if (CodeGenOpts.NoImplicitFloat)
1721  FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
1722 
1723  if (AttrOnCallSite) {
1724  // Attributes that should go on the call site only.
1725  if (!CodeGenOpts.SimplifyLibCalls ||
1726  CodeGenOpts.isNoBuiltinFunc(Name.data()))
1727  FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
1728  if (!CodeGenOpts.TrapFuncName.empty())
1729  FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName);
1730  } else {
1731  StringRef FpKind;
1732  switch (CodeGenOpts.getFramePointer()) {
1734  FpKind = "none";
1735  break;
1737  FpKind = "non-leaf";
1738  break;
1740  FpKind = "all";
1741  break;
1742  }
1743  FuncAttrs.addAttribute("frame-pointer", FpKind);
1744 
1745  FuncAttrs.addAttribute("less-precise-fpmad",
1746  llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
1747 
1748  if (CodeGenOpts.NullPointerIsValid)
1749  FuncAttrs.addAttribute("null-pointer-is-valid", "true");
1750  if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::Invalid)
1751  FuncAttrs.addAttribute("denormal-fp-math",
1752  llvm::denormalModeName(CodeGenOpts.FPDenormalMode));
1753 
1754  FuncAttrs.addAttribute("no-trapping-math",
1755  llvm::toStringRef(CodeGenOpts.NoTrappingMath));
1756 
1757  // Strict (compliant) code is the default, so only add this attribute to
1758  // indicate that we are trying to workaround a problem case.
1759  if (!CodeGenOpts.StrictFloatCastOverflow)
1760  FuncAttrs.addAttribute("strict-float-cast-overflow", "false");
1761 
1762  // TODO: Are these all needed?
1763  // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
1764  FuncAttrs.addAttribute("no-infs-fp-math",
1765  llvm::toStringRef(CodeGenOpts.NoInfsFPMath));
1766  FuncAttrs.addAttribute("no-nans-fp-math",
1767  llvm::toStringRef(CodeGenOpts.NoNaNsFPMath));
1768  FuncAttrs.addAttribute("unsafe-fp-math",
1769  llvm::toStringRef(CodeGenOpts.UnsafeFPMath));
1770  FuncAttrs.addAttribute("use-soft-float",
1771  llvm::toStringRef(CodeGenOpts.SoftFloat));
1772  FuncAttrs.addAttribute("stack-protector-buffer-size",
1773  llvm::utostr(CodeGenOpts.SSPBufferSize));
1774  FuncAttrs.addAttribute("no-signed-zeros-fp-math",
1775  llvm::toStringRef(CodeGenOpts.NoSignedZeros));
1776  FuncAttrs.addAttribute(
1777  "correctly-rounded-divide-sqrt-fp-math",
1778  llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt));
1779 
1780  if (getLangOpts().OpenCL)
1781  FuncAttrs.addAttribute("denorms-are-zero",
1782  llvm::toStringRef(CodeGenOpts.FlushDenorm));
1783 
1784  // TODO: Reciprocal estimate codegen options should apply to instructions?
1785  const std::vector<std::string> &Recips = CodeGenOpts.Reciprocals;
1786  if (!Recips.empty())
1787  FuncAttrs.addAttribute("reciprocal-estimates",
1788  llvm::join(Recips, ","));
1789 
1790  if (!CodeGenOpts.PreferVectorWidth.empty() &&
1791  CodeGenOpts.PreferVectorWidth != "none")
1792  FuncAttrs.addAttribute("prefer-vector-width",
1793  CodeGenOpts.PreferVectorWidth);
1794 
1795  if (CodeGenOpts.StackRealignment)
1796  FuncAttrs.addAttribute("stackrealign");
1797  if (CodeGenOpts.Backchain)
1798  FuncAttrs.addAttribute("backchain");
1799 
1800  if (CodeGenOpts.SpeculativeLoadHardening)
1801  FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
1802  }
1803 
1804  if (getLangOpts().assumeFunctionsAreConvergent()) {
1805  // Conservatively, mark all functions and calls in CUDA and OpenCL as
1806  // convergent (meaning, they may call an intrinsically convergent op, such
1807  // as __syncthreads() / barrier(), and so can't have certain optimizations
1808  // applied around them). LLVM will remove this attribute where it safely
1809  // can.
1810  FuncAttrs.addAttribute(llvm::Attribute::Convergent);
1811  }
1812 
1813  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
1814  // Exceptions aren't supported in CUDA device code.
1815  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1816 
1817  // Respect -fcuda-flush-denormals-to-zero.
1818  if (CodeGenOpts.FlushDenorm)
1819  FuncAttrs.addAttribute("nvptx-f32ftz", "true");
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::AddDefaultFnAttrs(llvm::Function &F) {
1830  llvm::AttrBuilder FuncAttrs;
1831  ConstructDefaultFnAttrList(F.getName(), F.hasOptNone(),
1832  /* AttrOnCallSite = */ false, FuncAttrs);
1833  F.addAttributes(llvm::AttributeList::FunctionIndex, FuncAttrs);
1834 }
1835 
1837  StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo,
1838  llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite) {
1839  llvm::AttrBuilder FuncAttrs;
1840  llvm::AttrBuilder RetAttrs;
1841 
1842  CallingConv = FI.getEffectiveCallingConvention();
1843  if (FI.isNoReturn())
1844  FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1845 
1846  // If we have information about the function prototype, we can learn
1847  // attributes from there.
1849  CalleeInfo.getCalleeFunctionProtoType());
1850 
1851  const Decl *TargetDecl = CalleeInfo.getCalleeDecl().getDecl();
1852 
1853  bool HasOptnone = false;
1854  // FIXME: handle sseregparm someday...
1855  if (TargetDecl) {
1856  if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
1857  FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
1858  if (TargetDecl->hasAttr<NoThrowAttr>())
1859  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1860  if (TargetDecl->hasAttr<NoReturnAttr>())
1861  FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1862  if (TargetDecl->hasAttr<ColdAttr>())
1863  FuncAttrs.addAttribute(llvm::Attribute::Cold);
1864  if (TargetDecl->hasAttr<NoDuplicateAttr>())
1865  FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate);
1866  if (TargetDecl->hasAttr<ConvergentAttr>())
1867  FuncAttrs.addAttribute(llvm::Attribute::Convergent);
1868 
1869  if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
1871  getContext(), FuncAttrs, Fn->getType()->getAs<FunctionProtoType>());
1872  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
1873  const bool IsVirtualCall = MD && MD->isVirtual();
1874  // Don't use [[noreturn]], _Noreturn or [[no_builtin]] for a call to a
1875  // virtual function. These attributes are not inherited by overloads.
1876  if (!(AttrOnCallSite && IsVirtualCall)) {
1877  if (Fn->isNoReturn())
1878  FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1879 
1880  const auto *NBA = Fn->getAttr<NoBuiltinAttr>();
1881  bool HasWildcard = NBA && llvm::is_contained(NBA->builtinNames(), "*");
1882  if (getLangOpts().NoBuiltin || HasWildcard)
1883  FuncAttrs.addAttribute("no-builtins");
1884  else {
1885  auto AddNoBuiltinAttr = [&FuncAttrs](StringRef BuiltinName) {
1886  SmallString<32> AttributeName;
1887  AttributeName += "no-builtin-";
1888  AttributeName += BuiltinName;
1889  FuncAttrs.addAttribute(AttributeName);
1890  };
1891  llvm::for_each(getLangOpts().NoBuiltinFuncs, AddNoBuiltinAttr);
1892  if (NBA)
1893  llvm::for_each(NBA->builtinNames(), AddNoBuiltinAttr);
1894  }
1895  }
1896  }
1897 
1898  // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
1899  if (TargetDecl->hasAttr<ConstAttr>()) {
1900  FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1901  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1902  } else if (TargetDecl->hasAttr<PureAttr>()) {
1903  FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1904  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1905  } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
1906  FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly);
1907  FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1908  }
1909  if (TargetDecl->hasAttr<RestrictAttr>())
1910  RetAttrs.addAttribute(llvm::Attribute::NoAlias);
1911  if (TargetDecl->hasAttr<ReturnsNonNullAttr>() &&
1912  !CodeGenOpts.NullPointerIsValid)
1913  RetAttrs.addAttribute(llvm::Attribute::NonNull);
1914  if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>())
1915  FuncAttrs.addAttribute("no_caller_saved_registers");
1916  if (TargetDecl->hasAttr<AnyX86NoCfCheckAttr>())
1917  FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck);
1918 
1919  HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>();
1920  if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) {
1921  Optional<unsigned> NumElemsParam;
1922  if (AllocSize->getNumElemsParam().isValid())
1923  NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex();
1924  FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(),
1925  NumElemsParam);
1926  }
1927  }
1928 
1929  ConstructDefaultFnAttrList(Name, HasOptnone, AttrOnCallSite, FuncAttrs);
1930 
1931  // This must run after constructing the default function attribute list
1932  // to ensure that the speculative load hardening attribute is removed
1933  // in the case where the -mspeculative-load-hardening flag was passed.
1934  if (TargetDecl) {
1935  if (TargetDecl->hasAttr<NoSpeculativeLoadHardeningAttr>())
1936  FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening);
1937  if (TargetDecl->hasAttr<SpeculativeLoadHardeningAttr>())
1938  FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
1939  }
1940 
1941  if (CodeGenOpts.EnableSegmentedStacks &&
1942  !(TargetDecl && TargetDecl->hasAttr<NoSplitStackAttr>()))
1943  FuncAttrs.addAttribute("split-stack");
1944 
1945  // Add NonLazyBind attribute to function declarations when -fno-plt
1946  // is used.
1947  if (TargetDecl && CodeGenOpts.NoPLT) {
1948  if (auto *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
1949  if (!Fn->isDefined() && !AttrOnCallSite) {
1950  FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind);
1951  }
1952  }
1953  }
1954 
1955  if (TargetDecl && TargetDecl->hasAttr<OpenCLKernelAttr>()) {
1956  if (getLangOpts().OpenCLVersion <= 120) {
1957  // OpenCL v1.2 Work groups are always uniform
1958  FuncAttrs.addAttribute("uniform-work-group-size", "true");
1959  } else {
1960  // OpenCL v2.0 Work groups may be whether uniform or not.
1961  // '-cl-uniform-work-group-size' compile option gets a hint
1962  // to the compiler that the global work-size be a multiple of
1963  // the work-group size specified to clEnqueueNDRangeKernel
1964  // (i.e. work groups are uniform).
1965  FuncAttrs.addAttribute("uniform-work-group-size",
1966  llvm::toStringRef(CodeGenOpts.UniformWGSize));
1967  }
1968  }
1969 
1970  if (!AttrOnCallSite) {
1971  bool DisableTailCalls = false;
1972 
1973  if (CodeGenOpts.DisableTailCalls)
1974  DisableTailCalls = true;
1975  else if (TargetDecl) {
1976  if (TargetDecl->hasAttr<DisableTailCallsAttr>() ||
1977  TargetDecl->hasAttr<AnyX86InterruptAttr>())
1978  DisableTailCalls = true;
1979  else if (CodeGenOpts.NoEscapingBlockTailCalls) {
1980  if (const auto *BD = dyn_cast<BlockDecl>(TargetDecl))
1981  if (!BD->doesNotEscape())
1982  DisableTailCalls = true;
1983  }
1984  }
1985 
1986  FuncAttrs.addAttribute("disable-tail-calls",
1987  llvm::toStringRef(DisableTailCalls));
1988  GetCPUAndFeaturesAttributes(CalleeInfo.getCalleeDecl(), FuncAttrs);
1989  }
1990 
1991  ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI);
1992 
1993  QualType RetTy = FI.getReturnType();
1994  const ABIArgInfo &RetAI = FI.getReturnInfo();
1995  switch (RetAI.getKind()) {
1996  case ABIArgInfo::Extend:
1997  if (RetAI.isSignExt())
1998  RetAttrs.addAttribute(llvm::Attribute::SExt);
1999  else
2000  RetAttrs.addAttribute(llvm::Attribute::ZExt);
2001  LLVM_FALLTHROUGH;
2002  case ABIArgInfo::Direct:
2003  if (RetAI.getInReg())
2004  RetAttrs.addAttribute(llvm::Attribute::InReg);
2005  break;
2006  case ABIArgInfo::Ignore:
2007  break;
2008 
2009  case ABIArgInfo::InAlloca:
2010  case ABIArgInfo::Indirect: {
2011  // inalloca and sret disable readnone and readonly
2012  FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2013  .removeAttribute(llvm::Attribute::ReadNone);
2014  break;
2015  }
2016 
2018  break;
2019 
2020  case ABIArgInfo::Expand:
2021  llvm_unreachable("Invalid ABI kind for return argument");
2022  }
2023 
2024  if (const auto *RefTy = RetTy->getAs<ReferenceType>()) {
2025  QualType PTy = RefTy->getPointeeType();
2026  if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
2027  RetAttrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy)
2028  .getQuantity());
2029  else if (getContext().getTargetAddressSpace(PTy) == 0 &&
2030  !CodeGenOpts.NullPointerIsValid)
2031  RetAttrs.addAttribute(llvm::Attribute::NonNull);
2032  }
2033 
2034  bool hasUsedSRet = false;
2035  SmallVector<llvm::AttributeSet, 4> ArgAttrs(IRFunctionArgs.totalIRArgs());
2036 
2037  // Attach attributes to sret.
2038  if (IRFunctionArgs.hasSRetArg()) {
2039  llvm::AttrBuilder SRETAttrs;
2040  SRETAttrs.addAttribute(llvm::Attribute::StructRet);
2041  hasUsedSRet = true;
2042  if (RetAI.getInReg())
2043  SRETAttrs.addAttribute(llvm::Attribute::InReg);
2044  ArgAttrs[IRFunctionArgs.getSRetArgNo()] =
2045  llvm::AttributeSet::get(getLLVMContext(), SRETAttrs);
2046  }
2047 
2048  // Attach attributes to inalloca argument.
2049  if (IRFunctionArgs.hasInallocaArg()) {
2050  llvm::AttrBuilder Attrs;
2051  Attrs.addAttribute(llvm::Attribute::InAlloca);
2052  ArgAttrs[IRFunctionArgs.getInallocaArgNo()] =
2053  llvm::AttributeSet::get(getLLVMContext(), Attrs);
2054  }
2055 
2056  unsigned ArgNo = 0;
2058  E = FI.arg_end();
2059  I != E; ++I, ++ArgNo) {
2060  QualType ParamType = I->type;
2061  const ABIArgInfo &AI = I->info;
2062  llvm::AttrBuilder Attrs;
2063 
2064  // Add attribute for padding argument, if necessary.
2065  if (IRFunctionArgs.hasPaddingArg(ArgNo)) {
2066  if (AI.getPaddingInReg()) {
2067  ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
2068  llvm::AttributeSet::get(
2069  getLLVMContext(),
2070  llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg));
2071  }
2072  }
2073 
2074  // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
2075  // have the corresponding parameter variable. It doesn't make
2076  // sense to do it here because parameters are so messed up.
2077  switch (AI.getKind()) {
2078  case ABIArgInfo::Extend:
2079  if (AI.isSignExt())
2080  Attrs.addAttribute(llvm::Attribute::SExt);
2081  else
2082  Attrs.addAttribute(llvm::Attribute::ZExt);
2083  LLVM_FALLTHROUGH;
2084  case ABIArgInfo::Direct:
2085  if (ArgNo == 0 && FI.isChainCall())
2086  Attrs.addAttribute(llvm::Attribute::Nest);
2087  else if (AI.getInReg())
2088  Attrs.addAttribute(llvm::Attribute::InReg);
2089  break;
2090 
2091  case ABIArgInfo::Indirect: {
2092  if (AI.getInReg())
2093  Attrs.addAttribute(llvm::Attribute::InReg);
2094 
2095  if (AI.getIndirectByVal())
2096  Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType));
2097 
2098  CharUnits Align = AI.getIndirectAlign();
2099 
2100  // In a byval argument, it is important that the required
2101  // alignment of the type is honored, as LLVM might be creating a
2102  // *new* stack object, and needs to know what alignment to give
2103  // it. (Sometimes it can deduce a sensible alignment on its own,
2104  // but not if clang decides it must emit a packed struct, or the
2105  // user specifies increased alignment requirements.)
2106  //
2107  // This is different from indirect *not* byval, where the object
2108  // exists already, and the align attribute is purely
2109  // informative.
2110  assert(!Align.isZero());
2111 
2112  // For now, only add this when we have a byval argument.
2113  // TODO: be less lazy about updating test cases.
2114  if (AI.getIndirectByVal())
2115  Attrs.addAlignmentAttr(Align.getQuantity());
2116 
2117  // byval disables readnone and readonly.
2118  FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2119  .removeAttribute(llvm::Attribute::ReadNone);
2120  break;
2121  }
2122  case ABIArgInfo::Ignore:
2123  case ABIArgInfo::Expand:
2125  break;
2126 
2127  case ABIArgInfo::InAlloca:
2128  // inalloca disables readnone and readonly.
2129  FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
2130  .removeAttribute(llvm::Attribute::ReadNone);
2131  continue;
2132  }
2133 
2134  if (const auto *RefTy = ParamType->getAs<ReferenceType>()) {
2135  QualType PTy = RefTy->getPointeeType();
2136  if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
2137  Attrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy)
2138  .getQuantity());
2139  else if (getContext().getTargetAddressSpace(PTy) == 0 &&
2140  !CodeGenOpts.NullPointerIsValid)
2141  Attrs.addAttribute(llvm::Attribute::NonNull);
2142  }
2143 
2144  switch (FI.getExtParameterInfo(ArgNo).getABI()) {
2146  break;
2147 
2149  // Add 'sret' if we haven't already used it for something, but
2150  // only if the result is void.
2151  if (!hasUsedSRet && RetTy->isVoidType()) {
2152  Attrs.addAttribute(llvm::Attribute::StructRet);
2153  hasUsedSRet = true;
2154  }
2155 
2156  // Add 'noalias' in either case.
2157  Attrs.addAttribute(llvm::Attribute::NoAlias);
2158 
2159  // Add 'dereferenceable' and 'alignment'.
2160  auto PTy = ParamType->getPointeeType();
2161  if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) {
2162  auto info = getContext().getTypeInfoInChars(PTy);
2163  Attrs.addDereferenceableAttr(info.first.getQuantity());
2164  Attrs.addAttribute(llvm::Attribute::getWithAlignment(
2165  getLLVMContext(), info.second.getAsAlign()));
2166  }
2167  break;
2168  }
2169 
2171  Attrs.addAttribute(llvm::Attribute::SwiftError);
2172  break;
2173 
2175  Attrs.addAttribute(llvm::Attribute::SwiftSelf);
2176  break;
2177  }
2178 
2179  if (FI.getExtParameterInfo(ArgNo).isNoEscape())
2180  Attrs.addAttribute(llvm::Attribute::NoCapture);
2181 
2182  if (Attrs.hasAttributes()) {
2183  unsigned FirstIRArg, NumIRArgs;
2184  std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
2185  for (unsigned i = 0; i < NumIRArgs; i++)
2186  ArgAttrs[FirstIRArg + i] =
2187  llvm::AttributeSet::get(getLLVMContext(), Attrs);
2188  }
2189  }
2190  assert(ArgNo == FI.arg_size());
2191 
2192  AttrList = llvm::AttributeList::get(
2193  getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), FuncAttrs),
2194  llvm::AttributeSet::get(getLLVMContext(), RetAttrs), ArgAttrs);
2195 }
2196 
2197 /// An argument came in as a promoted argument; demote it back to its
2198 /// declared type.
2200  const VarDecl *var,
2201  llvm::Value *value) {
2202  llvm::Type *varType = CGF.ConvertType(var->getType());
2203 
2204  // This can happen with promotions that actually don't change the
2205  // underlying type, like the enum promotions.
2206  if (value->getType() == varType) return value;
2207 
2208  assert((varType->isIntegerTy() || varType->isFloatingPointTy())
2209  && "unexpected promotion type");
2210 
2211  if (isa<llvm::IntegerType>(varType))
2212  return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
2213 
2214  return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
2215 }
2216 
2217 /// Returns the attribute (either parameter attribute, or function
2218 /// attribute), which declares argument ArgNo to be non-null.
2219 static const NonNullAttr *getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD,
2220  QualType ArgType, unsigned ArgNo) {
2221  // FIXME: __attribute__((nonnull)) can also be applied to:
2222  // - references to pointers, where the pointee is known to be
2223  // nonnull (apparently a Clang extension)
2224  // - transparent unions containing pointers
2225  // In the former case, LLVM IR cannot represent the constraint. In
2226  // the latter case, we have no guarantee that the transparent union
2227  // is in fact passed as a pointer.
2228  if (!ArgType->isAnyPointerType() && !ArgType->isBlockPointerType())
2229  return nullptr;
2230  // First, check attribute on parameter itself.
2231  if (PVD) {
2232  if (auto ParmNNAttr = PVD->getAttr<NonNullAttr>())
2233  return ParmNNAttr;
2234  }
2235  // Check function attributes.
2236  if (!FD)
2237  return nullptr;
2238  for (const auto *NNAttr : FD->specific_attrs<NonNullAttr>()) {
2239  if (NNAttr->isNonNull(ArgNo))
2240  return NNAttr;
2241  }
2242  return nullptr;
2243 }
2244 
2245 namespace {
2246  struct CopyBackSwiftError final : EHScopeStack::Cleanup {
2247  Address Temp;
2248  Address Arg;
2249  CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {}
2250  void Emit(CodeGenFunction &CGF, Flags flags) override {
2251  llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp);
2252  CGF.Builder.CreateStore(errorValue, Arg);
2253  }
2254  };
2255 }
2256 
2258  llvm::Function *Fn,
2259  const FunctionArgList &Args) {
2260  if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>())
2261  // Naked functions don't have prologues.
2262  return;
2263 
2264  // If this is an implicit-return-zero function, go ahead and
2265  // initialize the return value. TODO: it might be nice to have
2266  // a more general mechanism for this that didn't require synthesized
2267  // return statements.
2268  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
2269  if (FD->hasImplicitReturnZero()) {
2270  QualType RetTy = FD->getReturnType().getUnqualifiedType();
2271  llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
2272  llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
2273  Builder.CreateStore(Zero, ReturnValue);
2274  }
2275  }
2276 
2277  // FIXME: We no longer need the types from FunctionArgList; lift up and
2278  // simplify.
2279 
2280  ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI);
2281  // Flattened function arguments.
2283  FnArgs.reserve(IRFunctionArgs.totalIRArgs());
2284  for (auto &Arg : Fn->args()) {
2285  FnArgs.push_back(&Arg);
2286  }
2287  assert(FnArgs.size() == IRFunctionArgs.totalIRArgs());
2288 
2289  // If we're using inalloca, all the memory arguments are GEPs off of the last
2290  // parameter, which is a pointer to the complete memory area.
2291  Address ArgStruct = Address::invalid();
2292  if (IRFunctionArgs.hasInallocaArg()) {
2293  ArgStruct = Address(FnArgs[IRFunctionArgs.getInallocaArgNo()],
2294  FI.getArgStructAlignment());
2295 
2296  assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo());
2297  }
2298 
2299  // Name the struct return parameter.
2300  if (IRFunctionArgs.hasSRetArg()) {
2301  auto AI = cast<llvm::Argument>(FnArgs[IRFunctionArgs.getSRetArgNo()]);
2302  AI->setName("agg.result");
2303  AI->addAttr(llvm::Attribute::NoAlias);
2304  }
2305 
2306  // Track if we received the parameter as a pointer (indirect, byval, or
2307  // inalloca). If already have a pointer, EmitParmDecl doesn't need to copy it
2308  // into a local alloca for us.
2310  ArgVals.reserve(Args.size());
2311 
2312  // Create a pointer value for every parameter declaration. This usually
2313  // entails copying one or more LLVM IR arguments into an alloca. Don't push
2314  // any cleanups or do anything that might unwind. We do that separately, so
2315  // we can push the cleanups in the correct order for the ABI.
2316  assert(FI.arg_size() == Args.size() &&
2317  "Mismatch between function signature & arguments.");
2318  unsigned ArgNo = 0;
2320  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
2321  i != e; ++i, ++info_it, ++ArgNo) {
2322  const VarDecl *Arg = *i;
2323  const ABIArgInfo &ArgI = info_it->info;
2324 
2325  bool isPromoted =
2326  isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
2327  // We are converting from ABIArgInfo type to VarDecl type directly, unless
2328  // the parameter is promoted. In this case we convert to
2329  // CGFunctionInfo::ArgInfo type with subsequent argument demotion.
2330  QualType Ty = isPromoted ? info_it->type : Arg->getType();
2331  assert(hasScalarEvaluationKind(Ty) ==
2332  hasScalarEvaluationKind(Arg->getType()));
2333 
2334  unsigned FirstIRArg, NumIRArgs;
2335  std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
2336 
2337  switch (ArgI.getKind()) {
2338  case ABIArgInfo::InAlloca: {
2339  assert(NumIRArgs == 0);
2340  auto FieldIndex = ArgI.getInAllocaFieldIndex();
2341  Address V =
2342  Builder.CreateStructGEP(ArgStruct, FieldIndex, Arg->getName());
2343  ArgVals.push_back(ParamValue::forIndirect(V));
2344  break;
2345  }
2346 
2347  case ABIArgInfo::Indirect: {
2348  assert(NumIRArgs == 1);
2349  Address ParamAddr = Address(FnArgs[FirstIRArg], ArgI.getIndirectAlign());
2350 
2351  if (!hasScalarEvaluationKind(Ty)) {
2352  // Aggregates and complex variables are accessed by reference. All we
2353  // need to do is realign the value, if requested.
2354  Address V = ParamAddr;
2355  if (ArgI.getIndirectRealign()) {
2356  Address AlignedTemp = CreateMemTemp(Ty, "coerce");
2357 
2358  // Copy from the incoming argument pointer to the temporary with the
2359  // appropriate alignment.
2360  //
2361  // FIXME: We should have a common utility for generating an aggregate
2362  // copy.
2364  auto SizeVal = llvm::ConstantInt::get(IntPtrTy, Size.getQuantity());
2365  Address Dst = Builder.CreateBitCast(AlignedTemp, Int8PtrTy);
2366  Address Src = Builder.CreateBitCast(ParamAddr, Int8PtrTy);
2367  Builder.CreateMemCpy(Dst, Src, SizeVal, false);
2368  V = AlignedTemp;
2369  }
2370  ArgVals.push_back(ParamValue::forIndirect(V));
2371  } else {
2372  // Load scalar value from indirect argument.
2373  llvm::Value *V =
2374  EmitLoadOfScalar(ParamAddr, false, Ty, Arg->getBeginLoc());
2375 
2376  if (isPromoted)
2377  V = emitArgumentDemotion(*this, Arg, V);
2378  ArgVals.push_back(ParamValue::forDirect(V));
2379  }
2380  break;
2381  }
2382 
2383  case ABIArgInfo::Extend:
2384  case ABIArgInfo::Direct: {
2385 
2386  // If we have the trivial case, handle it with no muss and fuss.
2387  if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
2388  ArgI.getCoerceToType() == ConvertType(Ty) &&
2389  ArgI.getDirectOffset() == 0) {
2390  assert(NumIRArgs == 1);
2391  llvm::Value *V = FnArgs[FirstIRArg];
2392  auto AI = cast<llvm::Argument>(V);
2393 
2394  if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {
2395  if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(),
2396  PVD->getFunctionScopeIndex()) &&
2397  !CGM.getCodeGenOpts().NullPointerIsValid)
2398  AI->addAttr(llvm::Attribute::NonNull);
2399 
2400  QualType OTy = PVD->getOriginalType();
2401  if (const auto *ArrTy =
2402  getContext().getAsConstantArrayType(OTy)) {
2403  // A C99 array parameter declaration with the static keyword also
2404  // indicates dereferenceability, and if the size is constant we can
2405  // use the dereferenceable attribute (which requires the size in
2406  // bytes).
2407  if (ArrTy->getSizeModifier() == ArrayType::Static) {
2408  QualType ETy = ArrTy->getElementType();
2409  uint64_t ArrSize = ArrTy->getSize().getZExtValue();
2410  if (!ETy->isIncompleteType() && ETy->isConstantSizeType() &&
2411  ArrSize) {
2412  llvm::AttrBuilder Attrs;
2413  Attrs.addDereferenceableAttr(
2414  getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize);
2415  AI->addAttrs(Attrs);
2416  } else if (getContext().getTargetAddressSpace(ETy) == 0 &&
2417  !CGM.getCodeGenOpts().NullPointerIsValid) {
2418  AI->addAttr(llvm::Attribute::NonNull);
2419  }
2420  }
2421  } else if (const auto *ArrTy =
2422  getContext().getAsVariableArrayType(OTy)) {
2423  // For C99 VLAs with the static keyword, we don't know the size so
2424  // we can't use the dereferenceable attribute, but in addrspace(0)
2425  // we know that it must be nonnull.
2426  if (ArrTy->getSizeModifier() == VariableArrayType::Static &&
2427  !getContext().getTargetAddressSpace(ArrTy->getElementType()) &&
2428  !CGM.getCodeGenOpts().NullPointerIsValid)
2429  AI->addAttr(llvm::Attribute::NonNull);
2430  }
2431 
2432  const auto *AVAttr = PVD->getAttr<AlignValueAttr>();
2433  if (!AVAttr)
2434  if (const auto *TOTy = dyn_cast<TypedefType>(OTy))
2435  AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>();
2436  if (AVAttr && !SanOpts.has(SanitizerKind::Alignment)) {
2437  // If alignment-assumption sanitizer is enabled, we do *not* add
2438  // alignment attribute here, but emit normal alignment assumption,
2439  // so the UBSAN check could function.
2440  llvm::Value *AlignmentValue =
2441  EmitScalarExpr(AVAttr->getAlignment());
2442  llvm::ConstantInt *AlignmentCI =
2443  cast<llvm::ConstantInt>(AlignmentValue);
2444  unsigned Alignment = std::min((unsigned)AlignmentCI->getZExtValue(),
2445  +llvm::Value::MaximumAlignment);
2446  AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment));
2447  }
2448  }
2449 
2450  if (Arg->getType().isRestrictQualified())
2451  AI->addAttr(llvm::Attribute::NoAlias);
2452 
2453  // LLVM expects swifterror parameters to be used in very restricted
2454  // ways. Copy the value into a less-restricted temporary.
2455  if (FI.getExtParameterInfo(ArgNo).getABI()
2457  QualType pointeeTy = Ty->getPointeeType();
2458  assert(pointeeTy->isPointerType());
2459  Address temp =
2460  CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");
2461  Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy));
2462  llvm::Value *incomingErrorValue = Builder.CreateLoad(arg);
2463  Builder.CreateStore(incomingErrorValue, temp);
2464  V = temp.getPointer();
2465 
2466  // Push a cleanup to copy the value back at the end of the function.
2467  // The convention does not guarantee that the value will be written
2468  // back if the function exits with an unwind exception.
2469  EHStack.pushCleanup<CopyBackSwiftError>(NormalCleanup, temp, arg);
2470  }
2471 
2472  // Ensure the argument is the correct type.
2473  if (V->getType() != ArgI.getCoerceToType())
2474  V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
2475 
2476  if (isPromoted)
2477  V = emitArgumentDemotion(*this, Arg, V);
2478 
2479  // Because of merging of function types from multiple decls it is
2480  // possible for the type of an argument to not match the corresponding
2481  // type in the function type. Since we are codegening the callee
2482  // in here, add a cast to the argument type.
2483  llvm::Type *LTy = ConvertType(Arg->getType());
2484  if (V->getType() != LTy)
2485  V = Builder.CreateBitCast(V, LTy);
2486 
2487  ArgVals.push_back(ParamValue::forDirect(V));
2488  break;
2489  }
2490 
2491  Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg),
2492  Arg->getName());
2493 
2494  // Pointer to store into.
2495  Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI);
2496 
2497  // Fast-isel and the optimizer generally like scalar values better than
2498  // FCAs, so we flatten them if this is safe to do for this argument.
2499  llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
2500  if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy &&
2501  STy->getNumElements() > 1) {
2502  uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
2503  llvm::Type *DstTy = Ptr.getElementType();
2504  uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
2505 
2506  Address AddrToStoreInto = Address::invalid();
2507  if (SrcSize <= DstSize) {
2508  AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
2509  } else {
2510  AddrToStoreInto =
2511  CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
2512  }
2513 
2514  assert(STy->getNumElements() == NumIRArgs);
2515  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2516  auto AI = FnArgs[FirstIRArg + i];
2517  AI->setName(Arg->getName() + ".coerce" + Twine(i));
2518  Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
2519  Builder.CreateStore(AI, EltPtr);
2520  }
2521 
2522  if (SrcSize > DstSize) {
2523  Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize);
2524  }
2525 
2526  } else {
2527  // Simple case, just do a coerced store of the argument into the alloca.
2528  assert(NumIRArgs == 1);
2529  auto AI = FnArgs[FirstIRArg];
2530  AI->setName(Arg->getName() + ".coerce");
2531  CreateCoercedStore(AI, Ptr, /*DstIsVolatile=*/false, *this);
2532  }
2533 
2534  // Match to what EmitParmDecl is expecting for this type.
2536  llvm::Value *V =
2537  EmitLoadOfScalar(Alloca, false, Ty, Arg->getBeginLoc());
2538  if (isPromoted)
2539  V = emitArgumentDemotion(*this, Arg, V);
2540  ArgVals.push_back(ParamValue::forDirect(V));
2541  } else {
2542  ArgVals.push_back(ParamValue::forIndirect(Alloca));
2543  }
2544  break;
2545  }
2546 
2548  // Reconstruct into a temporary.
2549  Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2550  ArgVals.push_back(ParamValue::forIndirect(alloca));
2551 
2552  auto coercionType = ArgI.getCoerceAndExpandType();
2553  alloca = Builder.CreateElementBitCast(alloca, coercionType);
2554 
2555  unsigned argIndex = FirstIRArg;
2556  for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
2557  llvm::Type *eltType = coercionType->getElementType(i);
2559  continue;
2560 
2561  auto eltAddr = Builder.CreateStructGEP(alloca, i);
2562  auto elt = FnArgs[argIndex++];
2563  Builder.CreateStore(elt, eltAddr);
2564  }
2565  assert(argIndex == FirstIRArg + NumIRArgs);
2566  break;
2567  }
2568 
2569  case ABIArgInfo::Expand: {
2570  // If this structure was expanded into multiple arguments then
2571  // we need to create a temporary and reconstruct it from the
2572  // arguments.
2573  Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg));
2574  LValue LV = MakeAddrLValue(Alloca, Ty);
2575  ArgVals.push_back(ParamValue::forIndirect(Alloca));
2576 
2577  auto FnArgIter = FnArgs.begin() + FirstIRArg;
2578  ExpandTypeFromArgs(Ty, LV, FnArgIter);
2579  assert(FnArgIter == FnArgs.begin() + FirstIRArg + NumIRArgs);
2580  for (unsigned i = 0, e = NumIRArgs; i != e; ++i) {
2581  auto AI = FnArgs[FirstIRArg + i];
2582  AI->setName(Arg->getName() + "." + Twine(i));
2583  }
2584  break;
2585  }
2586 
2587  case ABIArgInfo::Ignore:
2588  assert(NumIRArgs == 0);
2589  // Initialize the local variable appropriately.
2590  if (!hasScalarEvaluationKind(Ty)) {
2591  ArgVals.push_back(ParamValue::forIndirect(CreateMemTemp(Ty)));
2592  } else {
2593  llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType()));
2594  ArgVals.push_back(ParamValue::forDirect(U));
2595  }
2596  break;
2597  }
2598  }
2599 
2600  if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {
2601  for (int I = Args.size() - 1; I >= 0; --I)
2602  EmitParmDecl(*Args[I], ArgVals[I], I + 1);
2603  } else {
2604  for (unsigned I = 0, E = Args.size(); I != E; ++I)
2605  EmitParmDecl(*Args[I], ArgVals[I], I + 1);
2606  }
2607 }
2608 
2609 static void eraseUnusedBitCasts(llvm::Instruction *insn) {
2610  while (insn->use_empty()) {
2611  llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
2612  if (!bitcast) return;
2613 
2614  // This is "safe" because we would have used a ConstantExpr otherwise.
2615  insn = cast<llvm::Instruction>(bitcast->getOperand(0));
2616  bitcast->eraseFromParent();
2617  }
2618 }
2619 
2620 /// Try to emit a fused autorelease of a return result.
2622  llvm::Value *result) {
2623  // We must be immediately followed the cast.
2624  llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
2625  if (BB->empty()) return nullptr;
2626  if (&BB->back() != result) return nullptr;
2627 
2628  llvm::Type *resultType = result->getType();
2629 
2630  // result is in a BasicBlock and is therefore an Instruction.
2631  llvm::Instruction *generator = cast<llvm::Instruction>(result);
2632 
2634 
2635  // Look for:
2636  // %generator = bitcast %type1* %generator2 to %type2*
2637  while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
2638  // We would have emitted this as a constant if the operand weren't
2639  // an Instruction.
2640  generator = cast<llvm::Instruction>(bitcast->getOperand(0));
2641 
2642  // Require the generator to be immediately followed by the cast.
2643  if (generator->getNextNode() != bitcast)
2644  return nullptr;
2645 
2646  InstsToKill.push_back(bitcast);
2647  }
2648 
2649  // Look for:
2650  // %generator = call i8* @objc_retain(i8* %originalResult)
2651  // or
2652  // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
2653  llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
2654  if (!call) return nullptr;
2655 
2656  bool doRetainAutorelease;
2657 
2658  if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints().objc_retain) {
2659  doRetainAutorelease = true;
2660  } else if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints()
2662  doRetainAutorelease = false;
2663 
2664  // If we emitted an assembly marker for this call (and the
2665  // ARCEntrypoints field should have been set if so), go looking
2666  // for that call. If we can't find it, we can't do this
2667  // optimization. But it should always be the immediately previous
2668  // instruction, unless we needed bitcasts around the call.
2670  llvm::Instruction *prev = call->getPrevNode();
2671  assert(prev);
2672  if (isa<llvm::BitCastInst>(prev)) {
2673  prev = prev->getPrevNode();
2674  assert(prev);
2675  }
2676  assert(isa<llvm::CallInst>(prev));
2677  assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
2679  InstsToKill.push_back(prev);
2680  }
2681  } else {
2682  return nullptr;
2683  }
2684 
2685  result = call->getArgOperand(0);
2686  InstsToKill.push_back(call);
2687 
2688  // Keep killing bitcasts, for sanity. Note that we no longer care
2689  // about precise ordering as long as there's exactly one use.
2690  while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
2691  if (!bitcast->hasOneUse()) break;
2692  InstsToKill.push_back(bitcast);
2693  result = bitcast->getOperand(0);
2694  }
2695 
2696  // Delete all the unnecessary instructions, from latest to earliest.
2697  for (auto *I : InstsToKill)
2698  I->eraseFromParent();
2699 
2700  // Do the fused retain/autorelease if we were asked to.
2701  if (doRetainAutorelease)
2702  result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
2703 
2704  // Cast back to the result type.
2705  return CGF.Builder.CreateBitCast(result, resultType);
2706 }
2707 
2708 /// If this is a +1 of the value of an immutable 'self', remove it.
2710  llvm::Value *result) {
2711  // This is only applicable to a method with an immutable 'self'.
2712  const ObjCMethodDecl *method =
2713  dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl);
2714  if (!method) return nullptr;
2715  const VarDecl *self = method->getSelfDecl();
2716  if (!self->getType().isConstQualified()) return nullptr;
2717 
2718  // Look for a retain call.
2719  llvm::CallInst *retainCall =
2720  dyn_cast<llvm::CallInst>(result->stripPointerCasts());
2721  if (!retainCall ||
2722  retainCall->getCalledValue() != CGF.CGM.getObjCEntrypoints().objc_retain)
2723  return nullptr;
2724 
2725  // Look for an ordinary load of 'self'.
2726  llvm::Value *retainedValue = retainCall->getArgOperand(0);
2727  llvm::LoadInst *load =
2728  dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
2729  if (!load || load->isAtomic() || load->isVolatile() ||
2730  load->getPointerOperand() != CGF.GetAddrOfLocalVar(self).getPointer())
2731  return nullptr;
2732 
2733  // Okay! Burn it all down. This relies for correctness on the
2734  // assumption that the retain is emitted as part of the return and
2735  // that thereafter everything is used "linearly".
2736  llvm::Type *resultType = result->getType();
2737  eraseUnusedBitCasts(cast<llvm::Instruction>(result));
2738  assert(retainCall->use_empty());
2739  retainCall->eraseFromParent();
2740  eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue));
2741 
2742  return CGF.Builder.CreateBitCast(load, resultType);
2743 }
2744 
2745 /// Emit an ARC autorelease of the result of a function.
2746 ///
2747 /// \return the value to actually return from the function
2749  llvm::Value *result) {
2750  // If we're returning 'self', kill the initial retain. This is a
2751  // heuristic attempt to "encourage correctness" in the really unfortunate
2752  // case where we have a return of self during a dealloc and we desperately
2753  // need to avoid the possible autorelease.
2754  if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result))
2755  return self;
2756 
2757  // At -O0, try to emit a fused retain/autorelease.
2758  if (CGF.shouldUseFusedARCCalls())
2759  if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
2760  return fused;
2761 
2762  return CGF.EmitARCAutoreleaseReturnValue(result);
2763 }
2764 
2765 /// Heuristically search for a dominating store to the return-value slot.
2766 static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
2767  // Check if a User is a store which pointerOperand is the ReturnValue.
2768  // We are looking for stores to the ReturnValue, not for stores of the
2769  // ReturnValue to some other location.
2770  auto GetStoreIfValid = [&CGF](llvm::User *U) -> llvm::StoreInst * {
2771  auto *SI = dyn_cast<llvm::StoreInst>(U);
2772  if (!SI || SI->getPointerOperand() != CGF.ReturnValue.getPointer())
2773  return nullptr;
2774  // These aren't actually possible for non-coerced returns, and we
2775  // only care about non-coerced returns on this code path.
2776  assert(!SI->isAtomic() && !SI->isVolatile());
2777  return SI;
2778  };
2779  // If there are multiple uses of the return-value slot, just check
2780  // for something immediately preceding the IP. Sometimes this can
2781  // happen with how we generate implicit-returns; it can also happen
2782  // with noreturn cleanups.
2783  if (!CGF.ReturnValue.getPointer()->hasOneUse()) {
2784  llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2785  if (IP->empty()) return nullptr;
2786  llvm::Instruction *I = &IP->back();
2787 
2788  // Skip lifetime markers
2789  for (llvm::BasicBlock::reverse_iterator II = IP->rbegin(),
2790  IE = IP->rend();
2791  II != IE; ++II) {
2792  if (llvm::IntrinsicInst *Intrinsic =
2793  dyn_cast<llvm::IntrinsicInst>(&*II)) {
2794  if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) {
2795  const llvm::Value *CastAddr = Intrinsic->getArgOperand(1);
2796  ++II;
2797  if (II == IE)
2798  break;
2799  if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
2800  continue;
2801  }
2802  }
2803  I = &*II;
2804  break;
2805  }
2806 
2807  return GetStoreIfValid(I);
2808  }
2809 
2810  llvm::StoreInst *store =
2811  GetStoreIfValid(CGF.ReturnValue.getPointer()->user_back());
2812  if (!store) return nullptr;
2813 
2814  // Now do a first-and-dirty dominance check: just walk up the
2815  // single-predecessors chain from the current insertion point.
2816  llvm::BasicBlock *StoreBB = store->getParent();
2817  llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2818  while (IP != StoreBB) {
2819  if (!(IP = IP->getSinglePredecessor()))
2820  return nullptr;
2821  }
2822 
2823  // Okay, the store's basic block dominates the insertion point; we
2824  // can do our thing.
2825  return store;
2826 }
2827 
2829  bool EmitRetDbgLoc,
2830  SourceLocation EndLoc) {
2831  if (FI.isNoReturn()) {
2832  // Noreturn functions don't return.
2833  EmitUnreachable(EndLoc);
2834  return;
2835  }
2836 
2837  if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) {
2838  // Naked functions don't have epilogues.
2839  Builder.CreateUnreachable();
2840  return;
2841  }
2842 
2843  // Functions with no result always return void.
2844  if (!ReturnValue.isValid()) {
2845  Builder.CreateRetVoid();
2846  return;
2847  }
2848 
2849  llvm::DebugLoc RetDbgLoc;
2850  llvm::Value *RV = nullptr;
2851  QualType RetTy = FI.getReturnType();
2852  const ABIArgInfo &RetAI = FI.getReturnInfo();
2853 
2854  switch (RetAI.getKind()) {
2855  case ABIArgInfo::InAlloca:
2856  // Aggregrates get evaluated directly into the destination. Sometimes we
2857  // need to return the sret value in a register, though.
2858  assert(hasAggregateEvaluationKind(RetTy));
2859  if (RetAI.getInAllocaSRet()) {
2860  llvm::Function::arg_iterator EI = CurFn->arg_end();
2861  --EI;
2862  llvm::Value *ArgStruct = &*EI;
2863  llvm::Value *SRet = Builder.CreateStructGEP(
2864  nullptr, ArgStruct, RetAI.getInAllocaFieldIndex());
2865  RV = Builder.CreateAlignedLoad(SRet, getPointerAlign(), "sret");
2866  }
2867  break;
2868 
2869  case ABIArgInfo::Indirect: {
2870  auto AI = CurFn->arg_begin();
2871  if (RetAI.isSRetAfterThis())
2872  ++AI;
2873  switch (getEvaluationKind(RetTy)) {
2874  case TEK_Complex: {
2875  ComplexPairTy RT =
2876  EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc);
2877  EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),
2878  /*isInit*/ true);
2879  break;
2880  }
2881  case TEK_Aggregate:
2882  // Do nothing; aggregrates get evaluated directly into the destination.
2883  break;
2884  case TEK_Scalar:
2885  EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
2886  MakeNaturalAlignAddrLValue(&*AI, RetTy),
2887  /*isInit*/ true);
2888  break;
2889  }
2890  break;
2891  }
2892 
2893  case ABIArgInfo::Extend:
2894  case ABIArgInfo::Direct:
2895  if (RetAI.getCoerceToType() == ConvertType(RetTy) &&
2896  RetAI.getDirectOffset() == 0) {
2897  // The internal return value temp always will have pointer-to-return-type
2898  // type, just do a load.
2899 
2900  // If there is a dominating store to ReturnValue, we can elide
2901  // the load, zap the store, and usually zap the alloca.
2902  if (llvm::StoreInst *SI =
2904  // Reuse the debug location from the store unless there is
2905  // cleanup code to be emitted between the store and return
2906  // instruction.
2907  if (EmitRetDbgLoc && !AutoreleaseResult)
2908  RetDbgLoc = SI->getDebugLoc();
2909  // Get the stored value and nuke the now-dead store.
2910  RV = SI->getValueOperand();
2911  SI->eraseFromParent();
2912 
2913  // Otherwise, we have to do a simple load.
2914  } else {
2915  RV = Builder.CreateLoad(ReturnValue);
2916  }
2917  } else {
2918  // If the value is offset in memory, apply the offset now.
2919  Address V = emitAddressAtOffset(*this, ReturnValue, RetAI);
2920 
2921  RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
2922  }
2923 
2924  // In ARC, end functions that return a retainable type with a call
2925  // to objc_autoreleaseReturnValue.
2926  if (AutoreleaseResult) {
2927 #ifndef NDEBUG
2928  // Type::isObjCRetainabletype has to be called on a QualType that hasn't
2929  // been stripped of the typedefs, so we cannot use RetTy here. Get the
2930  // original return type of FunctionDecl, CurCodeDecl, and BlockDecl from
2931  // CurCodeDecl or BlockInfo.
2932  QualType RT;
2933 
2934  if (auto *FD = dyn_cast<FunctionDecl>(CurCodeDecl))
2935  RT = FD->getReturnType();
2936  else if (auto *MD = dyn_cast<ObjCMethodDecl>(CurCodeDecl))
2937  RT = MD->getReturnType();
2938  else if (isa<BlockDecl>(CurCodeDecl))
2939  RT = BlockInfo->BlockExpression->getFunctionType()->getReturnType();
2940  else
2941  llvm_unreachable("Unexpected function/method type");
2942 
2943  assert(getLangOpts().ObjCAutoRefCount &&
2944  !FI.isReturnsRetained() &&
2945  RT->isObjCRetainableType());
2946 #endif
2947  RV = emitAutoreleaseOfResult(*this, RV);
2948  }
2949 
2950  break;
2951 
2952  case ABIArgInfo::Ignore:
2953  break;
2954 
2956  auto coercionType = RetAI.getCoerceAndExpandType();
2957 
2958  // Load all of the coerced elements out into results.
2960  Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType);
2961  for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
2962  auto coercedEltType = coercionType->getElementType(i);
2963  if (ABIArgInfo::isPaddingForCoerceAndExpand(coercedEltType))
2964  continue;
2965 
2966  auto eltAddr = Builder.CreateStructGEP(addr, i);
2967  auto elt = Builder.CreateLoad(eltAddr);
2968  results.push_back(elt);
2969  }
2970 
2971  // If we have one result, it's the single direct result type.
2972  if (results.size() == 1) {
2973  RV = results[0];
2974 
2975  // Otherwise, we need to make a first-class aggregate.
2976  } else {
2977  // Construct a return type that lacks padding elements.
2978  llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType();
2979 
2980  RV = llvm::UndefValue::get(returnType);
2981  for (unsigned i = 0, e = results.size(); i != e; ++i) {
2982  RV = Builder.CreateInsertValue(RV, results[i], i);
2983  }
2984  }
2985  break;
2986  }
2987 
2988  case ABIArgInfo::Expand:
2989  llvm_unreachable("Invalid ABI kind for return argument");
2990  }
2991 
2992  llvm::Instruction *Ret;
2993  if (RV) {
2994  EmitReturnValueCheck(RV);
2995  Ret = Builder.CreateRet(RV);
2996  } else {
2997  Ret = Builder.CreateRetVoid();
2998  }
2999 
3000  if (RetDbgLoc)
3001  Ret->setDebugLoc(std::move(RetDbgLoc));
3002 }
3003 
3005  // A current decl may not be available when emitting vtable thunks.
3006  if (!CurCodeDecl)
3007  return;
3008 
3009  ReturnsNonNullAttr *RetNNAttr = nullptr;
3010  if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute))
3011  RetNNAttr = CurCodeDecl->getAttr<ReturnsNonNullAttr>();
3012 
3013  if (!RetNNAttr && !requiresReturnValueNullabilityCheck())
3014  return;
3015 
3016  // Prefer the returns_nonnull attribute if it's present.
3017  SourceLocation AttrLoc;
3018  SanitizerMask CheckKind;
3019  SanitizerHandler Handler;
3020  if (RetNNAttr) {
3021  assert(!requiresReturnValueNullabilityCheck() &&
3022  "Cannot check nullability and the nonnull attribute");
3023  AttrLoc = RetNNAttr->getLocation();
3024  CheckKind = SanitizerKind::ReturnsNonnullAttribute;
3025  Handler = SanitizerHandler::NonnullReturn;
3026  } else {
3027  if (auto *DD = dyn_cast<DeclaratorDecl>(CurCodeDecl))
3028  if (auto *TSI = DD->getTypeSourceInfo())
3029  if (auto FTL = TSI->getTypeLoc().castAs<FunctionTypeLoc>())
3030  AttrLoc = FTL.getReturnLoc().findNullabilityLoc();
3031  CheckKind = SanitizerKind::NullabilityReturn;
3032  Handler = SanitizerHandler::NullabilityReturn;
3033  }
3034 
3035  SanitizerScope SanScope(this);
3036 
3037  // Make sure the "return" source location is valid. If we're checking a
3038  // nullability annotation, make sure the preconditions for the check are met.
3039  llvm::BasicBlock *Check = createBasicBlock("nullcheck");
3040  llvm::BasicBlock *NoCheck = createBasicBlock("no.nullcheck");
3041  llvm::Value *SLocPtr = Builder.CreateLoad(ReturnLocation, "return.sloc.load");
3042  llvm::Value *CanNullCheck = Builder.CreateIsNotNull(SLocPtr);
3043  if (requiresReturnValueNullabilityCheck())
3044  CanNullCheck =
3045  Builder.CreateAnd(CanNullCheck, RetValNullabilityPrecondition);
3046  Builder.CreateCondBr(CanNullCheck, Check, NoCheck);
3047  EmitBlock(Check);
3048 
3049  // Now do the null check.
3050  llvm::Value *Cond = Builder.CreateIsNotNull(RV);
3051  llvm::Constant *StaticData[] = {EmitCheckSourceLocation(AttrLoc)};
3052  llvm::Value *DynamicData[] = {SLocPtr};
3053  EmitCheck(std::make_pair(Cond, CheckKind), Handler, StaticData, DynamicData);
3054 
3055  EmitBlock(NoCheck);
3056 
3057 #ifndef NDEBUG
3058  // The return location should not be used after the check has been emitted.
3059  ReturnLocation = Address::invalid();
3060 #endif
3061 }
3062 
3064  const CXXRecordDecl *RD = type->getAsCXXRecordDecl();
3065  return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory;
3066 }
3067 
3069  QualType Ty) {
3070  // FIXME: Generate IR in one pass, rather than going back and fixing up these
3071  // placeholders.
3072  llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty);
3073  llvm::Type *IRPtrTy = IRTy->getPointerTo();
3074  llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo());
3075 
3076  // FIXME: When we generate this IR in one pass, we shouldn't need
3077  // this win32-specific alignment hack.
3079  Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align);
3080 
3081  return AggValueSlot::forAddr(Address(Placeholder, Align),
3082  Ty.getQualifiers(),
3087 }
3088 
3090  const VarDecl *param,
3091  SourceLocation loc) {
3092  // StartFunction converted the ABI-lowered parameter(s) into a
3093  // local alloca. We need to turn that into an r-value suitable
3094  // for EmitCall.
3095  Address local = GetAddrOfLocalVar(param);
3096 
3097  QualType type = param->getType();
3098 
3099  if (isInAllocaArgument(CGM.getCXXABI(), type)) {
3100  CGM.ErrorUnsupported(param, "forwarded non-trivially copyable parameter");
3101  }
3102 
3103  // GetAddrOfLocalVar returns a pointer-to-pointer for references,
3104  // but the argument needs to be the original pointer.
3105  if (type->isReferenceType()) {
3106  args.add(RValue::get(Builder.CreateLoad(local)), type);
3107 
3108  // In ARC, move out of consumed arguments so that the release cleanup
3109  // entered by StartFunction doesn't cause an over-release. This isn't
3110  // optimal -O0 code generation, but it should get cleaned up when
3111  // optimization is enabled. This also assumes that delegate calls are
3112  // performed exactly once for a set of arguments, but that should be safe.
3113  } else if (getLangOpts().ObjCAutoRefCount &&
3114  param->hasAttr<NSConsumedAttr>() &&
3115  type->isObjCRetainableType()) {
3116  llvm::Value *ptr = Builder.CreateLoad(local);
3117  auto null =
3118  llvm::ConstantPointerNull::get(cast<llvm::PointerType>(ptr->getType()));
3119  Builder.CreateStore(null, local);
3120  args.add(RValue::get(ptr), type);
3121 
3122  // For the most part, we just need to load the alloca, except that
3123  // aggregate r-values are actually pointers to temporaries.
3124  } else {
3125  args.add(convertTempToRValue(local, type, loc), type);
3126  }
3127 
3128  // Deactivate the cleanup for the callee-destructed param that was pushed.
3129  if (hasAggregateEvaluationKind(type) && !CurFuncIsThunk &&
3131  param->needsDestruction(getContext())) {
3133  CalleeDestructedParamCleanups.lookup(cast<ParmVarDecl>(param));
3134  assert(cleanup.isValid() &&
3135  "cleanup for callee-destructed param not recorded");
3136  // This unreachable is a temporary marker which will be removed later.
3137  llvm::Instruction *isActive = Builder.CreateUnreachable();
3138  args.addArgCleanupDeactivation(cleanup, isActive);
3139  }
3140 }
3141 
3142 static bool isProvablyNull(llvm::Value *addr) {
3143  return isa<llvm::ConstantPointerNull>(addr);
3144 }
3145 
3146 /// Emit the actual writing-back of a writeback.
3148  const CallArgList::Writeback &writeback) {
3149  const LValue &srcLV = writeback.Source;
3150  Address srcAddr = srcLV.getAddress(CGF);
3151  assert(!isProvablyNull(srcAddr.getPointer()) &&
3152  "shouldn't have writeback for provably null argument");
3153 
3154  llvm::BasicBlock *contBB = nullptr;
3155 
3156  // If the argument wasn't provably non-null, we need to null check
3157  // before doing the store.
3158  bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(),
3159  CGF.CGM.getDataLayout());
3160  if (!provablyNonNull) {
3161  llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
3162  contBB = CGF.createBasicBlock("icr.done");
3163 
3164  llvm::Value *isNull =
3165  CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
3166  CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
3167  CGF.EmitBlock(writebackBB);
3168  }
3169 
3170  // Load the value to writeback.
3171  llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
3172 
3173  // Cast it back, in case we're writing an id to a Foo* or something.
3174  value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(),
3175  "icr.writeback-cast");
3176 
3177  // Perform the writeback.
3178 
3179  // If we have a "to use" value, it's something we need to emit a use
3180  // of. This has to be carefully threaded in: if it's done after the
3181  // release it's potentially undefined behavior (and the optimizer
3182  // will ignore it), and if it happens before the retain then the
3183  // optimizer could move the release there.
3184  if (writeback.ToUse) {
3185  assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong);
3186 
3187  // Retain the new value. No need to block-copy here: the block's
3188  // being passed up the stack.
3189  value = CGF.EmitARCRetainNonBlock(value);
3190 
3191  // Emit the intrinsic use here.
3192  CGF.EmitARCIntrinsicUse(writeback.ToUse);
3193 
3194  // Load the old value (primitively).
3195  llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation());
3196 
3197  // Put the new value in place (primitively).
3198  CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
3199 
3200  // Release the old value.
3201  CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
3202 
3203  // Otherwise, we can just do a normal lvalue store.
3204  } else {
3205  CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
3206  }
3207 
3208  // Jump to the continuation block.
3209  if (!provablyNonNull)
3210  CGF.EmitBlock(contBB);
3211 }
3212 
3214  const CallArgList &args) {
3215  for (const auto &I : args.writebacks())
3216  emitWriteback(CGF, I);
3217 }
3218 
3220  const CallArgList &CallArgs) {
3222  CallArgs.getCleanupsToDeactivate();
3223  // Iterate in reverse to increase the likelihood of popping the cleanup.
3224  for (const auto &I : llvm::reverse(Cleanups)) {
3225  CGF.DeactivateCleanupBlock(I.Cleanup, I.IsActiveIP);
3226  I.IsActiveIP->eraseFromParent();
3227  }
3228 }
3229 
3230 static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) {
3231  if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens()))
3232  if (uop->getOpcode() == UO_AddrOf)
3233  return uop->getSubExpr();
3234  return nullptr;
3235 }
3236 
3237 /// Emit an argument that's being passed call-by-writeback. That is,
3238 /// we are passing the address of an __autoreleased temporary; it
3239 /// might be copy-initialized with the current value of the given
3240 /// address, but it will definitely be copied out of after the call.
3242  const ObjCIndirectCopyRestoreExpr *CRE) {
3243  LValue srcLV;
3244 
3245  // Make an optimistic effort to emit the address as an l-value.
3246  // This can fail if the argument expression is more complicated.
3247  if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) {
3248  srcLV = CGF.EmitLValue(lvExpr);
3249 
3250  // Otherwise, just emit it as a scalar.
3251  } else {
3252  Address srcAddr = CGF.EmitPointerWithAlignment(CRE->getSubExpr());
3253 
3254  QualType srcAddrType =
3255  CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
3256  srcLV = CGF.MakeAddrLValue(srcAddr, srcAddrType);
3257  }
3258  Address srcAddr = srcLV.getAddress(CGF);
3259 
3260  // The dest and src types don't necessarily match in LLVM terms
3261  // because of the crazy ObjC compatibility rules.
3262 
3263  llvm::PointerType *destType =
3264  cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
3265 
3266  // If the address is a constant null, just pass the appropriate null.
3267  if (isProvablyNull(srcAddr.getPointer())) {
3268  args.add(RValue::get(llvm::ConstantPointerNull::get(destType)),
3269  CRE->getType());
3270  return;
3271  }
3272 
3273  // Create the temporary.
3274  Address temp = CGF.CreateTempAlloca(destType->getElementType(),
3275  CGF.getPointerAlign(),
3276  "icr.temp");
3277  // Loading an l-value can introduce a cleanup if the l-value is __weak,
3278  // and that cleanup will be conditional if we can't prove that the l-value
3279  // isn't null, so we need to register a dominating point so that the cleanups
3280  // system will make valid IR.
3282 
3283  // Zero-initialize it if we're not doing a copy-initialization.
3284  bool shouldCopy = CRE->shouldCopy();
3285  if (!shouldCopy) {
3286  llvm::Value *null =
3287  llvm::ConstantPointerNull::get(
3288  cast<llvm::PointerType>(destType->getElementType()));
3289  CGF.Builder.CreateStore(null, temp);
3290  }
3291 
3292  llvm::BasicBlock *contBB = nullptr;
3293  llvm::BasicBlock *originBB = nullptr;
3294 
3295  // If the address is *not* known to be non-null, we need to switch.
3296  llvm::Value *finalArgument;
3297 
3298  bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(),
3299  CGF.CGM.getDataLayout());
3300  if (provablyNonNull) {
3301  finalArgument = temp.getPointer();
3302  } else {
3303  llvm::Value *isNull =
3304  CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
3305 
3306  finalArgument = CGF.Builder.CreateSelect(isNull,
3307  llvm::ConstantPointerNull::get(destType),
3308  temp.getPointer(), "icr.argument");
3309 
3310  // If we need to copy, then the load has to be conditional, which
3311  // means we need control flow.
3312  if (shouldCopy) {
3313  originBB = CGF.Builder.GetInsertBlock();
3314  contBB = CGF.createBasicBlock("icr.cont");
3315  llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy");
3316  CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
3317  CGF.EmitBlock(copyBB);
3318  condEval.begin(CGF);
3319  }
3320  }
3321 
3322  llvm::Value *valueToUse = nullptr;
3323 
3324  // Perform a copy if necessary.
3325  if (shouldCopy) {
3326  RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation());
3327  assert(srcRV.isScalar());
3328 
3329  llvm::Value *src = srcRV.getScalarVal();
3330  src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
3331  "icr.cast");
3332 
3333  // Use an ordinary store, not a store-to-lvalue.
3334  CGF.Builder.CreateStore(src, temp);
3335 
3336  // If optimization is enabled, and the value was held in a
3337  // __strong variable, we need to tell the optimizer that this
3338  // value has to stay alive until we're doing the store back.
3339  // This is because the temporary is effectively unretained,
3340  // and so otherwise we can violate the high-level semantics.
3341  if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 &&
3343  valueToUse = src;
3344  }
3345  }
3346 
3347  // Finish the control flow if we needed it.
3348  if (shouldCopy && !provablyNonNull) {
3349  llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
3350  CGF.EmitBlock(contBB);
3351 
3352  // Make a phi for the value to intrinsically use.
3353  if (valueToUse) {
3354  llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
3355  "icr.to-use");
3356  phiToUse->addIncoming(valueToUse, copyBB);
3357  phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
3358  originBB);
3359  valueToUse = phiToUse;
3360  }
3361 
3362  condEval.end(CGF);
3363  }
3364 
3365  args.addWriteback(srcLV, temp, valueToUse);
3366  args.add(RValue::get(finalArgument), CRE->getType());
3367 }
3368 
3370  assert(!StackBase);
3371 
3372  // Save the stack.
3373  llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave);
3374  StackBase = CGF.Builder.CreateCall(F, {}, "inalloca.save");
3375 }
3376 
3378  if (StackBase) {
3379  // Restore the stack after the call.
3380  llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
3381  CGF.Builder.CreateCall(F, StackBase);
3382  }
3383 }
3384 
3386  SourceLocation ArgLoc,
3387  AbstractCallee AC,
3388  unsigned ParmNum) {
3389  if (!AC.getDecl() || !(SanOpts.has(SanitizerKind::NonnullAttribute) ||
3390  SanOpts.has(SanitizerKind::NullabilityArg)))
3391  return;
3392 
3393  // The param decl may be missing in a variadic function.
3394  auto PVD = ParmNum < AC.getNumParams() ? AC.getParamDecl(ParmNum) : nullptr;
3395  unsigned ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum;
3396 
3397  // Prefer the nonnull attribute if it's present.
3398  const NonNullAttr *NNAttr = nullptr;
3399  if (SanOpts.has(SanitizerKind::NonnullAttribute))
3400  NNAttr = getNonNullAttr(AC.getDecl(), PVD, ArgType, ArgNo);
3401 
3402  bool CanCheckNullability = false;
3403  if (SanOpts.has(SanitizerKind::NullabilityArg) && !NNAttr && PVD) {
3404  auto Nullability = PVD->getType()->getNullability(getContext());
3405  CanCheckNullability = Nullability &&
3407  PVD->getTypeSourceInfo();
3408  }
3409 
3410  if (!NNAttr && !CanCheckNullability)
3411  return;
3412 
3413  SourceLocation AttrLoc;
3414  SanitizerMask CheckKind;
3415  SanitizerHandler Handler;
3416  if (NNAttr) {
3417  AttrLoc = NNAttr->getLocation();
3418  CheckKind = SanitizerKind::NonnullAttribute;
3419  Handler = SanitizerHandler::NonnullArg;
3420  } else {
3421  AttrLoc = PVD->getTypeSourceInfo()->getTypeLoc().findNullabilityLoc();
3422  CheckKind = SanitizerKind::NullabilityArg;
3423  Handler = SanitizerHandler::NullabilityArg;
3424  }
3425 
3426  SanitizerScope SanScope(this);
3427  assert(RV.isScalar());
3428  llvm::Value *V = RV.getScalarVal();
3429  llvm::Value *Cond =
3430  Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType()));
3431  llvm::Constant *StaticData[] = {
3432  EmitCheckSourceLocation(ArgLoc), EmitCheckSourceLocation(AttrLoc),
3433  llvm::ConstantInt::get(Int32Ty, ArgNo + 1),
3434  };
3435  EmitCheck(std::make_pair(Cond, CheckKind), Handler, StaticData, None);
3436 }
3437 
3439  CallArgList &Args, ArrayRef<QualType> ArgTypes,
3440  llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
3441  AbstractCallee AC, unsigned ParamsToSkip, EvaluationOrder Order) {
3442  assert((int)ArgTypes.size() == (ArgRange.end() - ArgRange.begin()));
3443 
3444  // We *have* to evaluate arguments from right to left in the MS C++ ABI,
3445  // because arguments are destroyed left to right in the callee. As a special
3446  // case, there are certain language constructs that require left-to-right
3447  // evaluation, and in those cases we consider the evaluation order requirement
3448  // to trump the "destruction order is reverse construction order" guarantee.
3449  bool LeftToRight =
3450  CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()
3451  ? Order == EvaluationOrder::ForceLeftToRight
3452  : Order != EvaluationOrder::ForceRightToLeft;
3453 
3454  auto MaybeEmitImplicitObjectSize = [&](unsigned I, const Expr *Arg,
3455  RValue EmittedArg) {
3456  if (!AC.hasFunctionDecl() || I >= AC.getNumParams())
3457  return;
3458  auto *PS = AC.getParamDecl(I)->getAttr<PassObjectSizeAttr>();
3459  if (PS == nullptr)
3460  return;
3461 
3462  const auto &Context = getContext();
3463  auto SizeTy = Context.getSizeType();
3464  auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
3465  assert(EmittedArg.getScalarVal() && "We emitted nothing for the arg?");
3466  llvm::Value *V = evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(), T,
3467  EmittedArg.getScalarVal(),
3468  PS->isDynamic());
3469  Args.add(RValue::get(V), SizeTy);
3470  // If we're emitting args in reverse, be sure to do so with
3471  // pass_object_size, as well.
3472  if (!LeftToRight)
3473  std::swap(Args.back(), *(&Args.back() - 1));
3474  };
3475 
3476  // Insert a stack save if we're going to need any inalloca args.
3477  bool HasInAllocaArgs = false;
3478  if (CGM.getTarget().getCXXABI().isMicrosoft()) {
3479  for (ArrayRef<QualType>::iterator I = ArgTypes.begin(), E = ArgTypes.end();
3480  I != E && !HasInAllocaArgs; ++I)
3481  HasInAllocaArgs = isInAllocaArgument(CGM.getCXXABI(), *I);
3482  if (HasInAllocaArgs) {
3483  assert(getTarget().getTriple().getArch() == llvm::Triple::x86);
3484  Args.allocateArgumentMemory(*this);
3485  }
3486  }
3487 
3488  // Evaluate each argument in the appropriate order.
3489  size_t CallArgsStart = Args.size();
3490  for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) {
3491  unsigned Idx = LeftToRight ? I : E - I - 1;
3492  CallExpr::const_arg_iterator Arg = ArgRange.begin() + Idx;
3493  unsigned InitialArgSize = Args.size();
3494  // If *Arg is an ObjCIndirectCopyRestoreExpr, check that either the types of
3495  // the argument and parameter match or the objc method is parameterized.
3496  assert((!isa<ObjCIndirectCopyRestoreExpr>(*Arg) ||
3497  getContext().hasSameUnqualifiedType((*Arg)->getType(),
3498  ArgTypes[Idx]) ||
3499  (isa<ObjCMethodDecl>(AC.getDecl()) &&
3500  isObjCMethodWithTypeParams(cast<ObjCMethodDecl>(AC.getDecl())))) &&
3501  "Argument and parameter types don't match");
3502  EmitCallArg(Args, *Arg, ArgTypes[Idx]);
3503  // In particular, we depend on it being the last arg in Args, and the
3504  // objectsize bits depend on there only being one arg if !LeftToRight.
3505  assert(InitialArgSize + 1 == Args.size() &&
3506  "The code below depends on only adding one arg per EmitCallArg");
3507  (void)InitialArgSize;
3508  // Since pointer argument are never emitted as LValue, it is safe to emit
3509  // non-null argument check for r-value only.
3510  if (!Args.back().hasLValue()) {
3511  RValue RVArg = Args.back().getKnownRValue();
3512  EmitNonNullArgCheck(RVArg, ArgTypes[Idx], (*Arg)->getExprLoc(), AC,
3513  ParamsToSkip + Idx);
3514  // @llvm.objectsize should never have side-effects and shouldn't need
3515  // destruction/cleanups, so we can safely "emit" it after its arg,
3516  // regardless of right-to-leftness
3517  MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg);
3518  }
3519  }
3520 
3521  if (!LeftToRight) {
3522  // Un-reverse the arguments we just evaluated so they match up with the LLVM
3523  // IR function.
3524  std::reverse(Args.begin() + CallArgsStart, Args.end());
3525  }
3526 }
3527 
3528 namespace {
3529 
3530 struct DestroyUnpassedArg final : EHScopeStack::Cleanup {
3531  DestroyUnpassedArg(Address Addr, QualType Ty)
3532  : Addr(Addr), Ty(Ty) {}
3533 
3534  Address Addr;
3535  QualType Ty;
3536 
3537  void Emit(CodeGenFunction &CGF, Flags flags) override {
3539  if (DtorKind == QualType::DK_cxx_destructor) {
3540  const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor();
3541  assert(!Dtor->isTrivial());
3542  CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false,
3543  /*Delegating=*/false, Addr, Ty);
3544  } else {
3545  CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Ty));
3546  }
3547  }
3548 };
3549 
3550 struct DisableDebugLocationUpdates {
3551  CodeGenFunction &CGF;
3552  bool disabledDebugInfo;
3553  DisableDebugLocationUpdates(CodeGenFunction &CGF, const Expr *E) : CGF(CGF) {
3554  if ((disabledDebugInfo = isa<CXXDefaultArgExpr>(E) && CGF.getDebugInfo()))
3555  CGF.disableDebugInfo();
3556  }
3557  ~DisableDebugLocationUpdates() {
3558  if (disabledDebugInfo)
3559  CGF.enableDebugInfo();
3560  }
3561 };
3562 
3563 } // end anonymous namespace
3564 
3566  if (!HasLV)
3567  return RV;
3568  LValue Copy = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty), Ty);
3570  LV.isVolatile());
3571  IsUsed = true;
3572  return RValue::getAggregate(Copy.getAddress(CGF));
3573 }
3574 
3576  LValue Dst = CGF.MakeAddrLValue(Addr, Ty);
3577  if (!HasLV && RV.isScalar())
3578  CGF.EmitStoreOfScalar(RV.getScalarVal(), Dst, /*isInit=*/true);
3579  else if (!HasLV && RV.isComplex())
3580  CGF.EmitStoreOfComplex(RV.getComplexVal(), Dst, /*init=*/true);
3581  else {
3582  auto Addr = HasLV ? LV.getAddress(CGF) : RV.getAggregateAddress();
3583  LValue SrcLV = CGF.MakeAddrLValue(Addr, Ty);
3584  // We assume that call args are never copied into subobjects.
3585  CGF.EmitAggregateCopy(Dst, SrcLV, Ty, AggValueSlot::DoesNotOverlap,
3586  HasLV ? LV.isVolatileQualified()
3587  : RV.isVolatileQualified());
3588  }
3589  IsUsed = true;
3590 }
3591 
3593  QualType type) {
3594  DisableDebugLocationUpdates Dis(*this, E);
3595  if (const ObjCIndirectCopyRestoreExpr *CRE
3596  = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
3597  assert(getLangOpts().ObjCAutoRefCount);
3598  return emitWritebackArg(*this, args, CRE);
3599  }
3600 
3601  assert(type->isReferenceType() == E->isGLValue() &&
3602  "reference binding to unmaterialized r-value!");
3603 
3604  if (E->isGLValue()) {
3605  assert(E->getObjectKind() == OK_Ordinary);
3606  return args.add(EmitReferenceBindingToExpr(E), type);
3607  }
3608 
3609  bool HasAggregateEvalKind = hasAggregateEvaluationKind(type);
3610 
3611  // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee.
3612  // However, we still have to push an EH-only cleanup in case we unwind before
3613  // we make it to the call.
3614  if (HasAggregateEvalKind &&
3616  // If we're using inalloca, use the argument memory. Otherwise, use a
3617  // temporary.
3618  AggValueSlot Slot;
3619  if (args.isUsingInAlloca())
3620  Slot = createPlaceholderSlot(*this, type);
3621  else
3622  Slot = CreateAggTemp(type, "agg.tmp");
3623 
3624  bool DestroyedInCallee = true, NeedsEHCleanup = true;
3625  if (const auto *RD = type->getAsCXXRecordDecl())
3626  DestroyedInCallee = RD->hasNonTrivialDestructor();
3627  else
3628  NeedsEHCleanup = needsEHCleanup(type.isDestructedType());
3629 
3630  if (DestroyedInCallee)
3631  Slot.setExternallyDestructed();
3632 
3633  EmitAggExpr(E, Slot);
3634  RValue RV = Slot.asRValue();
3635  args.add(RV, type);
3636 
3637  if (DestroyedInCallee && NeedsEHCleanup) {
3638  // Create a no-op GEP between the placeholder and the cleanup so we can
3639  // RAUW it successfully. It also serves as a marker of the first
3640  // instruction where the cleanup is active.
3641  pushFullExprCleanup<DestroyUnpassedArg>(EHCleanup, Slot.getAddress(),
3642  type);
3643  // This unreachable is a temporary marker which will be removed later.
3644  llvm::Instruction *IsActive = Builder.CreateUnreachable();
3645  args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive);
3646  }
3647  return;
3648  }
3649 
3650  if (HasAggregateEvalKind && isa<ImplicitCastExpr>(E) &&
3651  cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
3652  LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
3653  assert(L.isSimple());
3654  args.addUncopiedAggregate(L, type);
3655  return;
3656  }
3657 
3658  args.add(EmitAnyExprToTemp(E), type);
3659 }
3660 
3661 QualType CodeGenFunction::getVarArgType(const Expr *Arg) {
3662  // System headers on Windows define NULL to 0 instead of 0LL on Win64. MSVC
3663  // implicitly widens null pointer constants that are arguments to varargs
3664  // functions to pointer-sized ints.
3665  if (!getTarget().getTriple().isOSWindows())
3666  return Arg->getType();
3667 
3668  if (Arg->getType()->isIntegerType() &&
3669  getContext().getTypeSize(Arg->getType()) <
3673  return getContext().getIntPtrType();
3674  }
3675 
3676  return Arg->getType();
3677 }
3678 
3679 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
3680 // optimizer it can aggressively ignore unwind edges.
3681 void
3682 CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
3683  if (CGM.getCodeGenOpts().OptimizationLevel != 0 &&
3684  !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
3685  Inst->setMetadata("clang.arc.no_objc_arc_exceptions",
3686  CGM.getNoObjCARCExceptionsMetadata());
3687 }
3688 
3689 /// Emits a call to the given no-arguments nounwind runtime function.
3690 llvm::CallInst *
3691 CodeGenFunction::EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
3692  const llvm::Twine &name) {
3693  return EmitNounwindRuntimeCall(callee, None, name);
3694 }
3695 
3696 /// Emits a call to the given nounwind runtime function.
3697 llvm::CallInst *
3698 CodeGenFunction::EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
3700  const llvm::Twine &name) {
3701  llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
3702  call->setDoesNotThrow();
3703  return call;
3704 }
3705 
3706 /// Emits a simple call (never an invoke) to the given no-arguments
3707 /// runtime function.
3708 llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee,
3709  const llvm::Twine &name) {
3710  return EmitRuntimeCall(callee, None, name);
3711 }
3712 
3713 // Calls which may throw must have operand bundles indicating which funclet
3714 // they are nested within.
3718  // There is no need for a funclet operand bundle if we aren't inside a
3719  // funclet.
3720  if (!CurrentFuncletPad)
3721  return BundleList;
3722 
3723  // Skip intrinsics which cannot throw.
3724  auto *CalleeFn = dyn_cast<llvm::Function>(Callee->stripPointerCasts());
3725  if (CalleeFn && CalleeFn->isIntrinsic() && CalleeFn->doesNotThrow())
3726  return BundleList;
3727 
3728  BundleList.emplace_back("funclet", CurrentFuncletPad);
3729  return BundleList;
3730 }
3731 
3732 /// Emits a simple call (never an invoke) to the given runtime function.
3733 llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee,
3735  const llvm::Twine &name) {
3736  llvm::CallInst *call = Builder.CreateCall(
3737  callee, args, getBundlesForFunclet(callee.getCallee()), name);
3738  call->setCallingConv(getRuntimeCC());
3739  return call;
3740 }
3741 
3742 /// Emits a call or invoke to the given noreturn runtime function.
3744  llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args) {
3746  getBundlesForFunclet(callee.getCallee());
3747 
3748  if (getInvokeDest()) {
3749  llvm::InvokeInst *invoke =
3750  Builder.CreateInvoke(callee,
3751  getUnreachableBlock(),
3752  getInvokeDest(),
3753  args,
3754  BundleList);
3755  invoke->setDoesNotReturn();
3756  invoke->setCallingConv(getRuntimeCC());
3757  } else {
3758  llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList);
3759  call->setDoesNotReturn();
3760  call->setCallingConv(getRuntimeCC());
3761  Builder.CreateUnreachable();
3762  }
3763 }
3764 
3765 /// Emits a call or invoke instruction to the given nullary runtime function.
3766 llvm::CallBase *
3767 CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
3768  const Twine &name) {
3769  return EmitRuntimeCallOrInvoke(callee, None, name);
3770 }
3771 
3772 /// Emits a call or invoke instruction to the given runtime function.
3773 llvm::CallBase *
3774 CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
3776  const Twine &name) {
3777  llvm::CallBase *call = EmitCallOrInvoke(callee, args, name);
3778  call->setCallingConv(getRuntimeCC());
3779  return call;
3780 }
3781 
3782 /// Emits a call or invoke instruction to the given function, depending
3783 /// on the current state of the EH stack.
3784 llvm::CallBase *CodeGenFunction::EmitCallOrInvoke(llvm::FunctionCallee Callee,
3786  const Twine &Name) {
3787  llvm::BasicBlock *InvokeDest = getInvokeDest();
3789  getBundlesForFunclet(Callee.getCallee());
3790 
3791  llvm::CallBase *Inst;
3792  if (!InvokeDest)
3793  Inst = Builder.CreateCall(Callee, Args, BundleList, Name);
3794  else {
3795  llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
3796  Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList,
3797  Name);
3798  EmitBlock(ContBB);
3799  }
3800 
3801  // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
3802  // optimizer it can aggressively ignore unwind edges.
3803  if (CGM.getLangOpts().ObjCAutoRefCount)
3804  AddObjCARCExceptionMetadata(Inst);
3805 
3806  return Inst;
3807 }
3808 
3809 void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old,
3810  llvm::Value *New) {
3811  DeferredReplacements.push_back(std::make_pair(Old, New));
3812 }
3813 
3815  const CGCallee &Callee,
3817  const CallArgList &CallArgs,
3818  llvm::CallBase **callOrInvoke,
3819  SourceLocation Loc) {
3820  // FIXME: We no longer need the types from CallArgs; lift up and simplify.
3821 
3822  assert(Callee.isOrdinary() || Callee.isVirtual());
3823 
3824  // Handle struct-return functions by passing a pointer to the
3825  // location that we would like to return into.
3826  QualType RetTy = CallInfo.getReturnType();
3827  const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
3828 
3829  llvm::FunctionType *IRFuncTy = getTypes().GetFunctionType(CallInfo);
3830 
3831  const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl().getDecl();
3832  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
3833  // We can only guarantee that a function is called from the correct
3834  // context/function based on the appropriate target attributes,
3835  // so only check in the case where we have both always_inline and target
3836  // since otherwise we could be making a conditional call after a check for
3837  // the proper cpu features (and it won't cause code generation issues due to
3838  // function based code generation).
3839  if (TargetDecl->hasAttr<AlwaysInlineAttr>() &&
3840  TargetDecl->hasAttr<TargetAttr>())
3841  checkTargetFeatures(Loc, FD);
3842 
3843 #ifndef NDEBUG
3844  if (!(CallInfo.isVariadic() && CallInfo.getArgStruct())) {
3845  // For an inalloca varargs function, we don't expect CallInfo to match the
3846  // function pointer's type, because the inalloca struct a will have extra
3847  // fields in it for the varargs parameters. Code later in this function
3848  // bitcasts the function pointer to the type derived from CallInfo.
3849  //
3850  // In other cases, we assert that the types match up (until pointers stop
3851  // having pointee types).
3852  llvm::Type *TypeFromVal;
3853  if (Callee.isVirtual())
3854  TypeFromVal = Callee.getVirtualFunctionType();
3855  else
3856  TypeFromVal =
3857  Callee.getFunctionPointer()->getType()->getPointerElementType();
3858  assert(IRFuncTy == TypeFromVal);
3859  }
3860 #endif
3861 
3862  // 1. Set up the arguments.
3863 
3864  // If we're using inalloca, insert the allocation after the stack save.
3865  // FIXME: Do this earlier rather than hacking it in here!
3866  Address ArgMemory = Address::invalid();
3867  if (llvm::StructType *ArgStruct = CallInfo.getArgStruct()) {
3868  const llvm::DataLayout &DL = CGM.getDataLayout();
3869  llvm::Instruction *IP = CallArgs.getStackBase();
3870  llvm::AllocaInst *AI;
3871  if (IP) {
3872  IP = IP->getNextNode();
3873  AI = new llvm::AllocaInst(ArgStruct, DL.getAllocaAddrSpace(),
3874  "argmem", IP);
3875  } else {
3876  AI = CreateTempAlloca(ArgStruct, "argmem");
3877  }
3878  auto Align = CallInfo.getArgStructAlignment();
3879  AI->setAlignment(Align.getAsAlign());
3880  AI->setUsedWithInAlloca(true);
3881  assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca());
3882  ArgMemory = Address(AI, Align);
3883  }
3884 
3885  ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
3886  SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
3887 
3888  // If the call returns a temporary with struct return, create a temporary
3889  // alloca to hold the result, unless one is given to us.
3890  Address SRetPtr = Address::invalid();
3891  Address SRetAlloca = Address::invalid();
3892  llvm::Value *UnusedReturnSizePtr = nullptr;
3893  if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) {
3894  if (!ReturnValue.isNull()) {
3895  SRetPtr = ReturnValue.getValue();
3896  } else {
3897  SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca);
3898  if (HaveInsertPoint() && ReturnValue.isUnused()) {
3899  uint64_t size =
3900  CGM.getDataLayout().getTypeAllocSize(ConvertTypeForMem(RetTy));
3901  UnusedReturnSizePtr = EmitLifetimeStart(size, SRetAlloca.getPointer());
3902  }
3903  }
3904  if (IRFunctionArgs.hasSRetArg()) {
3905  IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr.getPointer();
3906  } else if (RetAI.isInAlloca()) {
3907  Address Addr =
3908  Builder.CreateStructGEP(ArgMemory, RetAI.getInAllocaFieldIndex());
3909  Builder.CreateStore(SRetPtr.getPointer(), Addr);
3910  }
3911  }
3912 
3913  Address swiftErrorTemp = Address::invalid();
3914  Address swiftErrorArg = Address::invalid();
3915 
3916  // When passing arguments using temporary allocas, we need to add the
3917  // appropriate lifetime markers. This vector keeps track of all the lifetime
3918  // markers that need to be ended right after the call.
3919  SmallVector<CallLifetimeEnd, 2> CallLifetimeEndAfterCall;
3920 
3921  // Translate all of the arguments as necessary to match the IR lowering.
3922  assert(CallInfo.arg_size() == CallArgs.size() &&
3923  "Mismatch between function signature & arguments.");
3924  unsigned ArgNo = 0;
3925  CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
3926  for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
3927  I != E; ++I, ++info_it, ++ArgNo) {
3928  const ABIArgInfo &ArgInfo = info_it->info;
3929 
3930  // Insert a padding argument to ensure proper alignment.
3931  if (IRFunctionArgs.hasPaddingArg(ArgNo))
3932  IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
3933  llvm::UndefValue::get(ArgInfo.getPaddingType());
3934 
3935  unsigned FirstIRArg, NumIRArgs;
3936  std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
3937 
3938  switch (ArgInfo.getKind()) {
3939  case ABIArgInfo::InAlloca: {
3940  assert(NumIRArgs == 0);
3941  assert(getTarget().getTriple().getArch() == llvm::Triple::x86);
3942  if (I->isAggregate()) {
3943  // Replace the placeholder with the appropriate argument slot GEP.
3944  Address Addr = I->hasLValue()
3945  ? I->getKnownLValue().getAddress(*this)
3946  : I->getKnownRValue().getAggregateAddress();
3947  llvm::Instruction *Placeholder =
3948  cast<llvm::Instruction>(Addr.getPointer());
3949  CGBuilderTy::InsertPoint IP = Builder.saveIP();
3950  Builder.SetInsertPoint(Placeholder);
3951  Addr =
3952  Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex());
3953  Builder.restoreIP(IP);
3954  deferPlaceholderReplacement(Placeholder, Addr.getPointer());
3955  } else {
3956  // Store the RValue into the argument struct.
3957  Address Addr =
3958  Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex());
3959  unsigned AS = Addr.getType()->getPointerAddressSpace();
3960  llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS);
3961  // There are some cases where a trivial bitcast is not avoidable. The
3962  // definition of a type later in a translation unit may change it's type
3963  // from {}* to (%struct.foo*)*.
3964  if (Addr.getType() != MemType)
3965  Addr = Builder.CreateBitCast(Addr, MemType);
3966  I->copyInto(*this, Addr);
3967  }
3968  break;
3969  }
3970 
3971  case ABIArgInfo::Indirect: {
3972  assert(NumIRArgs == 1);
3973  if (!I->isAggregate()) {
3974  // Make a temporary alloca to pass the argument.
3975  Address Addr = CreateMemTempWithoutCast(
3976  I->Ty, ArgInfo.getIndirectAlign(), "indirect-arg-temp");
3977  IRCallArgs[FirstIRArg] = Addr.getPointer();
3978 
3979  I->copyInto(*this, Addr);
3980  } else {
3981  // We want to avoid creating an unnecessary temporary+copy here;
3982  // however, we need one in three cases:
3983  // 1. If the argument is not byval, and we are required to copy the
3984  // source. (This case doesn't occur on any common architecture.)
3985  // 2. If the argument is byval, RV is not sufficiently aligned, and
3986  // we cannot force it to be sufficiently aligned.
3987  // 3. If the argument is byval, but RV is not located in default
3988  // or alloca address space.
3989  Address Addr = I->hasLValue()
3990  ? I->getKnownLValue().getAddress(*this)
3991  : I->getKnownRValue().getAggregateAddress();
3992  llvm::Value *V = Addr.getPointer();
3993  CharUnits Align = ArgInfo.getIndirectAlign();
3994  const llvm::DataLayout *TD = &CGM.getDataLayout();
3995 
3996  assert((FirstIRArg >= IRFuncTy->getNumParams() ||
3997  IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() ==
3998  TD->getAllocaAddrSpace()) &&
3999  "indirect argument must be in alloca address space");
4000 
4001  bool NeedCopy = false;
4002 
4003  if (Addr.getAlignment() < Align &&
4004  llvm::getOrEnforceKnownAlignment(V, Align.getQuantity(), *TD) <
4005  Align.getQuantity()) {
4006  NeedCopy = true;
4007  } else if (I->hasLValue()) {
4008  auto LV = I->getKnownLValue();
4009  auto AS = LV.getAddressSpace();
4010 
4011  if (!ArgInfo.getIndirectByVal() ||
4012  (LV.getAlignment() < getContext().getTypeAlignInChars(I->Ty))) {
4013  NeedCopy = true;
4014  }
4015  if (!getLangOpts().OpenCL) {
4016  if ((ArgInfo.getIndirectByVal() &&
4017  (AS != LangAS::Default &&
4018  AS != CGM.getASTAllocaAddressSpace()))) {
4019  NeedCopy = true;
4020  }
4021  }
4022  // For OpenCL even if RV is located in default or alloca address space
4023  // we don't want to perform address space cast for it.
4024  else if ((ArgInfo.getIndirectByVal() &&
4025  Addr.getType()->getAddressSpace() != IRFuncTy->
4026  getParamType(FirstIRArg)->getPointerAddressSpace())) {
4027  NeedCopy = true;
4028  }
4029  }
4030 
4031  if (NeedCopy) {
4032  // Create an aligned temporary, and copy to it.
4033  Address AI = CreateMemTempWithoutCast(
4034  I->Ty, ArgInfo.getIndirectAlign(), "byval-temp");
4035  IRCallArgs[FirstIRArg] = AI.getPointer();
4036 
4037  // Emit lifetime markers for the temporary alloca.
4038  uint64_t ByvalTempElementSize =
4039  CGM.getDataLayout().getTypeAllocSize(AI.getElementType());
4040  llvm::Value *LifetimeSize =
4041  EmitLifetimeStart(ByvalTempElementSize, AI.getPointer());
4042 
4043  // Add cleanup code to emit the end lifetime marker after the call.
4044  if (LifetimeSize) // In case we disabled lifetime markers.
4045  CallLifetimeEndAfterCall.emplace_back(AI, LifetimeSize);
4046 
4047  // Generate the copy.
4048  I->copyInto(*this, AI);
4049  } else {
4050  // Skip the extra memcpy call.
4051  auto *T = V->getType()->getPointerElementType()->getPointerTo(
4052  CGM.getDataLayout().getAllocaAddrSpace());
4053  IRCallArgs[FirstIRArg] = getTargetHooks().performAddrSpaceCast(
4054  *this, V, LangAS::Default, CGM.getASTAllocaAddressSpace(), T,
4055  true);
4056  }
4057  }
4058  break;
4059  }
4060 
4061  case ABIArgInfo::Ignore:
4062  assert(NumIRArgs == 0);
4063  break;
4064 
4065  case ABIArgInfo::Extend:
4066  case ABIArgInfo::Direct: {
4067  if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
4068  ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
4069  ArgInfo.getDirectOffset() == 0) {
4070  assert(NumIRArgs == 1);
4071  llvm::Value *V;
4072  if (!I->isAggregate())
4073  V = I->getKnownRValue().getScalarVal();
4074  else
4075  V = Builder.CreateLoad(
4076  I->hasLValue() ? I->getKnownLValue().getAddress(*this)
4077  : I->getKnownRValue().getAggregateAddress());
4078 
4079  // Implement swifterror by copying into a new swifterror argument.
4080  // We'll write back in the normal path out of the call.
4081  if (CallInfo.getExtParameterInfo(ArgNo).getABI()
4083  assert(!swiftErrorTemp.isValid() && "multiple swifterror args");
4084 
4085  QualType pointeeTy = I->Ty->getPointeeType();
4086  swiftErrorArg =
4087  Address(V, getContext().getTypeAlignInChars(pointeeTy));
4088 
4089  swiftErrorTemp =
4090  CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp");
4091  V = swiftErrorTemp.getPointer();
4092  cast<llvm::AllocaInst>(V)->setSwiftError(true);
4093 
4094  llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg);
4095  Builder.CreateStore(errorValue, swiftErrorTemp);
4096  }
4097 
4098  // We might have to widen integers, but we should never truncate.
4099  if (ArgInfo.getCoerceToType() != V->getType() &&
4100  V->getType()->isIntegerTy())
4101  V = Builder.CreateZExt(V, ArgInfo.getCoerceToType());
4102 
4103  // If the argument doesn't match, perform a bitcast to coerce it. This
4104  // can happen due to trivial type mismatches.
4105  if (FirstIRArg < IRFuncTy->getNumParams() &&
4106  V->getType() != IRFuncTy->getParamType(FirstIRArg))
4107  V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));
4108 
4109  IRCallArgs[FirstIRArg] = V;
4110  break;
4111  }
4112 
4113  // FIXME: Avoid the conversion through memory if possible.
4114  Address Src = Address::invalid();
4115  if (!I->isAggregate()) {
4116  Src = CreateMemTemp(I->Ty, "coerce");
4117  I->copyInto(*this, Src);
4118  } else {
4119  Src = I->hasLValue() ? I->getKnownLValue().getAddress(*this)
4120  : I->getKnownRValue().getAggregateAddress();
4121  }
4122 
4123  // If the value is offset in memory, apply the offset now.
4124  Src = emitAddressAtOffset(*this, Src, ArgInfo);
4125 
4126  // Fast-isel and the optimizer generally like scalar values better than
4127  // FCAs, so we flatten them if this is safe to do for this argument.
4128  llvm::StructType *STy =
4129  dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType());
4130  if (STy && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
4131  llvm::Type *SrcTy = Src.getType()->getElementType();
4132  uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4133  uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
4134 
4135  // If the source type is smaller than the destination type of the
4136  // coerce-to logic, copy the source value into a temp alloca the size
4137  // of the destination type to allow loading all of it. The bits past
4138  // the source value are left undef.
4139  if (SrcSize < DstSize) {
4140  Address TempAlloca
4141  = CreateTempAlloca(STy, Src.getAlignment(),
4142  Src.getName() + ".coerce");
4143  Builder.CreateMemCpy(TempAlloca, Src, SrcSize);
4144  Src = TempAlloca;
4145  } else {
4146  Src = Builder.CreateBitCast(Src,
4147  STy->getPointerTo(Src.getAddressSpace()));
4148  }
4149 
4150  assert(NumIRArgs == STy->getNumElements());
4151  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
4152  Address EltPtr = Builder.CreateStructGEP(Src, i);
4153  llvm::Value *LI = Builder.CreateLoad(EltPtr);
4154  IRCallArgs[FirstIRArg + i] = LI;
4155  }
4156  } else {
4157  // In the simple case, just pass the coerced loaded value.
4158  assert(NumIRArgs == 1);
4159  IRCallArgs[FirstIRArg] =
4160  CreateCoercedLoad(Src, ArgInfo.getCoerceToType(), *this);
4161  }
4162 
4163  break;
4164  }
4165 
4167  auto coercionType = ArgInfo.getCoerceAndExpandType();
4168  auto layout = CGM.getDataLayout().getStructLayout(coercionType);
4169 
4170  llvm::Value *tempSize = nullptr;
4171  Address addr = Address::invalid();
4172  Address AllocaAddr = Address::invalid();
4173  if (I->isAggregate()) {
4174  addr = I->hasLValue() ? I->getKnownLValue().getAddress(*this)
4175  : I->getKnownRValue().getAggregateAddress();
4176 
4177  } else {
4178  RValue RV = I->getKnownRValue();
4179  assert(RV.isScalar()); // complex should always just be direct
4180 
4181  llvm::Type *scalarType = RV.getScalarVal()->getType();
4182  auto scalarSize = CGM.getDataLayout().getTypeAllocSize(scalarType);
4183  auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType);
4184 
4185  // Materialize to a temporary.
4186  addr = CreateTempAlloca(
4187  RV.getScalarVal()->getType(),
4189  (unsigned)layout->getAlignment().value(), scalarAlign)),
4190  "tmp",
4191  /*ArraySize=*/nullptr, &AllocaAddr);
4192  tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer());
4193 
4194  Builder.CreateStore(RV.getScalarVal(), addr);
4195  }
4196 
4197  addr = Builder.CreateElementBitCast(addr, coercionType);
4198 
4199  unsigned IRArgPos = FirstIRArg;
4200  for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
4201  llvm::Type *eltType = coercionType->getElementType(i);
4202  if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue;
4203  Address eltAddr = Builder.CreateStructGEP(addr, i);
4204  llvm::Value *elt = Builder.CreateLoad(eltAddr);
4205  IRCallArgs[IRArgPos++] = elt;
4206  }
4207  assert(IRArgPos == FirstIRArg + NumIRArgs);
4208 
4209  if (tempSize) {
4210  EmitLifetimeEnd(tempSize, AllocaAddr.getPointer());
4211  }
4212 
4213  break;
4214  }
4215 
4216  case ABIArgInfo::Expand:
4217  unsigned IRArgPos = FirstIRArg;
4218  ExpandTypeToArgs(I->Ty, *I, IRFuncTy, IRCallArgs, IRArgPos);
4219  assert(IRArgPos == FirstIRArg + NumIRArgs);
4220  break;
4221  }
4222  }
4223 
4224  const CGCallee &ConcreteCallee = Callee.prepareConcreteCallee(*this);
4225  llvm::Value *CalleePtr = ConcreteCallee.getFunctionPointer();
4226 
4227  // If we're using inalloca, set up that argument.
4228  if (ArgMemory.isValid()) {
4229  llvm::Value *Arg = ArgMemory.getPointer();
4230  if (CallInfo.isVariadic()) {
4231  // When passing non-POD arguments by value to variadic functions, we will
4232  // end up with a variadic prototype and an inalloca call site. In such
4233  // cases, we can't do any parameter mismatch checks. Give up and bitcast
4234  // the callee.
4235  unsigned CalleeAS = CalleePtr->getType()->getPointerAddressSpace();
4236  CalleePtr =
4237  Builder.CreateBitCast(CalleePtr, IRFuncTy->getPointerTo(CalleeAS));
4238  } else {
4239  llvm::Type *LastParamTy =
4240  IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1);
4241  if (Arg->getType() != LastParamTy) {
4242 #ifndef NDEBUG
4243  // Assert that these structs have equivalent element types.
4244  llvm::StructType *FullTy = CallInfo.getArgStruct();
4245  llvm::StructType *DeclaredTy = cast<llvm::StructType>(
4246  cast<llvm::PointerType>(LastParamTy)->getElementType());
4247  assert(DeclaredTy->getNumElements() == FullTy->getNumElements());
4248  for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(),
4249  DE = DeclaredTy->element_end(),
4250  FI = FullTy->element_begin();
4251  DI != DE; ++DI, ++FI)
4252  assert(*DI == *FI);
4253 #endif
4254  Arg = Builder.CreateBitCast(Arg, LastParamTy);
4255  }
4256  }
4257  assert(IRFunctionArgs.hasInallocaArg());
4258  IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg;
4259  }
4260 
4261  // 2. Prepare the function pointer.
4262 
4263  // If the callee is a bitcast of a non-variadic function to have a
4264  // variadic function pointer type, check to see if we can remove the
4265  // bitcast. This comes up with unprototyped functions.
4266  //
4267  // This makes the IR nicer, but more importantly it ensures that we
4268  // can inline the function at -O0 if it is marked always_inline.
4269  auto simplifyVariadicCallee = [](llvm::FunctionType *CalleeFT,
4270  llvm::Value *Ptr) -> llvm::Function * {
4271  if (!CalleeFT->isVarArg())
4272  return nullptr;
4273 
4274  // Get underlying value if it's a bitcast
4275  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Ptr)) {
4276  if (CE->getOpcode() == llvm::Instruction::BitCast)
4277  Ptr = CE->getOperand(0);
4278  }
4279 
4280  llvm::Function *OrigFn = dyn_cast<llvm::Function>(Ptr);
4281  if (!OrigFn)
4282  return nullptr;
4283 
4284  llvm::FunctionType *OrigFT = OrigFn->getFunctionType();
4285 
4286  // If the original type is variadic, or if any of the component types
4287  // disagree, we cannot remove the cast.
4288  if (OrigFT->isVarArg() ||
4289  OrigFT->getNumParams() != CalleeFT->getNumParams() ||
4290  OrigFT->getReturnType() != CalleeFT->getReturnType())
4291  return nullptr;
4292 
4293  for (unsigned i = 0, e = OrigFT->getNumParams(); i != e; ++i)
4294  if (OrigFT->getParamType(i) != CalleeFT->getParamType(i))
4295  return nullptr;
4296 
4297  return OrigFn;
4298  };
4299 
4300  if (llvm::Function *OrigFn = simplifyVariadicCallee(IRFuncTy, CalleePtr)) {
4301  CalleePtr = OrigFn;
4302  IRFuncTy = OrigFn->getFunctionType();
4303  }
4304 
4305  // 3. Perform the actual call.
4306 
4307  // Deactivate any cleanups that we're supposed to do immediately before
4308  // the call.
4309  if (!CallArgs.getCleanupsToDeactivate().empty())
4310  deactivateArgCleanupsBeforeCall(*this, CallArgs);
4311 
4312  // Assert that the arguments we computed match up. The IR verifier
4313  // will catch this, but this is a common enough source of problems
4314  // during IRGen changes that it's way better for debugging to catch
4315  // it ourselves here.
4316 #ifndef NDEBUG
4317  assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg());
4318  for (unsigned i = 0; i < IRCallArgs.size(); ++i) {
4319  // Inalloca argument can have different type.
4320  if (IRFunctionArgs.hasInallocaArg() &&
4321  i == IRFunctionArgs.getInallocaArgNo())
4322  continue;
4323  if (i < IRFuncTy->getNumParams())
4324  assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i));
4325  }
4326 #endif
4327 
4328  // Update the largest vector width if any arguments have vector types.
4329  for (unsigned i = 0; i < IRCallArgs.size(); ++i) {
4330  if (auto *VT = dyn_cast<llvm::VectorType>(IRCallArgs[i]->getType()))
4331  LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
4332  VT->getPrimitiveSizeInBits().getFixedSize());
4333  }
4334 
4335  // Compute the calling convention and attributes.
4336  unsigned CallingConv;
4337  llvm::AttributeList Attrs;
4338  CGM.ConstructAttributeList(CalleePtr->getName(), CallInfo,
4339  Callee.getAbstractInfo(), Attrs, CallingConv,
4340  /*AttrOnCallSite=*/true);
4341 
4342  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl))
4343  if (FD->usesFPIntrin())
4344  // All calls within a strictfp function are marked strictfp
4345  Attrs =
4346  Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
4347  llvm::Attribute::StrictFP);
4348 
4349  // Apply some call-site-specific attributes.
4350  // TODO: work this into building the attribute set.
4351 
4352  // Apply always_inline to all calls within flatten functions.
4353  // FIXME: should this really take priority over __try, below?
4354  if (CurCodeDecl && CurCodeDecl->hasAttr<FlattenAttr>() &&
4355  !(TargetDecl && TargetDecl->hasAttr<NoInlineAttr>())) {
4356  Attrs =
4357  Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
4358  llvm::Attribute::AlwaysInline);
4359  }
4360 
4361  // Disable inlining inside SEH __try blocks.
4362  if (isSEHTryScope()) {
4363  Attrs =
4364  Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
4365  llvm::Attribute::NoInline);
4366  }
4367 
4368  // Decide whether to use a call or an invoke.
4369  bool CannotThrow;
4370  if (currentFunctionUsesSEHTry()) {
4371  // SEH cares about asynchronous exceptions, so everything can "throw."
4372  CannotThrow = false;
4373  } else if (isCleanupPadScope() &&
4375  // The MSVC++ personality will implicitly terminate the program if an
4376  // exception is thrown during a cleanup outside of a try/catch.
4377  // We don't need to model anything in IR to get this behavior.
4378  CannotThrow = true;
4379  } else {
4380  // Otherwise, nounwind call sites will never throw.
4381  CannotThrow = Attrs.hasAttribute(llvm::AttributeList::FunctionIndex,
4382  llvm::Attribute::NoUnwind);
4383  }
4384 
4385  // If we made a temporary, be sure to clean up after ourselves. Note that we
4386  // can't depend on being inside of an ExprWithCleanups, so we need to manually
4387  // pop this cleanup later on. Being eager about this is OK, since this
4388  // temporary is 'invisible' outside of the callee.
4389  if (UnusedReturnSizePtr)
4390  pushFullExprCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker, SRetAlloca,
4391  UnusedReturnSizePtr);
4392 
4393  llvm::BasicBlock *InvokeDest = CannotThrow ? nullptr : getInvokeDest();
4394 
4396  getBundlesForFunclet(CalleePtr);
4397 
4398  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl))
4399  if (FD->usesFPIntrin())
4400  // All calls within a strictfp function are marked strictfp
4401  Attrs =
4402  Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
4403  llvm::Attribute::StrictFP);
4404 
4405  // Emit the actual call/invoke instruction.
4406  llvm::CallBase *CI;
4407  if (!InvokeDest) {
4408  CI = Builder.CreateCall(IRFuncTy, CalleePtr, IRCallArgs, BundleList);
4409  } else {
4410  llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
4411  CI = Builder.CreateInvoke(IRFuncTy, CalleePtr, Cont, InvokeDest, IRCallArgs,
4412  BundleList);
4413  EmitBlock(Cont);
4414  }
4415  if (callOrInvoke)
4416  *callOrInvoke = CI;
4417 
4418  // If this is within a function that has the guard(nocf) attribute and is an
4419  // indirect call, add the "guard_nocf" attribute to this call to indicate that
4420  // Control Flow Guard checks should not be added, even if the call is inlined.
4421  if (const auto *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl)) {
4422  if (const auto *A = FD->getAttr<CFGuardAttr>()) {
4423  if (A->getGuard() == CFGuardAttr::GuardArg::nocf && !CI->getCalledFunction())
4424  Attrs = Attrs.addAttribute(
4425  getLLVMContext(), llvm::AttributeList::FunctionIndex, "guard_nocf");
4426  }
4427  }
4428 
4429  // Apply the attributes and calling convention.
4430  CI->setAttributes(Attrs);
4431  CI->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
4432 
4433  // Apply various metadata.
4434 
4435  if (!CI->getType()->isVoidTy())
4436  CI->setName("call");
4437 
4438  // Update largest vector width from the return type.
4439  if (auto *VT = dyn_cast<llvm::VectorType>(CI->getType()))
4440  LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
4441  VT->getPrimitiveSizeInBits().getFixedSize());
4442 
4443  // Insert instrumentation or attach profile metadata at indirect call sites.
4444  // For more details, see the comment before the definition of
4445  // IPVK_IndirectCallTarget in InstrProfData.inc.
4446  if (!CI->getCalledFunction())
4447  PGO.valueProfile(Builder, llvm::IPVK_IndirectCallTarget,
4448  CI, CalleePtr);
4449 
4450  // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
4451  // optimizer it can aggressively ignore unwind edges.
4452  if (CGM.getLangOpts().ObjCAutoRefCount)
4453  AddObjCARCExceptionMetadata(CI);
4454 
4455  // Suppress tail calls if requested.
4456  if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(CI)) {
4457  if (TargetDecl && TargetDecl->hasAttr<NotTailCalledAttr>())
4458  Call->setTailCallKind(llvm::CallInst::TCK_NoTail);
4459  }
4460 
4461  // Add metadata for calls to MSAllocator functions
4462  if (getDebugInfo() && TargetDecl &&
4463  TargetDecl->hasAttr<MSAllocatorAttr>())
4464  getDebugInfo()->addHeapAllocSiteMetadata(CI, RetTy, Loc);
4465 
4466  // 4. Finish the call.
4467 
4468  // If the call doesn't return, finish the basic block and clear the
4469  // insertion point; this allows the rest of IRGen to discard
4470  // unreachable code.
4471  if (CI->doesNotReturn()) {
4472  if (UnusedReturnSizePtr)
4473  PopCleanupBlock();
4474 
4475  // Strip away the noreturn attribute to better diagnose unreachable UB.
4476  if (SanOpts.has(SanitizerKind::Unreachable)) {
4477  // Also remove from function since CallBase::hasFnAttr additionally checks
4478  // attributes of the called function.
4479  if (auto *F = CI->getCalledFunction())
4480  F->removeFnAttr(llvm::Attribute::NoReturn);
4481  CI->removeAttribute(llvm::AttributeList::FunctionIndex,
4482  llvm::Attribute::NoReturn);
4483 
4484  // Avoid incompatibility with ASan which relies on the `noreturn`
4485  // attribute to insert handler calls.
4486  if (SanOpts.hasOneOf(SanitizerKind::Address |
4487  SanitizerKind::KernelAddress)) {
4488  SanitizerScope SanScope(this);
4489  llvm::IRBuilder<>::InsertPointGuard IPGuard(Builder);
4490  Builder.SetInsertPoint(CI);
4491  auto *FnType = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
4492  llvm::FunctionCallee Fn =
4493  CGM.CreateRuntimeFunction(FnType, "__asan_handle_no_return");
4494  EmitNounwindRuntimeCall(Fn);
4495  }
4496  }
4497 
4498  EmitUnreachable(Loc);
4499  Builder.ClearInsertionPoint();
4500 
4501  // FIXME: For now, emit a dummy basic block because expr emitters in
4502  // generally are not ready to handle emitting expressions at unreachable
4503  // points.
4504  EnsureInsertPoint();
4505 
4506  // Return a reasonable RValue.
4507  return GetUndefRValue(RetTy);
4508  }
4509 
4510  // Perform the swifterror writeback.
4511  if (swiftErrorTemp.isValid()) {
4512  llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp);
4513  Builder.CreateStore(errorResult, swiftErrorArg);
4514  }
4515 
4516  // Emit any call-associated writebacks immediately. Arguably this
4517  // should happen after any return-value munging.
4518  if (CallArgs.hasWritebacks())
4519  emitWritebacks(*this, CallArgs);
4520 
4521  // The stack cleanup for inalloca arguments has to run out of the normal
4522  // lexical order, so deactivate it and run it manually here.
4523  CallArgs.freeArgumentMemory(*this);
4524 
4525  // Extract the return value.
4526  RValue Ret = [&] {
4527  switch (RetAI.getKind()) {
4529  auto coercionType = RetAI.getCoerceAndExpandType();
4530 
4531  Address addr = SRetPtr;
4532  addr = Builder.CreateElementBitCast(addr, coercionType);
4533 
4534  assert(CI->getType() == RetAI.getUnpaddedCoerceAndExpandType());
4535  bool requiresExtract = isa<llvm::StructType>(CI->getType());
4536 
4537  unsigned unpaddedIndex = 0;
4538  for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) {
4539  llvm::Type *eltType = coercionType->getElementType(i);
4540  if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue;
4541  Address eltAddr = Builder.CreateStructGEP(addr, i);
4542  llvm::Value *elt = CI;
4543  if (requiresExtract)
4544  elt = Builder.CreateExtractValue(elt, unpaddedIndex++);
4545  else
4546  assert(unpaddedIndex == 0);
4547  Builder.CreateStore(elt, eltAddr);
4548  }
4549  // FALLTHROUGH
4550  LLVM_FALLTHROUGH;
4551  }
4552 
4553  case ABIArgInfo::InAlloca:
4554  case ABIArgInfo::Indirect: {
4555  RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation());
4556  if (UnusedReturnSizePtr)
4557  PopCleanupBlock();
4558  return ret;
4559  }
4560 
4561  case ABIArgInfo::Ignore:
4562  // If we are ignoring an argument that had a result, make sure to
4563  // construct the appropriate return value for our caller.
4564  return GetUndefRValue(RetTy);
4565 
4566  case ABIArgInfo::Extend:
4567  case ABIArgInfo::Direct: {
4568  llvm::Type *RetIRTy = ConvertType(RetTy);
4569  if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
4570  switch (getEvaluationKind(RetTy)) {
4571  case TEK_Complex: {
4572  llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
4573  llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
4574  return RValue::getComplex(std::make_pair(Real, Imag));
4575  }
4576  case TEK_Aggregate: {
4577  Address DestPtr = ReturnValue.getValue();
4578  bool DestIsVolatile = ReturnValue.isVolatile();
4579 
4580  if (!DestPtr.isValid()) {
4581  DestPtr = CreateMemTemp(RetTy, "agg.tmp");
4582  DestIsVolatile = false;
4583  }
4584  BuildAggStore(*this, CI, DestPtr, DestIsVolatile);
4585  return RValue::getAggregate(DestPtr);
4586  }
4587  case TEK_Scalar: {
4588  // If the argument doesn't match, perform a bitcast to coerce it. This
4589  // can happen due to trivial type mismatches.
4590  llvm::Value *V = CI;
4591  if (V->getType() != RetIRTy)
4592  V = Builder.CreateBitCast(V, RetIRTy);
4593  return RValue::get(V);
4594  }
4595  }
4596  llvm_unreachable("bad evaluation kind");
4597  }
4598 
4599  Address DestPtr = ReturnValue.getValue();
4600  bool DestIsVolatile = ReturnValue.isVolatile();
4601 
4602  if (!DestPtr.isValid()) {
4603  DestPtr = CreateMemTemp(RetTy, "coerce");
4604  DestIsVolatile = false;
4605  }
4606 
4607  // If the value is offset in memory, apply the offset now.
4608  Address StorePtr = emitAddressAtOffset(*this, DestPtr, RetAI);
4609  CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
4610 
4611  return convertTempToRValue(DestPtr, RetTy, SourceLocation());
4612  }
4613 
4614  case ABIArgInfo::Expand:
4615  llvm_unreachable("Invalid ABI kind for return argument");
4616  }
4617 
4618  llvm_unreachable("Unhandled ABIArgInfo::Kind");
4619  } ();
4620 
4621  // Emit the assume_aligned check on the return value.
4622  if (Ret.isScalar() && TargetDecl) {
4623  if (const auto *AA = TargetDecl->getAttr<AssumeAlignedAttr>()) {
4624  llvm::Value *OffsetValue = nullptr;
4625  if (const auto *Offset = AA->getOffset())
4626  OffsetValue = EmitScalarExpr(Offset);
4627 
4628  llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment());
4629  llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(Alignment);
4630  EmitAlignmentAssumption(Ret.getScalarVal(), RetTy, Loc, AA->getLocation(),
4631  AlignmentCI, OffsetValue);
4632  } else if (const auto *AA = TargetDecl->getAttr<AllocAlignAttr>()) {
4633  llvm::Value *AlignmentVal = CallArgs[AA->getParamIndex().getLLVMIndex()]
4634  .getRValue(*this)
4635  .getScalarVal();
4636  EmitAlignmentAssumption(Ret.getScalarVal(), RetTy, Loc, AA->getLocation(),
4637  AlignmentVal);
4638  }
4639  }
4640 
4641  // Explicitly call CallLifetimeEnd::Emit just to re-use the code even though
4642  // we can't use the full cleanup mechanism.
4643  for (CallLifetimeEnd &LifetimeEnd : CallLifetimeEndAfterCall)
4644  LifetimeEnd.Emit(*this, /*Flags=*/{});
4645 
4646  return Ret;
4647 }
4648 
4650  if (isVirtual()) {
4651  const CallExpr *CE = getVirtualCallExpr();
4653  CGF, getVirtualMethodDecl(), getThisAddress(), getVirtualFunctionType(),
4654  CE ? CE->getBeginLoc() : SourceLocation());
4655  }
4656 
4657  return *this;
4658 }
4659 
4660 /* VarArg handling */
4661 
4663  VAListAddr = VE->isMicrosoftABI()
4664  ? EmitMSVAListRef(VE->getSubExpr())
4665  : EmitVAListRef(VE->getSubExpr());
4666  QualType Ty = VE->getType();
4667  if (VE->isMicrosoftABI())
4668  return CGM.getTypes().getABIInfo().EmitMSVAArg(*this, VAListAddr, Ty);
4669  return CGM.getTypes().getABIInfo().EmitVAArg(*this, VAListAddr, Ty);
4670 }
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition: CGCall.cpp:653
const llvm::DataLayout & getDataLayout() const
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1577
CGCXXABI & getCXXABI() const
Definition: CodeGenTypes.h:119
Ignore - Ignore the argument (treat as void).
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:359
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
Definition: CGBuilder.h:178
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD)
Derives the &#39;this&#39; type for codegen purposes, i.e.
Definition: CGCall.cpp:74
Represents a function declaration or definition.
Definition: Decl.h:1783
Address getAddress() const
Definition: CGValue.h:583
const CGFunctionInfo & arrangeBlockFunctionDeclaration(const FunctionProtoType *type, const FunctionArgList &args)
Block invocation functions are C functions with an implicit parameter.
Definition: CGCall.cpp:628
void EmitReturnValueCheck(llvm::Value *RV)
Emit a test that checks if the return value RV is nonnull.
Definition: CGCall.cpp:3004
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
Complete object ctor.
Definition: ABI.h:25
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
A (possibly-)qualified type.
Definition: Type.h:654
bool isBlockPointerType() const
Definition: Type.h:6512
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses &#39;sret&#39; when used as a return type.
Definition: CGCall.cpp:1512
bool getNoCfCheck() const
Definition: Type.h:3582
llvm::Type * ConvertTypeForMem(QualType T)
const CodeGenOptions & getCodeGenOpts() const
bool isReturnsRetained() const
In ARC, whether this function retains its return value.
static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD)
Set calling convention for CUDA/HIP kernel.
Definition: CGCall.cpp:265
static CanQual< FunctionProtoType > GetFormalType(const CXXMethodDecl *MD)
Returns the canonical formal type of the given C++ method.
Definition: CGCall.cpp:88
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
Definition: CGExpr.cpp:139
static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback)
Emit the actual writing-back of a writeback.
Definition: CGCall.cpp:3147
static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty, CharUnits MinAlign)
Create a temporary allocation for the purposes of coercion.
Definition: CGCall.cpp:1119
static llvm::Value * emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)
Emit an ARC autorelease of the result of a function.
Definition: CGCall.cpp:2748
static const CGFunctionInfo & arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, CodeGenModule &CGM, const CallArgList &args, const FunctionType *fnType, unsigned numExtraRequiredArgs, bool chainCall)
Arrange a call as unto a free function, except possibly with an additional number of formal parameter...
Definition: CGCall.cpp:563
const ABIInfo & getABIInfo() const
Definition: CodeGenTypes.h:117
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:994
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:4148
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
Definition: Format.cpp:2472
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:602
Extend - Valid only for integer argument types.
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition: CGExpr.cpp:1039
Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr)
Generate code to get an argument from the passed in pointer and update it accordingly.
Definition: CGCall.cpp:4662
static bool isProvablyNull(llvm::Value *addr)
Definition: CGCall.cpp:3142
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
const CGFunctionInfo & arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD)
Arrange the argument and result information for a call to an unknown C++ non-static member function o...
Definition: CGCall.cpp:251
bool isVirtual() const
Definition: DeclCXX.h:1976
CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const
If this is a delayed callee computation of some sort, prepare a concrete callee.
Definition: CGCall.cpp:4649
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Direct - Pass the argument directly using the normal converted LLVM type, or by coercing to another s...
const Expr * getSubExpr() const
Definition: Expr.h:4262
void addUncopiedAggregate(LValue LV, QualType type)
Definition: CGCall.h:287
bool isVolatile() const
Definition: CGValue.h:301
The base class of the type hierarchy.
Definition: Type.h:1450
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Definition: CGExpr.cpp:1929
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
static const NonNullAttr * getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD, QualType ArgType, unsigned ArgNo)
Returns the attribute (either parameter attribute, or function attribute), which declares argument Ar...
Definition: CGCall.cpp:2219
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:6320
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
static int getExpansionSize(QualType Ty, const ASTContext &Context)
Definition: CGCall.cpp:960
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:707
const ParmVarDecl * getParamDecl(unsigned I) const
bool isFuncTypeConvertible(const FunctionType *FT)
isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i...
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:2137
static llvm::SmallVector< FunctionProtoType::ExtParameterInfo, 16 > getExtParameterInfosForCall(const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs)
Definition: CGCall.cpp:372
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2383
static llvm::Value * emitArgumentDemotion(CodeGenFunction &CGF, const VarDecl *var, llvm::Value *value)
An argument came in as a promoted argument; demote it back to its declared type.
Definition: CGCall.cpp:2199
bool hasWritebacks() const
Definition: CGCall.h:311
Default closure variant of a ctor.
Definition: ABI.h:29
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one...
bool ReturnValue(const T &V, APValue &R)
Convers a value to an APValue.
Definition: Interp.h:41
Represents a variable declaration or definition.
Definition: Decl.h:820
static void addExtParameterInfosForCall(llvm::SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &paramInfos, const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs)
Definition: CGCall.cpp:113
llvm::Instruction * getStackBase() const
Definition: CGCall.h:333
unsigned getNumParams() const
Definition: Type.h:3964
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
llvm::Value * getFunctionPointer() const
Definition: CGCall.h:182
static llvm::Value * CreateCoercedLoad(Address Src, llvm::Type *Ty, CodeGenFunction &CGF)
CreateCoercedLoad - Create a load from.
Definition: CGCall.cpp:1223
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:827
void setCoerceToType(llvm::Type *T)
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)
Definition: CGClass.cpp:2414
ExtInfo withProducesResult(bool producesResult) const
Definition: Type.h:3611
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl< CanQualType > &prefix, CanQual< FunctionProtoType > FTP)
Arrange the LLVM function layout for a value of the given function type, on top of any implicit param...
Definition: CGCall.cpp:176
void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum)
Create a check for a function parameter that may potentially be declared as non-null.
Definition: CGCall.cpp:3385
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
Definition: CGBuilder.h:244
llvm::Value * getPointer() const
Definition: Address.h:37
Address getValue() const
Definition: CGCall.h:379
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
Arrange the argument and result information for a value of the given freestanding function type...
Definition: CGCall.cpp:194
Represents a parameter to a function.
Definition: Decl.h:1595
unsigned getAddressSpace() const
Return the address space that this address resides in.
Definition: Address.h:56
void add(RValue rvalue, QualType type)
Definition: CGCall.h:285
unsigned ClangCallConvToLLVMCallConv(CallingConv CC)
Convert clang calling convention to LLVM callilng convention.
Definition: CGCall.cpp:45
virtual unsigned getOpenCLKernelCallingConv() const
Get LLVM calling convention for OpenCL kernel.
Definition: TargetInfo.cpp:420
Represents a struct/union/class.
Definition: Decl.h:3748
void freeArgumentMemory(CodeGenFunction &CGF) const
Definition: CGCall.cpp:3377
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:361
An object to manage conditionally-evaluated expressions.
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2357
bool usesInAlloca() const
Return true if this function uses inalloca arguments.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1063
static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args)
Definition: CGCall.cpp:3213
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
Definition: CGCall.cpp:2828
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.h:4081
unsigned getRegParm() const
Definition: Type.h:3585
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2613
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
Definition: Type.h:4152
field_range fields() const
Definition: Decl.h:3963
bool isVolatileQualified() const
Definition: CGValue.h:258
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2369
Represents a member of a struct/union/class.
Definition: Decl.h:2729
CharUnits getAlignment() const
Definition: CGValue.h:316
RequiredArgs getRequiredArgs() const
bool isUsingInAlloca() const
Returns if we&#39;re using an inalloca struct to pass arguments in memory.
Definition: CGCall.h:338
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1652
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:812
bool isOrdinary() const
Definition: CGCall.h:173
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition: CGValue.h:266
CharUnits getArgStructAlignment() const
bool isReferenceType() const
Definition: Type.h:6516
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:80
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
Autorelease the given object.
Definition: CGObjC.cpp:2359
static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE)
Emit an argument that&#39;s being passed call-by-writeback.
Definition: CGCall.cpp:3241
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:516
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
bool isVirtual() const
Definition: CGCall.h:191
static const EHPersonality & get(CodeGenModule &CGM, const FunctionDecl *FD)
__DEVICE__ int max(int __a, int __b)
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:723
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
void addArgCleanupDeactivation(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *IsActiveIP)
Definition: CGCall.h:320
bool getProducesResult() const
Definition: Type.h:3580
bool isGLValue() const
Definition: Expr.h:261
ARCPreciseLifetime_t isARCPreciseLifetime() const
Definition: CGValue.h:285
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
static bool hasScalarEvaluationKind(QualType T)
static llvm::Value * tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)
Try to emit a fused autorelease of a return result.
Definition: CGCall.cpp:2621
void copyInto(CodeGenFunction &CGF, Address A) const
Definition: CGCall.cpp:3575
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:156
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
llvm::StructType * getCoerceAndExpandType() const
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:223
Wrapper for source info for functions.
Definition: TypeLoc.h:1351
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
Definition: CGCXXABI.h:108
unsigned getInAllocaFieldIndex() const
const_arg_iterator arg_begin() const
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:79
const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs=true)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:390
LangAS getAddressSpace() const
Definition: Type.h:359
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite)
Get the LLVM attributes and calling convention to use for a particular function type.
Definition: CGCall.cpp:1836
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:274
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
static void appendParameterTypes(const CodeGenTypes &CGT, SmallVectorImpl< CanQualType > &prefix, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &paramInfos, CanQual< FunctionProtoType > FPT)
Adds the formal parameters in FPT to the given prefix.
Definition: CGCall.cpp:143
const CGFunctionInfo & arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD, QualType receiverType)
Arrange the argument and result information for the function type through which to perform a send to ...
Definition: CGCall.cpp:471
const CGFunctionInfo & arrangeCall(const CGFunctionInfo &declFI, const CallArgList &args)
Given a function info for a declaration, return the function info for a call with the given arguments...
Definition: CGCall.cpp:702
Values of this type can never be null.
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
Definition: EHScopeStack.h:84
bool isSimple() const
Definition: CGValue.h:252
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition: CGCall.cpp:279
bool isInstance() const
Definition: DeclCXX.h:1959
An ordinary object is located at an address in memory.
Definition: Specifiers.h:141
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1770
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:106
FunctionType::ExtInfo getExtInfo() const
QualType getReturnType() const
Definition: DeclObjC.h:324
const CGFunctionInfo & arrangeLLVMFunctionInfo(CanQualType returnType, bool instanceMethod, bool chainCall, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, ArrayRef< FunctionProtoType::ExtParameterInfo > paramInfos, RequiredArgs args)
"Arrange" the LLVM information for a call or type with the given signature.
Definition: CGCall.cpp:737
bool getNoReturn() const
Definition: Type.h:3579
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:83
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:71
bool getNoCallerSavedRegs() const
Definition: Type.h:3581
virtual AddedStructorArgs buildStructorSignature(GlobalDecl GD, SmallVectorImpl< CanQualType > &ArgTys)=0
Build the signature of the given constructor or destructor variant by adding any required parameters...
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType)
EmitCallArg - Emit a single call argument.
Definition: CGCall.cpp:3592
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
Definition: CGCall.cpp:513
virtual void setCUDAKernelCallingConvention(const FunctionType *&FT) const
Definition: TargetInfo.h:317
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:3638
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
const CGFunctionInfo & arrangeUnprototypedObjCMessageSend(QualType returnType, const CallArgList &args)
Definition: CGCall.cpp:502
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3717
bool hasAttr() const
Definition: DeclBase.h:542
CanQualType getReturnType() const
bool isValid() const
Definition: Address.h:35
unsigned getNumRequiredArgs() const
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1690
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
bool isMicrosoftABI() const
Returns whether this is really a Win64 ABI va_arg expression.
Definition: Expr.h:4267
const TargetCodeGenInfo & getTargetCodeGenInfo()
llvm::Function * objc_retainAutoreleasedReturnValue
id objc_retainAutoreleasedReturnValue(id);
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
writeback_const_range writebacks() const
Definition: CGCall.h:316
void addWriteback(LValue srcLV, Address temporary, llvm::Value *toUse)
Definition: CGCall.h:306
void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)
EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...
Definition: CGCall.cpp:3089
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4244
Address Temporary
The temporary alloca.
Definition: CGCall.h:271
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns &#39;th...
Definition: CGCXXABI.h:106
unsigned Offset
Definition: Format.cpp:1827
llvm::Value * ToUse
A value to "use" after the writeback, or null.
Definition: CGCall.h:274
const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)
Definition: CGCall.cpp:306
ExtParameterInfo withIsNoEscape(bool NoEscape) const
Definition: Type.h:3488
static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty)
Definition: CGCall.cpp:3068
This represents one expression.
Definition: Expr.h:108
static Address invalid()
Definition: Address.h:34
Address getAddress(CodeGenFunction &CGF) const
Definition: CGValue.h:327
llvm::Type * getUnpaddedCoerceAndExpandType() const
static bool isInAllocaArgument(CGCXXABI &ABI, QualType type)
Definition: CGCall.cpp:3063
bool useObjCFPRetForRealType(RealType T) const
Check whether the given real type should use the "fpret" flavor of Objective-C message passing on thi...
Definition: TargetInfo.h:740
static CanQualType GetReturnType(QualType RetTy)
Returns the "extra-canonicalized" return type, which discards qualifiers on the return type...
Definition: CGCall.cpp:97
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:66
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type &#39;void ()&#39;.
Definition: CGCall.cpp:695
bool getHasRegParm() const
Definition: Type.h:3583
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
bool isObjCRetainableType() const
Definition: Type.cpp:4060
#define V(N, I)
Definition: ASTContext.h:2941
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2649
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
static bool isPaddingForCoerceAndExpand(llvm::Type *eltType)
static SmallVector< CanQualType, 16 > getArgTypesForCall(ASTContext &ctx, const CallArgList &args)
Definition: CGCall.cpp:356
static void eraseUnusedBitCasts(llvm::Instruction *insn)
Definition: CGCall.cpp:2609
SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)
Definition: CGCall.cpp:3716
A class for recording the number of arguments that a function signature requires. ...
bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)
Return true iff the given type uses an argument slot when &#39;sret&#39; is used as a return type...
Definition: CGCall.cpp:1517
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
Definition: CGCall.cpp:640
QualType getType() const
Definition: Expr.h:137
static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr, const ABIArgInfo &info)
Definition: CGCall.cpp:1358
const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)
Arrange a thunk that takes &#39;this&#39; as the first parameter followed by varargs.
Definition: CGCall.cpp:530
static llvm::StoreInst * findDominatingStoreToReturnValue(CodeGenFunction &CGF)
Heuristically search for a dominating store to the return-value slot.
Definition: CGCall.cpp:2766
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:201
void Profile(llvm::FoldingSetNodeID &ID)
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2046
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2122
ASTContext & getContext() const
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:415
static llvm::Value * CoerceIntOrPtrToIntOrPtr(llvm::Value *Val, llvm::Type *Ty, CodeGenFunction &CGF)
CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both are either integers or p...
Definition: CGCall.cpp:1169
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:265
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:40
static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, Address Dest, bool DestIsVolatile)
Definition: CGCall.cpp:1275
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:421
CanQualType getCanonicalTypeUnqualified() const
LValue getKnownLValue() const
Definition: CGCall.h:241
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4505
unsigned getEffectiveCallingConvention() const
getEffectiveCallingConvention - Return the actual calling convention to use, which may depend on the ...
static void CreateCoercedStore(llvm::Value *Src, Address Dst, bool DstIsVolatile, CodeGenFunction &CGF)
CreateCoercedStore - Create a store to.
Definition: CGCall.cpp:1296
Enumerates target-specific builtins in their own namespaces within namespace clang.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:171
Kind
bool ReturnTypeUsesFPRet(QualType ResultType)
Return true iff the given type uses &#39;fpret&#39; when used as a return type.
Definition: CGCall.cpp:1522
CanProxy< U > castAs() const
static const Expr * maybeGetUnaryAddrOfOperand(const Expr *E)
Definition: CGCall.cpp:3230
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3743
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3680
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2246
A saved depth on the scope stack.
Definition: EHScopeStack.h:106
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
Definition: Interp.cpp:34
llvm::FunctionType * getVirtualFunctionType() const
Definition: CGCall.h:206
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3814
bool inheritingCtorHasParams(const InheritedConstructor &Inherited, CXXCtorType Type)
Determine if a C++ inheriting constructor should have parameters matching those of its inherited cons...
Definition: CGCall.cpp:296
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition: Type.h:3461
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
Definition: CGCleanup.cpp:1240
CallingConv getCC() const
Definition: Type.h:3592
const Decl * getDecl() const
Definition: GlobalDecl.h:77
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1884
An aggregate value slot.
Definition: CGValue.h:439
virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const =0
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition: CGCall.cpp:458
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI)
Compute the ABI information of a swiftcall function.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2466
const_arg_iterator arg_end() const
llvm::StructType * getArgStruct() const
Get the struct type used to represent all the arguments in memory.
ObjCEntrypoints & getObjCEntrypoints() const
CoerceAndExpand - Only valid for aggregate argument types.
void allocateArgumentMemory(CodeGenFunction &CGF)
Definition: CGCall.cpp:3369
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:743
CanQualType VoidTy
Definition: ASTContext.h:1016
llvm::InlineAsm * retainAutoreleasedReturnValueMarker
A void(void) inline asm to use to mark that the return value of a call will be immediately retain...
bool isAnyPointerType() const
Definition: Type.h:6508
An aligned address.
Definition: Address.h:24
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1174
bool useObjCFP2RetForComplexLongDouble() const
Check whether _Complex long double should use the "fp2ret" flavor of Objective-C message passing on t...
Definition: TargetInfo.h:746
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenTypes.h:120
All available information about a concrete callee.
Definition: CGCall.h:66
static SmallVector< CanQualType, 16 > getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args)
Definition: CGCall.cpp:364
Complete object dtor.
Definition: ABI.h:35
InAlloca - Pass the argument directly using the LLVM inalloca attribute.
bool ReturnTypeUsesFP2Ret(QualType ResultType)
Return true iff the given type uses &#39;fp2ret&#39; when used as a return type.
Definition: CGCall.cpp:1539
static void AddAttributesFromFunctionProtoType(ASTContext &Ctx, llvm::AttrBuilder &FuncAttrs, const FunctionProtoType *FPT)
Definition: CGCall.cpp:1694
bool hasFlexibleArrayMember() const
Definition: Decl.h:3802
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3989
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
const CGFunctionInfo & arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *type)
A block function is essentially a free function with an extra implicit argument.
Definition: CGCall.cpp:621
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
llvm::Type * getPaddingType() const
void setExternallyDestructed(bool destructed=true)
Definition: CGValue.h:554
static Address EnterStructPointerForCoercedAccess(Address SrcPtr, llvm::StructType *SrcSTy, uint64_t DstSize, CodeGenFunction &CGF)
EnterStructPointerForCoercedAccess - Given a struct pointer that we are accessing some number of byte...
Definition: CGCall.cpp:1133
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:355
bool getInAllocaSRet() const
Return true if this field of an inalloca struct should be returned to implement a struct return calli...
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
const TargetInfo & getTarget() const
Definition: CodeGenTypes.h:118
llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef< llvm::Value *> Args, const Twine &Name="")
Emits a call or invoke instruction to the given function, depending on the current state of the EH st...
Definition: CGCall.cpp:3784
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
Dataflow Directional Tag Classes.
ExtInfo getExtInfo() const
Definition: Type.h:3691
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition: CGValue.h:93
CodeGenFunction::ComplexPairTy ComplexPairTy
LValue Source
The original argument.
Definition: CGCall.h:268
const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)
Free functions are functions that are compatible with an ordinary C function pointer type...
Definition: CGCall.cpp:434
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2076
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
static void forConstantArrayExpansion(CodeGenFunction &CGF, ConstantArrayExpansion *CAE, Address BaseAddr, llvm::function_ref< void(Address)> Fn)
Definition: CGCall.cpp:1002
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3448
void EmitARCIntrinsicUse(ArrayRef< llvm::Value *> values)
Given a number of pointers, inform the optimizer that they&#39;re being intrinsically used up until this ...
Definition: CGObjC.cpp:1968
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:69
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2046
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
RValue getRValue(CodeGenFunction &CGF) const
Definition: CGCall.cpp:3565
static CGFunctionInfo * create(unsigned llvmCC, bool instanceMethod, bool chainCall, const FunctionType::ExtInfo &extInfo, ArrayRef< ExtParameterInfo > paramInfos, CanQualType resultType, ArrayRef< CanQualType > argTypes, RequiredArgs required)
Definition: CGCall.cpp:796
bool isBitField() const
Definition: CGValue.h:254
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:107
virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const
Determine whether a call to an unprototyped functions under the given calling convention should use t...
Definition: TargetInfo.cpp:401
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args)
Emits a call or invoke to the given noreturn runtime function.
Definition: CGCall.cpp:3743
ArrayRef< llvm::Type * > getCoerceAndExpandTypeSequence() const
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
Compute the arguments required by the given formal prototype, given that there may be some additional...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
Iterator for iterating over Stmt * arrays that contain only T *.
Definition: Stmt.h:1064
static bool classof(const OMPClause *T)
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:2105
QualType getCanonicalTypeInternal() const
Definition: Type.h:2429
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6811
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
static llvm::Value * tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result)
If this is a +1 of the value of an immutable &#39;self&#39;, remove it.
Definition: CGCall.cpp:2709
CharUnits getIndirectAlign() const
Implements C++ ABI-specific code generation functions.
Definition: CGCXXABI.h:43
T * getAttr() const
Definition: DeclBase.h:538
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
bool isMSVCXXPersonality() const
Definition: CGCleanup.h:644
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:59
llvm::StringRef getName() const
Return the IR name of the pointer value.
Definition: Address.h:61
Expand - Only valid for aggregate argument types.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
void getExpandedTypes(QualType Ty, SmallVectorImpl< llvm::Type *>::iterator &TI)
getExpandedTypes - Expand the type
Definition: CGCall.cpp:980
static std::unique_ptr< TypeExpansion > getTypeExpansion(QualType Ty, const ASTContext &Context)
Definition: CGCall.cpp:905
bool isParamDestroyedInCallee() const
Definition: Decl.h:3910
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:473
Represents a base class of a C++ class.
Definition: DeclCXX.h:145
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2115
ASTContext & getContext() const
Definition: CodeGenTypes.h:116
Pass it on the stack using its defined layout.
Definition: CGCXXABI.h:133
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:524
llvm::Type * GetFunctionTypeForVTable(GlobalDecl GD)
GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable, given a CXXMethodDecl...
Definition: CGCall.cpp:1684
LangAS getAddressSpace() const
Definition: CGValue.h:314
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
RValue getKnownRValue() const
Definition: CGCall.h:245
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
virtual const CXXRecordDecl * getThisArgumentTypeForMethod(const CXXMethodDecl *MD)
Get the type of the implicit "this" parameter used by a method.
Definition: CGCXXABI.h:333
bool isVoidType() const
Definition: Type.h:6777
llvm::Type * ConvertType(QualType T)
void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)
EmitFunctionProlog - Emit the target specific LLVM code to load the arguments for the given function...
Definition: CGCall.cpp:2257
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6283
virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0
Returns how an argument of the given record type should be passed.
const GlobalDecl getCalleeDecl() const
Definition: CGCall.h:62
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1246
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2465
bool isVariadic() const
Definition: DeclObjC.h:428
bool shouldCopy() const
shouldCopy - True if we should do the &#39;copy&#39; part of the copy-restore.
Definition: ExprObjC.h:1607
__DEVICE__ int min(int __a, int __b)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
Definition: CGExpr.cpp:1777
Copying closure variant of a ctor.
Definition: ABI.h:28
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2546
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows)
Definition: CGCall.cpp:200
bool hasLValue() const
Definition: CGCall.h:234
bool isCanonicalAsParam() const
Determines if this canonical type is furthermore canonical as a parameter.
CGCXXABI & getCXXABI() const
const CGFunctionInfo & arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT)
Definition: CGCall.cpp:540
CanQualType IntTy
Definition: ASTContext.h:1025
bool constructsVirtualBase() const
Returns true if the constructed base class is a virtual base class subobject of this declaration&#39;s cl...
Definition: DeclCXX.h:3355
llvm::Function * objc_retain
id objc_retain(id);
static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs)
Definition: CGCall.cpp:3219
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1902
const FunctionProtoType * getCalleeFunctionProtoType() const
Definition: CGCall.h:59
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
bool isUnion() const
Definition: Decl.h:3407
bool isPointerType() const
Definition: Type.h:6504
unsigned getNumRequiredArgs() const
unsigned getDirectOffset() const
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Figure out the rules for calling a function with the given formal type using the given arguments...
Definition: CGCall.cpp:611
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI)
QualType getType() const
Definition: Decl.h:630
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:107
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
bool Load(InterpState &S, CodePtr OpPC)
Definition: Interp.h:616
ExtParameterInfo getExtParameterInfo(unsigned argIndex) const
LValue - This represents an lvalue references.
Definition: CGValue.h:167
An abstract representation of regular/ObjC call/message targets.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1531
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:146
virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, Address This, llvm::Type *Ty, SourceLocation Loc)=0
Build a virtual function pointer in the ABI-specific way.
RValue asRValue() const
Definition: CGValue.h:607
llvm::Type * getCoerceToType() const
CGCalleeInfo getAbstractInfo() const
Definition: CGCall.h:176
Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list...
Definition: CGCXXABI.h:295
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2557
void AddDefaultFnAttrs(llvm::Function &F)
Adds attributes to F according to our CodeGenOptions and LangOptions, as though we had emitted it our...
Definition: CGCall.cpp:1829
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:163
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3774
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:261
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:675
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
Abstract information about a function or function prototype.
Definition: CGCall.h:44
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3533
bool isScalar() const
Definition: CGValue.h:52
Attr - This represents one attribute.
Definition: Attr.h:45
This parameter (which must have pointer type) is a Swift indirect result parameter.
static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)
Get the type of the Nth parameter from a given set of overload candidates.
ConstructorUsingShadowDecl * getShadowDecl() const
Definition: DeclCXX.h:2369
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:368
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2991
ArrayRef< CallArgCleanup > getCleanupsToDeactivate() const
Definition: CGCall.h:328
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign, ASTContext &Context)
A helper function to get the alignment of a Decl referred to by DeclRefExpr or MemberExpr.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1556