| //===--- CGCall.cpp - Encapsulate calling convention details --------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // These classes wrap the information about a call or function |
| // definition used to handle ABI compliancy. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CGCall.h" |
| #include "ABIInfo.h" |
| #include "CGBlocks.h" |
| #include "CGCXXABI.h" |
| #include "CGCleanup.h" |
| #include "CGRecordLayout.h" |
| #include "CodeGenFunction.h" |
| #include "CodeGenModule.h" |
| #include "TargetInfo.h" |
| #include "clang/AST/Attr.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/Basic/CodeGenOptions.h" |
| #include "clang/Basic/TargetBuiltins.h" |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/CodeGen/CGFunctionInfo.h" |
| #include "clang/CodeGen/SwiftCallingConv.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/Analysis/ValueTracking.h" |
| #include "llvm/IR/Attributes.h" |
| #include "llvm/IR/CallingConv.h" |
| #include "llvm/IR/DataLayout.h" |
| #include "llvm/IR/InlineAsm.h" |
| #include "llvm/IR/IntrinsicInst.h" |
| #include "llvm/IR/Intrinsics.h" |
| #include "llvm/Transforms/Utils/Local.h" |
| using namespace clang; |
| using namespace CodeGen; |
| |
| /***/ |
| |
| unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) { |
| switch (CC) { |
| default: return llvm::CallingConv::C; |
| case CC_X86StdCall: return llvm::CallingConv::X86_StdCall; |
| case CC_X86FastCall: return llvm::CallingConv::X86_FastCall; |
| case CC_X86RegCall: return llvm::CallingConv::X86_RegCall; |
| case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall; |
| case CC_Win64: return llvm::CallingConv::Win64; |
| case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV; |
| case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS; |
| case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP; |
| case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI; |
| // TODO: Add support for __pascal to LLVM. |
| case CC_X86Pascal: return llvm::CallingConv::C; |
| // TODO: Add support for __vectorcall to LLVM. |
| case CC_X86VectorCall: return llvm::CallingConv::X86_VectorCall; |
| case CC_AArch64VectorCall: return llvm::CallingConv::AArch64_VectorCall; |
| case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC; |
| case CC_OpenCLKernel: return CGM.getTargetCodeGenInfo().getOpenCLKernelCallingConv(); |
| case CC_PreserveMost: return llvm::CallingConv::PreserveMost; |
| case CC_PreserveAll: return llvm::CallingConv::PreserveAll; |
| case CC_Swift: return llvm::CallingConv::Swift; |
| } |
| } |
| |
| /// Derives the 'this' type for codegen purposes, i.e. ignoring method CVR |
| /// qualification. Either or both of RD and MD may be null. A null RD indicates |
| /// that there is no meaningful 'this' type, and a null MD can occur when |
| /// calling a method pointer. |
| CanQualType CodeGenTypes::DeriveThisType(const CXXRecordDecl *RD, |
| const CXXMethodDecl *MD) { |
| QualType RecTy; |
| if (RD) |
| RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal(); |
| else |
| RecTy = Context.VoidTy; |
| |
| if (MD) |
| RecTy = Context.getAddrSpaceQualType(RecTy, MD->getMethodQualifiers().getAddressSpace()); |
| return Context.getPointerType(CanQualType::CreateUnsafe(RecTy)); |
| } |
| |
| /// Returns the canonical formal type of the given C++ method. |
| static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) { |
| return MD->getType()->getCanonicalTypeUnqualified() |
| .getAs<FunctionProtoType>(); |
| } |
| |
| /// Returns the "extra-canonicalized" return type, which discards |
| /// qualifiers on the return type. Codegen doesn't care about them, |
| /// and it makes ABI code a little easier to be able to assume that |
| /// all parameter and return types are top-level unqualified. |
| static CanQualType GetReturnType(QualType RetTy) { |
| return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType(); |
| } |
| |
| /// Arrange the argument and result information for a value of the given |
| /// unprototyped freestanding function type. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) { |
| // When translating an unprototyped function type, always use a |
| // variadic type. |
| return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(), |
| /*instanceMethod=*/false, |
| /*chainCall=*/false, None, |
| FTNP->getExtInfo(), {}, RequiredArgs(0)); |
| } |
| |
| static void addExtParameterInfosForCall( |
| llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo> ¶mInfos, |
| const FunctionProtoType *proto, |
| unsigned prefixArgs, |
| unsigned totalArgs) { |
| assert(proto->hasExtParameterInfos()); |
| assert(paramInfos.size() <= prefixArgs); |
| assert(proto->getNumParams() + prefixArgs <= totalArgs); |
| |
| paramInfos.reserve(totalArgs); |
| |
| // Add default infos for any prefix args that don't already have infos. |
| paramInfos.resize(prefixArgs); |
| |
| // Add infos for the prototype. |
| for (const auto &ParamInfo : proto->getExtParameterInfos()) { |
| paramInfos.push_back(ParamInfo); |
| // pass_object_size params have no parameter info. |
| if (ParamInfo.hasPassObjectSize()) |
| paramInfos.emplace_back(); |
| } |
| |
| assert(paramInfos.size() <= totalArgs && |
| "Did we forget to insert pass_object_size args?"); |
| // Add default infos for the variadic and/or suffix arguments. |
| paramInfos.resize(totalArgs); |
| } |
| |
| /// Adds the formal parameters in FPT to the given prefix. If any parameter in |
| /// FPT has pass_object_size attrs, then we'll add parameters for those, too. |
| static void appendParameterTypes(const CodeGenTypes &CGT, |
| SmallVectorImpl<CanQualType> &prefix, |
| SmallVectorImpl<FunctionProtoType::ExtParameterInfo> ¶mInfos, |
| CanQual<FunctionProtoType> FPT) { |
| // Fast path: don't touch param info if we don't need to. |
| if (!FPT->hasExtParameterInfos()) { |
| assert(paramInfos.empty() && |
| "We have paramInfos, but the prototype doesn't?"); |
| prefix.append(FPT->param_type_begin(), FPT->param_type_end()); |
| return; |
| } |
| |
| unsigned PrefixSize = prefix.size(); |
| // In the vast majority of cases, we'll have precisely FPT->getNumParams() |
| // parameters; the only thing that can change this is the presence of |
| // pass_object_size. So, we preallocate for the common case. |
| prefix.reserve(prefix.size() + FPT->getNumParams()); |
| |
| auto ExtInfos = FPT->getExtParameterInfos(); |
| assert(ExtInfos.size() == FPT->getNumParams()); |
| for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) { |
| prefix.push_back(FPT->getParamType(I)); |
| if (ExtInfos[I].hasPassObjectSize()) |
| prefix.push_back(CGT.getContext().getSizeType()); |
| } |
| |
| addExtParameterInfosForCall(paramInfos, FPT.getTypePtr(), PrefixSize, |
| prefix.size()); |
| } |
| |
| /// Arrange the LLVM function layout for a value of the given function |
| /// type, on top of any implicit parameters already stored. |
| static const CGFunctionInfo & |
| arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, |
| SmallVectorImpl<CanQualType> &prefix, |
| CanQual<FunctionProtoType> FTP) { |
| SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos; |
| RequiredArgs Required = RequiredArgs::forPrototypePlus(FTP, prefix.size()); |
| // FIXME: Kill copy. |
| appendParameterTypes(CGT, prefix, paramInfos, FTP); |
| CanQualType resultType = FTP->getReturnType().getUnqualifiedType(); |
| |
| return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod, |
| /*chainCall=*/false, prefix, |
| FTP->getExtInfo(), paramInfos, |
| Required); |
| } |
| |
| /// Arrange the argument and result information for a value of the |
| /// given freestanding function type. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) { |
| SmallVector<CanQualType, 16> argTypes; |
| return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes, |
| FTP); |
| } |
| |
| static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) { |
| // Set the appropriate calling convention for the Function. |
| if (D->hasAttr<StdCallAttr>()) |
| return CC_X86StdCall; |
| |
| if (D->hasAttr<FastCallAttr>()) |
| return CC_X86FastCall; |
| |
| if (D->hasAttr<RegCallAttr>()) |
| return CC_X86RegCall; |
| |
| if (D->hasAttr<ThisCallAttr>()) |
| return CC_X86ThisCall; |
| |
| if (D->hasAttr<VectorCallAttr>()) |
| return CC_X86VectorCall; |
| |
| if (D->hasAttr<PascalAttr>()) |
| return CC_X86Pascal; |
| |
| if (PcsAttr *PCS = D->getAttr<PcsAttr>()) |
| return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP); |
| |
| if (D->hasAttr<AArch64VectorPcsAttr>()) |
| return CC_AArch64VectorCall; |
| |
| if (D->hasAttr<IntelOclBiccAttr>()) |
| return CC_IntelOclBicc; |
| |
| if (D->hasAttr<MSABIAttr>()) |
| return IsWindows ? CC_C : CC_Win64; |
| |
| if (D->hasAttr<SysVABIAttr>()) |
| return IsWindows ? CC_X86_64SysV : CC_C; |
| |
| if (D->hasAttr<PreserveMostAttr>()) |
| return CC_PreserveMost; |
| |
| if (D->hasAttr<PreserveAllAttr>()) |
| return CC_PreserveAll; |
| |
| return CC_C; |
| } |
| |
| /// Arrange the argument and result information for a call to an |
| /// unknown C++ non-static member function of the given abstract type. |
| /// (A null RD means we don't have any meaningful "this" argument type, |
| /// so fall back to a generic pointer type). |
| /// The member function must be an ordinary function, i.e. not a |
| /// constructor or destructor. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD, |
| const FunctionProtoType *FTP, |
| const CXXMethodDecl *MD) { |
| SmallVector<CanQualType, 16> argTypes; |
| |
| // Add the 'this' pointer. |
| argTypes.push_back(DeriveThisType(RD, MD)); |
| |
| return ::arrangeLLVMFunctionInfo( |
| *this, true, argTypes, |
| FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>()); |
| } |
| |
| /// Set calling convention for CUDA/HIP kernel. |
| static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, |
| const FunctionDecl *FD) { |
| if (FD->hasAttr<CUDAGlobalAttr>()) { |
| const FunctionType *FT = FTy->getAs<FunctionType>(); |
| CGM.getTargetCodeGenInfo().setCUDAKernelCallingConvention(FT); |
| FTy = FT->getCanonicalTypeUnqualified(); |
| } |
| } |
| |
| /// Arrange the argument and result information for a declaration or |
| /// definition of the given C++ non-static member function. The |
| /// member function must be an ordinary function, i.e. not a |
| /// constructor or destructor. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) { |
| assert(!isa<CXXConstructorDecl>(MD) && "wrong method for constructors!"); |
| assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!"); |
| |
| CanQualType FT = GetFormalType(MD).getAs<Type>(); |
| setCUDAKernelCallingConvention(FT, CGM, MD); |
| auto prototype = FT.getAs<FunctionProtoType>(); |
| |
| if (MD->isInstance()) { |
| // The abstract case is perfectly fine. |
| const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD); |
| return arrangeCXXMethodType(ThisType, prototype.getTypePtr(), MD); |
| } |
| |
| return arrangeFreeFunctionType(prototype); |
| } |
| |
| bool CodeGenTypes::inheritingCtorHasParams( |
| const InheritedConstructor &Inherited, CXXCtorType Type) { |
| // Parameters are unnecessary if we're constructing a base class subobject |
| // and the inherited constructor lives in a virtual base. |
| return Type == Ctor_Complete || |
| !Inherited.getShadowDecl()->constructsVirtualBase() || |
| !Target.getCXXABI().hasConstructorVariants(); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCXXStructorDeclaration(GlobalDecl GD) { |
| auto *MD = cast<CXXMethodDecl>(GD.getDecl()); |
| |
| SmallVector<CanQualType, 16> argTypes; |
| SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos; |
| argTypes.push_back(DeriveThisType(MD->getParent(), MD)); |
| |
| bool PassParams = true; |
| |
| if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) { |
| // A base class inheriting constructor doesn't get forwarded arguments |
| // needed to construct a virtual base (or base class thereof). |
| if (auto Inherited = CD->getInheritedConstructor()) |
| PassParams = inheritingCtorHasParams(Inherited, GD.getCtorType()); |
| } |
| |
| CanQual<FunctionProtoType> FTP = GetFormalType(MD); |
| |
| // Add the formal parameters. |
| if (PassParams) |
| appendParameterTypes(*this, argTypes, paramInfos, FTP); |
| |
| CGCXXABI::AddedStructorArgCounts AddedArgs = |
| TheCXXABI.buildStructorSignature(GD, argTypes); |
| if (!paramInfos.empty()) { |
| // Note: prefix implies after the first param. |
| if (AddedArgs.Prefix) |
| paramInfos.insert(paramInfos.begin() + 1, AddedArgs.Prefix, |
| FunctionProtoType::ExtParameterInfo{}); |
| if (AddedArgs.Suffix) |
| paramInfos.append(AddedArgs.Suffix, |
| FunctionProtoType::ExtParameterInfo{}); |
| } |
| |
| RequiredArgs required = |
| (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size()) |
| : RequiredArgs::All); |
| |
| FunctionType::ExtInfo extInfo = FTP->getExtInfo(); |
| CanQualType resultType = TheCXXABI.HasThisReturn(GD) |
| ? argTypes.front() |
| : TheCXXABI.hasMostDerivedReturn(GD) |
| ? CGM.getContext().VoidPtrTy |
| : Context.VoidTy; |
| return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true, |
| /*chainCall=*/false, argTypes, extInfo, |
| paramInfos, required); |
| } |
| |
| static SmallVector<CanQualType, 16> |
| getArgTypesForCall(ASTContext &ctx, const CallArgList &args) { |
| SmallVector<CanQualType, 16> argTypes; |
| for (auto &arg : args) |
| argTypes.push_back(ctx.getCanonicalParamType(arg.Ty)); |
| return argTypes; |
| } |
| |
| static SmallVector<CanQualType, 16> |
| getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) { |
| SmallVector<CanQualType, 16> argTypes; |
| for (auto &arg : args) |
| argTypes.push_back(ctx.getCanonicalParamType(arg->getType())); |
| return argTypes; |
| } |
| |
| static llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> |
| getExtParameterInfosForCall(const FunctionProtoType *proto, |
| unsigned prefixArgs, unsigned totalArgs) { |
| llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> result; |
| if (proto->hasExtParameterInfos()) { |
| addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs); |
| } |
| return result; |
| } |
| |
| /// Arrange a call to a C++ method, passing the given arguments. |
| /// |
| /// ExtraPrefixArgs is the number of ABI-specific args passed after the `this` |
| /// parameter. |
| /// ExtraSuffixArgs is the number of ABI-specific args passed at the end of |
| /// args. |
| /// PassProtoArgs indicates whether `args` has args for the parameters in the |
| /// given CXXConstructorDecl. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args, |
| const CXXConstructorDecl *D, |
| CXXCtorType CtorKind, |
| unsigned ExtraPrefixArgs, |
| unsigned ExtraSuffixArgs, |
| bool PassProtoArgs) { |
| // FIXME: Kill copy. |
| SmallVector<CanQualType, 16> ArgTypes; |
| for (const auto &Arg : args) |
| ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); |
| |
| // +1 for implicit this, which should always be args[0]. |
| unsigned TotalPrefixArgs = 1 + ExtraPrefixArgs; |
| |
| CanQual<FunctionProtoType> FPT = GetFormalType(D); |
| RequiredArgs Required = PassProtoArgs |
| ? RequiredArgs::forPrototypePlus( |
| FPT, TotalPrefixArgs + ExtraSuffixArgs) |
| : RequiredArgs::All; |
| |
| GlobalDecl GD(D, CtorKind); |
| CanQualType ResultType = TheCXXABI.HasThisReturn(GD) |
| ? ArgTypes.front() |
| : TheCXXABI.hasMostDerivedReturn(GD) |
| ? CGM.getContext().VoidPtrTy |
| : Context.VoidTy; |
| |
| FunctionType::ExtInfo Info = FPT->getExtInfo(); |
| llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> ParamInfos; |
| // If the prototype args are elided, we should only have ABI-specific args, |
| // which never have param info. |
| if (PassProtoArgs && FPT->hasExtParameterInfos()) { |
| // ABI-specific suffix arguments are treated the same as variadic arguments. |
| addExtParameterInfosForCall(ParamInfos, FPT.getTypePtr(), TotalPrefixArgs, |
| ArgTypes.size()); |
| } |
| return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true, |
| /*chainCall=*/false, ArgTypes, Info, |
| ParamInfos, Required); |
| } |
| |
| /// Arrange the argument and result information for the declaration or |
| /// definition of the given function. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) { |
| if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) |
| if (MD->isInstance()) |
| return arrangeCXXMethodDeclaration(MD); |
| |
| CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified(); |
| |
| assert(isa<FunctionType>(FTy)); |
| setCUDAKernelCallingConvention(FTy, CGM, FD); |
| |
| // When declaring a function without a prototype, always use a |
| // non-variadic type. |
| if (CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>()) { |
| return arrangeLLVMFunctionInfo( |
| noProto->getReturnType(), /*instanceMethod=*/false, |
| /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All); |
| } |
| |
| return arrangeFreeFunctionType(FTy.castAs<FunctionProtoType>()); |
| } |
| |
| /// Arrange the argument and result information for the declaration or |
| /// definition of an Objective-C method. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) { |
| // It happens that this is the same as a call with no optional |
| // arguments, except also using the formal 'self' type. |
| return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType()); |
| } |
| |
| /// Arrange the argument and result information for the function type |
| /// through which to perform a send to the given Objective-C method, |
| /// using the given receiver type. The receiver type is not always |
| /// the 'self' type of the method or even an Objective-C pointer type. |
| /// This is *not* the right method for actually performing such a |
| /// message send, due to the possibility of optional arguments. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD, |
| QualType receiverType) { |
| SmallVector<CanQualType, 16> argTys; |
| SmallVector<FunctionProtoType::ExtParameterInfo, 4> extParamInfos(2); |
| argTys.push_back(Context.getCanonicalParamType(receiverType)); |
| argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType())); |
| // FIXME: Kill copy? |
| for (const auto *I : MD->parameters()) { |
| argTys.push_back(Context.getCanonicalParamType(I->getType())); |
| auto extParamInfo = FunctionProtoType::ExtParameterInfo().withIsNoEscape( |
| I->hasAttr<NoEscapeAttr>()); |
| extParamInfos.push_back(extParamInfo); |
| } |
| |
| FunctionType::ExtInfo einfo; |
| bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows(); |
| einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows)); |
| |
| if (getContext().getLangOpts().ObjCAutoRefCount && |
| MD->hasAttr<NSReturnsRetainedAttr>()) |
| einfo = einfo.withProducesResult(true); |
| |
| RequiredArgs required = |
| (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All); |
| |
| return arrangeLLVMFunctionInfo( |
| GetReturnType(MD->getReturnType()), /*instanceMethod=*/false, |
| /*chainCall=*/false, argTys, einfo, extParamInfos, required); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeUnprototypedObjCMessageSend(QualType returnType, |
| const CallArgList &args) { |
| auto argTypes = getArgTypesForCall(Context, args); |
| FunctionType::ExtInfo einfo; |
| |
| return arrangeLLVMFunctionInfo( |
| GetReturnType(returnType), /*instanceMethod=*/false, |
| /*chainCall=*/false, argTypes, einfo, {}, RequiredArgs::All); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { |
| // FIXME: Do we need to handle ObjCMethodDecl? |
| const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); |
| |
| if (isa<CXXConstructorDecl>(GD.getDecl()) || |
| isa<CXXDestructorDecl>(GD.getDecl())) |
| return arrangeCXXStructorDeclaration(GD); |
| |
| return arrangeFunctionDeclaration(FD); |
| } |
| |
| /// Arrange a thunk that takes 'this' as the first parameter followed by |
| /// varargs. Return a void pointer, regardless of the actual return type. |
| /// The body of the thunk will end in a musttail call to a function of the |
| /// correct type, and the caller will bitcast the function to the correct |
| /// prototype. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) { |
| assert(MD->isVirtual() && "only methods have thunks"); |
| CanQual<FunctionProtoType> FTP = GetFormalType(MD); |
| CanQualType ArgTys[] = {DeriveThisType(MD->getParent(), MD)}; |
| return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false, |
| /*chainCall=*/false, ArgTys, |
| FTP->getExtInfo(), {}, RequiredArgs(1)); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeMSCtorClosure(const CXXConstructorDecl *CD, |
| CXXCtorType CT) { |
| assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure); |
| |
| CanQual<FunctionProtoType> FTP = GetFormalType(CD); |
| SmallVector<CanQualType, 2> ArgTys; |
| const CXXRecordDecl *RD = CD->getParent(); |
| ArgTys.push_back(DeriveThisType(RD, CD)); |
| if (CT == Ctor_CopyingClosure) |
| ArgTys.push_back(*FTP->param_type_begin()); |
| if (RD->getNumVBases() > 0) |
| ArgTys.push_back(Context.IntTy); |
| CallingConv CC = Context.getDefaultCallingConvention( |
| /*IsVariadic=*/false, /*IsCXXMethod=*/true); |
| return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/true, |
| /*chainCall=*/false, ArgTys, |
| FunctionType::ExtInfo(CC), {}, |
| RequiredArgs::All); |
| } |
| |
| /// Arrange a call as unto a free function, except possibly with an |
| /// additional number of formal parameters considered required. |
| static const CGFunctionInfo & |
| arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, |
| CodeGenModule &CGM, |
| const CallArgList &args, |
| const FunctionType *fnType, |
| unsigned numExtraRequiredArgs, |
| bool chainCall) { |
| assert(args.size() >= numExtraRequiredArgs); |
| |
| llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos; |
| |
| // In most cases, there are no optional arguments. |
| RequiredArgs required = RequiredArgs::All; |
| |
| // If we have a variadic prototype, the required arguments are the |
| // extra prefix plus the arguments in the prototype. |
| if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) { |
| if (proto->isVariadic()) |
| required = RequiredArgs::forPrototypePlus(proto, numExtraRequiredArgs); |
| |
| if (proto->hasExtParameterInfos()) |
| addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs, |
| args.size()); |
| |
| // If we don't have a prototype at all, but we're supposed to |
| // explicitly use the variadic convention for unprototyped calls, |
| // treat all of the arguments as required but preserve the nominal |
| // possibility of variadics. |
| } else if (CGM.getTargetCodeGenInfo() |
| .isNoProtoCallVariadic(args, |
| cast<FunctionNoProtoType>(fnType))) { |
| required = RequiredArgs(args.size()); |
| } |
| |
| // FIXME: Kill copy. |
| SmallVector<CanQualType, 16> argTypes; |
| for (const auto &arg : args) |
| argTypes.push_back(CGT.getContext().getCanonicalParamType(arg.Ty)); |
| return CGT.arrangeLLVMFunctionInfo(GetReturnType(fnType->getReturnType()), |
| /*instanceMethod=*/false, chainCall, |
| argTypes, fnType->getExtInfo(), paramInfos, |
| required); |
| } |
| |
| /// Figure out the rules for calling a function with the given formal |
| /// type using the given arguments. The arguments are necessary |
| /// because the function might be unprototyped, in which case it's |
| /// target-dependent in crazy ways. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args, |
| const FunctionType *fnType, |
| bool chainCall) { |
| return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, |
| chainCall ? 1 : 0, chainCall); |
| } |
| |
| /// A block function is essentially a free function with an |
| /// extra implicit argument. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, |
| const FunctionType *fnType) { |
| return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1, |
| /*chainCall=*/false); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeBlockFunctionDeclaration(const FunctionProtoType *proto, |
| const FunctionArgList ¶ms) { |
| auto paramInfos = getExtParameterInfosForCall(proto, 1, params.size()); |
| auto argTypes = getArgTypesForDeclaration(Context, params); |
| |
| return arrangeLLVMFunctionInfo(GetReturnType(proto->getReturnType()), |
| /*instanceMethod*/ false, /*chainCall*/ false, |
| argTypes, proto->getExtInfo(), paramInfos, |
| RequiredArgs::forPrototypePlus(proto, 1)); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType, |
| const CallArgList &args) { |
| // FIXME: Kill copy. |
| SmallVector<CanQualType, 16> argTypes; |
| for (const auto &Arg : args) |
| argTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); |
| return arrangeLLVMFunctionInfo( |
| GetReturnType(resultType), /*instanceMethod=*/false, |
| /*chainCall=*/false, argTypes, FunctionType::ExtInfo(), |
| /*paramInfos=*/ {}, RequiredArgs::All); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeBuiltinFunctionDeclaration(QualType resultType, |
| const FunctionArgList &args) { |
| auto argTypes = getArgTypesForDeclaration(Context, args); |
| |
| return arrangeLLVMFunctionInfo( |
| GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false, |
| argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType, |
| ArrayRef<CanQualType> argTypes) { |
| return arrangeLLVMFunctionInfo( |
| resultType, /*instanceMethod=*/false, /*chainCall=*/false, |
| argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All); |
| } |
| |
| /// Arrange a call to a C++ method, passing the given arguments. |
| /// |
| /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It |
| /// does not count `this`. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, |
| const FunctionProtoType *proto, |
| RequiredArgs required, |
| unsigned numPrefixArgs) { |
| assert(numPrefixArgs + 1 <= args.size() && |
| "Emitting a call with less args than the required prefix?"); |
| // Add one to account for `this`. It's a bit awkward here, but we don't count |
| // `this` in similar places elsewhere. |
| auto paramInfos = |
| getExtParameterInfosForCall(proto, numPrefixArgs + 1, args.size()); |
| |
| // FIXME: Kill copy. |
| auto argTypes = getArgTypesForCall(Context, args); |
| |
| FunctionType::ExtInfo info = proto->getExtInfo(); |
| return arrangeLLVMFunctionInfo( |
| GetReturnType(proto->getReturnType()), /*instanceMethod=*/true, |
| /*chainCall=*/false, argTypes, info, paramInfos, required); |
| } |
| |
| const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { |
| return arrangeLLVMFunctionInfo( |
| getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false, |
| None, FunctionType::ExtInfo(), {}, RequiredArgs::All); |
| } |
| |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeCall(const CGFunctionInfo &signature, |
| const CallArgList &args) { |
| assert(signature.arg_size() <= args.size()); |
| if (signature.arg_size() == args.size()) |
| return signature; |
| |
| SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos; |
| auto sigParamInfos = signature.getExtParameterInfos(); |
| if (!sigParamInfos.empty()) { |
| paramInfos.append(sigParamInfos.begin(), sigParamInfos.end()); |
| paramInfos.resize(args.size()); |
| } |
| |
| auto argTypes = getArgTypesForCall(Context, args); |
| |
| assert(signature.getRequiredArgs().allowsOptionalArgs()); |
| return arrangeLLVMFunctionInfo(signature.getReturnType(), |
| signature.isInstanceMethod(), |
| signature.isChainCall(), |
| argTypes, |
| signature.getExtInfo(), |
| paramInfos, |
| signature.getRequiredArgs()); |
| } |
| |
| namespace clang { |
| namespace CodeGen { |
| void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI); |
| } |
| } |
| |
| /// Arrange the argument and result information for an abstract value |
| /// of a given function type. This is the method which all of the |
| /// above functions ultimately defer to. |
| const CGFunctionInfo & |
| CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType, |
| bool instanceMethod, |
| bool chainCall, |
| ArrayRef<CanQualType> argTypes, |
| FunctionType::ExtInfo info, |
| ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos, |
| RequiredArgs required) { |
| assert(llvm::all_of(argTypes, |
| [](CanQualType T) { return T.isCanonicalAsParam(); })); |
| |
| // Lookup or create unique function info. |
| llvm::FoldingSetNodeID ID; |
| CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos, |
| required, resultType, argTypes); |
| |
| void *insertPos = nullptr; |
| CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); |
| if (FI) |
| return *FI; |
| |
| unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); |
| |
| // Construct the function info. We co-allocate the ArgInfos. |
| FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info, |
| paramInfos, resultType, argTypes, required); |
| FunctionInfos.InsertNode(FI, insertPos); |
| |
| bool inserted = FunctionsBeingProcessed.insert(FI).second; |
| (void)inserted; |
| assert(inserted && "Recursively being processed?"); |
| |
| // Compute ABI information. |
| if (CC == llvm::CallingConv::SPIR_KERNEL) { |
| // Force target independent argument handling for the host visible |
| // kernel functions. |
| computeSPIRKernelABIInfo(CGM, *FI); |
| } else if (info.getCC() == CC_Swift) { |
| swiftcall::computeABIInfo(CGM, *FI); |
| } else { |
| getABIInfo().computeInfo(*FI); |
| } |
| |
| // Loop over all of the computed argument and return value info. If any of |
| // them are direct or extend without a specified coerce type, specify the |
| // default now. |
| ABIArgInfo &retInfo = FI->getReturnInfo(); |
| if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr) |
| retInfo.setCoerceToType(ConvertType(FI->getReturnType())); |
| |
| for (auto &I : FI->arguments()) |
| if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr) |
| I.info.setCoerceToType(ConvertType(I.type)); |
| |
| bool erased = FunctionsBeingProcessed.erase(FI); (void)erased; |
| assert(erased && "Not in set?"); |
| |
| return *FI; |
| } |
| |
| CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, |
| bool instanceMethod, |
| bool chainCall, |
| const FunctionType::ExtInfo &info, |
| ArrayRef<ExtParameterInfo> paramInfos, |
| CanQualType resultType, |
| ArrayRef<CanQualType> argTypes, |
| RequiredArgs required) { |
| assert(paramInfos.empty() || paramInfos.size() == argTypes.size()); |
| assert(!required.allowsOptionalArgs() || |
| required.getNumRequiredArgs() <= argTypes.size()); |
| |
| void *buffer = |
| operator new(totalSizeToAlloc<ArgInfo, ExtParameterInfo>( |
| argTypes.size() + 1, paramInfos.size())); |
| |
| CGFunctionInfo *FI = new(buffer) CGFunctionInfo(); |
| FI->CallingConvention = llvmCC; |
| FI->EffectiveCallingConvention = llvmCC; |
| FI->ASTCallingConvention = info.getCC(); |
| FI->InstanceMethod = instanceMethod; |
| FI->ChainCall = chainCall; |
| FI->CmseNSCall = info.getCmseNSCall(); |
| FI->NoReturn = info.getNoReturn(); |
| FI->ReturnsRetained = info.getProducesResult(); |
| FI->NoCallerSavedRegs = info.getNoCallerSavedRegs(); |
| FI->NoCfCheck = info.getNoCfCheck(); |
| FI->Required = required; |
| FI->HasRegParm = info.getHasRegParm(); |
| FI->RegParm = info.getRegParm(); |
| FI->ArgStruct = nullptr; |
| FI->ArgStructAlign = 0; |
| FI->NumArgs = argTypes.size(); |
| FI->HasExtParameterInfos = !paramInfos.empty(); |
| FI->getArgsBuffer()[0].type = resultType; |
| for (unsigned i = 0, e = argTypes.size(); i != e; ++i) |
| FI->getArgsBuffer()[i + 1].type = argTypes[i]; |
| for (unsigned i = 0, e = paramInfos.size(); i != e; ++i) |
| FI->getExtParameterInfosBuffer()[i] = paramInfos[i]; |
| return FI; |
| } |
| |
| /***/ |
| |
| namespace { |
| // ABIArgInfo::Expand implementation. |
| |
| // Specifies the way QualType passed as ABIArgInfo::Expand is expanded. |
| struct TypeExpansion { |
| enum TypeExpansionKind { |
| // Elements of constant arrays are expanded recursively. |
| TEK_ConstantArray, |
| // Record fields are expanded recursively (but if record is a union, only |
| // the field with the largest size is expanded). |
| TEK_Record, |
| // For complex types, real and imaginary parts are expanded recursively. |
| TEK_Complex, |
| // All other types are not expandable. |
| TEK_None |
| }; |
| |
| const TypeExpansionKind Kind; |
| |
| TypeExpansion(TypeExpansionKind K) : Kind(K) {} |
| virtual ~TypeExpansion() {} |
| }; |
| |
| struct ConstantArrayExpansion : TypeExpansion { |
| QualType EltTy; |
| uint64_t NumElts; |
| |
| ConstantArrayExpansion(QualType EltTy, uint64_t NumElts) |
| : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {} |
| static bool classof(const TypeExpansion *TE) { |
| return TE->Kind == TEK_ConstantArray; |
| } |
| }; |
| |
| struct RecordExpansion : TypeExpansion { |
| SmallVector<const CXXBaseSpecifier *, 1> Bases; |
| |
| SmallVector<const FieldDecl *, 1> Fields; |
| |
| RecordExpansion(SmallVector<const CXXBaseSpecifier *, 1> &&Bases, |
| SmallVector<const FieldDecl *, 1> &&Fields) |
| : TypeExpansion(TEK_Record), Bases(std::move(Bases)), |
| Fields(std::move(Fields)) {} |
| static bool classof(const TypeExpansion *TE) { |
| return TE->Kind == TEK_Record; |
| } |
| }; |
| |
| struct ComplexExpansion : TypeExpansion { |
| QualType EltTy; |
| |
| ComplexExpansion(QualType EltTy) : TypeExpansion(TEK_Complex), EltTy(EltTy) {} |
| static bool classof(const TypeExpansion *TE) { |
| return TE->Kind == TEK_Complex; |
| } |
| }; |
| |
| struct NoExpansion : TypeExpansion { |
| NoExpansion() : TypeExpansion(TEK_None) {} |
| static bool classof(const TypeExpansion *TE) { |
| return TE->Kind == TEK_None; |
| } |
| }; |
| } // namespace |
| |
| static std::unique_ptr<TypeExpansion> |
| getTypeExpansion(QualType Ty, const ASTContext &Context) { |
| if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) { |
| return std::make_unique<ConstantArrayExpansion>( |
| AT->getElementType(), AT->getSize().getZExtValue()); |
| } |
| if (const RecordType *RT = Ty->getAs<RecordType>()) { |
| SmallVector<const CXXBaseSpecifier *, 1> Bases; |
| SmallVector<const FieldDecl *, 1> Fields; |
| const RecordDecl *RD = RT->getDecl(); |
| assert(!RD->hasFlexibleArrayMember() && |
| "Cannot expand structure with flexible array."); |
| if (RD->isUnion()) { |
| // Unions can be here only in degenerative cases - all the fields are same |
| // after flattening. Thus we have to use the "largest" field. |
| const FieldDecl *LargestFD = nullptr; |
| CharUnits UnionSize = CharUnits::Zero(); |
| |
| for (const auto *FD : RD->fields()) { |
| if (FD->isZeroLengthBitField(Context)) |
| continue; |
| assert(!FD->isBitField() && |
| "Cannot expand structure with bit-field members."); |
| CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType()); |
| if (UnionSize < FieldSize) { |
| UnionSize = FieldSize; |
| LargestFD = FD; |
| } |
| } |
| if (LargestFD) |
| Fields.push_back(LargestFD); |
| } else { |
| if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) { |
| assert(!CXXRD->isDynamicClass() && |
| "cannot expand vtable pointers in dynamic classes"); |
| for (const CXXBaseSpecifier &BS : CXXRD->bases()) |
| Bases.push_back(&BS); |
| } |
| |
| for (const auto *FD : RD->fields()) { |
| if (FD->isZeroLengthBitField(Context)) |
| continue; |
| assert(!FD->isBitField() && |
| "Cannot expand structure with bit-field members."); |
| Fields.push_back(FD); |
| } |
| } |
| return std::make_unique<RecordExpansion>(std::move(Bases), |
| std::move(Fields)); |
| } |
| if (const ComplexType *CT = Ty->getAs<ComplexType>()) { |
| return std::make_unique<ComplexExpansion>(CT->getElementType()); |
| } |
| return std::make_unique<NoExpansion>(); |
| } |
| |
| static int getExpansionSize(QualType Ty, const ASTContext &Context) { |
| auto Exp = getTypeExpansion(Ty, Context); |
| if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) { |
| return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context); |
| } |
| if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) { |
| int Res = 0; |
| for (auto BS : RExp->Bases) |
| Res += getExpansionSize(BS->getType(), Context); |
| for (auto FD : RExp->Fields) |
| Res += getExpansionSize(FD->getType(), Context); |
| return Res; |
| } |
| if (isa<ComplexExpansion>(Exp.get())) |
| return 2; |
| assert(isa<NoExpansion>(Exp.get())); |
| return 1; |
| } |
| |
| void |
| CodeGenTypes::getExpandedTypes(QualType Ty, |
| SmallVectorImpl<llvm::Type *>::iterator &TI) { |
| auto Exp = getTypeExpansion(Ty, Context); |
| if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) { |
| for (int i = 0, n = CAExp->NumElts; i < n; i++) { |
| getExpandedTypes(CAExp->EltTy, TI); |
| } |
| } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) { |
| for (auto BS : RExp->Bases) |
| getExpandedTypes(BS->getType(), TI); |
| for (auto FD : RExp->Fields) |
| getExpandedTypes(FD->getType(), TI); |
| } else if (auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) { |
| llvm::Type *EltTy = ConvertType(CExp->EltTy); |
| *TI++ = EltTy; |
| *TI++ = EltTy; |
| } else { |
| assert(isa<NoExpansion>(Exp.get())); |
| *TI++ = ConvertType(Ty); |
| } |
| } |
| |
| static void forConstantArrayExpansion(CodeGenFunction &CGF, |
| ConstantArrayExpansion *CAE, |
| Address BaseAddr, |
| llvm::function_ref<void(Address)> Fn) { |
| CharUnits EltSize = CGF.getContext().getTypeSizeInChars(CAE->EltTy); |
| CharUnits EltAlign = |
| BaseAddr.getAlignment().alignmentOfArrayElement(EltSize); |
| |
| for (int i = 0, n = CAE->NumElts; i < n; i++) { |
| llvm::Value *EltAddr = |
| CGF.Builder.CreateConstGEP2_32(nullptr, BaseAddr.getPointer(), 0, i); |
| Fn(Address(EltAddr, EltAlign)); |
| } |
| } |
| |
| void CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, |
| llvm::Function::arg_iterator &AI) { |
| assert(LV.isSimple() && |
| "Unexpected non-simple lvalue during struct expansion."); |
| |
| auto Exp = getTypeExpansion(Ty, getContext()); |
| if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) { |
| forConstantArrayExpansion( |
| *this, CAExp, LV.getAddress(*this), [&](Address EltAddr) { |
| LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy); |
| ExpandTypeFromArgs(CAExp->EltTy, LV, AI); |
| }); |
| } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) { |
| Address This = LV.getAddress(*this); |
| for (const CXXBaseSpecifier *BS : RExp->Bases) { |
| // Perform a single step derived-to-base conversion. |
| Address Base = |
| GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1, |
| /*NullCheckValue=*/false, SourceLocation()); |
| LValue SubLV = MakeAddrLValue(Base, BS->getType()); |
| |
| // Recurse onto bases. |
| ExpandTypeFromArgs(BS->getType(), SubLV, AI); |
| } |
| for (auto FD : RExp->Fields) { |
| // FIXME: What are the right qualifiers here? |
| LValue SubLV = EmitLValueForFieldInitialization(LV, FD); |
| ExpandTypeFromArgs(FD->getType(), SubLV, AI); |
| } |
| } else if (isa<ComplexExpansion>(Exp.get())) { |
| auto realValue = &*AI++; |
| auto imagValue = &*AI++; |
| EmitStoreOfComplex(ComplexPairTy(realValue, imagValue), LV, /*init*/ true); |
| } else { |
| // Call EmitStoreOfScalar except when the lvalue is a bitfield to emit a |
| // primitive store. |
| assert(isa<NoExpansion>(Exp.get())); |
| if (LV.isBitField()) |
| EmitStoreThroughLValue(RValue::get(&*AI++), LV); |
| else |
| EmitStoreOfScalar(&*AI++, LV); |
| } |
| } |
| |
| void CodeGenFunction::ExpandTypeToArgs( |
| QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, |
| SmallVectorImpl<llvm::Value *> &IRCallArgs, unsigned &IRCallArgPos) { |
| auto Exp = getTypeExpansion(Ty, getContext()); |
| if (auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) { |
| Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this) |
| : Arg.getKnownRValue().getAggregateAddress(); |
| forConstantArrayExpansion( |
| *this, CAExp, Addr, [&](Address EltAddr) { |
| CallArg EltArg = CallArg( |
| convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation()), |
| CAExp->EltTy); |
| ExpandTypeToArgs(CAExp->EltTy, EltArg, IRFuncTy, IRCallArgs, |
| IRCallArgPos); |
| }); |
| } else if (auto RExp = dyn_cast<RecordExpansion>(Exp.get())) { |
| Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress(*this) |
| : Arg.getKnownRValue().getAggregateAddress(); |
| for (const CXXBaseSpecifier *BS : RExp->Bases) { |
| // Perform a single step derived-to-base conversion. |
| Address Base = |
| GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1, |
| /*NullCheckValue=*/false, SourceLocation()); |
| CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType()); |
| |
| // Recurse onto bases. |
| ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs, |
| IRCallArgPos); |
| } |
| |
| LValue LV = MakeAddrLValue(This, Ty); |
| for (auto FD : RExp->Fields) { |
| CallArg FldArg = |
| CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType()); |
| ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs, |
| IRCallArgPos); |
| } |
| } else if (isa<ComplexExpansion>(Exp.get())) { |
| ComplexPairTy CV = Arg.getKnownRValue().getComplexVal(); |
| IRCallArgs[IRCallArgPos++] = CV.first; |
| IRCallArgs[IRCallArgPos++] = CV.second; |
| } else { |
| assert(isa<NoExpansion>(Exp.get())); |
| auto RV = Arg.getKnownRValue(); |
| assert(RV.isScalar() && |
| "Unexpected non-scalar rvalue during struct expansion."); |
| |
| // Insert a bitcast as needed. |
| llvm::Value *V = RV.getScalarVal(); |
| if (IRCallArgPos < IRFuncTy->getNumParams() && |
| V->getType() != IRFuncTy->getParamType(IRCallArgPos)) |
| V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos)); |
| |
| IRCallArgs[IRCallArgPos++] = V; |
| } |
| } |
| |
| /// Create a temporary allocation for the purposes of coercion. |
| static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty, |
| CharUnits MinAlign, |
| const Twine &Name = "tmp") { |
| // Don't use an alignment that's worse than what LLVM would prefer. |
| auto PrefAlign = CGF.CGM.getDataLayout().getPrefTypeAlignment(Ty); |
| CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign)); |
| |
| return CGF.CreateTempAlloca(Ty, Align, Name + ".coerce"); |
| } |
| |
| /// EnterStructPointerForCoercedAccess - Given a struct pointer that we are |
| /// accessing some number of bytes out of it, try to gep into the struct to get |
| /// at its inner goodness. Dive as deep as possible without entering an element |
| /// with an in-memory size smaller than DstSize. |
| static Address |
| EnterStructPointerForCoercedAccess(Address SrcPtr, |
| llvm::StructType *SrcSTy, |
| uint64_t DstSize, CodeGenFunction &CGF) { |
| // We can't dive into a zero-element struct. |
| if (SrcSTy->getNumElements() == 0) return SrcPtr; |
| |
| llvm::Type *FirstElt = SrcSTy->getElementType(0); |
| |
| // If the first elt is at least as large as what we're looking for, or if the |
| // first element is the same size as the whole struct, we can enter it. The |
| // comparison must be made on the store size and not the alloca size. Using |
| // the alloca size may overstate the size of the load. |
| uint64_t FirstEltSize = |
| CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt); |
| if (FirstEltSize < DstSize && |
| FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy)) |
| return SrcPtr; |
| |
| // GEP into the first element. |
| SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, "coerce.dive"); |
| |
| // If the first element is a struct, recurse. |
| llvm::Type *SrcTy = SrcPtr.getElementType(); |
| if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) |
| return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); |
| |
| return SrcPtr; |
| } |
| |
| /// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both |
| /// are either integers or pointers. This does a truncation of the value if it |
| /// is too large or a zero extension if it is too small. |
| /// |
| /// This behaves as if the value were coerced through memory, so on big-endian |
| /// targets the high bits are preserved in a truncation, while little-endian |
| /// targets preserve the low bits. |
| static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val, |
| llvm::Type *Ty, |
| CodeGenFunction &CGF) { |
| if (Val->getType() == Ty) |
| return Val; |
| |
| if (isa<llvm::PointerType>(Val->getType())) { |
| // If this is Pointer->Pointer avoid conversion to and from int. |
| if (isa<llvm::PointerType>(Ty)) |
| return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val"); |
| |
| // Convert the pointer to an integer so we can play with its width. |
| Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi"); |
| } |
| |
| llvm::Type *DestIntTy = Ty; |
| if (isa<llvm::PointerType>(DestIntTy)) |
| DestIntTy = CGF.IntPtrTy; |
| |
| if (Val->getType() != DestIntTy) { |
| const llvm::DataLayout &DL = CGF.CGM.getDataLayout(); |
| if (DL.isBigEndian()) { |
| // Preserve the high bits on big-endian targets. |
| // That is what memory coercion does. |
| uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType()); |
| uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy); |
| |
| if (SrcSize > DstSize) { |
| Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits"); |
| Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii"); |
| } else { |
| Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii"); |
| Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits"); |
| } |
| } else { |
| // Little-endian targets preserve the low bits. No shifts required. |
| Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii"); |
| } |
| } |
| |
| if (isa<llvm::PointerType>(Ty)) |
| Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip"); |
| return Val; |
| } |
| |
| |
| |
| /// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as |
| /// a pointer to an object of type \arg Ty, known to be aligned to |
| /// \arg SrcAlign bytes. |
| /// |
| /// This safely handles the case when the src type is smaller than the |
| /// destination type; in this situation the values of bits which not |
| /// present in the src are undefined. |
| static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty, |
| CodeGenFunction &CGF) { |
| llvm::Type *SrcTy = Src.getElementType(); |
| |
| // If SrcTy and Ty are the same, just do a load. |
| if (SrcTy == Ty) |
| return CGF.Builder.CreateLoad(Src); |
| |
| llvm::TypeSize DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty); |
| |
| if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) { |
| Src = EnterStructPointerForCoercedAccess(Src, SrcSTy, |
| DstSize.getFixedSize(), CGF); |
| SrcTy = Src.getElementType(); |
| } |
| |
| llvm::TypeSize SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); |
| |
| // If the source and destination are integer or pointer types, just do an |
| // extension or truncation to the desired type. |
| if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) && |
| (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) { |
| llvm::Value *Load = CGF.Builder.CreateLoad(Src); |
| return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF); |
| } |
| |
| // If load is legal, just bitcast the src pointer. |
| if (!SrcSize.isScalable() && !DstSize.isScalable() && |
| SrcSize.getFixedSize() >= DstSize.getFixedSize()) { |
| // Generally SrcSize is never greater than DstSize, since this means we are |
| // losing bits. However, this can happen in cases where the structure has |
| // additional padding, for example due to a user specified alignment. |
| // |
| // FIXME: Assert that we aren't truncating non-padding bits when have access |
| // to that information. |
| Src = CGF.Builder.CreateBitCast(Src, |
| Ty->getPointerTo(Src.getAddressSpace())); |
| return CGF.Builder.CreateLoad(Src); |
| } |
| |
| // Otherwise do coercion through memory. This is stupid, but simple. |
| Address Tmp = |
| CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment(), Src.getName()); |
| CGF.Builder.CreateMemCpy( |
| Tmp.getPointer(), Tmp.getAlignment().getAsAlign(), Src.getPointer(), |
| Src.getAlignment().getAsAlign(), |
| llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize.getKnownMinSize())); |
| return CGF.Builder.CreateLoad(Tmp); |
| } |
| |
| // Function to store a first-class aggregate into memory. We prefer to |
| // store the elements rather than the aggregate to be more friendly to |
| // fast-isel. |
| // FIXME: Do we need to recurse here? |
| void CodeGenFunction::EmitAggregateStore(llvm::Value *Val, Address Dest, |
| bool DestIsVolatile) { |
| // Prefer scalar stores to first-class aggregate stores. |
| if (llvm::StructType *STy = dyn_cast<llvm::StructType>(Val->getType())) { |
| for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { |
| Address EltPtr = Builder.CreateStructGEP(Dest, i); |
| llvm::Value *Elt = Builder.CreateExtractValue(Val, i); |
| Builder.CreateStore(Elt, EltPtr, DestIsVolatile); |
| } |
| } else { |
| Builder.CreateStore(Val, Dest, DestIsVolatile); |
| } |
| } |
| |
| /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, |
| /// where the source and destination may have different types. The |
| /// destination is known to be aligned to \arg DstAlign bytes. |
| /// |
| /// This safely handles the case when the src type is larger than the |
| /// destination type; the upper bits of the src will be lost. |
| static void CreateCoercedStore(llvm::Value *Src, |
| Address Dst, |
| bool DstIsVolatile, |
| CodeGenFunction &CGF) { |
| llvm::Type *SrcTy = Src->getType(); |
| llvm::Type *DstTy = Dst.getElementType(); |
| if (SrcTy == DstTy) { |
| CGF.Builder.CreateStore(Src, Dst, DstIsVolatile); |
| return; |
| } |
| |
| llvm::TypeSize SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); |
| |
| if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) { |
| Dst = EnterStructPointerForCoercedAccess(Dst, DstSTy, |
| SrcSize.getFixedSize(), CGF); |
| DstTy = Dst.getElementType(); |
| } |
| |
| llvm::PointerType *SrcPtrTy = llvm::dyn_cast<llvm::PointerType>(SrcTy); |
| llvm::PointerType *DstPtrTy = llvm::dyn_cast<llvm::PointerType>(DstTy); |
| if (SrcPtrTy && DstPtrTy && |
| SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace()) { |
| Src = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy); |
| CGF.Builder.CreateStore(Src, Dst, DstIsVolatile); |
| return; |
| } |
| |
| // If the source and destination are integer or pointer types, just do an |
| // extension or truncation to the desired type. |
| if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) && |
| (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) { |
| Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF); |
| CGF.Builder.CreateStore(Src, Dst, DstIsVolatile); |
| return; |
| } |
| |
| llvm::TypeSize DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy); |
| |
| // If store is legal, just bitcast the src pointer. |
| if (isa<llvm::ScalableVectorType>(SrcTy) || |
| isa<llvm::ScalableVectorType>(DstTy) || |
| SrcSize.getFixedSize() <= DstSize.getFixedSize()) { |
| Dst = CGF.Builder.CreateElementBitCast(Dst, SrcTy); |
| CGF.EmitAggregateStore(Src, Dst, DstIsVolatile); |
| } else { |
| // Otherwise do coercion through memory. This is stupid, but |
| // simple. |
| |
| // Generally SrcSize is never greater than DstSize, since this means we are |
| // losing bits. However, this can happen in cases where the structure has |
| // additional padding, for example due to a user specified alignment. |
| // |
| // FIXME: Assert that we aren't truncating non-padding bits when have access |
| // to that information. |
| Address Tmp = CreateTempAllocaForCoercion(CGF, SrcTy, Dst.getAlignment()); |
| CGF.Builder.CreateStore(Src, Tmp); |
| CGF.Builder.CreateMemCpy( |
| Dst.getPointer(), Dst.getAlignment().getAsAlign(), Tmp.getPointer(), |
| Tmp.getAlignment().getAsAlign(), |
| llvm::ConstantInt::get(CGF.IntPtrTy, DstSize.getFixedSize())); |
| } |
| } |
| |
| static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr, |
| const ABIArgInfo &info) { |
| if (unsigned offset = info.getDirectOffset()) { |
| addr = CGF.Builder.CreateElementBitCast(addr, CGF.Int8Ty); |
| addr = CGF.Builder.CreateConstInBoundsByteGEP(addr, |
| CharUnits::fromQuantity(offset)); |
| addr = CGF.Builder.CreateElementBitCast(addr, info.getCoerceToType()); |
| } |
| return addr; |
| } |
| |
| namespace { |
| |
| /// Encapsulates information about the way function arguments from |
| /// CGFunctionInfo should be passed to actual LLVM IR function. |
| class ClangToLLVMArgMapping { |
| static const unsigned InvalidIndex = ~0U; |
| unsigned InallocaArgNo; |
| unsigned SRetArgNo; |
| unsigned TotalIRArgs; |
| |
| /// Arguments of LLVM IR function corresponding to single Clang argument. |
| struct IRArgs { |
| unsigned PaddingArgIndex; |
| // Argument is expanded to IR arguments at positions |
| // [FirstArgIndex, FirstArgIndex + NumberOfArgs). |
| unsigned FirstArgIndex; |
| unsigned NumberOfArgs; |
| |
| IRArgs() |
| : PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex), |
| NumberOfArgs(0) {} |
| }; |
| |
| SmallVector<IRArgs, 8> ArgInfo; |
| |
| public: |
| ClangToLLVMArgMapping(const ASTContext &Context, const CGFunctionInfo &FI, |
| bool OnlyRequiredArgs = false) |
| : InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0), |
| ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) { |
| construct(Context, FI, OnlyRequiredArgs); |
| } |
| |
| bool hasInallocaArg() const { return InallocaArgNo != InvalidIndex; } |
| unsigned getInallocaArgNo() const { |
| assert(hasInallocaArg()); |
| return InallocaArgNo; |
| } |
| |
| bool hasSRetArg() const { return SRetArgNo != InvalidIndex; } |
| unsigned getSRetArgNo() const { |
| assert(hasSRetArg()); |
| return SRetArgNo; |
| } |
| |
| unsigned totalIRArgs() const { return TotalIRArgs; } |
| |
| bool hasPaddingArg(unsigned ArgNo) const { |
| assert(ArgNo < ArgInfo.size()); |
| return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex; |
| } |
| unsigned getPaddingArgNo(unsigned ArgNo) const { |
| assert(hasPaddingArg(ArgNo)); |
| return ArgInfo[ArgNo].PaddingArgIndex; |
| } |
| |
| /// Returns index of first IR argument corresponding to ArgNo, and their |
| /// quantity. |
| std::pair<unsigned, unsigned> getIRArgs(unsigned ArgNo) const { |
| assert(ArgNo < ArgInfo.size()); |
| return std::make_pair(ArgInfo[ArgNo].FirstArgIndex, |
| ArgInfo[ArgNo].NumberOfArgs); |
| } |
| |
| private: |
| void construct(const ASTContext &Context, const CGFunctionInfo &FI, |
| bool OnlyRequiredArgs); |
| }; |
| |
| void ClangToLLVMArgMapping::construct(const ASTContext &Context, |
| const CGFunctionInfo &FI, |
| bool OnlyRequiredArgs) { |
| unsigned IRArgNo = 0; |
| bool SwapThisWithSRet = false; |
| const ABIArgInfo &RetAI = FI.getReturnInfo(); |
| |
| if (RetAI.getKind() == ABIArgInfo::Indirect) { |
| SwapThisWithSRet = RetAI.isSRetAfterThis(); |
| SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++; |
| } |
| |
| unsigned ArgNo = 0; |
| unsigned NumArgs = OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size(); |
| for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(); ArgNo < NumArgs; |
| ++I, ++ArgNo) { |
| assert(I != FI.arg_end()); |
| QualType ArgType = I->type; |
| const ABIArgInfo &AI = I->info; |
| // Collect data about IR arguments corresponding to Clang argument ArgNo. |
| auto &IRArgs = ArgInfo[ArgNo]; |
| |
| if (AI.getPaddingType()) |
| IRArgs.PaddingArgIndex = IRArgNo++; |
| |
| switch (AI.getKind()) { |
| case ABIArgInfo::Extend: |
| case ABIArgInfo::Direct: { |
| // FIXME: handle sseregparm someday... |
| llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.getCoerceToType()); |
| if (AI.isDirect() && AI.getCanBeFlattened() && STy) { |
| IRArgs.NumberOfArgs = STy->getNumElements(); |
| } else { |
| IRArgs.NumberOfArgs = 1; |
| } |
| break; |
| } |
| case ABIArgInfo::Indirect: |
| case ABIArgInfo::IndirectAliased: |
| IRArgs.NumberOfArgs = 1; |
| break; |
| case ABIArgInfo::Ignore: |
| case ABIArgInfo::InAlloca: |
| // ignore and inalloca doesn't have matching LLVM parameters. |
| IRArgs.NumberOfArgs = 0; |
| break; |
| case ABIArgInfo::CoerceAndExpand: |
| IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size(); |
| break; |
| case ABIArgInfo::Expand: |
| IRArgs.NumberOfArgs = getExpansionSize(ArgType, Context); |
| break; |
| } |
| |
| if (IRArgs.NumberOfArgs > 0) { |
| IRArgs.FirstArgIndex = IRArgNo; |
| IRArgNo += IRArgs.NumberOfArgs; |
| } |
| |
| // Skip over the sret parameter when it comes second. We already handled it |
| // above. |
| if (IRArgNo == 1 && SwapThisWithSRet) |
| IRArgNo++; |
| } |
| assert(ArgNo == ArgInfo.size()); |
| |
| if (FI.usesInAlloca()) |
| InallocaArgNo = IRArgNo++; |
| |
| TotalIRArgs = IRArgNo; |
| } |
| } // namespace |
| |
| /***/ |
| |
| bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { |
| const auto &RI = FI.getReturnInfo(); |
| return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet()); |
| } |
| |
| bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) { |
| return ReturnTypeUsesSRet(FI) && |
| getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs(); |
| } |
| |
| bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { |
| if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) { |
| switch (BT->getKind()) { |
| default: |
| return false; |
| case BuiltinType::Float: |
| return getTarget().useObjCFPRetForRealType(TargetInfo::Float); |
| case BuiltinType::Double: |
| return getTarget().useObjCFPRetForRealType(TargetInfo::Double); |
| case BuiltinType::LongDouble: |
| return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble); |
| } |
| } |
| |
| return false; |
| } |
| |
| bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) { |
| if (const ComplexType *CT = ResultType->getAs<ComplexType>()) { |
| if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) { |
| if (BT->getKind() == BuiltinType::LongDouble) |
| return getTarget().useObjCFP2RetForComplexLongDouble(); |
| } |
| } |
| |
| return false; |
| } |
| |
| llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) { |
| const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD); |
| return GetFunctionType(FI); |
| } |
| |
| llvm::FunctionType * |
| CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) { |
| |
| bool Inserted = FunctionsBeingProcessed.insert(&FI).second; |
| (void)Inserted; |
| assert(Inserted && "Recursively being processed?"); |
| |
| llvm::Type *resultType = nullptr; |
| const ABIArgInfo &retAI = FI.getReturnInfo(); |
| switch (retAI.getKind()) { |
| case ABIArgInfo::Expand: |
| case ABIArgInfo::IndirectAliased: |
| llvm_unreachable("Invalid ABI kind for return argument"); |
| |
| case ABIArgInfo::Extend: |
| case ABIArgInfo::Direct: |
| resultType = retAI.getCoerceToType(); |
| break; |
| |
| case ABIArgInfo::InAlloca: |
| if (retAI.getInAllocaSRet()) { |
| // sret things on win32 aren't void, they return the sret pointer. |
| QualType ret = FI.getReturnType(); |
| llvm::Type *ty = ConvertType(ret); |
| unsigned addressSpace = Context.getTargetAddressSpace(ret); |
| resultType = llvm::PointerType::get(ty, addressSpace); |
| } else { |
| resultType = llvm::Type::getVoidTy(getLLVMContext()); |
| } |
| break; |
| |
| case ABIArgInfo::Indirect: |
| case ABIArgInfo::Ignore: |
| resultType = llvm::Type::getVoidTy(getLLVMContext()); |
| break; |
| |
| case ABIArgInfo::CoerceAndExpand: |
| resultType = retAI.getUnpaddedCoerceAndExpandType(); |
| break; |
| } |
| |
| ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true); |
| SmallVector<llvm::Type*, 8> ArgTypes(IRFunctionArgs.totalIRArgs()); |
| |
| // Add type for sret argument. |
| if (IRFunctionArgs.hasSRetArg()) { |
| QualType Ret = FI.getReturnType(); |
| llvm::Type *Ty = ConvertType(Ret); |
| unsigned AddressSpace = Context.getTargetAddressSpace(Ret); |
| ArgTypes[IRFunctionArgs.getSRetArgNo()] = |
| llvm::PointerType::get(Ty, AddressSpace); |
| } |
| |
| // Add type for inalloca argument. |
| if (IRFunctionArgs.hasInallocaArg()) { |
| auto ArgStruct = FI.getArgStruct(); |
| assert(ArgStruct); |
| ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo(); |
| } |
| |
| // Add in all of the required arguments. |
| unsigned ArgNo = 0; |
| CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), |
| ie = it + FI.getNumRequiredArgs(); |
| for (; it != ie; ++it, ++ArgNo) { |
| const ABIArgInfo &ArgInfo = it->info; |
| |
| // Insert a padding type to ensure proper alignment. |
| if (IRFunctionArgs.hasPaddingArg(ArgNo)) |
| ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] = |
| ArgInfo.getPaddingType(); |
| |
| unsigned FirstIRArg, NumIRArgs; |
| std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); |
| |
| switch (ArgInfo.getKind()) { |
| case ABIArgInfo::Ignore: |
| case ABIArgInfo::InAlloca: |
| assert(NumIRArgs == 0); |
| break; |
| |
| case ABIArgInfo::Indirect: { |
| assert(NumIRArgs == 1); |
| // indirect arguments are always on the stack, which is alloca addr space. |
| llvm::Type *LTy = ConvertTypeForMem(it->type); |
| ArgTypes[FirstIRArg] = LTy->getPointerTo( |
| CGM.getDataLayout().getAllocaAddrSpace()); |
| break; |
| } |
| case ABIArgInfo::IndirectAliased: { |
| assert(NumIRArgs == 1); |
| llvm::Type *LTy = ConvertTypeForMem(it->type); |
| ArgTypes[FirstIRArg] = LTy->getPointerTo(ArgInfo.getIndirectAddrSpace()); |
| break; |
| } |
| case ABIArgInfo::Extend: |
| case ABIArgInfo::Direct: { |
| // Fast-isel and the optimizer generally like scalar values better than |
| // FCAs, so we flatten them if this is safe to do for this argument. |
| llvm::Type *argType = ArgInfo.getCoerceToType(); |
| llvm::StructType *st = dyn_cast<llvm::StructType>(argType); |
| if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) { |
| assert(NumIRArgs == st->getNumElements()); |
| for (unsigned i = 0, e = st->getNumElements(); i != e; ++i) |
| ArgTypes[FirstIRArg + i] = st->getElementType(i); |
| } else { |
| assert(NumIRArgs == 1); |
| ArgTypes[FirstIRArg] = argType; |
| } |
| break; |
| } |
| |
| case ABIArgInfo::CoerceAndExpand: { |
| auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; |
| for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) { |
| *ArgTypesIter++ = EltTy; |
| } |
| assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); |
| break; |
| } |
| |
| case ABIArgInfo::Expand: |
| auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; |
| getExpandedTypes(it->type, ArgTypesIter); |
| assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); |
| break; |
| } |
| } |
| |
| bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased; |
| assert(Erased && "Not in set?"); |
| |
| return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic()); |
| } |
| |
| llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) { |
| const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); |
| const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); |
| |
| if (!isFuncTypeConvertible(FPT)) |
| return llvm::StructType::get(getLLVMContext()); |
| |
| return GetFunctionType(GD); |
| } |
| |
| static void AddAttributesFromFunctionProtoType(ASTContext &Ctx, |
| llvm::AttrBuilder &FuncAttrs, |
| const FunctionProtoType *FPT) { |
| if (!FPT) |
| return; |
| |
| if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) && |
| FPT->isNothrow()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| } |
| |
| void CodeGenModule::getDefaultFunctionAttributes(StringRef Name, |
| bool HasOptnone, |
| bool AttrOnCallSite, |
| llvm::AttrBuilder &FuncAttrs) { |
| // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed. |
| if (!HasOptnone) { |
| if (CodeGenOpts.OptimizeSize) |
| FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize); |
| if (CodeGenOpts.OptimizeSize == 2) |
| FuncAttrs.addAttribute(llvm::Attribute::MinSize); |
| } |
| |
| if (CodeGenOpts.DisableRedZone) |
| FuncAttrs.addAttribute(llvm::Attribute::NoRedZone); |
| if (CodeGenOpts.IndirectTlsSegRefs) |
| FuncAttrs.addAttribute("indirect-tls-seg-refs"); |
| if (CodeGenOpts.NoImplicitFloat) |
| FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat); |
| |
| if (AttrOnCallSite) { |
| // Attributes that should go on the call site only. |
| if (!CodeGenOpts.SimplifyLibCalls || |
| CodeGenOpts.isNoBuiltinFunc(Name.data())) |
| FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); |
| if (!CodeGenOpts.TrapFuncName.empty()) |
| FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName); |
| } else { |
| StringRef FpKind; |
| switch (CodeGenOpts.getFramePointer()) { |
| case CodeGenOptions::FramePointerKind::None: |
| FpKind = "none"; |
| break; |
| case CodeGenOptions::FramePointerKind::NonLeaf: |
| FpKind = "non-leaf"; |
| break; |
| case CodeGenOptions::FramePointerKind::All: |
| FpKind = "all"; |
| break; |
| } |
| FuncAttrs.addAttribute("frame-pointer", FpKind); |
| |
| FuncAttrs.addAttribute("less-precise-fpmad", |
| llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); |
| |
| if (CodeGenOpts.NullPointerIsValid) |
| FuncAttrs.addAttribute(llvm::Attribute::NullPointerIsValid); |
| |
| if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE()) |
| FuncAttrs.addAttribute("denormal-fp-math", |
| CodeGenOpts.FPDenormalMode.str()); |
| if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) { |
| FuncAttrs.addAttribute( |
| "denormal-fp-math-f32", |
| CodeGenOpts.FP32DenormalMode.str()); |
| } |
| |
| FuncAttrs.addAttribute("no-trapping-math", |
| llvm::toStringRef(LangOpts.getFPExceptionMode() == |
| LangOptions::FPE_Ignore)); |
| |
| // Strict (compliant) code is the default, so only add this attribute to |
| // indicate that we are trying to workaround a problem case. |
| if (!CodeGenOpts.StrictFloatCastOverflow) |
| FuncAttrs.addAttribute("strict-float-cast-overflow", "false"); |
| |
| // TODO: Are these all needed? |
| // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags. |
| FuncAttrs.addAttribute("no-infs-fp-math", |
| llvm::toStringRef(LangOpts.NoHonorInfs)); |
| FuncAttrs.addAttribute("no-nans-fp-math", |
| llvm::toStringRef(LangOpts.NoHonorNaNs)); |
| FuncAttrs.addAttribute("unsafe-fp-math", |
| llvm::toStringRef(LangOpts.UnsafeFPMath)); |
| FuncAttrs.addAttribute("use-soft-float", |
| llvm::toStringRef(CodeGenOpts.SoftFloat)); |
| FuncAttrs.addAttribute("stack-protector-buffer-size", |
| llvm::utostr(CodeGenOpts.SSPBufferSize)); |
| FuncAttrs.addAttribute("no-signed-zeros-fp-math", |
| llvm::toStringRef(LangOpts.NoSignedZero)); |
| FuncAttrs.addAttribute( |
| "correctly-rounded-divide-sqrt-fp-math", |
| llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt)); |
| |
| // TODO: Reciprocal estimate codegen options should apply to instructions? |
| const std::vector<std::string> &Recips = CodeGenOpts.Reciprocals; |
| if (!Recips.empty()) |
| FuncAttrs.addAttribute("reciprocal-estimates", |
| llvm::join(Recips, ",")); |
| |
| if (!CodeGenOpts.PreferVectorWidth.empty() && |
| CodeGenOpts.PreferVectorWidth != "none") |
| FuncAttrs.addAttribute("prefer-vector-width", |
| CodeGenOpts.PreferVectorWidth); |
| |
| if (CodeGenOpts.StackRealignment) |
| FuncAttrs.addAttribute("stackrealign"); |
| if (CodeGenOpts.Backchain) |
| FuncAttrs.addAttribute("backchain"); |
| if (CodeGenOpts.EnableSegmentedStacks) |
| FuncAttrs.addAttribute("split-stack"); |
| |
| if (CodeGenOpts.SpeculativeLoadHardening) |
| FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening); |
| } |
| |
| if (getLangOpts().assumeFunctionsAreConvergent()) { |
| // Conservatively, mark all functions and calls in CUDA and OpenCL as |
| // convergent (meaning, they may call an intrinsically convergent op, such |
| // as __syncthreads() / barrier(), and so can't have certain optimizations |
| // applied around them). LLVM will remove this attribute where it safely |
| // can. |
| FuncAttrs.addAttribute(llvm::Attribute::Convergent); |
| } |
| |
| if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { |
| // Exceptions aren't supported in CUDA device code. |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| } |
| |
| for (StringRef Attr : CodeGenOpts.DefaultFunctionAttrs) { |
| StringRef Var, Value; |
| std::tie(Var, Value) = Attr.split('='); |
| FuncAttrs.addAttribute(Var, Value); |
| } |
| } |
| |
| void CodeGenModule::addDefaultFunctionDefinitionAttributes(llvm::Function &F) { |
| llvm::AttrBuilder FuncAttrs; |
| getDefaultFunctionAttributes(F.getName(), F.hasOptNone(), |
| /* AttrOnCallSite = */ false, FuncAttrs); |
| // TODO: call GetCPUAndFeaturesAttributes? |
| F.addAttributes(llvm::AttributeList::FunctionIndex, FuncAttrs); |
| } |
| |
| void CodeGenModule::addDefaultFunctionDefinitionAttributes( |
| llvm::AttrBuilder &attrs) { |
| getDefaultFunctionAttributes(/*function name*/ "", /*optnone*/ false, |
| /*for call*/ false, attrs); |
| GetCPUAndFeaturesAttributes(GlobalDecl(), attrs); |
| } |
| |
| static void addNoBuiltinAttributes(llvm::AttrBuilder &FuncAttrs, |
| const LangOptions &LangOpts, |
| const NoBuiltinAttr *NBA = nullptr) { |
| auto AddNoBuiltinAttr = [&FuncAttrs](StringRef BuiltinName) { |
| SmallString<32> AttributeName; |
| AttributeName += "no-builtin-"; |
| AttributeName += BuiltinName; |
| FuncAttrs.addAttribute(AttributeName); |
| }; |
| |
| // First, handle the language options passed through -fno-builtin. |
| if (LangOpts.NoBuiltin) { |
| // -fno-builtin disables them all. |
| FuncAttrs.addAttribute("no-builtins"); |
| return; |
| } |
| |
| // Then, add attributes for builtins specified through -fno-builtin-<name>. |
| llvm::for_each(LangOpts.NoBuiltinFuncs, AddNoBuiltinAttr); |
| |
| // Now, let's check the __attribute__((no_builtin("...")) attribute added to |
| // the source. |
| if (!NBA) |
| return; |
| |
| // If there is a wildcard in the builtin names specified through the |
| // attribute, disable them all. |
| if (llvm::is_contained(NBA->builtinNames(), "*")) { |
| FuncAttrs.addAttribute("no-builtins"); |
| return; |
| } |
| |
| // And last, add the rest of the builtin names. |
| llvm::for_each(NBA->builtinNames(), AddNoBuiltinAttr); |
| } |
| |
| /// Construct the IR attribute list of a function or call. |
| /// |
| /// When adding an attribute, please consider where it should be handled: |
| /// |
| /// - getDefaultFunctionAttributes is for attributes that are essentially |
| /// part of the global target configuration (but perhaps can be |
| /// overridden on a per-function basis). Adding attributes there |
| /// will cause them to also be set in frontends that build on Clang's |
| /// target-configuration logic, as well as for code defined in library |
| /// modules such as CUDA's libdevice. |
| /// |
| /// - ConstructAttributeList builds on top of getDefaultFunctionAttributes |
| /// and adds declaration-specific, convention-specific, and |
| /// frontend-specific logic. The last is of particular importance: |
| /// attributes that restrict how the frontend generates code must be |
| /// added here rather than getDefaultFunctionAttributes. |
| /// |
| void CodeGenModule::ConstructAttributeList( |
| StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo, |
| llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite) { |
| llvm::AttrBuilder FuncAttrs; |
| llvm::AttrBuilder RetAttrs; |
| |
| // Collect function IR attributes from the CC lowering. |
| // We'll collect the paramete and result attributes later. |
| CallingConv = FI.getEffectiveCallingConvention(); |
| if (FI.isNoReturn()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoReturn); |
| if (FI.isCmseNSCall()) |
| FuncAttrs.addAttribute("cmse_nonsecure_call"); |
| |
| // Collect function IR attributes from the callee prototype if we have one. |
| AddAttributesFromFunctionProtoType(getContext(), FuncAttrs, |
| CalleeInfo.getCalleeFunctionProtoType()); |
| |
| const Decl *TargetDecl = CalleeInfo.getCalleeDecl().getDecl(); |
| |
| bool HasOptnone = false; |
| // The NoBuiltinAttr attached to the target FunctionDecl. |
| const NoBuiltinAttr *NBA = nullptr; |
| |
| // Collect function IR attributes based on declaration-specific |
| // information. |
| // FIXME: handle sseregparm someday... |
| if (TargetDecl) { |
| if (TargetDecl->hasAttr<ReturnsTwiceAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice); |
| if (TargetDecl->hasAttr<NoThrowAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| if (TargetDecl->hasAttr<NoReturnAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoReturn); |
| if (TargetDecl->hasAttr<ColdAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::Cold); |
| if (TargetDecl->hasAttr<NoDuplicateAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate); |
| if (TargetDecl->hasAttr<ConvergentAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::Convergent); |
| |
| if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) { |
| AddAttributesFromFunctionProtoType( |
| getContext(), FuncAttrs, Fn->getType()->getAs<FunctionProtoType>()); |
| if (AttrOnCallSite && Fn->isReplaceableGlobalAllocationFunction()) { |
| // A sane operator new returns a non-aliasing pointer. |
| auto Kind = Fn->getDeclName().getCXXOverloadedOperator(); |
| if (getCodeGenOpts().AssumeSaneOperatorNew && |
| (Kind == OO_New || Kind == OO_Array_New)) |
| RetAttrs.addAttribute(llvm::Attribute::NoAlias); |
| } |
| const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn); |
| const bool IsVirtualCall = MD && MD->isVirtual(); |
| // Don't use [[noreturn]], _Noreturn or [[no_builtin]] for a call to a |
| // virtual function. These attributes are not inherited by overloads. |
| if (!(AttrOnCallSite && IsVirtualCall)) { |
| if (Fn->isNoReturn()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoReturn); |
| NBA = Fn->getAttr<NoBuiltinAttr>(); |
| } |
| } |
| |
| // 'const', 'pure' and 'noalias' attributed functions are also nounwind. |
| if (TargetDecl->hasAttr<ConstAttr>()) { |
| FuncAttrs.addAttribute(llvm::Attribute::ReadNone); |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| } else if (TargetDecl->hasAttr<PureAttr>()) { |
| FuncAttrs.addAttribute(llvm::Attribute::ReadOnly); |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| } else if (TargetDecl->hasAttr<NoAliasAttr>()) { |
| FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly); |
| FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); |
| } |
| if (TargetDecl->hasAttr<RestrictAttr>()) |
| RetAttrs.addAttribute(llvm::Attribute::NoAlias); |
| if (TargetDecl->hasAttr<ReturnsNonNullAttr>() && |
| !CodeGenOpts.NullPointerIsValid) |
| RetAttrs.addAttribute(llvm::Attribute::NonNull); |
| if (TargetDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>()) |
| FuncAttrs.addAttribute("no_caller_saved_registers"); |
| if (TargetDecl->hasAttr<AnyX86NoCfCheckAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck); |
| |
| HasOptnone = TargetDecl->hasAttr<OptimizeNoneAttr>(); |
| if (auto *AllocSize = TargetDecl->getAttr<AllocSizeAttr>()) { |
| Optional<unsigned> NumElemsParam; |
| if (AllocSize->getNumElemsParam().isValid()) |
| NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex(); |
| FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(), |
| NumElemsParam); |
| } |
| |
| if (TargetDecl->hasAttr<OpenCLKernelAttr>()) { |
| if (getLangOpts().OpenCLVersion <= 120) { |
| // OpenCL v1.2 Work groups are always uniform |
| FuncAttrs.addAttribute("uniform-work-group-size", "true"); |
| } else { |
| // OpenCL v2.0 Work groups may be whether uniform or not. |
| // '-cl-uniform-work-group-size' compile option gets a hint |
| // to the compiler that the global work-size be a multiple of |
| // the work-group size specified to clEnqueueNDRangeKernel |
| // (i.e. work groups are uniform). |
| FuncAttrs.addAttribute("uniform-work-group-size", |
| llvm::toStringRef(CodeGenOpts.UniformWGSize)); |
| } |
| } |
| } |
| |
| // Attach "no-builtins" attributes to: |
| // * call sites: both `nobuiltin` and "no-builtins" or "no-builtin-<name>". |
| // * definitions: "no-builtins" or "no-builtin-<name>" only. |
| // The attributes can come from: |
| // * LangOpts: -ffreestanding, -fno-builtin, -fno-builtin-<name> |
| // * FunctionDecl attributes: __attribute__((no_builtin(...))) |
| addNoBuiltinAttributes(FuncAttrs, getLangOpts(), NBA); |
| |
| // Collect function IR attributes based on global settiings. |
| getDefaultFunctionAttributes(Name, HasOptnone, AttrOnCallSite, FuncAttrs); |
| |
| // Override some default IR attributes based on declaration-specific |
| // information. |
| if (TargetDecl) { |
| if (TargetDecl->hasAttr<NoSpeculativeLoadHardeningAttr>()) |
| FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening); |
| if (TargetDecl->hasAttr<SpeculativeLoadHardeningAttr>()) |
| FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening); |
| if (TargetDecl->hasAttr<NoSplitStackAttr>()) |
| FuncAttrs.removeAttribute("split-stack"); |
| |
| // Add NonLazyBind attribute to function declarations when -fno-plt |
| // is used. |
| // FIXME: what if we just haven't processed the function definition |
| // yet, or if it's an external definition like C99 inline? |
| if (CodeGenOpts.NoPLT) { |
| if (auto *Fn = dyn_cast<FunctionDecl>(TargetDecl)) { |
| if (!Fn->isDefined() && !AttrOnCallSite) { |
| FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind); |
| } |
| } |
| } |
| } |
| |
| // Collect non-call-site function IR attributes from declaration-specific |
| // information. |
| if (!AttrOnCallSite) { |
| if (TargetDecl && TargetDecl->hasAttr<CmseNSEntryAttr>()) |
| FuncAttrs.addAttribute("cmse_nonsecure_entry"); |
| |
| // Whether tail calls are enabled. |
| auto shouldDisableTailCalls = [&] { |
| // Should this be honored in getDefaultFunctionAttributes? |
| if (CodeGenOpts.DisableTailCalls) |
| return true; |
| |
| if (!TargetDecl) |
| return false; |
| |
| if (TargetDecl->hasAttr<DisableTailCallsAttr>() || |
| TargetDecl->hasAttr<AnyX86InterruptAttr>()) |
| return true; |
| |
| if (CodeGenOpts.NoEscapingBlockTailCalls) { |
| if (const auto *BD = dyn_cast<BlockDecl>(TargetDecl)) |
| if (!BD->doesNotEscape()) |
| return true; |
| } |
| |
| return false; |
| }; |
| FuncAttrs.addAttribute("disable-tail-calls", |
| llvm::toStringRef(shouldDisableTailCalls())); |
| |
| // CPU/feature overrides. addDefaultFunctionDefinitionAttributes |
| // handles these separately to set them based on the global defaults. |
| GetCPUAndFeaturesAttributes(CalleeInfo.getCalleeDecl(), FuncAttrs); |
| } |
| |
| // Collect attributes from arguments and return values. |
| ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI); |
| |
| QualType RetTy = FI.getReturnType(); |
| const ABIArgInfo &RetAI = FI.getReturnInfo(); |
| switch (RetAI.getKind()) { |
| case ABIArgInfo::Extend: |
| if (RetAI.isSignExt()) |
| RetAttrs.addAttribute(llvm::Attribute::SExt); |
| else |
| RetAttrs.addAttribute(llvm::Attribute::ZExt); |
| LLVM_FALLTHROUGH; |
| case ABIArgInfo::Direct: |
| if (RetAI.getInReg()) |
| RetAttrs.addAttribute(llvm::Attribute::InReg); |
| break; |
| case ABIArgInfo::Ignore: |
| break; |
| |
| case ABIArgInfo::InAlloca: |
| case ABIArgInfo::Indirect: { |
| // inalloca and sret disable readnone and readonly |
| FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) |
| .removeAttribute(llvm::Attribute::ReadNone); |
| break; |
| } |
| |
| case ABIArgInfo::CoerceAndExpand: |
| break; |
| |
| case ABIArgInfo::Expand: |
| case ABIArgInfo::IndirectAliased: |
| llvm_unreachable("Invalid ABI kind for return argument"); |
| } |
| |
| if (const auto *RefTy = RetTy->getAs<ReferenceType>()) { |
| QualType PTy = RefTy->getPointeeType(); |
| if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) |
| RetAttrs.addDereferenceableAttr( |
| getMinimumObjectSize(PTy).getQuantity()); |
| if (getContext().getTargetAddressSpace(PTy) == 0 && |
| !CodeGenOpts.NullPointerIsValid) |
| RetAttrs.addAttribute(llvm::Attribute::NonNull); |
| if (PTy->isObjectType()) { |
| llvm::Align Alignment = |
| getNaturalPointeeTypeAlignment(RetTy).getAsAlign(); |
| RetAttrs.addAlignmentAttr(Alignment); |
| } |
| } |
| |
| bool hasUsedSRet = false; |
| SmallVector<llvm::AttributeSet, 4> ArgAttrs(IRFunctionArgs.totalIRArgs()); |
| |
| // Attach attributes to sret. |
| if (IRFunctionArgs.hasSRetArg()) { |
| llvm::AttrBuilder SRETAttrs; |
| SRETAttrs.addAttribute(llvm::Attribute::StructRet); |
| hasUsedSRet = true; |
| if (RetAI.getInReg()) |
| SRETAttrs.addAttribute(llvm::Attribute::InReg); |
| SRETAttrs.addAlignmentAttr(RetAI.getIndirectAlign().getQuantity()); |
| ArgAttrs[IRFunctionArgs.getSRetArgNo()] = |
| llvm::AttributeSet::get(getLLVMContext(), SRETAttrs); |
| } |
| |
| // Attach attributes to inalloca argument. |
| if (IRFunctionArgs.hasInallocaArg()) { |
| llvm::AttrBuilder Attrs; |
| Attrs.addAttribute(llvm::Attribute::InAlloca); |
| ArgAttrs[IRFunctionArgs.getInallocaArgNo()] = |
| llvm::AttributeSet::get(getLLVMContext(), Attrs); |
| } |
| |
| unsigned ArgNo = 0; |
| for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(), |
| E = FI.arg_end(); |
| I != E; ++I, ++ArgNo) { |
| QualType ParamType = I->type; |
| const ABIArgInfo &AI = I->info; |
| llvm::AttrBuilder Attrs; |
| |
| // Add attribute for padding argument, if necessary. |
| if (IRFunctionArgs.hasPaddingArg(ArgNo)) { |
| if (AI.getPaddingInReg()) { |
| ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] = |
| llvm::AttributeSet::get( |
| getLLVMContext(), |
| llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg)); |
| } |
| } |
| |
| // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we |
| // have the corresponding parameter variable. It doesn't make |
| // sense to do it here because parameters are so messed up. |
| switch (AI.getKind()) { |
| case ABIArgInfo::Extend: |
| if (AI.isSignExt()) |
| Attrs.addAttribute(llvm::Attribute::SExt); |
| else |
| Attrs.addAttribute(llvm::Attribute::ZExt); |
| LLVM_FALLTHROUGH; |
| case ABIArgInfo::Direct: |
| if (ArgNo == 0 && FI.isChainCall()) |
| Attrs.addAttribute(llvm::Attribute::Nest); |
| else if (AI.getInReg()) |
| Attrs.addAttribute(llvm::Attribute::InReg); |
| break; |
| |
| case ABIArgInfo::Indirect: { |
| if (AI.getInReg()) |
| Attrs.addAttribute(llvm::Attribute::InReg); |
| |
| if (AI.getIndirectByVal()) |
| Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType)); |
| |
| auto *Decl = ParamType->getAsRecordDecl(); |
| if (CodeGenOpts.PassByValueIsNoAlias && Decl && |
| Decl->getArgPassingRestrictions() == RecordDecl::APK_CanPassInRegs) |
| // When calling the function, the pointer passed in will be the only |
| // reference to the underlying object. Mark it accordingly. |
| Attrs.addAttribute(llvm::Attribute::NoAlias); |
| |
| // TODO: We could add the byref attribute if not byval, but it would |
| // require updating many testcases. |
| |
| CharUnits Align = AI.getIndirectAlign(); |
| |
| // In a byval argument, it is important that the required |
| // alignment of the type is honored, as LLVM might be creating a |
| // *new* stack object, and needs to know what alignment to give |
| // it. (Sometimes it can deduce a sensible alignment on its own, |
| // but not if clang decides it must emit a packed struct, or the |
| // user specifies increased alignment requirements.) |
| // |
| // This is different from indirect *not* byval, where the object |
| // exists already, and the align attribute is purely |
| // informative. |
| assert(!Align.isZero()); |
| |
| // For now, only add this when we have a byval argument. |
| // TODO: be less lazy about updating test cases. |
| if (AI.getIndirectByVal()) |
| Attrs.addAlignmentAttr(Align.getQuantity()); |
| |
| // byval disables readnone and readonly. |
| FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) |
| .removeAttribute(llvm::Attribute::ReadNone); |
| |
| break; |
| } |
| case ABIArgInfo::IndirectAliased: { |
| CharUnits Align = AI.getIndirectAlign(); |
| Attrs.addByRefAttr(getTypes().ConvertTypeForMem(ParamType)); |
| Attrs.addAlignmentAttr(Align.getQuantity()); |
| break; |
| } |
| case ABIArgInfo::Ignore: |
| case ABIArgInfo::Expand: |
| case ABIArgInfo::CoerceAndExpand: |
| break; |
| |
| case ABIArgInfo::InAlloca: |
| // inalloca disables readnone and readonly. |
| FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) |
| .removeAttribute(llvm::Attribute::ReadNone); |
| continue; |
| } |
| |
| if (const auto *RefTy = ParamType->getAs<ReferenceType>()) { |
| QualType PTy = RefTy->getPointeeType(); |
| if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) |
| Attrs.addDereferenceableAttr( |
| getMinimumObjectSize(PTy).getQuantity()); |
| if (getContext().getTargetAddressSpace(PTy) == 0 && |
| !CodeGenOpts.NullPointerIsValid) |
| Attrs.addAttribute(llvm::Attribute::NonNull); |
| if (PTy->isObjectType()) { |
| llvm::Align Alignment = |
| getNaturalPointeeTypeAlignment(ParamType).getAsAlign(); |
| Attrs.addAlignmentAttr(Alignment); |
| } |
| } |
| |
| switch (FI.getExtParameterInfo(ArgNo).getABI()) { |
| case ParameterABI::Ordinary: |
| break; |
| |
| case ParameterABI::SwiftIndirectResult: { |
| // Add 'sret' if we haven't already used it for something, but |
| // only if the result is void. |
| if (!hasUsedSRet && RetTy->isVoidType()) { |
| Attrs.addAttribute(llvm::Attribute::StructRet); |
| hasUsedSRet = true; |
| } |
| |
| // Add 'noalias' in either case. |
| Attrs.addAttribute(llvm::Attribute::NoAlias); |
| |
| // Add 'dereferenceable' and 'alignment'. |
| auto PTy = ParamType->getPointeeType(); |
| if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) { |
| auto info = getContext().getTypeInfoInChars(PTy); |
| Attrs.addDereferenceableAttr(info.first.getQuantity()); |
| Attrs.addAlignmentAttr(info.second.getAsAlign()); |
| } |
| break; |
| } |
| |
| case ParameterABI::SwiftErrorResult: |
| Attrs.addAttribute(llvm::Attribute::SwiftError); |
| break; |
| |
| case ParameterABI::SwiftContext: |
| Attrs.addAttribute(llvm::Attribute::SwiftSelf); |
| break; |
| } |
| |
| if (FI.getExtParameterInfo(ArgNo).isNoEscape()) |
| Attrs.addAttribute(llvm::Attribute::NoCapture); |
| |
| if (Attrs.hasAttributes()) { |
| unsigned FirstIRArg, NumIRArgs; |
| std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); |
| for (unsigned i = 0; i < NumIRArgs; i++) |
| ArgAttrs[FirstIRArg + i] = |
| llvm::AttributeSet::get(getLLVMContext(), Attrs); |
| } |
| } |
| assert(ArgNo == FI.arg_size()); |
| |
| AttrList = llvm::AttributeList::get( |
| getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), FuncAttrs), |
| llvm::AttributeSet::get(getLLVMContext(), RetAttrs), ArgAttrs); |
| } |
| |
| /// An argument came in as a promoted argument; demote it back to its |
| /// declared type. |
| static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF, |
| const VarDecl *var, |
| llvm::Value *value) { |
| llvm::Type *varType = CGF.ConvertType(var->getType()); |
| |
| // This can happen with promotions that actually don't change the |
| // underlying type, like the enum promotions. |
| if (value->getType() == varType) return value; |
| |
| assert((varType->isIntegerTy() || varType->isFloatingPointTy()) |
| && "unexpected promotion type"); |
| |
| if (isa<llvm::IntegerType>(varType)) |
| return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote"); |
| |
| return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote"); |
| } |
| |
| /// Returns the attribute (either parameter attribute, or function |
| /// attribute), which declares argument ArgNo to be non-null. |
| static const NonNullAttr *getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD, |
| QualType ArgType, unsigned ArgNo) { |
| // FIXME: __attribute__((nonnull)) can also be applied to: |
| // - references to pointers, where the pointee is known to be |
| // nonnull (apparently a Clang extension) |
| // - transparent unions containing pointers |
| // In the former case, LLVM IR cannot represent the constraint. In |
| // the latter case, we have no guarantee that the transparent union |
| // is in fact passed as a pointer. |
| if (!ArgType->isAnyPointerType() && !ArgType->isBlockPointerType()) |
| return nullptr; |
| // First, check attribute on parameter itself. |
| if (PVD) { |
| if (auto ParmNNAttr = PVD->getAttr<NonNullAttr>()) |
| return ParmNNAttr; |
| } |
| // Check function attributes. |
| if (!FD) |
| return nullptr; |
| for (const auto *NNAttr : FD->specific_attrs<NonNullAttr>()) { |
| if (NNAttr->isNonNull(ArgNo)) |
| return NNAttr; |
| } |
| return nullptr; |
| } |
| |
| namespace { |
| struct CopyBackSwiftError final : EHScopeStack::Cleanup { |
| Address Temp; |
| Address Arg; |
| CopyBackSwiftError(Address temp, Address arg) : Temp(temp), Arg(arg) {} |
| void Emit(CodeGenFunction &CGF, Flags flags) override { |
| llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp); |
| CGF.Builder.CreateStore(errorValue, Arg); |
| } |
| }; |
| } |
| |
| void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, |
| llvm::Function *Fn, |
| const FunctionArgList &Args) { |
| if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) |
| // Naked functions don't have prologues. |
| return; |
| |
| // If this is an implicit-return-zero function, go ahead and |
| // initialize the return value. TODO: it might be nice to have |
| // a more general mechanism for this that didn't require synthesized |
| // return statements. |
| if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) { |
| if (FD->hasImplicitReturnZero()) { |
| QualType RetTy = FD->getReturnType().getUnqualifiedType(); |
| llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy); |
| llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy); |
| Builder.CreateStore(Zero, ReturnValue); |
| } |
| } |
| |
| // FIXME: We no longer need the types from FunctionArgList; lift up and |
| // simplify. |
| |
| ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI); |
| assert(Fn->arg_size() == IRFunctionArgs.totalIRArgs()); |
| |
| // If we're using inalloca, all the memory arguments are GEPs off of the last |
| // parameter, which is a pointer to the complete memory area. |
| Address ArgStruct = Address::invalid(); |
| if (IRFunctionArgs.hasInallocaArg()) { |
| ArgStruct = Address(Fn->getArg(IRFunctionArgs.getInallocaArgNo()), |
| FI.getArgStructAlignment()); |
| |
| assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo()); |
| } |
| |
| // Name the struct return parameter. |
| if (IRFunctionArgs.hasSRetArg()) { |
| auto AI = Fn->getArg(IRFunctionArgs.getSRetArgNo()); |
| AI->setName("agg.result"); |
| AI->addAttr(llvm::Attribute::NoAlias); |
| } |
| |
| // Track if we received the parameter as a pointer (indirect, byval, or |
| // inalloca). If already have a pointer, EmitParmDecl doesn't need to copy it |
| // into a local alloca for us. |
| SmallVector<ParamValue, 16> ArgVals; |
| ArgVals.reserve(Args.size()); |
| |
| // Create a pointer value for every parameter declaration. This usually |
| // entails copying one or more LLVM IR arguments into an alloca. Don't push |
| // any cleanups or do anything that might unwind. We do that separately, so |
| // we can push the cleanups in the correct order for the ABI. |
| assert(FI.arg_size() == Args.size() && |
| "Mismatch between function signature & arguments."); |
| unsigned ArgNo = 0; |
| CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin(); |
| for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); |
| i != e; ++i, ++info_it, ++ArgNo) { |
| const VarDecl *Arg = *i; |
| const ABIArgInfo &ArgI = info_it->info; |
| |
| bool isPromoted = |
| isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted(); |
| // We are converting from ABIArgInfo type to VarDecl type directly, unless |
| // the parameter is promoted. In this case we convert to |
| // CGFunctionInfo::ArgInfo type with subsequent argument demotion. |
| QualType Ty = isPromoted ? info_it->type : Arg->getType(); |
| assert(hasScalarEvaluationKind(Ty) == |
| hasScalarEvaluationKind(Arg->getType())); |
| |
| unsigned FirstIRArg, NumIRArgs; |
| std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); |
| |
| switch (ArgI.getKind()) { |
| case ABIArgInfo::InAlloca: { |
| assert(NumIRArgs == 0); |
| auto FieldIndex = ArgI.getInAllocaFieldIndex(); |
| Address V = |
| Builder.CreateStructGEP(ArgStruct, FieldIndex, Arg->getName()); |
| if (ArgI.getInAllocaIndirect()) |
| V = Address(Builder.CreateLoad(V), |
| getContext().getTypeAlignInChars(Ty)); |
| ArgVals.push_back(ParamValue::forIndirect(V)); |
| break; |
| } |
| |
| case ABIArgInfo::Indirect: |
| case ABIArgInfo::IndirectAliased: { |
| assert(NumIRArgs == 1); |
| Address ParamAddr = |
| Address(Fn->getArg(FirstIRArg), ArgI.getIndirectAlign()); |
| |
| if (!hasScalarEvaluationKind(Ty)) { |
| // Aggregates and complex variables are accessed by reference. All we |
| // need to do is realign the value, if requested. Also, if the address |
| // may be aliased, copy it to ensure that the parameter variable is |
| // mutable and has a unique adress, as C requires. |
| Address V = ParamAddr; |
| if (ArgI.getIndirectRealign() || ArgI.isIndirectAliased()) { |
| Address AlignedTemp = CreateMemTemp(Ty, "coerce"); |
| |
| // Copy from the incoming argument pointer to the temporary with the |
| // appropriate alignment. |
| // |
| // FIXME: We should have a common utility for generating an aggregate |
| // copy. |
| CharUnits Size = getContext().getTypeSizeInChars(Ty); |
| Builder.CreateMemCpy( |
| AlignedTemp.getPointer(), AlignedTemp.getAlignment().getAsAlign(), |
| ParamAddr.getPointer(), ParamAddr.getAlignment().getAsAlign(), |
| llvm::ConstantInt::get(IntPtrTy, Size.getQuantity())); |
| V = AlignedTemp; |
| } |
| ArgVals.push_back(ParamValue::forIndirect(V)); |
| } else { |
| // Load scalar value from indirect argument. |
| llvm::Value *V = |
| EmitLoadOfScalar(ParamAddr, false, Ty, Arg->getBeginLoc()); |
| |
| if (isPromoted) |
| V = emitArgumentDemotion(*this, Arg, V); |
| ArgVals.push_back(ParamValue::forDirect(V)); |
| } |
| break; |
| } |
| |
| case ABIArgInfo::Extend: |
| case ABIArgInfo::Direct: { |
| auto AI = Fn->getArg(FirstIRArg); |
| llvm::Type *LTy = ConvertType(Arg->getType()); |
| |
| // Prepare parameter attributes. So far, only attributes for pointer |
| // parameters are prepared. See |
| // http://llvm.org/docs/LangRef.html#paramattrs. |
| if (ArgI.getDirectOffset() == 0 && LTy->isPointerTy() && |
| ArgI.getCoerceToType()->isPointerTy()) { |
| assert(NumIRArgs == 1); |
| |
| if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) { |
| // Set `nonnull` attribute if any. |
| if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(), |
| PVD->getFunctionScopeIndex()) && |
| !CGM.getCodeGenOpts().NullPointerIsValid) |
| AI->addAttr(llvm::Attribute::NonNull); |
| |
| QualType OTy = PVD->getOriginalType(); |
| if (const auto *ArrTy = |
| getContext().getAsConstantArrayType(OTy)) { |
| // A C99 array parameter declaration with the static keyword also |
| // indicates dereferenceability, and if the size is constant we can |
| // use the dereferenceable attribute (which requires the size in |
| // bytes). |
| if (ArrTy->getSizeModifier() == ArrayType::Static) { |
| QualType ETy = ArrTy->getElementType(); |
| llvm::Align Alignment = |
| CGM.getNaturalTypeAlignment(ETy).getAsAlign(); |
| AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment)); |
| uint64_t ArrSize = ArrTy->getSize().getZExtValue(); |
| if (!ETy->isIncompleteType() && ETy->isConstantSizeType() && |
| ArrSize) { |
| llvm::AttrBuilder Attrs; |
| Attrs.addDereferenceableAttr( |
| getContext().getTypeSizeInChars(ETy).getQuantity() * |
| ArrSize); |
| AI->addAttrs(Attrs); |
| } else if (getContext().getTargetInfo().getNullPointerValue( |
| ETy.getAddressSpace()) == 0 && |
| !CGM.getCodeGenOpts().NullPointerIsValid) { |
| AI->addAttr(llvm::Attribute::NonNull); |
| } |
| } |
| } else if (const auto *ArrTy = |
| getContext().getAsVariableArrayType(OTy)) { |
| // For C99 VLAs with the static keyword, we don't know the size so |
| // we can't use the dereferenceable attribute, but in addrspace(0) |
| // we know that it must be nonnull. |
| if (ArrTy->getSizeModifier() == VariableArrayType::Static) { |
| QualType ETy = ArrTy->getElementType(); |
| llvm::Align Alignment = |
| CGM.getNaturalTypeAlignment(ETy).getAsAlign(); |
| AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment)); |
| if (!getContext().getTargetAddressSpace(ETy) && |
| !CGM.getCodeGenOpts().NullPointerIsValid) |
| AI->addAttr(llvm::Attribute::NonNull); |
| } |
| } |
| |
| // Set `align` attribute if any. |
| const auto *AVAttr = PVD->getAttr<AlignValueAttr>(); |
| if (!AVAttr) |
| if (const auto *TOTy = dyn_cast<TypedefType>(OTy)) |
| AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>(); |
| if (AVAttr && !SanOpts.has(SanitizerKind::Alignment)) { |
| // If alignment-assumption sanitizer is enabled, we do *not* add |
| // alignment attribute here, but emit normal alignment assumption, |
| // so the UBSAN check could function. |
| llvm::ConstantInt *AlignmentCI = |
| cast<llvm::ConstantInt>(EmitScalarExpr(AVAttr->getAlignment())); |
| unsigned AlignmentInt = |
| AlignmentCI->getLimitedValue(llvm::Value::MaximumAlignment); |
| if (AI->getParamAlign().valueOrOne() < AlignmentInt) { |
| AI->removeAttr(llvm::Attribute::AttrKind::Alignment); |
| AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr( |
| llvm::Align(AlignmentInt))); |
| } |
| } |
| } |
| |
| // Set 'noalias' if an argument type has the `restrict` qualifier. |
| if (Arg->getType().isRestrictQualified()) |
| AI->addAttr(llvm::Attribute::NoAlias); |
| } |
| |
| // Prepare the argument value. If we have the trivial case, handle it |
| // with no muss and fuss. |
| if (!isa<llvm::StructType>(ArgI.getCoerceToType()) && |
| ArgI.getCoerceToType() == ConvertType(Ty) && |
| ArgI.getDirectOffset() == 0) { |
| assert(NumIRArgs == 1); |
| |
| // LLVM expects swifterror parameters to be used in very restricted |
| // ways. Copy the value into a less-restricted temporary. |
| llvm::Value *V = AI; |
| if (FI.getExtParameterInfo(ArgNo).getABI() |
| == ParameterABI::SwiftErrorResult) { |
| QualType pointeeTy = Ty->getPointeeType(); |
| assert(pointeeTy->isPointerType()); |
| Address temp = |
| CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp"); |
| Address arg = Address(V, getContext().getTypeAlignInChars(pointeeTy)); |
| llvm::Value *incomingErrorValue = Builder.CreateLoad(arg); |
| Builder.CreateStore(incomingErrorValue, temp); |
| V = temp.getPointer(); |
| |
| // Push a cleanup to copy the value back at the end of the function. |
| // The convention does not guarantee that the value will be written |
| // back if the function exits with an unwind exception. |
| EHStack.pushCleanup<CopyBackSwiftError>(NormalCleanup, temp, arg); |
| } |
| |
| // Ensure the argument is the correct type. |
| if (V->getType() != ArgI.getCoerceToType()) |
| V = Builder.CreateBitCast(V, ArgI.getCoerceToType()); |
| |
| if (isPromoted) |
| V = emitArgumentDemotion(*this, Arg, V); |
| |
| // Because of merging of function types from multiple decls it is |
| // possible for the type of an argument to not match the corresponding |
| // type in the function type. Since we are codegening the callee |
| // in here, add a cast to the argument type. |
| llvm::Type *LTy = ConvertType(Arg->getType()); |
| if (V->getType() != LTy) |
| V = Builder.CreateBitCast(V, LTy); |
| |
| ArgVals.push_back(ParamValue::forDirect(V)); |
| break; |
| } |
| |
| Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg), |
| Arg->getName()); |
| |
| // Pointer to store into. |
| Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI); |
| |
| // Fast-isel and the optimizer generally like scalar values better than |
| // FCAs, so we flatten them if this is safe to do for this argument. |
| llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType()); |
| if (ArgI.isDirect() |