head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.11; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.26; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.08; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.52; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.33.24; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.35.28; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.02; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.52; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.11.2.1 date 2018.07.28.04.33.17; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGCall.cpp - Encapsulate calling convention details --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // These classes wrap the information about a call or function // definition used to handle ABI compliancy. // //===----------------------------------------------------------------------===// #include "CGCall.h" #include "ABIInfo.h" #include "CGCXXABI.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/MC/SubtargetFeature.h" #include "llvm/Support/CallSite.h" #include "llvm/Transforms/Utils/Local.h" using namespace clang; using namespace CodeGen; /***/ static unsigned 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_X86ThisCall: return llvm::CallingConv::X86_ThisCall; case CC_X86_64Win64: return llvm::CallingConv::X86_64_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 CC_X86Pascal to llvm } } /// Derives the 'this' type for codegen purposes, i.e. ignoring method /// qualification. /// FIXME: address space qualification? static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) { QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal(); return Context.getPointerType(CanQualType::CreateUnsafe(RecTy)); } /// Returns the canonical formal type of the given C++ method. static CanQual GetFormalType(const CXXMethodDecl *MD) { return MD->getType()->getCanonicalTypeUnqualified() .getAs(); } /// 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 FTNP) { // When translating an unprototyped function type, always use a // variadic type. return arrangeLLVMFunctionInfo(FTNP->getResultType().getUnqualifiedType(), None, FTNP->getExtInfo(), RequiredArgs(0)); } /// Arrange the LLVM function layout for a value of the given function /// type, on top of any implicit parameters already stored. Use the /// given ExtInfo instead of the ExtInfo from the function type. static const CGFunctionInfo &arrangeLLVMFunctionInfo(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP, FunctionType::ExtInfo extInfo) { RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, prefix.size()); // FIXME: Kill copy. for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) prefix.push_back(FTP->getArgType(i)); CanQualType resultType = FTP->getResultType().getUnqualifiedType(); return CGT.arrangeLLVMFunctionInfo(resultType, prefix, extInfo, required); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { return arrangeLLVMFunctionInfo(CGT, prefix, FTP, FTP->getExtInfo()); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeCXXMethodType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(CGT, prefix, FTP, extInfo); } /// Arrange the argument and result information for a value of the /// given freestanding function type. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionType(CanQual FTP) { SmallVector argTypes; return ::arrangeFreeFunctionType(*this, argTypes, FTP); } static CallingConv getCallingConventionForDecl(const Decl *D) { // Set the appropriate calling convention for the Function. if (D->hasAttr()) return CC_X86StdCall; if (D->hasAttr()) return CC_X86FastCall; if (D->hasAttr()) return CC_X86ThisCall; if (D->hasAttr()) return CC_X86Pascal; if (PcsAttr *PCS = D->getAttr()) return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP); if (D->hasAttr()) return CC_PnaclCall; if (D->hasAttr()) return CC_IntelOclBicc; 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. /// (Zero value of 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) { SmallVector argTypes; // Add the 'this' pointer. if (RD) argTypes.push_back(GetThisType(Context, RD)); else argTypes.push_back(Context.VoidPtrTy); return ::arrangeCXXMethodType(*this, argTypes, FTP->getCanonicalTypeUnqualified().getAs()); } /// 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(MD) && "wrong method for constructors!"); assert(!isa(MD) && "wrong method for destructors!"); CanQual prototype = GetFormalType(MD); if (MD->isInstance()) { // The abstract case is perfectly fine. const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD); return arrangeCXXMethodType(ThisType, prototype.getTypePtr()); } return arrangeFreeFunctionType(prototype); } /// Arrange the argument and result information for a declaration /// or definition to the given constructor variant. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorDeclaration(const CXXConstructorDecl *D, CXXCtorType ctorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, ctorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes); CanQual FTP = GetFormalType(D); RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size()); // Add the formal parameters. for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) argTypes.push_back(FTP->getArgType(i)); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required); } /// Arrange the argument and result information for a declaration, /// definition, or call to the given destructor variant. It so /// happens that all three cases produce the same information. const CGFunctionInfo & CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D, CXXDtorType dtorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, dtorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes); CanQual FTP = GetFormalType(D); assert(FTP->getNumArgs() == 0 && "dtor with formal parameters"); assert(FTP->isVariadic() == 0 && "dtor with formal parameters"); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, RequiredArgs::All); } /// 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(FD)) if (MD->isInstance()) return arrangeCXXMethodDeclaration(MD); CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified(); assert(isa(FTy)); // When declaring a function without a prototype, always use a // non-variadic type. if (isa(FTy)) { CanQual noProto = FTy.getAs(); return arrangeLLVMFunctionInfo(noProto->getResultType(), None, noProto->getExtInfo(), RequiredArgs::All); } assert(isa(FTy)); return arrangeFreeFunctionType(FTy.getAs()); } /// 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 argTys; argTys.push_back(Context.getCanonicalParamType(receiverType)); argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType())); // FIXME: Kill copy? for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(), e = MD->param_end(); i != e; ++i) { argTys.push_back(Context.getCanonicalParamType((*i)->getType())); } FunctionType::ExtInfo einfo; einfo = einfo.withCallingConv(getCallingConventionForDecl(MD)); if (getContext().getLangOpts().ObjCAutoRefCount && MD->hasAttr()) einfo = einfo.withProducesResult(true); RequiredArgs required = (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys, einfo, required); } const CGFunctionInfo & CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { // FIXME: Do we need to handle ObjCMethodDecl? const FunctionDecl *FD = cast(GD.getDecl()); if (const CXXConstructorDecl *CD = dyn_cast(FD)) return arrangeCXXConstructorDeclaration(CD, GD.getCtorType()); if (const CXXDestructorDecl *DD = dyn_cast(FD)) return arrangeCXXDestructor(DD, GD.getDtorType()); return arrangeFunctionDeclaration(FD); } /// 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) { assert(args.size() >= numExtraRequiredArgs); // 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(fnType)) { if (proto->isVariadic()) required = RequiredArgs(proto->getNumArgs() + numExtraRequiredArgs); // 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(fnType))) { required = RequiredArgs(args.size()); } return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args, fnType->getExtInfo(), 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) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 0); } /// A block function call is essentially a free-function call with an /// extra implicit argument. const CGFunctionInfo & CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *fnType) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1); } const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionCall(QualType resultType, const CallArgList &args, FunctionType::ExtInfo info, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *FPT, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); FunctionType::ExtInfo info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()), argTypes, info, required); } const CGFunctionInfo & CodeGenTypes::arrangeFunctionDeclaration(QualType resultType, const FunctionArgList &args, const FunctionType::ExtInfo &info, bool isVariadic) { // FIXME: Kill copy. SmallVector argTypes; for (FunctionArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType((*i)->getType())); RequiredArgs required = (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info, required); } const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { return arrangeLLVMFunctionInfo(getContext().VoidTy, None, FunctionType::ExtInfo(), RequiredArgs::All); } /// 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, ArrayRef argTypes, FunctionType::ExtInfo info, RequiredArgs required) { #ifndef NDEBUG for (ArrayRef::const_iterator I = argTypes.begin(), E = argTypes.end(); I != E; ++I) assert(I->isCanonicalAsParam()); #endif unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); // Lookup or create unique function info. llvm::FoldingSetNodeID ID; CGFunctionInfo::Profile(ID, info, required, resultType, argTypes); void *insertPos = 0; CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); if (FI) return *FI; // Construct the function info. We co-allocate the ArgInfos. FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required); FunctionInfos.InsertNode(FI, insertPos); bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted; assert(inserted && "Recursively being processed?"); // Compute ABI information. 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() == 0) retInfo.setCoerceToType(ConvertType(FI->getReturnType())); for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end(); I != E; ++I) if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0) 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, const FunctionType::ExtInfo &info, CanQualType resultType, ArrayRef argTypes, RequiredArgs required) { void *buffer = operator new(sizeof(CGFunctionInfo) + sizeof(ArgInfo) * (argTypes.size() + 1)); CGFunctionInfo *FI = new(buffer) CGFunctionInfo(); FI->CallingConvention = llvmCC; FI->EffectiveCallingConvention = llvmCC; FI->ASTCallingConvention = info.getCC(); FI->NoReturn = info.getNoReturn(); FI->ReturnsRetained = info.getProducesResult(); FI->Required = required; FI->HasRegParm = info.getHasRegParm(); FI->RegParm = info.getRegParm(); FI->NumArgs = argTypes.size(); FI->getArgsBuffer()[0].type = resultType; for (unsigned i = 0, e = argTypes.size(); i != e; ++i) FI->getArgsBuffer()[i + 1].type = argTypes[i]; return FI; } /***/ void CodeGenTypes::GetExpandedTypes(QualType type, SmallVectorImpl &expandedTypes) { if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) { uint64_t NumElts = AT->getSize().getZExtValue(); for (uint64_t Elt = 0; Elt < NumElts; ++Elt) GetExpandedTypes(AT->getElementType(), expandedTypes); } else if (const RecordType *RT = type->getAs()) { 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 = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) GetExpandedTypes(LargestFD->getType(), expandedTypes); } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { assert(!i->isBitField() && "Cannot expand structure with bit-field members."); GetExpandedTypes(i->getType(), expandedTypes); } } } else if (const ComplexType *CT = type->getAs()) { llvm::Type *EltTy = ConvertType(CT->getElementType()); expandedTypes.push_back(EltTy); expandedTypes.push_back(EltTy); } else expandedTypes.push_back(ConvertType(type)); } llvm::Function::arg_iterator CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, llvm::Function::arg_iterator AI) { assert(LV.isSimple() && "Unexpected non-simple lvalue during struct expansion."); if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt); LValue LV = MakeAddrLValue(EltAddr, EltTy); AI = ExpandTypeFromArgs(EltTy, LV, AI); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); 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 = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, LargestFD); AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI); } } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; QualType FT = FD->getType(); // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, FD); AI = ExpandTypeFromArgs(FT, SubLV, AI); } } } else if (const ComplexType *CT = Ty->getAs()) { QualType EltTy = CT->getElementType(); llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy)); llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy)); } else { EmitStoreThroughLValue(RValue::get(AI), LV); ++AI; } return AI; } /// 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 llvm::Value * EnterStructPointerForCoercedAccess(llvm::Value *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. uint64_t FirstEltSize = CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt); if (FirstEltSize < DstSize && FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy)) return SrcPtr; // GEP into the first element. SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive"); // If the first element is a struct, recurse. llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); if (llvm::StructType *SrcSTy = dyn_cast(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(Val->getType())) { // If this is Pointer->Pointer avoid conversion to and from int. if (isa(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(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.getTypeAllocSizeInBits(Val->getType()); uint64_t DstSize = DL.getTypeAllocSizeInBits(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(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. /// /// 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(llvm::Value *SrcPtr, llvm::Type *Ty, CodeGenFunction &CGF) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); // If SrcTy and Ty are the same, just do a load. if (SrcTy == Ty) return CGF.Builder.CreateLoad(SrcPtr); uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty); if (llvm::StructType *SrcSTy = dyn_cast(SrcTy)) { SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); SrcTy = cast(SrcPtr->getType())->getElementType(); } uint64_t 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(Ty) || isa(Ty)) && (isa(SrcTy) || isa(SrcTy))) { llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr); return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF); } // If load is legal, just bitcast the src pointer. if (SrcSize >= DstSize) { // 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. llvm::Value *Casted = CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty)); llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); // FIXME: Use better alignment / avoid requiring aligned load. Load->setAlignment(1); return Load; } // Otherwise do coercion through memory. This is stupid, but // simple. llvm::Value *Tmp = CGF.CreateTempAlloca(Ty); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(Casted, SrcCasted, llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize), 1, false); 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? static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, llvm::Value *DestPtr, bool DestIsVolatile, bool LowAlignment) { // Prefer scalar stores to first-class aggregate stores. if (llvm::StructType *STy = dyn_cast(Val->getType())) { for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i); llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i); llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } else { llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, /// where the source and destination may have different types. /// /// 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, llvm::Value *DstPtr, bool DstIsVolatile, CodeGenFunction &CGF) { llvm::Type *SrcTy = Src->getType(); llvm::Type *DstTy = cast(DstPtr->getType())->getElementType(); if (SrcTy == DstTy) { CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); if (llvm::StructType *DstSTy = dyn_cast(DstTy)) { DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF); DstTy = cast(DstPtr->getType())->getElementType(); } // If the source and destination are integer or pointer types, just do an // extension or truncation to the desired type. if ((isa(SrcTy) || isa(SrcTy)) && (isa(DstTy) || isa(DstTy))) { Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF); CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy); // If store is legal, just bitcast the src pointer. if (SrcSize <= DstSize) { llvm::Value *Casted = CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy)); // FIXME: Use better alignment / avoid requiring aligned store. BuildAggStore(CGF, Src, Casted, DstIsVolatile, true); } 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. llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy); CGF.Builder.CreateStore(Src, Tmp); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(DstCasted, Casted, llvm::ConstantInt::get(CGF.IntPtrTy, DstSize), 1, false); } } /***/ bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { return FI.getReturnInfo().isIndirect(); } bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { if (const BuiltinType *BT = ResultType->getAs()) { 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()) { if (const BuiltinType *BT = CT->getElementType()->getAs()) { 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); (void)Inserted; assert(Inserted && "Recursively being processed?"); SmallVector argTypes; llvm::Type *resultType = 0; const ABIArgInfo &retAI = FI.getReturnInfo(); switch (retAI.getKind()) { case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); case ABIArgInfo::Extend: case ABIArgInfo::Direct: resultType = retAI.getCoerceToType(); break; case ABIArgInfo::Indirect: { assert(!retAI.getIndirectAlign() && "Align unused on indirect return."); resultType = llvm::Type::getVoidTy(getLLVMContext()); QualType ret = FI.getReturnType(); llvm::Type *ty = ConvertType(ret); unsigned addressSpace = Context.getTargetAddressSpace(ret); argTypes.push_back(llvm::PointerType::get(ty, addressSpace)); break; } case ABIArgInfo::Ignore: resultType = llvm::Type::getVoidTy(getLLVMContext()); break; } // Add in all of the required arguments. CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie; if (FI.isVariadic()) { ie = it + FI.getRequiredArgs().getNumRequiredArgs(); } else { ie = FI.arg_end(); } for (; it != ie; ++it) { const ABIArgInfo &argAI = it->info; // Insert a padding type to ensure proper alignment. if (llvm::Type *PaddingType = argAI.getPaddingType()) argTypes.push_back(PaddingType); switch (argAI.getKind()) { case ABIArgInfo::Ignore: break; case ABIArgInfo::Indirect: { // indirect arguments are always on the stack, which is addr space #0. llvm::Type *LTy = ConvertTypeForMem(it->type); argTypes.push_back(LTy->getPointerTo()); break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If the coerce-to type is a first class aggregate, flatten it. Either // way is semantically identical, but fast-isel and the optimizer // generally likes scalar values better than FCAs. llvm::Type *argType = argAI.getCoerceToType(); if (llvm::StructType *st = dyn_cast(argType)) { for (unsigned i = 0, e = st->getNumElements(); i != e; ++i) argTypes.push_back(st->getElementType(i)); } else { argTypes.push_back(argType); } break; } case ABIArgInfo::Expand: GetExpandedTypes(it->type, argTypes); 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(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); if (!isFuncTypeConvertible(FPT)) return llvm::StructType::get(getLLVMContext()); const CGFunctionInfo *Info; if (isa(MD)) Info = &arrangeCXXDestructor(cast(MD), GD.getDtorType()); else Info = &arrangeCXXMethodDeclaration(MD); return GetFunctionType(*Info); } void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, const Decl *TargetDecl, AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) { llvm::AttrBuilder FuncAttrs; llvm::AttrBuilder RetAttrs; CallingConv = FI.getEffectiveCallingConvention(); if (FI.isNoReturn()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); // FIXME: handle sseregparm someday... if (TargetDecl) { if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); if (const FunctionDecl *Fn = dyn_cast(TargetDecl)) { const FunctionProtoType *FPT = Fn->getType()->getAs(); if (FPT && FPT->isNothrow(getContext())) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Don't use [[noreturn]] or _Noreturn for a call to a virtual function. // These attributes are not inherited by overloads. const CXXMethodDecl *MD = dyn_cast(Fn); if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual())) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); } // 'const' and 'pure' attribute functions are also nounwind. if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadNone); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } else if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadOnly); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } if (TargetDecl->hasAttr()) RetAttrs.addAttribute(llvm::Attribute::NoAlias); } 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.NoImplicitFloat) FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat); if (AttrOnCallSite) { // Attributes that should go on the call site only. if (!CodeGenOpts.SimplifyLibCalls) FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); } else { // Attributes that should go on the function, but not the call site. if (!CodeGenOpts.DisableFPElim) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); } else if (CodeGenOpts.OmitLeafFramePointer) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } else { FuncAttrs.addAttribute("no-frame-pointer-elim", "true"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } FuncAttrs.addAttribute("less-precise-fpmad", llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); FuncAttrs.addAttribute("no-infs-fp-math", llvm::toStringRef(CodeGenOpts.NoInfsFPMath)); FuncAttrs.addAttribute("no-nans-fp-math", llvm::toStringRef(CodeGenOpts.NoNaNsFPMath)); FuncAttrs.addAttribute("unsafe-fp-math", llvm::toStringRef(CodeGenOpts.UnsafeFPMath)); FuncAttrs.addAttribute("use-soft-float", llvm::toStringRef(CodeGenOpts.SoftFloat)); FuncAttrs.addAttribute("stack-protector-buffer-size", llvm::utostr(CodeGenOpts.SSPBufferSize)); if (!CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("no-realign-stack"); } QualType RetTy = FI.getReturnType(); unsigned Index = 1; const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::Extend: if (RetTy->hasSignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::SExt); else if (RetTy->hasUnsignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: if (RetAI.getInReg()) RetAttrs.addAttribute(llvm::Attribute::InReg); break; case ABIArgInfo::Ignore: break; case ABIArgInfo::Indirect: { llvm::AttrBuilder SRETAttrs; SRETAttrs.addAttribute(llvm::Attribute::StructRet); if (RetAI.getInReg()) SRETAttrs.addAttribute(llvm::Attribute::InReg); PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), Index, SRETAttrs)); ++Index; // sret disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } if (RetAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs)); for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie = FI.arg_end(); it != ie; ++it) { QualType ParamType = it->type; const ABIArgInfo &AI = it->info; llvm::AttrBuilder Attrs; if (AI.getPaddingType()) { if (AI.getPaddingInReg()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, llvm::Attribute::InReg)); // Increment Index if there is padding. ++Index; } // '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 (ParamType->isSignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::SExt); else if (ParamType->isUnsignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); // FIXME: handle sseregparm someday... if (llvm::StructType *STy = dyn_cast(AI.getCoerceToType())) { unsigned Extra = STy->getNumElements()-1; // 1 will be added below. if (Attrs.hasAttributes()) for (unsigned I = 0; I < Extra; ++I) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I, Attrs)); Index += Extra; } break; case ABIArgInfo::Indirect: if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); if (AI.getIndirectByVal()) Attrs.addAttribute(llvm::Attribute::ByVal); Attrs.addAlignmentAttr(AI.getIndirectAlign()); // byval disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; case ABIArgInfo::Ignore: // Skip increment, no matching LLVM parameter. continue; case ABIArgInfo::Expand: { SmallVector types; // FIXME: This is rather inefficient. Do we ever actually need to do // anything here? The result should be just reconstructed on the other // side, so extension should be a non-issue. getTypes().GetExpandedTypes(ParamType, types); Index += types.size(); continue; } } if (Attrs.hasAttributes()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); ++Index; } if (FuncAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs)); } /// 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(varType)) return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote"); return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote"); } void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args) { // 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(CurCodeDecl)) { if (FD->hasImplicitReturnZero()) { QualType RetTy = FD->getResultType().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. // Emit allocs for param decls. Give the LLVM Argument nodes names. llvm::Function::arg_iterator AI = Fn->arg_begin(); // Name the struct return argument. if (CGM.ReturnTypeUsesSRet(FI)) { AI->setName("agg.result"); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); ++AI; } assert(FI.arg_size() == Args.size() && "Mismatch between function signature & arguments."); unsigned ArgNo = 1; 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; QualType Ty = info_it->type; const ABIArgInfo &ArgI = info_it->info; bool isPromoted = isa(Arg) && cast(Arg)->isKNRPromoted(); // Skip the dummy padding argument. if (ArgI.getPaddingType()) ++AI; switch (ArgI.getKind()) { case ABIArgInfo::Indirect: { llvm::Value *V = AI; if (!hasScalarEvaluationKind(Ty)) { // Aggregates and complex variables are accessed by reference. All we // need to do is realign the value, if requested if (ArgI.getIndirectRealign()) { llvm::Value *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. llvm::Type *I8PtrTy = Builder.getInt8PtrTy(); CharUnits Size = getContext().getTypeSizeInChars(Ty); llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy); llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy); Builder.CreateMemCpy(Dst, Src, llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()), ArgI.getIndirectAlign(), false); V = AlignedTemp; } } else { // Load scalar value from indirect argument. CharUnits Alignment = getContext().getTypeAlignInChars(Ty); V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); } EmitParmDecl(*Arg, V, ArgNo); break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If we have the trivial case, handle it with no muss and fuss. if (!isa(ArgI.getCoerceToType()) && ArgI.getCoerceToType() == ConvertType(Ty) && ArgI.getDirectOffset() == 0) { assert(AI != Fn->arg_end() && "Argument mismatch!"); llvm::Value *V = AI; if (Arg->getType().isRestrictQualified()) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); // 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); if (const CXXMethodDecl *MD = dyn_cast_or_null(CurCodeDecl)) { if (MD->isVirtual() && Arg == CXXABIThisDecl) V = CGM.getCXXABI(). adjustThisParameterInVirtualFunctionPrologue(*this, CurGD, 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); EmitParmDecl(*Arg, V, ArgNo); break; } llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName()); // The alignment we need to use is the max of the requested alignment for // the argument plus the alignment required by our access code below. unsigned AlignmentToUse = CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType()); AlignmentToUse = std::max(AlignmentToUse, (unsigned)getContext().getDeclAlign(Arg).getQuantity()); Alloca->setAlignment(AlignmentToUse); llvm::Value *V = Alloca; llvm::Value *Ptr = V; // Pointer to store into. // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgI.getDirectOffset()) { Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy()); Ptr = Builder.CreateConstGEP1_32(Ptr, Offs); Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ArgI.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. llvm::StructType *STy = dyn_cast(ArgI.getCoerceToType()); if (STy && STy->getNumElements() > 1) { uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy); llvm::Type *DstTy = cast(Ptr->getType())->getElementType(); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy); if (SrcSize <= DstSize) { Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy)); for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i); Builder.CreateStore(AI++, EltPtr); } } else { llvm::AllocaInst *TempAlloca = CreateTempAlloca(ArgI.getCoerceToType(), "coerce"); TempAlloca->setAlignment(AlignmentToUse); llvm::Value *TempV = TempAlloca; for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i); Builder.CreateStore(AI++, EltPtr); } Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse); } } else { // Simple case, just do a coerced store of the argument into the alloca. assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce"); CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this); } // Match to what EmitParmDecl is expecting for this type. if (CodeGenFunction::hasScalarEvaluationKind(Ty)) { V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); } EmitParmDecl(*Arg, V, ArgNo); continue; // Skip ++AI increment, already done. } case ABIArgInfo::Expand: { // If this structure was expanded into multiple arguments then // we need to create a temporary and reconstruct it from the // arguments. llvm::AllocaInst *Alloca = CreateMemTemp(Ty); CharUnits Align = getContext().getDeclAlign(Arg); Alloca->setAlignment(Align.getQuantity()); LValue LV = MakeAddrLValue(Alloca, Ty, Align); llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI); EmitParmDecl(*Arg, Alloca, ArgNo); // Name the arguments used in expansion and increment AI. unsigned Index = 0; for (; AI != End; ++AI, ++Index) AI->setName(Arg->getName() + "." + Twine(Index)); continue; } case ABIArgInfo::Ignore: // Initialize the local variable appropriately. if (!hasScalarEvaluationKind(Ty)) EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo); else EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())), ArgNo); // Skip increment, no matching LLVM parameter. continue; } ++AI; } assert(AI == Fn->arg_end() && "Argument mismatch!"); } static void eraseUnusedBitCasts(llvm::Instruction *insn) { while (insn->use_empty()) { llvm::BitCastInst *bitcast = dyn_cast(insn); if (!bitcast) return; // This is "safe" because we would have used a ConstantExpr otherwise. insn = cast(bitcast->getOperand(0)); bitcast->eraseFromParent(); } } /// Try to emit a fused autorelease of a return result. static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // We must be immediately followed the cast. llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock(); if (BB->empty()) return 0; if (&BB->back() != result) return 0; llvm::Type *resultType = result->getType(); // result is in a BasicBlock and is therefore an Instruction. llvm::Instruction *generator = cast(result); SmallVector insnsToKill; // Look for: // %generator = bitcast %type1* %generator2 to %type2* while (llvm::BitCastInst *bitcast = dyn_cast(generator)) { // We would have emitted this as a constant if the operand weren't // an Instruction. generator = cast(bitcast->getOperand(0)); // Require the generator to be immediately followed by the cast. if (generator->getNextNode() != bitcast) return 0; insnsToKill.push_back(bitcast); } // Look for: // %generator = call i8* @@objc_retain(i8* %originalResult) // or // %generator = call i8* @@objc_retainAutoreleasedReturnValue(i8* %originalResult) llvm::CallInst *call = dyn_cast(generator); if (!call) return 0; bool doRetainAutorelease; if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) { doRetainAutorelease = true; } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints() .objc_retainAutoreleasedReturnValue) { doRetainAutorelease = false; // If we emitted an assembly marker for this call (and the // ARCEntrypoints field should have been set if so), go looking // for that call. If we can't find it, we can't do this // optimization. But it should always be the immediately previous // instruction, unless we needed bitcasts around the call. if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) { llvm::Instruction *prev = call->getPrevNode(); assert(prev); if (isa(prev)) { prev = prev->getPrevNode(); assert(prev); } assert(isa(prev)); assert(cast(prev)->getCalledValue() == CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker); insnsToKill.push_back(prev); } } else { return 0; } result = call->getArgOperand(0); insnsToKill.push_back(call); // Keep killing bitcasts, for sanity. Note that we no longer care // about precise ordering as long as there's exactly one use. while (llvm::BitCastInst *bitcast = dyn_cast(result)) { if (!bitcast->hasOneUse()) break; insnsToKill.push_back(bitcast); result = bitcast->getOperand(0); } // Delete all the unnecessary instructions, from latest to earliest. for (SmallVectorImpl::iterator i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i) (*i)->eraseFromParent(); // Do the fused retain/autorelease if we were asked to. if (doRetainAutorelease) result = CGF.EmitARCRetainAutoreleaseReturnValue(result); // Cast back to the result type. return CGF.Builder.CreateBitCast(result, resultType); } /// If this is a +1 of the value of an immutable 'self', remove it. static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result) { // This is only applicable to a method with an immutable 'self'. const ObjCMethodDecl *method = dyn_cast_or_null(CGF.CurCodeDecl); if (!method) return 0; const VarDecl *self = method->getSelfDecl(); if (!self->getType().isConstQualified()) return 0; // Look for a retain call. llvm::CallInst *retainCall = dyn_cast(result->stripPointerCasts()); if (!retainCall || retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain) return 0; // Look for an ordinary load of 'self'. llvm::Value *retainedValue = retainCall->getArgOperand(0); llvm::LoadInst *load = dyn_cast(retainedValue->stripPointerCasts()); if (!load || load->isAtomic() || load->isVolatile() || load->getPointerOperand() != CGF.GetAddrOfLocalVar(self)) return 0; // Okay! Burn it all down. This relies for correctness on the // assumption that the retain is emitted as part of the return and // that thereafter everything is used "linearly". llvm::Type *resultType = result->getType(); eraseUnusedBitCasts(cast(result)); assert(retainCall->use_empty()); retainCall->eraseFromParent(); eraseUnusedBitCasts(cast(retainedValue)); return CGF.Builder.CreateBitCast(load, resultType); } /// Emit an ARC autorelease of the result of a function. /// /// \return the value to actually return from the function static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // If we're returning 'self', kill the initial retain. This is a // heuristic attempt to "encourage correctness" in the really unfortunate // case where we have a return of self during a dealloc and we desperately // need to avoid the possible autorelease. if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result)) return self; // At -O0, try to emit a fused retain/autorelease. if (CGF.shouldUseFusedARCCalls()) if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result)) return fused; return CGF.EmitARCAutoreleaseReturnValue(result); } /// Heuristically search for a dominating store to the return-value slot. static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { // If there are multiple uses of the return-value slot, just check // for something immediately preceding the IP. Sometimes this can // happen with how we generate implicit-returns; it can also happen // with noreturn cleanups. if (!CGF.ReturnValue->hasOneUse()) { llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); if (IP->empty()) return 0; llvm::StoreInst *store = dyn_cast(&IP->back()); if (!store) return 0; if (store->getPointerOperand() != CGF.ReturnValue) return 0; assert(!store->isAtomic() && !store->isVolatile()); // see below return store; } llvm::StoreInst *store = dyn_cast(CGF.ReturnValue->use_back()); if (!store) return 0; // These aren't actually possible for non-coerced returns, and we // only care about non-coerced returns on this code path. assert(!store->isAtomic() && !store->isVolatile()); // Now do a first-and-dirty dominance check: just walk up the // single-predecessors chain from the current insertion point. llvm::BasicBlock *StoreBB = store->getParent(); llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); while (IP != StoreBB) { if (!(IP = IP->getSinglePredecessor())) return 0; } // Okay, the store's basic block dominates the insertion point; we // can do our thing. return store; } void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc) { // Functions with no result always return void. if (ReturnValue == 0) { Builder.CreateRetVoid(); return; } llvm::DebugLoc RetDbgLoc; llvm::Value *RV = 0; QualType RetTy = FI.getReturnType(); const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::Indirect: { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { ComplexPairTy RT = EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy), EndLoc); EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), /*isInit*/ true); break; } case TEK_Aggregate: // Do nothing; aggregrates get evaluated directly into the destination. break; case TEK_Scalar: EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), /*isInit*/ true); break; } break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: if (RetAI.getCoerceToType() == ConvertType(RetTy) && RetAI.getDirectOffset() == 0) { // The internal return value temp always will have pointer-to-return-type // type, just do a load. // If there is a dominating store to ReturnValue, we can elide // the load, zap the store, and usually zap the alloca. if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) { // Reuse the debug location from the store unless there is // cleanup code to be emitted between the store and return // instruction. if (EmitRetDbgLoc && !AutoreleaseResult) RetDbgLoc = SI->getDebugLoc(); // Get the stored value and nuke the now-dead store. RV = SI->getValueOperand(); SI->eraseFromParent(); // If that was the only use of the return value, nuke it as well now. if (ReturnValue->use_empty() && isa(ReturnValue)) { cast(ReturnValue)->eraseFromParent(); ReturnValue = 0; } // Otherwise, we have to do a simple load. } else { RV = Builder.CreateLoad(ReturnValue); } } else { llvm::Value *V = ReturnValue; // If the value is offset in memory, apply the offset now. if (unsigned Offs = RetAI.getDirectOffset()) { V = Builder.CreateBitCast(V, Builder.getInt8PtrTy()); V = Builder.CreateConstGEP1_32(V, Offs); V = Builder.CreateBitCast(V, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this); } // In ARC, end functions that return a retainable type with a call // to objc_autoreleaseReturnValue. if (AutoreleaseResult) { assert(getLangOpts().ObjCAutoRefCount && !FI.isReturnsRetained() && RetTy->isObjCRetainableType()); RV = emitAutoreleaseOfResult(*this, RV); } break; case ABIArgInfo::Ignore: break; case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid(); if (!RetDbgLoc.isUnknown()) Ret->setDebugLoc(RetDbgLoc); } void CodeGenFunction::EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc) { // StartFunction converted the ABI-lowered parameter(s) into a // local alloca. We need to turn that into an r-value suitable // for EmitCall. llvm::Value *local = GetAddrOfLocalVar(param); QualType type = param->getType(); // For the most part, we just need to load the alloca, except: // 1) aggregate r-values are actually pointers to temporaries, and // 2) references to non-scalars are pointers directly to the aggregate. // I don't know why references to scalars are different here. if (const ReferenceType *ref = type->getAs()) { if (!hasScalarEvaluationKind(ref->getPointeeType())) return args.add(RValue::getAggregate(local), type); // Locals which are references to scalars are represented // with allocas holding the pointer. return args.add(RValue::get(Builder.CreateLoad(local)), type); } args.add(convertTempToRValue(local, type, loc), type); } static bool isProvablyNull(llvm::Value *addr) { return isa(addr); } static bool isProvablyNonNull(llvm::Value *addr) { return isa(addr); } /// Emit the actual writing-back of a writeback. static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback) { const LValue &srcLV = writeback.Source; llvm::Value *srcAddr = srcLV.getAddress(); assert(!isProvablyNull(srcAddr) && "shouldn't have writeback for provably null argument"); llvm::BasicBlock *contBB = 0; // If the argument wasn't provably non-null, we need to null check // before doing the store. bool provablyNonNull = isProvablyNonNull(srcAddr); if (!provablyNonNull) { llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback"); contBB = CGF.createBasicBlock("icr.done"); llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); CGF.Builder.CreateCondBr(isNull, contBB, writebackBB); CGF.EmitBlock(writebackBB); } // Load the value to writeback. llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary); // Cast it back, in case we're writing an id to a Foo* or something. value = CGF.Builder.CreateBitCast(value, cast(srcAddr->getType())->getElementType(), "icr.writeback-cast"); // Perform the writeback. // If we have a "to use" value, it's something we need to emit a use // of. This has to be carefully threaded in: if it's done after the // release it's potentially undefined behavior (and the optimizer // will ignore it), and if it happens before the retain then the // optimizer could move the release there. if (writeback.ToUse) { assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong); // Retain the new value. No need to block-copy here: the block's // being passed up the stack. value = CGF.EmitARCRetainNonBlock(value); // Emit the intrinsic use here. CGF.EmitARCIntrinsicUse(writeback.ToUse); // Load the old value (primitively). llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation()); // Put the new value in place (primitively). CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false); // Release the old value. CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime()); // Otherwise, we can just do a normal lvalue store. } else { CGF.EmitStoreThroughLValue(RValue::get(value), srcLV); } // Jump to the continuation block. if (!provablyNonNull) CGF.EmitBlock(contBB); } static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args) { for (CallArgList::writeback_iterator i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i) emitWriteback(CGF, *i); } static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs) { assert(CGF.getTarget().getCXXABI().isArgumentDestroyedByCallee()); ArrayRef Cleanups = CallArgs.getCleanupsToDeactivate(); // Iterate in reverse to increase the likelihood of popping the cleanup. for (ArrayRef::reverse_iterator I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) { CGF.DeactivateCleanupBlock(I->Cleanup, I->IsActiveIP); I->IsActiveIP->eraseFromParent(); } } static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) { if (const UnaryOperator *uop = dyn_cast(E->IgnoreParens())) if (uop->getOpcode() == UO_AddrOf) return uop->getSubExpr(); return 0; } /// Emit an argument that's being passed call-by-writeback. That is, /// we are passing the address of static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE) { LValue srcLV; // Make an optimistic effort to emit the address as an l-value. // This can fail if the the argument expression is more complicated. if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) { srcLV = CGF.EmitLValue(lvExpr); // Otherwise, just emit it as a scalar. } else { llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr()); QualType srcAddrType = CRE->getSubExpr()->getType()->castAs()->getPointeeType(); srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType); } llvm::Value *srcAddr = srcLV.getAddress(); // The dest and src types don't necessarily match in LLVM terms // because of the crazy ObjC compatibility rules. llvm::PointerType *destType = cast(CGF.ConvertType(CRE->getType())); // If the address is a constant null, just pass the appropriate null. if (isProvablyNull(srcAddr)) { args.add(RValue::get(llvm::ConstantPointerNull::get(destType)), CRE->getType()); return; } // Create the temporary. llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(), "icr.temp"); // Loading an l-value can introduce a cleanup if the l-value is __weak, // and that cleanup will be conditional if we can't prove that the l-value // isn't null, so we need to register a dominating point so that the cleanups // system will make valid IR. CodeGenFunction::ConditionalEvaluation condEval(CGF); // Zero-initialize it if we're not doing a copy-initialization. bool shouldCopy = CRE->shouldCopy(); if (!shouldCopy) { llvm::Value *null = llvm::ConstantPointerNull::get( cast(destType->getElementType())); CGF.Builder.CreateStore(null, temp); } llvm::BasicBlock *contBB = 0; llvm::BasicBlock *originBB = 0; // If the address is *not* known to be non-null, we need to switch. llvm::Value *finalArgument; bool provablyNonNull = isProvablyNonNull(srcAddr); if (provablyNonNull) { finalArgument = temp; } else { llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); finalArgument = CGF.Builder.CreateSelect(isNull, llvm::ConstantPointerNull::get(destType), temp, "icr.argument"); // If we need to copy, then the load has to be conditional, which // means we need control flow. if (shouldCopy) { originBB = CGF.Builder.GetInsertBlock(); contBB = CGF.createBasicBlock("icr.cont"); llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy"); CGF.Builder.CreateCondBr(isNull, contBB, copyBB); CGF.EmitBlock(copyBB); condEval.begin(CGF); } } llvm::Value *valueToUse = 0; // Perform a copy if necessary. if (shouldCopy) { RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation()); assert(srcRV.isScalar()); llvm::Value *src = srcRV.getScalarVal(); src = CGF.Builder.CreateBitCast(src, destType->getElementType(), "icr.cast"); // Use an ordinary store, not a store-to-lvalue. CGF.Builder.CreateStore(src, temp); // If optimization is enabled, and the value was held in a // __strong variable, we need to tell the optimizer that this // value has to stay alive until we're doing the store back. // This is because the temporary is effectively unretained, // and so otherwise we can violate the high-level semantics. if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 && srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) { valueToUse = src; } } // Finish the control flow if we needed it. if (shouldCopy && !provablyNonNull) { llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock(); CGF.EmitBlock(contBB); // Make a phi for the value to intrinsically use. if (valueToUse) { llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2, "icr.to-use"); phiToUse->addIncoming(valueToUse, copyBB); phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()), originBB); valueToUse = phiToUse; } condEval.end(CGF); } args.addWriteback(srcLV, temp, valueToUse); args.add(RValue::get(finalArgument), CRE->getType()); } void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E, QualType type) { if (const ObjCIndirectCopyRestoreExpr *CRE = dyn_cast(E)) { assert(getLangOpts().ObjCAutoRefCount); assert(getContext().hasSameType(E->getType(), type)); return emitWritebackArg(*this, args, CRE); } assert(type->isReferenceType() == E->isGLValue() && "reference binding to unmaterialized r-value!"); if (E->isGLValue()) { assert(E->getObjectKind() == OK_Ordinary); return args.add(EmitReferenceBindingToExpr(E), type); } bool HasAggregateEvalKind = hasAggregateEvaluationKind(type); // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee. // However, we still have to push an EH-only cleanup in case we unwind before // we make it to the call. if (HasAggregateEvalKind && CGM.getTarget().getCXXABI().isArgumentDestroyedByCallee()) { const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); if (RD && RD->hasNonTrivialDestructor()) { AggValueSlot Slot = CreateAggTemp(type, "agg.arg.tmp"); Slot.setExternallyDestructed(); EmitAggExpr(E, Slot); RValue RV = Slot.asRValue(); args.add(RV, type); pushDestroy(EHCleanup, RV.getAggregateAddr(), type, destroyCXXObject, /*useEHCleanupForArray*/ true); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *IsActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive); return; } } if (HasAggregateEvalKind && isa(E) && cast(E)->getCastKind() == CK_LValueToRValue) { LValue L = EmitLValue(cast(E)->getSubExpr()); assert(L.isSimple()); if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) { args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true); } else { // We can't represent a misaligned lvalue in the CallArgList, so copy // to an aligned temporary now. llvm::Value *tmp = CreateMemTemp(type); EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile(), L.getAlignment()); args.add(RValue::getAggregate(tmp), type); } return; } args.add(EmitAnyExprToTemp(E), type); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. void CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) { if (CGM.getCodeGenOpts().OptimizationLevel != 0 && !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions) Inst->setMetadata("clang.arc.no_objc_arc_exceptions", CGM.getNoObjCARCExceptionsMetadata()); } /// Emits a call to the given no-arguments nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitNounwindRuntimeCall(callee, ArrayRef(), name); } /// Emits a call to the given nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = EmitRuntimeCall(callee, args, name); call->setDoesNotThrow(); return call; } /// Emits a simple call (never an invoke) to the given no-arguments /// runtime function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitRuntimeCall(callee, ArrayRef(), name); } /// Emits a simple call (never an invoke) to the given runtime /// function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = Builder.CreateCall(callee, args, name); call->setCallingConv(getRuntimeCC()); return call; } /// Emits a call or invoke to the given noreturn runtime function. void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args) { if (getInvokeDest()) { llvm::InvokeInst *invoke = Builder.CreateInvoke(callee, getUnreachableBlock(), getInvokeDest(), args); invoke->setDoesNotReturn(); invoke->setCallingConv(getRuntimeCC()); } else { llvm::CallInst *call = Builder.CreateCall(callee, args); call->setDoesNotReturn(); call->setCallingConv(getRuntimeCC()); Builder.CreateUnreachable(); } } /// Emits a call or invoke instruction to the given nullary runtime /// function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, const Twine &name) { return EmitRuntimeCallOrInvoke(callee, ArrayRef(), name); } /// Emits a call or invoke instruction to the given runtime function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args, const Twine &name) { llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name); callSite.setCallingConv(getRuntimeCC()); return callSite; } llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, const Twine &Name) { return EmitCallOrInvoke(Callee, ArrayRef(), Name); } /// Emits a call or invoke instruction to the given function, depending /// on the current state of the EH stack. llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, ArrayRef Args, const Twine &Name) { llvm::BasicBlock *InvokeDest = getInvokeDest(); llvm::Instruction *Inst; if (!InvokeDest) Inst = Builder.CreateCall(Callee, Args, Name); else { llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont"); Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name); EmitBlock(ContBB); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(Inst); return Inst; } static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo, llvm::FunctionType *FTy) { if (ArgNo < FTy->getNumParams()) assert(Elt->getType() == FTy->getParamType(ArgNo)); else assert(FTy->isVarArg()); ++ArgNo; } void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV, SmallVectorImpl &Args, llvm::FunctionType *IRFuncTy) { if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); llvm::Value *Addr = RV.getAggregateAddr(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt); RValue EltRV = convertTempToRValue(EltAddr, EltTy, SourceLocation()); ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); assert(RV.isAggregate() && "Unexpected rvalue during struct expansion"); LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty); if (RD->isUnion()) { const FieldDecl *LargestFD = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { RValue FldRV = EmitRValueForField(LV, LargestFD, SourceLocation()); ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy); } } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy); } } } else if (Ty->isAnyComplexType()) { ComplexPairTy CV = RV.getComplexVal(); Args.push_back(CV.first); Args.push_back(CV.second); } else { assert(RV.isScalar() && "Unexpected non-scalar rvalue during struct expansion."); // Insert a bitcast as needed. llvm::Value *V = RV.getScalarVal(); if (Args.size() < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(Args.size())) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size())); Args.push_back(V); } } RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &CallArgs, const Decl *TargetDecl, llvm::Instruction **callOrInvoke) { // FIXME: We no longer need the types from CallArgs; lift up and simplify. SmallVector Args; // Handle struct-return functions by passing a pointer to the // location that we would like to return into. QualType RetTy = CallInfo.getReturnType(); const ABIArgInfo &RetAI = CallInfo.getReturnInfo(); // IRArgNo - Keep track of the argument number in the callee we're looking at. unsigned IRArgNo = 0; llvm::FunctionType *IRFuncTy = cast( cast(Callee->getType())->getElementType()); // If the call returns a temporary with struct return, create a temporary // alloca to hold the result, unless one is given to us. if (CGM.ReturnTypeUsesSRet(CallInfo)) { llvm::Value *Value = ReturnValue.getValue(); if (!Value) Value = CreateMemTemp(RetTy); Args.push_back(Value); checkArgMatches(Value, IRArgNo, IRFuncTy); } assert(CallInfo.arg_size() == CallArgs.size() && "Mismatch between function signature & arguments."); CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin(); for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); I != E; ++I, ++info_it) { const ABIArgInfo &ArgInfo = info_it->info; RValue RV = I->RV; CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty); // Insert a padding argument to ensure proper alignment. if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) { Args.push_back(llvm::UndefValue::get(PaddingType)); ++IRArgNo; } switch (ArgInfo.getKind()) { case ABIArgInfo::Indirect: { if (RV.isScalar() || RV.isComplex()) { // Make a temporary alloca to pass the argument. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (ArgInfo.getIndirectAlign() > AI->getAlignment()) AI->setAlignment(ArgInfo.getIndirectAlign()); Args.push_back(AI); LValue argLV = MakeAddrLValue(Args.back(), I->Ty, TypeAlign); if (RV.isScalar()) EmitStoreOfScalar(RV.getScalarVal(), argLV, /*init*/ true); else EmitStoreOfComplex(RV.getComplexVal(), argLV, /*init*/ true); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // We want to avoid creating an unnecessary temporary+copy here; // however, we need one in three cases: // 1. If the argument is not byval, and we are required to copy the // source. (This case doesn't occur on any common architecture.) // 2. If the argument is byval, RV is not sufficiently aligned, and // we cannot force it to be sufficiently aligned. // 3. If the argument is byval, but RV is located in an address space // different than that of the argument (0). llvm::Value *Addr = RV.getAggregateAddr(); unsigned Align = ArgInfo.getIndirectAlign(); const llvm::DataLayout *TD = &CGM.getDataLayout(); const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace(); const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ? IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0); if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) || (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align && llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) || (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) { // Create an aligned temporary, and copy to it. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (Align > AI->getAlignment()) AI->setAlignment(Align); Args.push_back(AI); EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified()); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // Skip the extra memcpy call. Args.push_back(Addr); // Validate argument match. checkArgMatches(Addr, IRArgNo, IRFuncTy); } } break; } case ABIArgInfo::Ignore: break; case ABIArgInfo::Extend: case ABIArgInfo::Direct: { if (!isa(ArgInfo.getCoerceToType()) && ArgInfo.getCoerceToType() == ConvertType(info_it->type) && ArgInfo.getDirectOffset() == 0) { llvm::Value *V; if (RV.isScalar()) V = RV.getScalarVal(); else V = Builder.CreateLoad(RV.getAggregateAddr()); // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. if (IRArgNo < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(IRArgNo)) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo)); Args.push_back(V); checkArgMatches(V, IRArgNo, IRFuncTy); break; } // FIXME: Avoid the conversion through memory if possible. llvm::Value *SrcPtr; if (RV.isScalar() || RV.isComplex()) { SrcPtr = CreateMemTemp(I->Ty, "coerce"); LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign); if (RV.isScalar()) { EmitStoreOfScalar(RV.getScalarVal(), SrcLV, /*init*/ true); } else { EmitStoreOfComplex(RV.getComplexVal(), SrcLV, /*init*/ true); } } else SrcPtr = RV.getAggregateAddr(); // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgInfo.getDirectOffset()) { SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy()); SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs); SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(ArgInfo.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. if (llvm::StructType *STy = dyn_cast(ArgInfo.getCoerceToType())) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy); // If the source type is smaller than the destination type of the // coerce-to logic, copy the source value into a temp alloca the size // of the destination type to allow loading all of it. The bits past // the source value are left undef. if (SrcSize < DstSize) { llvm::AllocaInst *TempAlloca = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce"); Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0); SrcPtr = TempAlloca; } else { SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(STy)); } for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i); llvm::LoadInst *LI = Builder.CreateLoad(EltPtr); // We don't know what we're loading from. LI->setAlignment(1); Args.push_back(LI); // Validate argument match. checkArgMatches(LI, IRArgNo, IRFuncTy); } } else { // In the simple case, just pass the coerced loaded value. Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), *this)); // Validate argument match. checkArgMatches(Args.back(), IRArgNo, IRFuncTy); } break; } case ABIArgInfo::Expand: ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy); IRArgNo = Args.size(); break; } } if (!CallArgs.getCleanupsToDeactivate().empty()) deactivateArgCleanupsBeforeCall(*this, CallArgs); // If the callee is a bitcast of a function to a varargs pointer to function // type, check to see if we can remove the bitcast. This handles some cases // with unprototyped functions. if (llvm::ConstantExpr *CE = dyn_cast(Callee)) if (llvm::Function *CalleeF = dyn_cast(CE->getOperand(0))) { llvm::PointerType *CurPT=cast(Callee->getType()); llvm::FunctionType *CurFT = cast(CurPT->getElementType()); llvm::FunctionType *ActualFT = CalleeF->getFunctionType(); if (CE->getOpcode() == llvm::Instruction::BitCast && ActualFT->getReturnType() == CurFT->getReturnType() && ActualFT->getNumParams() == CurFT->getNumParams() && ActualFT->getNumParams() == Args.size() && (CurFT->isVarArg() || !ActualFT->isVarArg())) { bool ArgsMatch = true; for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i) if (ActualFT->getParamType(i) != CurFT->getParamType(i)) { ArgsMatch = false; break; } // Strip the cast if we can get away with it. This is a nice cleanup, // but also allows us to inline the function at -O0 if it is marked // always_inline. if (ArgsMatch) Callee = CalleeF; } } unsigned CallingConv; CodeGen::AttributeListType AttributeList; CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, CallingConv, true); llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), AttributeList); llvm::BasicBlock *InvokeDest = 0; if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind)) InvokeDest = getInvokeDest(); llvm::CallSite CS; if (!InvokeDest) { CS = Builder.CreateCall(Callee, Args); } else { llvm::BasicBlock *Cont = createBasicBlock("invoke.cont"); CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args); EmitBlock(Cont); } if (callOrInvoke) *callOrInvoke = CS.getInstruction(); CS.setAttributes(Attrs); CS.setCallingConv(static_cast(CallingConv)); // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(CS.getInstruction()); // If the call doesn't return, finish the basic block and clear the // insertion point; this allows the rest of IRgen to discard // unreachable code. if (CS.doesNotReturn()) { Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); // FIXME: For now, emit a dummy basic block because expr emitters in // generally are not ready to handle emitting expressions at unreachable // points. EnsureInsertPoint(); // Return a reasonable RValue. return GetUndefRValue(RetTy); } llvm::Instruction *CI = CS.getInstruction(); if (Builder.isNamePreserving() && !CI->getType()->isVoidTy()) CI->setName("call"); // Emit any writebacks immediately. Arguably this should happen // after any return-value munging. if (CallArgs.hasWritebacks()) emitWritebacks(*this, CallArgs); switch (RetAI.getKind()) { case ABIArgInfo::Indirect: return convertTempToRValue(Args[0], RetTy, SourceLocation()); case ABIArgInfo::Ignore: // If we are ignoring an argument that had a result, make sure to // construct the appropriate return value for our caller. return GetUndefRValue(RetTy); case ABIArgInfo::Extend: case ABIArgInfo::Direct: { llvm::Type *RetIRTy = ConvertType(RetTy); if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { llvm::Value *Real = Builder.CreateExtractValue(CI, 0); llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); return RValue::getComplex(std::make_pair(Real, Imag)); } case TEK_Aggregate: { llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "agg.tmp"); DestIsVolatile = false; } BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); return RValue::getAggregate(DestPtr); } case TEK_Scalar: { // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. llvm::Value *V = CI; if (V->getType() != RetIRTy) V = Builder.CreateBitCast(V, RetIRTy); return RValue::get(V); } } llvm_unreachable("bad evaluation kind"); } llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "coerce"); DestIsVolatile = false; } // If the value is offset in memory, apply the offset now. llvm::Value *StorePtr = DestPtr; if (unsigned Offs = RetAI.getDirectOffset()) { StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); StorePtr = Builder.CreateBitCast(StorePtr, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); return convertTempToRValue(DestPtr, RetTy, SourceLocation()); } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm_unreachable("Unhandled ABIArgInfo::Kind"); } /* VarArg handling */ llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) { return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d126 1 a126 1 static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) { a148 6 if (D->hasAttr()) return IsWindows ? CC_C : CC_X86_64Win64; if (D->hasAttr()) return IsWindows ? CC_X86_64SysV : CC_C; d205 2 d209 2 a214 5 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes); RequiredArgs required = (D->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); d295 1 a295 2 bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows(); einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows)); a1248 6 // 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. SmallVector ArgVals; ArgVals.reserve(Args.size()); d1302 1 a1302 1 ArgVals.push_back(V); d1343 1 a1343 1 ArgVals.push_back(V); d1416 1 a1416 1 ArgVals.push_back(V); d1429 1 a1429 1 ArgVals.push_back(Alloca); d1441 1 a1441 1 ArgVals.push_back(CreateMemTemp(Ty)); d1443 2 a1444 1 ArgVals.push_back(llvm::UndefValue::get(ConvertType(Arg->getType()))); a1452 8 if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { for (int I = Args.size() - 1; I >= 0; --I) EmitParmDecl(*Args[I], ArgVals[I], I + 1); } else { for (unsigned I = 0, E = Args.size(); I != E; ++I) EmitParmDecl(*Args[I], ArgVals[I], I + 1); } d1862 1 a1862 1 assert(CGF.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()); a2006 35 void CodeGenFunction::EmitCallArgs(CallArgList &Args, ArrayRef ArgTypes, CallExpr::const_arg_iterator ArgBeg, CallExpr::const_arg_iterator ArgEnd, bool ForceColumnInfo) { CGDebugInfo *DI = getDebugInfo(); SourceLocation CallLoc; if (DI) CallLoc = DI->getLocation(); // We *have* to evaluate arguments from right to left in the MS C++ ABI, // because arguments are destroyed left to right in the callee. if (CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { size_t CallArgsStart = Args.size(); for (int I = ArgTypes.size() - 1; I >= 0; --I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } // Un-reverse the arguments we just evaluated so they match up with the LLVM // IR function. std::reverse(Args.begin() + CallArgsStart, Args.end()); return; } for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; assert(Arg != ArgEnd); EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } } d2030 1 a2030 1 CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @a2186 1 PGO.setCurrentRegionUnreachable(); @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d31 1 a31 1 #include "llvm/IR/Intrinsics.h" d82 2 a83 3 return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(), false, None, FTNP->getExtInfo(), RequiredArgs(0)); a89 1 bool IsInstanceMethod, d95 4 a98 5 for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) prefix.push_back(FTP->getParamType(i)); CanQualType resultType = FTP->getReturnType().getUnqualifiedType(); return CGT.arrangeLLVMFunctionInfo(resultType, IsInstanceMethod, prefix, extInfo, required); d106 1 a106 1 return arrangeLLVMFunctionInfo(CGT, false, prefix, FTP, FTP->getExtInfo()); d115 1 a115 1 return arrangeLLVMFunctionInfo(CGT, true, prefix, FTP, extInfo); d214 2 a215 2 for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) argTypes.push_back(FTP->getParamType(i)); d223 1 a223 23 return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraArgs) { // FIXME: Kill copy. SmallVector ArgTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) ArgTypes.push_back(Context.getCanonicalParamType(i->Ty)); CanQual FPT = GetFormalType(D); RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs); GlobalDecl GD(D, CtorKind); CanQualType ResultType = TheCXXABI.HasThisReturn(GD) ? ArgTypes.front() : Context.VoidTy; FunctionType::ExtInfo Info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(ResultType, true, ArgTypes, Info, Required); d242 1 a242 1 assert(FTP->getNumParams() == 0 && "dtor with formal parameters"); d246 1 a246 1 return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, d266 1 a266 1 return arrangeLLVMFunctionInfo(noProto->getReturnType(), false, None, d312 2 a313 2 return arrangeLLVMFunctionInfo(GetReturnType(MD->getReturnType()), false, argTys, einfo, required); d347 1 a347 1 required = RequiredArgs(proto->getNumParams() + numExtraRequiredArgs); d359 1 a359 1 return CGT.arrangeFreeFunctionCall(fnType->getReturnType(), args, d391 2 a392 2 return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, required); d407 1 a407 1 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getReturnType()), true, d411 5 a415 3 const CGFunctionInfo &CodeGenTypes::arrangeFreeFunctionDeclaration( QualType resultType, const FunctionArgList &args, const FunctionType::ExtInfo &info, bool isVariadic) { d424 1 a424 1 return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, d429 1 a429 1 return arrangeLLVMFunctionInfo(getContext().VoidTy, false, None, a437 1 bool IsInstanceMethod, d451 1 a451 2 CGFunctionInfo::Profile(ID, IsInstanceMethod, info, required, resultType, argTypes); d459 1 a459 2 FI = CGFunctionInfo::create(CC, IsInstanceMethod, info, resultType, argTypes, required); a486 1 bool IsInstanceMethod, a496 1 FI->InstanceMethod = IsInstanceMethod; a501 1 FI->ArgStruct = 0; a912 4 case ABIArgInfo::InAlloca: resultType = llvm::Type::getVoidTy(getLLVMContext()); break; a944 1 case ABIArgInfo::InAlloca: a974 4 // Add the inalloca struct as the last parameter type. if (llvm::StructType *ArgStruct = FI.getArgStruct()) argTypes.push_back(ArgStruct->getPointerTo()); a1099 7 case ABIArgInfo::InAlloca: { // inalloca disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } a1183 7 case ABIArgInfo::InAlloca: // inalloca disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); // Skip increment, no matching LLVM parameter. continue; a1198 8 // Add the inalloca attribute to the trailing inalloca parameter if present. if (FI.usesInAlloca()) { llvm::AttrBuilder Attrs; Attrs.addAttribute(llvm::Attribute::InAlloca); PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); } d1235 1 a1235 1 QualType RetTy = FD->getReturnType().getUnqualifiedType(); a1247 10 // 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. llvm::Value *ArgStruct = 0; if (FI.usesInAlloca()) { llvm::Function::arg_iterator EI = Fn->arg_end(); --EI; ArgStruct = EI; assert(ArgStruct->getType() == FI.getArgStruct()->getPointerTo()); } a1256 8 // 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. enum ValOrPointer { HaveValue = 0, HavePointer = 1 }; typedef llvm::PointerIntPair ValueAndIsPtr; SmallVector ArgVals; ArgVals.reserve(Args.size()); d1261 2 a1280 7 case ABIArgInfo::InAlloca: { llvm::Value *V = Builder.CreateStructGEP( ArgStruct, ArgI.getInAllocaFieldIndex(), Arg->getName()); ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); continue; // Don't increment AI! } a1306 1 ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); a1314 1 ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); d1316 1 d1357 1 a1357 1 ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); a1428 3 ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); } else { ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); d1430 1 d1443 1 a1443 1 ArgVals.push_back(ValueAndIsPtr(Alloca, HavePointer)); d1454 4 a1457 6 if (!hasScalarEvaluationKind(Ty)) { ArgVals.push_back(ValueAndIsPtr(CreateMemTemp(Ty), HavePointer)); } else { llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType())); ArgVals.push_back(ValueAndIsPtr(U, HaveValue)); } a1464 3 if (FI.usesInAlloca()) ++AI; d1469 1 a1469 2 EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); d1472 1 a1472 2 EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); a1685 4 case ABIArgInfo::InAlloca: // Do nothing; aggregrates get evaluated directly into the destination. break; a1773 19 static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) { const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory; } static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty) { // FIXME: Generate IR in one pass, rather than going back and fixing up these // placeholders. llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty); llvm::Value *Placeholder = llvm::UndefValue::get(IRTy->getPointerTo()->getPointerTo()); Placeholder = CGF.Builder.CreateLoad(Placeholder); return AggValueSlot::forAddr(Placeholder, CharUnits::Zero(), Ty.getQualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); } a1796 14 if (isInAllocaArgument(CGM.getCXXABI(), type)) { AggValueSlot Slot = createPlaceholderSlot(*this, type); Slot.setExternallyDestructed(); // FIXME: Either emit a copy constructor call, or figure out how to do // guaranteed tail calls with perfect forwarding in LLVM. CGM.ErrorUnsupported(param, "non-trivial argument copy for thunk"); EmitNullInitialization(Slot.getAddr(), type); RValue RV = Slot.asRValue(); args.add(RV, type); return; } a2027 28 void CallArgList::allocateArgumentMemory(CodeGenFunction &CGF) { assert(!StackBase && !StackCleanup.isValid()); // Save the stack. llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave); StackBase = CGF.Builder.CreateCall(F, "inalloca.save"); // Control gets really tied up in landing pads, so we have to spill the // stacksave to an alloca to avoid violating SSA form. // TODO: This is dead if we never emit the cleanup. We should create the // alloca and store lazily on the first cleanup emission. StackBaseMem = CGF.CreateTempAlloca(CGF.Int8PtrTy, "inalloca.spmem"); CGF.Builder.CreateStore(StackBase, StackBaseMem); CGF.pushStackRestore(EHCleanup, StackBaseMem); StackCleanup = CGF.EHStack.getInnermostEHScope(); assert(StackCleanup.isValid()); } void CallArgList::freeArgumentMemory(CodeGenFunction &CGF) const { if (StackBase) { CGF.DeactivateCleanupBlock(StackCleanup, StackBase); llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore); // We could load StackBase from StackBaseMem, but in the non-exceptional // case we can skip it. CGF.Builder.CreateCall(F, StackBase); } } a2039 11 // Insert a stack save if we're going to need any inalloca args. bool HasInAllocaArgs = false; for (ArrayRef::iterator I = ArgTypes.begin(), E = ArgTypes.end(); I != E && !HasInAllocaArgs; ++I) HasInAllocaArgs = isInAllocaArgument(CGM.getCXXABI(), *I); if (HasInAllocaArgs) { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); Args.allocateArgumentMemory(*this); } // Evaluate each argument. a2062 19 namespace { struct DestroyUnpassedArg : EHScopeStack::Cleanup { DestroyUnpassedArg(llvm::Value *Addr, QualType Ty) : Addr(Addr), Ty(Ty) {} llvm::Value *Addr; QualType Ty; void Emit(CodeGenFunction &CGF, Flags flags) { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } }; } d2085 9 a2093 7 if (HasAggregateEvalKind && args.isUsingInAlloca()) { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); AggValueSlot Slot = createPlaceholderSlot(*this, type); Slot.setExternallyDestructed(); EmitAggExpr(E, Slot); RValue RV = Slot.asRValue(); args.add(RV, type); d2095 2 a2096 6 const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); if (RD->hasNonTrivialDestructor()) { // Create a no-op GEP between the placeholder and the cleanup so we can // RAUW it successfully. It also serves as a marker of the first // instruction where the cleanup is active. pushFullExprCleanup(EHCleanup, Slot.getAddr(), type); d2100 1 a2101 1 return; a2310 14 /// \brief Store a non-aggregate value to an address to initialize it. For /// initialization, a non-atomic store will be used. static void EmitInitStoreOfNonAggregate(CodeGenFunction &CGF, RValue Src, LValue Dst) { if (Src.isScalar()) CGF.EmitStoreOfScalar(Src.getScalarVal(), Dst, /*init=*/true); else CGF.EmitStoreOfComplex(Src.getComplexVal(), Dst, /*init=*/true); } void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New) { DeferredReplacements.push_back(std::make_pair(Old, New)); } a2331 11 // If we're using inalloca, insert the allocation after the stack save. // FIXME: Do this earlier rather than hacking it in here! llvm::Value *ArgMemory = 0; if (llvm::StructType *ArgStruct = CallInfo.getArgStruct()) { llvm::AllocaInst *AI = new llvm::AllocaInst( ArgStruct, "argmem", CallArgs.getStackBase()->getNextNode()); AI->setUsedWithInAlloca(true); assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca()); ArgMemory = AI; } d2334 6 a2339 13 llvm::Value *SRetPtr = 0; if (CGM.ReturnTypeUsesSRet(CallInfo) || RetAI.isInAlloca()) { SRetPtr = ReturnValue.getValue(); if (!SRetPtr) SRetPtr = CreateMemTemp(RetTy); if (CGM.ReturnTypeUsesSRet(CallInfo)) { Args.push_back(SRetPtr); checkArgMatches(SRetPtr, IRArgNo, IRFuncTy); } else { llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, RetAI.getInAllocaFieldIndex()); Builder.CreateStore(SRetPtr, Addr); } a2358 22 case ABIArgInfo::InAlloca: { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); if (RV.isAggregate()) { // Replace the placeholder with the appropriate argument slot GEP. llvm::Instruction *Placeholder = cast(RV.getAggregateAddr()); CGBuilderTy::InsertPoint IP = Builder.saveIP(); Builder.SetInsertPoint(Placeholder); llvm::Value *Addr = Builder.CreateStructGEP( ArgMemory, ArgInfo.getInAllocaFieldIndex()); Builder.restoreIP(IP); deferPlaceholderReplacement(Placeholder, Addr); } else { // Store the RValue into the argument struct. llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex()); LValue argLV = MakeAddrLValue(Addr, I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); } break; // Don't increment IRArgNo! } d2367 7 a2373 2 LValue argLV = MakeAddrLValue(Args.back(), I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); d2446 5 a2450 1 EmitInitStoreOfNonAggregate(*this, RV, SrcLV); a2515 28 if (ArgMemory) { llvm::Value *Arg = ArgMemory; llvm::Type *LastParamTy = IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1); if (Arg->getType() != LastParamTy) { #ifndef NDEBUG // Assert that these structs have equivalent element types. llvm::StructType *FullTy = CallInfo.getArgStruct(); llvm::StructType *Prefix = cast( cast(LastParamTy)->getElementType()); // For variadic functions, the caller might supply a larger struct than // the callee expects, and that's OK. assert(Prefix->getNumElements() == FullTy->getNumElements() || (CallInfo.isVariadic() && Prefix->getNumElements() <= FullTy->getNumElements())); for (llvm::StructType::element_iterator PI = Prefix->element_begin(), PE = Prefix->element_end(), FI = FullTy->element_begin(); PI != PE; ++PI, ++FI) assert(*PI == *FI); #endif Arg = Builder.CreateBitCast(Arg, LastParamTy); } Args.push_back(Arg); } a2604 4 // The stack cleanup for inalloca arguments has to run out of the normal // lexical order, so deactivate it and run it manually here. CallArgs.freeArgumentMemory(*this); a2605 1 case ABIArgInfo::InAlloca: d2607 1 a2607 1 return convertTempToRValue(SRetPtr, RetTy, SourceLocation()); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @d943 1 a943 9 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()); } a1054 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate); d1780 1 a1780 11 // Aggregrates get evaluated directly into the destination. Sometimes we // need to return the sret value in a register, though. assert(hasAggregateEvaluationKind(RetTy)); if (RetAI.getInAllocaSRet()) { llvm::Function::arg_iterator EI = CurFn->arg_end(); --EI; llvm::Value *ArgStruct = EI; llvm::Value *SRet = Builder.CreateStructGEP(ArgStruct, RetAI.getInAllocaFieldIndex()); RV = Builder.CreateLoad(SRet, "sret"); } @ 1.1.1.5.2.1 log @Rebase. @ text @a28 1 #include "llvm/IR/CallSite.h" d32 1 a160 17 static bool isAAPCSVFP(const CGFunctionInfo &FI, const TargetInfo &Target) { switch (FI.getEffectiveCallingConvention()) { case llvm::CallingConv::C: switch (Target.getTriple().getEnvironment()) { case llvm::Triple::EABIHF: case llvm::Triple::GNUEABIHF: return true; default: return false; } case llvm::CallingConv::ARM_AAPCS_VFP: return true; default: return false; } } d321 3 a323 2 for (const auto *I : MD->params()) { argTys.push_back(Context.getCanonicalParamType(I->getType())); d478 1 a478 1 void *insertPos = nullptr; d498 1 a498 1 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr) d501 4 a504 3 for (auto &I : FI->arguments()) if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr) I.info.setCoerceToType(ConvertType(I.type)); d530 1 a530 1 FI->ArgStruct = nullptr; d553 1 a553 1 const FieldDecl *LargestFD = nullptr; d556 3 a558 1 for (const auto *FD : RD->fields()) { d570 3 a572 2 for (const auto *I : RD->fields()) { assert(!I->isBitField() && d574 1 a574 1 GetExpandedTypes(I->getType(), expandedTypes); d604 1 a604 1 const FieldDecl *LargestFD = nullptr; d607 3 a609 1 for (const auto *FD : RD->fields()) { d624 3 a626 1 for (const auto *FD : RD->fields()) { d712 2 a713 3 uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType()); uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy); a889 5 bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) { return ReturnTypeUsesSRet(FI) && getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs(); } a928 1 bool SwapThisWithSRet = false; d930 1 a930 1 llvm::Type *resultType = nullptr; a961 2 SwapThisWithSRet = retAI.isSRetAfterThis(); a1000 2 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. d1002 1 a1002 2 llvm::StructType *st = dyn_cast(argType); if (st && !isAAPCSVFP(FI, getTarget())) { a1020 3 if (SwapThisWithSRet) std::swap(argTypes[0], argTypes[1]); a1096 3 if (CodeGenOpts.EnableSegmentedStacks && !(TargetDecl && TargetDecl->hasAttr())) FuncAttrs.addAttribute("split-stack"); a1132 1 bool SwapThisWithSRet = false; d1160 2 a1161 3 SwapThisWithSRet = RetAI.isSRetAfterThis(); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), SwapThisWithSRet ? 2 : Index, SRETAttrs)); d1163 1 a1163 2 if (!SwapThisWithSRet) ++Index; a1173 3 if (RetTy->isReferenceType()) RetAttrs.addAttribute(llvm::Attribute::NonNull); d1180 4 a1183 3 for (const auto &I : FI.arguments()) { QualType ParamType = I.type; const ABIArgInfo &AI = I.info; a1185 5 // Skip over the sret parameter when it comes second. We already handled it // above. if (Index == 2 && SwapThisWithSRet) ++Index; d1204 1 a1204 1 case ABIArgInfo::Direct: { d1210 2 a1211 3 llvm::StructType *STy = dyn_cast(AI.getCoerceToType()); if (!isAAPCSVFP(FI, getTarget()) && STy) { d1220 1 a1220 1 } a1256 3 if (ParamType->isReferenceType()) Attrs.addAttribute(llvm::Attribute::NonNull); d1320 1 a1320 1 llvm::Value *ArgStruct = nullptr; d1328 2 a1329 7 // Name the struct return parameter, which can come first or second. const ABIArgInfo &RetAI = FI.getReturnInfo(); bool SwapThisWithSRet = false; if (RetAI.isIndirect()) { SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) ++AI; d1331 2 a1332 1 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, d1334 1 a1334 4 if (SwapThisWithSRet) --AI; // Go back to the beginning for 'this'. else ++AI; // Skip the sret parameter. a1478 2 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. d1480 1 a1480 1 if (!isAAPCSVFP(FI, getTarget()) && STy && STy->getNumElements() > 1) { a1561 3 if (ArgNo == 1 && SwapThisWithSRet) ++AI; // Skip the sret parameter. d1595 2 a1596 2 if (BB->empty()) return nullptr; if (&BB->back() != result) return nullptr; d1614 1 a1614 1 return nullptr; d1624 1 a1624 1 if (!call) return nullptr; d1652 1 a1652 1 return nullptr; d1685 1 a1685 1 if (!method) return nullptr; d1687 1 a1687 1 if (!self->getType().isConstQualified()) return nullptr; d1694 1 a1694 1 return nullptr; d1702 1 a1702 1 return nullptr; d1744 1 a1744 1 if (IP->empty()) return nullptr; d1746 2 a1747 2 if (!store) return nullptr; if (store->getPointerOperand() != CGF.ReturnValue) return nullptr; d1753 2 a1754 2 dyn_cast(CGF.ReturnValue->user_back()); if (!store) return nullptr; d1766 1 a1766 1 return nullptr; d1778 1 a1778 1 if (!ReturnValue) { d1784 1 a1784 1 llvm::Value *RV = nullptr; a1803 3 auto AI = CurFn->arg_begin(); if (RetAI.isSRetAfterThis()) ++AI; d1809 2 a1810 1 EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(AI, RetTy), d1819 1 a1819 1 MakeNaturalAlignAddrLValue(AI, RetTy), d1848 1 a1848 1 ReturnValue = nullptr; d1966 1 a1966 1 llvm::BasicBlock *contBB = nullptr; d2026 3 a2028 2 for (const auto &I : args.writebacks()) emitWriteback(CGF, I); d2048 1 a2048 1 return nullptr; d2102 3 a2104 3 llvm::BasicBlock *contBB = nullptr; llvm::BasicBlock *originBB = nullptr; d2131 1 a2131 1 llvm::Value *valueToUse = nullptr; d2261 1 a2261 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d2293 4 a2296 17 if (HasAggregateEvalKind && CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { // If we're using inalloca, use the argument memory. Otherwise, use a // temporary. AggValueSlot Slot; if (args.isUsingInAlloca()) Slot = createPlaceholderSlot(*this, type); else Slot = CreateAggTemp(type, "agg.tmp"); const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); bool DestroyedInCallee = RD && RD->hasNonTrivialDestructor() && CGM.getCXXABI().getRecordArgABI(RD) != CGCXXABI::RAA_Default; if (DestroyedInCallee) Slot.setExternallyDestructed(); d2301 2 a2302 1 if (DestroyedInCallee) { d2476 1 a2476 1 const FieldDecl *LargestFD = nullptr; d2479 3 a2481 1 for (const auto *FD : RD->fields()) { d2495 4 a2498 1 for (const auto *FD : RD->fields()) { d2558 1 a2558 1 llvm::Value *ArgMemory = nullptr; d2560 2 a2561 8 llvm::Instruction *IP = CallArgs.getStackBase(); llvm::AllocaInst *AI; if (IP) { IP = IP->getNextNode(); AI = new llvm::AllocaInst(ArgStruct, "argmem", IP); } else { AI = CreateTempAlloca(ArgStruct, "argmem"); } d2569 2 a2570 3 llvm::Value *SRetPtr = nullptr; bool SwapThisWithSRet = false; if (RetAI.isIndirect() || RetAI.isInAlloca()) { d2574 1 a2574 1 if (RetAI.isIndirect()) { a2575 3 SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) IRArgNo = 1; a2576 2 if (SwapThisWithSRet) IRArgNo = 0; a2591 4 // Skip 'sret' if it came second. if (IRArgNo == 1 && SwapThisWithSRet) ++IRArgNo; a2616 7 unsigned AS = Addr->getType()->getPointerAddressSpace(); llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS); // There are some cases where a trivial bitcast is not avoidable. The // definition of a type later in a translation unit may change it's type // from {}* to (%struct.foo*)*. if (Addr->getType() != MemType) Addr = Builder.CreateBitCast(Addr, MemType); d2721 2 a2722 5 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. llvm::StructType *STy = dyn_cast(ArgInfo.getCoerceToType()); if (STy && !isAAPCSVFP(CallInfo, getTarget())) { a2770 3 if (SwapThisWithSRet) std::swap(Args[0], Args[1]); d2839 1 a2839 1 llvm::BasicBlock *InvokeDest = nullptr; a2854 6 if (CurCodeDecl && CurCodeDecl->hasAttr() && !CS.hasFnAttr(llvm::Attribute::NoInline)) Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::AlwaysInline); @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @a28 1 #include "llvm/IR/CallSite.h" d32 1 a160 17 static bool isAAPCSVFP(const CGFunctionInfo &FI, const TargetInfo &Target) { switch (FI.getEffectiveCallingConvention()) { case llvm::CallingConv::C: switch (Target.getTriple().getEnvironment()) { case llvm::Triple::EABIHF: case llvm::Triple::GNUEABIHF: return true; default: return false; } case llvm::CallingConv::ARM_AAPCS_VFP: return true; default: return false; } } d321 3 a323 2 for (const auto *I : MD->params()) { argTys.push_back(Context.getCanonicalParamType(I->getType())); d478 1 a478 1 void *insertPos = nullptr; d498 1 a498 1 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr) d501 4 a504 3 for (auto &I : FI->arguments()) if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() == nullptr) I.info.setCoerceToType(ConvertType(I.type)); d530 1 a530 1 FI->ArgStruct = nullptr; d553 1 a553 1 const FieldDecl *LargestFD = nullptr; d556 3 a558 1 for (const auto *FD : RD->fields()) { d570 3 a572 2 for (const auto *I : RD->fields()) { assert(!I->isBitField() && d574 1 a574 1 GetExpandedTypes(I->getType(), expandedTypes); d604 1 a604 1 const FieldDecl *LargestFD = nullptr; d607 3 a609 1 for (const auto *FD : RD->fields()) { d624 3 a626 1 for (const auto *FD : RD->fields()) { d712 2 a713 3 uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType()); uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy); a889 5 bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) { return ReturnTypeUsesSRet(FI) && getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs(); } a928 1 bool SwapThisWithSRet = false; d930 1 a930 1 llvm::Type *resultType = nullptr; a961 2 SwapThisWithSRet = retAI.isSRetAfterThis(); a1000 2 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. d1002 1 a1002 2 llvm::StructType *st = dyn_cast(argType); if (st && !isAAPCSVFP(FI, getTarget())) { a1020 3 if (SwapThisWithSRet) std::swap(argTypes[0], argTypes[1]); a1096 3 if (CodeGenOpts.EnableSegmentedStacks && !(TargetDecl && TargetDecl->hasAttr())) FuncAttrs.addAttribute("split-stack"); a1132 1 bool SwapThisWithSRet = false; d1160 2 a1161 3 SwapThisWithSRet = RetAI.isSRetAfterThis(); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), SwapThisWithSRet ? 2 : Index, SRETAttrs)); d1163 1 a1163 2 if (!SwapThisWithSRet) ++Index; a1173 3 if (RetTy->isReferenceType()) RetAttrs.addAttribute(llvm::Attribute::NonNull); d1180 4 a1183 3 for (const auto &I : FI.arguments()) { QualType ParamType = I.type; const ABIArgInfo &AI = I.info; a1185 5 // Skip over the sret parameter when it comes second. We already handled it // above. if (Index == 2 && SwapThisWithSRet) ++Index; d1204 1 a1204 1 case ABIArgInfo::Direct: { d1210 2 a1211 3 llvm::StructType *STy = dyn_cast(AI.getCoerceToType()); if (!isAAPCSVFP(FI, getTarget()) && STy) { d1220 1 a1220 1 } a1256 3 if (ParamType->isReferenceType()) Attrs.addAttribute(llvm::Attribute::NonNull); d1320 1 a1320 1 llvm::Value *ArgStruct = nullptr; d1328 2 a1329 7 // Name the struct return parameter, which can come first or second. const ABIArgInfo &RetAI = FI.getReturnInfo(); bool SwapThisWithSRet = false; if (RetAI.isIndirect()) { SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) ++AI; d1331 2 a1332 1 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, d1334 1 a1334 4 if (SwapThisWithSRet) --AI; // Go back to the beginning for 'this'. else ++AI; // Skip the sret parameter. a1478 2 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. d1480 1 a1480 1 if (!isAAPCSVFP(FI, getTarget()) && STy && STy->getNumElements() > 1) { a1561 3 if (ArgNo == 1 && SwapThisWithSRet) ++AI; // Skip the sret parameter. d1595 2 a1596 2 if (BB->empty()) return nullptr; if (&BB->back() != result) return nullptr; d1614 1 a1614 1 return nullptr; d1624 1 a1624 1 if (!call) return nullptr; d1652 1 a1652 1 return nullptr; d1685 1 a1685 1 if (!method) return nullptr; d1687 1 a1687 1 if (!self->getType().isConstQualified()) return nullptr; d1694 1 a1694 1 return nullptr; d1702 1 a1702 1 return nullptr; d1744 1 a1744 1 if (IP->empty()) return nullptr; d1746 2 a1747 2 if (!store) return nullptr; if (store->getPointerOperand() != CGF.ReturnValue) return nullptr; d1753 2 a1754 2 dyn_cast(CGF.ReturnValue->user_back()); if (!store) return nullptr; d1766 1 a1766 1 return nullptr; d1778 1 a1778 1 if (!ReturnValue) { d1784 1 a1784 1 llvm::Value *RV = nullptr; a1803 3 auto AI = CurFn->arg_begin(); if (RetAI.isSRetAfterThis()) ++AI; d1809 2 a1810 1 EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(AI, RetTy), d1819 1 a1819 1 MakeNaturalAlignAddrLValue(AI, RetTy), d1848 1 a1848 1 ReturnValue = nullptr; d1966 1 a1966 1 llvm::BasicBlock *contBB = nullptr; d2026 3 a2028 2 for (const auto &I : args.writebacks()) emitWriteback(CGF, I); d2048 1 a2048 1 return nullptr; d2102 3 a2104 3 llvm::BasicBlock *contBB = nullptr; llvm::BasicBlock *originBB = nullptr; d2131 1 a2131 1 llvm::Value *valueToUse = nullptr; d2261 1 a2261 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d2293 4 a2296 17 if (HasAggregateEvalKind && CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { // If we're using inalloca, use the argument memory. Otherwise, use a // temporary. AggValueSlot Slot; if (args.isUsingInAlloca()) Slot = createPlaceholderSlot(*this, type); else Slot = CreateAggTemp(type, "agg.tmp"); const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); bool DestroyedInCallee = RD && RD->hasNonTrivialDestructor() && CGM.getCXXABI().getRecordArgABI(RD) != CGCXXABI::RAA_Default; if (DestroyedInCallee) Slot.setExternallyDestructed(); d2301 2 a2302 1 if (DestroyedInCallee) { d2476 1 a2476 1 const FieldDecl *LargestFD = nullptr; d2479 3 a2481 1 for (const auto *FD : RD->fields()) { d2495 4 a2498 1 for (const auto *FD : RD->fields()) { d2558 1 a2558 1 llvm::Value *ArgMemory = nullptr; d2560 2 a2561 8 llvm::Instruction *IP = CallArgs.getStackBase(); llvm::AllocaInst *AI; if (IP) { IP = IP->getNextNode(); AI = new llvm::AllocaInst(ArgStruct, "argmem", IP); } else { AI = CreateTempAlloca(ArgStruct, "argmem"); } d2569 2 a2570 3 llvm::Value *SRetPtr = nullptr; bool SwapThisWithSRet = false; if (RetAI.isIndirect() || RetAI.isInAlloca()) { d2574 1 a2574 1 if (RetAI.isIndirect()) { a2575 3 SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) IRArgNo = 1; a2576 2 if (SwapThisWithSRet) IRArgNo = 0; a2591 4 // Skip 'sret' if it came second. if (IRArgNo == 1 && SwapThisWithSRet) ++IRArgNo; a2616 7 unsigned AS = Addr->getType()->getPointerAddressSpace(); llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS); // There are some cases where a trivial bitcast is not avoidable. The // definition of a type later in a translation unit may change it's type // from {}* to (%struct.foo*)*. if (Addr->getType() != MemType) Addr = Builder.CreateBitCast(Addr, MemType); d2721 2 a2722 5 // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. llvm::StructType *STy = dyn_cast(ArgInfo.getCoerceToType()); if (STy && !isAAPCSVFP(CallInfo, getTarget())) { a2770 3 if (SwapThisWithSRet) std::swap(Args[0], Args[1]); d2839 1 a2839 1 llvm::BasicBlock *InvokeDest = nullptr; a2854 6 if (CurCodeDecl && CurCodeDecl->hasAttr() && !CS.hasFnAttr(llvm::Attribute::NoInline)) Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::AlwaysInline); @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @a1109 2 if (TargetDecl->hasAttr()) RetAttrs.addAttribute(llvm::Attribute::NonNull); d1203 2 a1204 8 if (const auto *RefTy = RetTy->getAs()) { QualType PTy = RefTy->getPointeeType(); if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) RetAttrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy) .getQuantity()); else if (getContext().getTargetAddressSpace(PTy) == 0) RetAttrs.addAttribute(llvm::Attribute::NonNull); } d1294 2 a1295 8 if (const auto *RefTy = ParamType->getAs()) { QualType PTy = RefTy->getPointeeType(); if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) Attrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy) .getQuantity()); else if (getContext().getTargetAddressSpace(PTy) == 0) Attrs.addAttribute(llvm::Attribute::NonNull); } a1383 4 // Get the function-level nonnull attribute if it exists. const NonNullAttr *NNAtt = CurCodeDecl ? CurCodeDecl->getAttr() : nullptr; a1470 43 if (const ParmVarDecl *PVD = dyn_cast(Arg)) { if ((NNAtt && NNAtt->isNonNull(PVD->getFunctionScopeIndex())) || PVD->hasAttr()) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, 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(); uint64_t ArrSize = ArrTy->getSize().getZExtValue(); if (!ETy->isIncompleteType() && ETy->isConstantSizeType() && ArrSize) { llvm::AttrBuilder Attrs; Attrs.addDereferenceableAttr( getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, Attrs)); } else if (getContext().getTargetAddressSpace(ETy) == 0) { AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, 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 && !getContext().getTargetAddressSpace(ArrTy->getElementType())) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NonNull)); } } d1987 13 a1999 2 assert(!isInAllocaArgument(CGM.getCXXABI(), type) && "cannot emit delegate call arguments for inalloca arguments!"); d2862 3 a2864 13 if (CallInfo.isVariadic()) { // When passing non-POD arguments by value to variadic functions, we will // end up with a variadic prototype and an inalloca call site. In such // cases, we can't do any parameter mismatch checks. Give up and bitcast // the callee. unsigned CalleeAS = cast(Callee->getType())->getAddressSpace(); Callee = Builder.CreateBitCast( Callee, getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS)); } else { llvm::Type *LastParamTy = IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1); if (Arg->getType() != LastParamTy) { d2866 16 a2881 10 // Assert that these structs have equivalent element types. llvm::StructType *FullTy = CallInfo.getArgStruct(); llvm::StructType *DeclaredTy = cast( cast(LastParamTy)->getElementType()); assert(DeclaredTy->getNumElements() == FullTy->getNumElements()); for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(), DE = DeclaredTy->element_end(), FI = FullTy->element_begin(); DI != DE; ++DI, ++FI) assert(*DI == *FI); d2883 1 a2883 2 Arg = Builder.CreateBitCast(Arg, LastParamTy); } @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d50 1 a50 4 // 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; d83 2 a84 3 /*instanceMethod=*/false, /*chainCall=*/false, None, FTNP->getExtInfo(), RequiredArgs(0)); d88 7 a94 5 /// type, on top of any implicit parameters already stored. static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl &prefix, CanQual FTP) { d100 19 a118 3 return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod, /*chainCall=*/false, prefix, FTP->getExtInfo(), required); d126 1 a126 2 return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes, FTP); a139 3 if (D->hasAttr()) return CC_X86VectorCall; d161 17 d195 2 a196 3 return ::arrangeLLVMFunctionInfo( *this, true, argTypes, FTP->getCanonicalTypeUnqualified().getAs()); d219 2 d222 2 a223 3 CodeGenTypes::arrangeCXXStructorDeclaration(const CXXMethodDecl *MD, StructorType Type) { d225 1 a225 1 argTypes.push_back(GetThisType(Context, MD->getParent())); d227 3 a229 7 GlobalDecl GD; if (auto *CD = dyn_cast(MD)) { GD = GlobalDecl(CD, toCXXCtorType(Type)); } else { auto *DD = dyn_cast(MD); GD = GlobalDecl(DD, toCXXDtorType(Type)); } d231 1 a231 1 CanQual FTP = GetFormalType(MD); d237 1 a237 1 TheCXXABI.buildStructorSignature(MD, Type, argTypes); d240 1 a240 1 (MD->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); d243 1 a243 8 CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : TheCXXABI.hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : Context.VoidTy; return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true, /*chainCall=*/false, argTypes, extInfo, required); d254 3 a256 2 for (const auto &Arg : args) ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); d261 2 a262 5 CanQualType ResultType = TheCXXABI.HasThisReturn(GD) ? ArgTypes.front() : TheCXXABI.hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : Context.VoidTy; d265 25 a289 3 return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true, /*chainCall=*/false, ArgTypes, Info, Required); d308 2 a309 3 return arrangeLLVMFunctionInfo( noProto->getReturnType(), /*instanceMethod=*/false, /*chainCall=*/false, None, noProto->getExtInfo(), RequiredArgs::All); d353 2 a354 3 return arrangeLLVMFunctionInfo( GetReturnType(MD->getReturnType()), /*instanceMethod=*/false, /*chainCall=*/false, argTys, einfo, required); d363 1 a363 1 return arrangeCXXStructorDeclaration(CD, getFromCtorType(GD.getCtorType())); d366 1 a366 1 return arrangeCXXStructorDeclaration(DD, getFromDtorType(GD.getDtorType())); a370 15 /// 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::arrangeMSMemberPointerThunk(const CXXMethodDecl *MD) { assert(MD->isVirtual() && "only virtual memptrs have thunks"); CanQual FTP = GetFormalType(MD); CanQualType ArgTys[] = { GetThisType(Context, MD->getParent()) }; return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false, /*chainCall=*/false, ArgTys, FTP->getExtInfo(), RequiredArgs(1)); } d378 1 a378 2 unsigned numExtraRequiredArgs, bool chainCall) { d400 2 a401 7 // FIXME: Kill copy. SmallVector 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(), required); d410 2 a411 4 const FunctionType *fnType, bool chainCall) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, chainCall ? 1 : 0, chainCall); d419 1 a419 2 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1, /*chainCall=*/false); d429 5 a433 5 for (const auto &Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); return arrangeLLVMFunctionInfo( GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false, argTypes, info, required); d443 3 a445 2 for (const auto &Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); d448 2 a449 3 return arrangeLLVMFunctionInfo( GetReturnType(FPT->getReturnType()), /*instanceMethod=*/true, /*chainCall=*/false, argTypes, info, required); d457 3 a459 2 for (auto Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg->getType())); d463 2 a464 3 return arrangeLLVMFunctionInfo( GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false, argTypes, info, required); d468 2 a469 3 return arrangeLLVMFunctionInfo( getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false, None, FunctionType::ExtInfo(), RequiredArgs::All); d477 1 a477 2 bool instanceMethod, bool chainCall, d481 5 a485 2 assert(std::all_of(argTypes.begin(), argTypes.end(), std::mem_fun_ref(&CanQualType::isCanonicalAsParam))); d491 2 a492 2 CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, required, resultType, argTypes); d500 2 a501 2 FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info, resultType, argTypes, required); d504 1 a504 2 bool inserted = FunctionsBeingProcessed.insert(FI).second; (void)inserted; d528 1 a528 2 bool instanceMethod, bool chainCall, d539 1 a539 2 FI->InstanceMethod = instanceMethod; FI->ChainCall = chainCall; d555 7 a561 73 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 Bases; SmallVector Fields; RecordExpansion(SmallVector &&Bases, SmallVector &&Fields) : TypeExpansion(TEK_Record), Bases(Bases), Fields(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 getTypeExpansion(QualType Ty, const ASTContext &Context) { if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) { return llvm::make_unique( AT->getElementType(), AT->getSize().getZExtValue()); } if (const RecordType *RT = Ty->getAs()) { SmallVector Bases; SmallVector Fields; a571 3 // Skip zero length bitfields. if (FD->isBitField() && FD->getBitWidthValue(Context) == 0) continue; d574 1 a574 1 CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType()); d581 1 a581 1 Fields.push_back(LargestFD); d583 2 a584 12 if (const auto *CXXRD = dyn_cast(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()) { // Skip zero length bitfields. if (FD->isBitField() && FD->getBitWidthValue(Context) == 0) continue; assert(!FD->isBitField() && d586 1 a586 1 Fields.push_back(FD); d589 6 a594 7 return llvm::make_unique(std::move(Bases), std::move(Fields)); } if (const ComplexType *CT = Ty->getAs()) { return llvm::make_unique(CT->getElementType()); } return llvm::make_unique(); d597 5 a601 18 static int getExpansionSize(QualType Ty, const ASTContext &Context) { auto Exp = getTypeExpansion(Ty, Context); if (auto CAExp = dyn_cast(Exp.get())) { return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context); } if (auto RExp = dyn_cast(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(Exp.get())) return 2; assert(isa(Exp.get())); return 1; } d603 15 a617 22 void CodeGenTypes::getExpandedTypes(QualType Ty, SmallVectorImpl::iterator &TI) { auto Exp = getTypeExpansion(Ty, Context); if (auto CAExp = dyn_cast(Exp.get())) { for (int i = 0, n = CAExp->NumElts; i < n; i++) { getExpandedTypes(CAExp->EltTy, TI); } } else if (auto RExp = dyn_cast(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(Exp.get())) { llvm::Type *EltTy = ConvertType(CExp->EltTy); *TI++ = EltTy; *TI++ = EltTy; } else { assert(isa(Exp.get())); *TI++ = ConvertType(Ty); } } d619 17 a635 4 void CodeGenFunction::ExpandTypeFromArgs( QualType Ty, LValue LV, SmallVectorImpl::iterator &AI) { assert(LV.isSimple() && "Unexpected non-simple lvalue during struct expansion."); d637 4 a640 23 auto Exp = getTypeExpansion(Ty, getContext()); if (auto CAExp = dyn_cast(Exp.get())) { for (int i = 0, n = CAExp->NumElts; i < n; i++) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, i); LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy); ExpandTypeFromArgs(CAExp->EltTy, LV, AI); } } else if (auto RExp = dyn_cast(Exp.get())) { llvm::Value *This = LV.getAddress(); for (const CXXBaseSpecifier *BS : RExp->Bases) { // Perform a single step derived-to-base conversion. llvm::Value *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 = EmitLValueForField(LV, FD); ExpandTypeFromArgs(FD->getType(), SubLV, AI); d642 2 a643 1 } else if (auto CExp = dyn_cast(Exp.get())) { d645 1 a645 2 EmitStoreThroughLValue(RValue::get(*AI++), MakeAddrLValue(RealAddr, CExp->EltTy)); d647 1 a647 2 EmitStoreThroughLValue(RValue::get(*AI++), MakeAddrLValue(ImagAddr, CExp->EltTy)); d649 2 a650 2 assert(isa(Exp.get())); EmitStoreThroughLValue(RValue::get(*AI++), LV); a651 1 } d653 1 a653 49 void CodeGenFunction::ExpandTypeToArgs( QualType Ty, RValue RV, llvm::FunctionType *IRFuncTy, SmallVectorImpl &IRCallArgs, unsigned &IRCallArgPos) { auto Exp = getTypeExpansion(Ty, getContext()); if (auto CAExp = dyn_cast(Exp.get())) { llvm::Value *Addr = RV.getAggregateAddr(); for (int i = 0, n = CAExp->NumElts; i < n; i++) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, i); RValue EltRV = convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation()); ExpandTypeToArgs(CAExp->EltTy, EltRV, IRFuncTy, IRCallArgs, IRCallArgPos); } } else if (auto RExp = dyn_cast(Exp.get())) { llvm::Value *This = RV.getAggregateAddr(); for (const CXXBaseSpecifier *BS : RExp->Bases) { // Perform a single step derived-to-base conversion. llvm::Value *Base = GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1, /*NullCheckValue=*/false, SourceLocation()); RValue BaseRV = RValue::getAggregate(Base); // Recurse onto bases. ExpandTypeToArgs(BS->getType(), BaseRV, IRFuncTy, IRCallArgs, IRCallArgPos); } LValue LV = MakeAddrLValue(This, Ty); for (auto FD : RExp->Fields) { RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); ExpandTypeToArgs(FD->getType(), FldRV, IRFuncTy, IRCallArgs, IRCallArgPos); } } else if (isa(Exp.get())) { ComplexPairTy CV = RV.getComplexVal(); IRCallArgs[IRCallArgPos++] = CV.first; IRCallArgs[IRCallArgPos++] = CV.second; } else { assert(isa(Exp.get())); 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; } d670 1 a670 3 // 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. d672 1 a672 1 CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt); d674 1 a674 1 FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy)) a892 139 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 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 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(AI.getCoerceToType()); if (AI.isDirect() && AI.getCanBeFlattened() && STy) { IRArgs.NumberOfArgs = STy->getNumElements(); } else { IRArgs.NumberOfArgs = 1; } break; } case ABIArgInfo::Indirect: 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::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 d939 2 a940 3 bool Inserted = FunctionsBeingProcessed.insert(&FI).second; (void)Inserted; d942 4 a946 1 llvm::Type *resultType = nullptr; d972 7 d987 6 a992 17 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true); SmallVector 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(); d994 2 a995 7 // 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; d998 2 a999 3 if (IRFunctionArgs.hasPaddingArg(ArgNo)) ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] = ArgInfo.getPaddingType(); d1001 1 a1001 4 unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); switch (ArgInfo.getKind()) { a1003 1 assert(NumIRArgs == 0); a1006 1 assert(NumIRArgs == 1); d1009 1 a1009 1 ArgTypes[FirstIRArg] = LTy->getPointerTo(); d1015 6 a1020 3 // 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(); d1022 1 a1022 2 if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) { assert(NumIRArgs == st->getNumElements()); d1024 1 a1024 1 ArgTypes[FirstIRArg + i] = st->getElementType(i); d1026 1 a1026 2 assert(NumIRArgs == 1); ArgTypes[FirstIRArg] = argType; d1032 1 a1032 3 auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; getExpandedTypes(it->type, ArgTypesIter); assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); d1037 7 d1046 2 a1047 2 return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic()); d1059 1 a1059 2 Info = &arrangeCXXStructorDeclaration(MD, getFromDtorType(GD.getDtorType())); a1071 1 bool HasOptnone = false; a1111 10 HasOptnone = TargetDecl->hasAttr(); } // 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); d1114 4 a1158 2 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI); d1160 2 d1177 7 a1183 1 case ABIArgInfo::InAlloca: d1185 11 a1195 1 // inalloca and sret disable readnone and readonly d1214 5 a1218 15 // Attach return attributes. if (RetAttrs.hasAttributes()) { PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs)); } // Attach attributes to sret. if (IRFunctionArgs.hasSRetArg()) { llvm::AttrBuilder SRETAttrs; SRETAttrs.addAttribute(llvm::Attribute::StructRet); if (RetAI.getInReg()) SRETAttrs.addAttribute(llvm::Attribute::InReg); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getSRetArgNo() + 1, SRETAttrs)); } d1220 3 a1222 2 // Attach attributes to inalloca argument. if (IRFunctionArgs.hasInallocaArg()) { a1223 4 Attrs.addAttribute(llvm::Attribute::InAlloca); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getInallocaArgNo() + 1, Attrs)); } d1225 4 a1228 7 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; d1230 1 a1230 2 // Add attribute for padding argument, if necessary. if (IRFunctionArgs.hasPaddingArg(ArgNo)) { d1232 4 a1235 3 PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getPaddingArgNo(ArgNo) + 1, llvm::Attribute::InReg)); d1248 2 a1249 4 case ABIArgInfo::Direct: if (ArgNo == 0 && FI.isChainCall()) Attrs.addAttribute(llvm::Attribute::Nest); else if (AI.getInReg()) d1251 13 d1265 1 a1265 1 d1281 1 a1281 1 case ABIArgInfo::Expand: d1288 10 d1300 1 d1311 10 a1320 7 if (Attrs.hasAttributes()) { unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); for (unsigned i = 0; i < NumIRArgs; i++) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), FirstIRArg + i + 1, Attrs)); } a1321 1 assert(ArgNo == FI.arg_size()); a1349 28 /// 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()) return ParmNNAttr; } // Check function attributes. if (!FD) return nullptr; for (const auto *NNAttr : FD->specific_attrs()) { if (NNAttr->isNonNull(ArgNo)) return NNAttr; } return nullptr; } a1352 4 if (CurCodeDecl && CurCodeDecl->hasAttr()) // Naked functions don't have prologues. return; d1369 2 a1370 8 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI); // Flattened function arguments. SmallVector FnArgs; FnArgs.reserve(IRFunctionArgs.totalIRArgs()); for (auto &Arg : Fn->args()) { FnArgs.push_back(&Arg); } assert(FnArgs.size() == IRFunctionArgs.totalIRArgs()); d1375 4 a1378 2 if (IRFunctionArgs.hasInallocaArg()) { ArgStruct = FnArgs[IRFunctionArgs.getInallocaArgNo()]; d1382 7 a1388 3 // Name the struct return parameter. if (IRFunctionArgs.hasSRetArg()) { auto AI = FnArgs[IRFunctionArgs.getSRetArgNo()]; d1392 4 d1398 4 d1416 1 a1416 1 unsigned ArgNo = 0; d1418 1 a1418 1 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); d1427 3 a1429 2 unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); a1432 1 assert(NumIRArgs == 0); d1436 1 a1436 1 break; d1440 1 a1440 2 assert(NumIRArgs == 1); llvm::Value *V = FnArgs[FirstIRArg]; d1486 1 a1486 2 assert(NumIRArgs == 1); auto AI = FnArgs[FirstIRArg]; d1490 2 a1491 2 if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(), PVD->getFunctionScopeIndex())) a1529 19 const auto *AVAttr = PVD->getAttr(); if (!AVAttr) if (const auto *TOTy = dyn_cast(OTy)) AVAttr = TOTy->getDecl()->getAttr(); if (AVAttr) { llvm::Value *AlignmentValue = EmitScalarExpr(AVAttr->getAlignment()); llvm::ConstantInt *AlignmentCI = cast(AlignmentValue); unsigned Alignment = std::min((unsigned) AlignmentCI->getZExtValue(), +llvm::Value::MaximumAlignment); llvm::AttrBuilder Attrs; Attrs.addAlignmentAttr(Alignment); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, Attrs)); } d1584 5 a1588 2 // 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. d1590 1 a1590 2 if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy && STy->getNumElements() > 1) { a1598 1 assert(STy->getNumElements() == NumIRArgs); d1600 1 a1600 1 auto AI = FnArgs[FirstIRArg + i]; d1603 1 a1603 1 Builder.CreateStore(AI, EltPtr); a1610 1 assert(STy->getNumElements() == NumIRArgs); d1612 1 a1612 1 auto AI = FnArgs[FirstIRArg + i]; d1615 1 a1615 1 Builder.CreateStore(AI, EltPtr); d1622 1 a1622 2 assert(NumIRArgs == 1); auto AI = FnArgs[FirstIRArg]; d1624 1 a1624 1 CreateCoercedStore(AI, Ptr, /*DestIsVolatile=*/false, *this); d1637 1 a1637 1 break; d1648 1 d1651 5 a1655 8 auto FnArgIter = FnArgs.begin() + FirstIRArg; ExpandTypeFromArgs(Ty, LV, FnArgIter); assert(FnArgIter == FnArgs.begin() + FirstIRArg + NumIRArgs); for (unsigned i = 0, e = NumIRArgs; i != e; ++i) { auto AI = FnArgs[FirstIRArg + i]; AI->setName(Arg->getName() + "." + Twine(i)); } break; a1658 1 assert(NumIRArgs == 0); d1666 3 a1668 1 break; d1670 5 d1677 4 a1889 6 if (CurCodeDecl && CurCodeDecl->hasAttr()) { // Naked functions don't have epilogues. Builder.CreateUnreachable(); return; } d2001 1 a2001 20 llvm::Instruction *Ret; if (RV) { if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) { if (auto RetNNAttr = CurGD.getDecl()->getAttr()) { SanitizerScope SanScope(this); llvm::Value *Cond = Builder.CreateICmpNE( RV, llvm::Constant::getNullValue(RV->getType())); llvm::Constant *StaticData[] = { EmitCheckSourceLocation(EndLoc), EmitCheckSourceLocation(RetNNAttr->getLocation()), }; EmitCheck(std::make_pair(Cond, SanitizerKind::ReturnsNonnullAttribute), "nonnull_return", StaticData, None); } } Ret = Builder.CreateRet(RV); } else { Ret = Builder.CreateRetVoid(); } a2308 24 static void emitNonNullArgCheck(CodeGenFunction &CGF, RValue RV, QualType ArgType, SourceLocation ArgLoc, const FunctionDecl *FD, unsigned ParmNum) { if (!CGF.SanOpts.has(SanitizerKind::NonnullAttribute) || !FD) return; auto PVD = ParmNum < FD->getNumParams() ? FD->getParamDecl(ParmNum) : nullptr; unsigned ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum; auto NNAttr = getNonNullAttr(FD, PVD, ArgType, ArgNo); if (!NNAttr) return; CodeGenFunction::SanitizerScope SanScope(&CGF); assert(RV.isScalar()); llvm::Value *V = RV.getScalarVal(); llvm::Value *Cond = CGF.Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType())); llvm::Constant *StaticData[] = { CGF.EmitCheckSourceLocation(ArgLoc), CGF.EmitCheckSourceLocation(NNAttr->getLocation()), llvm::ConstantInt::get(CGF.Int32Ty, ArgNo + 1), }; CGF.EmitCheck(std::make_pair(Cond, SanitizerKind::NonnullAttribute), "nonnull_arg", StaticData, None); } a2312 2 const FunctionDecl *CalleeDecl, unsigned ParamsToSkip, a2335 2 emitNonNullArgCheck(*this, Args.back().RV, ArgTypes[I], Arg->getExprLoc(), CalleeDecl, ParamsToSkip + I); a2349 2 emitNonNullArgCheck(*this, Args.back().RV, ArgTypes[I], Arg->getExprLoc(), CalleeDecl, ParamsToSkip + I); a2448 18 QualType CodeGenFunction::getVarArgType(const Expr *Arg) { // System headers on Windows define NULL to 0 instead of 0LL on Win64. MSVC // implicitly widens null pointer constants that are arguments to varargs // functions to pointer-sized ints. if (!getTarget().getTriple().isOSWindows()) return Arg->getType(); if (Arg->getType()->isIntegerType() && getContext().getTypeSize(Arg->getType()) < getContext().getTargetInfo().getPointerWidth(0) && Arg->isNullPointerConstant(getContext(), Expr::NPC_ValueDependentIsNotNull)) { return getContext().getIntPtrType(); } return Arg->getType(); } d2463 1 a2463 1 return EmitNounwindRuntimeCall(callee, None, name); d2481 1 a2481 1 return EmitRuntimeCall(callee, None, name); d2520 1 a2520 1 return EmitRuntimeCallOrInvoke(callee, None, name); d2536 1 a2536 1 return EmitCallOrInvoke(Callee, None, Name); d2564 67 d2653 1 d2660 2 a2682 3 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); SmallVector IRCallArgs(IRFunctionArgs.totalIRArgs()); d2686 1 d2691 8 a2698 2 if (IRFunctionArgs.hasSRetArg()) { IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr; a2707 1 unsigned ArgNo = 0; d2710 1 a2710 1 I != E; ++I, ++info_it, ++ArgNo) { d2714 4 d2721 4 a2724 6 if (IRFunctionArgs.hasPaddingArg(ArgNo)) IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] = llvm::UndefValue::get(ArgInfo.getPaddingType()); unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); a2727 1 assert(NumIRArgs == 0); d2753 1 a2753 1 break; a2756 1 assert(NumIRArgs == 1); d2762 1 a2762 1 IRCallArgs[FirstIRArg] = AI; d2764 1 a2764 1 LValue argLV = MakeAddrLValue(AI, I->Ty, TypeAlign); d2766 3 d2782 2 a2783 4 const unsigned ArgAddrSpace = (FirstIRArg < IRFuncTy->getNumParams() ? IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() : 0); d2792 1 a2792 1 IRCallArgs[FirstIRArg] = AI; d2794 3 d2799 4 a2802 1 IRCallArgs[FirstIRArg] = Addr; a2808 1 assert(NumIRArgs == 0); a2815 1 assert(NumIRArgs == 1); d2821 1 a2821 6 // We might have to widen integers, but we should never truncate. if (ArgInfo.getCoerceToType() != V->getType() && V->getType()->isIntegerTy()) V = Builder.CreateZExt(V, ArgInfo.getCoerceToType()); d2824 6 a2829 4 if (FirstIRArg < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(FirstIRArg)) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg)); IRCallArgs[FirstIRArg] = V; d2851 5 a2855 2 // 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. d2858 1 a2858 1 if (STy && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) { a2877 1 assert(NumIRArgs == STy->getNumElements()); d2883 4 a2886 1 IRCallArgs[FirstIRArg + i] = LI; d2890 5 a2894 3 assert(NumIRArgs == 1); IRCallArgs[FirstIRArg] = CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), *this); d2901 2 a2902 3 unsigned IRArgPos = FirstIRArg; ExpandTypeToArgs(I->Ty, RV, IRFuncTy, IRCallArgs, IRArgPos); assert(IRArgPos == FirstIRArg + NumIRArgs); d2907 3 d2940 1 a2940 2 assert(IRFunctionArgs.hasInallocaArg()); IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg; d2959 1 a2959 1 ActualFT->getNumParams() == IRCallArgs.size() && a2975 10 assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg()); for (unsigned i = 0; i < IRCallArgs.size(); ++i) { // Inalloca argument can have different type. if (IRFunctionArgs.hasInallocaArg() && i == IRFunctionArgs.getInallocaArgNo()) continue; if (i < IRFuncTy->getNumParams()) assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i)); } d2990 1 a2990 1 CS = Builder.CreateCall(Callee, IRCallArgs); d2993 1 a2993 1 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, IRCallArgs); d3042 4 a3045 5 RValue Ret = [&] { switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: case ABIArgInfo::Indirect: return convertTempToRValue(SRetPtr, RetTy, SourceLocation()); d3047 4 a3050 4 case ABIArgInfo::Ignore: // If we are ignoring an argument that had a result, make sure to // construct the appropriate return value for our caller. return GetUndefRValue(RetTy); d3052 17 a3068 9 case ABIArgInfo::Extend: case ABIArgInfo::Direct: { llvm::Type *RetIRTy = ConvertType(RetTy); if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { llvm::Value *Real = Builder.CreateExtractValue(CI, 0); llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); return RValue::getComplex(std::make_pair(Real, Imag)); d3070 10 a3079 21 case TEK_Aggregate: { llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "agg.tmp"); DestIsVolatile = false; } BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); return RValue::getAggregate(DestPtr); } case TEK_Scalar: { // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. llvm::Value *V = CI; if (V->getType() != RetIRTy) V = Builder.CreateBitCast(V, RetIRTy); return RValue::get(V); } } llvm_unreachable("bad evaluation kind"); a3080 7 llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "coerce"); DestIsVolatile = false; d3082 2 d3085 2 a3086 9 // If the value is offset in memory, apply the offset now. llvm::Value *StorePtr = DestPtr; if (unsigned Offs = RetAI.getDirectOffset()) { StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); StorePtr = Builder.CreateBitCast(StorePtr, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); d3088 3 a3090 1 return convertTempToRValue(DestPtr, RetTy, SourceLocation()); d3093 7 a3099 2 case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); d3101 1 d3103 2 a3104 2 llvm_unreachable("Unhandled ABIArgInfo::Kind"); } (); d3106 2 a3107 11 if (Ret.isScalar() && TargetDecl) { if (const auto *AA = TargetDecl->getAttr()) { llvm::Value *OffsetValue = nullptr; if (const auto *Offset = AA->getOffset()) OffsetValue = EmitScalarExpr(Offset); llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment()); llvm::ConstantInt *AlignmentCI = cast(Alignment); EmitAlignmentAssumption(Ret.getScalarVal(), AlignmentCI->getZExtValue(), OffsetValue); } d3110 1 a3110 1 return Ret; @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d50 1 a50 4 // 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; d83 2 a84 3 /*instanceMethod=*/false, /*chainCall=*/false, None, FTNP->getExtInfo(), RequiredArgs(0)); d88 7 a94 5 /// type, on top of any implicit parameters already stored. static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl &prefix, CanQual FTP) { d100 19 a118 3 return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod, /*chainCall=*/false, prefix, FTP->getExtInfo(), required); d126 1 a126 2 return ::arrangeLLVMFunctionInfo(*this, /*instanceMethod=*/false, argTypes, FTP); a139 3 if (D->hasAttr()) return CC_X86VectorCall; d161 17 d195 2 a196 3 return ::arrangeLLVMFunctionInfo( *this, true, argTypes, FTP->getCanonicalTypeUnqualified().getAs()); d219 2 d222 2 a223 3 CodeGenTypes::arrangeCXXStructorDeclaration(const CXXMethodDecl *MD, StructorType Type) { d225 1 a225 1 argTypes.push_back(GetThisType(Context, MD->getParent())); d227 3 a229 7 GlobalDecl GD; if (auto *CD = dyn_cast(MD)) { GD = GlobalDecl(CD, toCXXCtorType(Type)); } else { auto *DD = dyn_cast(MD); GD = GlobalDecl(DD, toCXXDtorType(Type)); } d231 1 a231 1 CanQual FTP = GetFormalType(MD); d237 1 a237 1 TheCXXABI.buildStructorSignature(MD, Type, argTypes); d240 1 a240 1 (MD->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); d243 1 a243 8 CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : TheCXXABI.hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : Context.VoidTy; return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true, /*chainCall=*/false, argTypes, extInfo, required); d254 3 a256 2 for (const auto &Arg : args) ArgTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); d261 2 a262 5 CanQualType ResultType = TheCXXABI.HasThisReturn(GD) ? ArgTypes.front() : TheCXXABI.hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : Context.VoidTy; d265 25 a289 3 return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true, /*chainCall=*/false, ArgTypes, Info, Required); d308 2 a309 3 return arrangeLLVMFunctionInfo( noProto->getReturnType(), /*instanceMethod=*/false, /*chainCall=*/false, None, noProto->getExtInfo(), RequiredArgs::All); d353 2 a354 3 return arrangeLLVMFunctionInfo( GetReturnType(MD->getReturnType()), /*instanceMethod=*/false, /*chainCall=*/false, argTys, einfo, required); d363 1 a363 1 return arrangeCXXStructorDeclaration(CD, getFromCtorType(GD.getCtorType())); d366 1 a366 1 return arrangeCXXStructorDeclaration(DD, getFromDtorType(GD.getDtorType())); a370 15 /// 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::arrangeMSMemberPointerThunk(const CXXMethodDecl *MD) { assert(MD->isVirtual() && "only virtual memptrs have thunks"); CanQual FTP = GetFormalType(MD); CanQualType ArgTys[] = { GetThisType(Context, MD->getParent()) }; return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false, /*chainCall=*/false, ArgTys, FTP->getExtInfo(), RequiredArgs(1)); } d378 1 a378 2 unsigned numExtraRequiredArgs, bool chainCall) { d400 2 a401 7 // FIXME: Kill copy. SmallVector 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(), required); d410 2 a411 4 const FunctionType *fnType, bool chainCall) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, chainCall ? 1 : 0, chainCall); d419 1 a419 2 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1, /*chainCall=*/false); d429 5 a433 5 for (const auto &Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); return arrangeLLVMFunctionInfo( GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false, argTypes, info, required); d443 3 a445 2 for (const auto &Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg.Ty)); d448 2 a449 3 return arrangeLLVMFunctionInfo( GetReturnType(FPT->getReturnType()), /*instanceMethod=*/true, /*chainCall=*/false, argTypes, info, required); d457 3 a459 2 for (auto Arg : args) argTypes.push_back(Context.getCanonicalParamType(Arg->getType())); d463 2 a464 3 return arrangeLLVMFunctionInfo( GetReturnType(resultType), /*instanceMethod=*/false, /*chainCall=*/false, argTypes, info, required); d468 2 a469 3 return arrangeLLVMFunctionInfo( getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false, None, FunctionType::ExtInfo(), RequiredArgs::All); d477 1 a477 2 bool instanceMethod, bool chainCall, d481 5 a485 2 assert(std::all_of(argTypes.begin(), argTypes.end(), std::mem_fun_ref(&CanQualType::isCanonicalAsParam))); d491 2 a492 2 CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, required, resultType, argTypes); d500 2 a501 2 FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info, resultType, argTypes, required); d504 1 a504 2 bool inserted = FunctionsBeingProcessed.insert(FI).second; (void)inserted; d528 1 a528 2 bool instanceMethod, bool chainCall, d539 1 a539 2 FI->InstanceMethod = instanceMethod; FI->ChainCall = chainCall; d555 7 a561 73 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 Bases; SmallVector Fields; RecordExpansion(SmallVector &&Bases, SmallVector &&Fields) : TypeExpansion(TEK_Record), Bases(Bases), Fields(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 getTypeExpansion(QualType Ty, const ASTContext &Context) { if (const ConstantArrayType *AT = Context.getAsConstantArrayType(Ty)) { return llvm::make_unique( AT->getElementType(), AT->getSize().getZExtValue()); } if (const RecordType *RT = Ty->getAs()) { SmallVector Bases; SmallVector Fields; a571 3 // Skip zero length bitfields. if (FD->isBitField() && FD->getBitWidthValue(Context) == 0) continue; d574 1 a574 1 CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType()); d581 1 a581 1 Fields.push_back(LargestFD); d583 2 a584 12 if (const auto *CXXRD = dyn_cast(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()) { // Skip zero length bitfields. if (FD->isBitField() && FD->getBitWidthValue(Context) == 0) continue; assert(!FD->isBitField() && d586 1 a586 1 Fields.push_back(FD); d589 6 a594 7 return llvm::make_unique(std::move(Bases), std::move(Fields)); } if (const ComplexType *CT = Ty->getAs()) { return llvm::make_unique(CT->getElementType()); } return llvm::make_unique(); d597 5 a601 18 static int getExpansionSize(QualType Ty, const ASTContext &Context) { auto Exp = getTypeExpansion(Ty, Context); if (auto CAExp = dyn_cast(Exp.get())) { return CAExp->NumElts * getExpansionSize(CAExp->EltTy, Context); } if (auto RExp = dyn_cast(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(Exp.get())) return 2; assert(isa(Exp.get())); return 1; } d603 15 a617 22 void CodeGenTypes::getExpandedTypes(QualType Ty, SmallVectorImpl::iterator &TI) { auto Exp = getTypeExpansion(Ty, Context); if (auto CAExp = dyn_cast(Exp.get())) { for (int i = 0, n = CAExp->NumElts; i < n; i++) { getExpandedTypes(CAExp->EltTy, TI); } } else if (auto RExp = dyn_cast(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(Exp.get())) { llvm::Type *EltTy = ConvertType(CExp->EltTy); *TI++ = EltTy; *TI++ = EltTy; } else { assert(isa(Exp.get())); *TI++ = ConvertType(Ty); } } d619 17 a635 4 void CodeGenFunction::ExpandTypeFromArgs( QualType Ty, LValue LV, SmallVectorImpl::iterator &AI) { assert(LV.isSimple() && "Unexpected non-simple lvalue during struct expansion."); d637 4 a640 23 auto Exp = getTypeExpansion(Ty, getContext()); if (auto CAExp = dyn_cast(Exp.get())) { for (int i = 0, n = CAExp->NumElts; i < n; i++) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, i); LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy); ExpandTypeFromArgs(CAExp->EltTy, LV, AI); } } else if (auto RExp = dyn_cast(Exp.get())) { llvm::Value *This = LV.getAddress(); for (const CXXBaseSpecifier *BS : RExp->Bases) { // Perform a single step derived-to-base conversion. llvm::Value *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 = EmitLValueForField(LV, FD); ExpandTypeFromArgs(FD->getType(), SubLV, AI); d642 2 a643 1 } else if (auto CExp = dyn_cast(Exp.get())) { d645 1 a645 2 EmitStoreThroughLValue(RValue::get(*AI++), MakeAddrLValue(RealAddr, CExp->EltTy)); d647 1 a647 2 EmitStoreThroughLValue(RValue::get(*AI++), MakeAddrLValue(ImagAddr, CExp->EltTy)); d649 2 a650 2 assert(isa(Exp.get())); EmitStoreThroughLValue(RValue::get(*AI++), LV); a651 1 } d653 1 a653 49 void CodeGenFunction::ExpandTypeToArgs( QualType Ty, RValue RV, llvm::FunctionType *IRFuncTy, SmallVectorImpl &IRCallArgs, unsigned &IRCallArgPos) { auto Exp = getTypeExpansion(Ty, getContext()); if (auto CAExp = dyn_cast(Exp.get())) { llvm::Value *Addr = RV.getAggregateAddr(); for (int i = 0, n = CAExp->NumElts; i < n; i++) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, i); RValue EltRV = convertTempToRValue(EltAddr, CAExp->EltTy, SourceLocation()); ExpandTypeToArgs(CAExp->EltTy, EltRV, IRFuncTy, IRCallArgs, IRCallArgPos); } } else if (auto RExp = dyn_cast(Exp.get())) { llvm::Value *This = RV.getAggregateAddr(); for (const CXXBaseSpecifier *BS : RExp->Bases) { // Perform a single step derived-to-base conversion. llvm::Value *Base = GetAddressOfBaseClass(This, Ty->getAsCXXRecordDecl(), &BS, &BS + 1, /*NullCheckValue=*/false, SourceLocation()); RValue BaseRV = RValue::getAggregate(Base); // Recurse onto bases. ExpandTypeToArgs(BS->getType(), BaseRV, IRFuncTy, IRCallArgs, IRCallArgPos); } LValue LV = MakeAddrLValue(This, Ty); for (auto FD : RExp->Fields) { RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); ExpandTypeToArgs(FD->getType(), FldRV, IRFuncTy, IRCallArgs, IRCallArgPos); } } else if (isa(Exp.get())) { ComplexPairTy CV = RV.getComplexVal(); IRCallArgs[IRCallArgPos++] = CV.first; IRCallArgs[IRCallArgPos++] = CV.second; } else { assert(isa(Exp.get())); 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; } d670 1 a670 3 // 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. d672 1 a672 1 CGF.CGM.getDataLayout().getTypeStoreSize(FirstElt); d674 1 a674 1 FirstEltSize < CGF.CGM.getDataLayout().getTypeStoreSize(SrcSTy)) a892 139 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 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 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(AI.getCoerceToType()); if (AI.isDirect() && AI.getCanBeFlattened() && STy) { IRArgs.NumberOfArgs = STy->getNumElements(); } else { IRArgs.NumberOfArgs = 1; } break; } case ABIArgInfo::Indirect: 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::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 d939 2 a940 3 bool Inserted = FunctionsBeingProcessed.insert(&FI).second; (void)Inserted; d942 4 a946 1 llvm::Type *resultType = nullptr; d972 7 d987 6 a992 17 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI, true); SmallVector 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(); d994 2 a995 7 // 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; d998 2 a999 3 if (IRFunctionArgs.hasPaddingArg(ArgNo)) ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] = ArgInfo.getPaddingType(); d1001 1 a1001 4 unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); switch (ArgInfo.getKind()) { a1003 1 assert(NumIRArgs == 0); a1006 1 assert(NumIRArgs == 1); d1009 1 a1009 1 ArgTypes[FirstIRArg] = LTy->getPointerTo(); d1015 6 a1020 3 // 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(); d1022 1 a1022 2 if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) { assert(NumIRArgs == st->getNumElements()); d1024 1 a1024 1 ArgTypes[FirstIRArg + i] = st->getElementType(i); d1026 1 a1026 2 assert(NumIRArgs == 1); ArgTypes[FirstIRArg] = argType; d1032 1 a1032 3 auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; getExpandedTypes(it->type, ArgTypesIter); assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); d1037 7 d1046 2 a1047 2 return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic()); d1059 1 a1059 2 Info = &arrangeCXXStructorDeclaration(MD, getFromDtorType(GD.getDtorType())); a1071 1 bool HasOptnone = false; a1111 10 HasOptnone = TargetDecl->hasAttr(); } // 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); d1114 4 a1158 2 ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI); d1160 2 d1177 7 a1183 1 case ABIArgInfo::InAlloca: d1185 11 a1195 1 // inalloca and sret disable readnone and readonly d1214 5 a1218 15 // Attach return attributes. if (RetAttrs.hasAttributes()) { PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs)); } // Attach attributes to sret. if (IRFunctionArgs.hasSRetArg()) { llvm::AttrBuilder SRETAttrs; SRETAttrs.addAttribute(llvm::Attribute::StructRet); if (RetAI.getInReg()) SRETAttrs.addAttribute(llvm::Attribute::InReg); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getSRetArgNo() + 1, SRETAttrs)); } d1220 3 a1222 2 // Attach attributes to inalloca argument. if (IRFunctionArgs.hasInallocaArg()) { a1223 4 Attrs.addAttribute(llvm::Attribute::InAlloca); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getInallocaArgNo() + 1, Attrs)); } d1225 4 a1228 7 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; d1230 1 a1230 2 // Add attribute for padding argument, if necessary. if (IRFunctionArgs.hasPaddingArg(ArgNo)) { d1232 4 a1235 3 PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), IRFunctionArgs.getPaddingArgNo(ArgNo) + 1, llvm::Attribute::InReg)); d1248 2 a1249 4 case ABIArgInfo::Direct: if (ArgNo == 0 && FI.isChainCall()) Attrs.addAttribute(llvm::Attribute::Nest); else if (AI.getInReg()) d1251 13 d1265 1 a1265 1 d1281 1 a1281 1 case ABIArgInfo::Expand: d1288 10 d1300 1 d1311 10 a1320 7 if (Attrs.hasAttributes()) { unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); for (unsigned i = 0; i < NumIRArgs; i++) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), FirstIRArg + i + 1, Attrs)); } a1321 1 assert(ArgNo == FI.arg_size()); a1349 28 /// 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()) return ParmNNAttr; } // Check function attributes. if (!FD) return nullptr; for (const auto *NNAttr : FD->specific_attrs()) { if (NNAttr->isNonNull(ArgNo)) return NNAttr; } return nullptr; } a1352 4 if (CurCodeDecl && CurCodeDecl->hasAttr()) // Naked functions don't have prologues. return; d1369 2 a1370 8 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), FI); // Flattened function arguments. SmallVector FnArgs; FnArgs.reserve(IRFunctionArgs.totalIRArgs()); for (auto &Arg : Fn->args()) { FnArgs.push_back(&Arg); } assert(FnArgs.size() == IRFunctionArgs.totalIRArgs()); d1375 4 a1378 2 if (IRFunctionArgs.hasInallocaArg()) { ArgStruct = FnArgs[IRFunctionArgs.getInallocaArgNo()]; d1382 7 a1388 3 // Name the struct return parameter. if (IRFunctionArgs.hasSRetArg()) { auto AI = FnArgs[IRFunctionArgs.getSRetArgNo()]; d1392 4 d1398 4 d1416 1 a1416 1 unsigned ArgNo = 0; d1418 1 a1418 1 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); d1427 3 a1429 2 unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); a1432 1 assert(NumIRArgs == 0); d1436 1 a1436 1 break; d1440 1 a1440 2 assert(NumIRArgs == 1); llvm::Value *V = FnArgs[FirstIRArg]; d1486 1 a1486 2 assert(NumIRArgs == 1); auto AI = FnArgs[FirstIRArg]; d1490 2 a1491 2 if (getNonNullAttr(CurCodeDecl, PVD, PVD->getType(), PVD->getFunctionScopeIndex())) a1529 19 const auto *AVAttr = PVD->getAttr(); if (!AVAttr) if (const auto *TOTy = dyn_cast(OTy)) AVAttr = TOTy->getDecl()->getAttr(); if (AVAttr) { llvm::Value *AlignmentValue = EmitScalarExpr(AVAttr->getAlignment()); llvm::ConstantInt *AlignmentCI = cast(AlignmentValue); unsigned Alignment = std::min((unsigned) AlignmentCI->getZExtValue(), +llvm::Value::MaximumAlignment); llvm::AttrBuilder Attrs; Attrs.addAlignmentAttr(Alignment); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, Attrs)); } d1584 5 a1588 2 // 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. d1590 1 a1590 2 if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy && STy->getNumElements() > 1) { a1598 1 assert(STy->getNumElements() == NumIRArgs); d1600 1 a1600 1 auto AI = FnArgs[FirstIRArg + i]; d1603 1 a1603 1 Builder.CreateStore(AI, EltPtr); a1610 1 assert(STy->getNumElements() == NumIRArgs); d1612 1 a1612 1 auto AI = FnArgs[FirstIRArg + i]; d1615 1 a1615 1 Builder.CreateStore(AI, EltPtr); d1622 1 a1622 2 assert(NumIRArgs == 1); auto AI = FnArgs[FirstIRArg]; d1624 1 a1624 1 CreateCoercedStore(AI, Ptr, /*DestIsVolatile=*/false, *this); d1637 1 a1637 1 break; d1648 1 d1651 5 a1655 8 auto FnArgIter = FnArgs.begin() + FirstIRArg; ExpandTypeFromArgs(Ty, LV, FnArgIter); assert(FnArgIter == FnArgs.begin() + FirstIRArg + NumIRArgs); for (unsigned i = 0, e = NumIRArgs; i != e; ++i) { auto AI = FnArgs[FirstIRArg + i]; AI->setName(Arg->getName() + "." + Twine(i)); } break; a1658 1 assert(NumIRArgs == 0); d1666 3 a1668 1 break; d1670 5 d1677 4 a1889 6 if (CurCodeDecl && CurCodeDecl->hasAttr()) { // Naked functions don't have epilogues. Builder.CreateUnreachable(); return; } d2001 1 a2001 20 llvm::Instruction *Ret; if (RV) { if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) { if (auto RetNNAttr = CurGD.getDecl()->getAttr()) { SanitizerScope SanScope(this); llvm::Value *Cond = Builder.CreateICmpNE( RV, llvm::Constant::getNullValue(RV->getType())); llvm::Constant *StaticData[] = { EmitCheckSourceLocation(EndLoc), EmitCheckSourceLocation(RetNNAttr->getLocation()), }; EmitCheck(std::make_pair(Cond, SanitizerKind::ReturnsNonnullAttribute), "nonnull_return", StaticData, None); } } Ret = Builder.CreateRet(RV); } else { Ret = Builder.CreateRetVoid(); } a2308 24 static void emitNonNullArgCheck(CodeGenFunction &CGF, RValue RV, QualType ArgType, SourceLocation ArgLoc, const FunctionDecl *FD, unsigned ParmNum) { if (!CGF.SanOpts.has(SanitizerKind::NonnullAttribute) || !FD) return; auto PVD = ParmNum < FD->getNumParams() ? FD->getParamDecl(ParmNum) : nullptr; unsigned ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum; auto NNAttr = getNonNullAttr(FD, PVD, ArgType, ArgNo); if (!NNAttr) return; CodeGenFunction::SanitizerScope SanScope(&CGF); assert(RV.isScalar()); llvm::Value *V = RV.getScalarVal(); llvm::Value *Cond = CGF.Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType())); llvm::Constant *StaticData[] = { CGF.EmitCheckSourceLocation(ArgLoc), CGF.EmitCheckSourceLocation(NNAttr->getLocation()), llvm::ConstantInt::get(CGF.Int32Ty, ArgNo + 1), }; CGF.EmitCheck(std::make_pair(Cond, SanitizerKind::NonnullAttribute), "nonnull_arg", StaticData, None); } a2312 2 const FunctionDecl *CalleeDecl, unsigned ParamsToSkip, a2335 2 emitNonNullArgCheck(*this, Args.back().RV, ArgTypes[I], Arg->getExprLoc(), CalleeDecl, ParamsToSkip + I); a2349 2 emitNonNullArgCheck(*this, Args.back().RV, ArgTypes[I], Arg->getExprLoc(), CalleeDecl, ParamsToSkip + I); a2448 18 QualType CodeGenFunction::getVarArgType(const Expr *Arg) { // System headers on Windows define NULL to 0 instead of 0LL on Win64. MSVC // implicitly widens null pointer constants that are arguments to varargs // functions to pointer-sized ints. if (!getTarget().getTriple().isOSWindows()) return Arg->getType(); if (Arg->getType()->isIntegerType() && getContext().getTypeSize(Arg->getType()) < getContext().getTargetInfo().getPointerWidth(0) && Arg->isNullPointerConstant(getContext(), Expr::NPC_ValueDependentIsNotNull)) { return getContext().getIntPtrType(); } return Arg->getType(); } d2463 1 a2463 1 return EmitNounwindRuntimeCall(callee, None, name); d2481 1 a2481 1 return EmitRuntimeCall(callee, None, name); d2520 1 a2520 1 return EmitRuntimeCallOrInvoke(callee, None, name); d2536 1 a2536 1 return EmitCallOrInvoke(Callee, None, Name); d2564 67 d2653 1 d2660 2 a2682 3 ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); SmallVector IRCallArgs(IRFunctionArgs.totalIRArgs()); d2686 1 d2691 8 a2698 2 if (IRFunctionArgs.hasSRetArg()) { IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr; a2707 1 unsigned ArgNo = 0; d2710 1 a2710 1 I != E; ++I, ++info_it, ++ArgNo) { d2714 4 d2721 4 a2724 6 if (IRFunctionArgs.hasPaddingArg(ArgNo)) IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] = llvm::UndefValue::get(ArgInfo.getPaddingType()); unsigned FirstIRArg, NumIRArgs; std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo); a2727 1 assert(NumIRArgs == 0); d2753 1 a2753 1 break; a2756 1 assert(NumIRArgs == 1); d2762 1 a2762 1 IRCallArgs[FirstIRArg] = AI; d2764 1 a2764 1 LValue argLV = MakeAddrLValue(AI, I->Ty, TypeAlign); d2766 3 d2782 2 a2783 4 const unsigned ArgAddrSpace = (FirstIRArg < IRFuncTy->getNumParams() ? IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() : 0); d2792 1 a2792 1 IRCallArgs[FirstIRArg] = AI; d2794 3 d2799 4 a2802 1 IRCallArgs[FirstIRArg] = Addr; a2808 1 assert(NumIRArgs == 0); a2815 1 assert(NumIRArgs == 1); d2821 1 a2821 6 // We might have to widen integers, but we should never truncate. if (ArgInfo.getCoerceToType() != V->getType() && V->getType()->isIntegerTy()) V = Builder.CreateZExt(V, ArgInfo.getCoerceToType()); d2824 6 a2829 4 if (FirstIRArg < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(FirstIRArg)) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg)); IRCallArgs[FirstIRArg] = V; d2851 5 a2855 2 // 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. d2858 1 a2858 1 if (STy && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) { a2877 1 assert(NumIRArgs == STy->getNumElements()); d2883 4 a2886 1 IRCallArgs[FirstIRArg + i] = LI; d2890 5 a2894 3 assert(NumIRArgs == 1); IRCallArgs[FirstIRArg] = CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), *this); d2901 2 a2902 3 unsigned IRArgPos = FirstIRArg; ExpandTypeToArgs(I->Ty, RV, IRFuncTy, IRCallArgs, IRArgPos); assert(IRArgPos == FirstIRArg + NumIRArgs); d2907 3 d2940 1 a2940 2 assert(IRFunctionArgs.hasInallocaArg()); IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg; d2959 1 a2959 1 ActualFT->getNumParams() == IRCallArgs.size() && a2975 10 assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg()); for (unsigned i = 0; i < IRCallArgs.size(); ++i) { // Inalloca argument can have different type. if (IRFunctionArgs.hasInallocaArg() && i == IRFunctionArgs.getInallocaArgNo()) continue; if (i < IRFuncTy->getNumParams()) assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i)); } d2990 1 a2990 1 CS = Builder.CreateCall(Callee, IRCallArgs); d2993 1 a2993 1 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, IRCallArgs); d3042 4 a3045 5 RValue Ret = [&] { switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: case ABIArgInfo::Indirect: return convertTempToRValue(SRetPtr, RetTy, SourceLocation()); d3047 4 a3050 4 case ABIArgInfo::Ignore: // If we are ignoring an argument that had a result, make sure to // construct the appropriate return value for our caller. return GetUndefRValue(RetTy); d3052 17 a3068 9 case ABIArgInfo::Extend: case ABIArgInfo::Direct: { llvm::Type *RetIRTy = ConvertType(RetTy); if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { llvm::Value *Real = Builder.CreateExtractValue(CI, 0); llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); return RValue::getComplex(std::make_pair(Real, Imag)); d3070 10 a3079 21 case TEK_Aggregate: { llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "agg.tmp"); DestIsVolatile = false; } BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); return RValue::getAggregate(DestPtr); } case TEK_Scalar: { // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. llvm::Value *V = CI; if (V->getType() != RetIRTy) V = Builder.CreateBitCast(V, RetIRTy); return RValue::get(V); } } llvm_unreachable("bad evaluation kind"); a3080 7 llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "coerce"); DestIsVolatile = false; d3082 2 d3085 2 a3086 9 // If the value is offset in memory, apply the offset now. llvm::Value *StorePtr = DestPtr; if (unsigned Offs = RetAI.getDirectOffset()) { StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); StorePtr = Builder.CreateBitCast(StorePtr, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); d3088 3 a3090 1 return convertTempToRValue(DestPtr, RetTy, SourceLocation()); d3093 7 a3099 2 case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); d3101 1 d3103 2 a3104 2 llvm_unreachable("Unhandled ABIArgInfo::Kind"); } (); d3106 2 a3107 11 if (Ret.isScalar() && TargetDecl) { if (const auto *AA = TargetDecl->getAttr()) { llvm::Value *OffsetValue = nullptr; if (const auto *Offset = AA->getOffset()) OffsetValue = EmitScalarExpr(Offset); llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment()); llvm::ConstantInt *AlignmentCI = cast(Alignment); EmitAlignmentAssumption(Ret.getScalarVal(), AlignmentCI->getZExtValue(), OffsetValue); } d3110 1 a3110 1 return Ret; @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @a17 1 #include "CGCleanup.h" a23 1 #include "clang/Basic/TargetBuiltins.h" a32 1 #include "llvm/IR/IntrinsicInst.h" a53 2 case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC; case CC_SpirKernel: return llvm::CallingConv::SPIR_KERNEL; a90 25 /// Adds the formal paramaters 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 &prefix, const CanQual &FPT, const FunctionDecl *FD) { // Fast path: unknown target. if (FD == nullptr) { prefix.append(FPT->param_type_begin(), FPT->param_type_end()); return; } // In the vast majority 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()); assert(FD->getNumParams() == FPT->getNumParams()); for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) { prefix.push_back(FPT->getParamType(I)); if (FD->getParamDecl(I)->hasAttr()) prefix.push_back(CGT.getContext().getSizeType()); } } d96 1 a96 2 CanQual FTP, const FunctionDecl *FD) { d99 2 a100 1 appendParameterTypes(CGT, prefix, FTP, FD); d110 1 a110 2 CodeGenTypes::arrangeFreeFunctionType(CanQual FTP, const FunctionDecl *FD) { d113 1 a113 1 FTP, FD); d136 3 d159 1 a159 2 const FunctionProtoType *FTP, const CXXMethodDecl *MD) { d170 1 a170 1 FTP->getCanonicalTypeUnqualified().getAs(), MD); d187 1 a187 1 return arrangeCXXMethodType(ThisType, prototype.getTypePtr(), MD); d190 1 a190 1 return arrangeFreeFunctionType(prototype, MD); d211 2 a212 1 appendParameterTypes(*this, argTypes, FTP, MD); d278 1 a278 1 return arrangeFreeFunctionType(FTy.getAs(), FD); a351 20 const CGFunctionInfo & CodeGenTypes::arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT) { assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure); CanQual FTP = GetFormalType(CD); SmallVector ArgTys; const CXXRecordDecl *RD = CD->getParent(); ArgTys.push_back(GetThisType(Context, RD)); 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); } a537 1 FI->ArgStructAlign = 0; a710 15 static void forConstantArrayExpansion(CodeGenFunction &CGF, ConstantArrayExpansion *CAE, Address BaseAddr, llvm::function_ref 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)); } } d718 2 a719 2 forConstantArrayExpansion(*this, CAExp, LV.getAddress(), [&](Address EltAddr) { d722 1 a722 1 }); d724 1 a724 1 Address This = LV.getAddress(); d727 1 a727 1 Address Base = d740 7 a746 4 } else if (isa(Exp.get())) { auto realValue = *AI++; auto imagValue = *AI++; EmitStoreOfComplex(ComplexPairTy(realValue, imagValue), LV, /*init*/ true); d758 3 a760 2 forConstantArrayExpansion(*this, CAExp, RV.getAggregateAddress(), [&](Address EltAddr) { d764 1 a764 1 }); d766 1 a766 1 Address This = RV.getAggregateAddress(); d769 1 a769 1 Address Base = a803 10 /// Create a temporary allocation for the purposes of coercion. static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty, CharUnits MinAlign) { // 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); } d808 2 a809 2 static Address EnterStructPointerForCoercedAccess(Address SrcPtr, d828 1 a828 1 SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, CharUnits(), "coerce.dive"); d831 2 a832 1 llvm::Type *SrcTy = SrcPtr.getElementType(); d894 1 a894 2 /// a pointer to an object of type \arg Ty, known to be aligned to /// \arg SrcAlign bytes. d899 2 a900 1 static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty, d902 2 a903 1 llvm::Type *SrcTy = Src.getElementType(); d907 1 a907 1 return CGF.Builder.CreateLoad(Src); d912 2 a913 2 Src = EnterStructPointerForCoercedAccess(Src, SrcSTy, DstSize, CGF); SrcTy = Src.getType()->getElementType(); d922 1 a922 1 llvm::Value *Load = CGF.Builder.CreateLoad(Src); d934 6 a939 2 Src = CGF.Builder.CreateBitCast(Src, llvm::PointerType::getUnqual(Ty)); return CGF.Builder.CreateLoad(Src); d942 7 a948 4 // Otherwise do coercion through memory. This is stupid, but simple. Address Tmp = CreateTempAllocaForCoercion(CGF, Ty, Src.getAlignment()); Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.Int8PtrTy); Address SrcCasted = CGF.Builder.CreateBitCast(Src, CGF.Int8PtrTy); d951 1 a951 1 false); d960 2 a961 1 Address Dest, bool DestIsVolatile) { a964 3 const llvm::StructLayout *Layout = CGF.CGM.getDataLayout().getStructLayout(STy); d966 1 a966 2 auto EltOffset = CharUnits::fromQuantity(Layout->getElementOffset(i)); Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i, EltOffset); d968 4 a971 1 CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile); d974 3 a976 1 CGF.Builder.CreateStore(Val, Dest, DestIsVolatile); d981 1 a981 2 /// where the source and destination may have different types. The /// destination is known to be aligned to \arg DstAlign bytes. d986 1 a986 1 Address Dst, d990 2 a991 1 llvm::Type *DstTy = Dst.getType()->getElementType(); d993 1 a993 1 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile); d1000 2 a1001 2 Dst = EnterStructPointerForCoercedAccess(Dst, DstSTy, SrcSize, CGF); DstTy = Dst.getType()->getElementType(); d1009 1 a1009 1 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile); d1017 4 a1020 2 Dst = CGF.Builder.CreateBitCast(Dst, llvm::PointerType::getUnqual(SrcTy)); BuildAggStore(CGF, Src, Dst, DstIsVolatile); d1031 1 a1031 1 Address Tmp = CreateTempAllocaForCoercion(CGF, SrcTy, Dst.getAlignment()); d1033 4 a1036 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.Int8PtrTy); Address DstCasted = CGF.Builder.CreateBitCast(Dst, CGF.Int8PtrTy); d1039 1 a1039 1 false); a1042 11 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; } d1256 6 a1261 1 case ABIArgInfo::Indirect: d1362 5 a1366 14 static void AddAttributesFromFunctionProtoType(ASTContext &Ctx, llvm::AttrBuilder &FuncAttrs, const FunctionProtoType *FPT) { if (!FPT) return; if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) && FPT->isNothrow(Ctx)) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } void CodeGenModule::ConstructAttributeList( StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo, AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) { a1375 7 // If we have information about the function prototype, we can learn // attributes form there. AddAttributesFromFunctionProtoType(getContext(), FuncAttrs, CalleeInfo.getCalleeFunctionProtoType()); const Decl *TargetDecl = CalleeInfo.getCalleeDecl(); d1388 3 a1390 2 AddAttributesFromFunctionProtoType( getContext(), FuncAttrs, Fn->getType()->getAs()); d1398 1 a1398 1 // 'const', 'pure' and 'noalias' attributed functions are also nounwind. a1404 3 } else if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ArgMemOnly); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); d1406 1 a1406 1 if (TargetDecl->hasAttr()) d1432 1 a1432 2 if (!CodeGenOpts.SimplifyLibCalls || CodeGenOpts.isNoBuiltinFunc(Name.data())) a1433 2 if (!CodeGenOpts.TrapFuncName.empty()) FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName); a1445 6 bool DisableTailCalls = CodeGenOpts.DisableTailCalls || (TargetDecl && TargetDecl->hasAttr()); FuncAttrs.addAttribute("disable-tail-calls", llvm::toStringRef(DisableTailCalls)); d1459 2 a1460 48 if (CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("stackrealign"); // Add target-cpu and target-features attributes to functions. If // we have a decl for the function and it has a target attribute then // parse that and add it to the feature set. StringRef TargetCPU = getTarget().getTargetOpts().CPU; const FunctionDecl *FD = dyn_cast_or_null(TargetDecl); if (FD && FD->hasAttr()) { llvm::StringMap FeatureMap; getFunctionFeatureMap(FeatureMap, FD); // Produce the canonical string for this set of features. std::vector Features; for (llvm::StringMap::const_iterator it = FeatureMap.begin(), ie = FeatureMap.end(); it != ie; ++it) Features.push_back((it->second ? "+" : "-") + it->first().str()); // Now add the target-cpu and target-features to the function. // While we populated the feature map above, we still need to // get and parse the target attribute so we can get the cpu for // the function. const auto *TD = FD->getAttr(); TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse(); if (ParsedAttr.second != "") TargetCPU = ParsedAttr.second; if (TargetCPU != "") FuncAttrs.addAttribute("target-cpu", TargetCPU); if (!Features.empty()) { std::sort(Features.begin(), Features.end()); FuncAttrs.addAttribute( "target-features", llvm::join(Features.begin(), Features.end(), ",")); } } else { // Otherwise just add the existing target cpu and target features to the // function. std::vector &Features = getTarget().getTargetOpts().Features; if (TargetCPU != "") FuncAttrs.addAttribute("target-cpu", TargetCPU); if (!Features.empty()) { std::sort(Features.begin(), Features.end()); FuncAttrs.addAttribute( "target-features", llvm::join(Features.begin(), Features.end(), ",")); } } d1549 2 a1550 6 else if (ParamType->isUnsignedIntegerOrEnumerationType()) { if (getTypes().getABIInfo().shouldSignExtUnsignedType(ParamType)) Attrs.addAttribute(llvm::Attribute::SExt); else Attrs.addAttribute(llvm::Attribute::ZExt); } d1559 1 a1559 1 case ABIArgInfo::Indirect: { d1566 1 a1566 18 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()); d1572 1 a1572 1 } d1692 1 a1692 2 Address ArgStruct = Address::invalid(); const llvm::StructLayout *ArgStructLayout = nullptr; d1694 2 a1695 5 ArgStructLayout = CGM.getDataLayout().getStructLayout(FI.getArgStruct()); ArgStruct = Address(FnArgs[IRFunctionArgs.getInallocaArgNo()], FI.getArgStructAlignment()); assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo()); d1709 3 a1711 1 SmallVector ArgVals; d1737 3 a1739 6 auto FieldIndex = ArgI.getInAllocaFieldIndex(); CharUnits FieldOffset = CharUnits::fromQuantity(ArgStructLayout->getElementOffset(FieldIndex)); Address V = Builder.CreateStructGEP(ArgStruct, FieldIndex, FieldOffset, Arg->getName()); ArgVals.push_back(ParamValue::forIndirect(V)); d1745 1 a1745 1 Address ParamAddr = Address(FnArgs[FirstIRArg], ArgI.getIndirectAlign()); d1749 1 a1749 2 // need to do is realign the value, if requested. Address V = ParamAddr; d1751 1 a1751 1 Address AlignedTemp = CreateMemTemp(Ty, "coerce"); d1758 1 d1760 8 a1767 4 auto SizeVal = llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()); Address Dst = Builder.CreateBitCast(AlignedTemp, Int8PtrTy); Address Src = Builder.CreateBitCast(ParamAddr, Int8PtrTy); Builder.CreateMemCpy(Dst, Src, SizeVal, false); d1770 1 a1770 1 ArgVals.push_back(ParamValue::forIndirect(V)); d1773 3 a1775 2 llvm::Value *V = EmitLoadOfScalar(ParamAddr, false, Ty, Arg->getLocStart()); d1779 1 a1779 1 ArgVals.push_back(ParamValue::forDirect(V)); d1884 1 a1884 1 ArgVals.push_back(ParamValue::forDirect(V)); d1888 1 a1888 2 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg), Arg->getName()); d1890 18 a1907 2 // Pointer to store into. Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI); a1913 1 auto SrcLayout = CGM.getDataLayout().getStructLayout(STy); d1915 2 a1916 1 llvm::Type *DstTy = Ptr.getElementType(); a1918 1 Address AddrToStoreInto = Address::invalid(); d1920 9 a1928 2 AddrToStoreInto = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy)); d1930 12 a1941 3 AddrToStoreInto = CreateTempAlloca(STy, Alloca.getAlignment(), "coerce"); } d1943 1 a1943 12 assert(STy->getNumElements() == NumIRArgs); for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { auto AI = FnArgs[FirstIRArg + i]; AI->setName(Arg->getName() + ".coerce" + Twine(i)); auto Offset = CharUnits::fromQuantity(SrcLayout->getElementOffset(i)); Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i, Offset); Builder.CreateStore(AI, EltPtr); } if (SrcSize > DstSize) { Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize); a1944 1 d1953 1 d1956 1 a1956 2 llvm::Value *V = EmitLoadOfScalar(Alloca, false, Ty, Arg->getLocStart()); d1959 1 a1959 1 ArgVals.push_back(ParamValue::forDirect(V)); d1961 1 a1961 1 ArgVals.push_back(ParamValue::forIndirect(Alloca)); d1970 5 a1974 3 Address Alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg)); LValue LV = MakeAddrLValue(Alloca, Ty); ArgVals.push_back(ParamValue::forIndirect(Alloca)); d1990 1 a1990 1 ArgVals.push_back(ParamValue::forIndirect(CreateMemTemp(Ty))); d1993 1 a1993 1 ArgVals.push_back(ParamValue::forDirect(U)); d2001 2 a2002 1 EmitParmDecl(*Args[I], ArgVals[I], I + 1); d2005 2 a2006 1 EmitParmDecl(*Args[I], ArgVals[I], I + 1); d2059 1 a2059 1 if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints().objc_retain) { d2061 1 a2061 1 } else if (call->getCalledValue() == CGF.CGM.getObjCEntrypoints() d2070 1 a2070 1 if (CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker) { d2079 1 a2079 1 CGF.CGM.getObjCEntrypoints().retainAutoreleasedReturnValueMarker); d2124 1 a2124 1 retainCall->getCalledValue() != CGF.CGM.getObjCEntrypoints().objc_retain) d2132 1 a2132 1 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self).getPointer()) a2168 12 // Check if a User is a store which pointerOperand is the ReturnValue. // We are looking for stores to the ReturnValue, not for stores of the // ReturnValue to some other location. auto GetStoreIfValid = [&CGF](llvm::User *U) -> llvm::StoreInst * { auto *SI = dyn_cast(U); if (!SI || SI->getPointerOperand() != CGF.ReturnValue.getPointer()) return nullptr; // These aren't actually possible for non-coerced returns, and we // only care about non-coerced returns on this code path. assert(!SI->isAtomic() && !SI->isVolatile()); return SI; }; d2173 1 a2173 1 if (!CGF.ReturnValue.getPointer()->hasOneUse()) { d2176 5 a2180 22 llvm::Instruction *I = &IP->back(); // Skip lifetime markers for (llvm::BasicBlock::reverse_iterator II = IP->rbegin(), IE = IP->rend(); II != IE; ++II) { if (llvm::IntrinsicInst *Intrinsic = dyn_cast(&*II)) { if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) { const llvm::Value *CastAddr = Intrinsic->getArgOperand(1); ++II; if (II == IE) break; if (isa(&*II) && (CastAddr == &*II)) continue; } } I = &*II; break; } return GetStoreIfValid(I); d2184 1 a2184 1 GetStoreIfValid(CGF.ReturnValue.getPointer()->user_back()); d2187 4 d2215 1 a2215 1 if (!ReturnValue.isValid()) { d2233 4 a2236 4 llvm::Value *ArgStruct = &*EI; llvm::Value *SRet = Builder.CreateStructGEP( nullptr, ArgStruct, RetAI.getInAllocaFieldIndex()); RV = Builder.CreateAlignedLoad(SRet, getPointerAlign(), "sret"); d2247 3 a2249 2 EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc); EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy), d2258 1 a2258 1 MakeNaturalAlignAddrLValue(&*AI, RetTy), d2274 1 a2274 2 if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) { d2285 3 a2287 6 auto returnValueInst = ReturnValue.getPointer(); if (returnValueInst->use_empty()) { if (auto alloca = dyn_cast(returnValueInst)) { alloca->eraseFromParent(); ReturnValue = Address::invalid(); } d2295 1 d2297 6 a2302 1 Address V = emitAddressAtOffset(*this, ReturnValue, RetAI); d2327 2 a2328 2 if (CurCodeDecl && SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) { if (auto RetNNAttr = CurCodeDecl->getAttr()) { d2345 2 a2346 2 if (RetDbgLoc) Ret->setDebugLoc(std::move(RetDbgLoc)); d2354 1 a2354 2 static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty) { d2359 3 a2361 8 llvm::UndefValue::get(IRTy->getPointerTo()->getPointerTo()); Placeholder = CGF.Builder.CreateDefaultAlignedLoad(Placeholder); // FIXME: When we generate this IR in one pass, we shouldn't need // this win32-specific alignment hack. CharUnits Align = CharUnits::fromQuantity(4); return AggValueSlot::forAddr(Address(Placeholder, Align), d2374 1 a2374 1 Address local = GetAddrOfLocalVar(param); d2409 2 a2410 2 Address srcAddr = srcLV.getAddress(); assert(!isProvablyNull(srcAddr.getPointer()) && d2417 1 a2417 1 bool provablyNonNull = isProvablyNonNull(srcAddr.getPointer()); d2422 1 a2422 2 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull"); d2431 3 a2433 2 value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(), "icr.writeback-cast"); d2483 4 a2486 3 for (const auto &I : llvm::reverse(Cleanups)) { CGF.DeactivateCleanupBlock(I.Cleanup, I.IsActiveIP); I.IsActiveIP->eraseFromParent(); d2498 1 a2498 3 /// we are passing the address of an __autoreleased temporary; it /// might be copy-initialized with the current value of the given /// address, but it will definitely be copied out of after the call. d2504 1 a2504 1 // This can fail if the argument expression is more complicated. d2510 1 a2510 1 Address srcAddr = CGF.EmitPointerWithAlignment(CRE->getSubExpr()); d2514 1 a2514 1 srcLV = CGF.MakeAddrLValue(srcAddr, srcAddrType); d2516 1 a2516 1 Address srcAddr = srcLV.getAddress(); d2525 1 a2525 1 if (isProvablyNull(srcAddr.getPointer())) { d2532 2 a2533 3 Address temp = CGF.CreateTempAlloca(destType->getElementType(), CGF.getPointerAlign(), "icr.temp"); d2555 1 a2555 1 bool provablyNonNull = isProvablyNonNull(srcAddr.getPointer()); d2557 1 a2557 1 finalArgument = temp.getPointer(); d2559 1 a2559 2 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull"); d2563 1 a2563 1 temp.getPointer(), "icr.argument"); d2629 11 a2639 1 StackBase = CGF.Builder.CreateCall(F, {}, "inalloca.save"); d2644 1 a2644 1 // Restore the stack after the call. d2646 2 d2652 4 a2655 5 void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, const FunctionDecl *FD, unsigned ParmNum) { if (!SanOpts.has(SanitizerKind::NonnullAttribute) || !FD) d2662 1 a2662 1 SanitizerScope SanScope(this); d2666 1 a2666 1 Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType())); d2668 3 a2670 3 EmitCheckSourceLocation(ArgLoc), EmitCheckSourceLocation(NNAttr->getLocation()), llvm::ConstantInt::get(Int32Ty, ArgNo + 1), d2672 1 a2672 1 EmitCheck(std::make_pair(Cond, SanitizerKind::NonnullAttribute), d2676 10 a2685 19 void CodeGenFunction::EmitCallArgs( CallArgList &Args, ArrayRef ArgTypes, llvm::iterator_range ArgRange, const FunctionDecl *CalleeDecl, unsigned ParamsToSkip) { assert((int)ArgTypes.size() == (ArgRange.end() - ArgRange.begin())); auto MaybeEmitImplicitObjectSize = [&](unsigned I, const Expr *Arg) { if (CalleeDecl == nullptr || I >= CalleeDecl->getNumParams()) return; auto *PS = CalleeDecl->getParamDecl(I)->getAttr(); if (PS == nullptr) return; const auto &Context = getContext(); auto SizeTy = Context.getSizeType(); auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy)); llvm::Value *V = evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(), T); Args.add(RValue::get(V), SizeTy); }; d2703 1 a2703 1 CallExpr::const_arg_iterator Arg = ArgRange.begin() + I; d2705 1 a2705 1 EmitNonNullArgCheck(Args.back().RV, ArgTypes[I], (*Arg)->getExprLoc(), d2707 2 a2708 1 MaybeEmitImplicitObjectSize(I, *Arg); d2718 2 a2719 2 CallExpr::const_arg_iterator Arg = ArgRange.begin() + I; assert(Arg != ArgRange.end()); d2721 1 a2721 1 EmitNonNullArgCheck(Args.back().RV, ArgTypes[I], (*Arg)->getExprLoc(), d2723 2 a2724 1 MaybeEmitImplicitObjectSize(I, *Arg); d2730 2 a2731 2 struct DestroyUnpassedArg final : EHScopeStack::Cleanup { DestroyUnpassedArg(Address Addr, QualType Ty) d2734 1 a2734 1 Address Addr; d2745 1 a2745 14 struct DisableDebugLocationUpdates { CodeGenFunction &CGF; bool disabledDebugInfo; DisableDebugLocationUpdates(CodeGenFunction &CGF, const Expr *E) : CGF(CGF) { if ((disabledDebugInfo = isa(E) && CGF.getDebugInfo())) CGF.disableDebugInfo(); } ~DisableDebugLocationUpdates() { if (disabledDebugInfo) CGF.enableDebugInfo(); } }; } // end anonymous namespace a2748 1 DisableDebugLocationUpdates Dis(*this, E); d2794 1 a2794 2 pushFullExprCleanup(EHCleanup, Slot.getAddress(), type); d2811 3 a2813 2 Address tmp = CreateMemTemp(type); EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile()); a2885 18 // Calls which may throw must have operand bundles indicating which funclet // they are nested within. static void getBundlesForFunclet(llvm::Value *Callee, llvm::Instruction *CurrentFuncletPad, SmallVectorImpl &BundleList) { // There is no need for a funclet operand bundle if we aren't inside a funclet. if (!CurrentFuncletPad) return; // Skip intrinsics which cannot throw. auto *CalleeFn = dyn_cast(Callee->stripPointerCasts()); if (CalleeFn && CalleeFn->isIntrinsic() && CalleeFn->doesNotThrow()) return; BundleList.emplace_back("funclet", CurrentFuncletPad); } a2888 3 SmallVector BundleList; getBundlesForFunclet(callee, CurrentFuncletPad, BundleList); d2894 1 a2894 2 args, BundleList); d2898 1 a2898 1 llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList); d2903 1 d2924 6 d2952 1 a2952 1 return llvm::CallSite(Inst); d2974 1 a2974 1 CGCalleeInfo CalleeInfo, d2989 1 a2989 2 Address ArgMemory = Address::invalid(); const llvm::StructLayout *ArgMemoryLayout = nullptr; a2990 1 ArgMemoryLayout = CGM.getDataLayout().getStructLayout(ArgStruct); a2998 2 auto Align = CallInfo.getArgStructAlignment(); AI->setAlignment(Align.getQuantity()); d3001 1 a3001 1 ArgMemory = Address(AI, Align); a3003 7 // Helper function to drill into the inalloca allocation. auto createInAllocaStructGEP = [&](unsigned FieldIndex) -> Address { auto FieldOffset = CharUnits::fromQuantity(ArgMemoryLayout->getElementOffset(FieldIndex)); return Builder.CreateStructGEP(ArgMemory, FieldIndex, FieldOffset); }; d3009 1 a3009 2 Address SRetPtr = Address::invalid(); size_t UnusedReturnSize = 0; d3011 2 a3012 3 if (!ReturnValue.isNull()) { SRetPtr = ReturnValue.getValue(); } else { a3013 7 if (HaveInsertPoint() && ReturnValue.isUnused()) { uint64_t size = CGM.getDataLayout().getTypeAllocSize(ConvertTypeForMem(RetTy)); if (EmitLifetimeStart(size, SRetPtr.getPointer())) UnusedReturnSize = size; } } d3015 1 a3015 1 IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr.getPointer(); d3017 3 a3019 2 Address Addr = createInAllocaStructGEP(RetAI.getInAllocaFieldIndex()); Builder.CreateStore(SRetPtr.getPointer(), Addr); d3032 2 d3049 1 a3049 1 cast(RV.getAggregatePointer()); d3052 2 a3053 1 Address Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex()); d3055 1 a3055 1 deferPlaceholderReplacement(Placeholder, Addr.getPointer()); d3058 3 a3060 2 Address Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex()); unsigned AS = Addr.getType()->getPointerAddressSpace(); d3065 1 a3065 1 if (Addr.getType() != MemType) d3067 1 a3067 1 LValue argLV = MakeAddrLValue(Addr, I->Ty); d3077 4 a3080 2 Address Addr = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign()); IRCallArgs[FirstIRArg] = Addr.getPointer(); d3082 1 a3082 1 LValue argLV = MakeAddrLValue(Addr, I->Ty); d3093 2 a3094 2 Address Addr = RV.getAggregateAddress(); CharUnits Align = ArgInfo.getIndirectAlign(); d3096 1 a3096 1 const unsigned RVAddrSpace = Addr.getType()->getAddressSpace(); d3102 3 a3104 5 (ArgInfo.getIndirectByVal() && Addr.getAlignment() < Align && llvm::getOrEnforceKnownAlignment(Addr.getPointer(), Align.getQuantity(), *TD) < Align.getQuantity()) || (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) { d3106 4 a3109 2 Address AI = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign()); IRCallArgs[FirstIRArg] = AI.getPointer(); d3113 1 a3113 1 IRCallArgs[FirstIRArg] = Addr.getPointer(); d3133 1 a3133 1 V = Builder.CreateLoad(RV.getAggregateAddress()); d3150 1 a3150 1 Address Src = Address::invalid(); d3152 2 a3153 2 Src = CreateMemTemp(I->Ty, "coerce"); LValue SrcLV = MakeAddrLValue(Src, I->Ty); d3155 2 a3156 3 } else { Src = RV.getAggregateAddress(); } d3159 7 a3165 1 Src = emitAddressAtOffset(*this, Src, ArgInfo); d3172 2 a3173 1 llvm::Type *SrcTy = Src.getType()->getElementType(); d3182 4 a3185 5 Address TempAlloca = CreateTempAlloca(STy, Src.getAlignment(), Src.getName() + ".coerce"); Builder.CreateMemCpy(TempAlloca, Src, SrcSize); Src = TempAlloca; d3187 2 a3188 1 Src = Builder.CreateBitCast(Src, llvm::PointerType::getUnqual(STy)); a3190 1 auto SrcLayout = CGM.getDataLayout().getStructLayout(STy); d3193 4 a3196 3 auto Offset = CharUnits::fromQuantity(SrcLayout->getElementOffset(i)); Address EltPtr = Builder.CreateStructGEP(Src, i, Offset); llvm::Value *LI = Builder.CreateLoad(EltPtr); d3203 1 a3203 1 CreateCoercedLoad(Src, ArgInfo.getCoerceToType(), *this); d3217 2 a3218 2 if (ArgMemory.isValid()) { llvm::Value *Arg = ArgMemory.getPointer(); d3296 2 a3297 3 CGM.ConstructAttributeList(Callee->getName(), CallInfo, CalleeInfo, AttributeList, CallingConv, /*AttrOnCallSite=*/true); d3301 4 a3304 18 bool CannotThrow; if (currentFunctionUsesSEHTry()) { // SEH cares about asynchronous exceptions, everything can "throw." CannotThrow = false; } else if (isCleanupPadScope() && EHPersonality::get(*this).isMSVCXXPersonality()) { // The MSVC++ personality will implicitly terminate the program if an // exception is thrown. An unwind edge cannot be reached. CannotThrow = true; } else { // Otherwise, nowunind callsites will never throw. CannotThrow = Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind); } llvm::BasicBlock *InvokeDest = CannotThrow ? nullptr : getInvokeDest(); SmallVector BundleList; getBundlesForFunclet(Callee, CurrentFuncletPad, BundleList); d3308 1 a3308 1 CS = Builder.CreateCall(Callee, IRCallArgs, BundleList); d3311 1 a3311 2 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, IRCallArgs, BundleList); a3322 6 // Disable inlining inside SEH __try blocks. if (isSEHTryScope()) Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoInline); a3334 4 if (UnusedReturnSize) EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize), SRetPtr.getPointer()); a3359 6 if (llvm::CallInst *Call = dyn_cast(CI)) { const Decl *TargetDecl = CalleeInfo.getCalleeDecl(); if (TargetDecl && TargetDecl->hasAttr()) Call->setTailCallKind(llvm::CallInst::TCK_NoTail); } d3363 2 a3364 7 case ABIArgInfo::Indirect: { RValue ret = convertTempToRValue(SRetPtr, RetTy, SourceLocation()); if (UnusedReturnSize) EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize), SRetPtr.getPointer()); return ret; } d3382 1 a3382 1 Address DestPtr = ReturnValue.getValue(); d3385 1 a3385 1 if (!DestPtr.isValid()) { d3389 1 a3389 1 BuildAggStore(*this, CI, DestPtr, DestIsVolatile); d3404 1 a3404 1 Address DestPtr = ReturnValue.getValue(); d3407 1 a3407 1 if (!DestPtr.isValid()) { d3413 7 a3419 1 Address StorePtr = emitAddressAtOffset(*this, DestPtr, RetAI); a3431 2 const Decl *TargetDecl = CalleeInfo.getCalleeDecl(); d3450 2 a3451 8 Address CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr) { VAListAddr = VE->isMicrosoftABI() ? EmitMSVAListRef(VE->getSubExpr()) : EmitVAListRef(VE->getSubExpr()); QualType Ty = VE->getType(); if (VE->isMicrosoftABI()) return CGM.getTypes().getABIInfo().EmitMSVAArg(*this, VAListAddr, Ty); return CGM.getTypes().getABIInfo().EmitVAArg(*this, VAListAddr, Ty); @ 1.1.1.9.2.1 log @Sync with HEAD @ text @a16 1 #include "CGBlocks.h" a27 1 #include "clang/CodeGen/SwiftCallingConv.h" a29 1 #include "llvm/Analysis/ValueTracking.h" a30 1 #include "llvm/IR/CallingConv.h" d42 1 a42 1 unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) { a46 1 case CC_X86RegCall: return llvm::CallingConv::X86_RegCall; d58 1 a58 4 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; d93 1 a93 1 FTNP->getExtInfo(), {}, RequiredArgs(0)); d100 1 a100 2 SmallVectorImpl ¶mInfos, CanQual FPT, a101 9 // Fill out paramInfos. if (FPT->hasExtParameterInfos() || !paramInfos.empty()) { assert(paramInfos.size() <= prefix.size()); auto protoParamInfos = FPT->getExtParameterInfos(); paramInfos.reserve(prefix.size() + protoParamInfos.size()); paramInfos.resize(prefix.size()); paramInfos.append(protoParamInfos.begin(), protoParamInfos.end()); } d128 1 a128 3 SmallVector paramInfos; RequiredArgs Required = RequiredArgs::forPrototypePlus(FTP, prefix.size(), FD); d130 1 a130 1 appendParameterTypes(CGT, prefix, paramInfos, FTP, FD); a131 1 d134 1 a134 2 FTP->getExtInfo(), paramInfos, Required); a154 3 if (D->hasAttr()) return CC_X86RegCall; a175 6 if (D->hasAttr()) return CC_PreserveMost; if (D->hasAttr()) return CC_PreserveAll; a221 9 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(); } a226 1 SmallVector paramInfos; a228 2 bool PassParams = true; a231 5 // 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, toCXXCtorType(Type)); d240 1 a240 2 if (PassParams) appendParameterTypes(*this, argTypes, paramInfos, FTP, MD); d245 1 a245 2 (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); d255 1 a255 47 paramInfos, required); } static SmallVector getArgTypesForCall(ASTContext &ctx, const CallArgList &args) { SmallVector argTypes; for (auto &arg : args) argTypes.push_back(ctx.getCanonicalParamType(arg.Ty)); return argTypes; } static SmallVector getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) { SmallVector argTypes; for (auto &arg : args) argTypes.push_back(ctx.getCanonicalParamType(arg->getType())); return argTypes; } static void addExtParameterInfosForCall( llvm::SmallVectorImpl ¶mInfos, const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { assert(proto->hasExtParameterInfos()); assert(paramInfos.size() <= prefixArgs); assert(proto->getNumParams() + prefixArgs <= totalArgs); // Add default infos for any prefix args that don't already have infos. paramInfos.resize(prefixArgs); // Add infos for the prototype. auto protoInfos = proto->getExtParameterInfos(); paramInfos.append(protoInfos.begin(), protoInfos.end()); // Add default infos for the variadic arguments. paramInfos.resize(totalArgs); } static llvm::SmallVector getExtParameterInfosForCall(const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { llvm::SmallVector result; if (proto->hasExtParameterInfos()) { addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs); } return result; d270 1 a270 1 RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs, D); a278 2 auto ParamInfos = getExtParameterInfosForCall(FPT.getTypePtr(), 1 + ExtraArgs, ArgTypes.size()); d281 1 a281 1 ParamInfos, Required); d298 2 a299 1 if (CanQual noProto = FTy.getAs()) { d302 1 a302 1 /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All); d305 2 a306 1 return arrangeFreeFunctionType(FTy.castAs(), FD); d331 1 a331 1 for (const auto *I : MD->parameters()) { d348 1 a348 12 /*chainCall=*/false, argTys, einfo, {}, 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); d377 1 a377 1 FTP->getExtInfo(), {}, RequiredArgs(1)); d397 1 a397 2 FunctionType::ExtInfo(CC), {}, RequiredArgs::All); a410 2 llvm::SmallVector paramInfos; a419 4 if (proto->hasExtParameterInfos()) addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs, args.size()); d436 1 a436 2 argTypes, fnType->getExtInfo(), paramInfos, required); d451 1 a451 1 /// A block function is essentially a free function with an d461 4 a464 15 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, nullptr)); } const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args) { d471 1 a471 2 /*chainCall=*/false, argTypes, FunctionType::ExtInfo(), /*paramInfos=*/ {}, RequiredArgs::All); d474 1 d476 7 a482 8 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); } d484 1 a484 3 const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType, ArrayRef argTypes) { d486 2 a487 2 resultType, /*instanceMethod=*/false, /*chainCall=*/false, argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All); d490 3 a492 11 /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *proto, RequiredArgs required) { unsigned numRequiredArgs = (proto->isVariadic() ? required.getNumRequiredArgs() : args.size()); unsigned numPrefixArgs = numRequiredArgs - proto->getNumParams(); auto paramInfos = getExtParameterInfosForCall(proto, numPrefixArgs, args.size()); d494 3 a496 1 auto argTypes = getArgTypesForCall(Context, args); d498 2 a499 1 FunctionType::ExtInfo info = proto->getExtInfo(); d501 2 a502 2 GetReturnType(proto->getReturnType()), /*instanceMethod=*/true, /*chainCall=*/false, argTypes, info, paramInfos, required); d508 1 a508 27 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 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()); a519 1 ArrayRef paramInfos, d524 2 d528 2 a529 2 CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos, required, resultType, argTypes); a535 2 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); d538 1 a538 1 paramInfos, resultType, argTypes, required); d546 1 a546 5 if (info.getCC() != CC_Swift) { getABIInfo().computeInfo(*FI); } else { swiftcall::computeABIInfo(CGM, *FI); } a568 1 ArrayRef paramInfos, d572 2 a573 6 assert(paramInfos.empty() || paramInfos.size() == argTypes.size()); void *buffer = operator new(totalSizeToAlloc( argTypes.size() + 1, paramInfos.size())); a587 1 FI->HasExtParameterInfos = !paramInfos.empty(); a590 2 for (unsigned i = 0, e = paramInfos.size(); i != e; ++i) FI->getExtParameterInfosBuffer()[i] = paramInfos[i]; d637 1 a637 2 : TypeExpansion(TEK_Record), Bases(std::move(Bases)), Fields(std::move(Fields)) {} d776 1 a776 1 QualType Ty, LValue LV, SmallVectorImpl::iterator &AI) { d801 1 a801 1 LValue SubLV = EmitLValueForFieldInitialization(LV, FD); d1223 1 a1223 4 case ABIArgInfo::CoerceAndExpand: IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size(); break; case ABIArgInfo::Expand: d1227 1 a1325 4 case ABIArgInfo::CoerceAndExpand: resultType = retAI.getUnpaddedCoerceAndExpandType(); break; a1392 9 case ABIArgInfo::CoerceAndExpand: { auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) { *ArgTypesIter++ = EltTy; } assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); break; } a1452 1 bool HasAnyX86InterruptAttr = false; a1462 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::Convergent); a1489 1 HasAnyX86InterruptAttr = TargetDecl->hasAttr(); a1490 8 if (auto *AllocSize = TargetDecl->getAttr()) { Optional NumElemsParam; // alloc_size args are base-1, 0 means not present. if (unsigned N = AllocSize->getNumElemsParam()) NumElemsParam = N - 1; FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam() - 1, NumElemsParam); } d1529 1 a1529 1 CodeGenOpts.DisableTailCalls || HasAnyX86InterruptAttr || d1531 2 a1532 3 FuncAttrs.addAttribute( "disable-tail-calls", llvm::toStringRef(DisableTailCalls)); a1535 10 if (!CodeGenOpts.FPDenormalMode.empty()) FuncAttrs.addAttribute("denormal-fp-math", CodeGenOpts.FPDenormalMode); FuncAttrs.addAttribute("no-trapping-math", llvm::toStringRef(CodeGenOpts.NoTrappingMath)); // TODO: Are these all needed? // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags. a1545 11 FuncAttrs.addAttribute("no-signed-zeros-fp-math", llvm::toStringRef(CodeGenOpts.NoSignedZeros)); FuncAttrs.addAttribute( "correctly-rounded-divide-sqrt-fp-math", llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt)); // TODO: Reciprocal estimate codegen options should apply to instructions? std::vector &Recips = getTarget().getTargetOpts().Reciprocals; if (!Recips.empty()) FuncAttrs.addAttribute("reciprocal-estimates", llvm::join(Recips.begin(), Recips.end(), ",")); a1548 2 if (CodeGenOpts.Backchain) FuncAttrs.addAttribute("backchain"); a1596 15 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { // Conservatively, mark all functions and calls in CUDA as convergent // (meaning, they may call an intrinsically convergent op, such as // __syncthreads(), and so can't have certain optimizations applied around // them). LLVM will remove this attribute where it safely can. FuncAttrs.addAttribute(llvm::Attribute::Convergent); // Exceptions aren't supported in CUDA device code. FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Respect -fcuda-flush-denormals-to-zero. if (getLangOpts().CUDADeviceFlushDenormalsToZero) FuncAttrs.addAttribute("nvptx-f32ftz", "true"); } a1622 3 case ABIArgInfo::CoerceAndExpand: break; a1641 2 bool hasUsedSRet = false; a1645 1 hasUsedSRet = true; d1730 1 a1730 2 case ABIArgInfo::CoerceAndExpand: break; a1747 35 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.addAttribute(llvm::Attribute::getWithAlignment(getLLVMContext(), info.second.getQuantity())); } break; } case ParameterABI::SwiftErrorResult: Attrs.addAttribute(llvm::Attribute::SwiftError); break; case ParameterABI::SwiftContext: Attrs.addAttribute(llvm::Attribute::SwiftSelf); break; } a1812 12 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); } }; } d1838 1 a1838 1 SmallVector FnArgs; d1859 1 a1859 1 auto AI = cast(FnArgs[IRFunctionArgs.getSRetArgNo()]); d1947 2 a1948 2 llvm::Value *V = FnArgs[FirstIRArg]; auto AI = cast(V); a2016 19 // LLVM expects swifterror parameters to be used in very restricted // ways. Copy the value into a less-restricted temporary. 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(NormalCleanup, temp, arg); } d2024 7 a2102 23 case ABIArgInfo::CoerceAndExpand: { // Reconstruct into a temporary. Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg)); ArgVals.push_back(ParamValue::forIndirect(alloca)); auto coercionType = ArgI.getCoerceAndExpandType(); alloca = Builder.CreateElementBitCast(alloca, coercionType); auto layout = CGM.getDataLayout().getStructLayout(coercionType); unsigned argIndex = FirstIRArg; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; auto eltAddr = Builder.CreateStructGEP(alloca, i, layout); auto elt = FnArgs[argIndex++]; Builder.CreateStore(elt, eltAddr); } assert(argIndex == FirstIRArg + NumIRArgs); break; } d2167 1 a2167 1 SmallVector InstsToKill; d2180 1 a2180 1 InstsToKill.push_back(bitcast); d2213 1 a2213 1 InstsToKill.push_back(prev); d2220 1 a2220 1 InstsToKill.push_back(call); d2226 1 a2226 1 InstsToKill.push_back(bitcast); d2231 3 a2233 2 for (auto *I : InstsToKill) I->eraseFromParent(); a2464 16 #ifndef NDEBUG // Type::isObjCRetainabletype has to be called on a QualType that hasn't // been stripped of the typedefs, so we cannot use RetTy here. Get the // original return type of FunctionDecl, CurCodeDecl, and BlockDecl from // CurCodeDecl or BlockInfo. QualType RT; if (auto *FD = dyn_cast(CurCodeDecl)) RT = FD->getReturnType(); else if (auto *MD = dyn_cast(CurCodeDecl)) RT = MD->getReturnType(); else if (isa(CurCodeDecl)) RT = BlockInfo->BlockExpression->getFunctionType()->getReturnType(); else llvm_unreachable("Unexpected function/method type"); d2467 1 a2467 2 RT->isObjCRetainableType()); #endif a2475 34 case ABIArgInfo::CoerceAndExpand: { auto coercionType = RetAI.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); // Load all of the coerced elements out into results. llvm::SmallVector results; Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType); for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { auto coercedEltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(coercedEltType)) continue; auto eltAddr = Builder.CreateStructGEP(addr, i, layout); auto elt = Builder.CreateLoad(eltAddr); results.push_back(elt); } // If we have one result, it's the single direct result type. if (results.size() == 1) { RV = results[0]; // Otherwise, we need to make a first-class aggregate. } else { // Construct a return type that lacks padding elements. llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType(); RV = llvm::UndefValue::get(returnType); for (unsigned i = 0, e = results.size(); i != e; ++i) { RV = Builder.CreateInsertValue(RV, results[i], i); } } break; } d2492 1 a2492 1 SanitizerHandler::NonnullReturn, StaticData, None); d2514 3 a2516 2 llvm::Type *IRPtrTy = IRTy->getPointerTo(); llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo()); a2520 1 Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align); d2539 13 d2555 1 a2555 24 // GetAddrOfLocalVar returns a pointer-to-pointer for references, // but the argument needs to be the original pointer. if (type->isReferenceType()) { args.add(RValue::get(Builder.CreateLoad(local)), type); // In ARC, move out of consumed arguments so that the release cleanup // entered by StartFunction doesn't cause an over-release. This isn't // optimal -O0 code generation, but it should get cleaned up when // optimization is enabled. This also assumes that delegate calls are // performed exactly once for a set of arguments, but that should be safe. } else if (getLangOpts().ObjCAutoRefCount && param->hasAttr() && type->isObjCRetainableType()) { llvm::Value *ptr = Builder.CreateLoad(local); auto null = llvm::ConstantPointerNull::get(cast(ptr->getType())); Builder.CreateStore(null, local); args.add(RValue::get(ptr), type); // For the most part, we just need to load the alloca, except that // aggregate r-values are actually pointers to temporaries. } else { args.add(convertTempToRValue(local, type, loc), type); } d2562 4 d2578 1 a2578 1 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer()); d2718 1 a2718 1 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer()); d2789 1 a2789 1 assert(!StackBase); d2826 1 a2826 1 SanitizerHandler::NonnullArg, StaticData, None); d2832 1 a2832 2 const FunctionDecl *CalleeDecl, unsigned ParamsToSkip, EvaluationOrder Order) { d2850 4 a2853 12 // because arguments are destroyed left to right in the callee. As a special // case, there are certain language constructs that require left-to-right // evaluation, and in those cases we consider the evaluation order requirement // to trump the "destruction order is reverse construction order" guarantee. bool LeftToRight = CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee() ? Order == EvaluationOrder::ForceLeftToRight : Order != EvaluationOrder::ForceRightToLeft; // Insert a stack save if we're going to need any inalloca args. bool HasInAllocaArgs = false; if (CGM.getTarget().getCXXABI().isMicrosoft()) { a2860 1 } d2862 9 a2870 11 // Evaluate each argument in the appropriate order. size_t CallArgsStart = Args.size(); for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) { unsigned Idx = LeftToRight ? I : E - I - 1; CallExpr::const_arg_iterator Arg = ArgRange.begin() + Idx; if (!LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg); EmitCallArg(Args, *Arg, ArgTypes[Idx]); EmitNonNullArgCheck(Args.back().RV, ArgTypes[Idx], (*Arg)->getExprLoc(), CalleeDecl, ParamsToSkip + Idx); if (LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg); } a2871 1 if (!LeftToRight) { d2875 10 d2926 1 a2926 1 assert(getContext().hasSameUnqualifiedType(E->getType(), type)); d3049 11 d3063 2 a3064 1 getBundlesForFunclet(llvm::Value *Callee, llvm::Instruction *CurrentFuncletPad, d3066 1 a3066 2 // There is no need for a funclet operand bundle if we aren't inside a // funclet. a3077 13 /// Emits a simple call (never an invoke) to the given runtime function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { SmallVector BundleList; getBundlesForFunclet(callee, CurrentFuncletPad, BundleList); llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList, name); call->setCallingConv(getRuntimeCC()); return call; } d3101 2 a3102 1 /// Emits a call or invoke instruction to the given nullary runtime function. a3125 2 SmallVector BundleList; getBundlesForFunclet(Callee, CurrentFuncletPad, BundleList); d3129 1 a3129 1 Inst = Builder.CreateCall(Callee, Args, BundleList, Name); d3132 1 a3132 2 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList, Name); d3160 1 a3160 1 const CGCallee &Callee, d3163 1 a3166 2 assert(Callee.isOrdinary()); d3172 3 a3174 3 llvm::FunctionType *IRFuncTy = Callee.getFunctionType(); // 1. Set up the arguments. d3211 1 a3211 1 if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) { d3225 1 a3225 1 } else if (RetAI.isInAlloca()) { a3230 4 Address swiftErrorTemp = Address::invalid(); Address swiftErrorArg = Address::invalid(); // Translate all of the arguments as necessary to match the IR lowering. a3336 19 // Implement swifterror by copying into a new swifterror argument. // We'll write back in the normal path out of the call. if (CallInfo.getExtParameterInfo(ArgNo).getABI() == ParameterABI::SwiftErrorResult) { assert(!swiftErrorTemp.isValid() && "multiple swifterror args"); QualType pointeeTy = I->Ty->getPointeeType(); swiftErrorArg = Address(V, getContext().getTypeAlignInChars(pointeeTy)); swiftErrorTemp = CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp"); V = swiftErrorTemp.getPointer(); cast(V)->setSwiftError(true); llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg); Builder.CreateStore(errorValue, swiftErrorTemp); } a3346 1 a3404 45 case ABIArgInfo::CoerceAndExpand: { auto coercionType = ArgInfo.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); llvm::Value *tempSize = nullptr; Address addr = Address::invalid(); if (RV.isAggregate()) { addr = RV.getAggregateAddress(); } else { assert(RV.isScalar()); // complex should always just be direct llvm::Type *scalarType = RV.getScalarVal()->getType(); auto scalarSize = CGM.getDataLayout().getTypeAllocSize(scalarType); auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType); tempSize = llvm::ConstantInt::get(CGM.Int64Ty, scalarSize); // Materialize to a temporary. addr = CreateTempAlloca(RV.getScalarVal()->getType(), CharUnits::fromQuantity(std::max(layout->getAlignment(), scalarAlign))); EmitLifetimeStart(scalarSize, addr.getPointer()); Builder.CreateStore(RV.getScalarVal(), addr); } addr = Builder.CreateElementBitCast(addr, coercionType); unsigned IRArgPos = FirstIRArg; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; Address eltAddr = Builder.CreateStructGEP(addr, i, layout); llvm::Value *elt = Builder.CreateLoad(eltAddr); IRCallArgs[IRArgPos++] = elt; } assert(IRArgPos == FirstIRArg + NumIRArgs); if (tempSize) { EmitLifetimeEnd(tempSize, addr.getPointer()); } break; } a3412 3 llvm::Value *CalleePtr = Callee.getFunctionPointer(); // If we're using inalloca, set up that argument. d3420 4 a3423 3 unsigned CalleeAS = CalleePtr->getType()->getPointerAddressSpace(); auto FnTy = getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS); CalleePtr = Builder.CreateBitCast(CalleePtr, FnTy); d3447 2 a3448 1 // 2. Prepare the function pointer. d3450 21 a3470 32 // If the callee is a bitcast of a non-variadic function to have a // variadic function pointer type, check to see if we can remove the // bitcast. This comes up with unprototyped functions. // // This makes the IR nicer, but more importantly it ensures that we // can inline the function at -O0 if it is marked always_inline. auto simplifyVariadicCallee = [](llvm::Value *Ptr) -> llvm::Value* { llvm::FunctionType *CalleeFT = cast(Ptr->getType()->getPointerElementType()); if (!CalleeFT->isVarArg()) return Ptr; llvm::ConstantExpr *CE = dyn_cast(Ptr); if (!CE || CE->getOpcode() != llvm::Instruction::BitCast) return Ptr; llvm::Function *OrigFn = dyn_cast(CE->getOperand(0)); if (!OrigFn) return Ptr; llvm::FunctionType *OrigFT = OrigFn->getFunctionType(); // If the original type is variadic, or if any of the component types // disagree, we cannot remove the cast. if (OrigFT->isVarArg() || OrigFT->getNumParams() != CalleeFT->getNumParams() || OrigFT->getReturnType() != CalleeFT->getReturnType()) return Ptr; for (unsigned i = 0, e = OrigFT->getNumParams(); i != e; ++i) if (OrigFT->getParamType(i) != CalleeFT->getParamType(i)) return Ptr; d3472 7 a3478 10 return OrigFn; }; CalleePtr = simplifyVariadicCallee(CalleePtr); // 3. Perform the actual call. // Deactivate any cleanups that we're supposed to do immediately before // the call. if (!CallArgs.getCleanupsToDeactivate().empty()) deactivateArgCleanupsBeforeCall(*this, CallArgs); a3479 5 // Assert that the arguments we computed match up. The IR verifier // will catch this, but this is a common enough source of problems // during IRGen changes that it's way better for debugging to catch // it ourselves here. #ifndef NDEBUG a3488 1 #endif a3489 1 // Compute the calling convention and attributes. d3492 1 a3492 2 CGM.ConstructAttributeList(CalleePtr->getName(), CallInfo, Callee.getAbstractInfo(), a3497 22 // Apply some call-site-specific attributes. // TODO: work this into building the attribute set. // Apply always_inline to all calls within flatten functions. // FIXME: should this really take priority over __try, below? if (CurCodeDecl && CurCodeDecl->hasAttr() && !(Callee.getAbstractInfo().getCalleeDecl() && Callee.getAbstractInfo().getCalleeDecl()->hasAttr())) { Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::AlwaysInline); } // Disable inlining inside SEH __try blocks. if (isSEHTryScope()) { Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoInline); } // Decide whether to use a call or an invoke. d3500 1 a3500 1 // SEH cares about asynchronous exceptions, so everything can "throw." d3505 1 a3505 2 // exception is thrown during a cleanup outside of a try/catch. // We don't need to model anything in IR to get this behavior. d3508 1 a3508 1 // Otherwise, nounwind call sites will never throw. d3515 1 a3515 1 getBundlesForFunclet(CalleePtr, CurrentFuncletPad, BundleList); a3516 1 // Emit the actual call/invoke instruction. d3519 1 a3519 1 CS = Builder.CreateCall(CalleePtr, IRCallArgs, BundleList); d3522 1 a3522 1 CS = Builder.CreateInvoke(CalleePtr, Cont, InvokeDest, IRCallArgs, a3525 1 llvm::Instruction *CI = CS.getInstruction(); d3527 13 a3539 1 *callOrInvoke = CI; a3540 1 // Apply the attributes and calling convention. a3543 12 // Apply various metadata. if (!CI->getType()->isVoidTy()) CI->setName("call"); // Insert instrumentation or attach profile metadata at indirect call sites. // For more details, see the comment before the definition of // IPVK_IndirectCallTarget in InstrProfData.inc. if (!CS.getCalledFunction()) PGO.valueProfile(Builder, llvm::IPVK_IndirectCallTarget, CI, CalleePtr); d3547 1 a3547 10 AddObjCARCExceptionMetadata(CI); // Suppress tail calls if requested. if (llvm::CallInst *Call = dyn_cast(CI)) { const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl(); if (TargetDecl && TargetDecl->hasAttr()) Call->setTailCallKind(llvm::CallInst::TCK_NoTail); } // 4. Finish the call. d3550 1 a3550 1 // insertion point; this allows the rest of IRGen to discard d3569 3 a3571 5 // Perform the swifterror writeback. if (swiftErrorTemp.isValid()) { llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp); Builder.CreateStore(errorResult, swiftErrorArg); } d3573 2 a3574 2 // Emit any call-associated writebacks immediately. Arguably this // should happen after any return-value munging. d3582 6 a3587 1 // Extract the return value. a3589 25 case ABIArgInfo::CoerceAndExpand: { auto coercionType = RetAI.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); Address addr = SRetPtr; addr = Builder.CreateElementBitCast(addr, coercionType); assert(CI->getType() == RetAI.getUnpaddedCoerceAndExpandType()); bool requiresExtract = isa(CI->getType()); unsigned unpaddedIndex = 0; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; Address eltAddr = Builder.CreateStructGEP(addr, i, layout); llvm::Value *elt = CI; if (requiresExtract) elt = Builder.CreateExtractValue(elt, unpaddedIndex++); else assert(unpaddedIndex == 0); Builder.CreateStore(elt, eltAddr); } // FALLTHROUGH } d3659 2 a3660 2 // Emit the assume_aligned check on the return value. const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl(); @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @a16 1 #include "CGBlocks.h" a27 1 #include "clang/CodeGen/SwiftCallingConv.h" a29 1 #include "llvm/Analysis/ValueTracking.h" a30 1 #include "llvm/IR/CallingConv.h" d42 1 a42 1 unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) { a46 1 case CC_X86RegCall: return llvm::CallingConv::X86_RegCall; d58 1 a58 4 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; d93 1 a93 1 FTNP->getExtInfo(), {}, RequiredArgs(0)); d100 1 a100 2 SmallVectorImpl ¶mInfos, CanQual FPT, a101 9 // Fill out paramInfos. if (FPT->hasExtParameterInfos() || !paramInfos.empty()) { assert(paramInfos.size() <= prefix.size()); auto protoParamInfos = FPT->getExtParameterInfos(); paramInfos.reserve(prefix.size() + protoParamInfos.size()); paramInfos.resize(prefix.size()); paramInfos.append(protoParamInfos.begin(), protoParamInfos.end()); } d128 1 a128 3 SmallVector paramInfos; RequiredArgs Required = RequiredArgs::forPrototypePlus(FTP, prefix.size(), FD); d130 1 a130 1 appendParameterTypes(CGT, prefix, paramInfos, FTP, FD); a131 1 d134 1 a134 2 FTP->getExtInfo(), paramInfos, Required); a154 3 if (D->hasAttr()) return CC_X86RegCall; a175 6 if (D->hasAttr()) return CC_PreserveMost; if (D->hasAttr()) return CC_PreserveAll; a221 9 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(); } a226 1 SmallVector paramInfos; a228 2 bool PassParams = true; a231 5 // 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, toCXXCtorType(Type)); d240 1 a240 2 if (PassParams) appendParameterTypes(*this, argTypes, paramInfos, FTP, MD); d245 1 a245 2 (PassParams && MD->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); d255 1 a255 47 paramInfos, required); } static SmallVector getArgTypesForCall(ASTContext &ctx, const CallArgList &args) { SmallVector argTypes; for (auto &arg : args) argTypes.push_back(ctx.getCanonicalParamType(arg.Ty)); return argTypes; } static SmallVector getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) { SmallVector argTypes; for (auto &arg : args) argTypes.push_back(ctx.getCanonicalParamType(arg->getType())); return argTypes; } static void addExtParameterInfosForCall( llvm::SmallVectorImpl ¶mInfos, const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { assert(proto->hasExtParameterInfos()); assert(paramInfos.size() <= prefixArgs); assert(proto->getNumParams() + prefixArgs <= totalArgs); // Add default infos for any prefix args that don't already have infos. paramInfos.resize(prefixArgs); // Add infos for the prototype. auto protoInfos = proto->getExtParameterInfos(); paramInfos.append(protoInfos.begin(), protoInfos.end()); // Add default infos for the variadic arguments. paramInfos.resize(totalArgs); } static llvm::SmallVector getExtParameterInfosForCall(const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { llvm::SmallVector result; if (proto->hasExtParameterInfos()) { addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs); } return result; d270 1 a270 1 RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs, D); a278 2 auto ParamInfos = getExtParameterInfosForCall(FPT.getTypePtr(), 1 + ExtraArgs, ArgTypes.size()); d281 1 a281 1 ParamInfos, Required); d298 2 a299 1 if (CanQual noProto = FTy.getAs()) { d302 1 a302 1 /*chainCall=*/false, None, noProto->getExtInfo(), {},RequiredArgs::All); d305 2 a306 1 return arrangeFreeFunctionType(FTy.castAs(), FD); d331 1 a331 1 for (const auto *I : MD->parameters()) { d348 1 a348 12 /*chainCall=*/false, argTys, einfo, {}, 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); d377 1 a377 1 FTP->getExtInfo(), {}, RequiredArgs(1)); d397 1 a397 2 FunctionType::ExtInfo(CC), {}, RequiredArgs::All); a410 2 llvm::SmallVector paramInfos; a419 4 if (proto->hasExtParameterInfos()) addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs, args.size()); d436 1 a436 2 argTypes, fnType->getExtInfo(), paramInfos, required); d451 1 a451 1 /// A block function is essentially a free function with an d461 4 a464 15 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, nullptr)); } const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args) { d471 1 a471 2 /*chainCall=*/false, argTypes, FunctionType::ExtInfo(), /*paramInfos=*/ {}, RequiredArgs::All); d474 1 d476 7 a482 8 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); } d484 1 a484 3 const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType, ArrayRef argTypes) { d486 2 a487 2 resultType, /*instanceMethod=*/false, /*chainCall=*/false, argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All); d490 3 a492 11 /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *proto, RequiredArgs required) { unsigned numRequiredArgs = (proto->isVariadic() ? required.getNumRequiredArgs() : args.size()); unsigned numPrefixArgs = numRequiredArgs - proto->getNumParams(); auto paramInfos = getExtParameterInfosForCall(proto, numPrefixArgs, args.size()); d494 3 a496 1 auto argTypes = getArgTypesForCall(Context, args); d498 2 a499 1 FunctionType::ExtInfo info = proto->getExtInfo(); d501 2 a502 2 GetReturnType(proto->getReturnType()), /*instanceMethod=*/true, /*chainCall=*/false, argTypes, info, paramInfos, required); d508 1 a508 27 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 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()); a519 1 ArrayRef paramInfos, d524 2 d528 2 a529 2 CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos, required, resultType, argTypes); a535 2 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); d538 1 a538 1 paramInfos, resultType, argTypes, required); d546 1 a546 5 if (info.getCC() != CC_Swift) { getABIInfo().computeInfo(*FI); } else { swiftcall::computeABIInfo(CGM, *FI); } a568 1 ArrayRef paramInfos, d572 2 a573 6 assert(paramInfos.empty() || paramInfos.size() == argTypes.size()); void *buffer = operator new(totalSizeToAlloc( argTypes.size() + 1, paramInfos.size())); a587 1 FI->HasExtParameterInfos = !paramInfos.empty(); a590 2 for (unsigned i = 0, e = paramInfos.size(); i != e; ++i) FI->getExtParameterInfosBuffer()[i] = paramInfos[i]; d637 1 a637 2 : TypeExpansion(TEK_Record), Bases(std::move(Bases)), Fields(std::move(Fields)) {} d776 1 a776 1 QualType Ty, LValue LV, SmallVectorImpl::iterator &AI) { d801 1 a801 1 LValue SubLV = EmitLValueForFieldInitialization(LV, FD); d1223 1 a1223 4 case ABIArgInfo::CoerceAndExpand: IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size(); break; case ABIArgInfo::Expand: d1227 1 a1325 4 case ABIArgInfo::CoerceAndExpand: resultType = retAI.getUnpaddedCoerceAndExpandType(); break; a1392 9 case ABIArgInfo::CoerceAndExpand: { auto ArgTypesIter = ArgTypes.begin() + FirstIRArg; for (auto EltTy : ArgInfo.getCoerceAndExpandTypeSequence()) { *ArgTypesIter++ = EltTy; } assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs); break; } a1452 1 bool HasAnyX86InterruptAttr = false; a1462 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::Convergent); a1489 1 HasAnyX86InterruptAttr = TargetDecl->hasAttr(); a1490 8 if (auto *AllocSize = TargetDecl->getAttr()) { Optional NumElemsParam; // alloc_size args are base-1, 0 means not present. if (unsigned N = AllocSize->getNumElemsParam()) NumElemsParam = N - 1; FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam() - 1, NumElemsParam); } d1529 1 a1529 1 CodeGenOpts.DisableTailCalls || HasAnyX86InterruptAttr || d1531 2 a1532 3 FuncAttrs.addAttribute( "disable-tail-calls", llvm::toStringRef(DisableTailCalls)); a1535 10 if (!CodeGenOpts.FPDenormalMode.empty()) FuncAttrs.addAttribute("denormal-fp-math", CodeGenOpts.FPDenormalMode); FuncAttrs.addAttribute("no-trapping-math", llvm::toStringRef(CodeGenOpts.NoTrappingMath)); // TODO: Are these all needed? // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags. a1545 11 FuncAttrs.addAttribute("no-signed-zeros-fp-math", llvm::toStringRef(CodeGenOpts.NoSignedZeros)); FuncAttrs.addAttribute( "correctly-rounded-divide-sqrt-fp-math", llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt)); // TODO: Reciprocal estimate codegen options should apply to instructions? std::vector &Recips = getTarget().getTargetOpts().Reciprocals; if (!Recips.empty()) FuncAttrs.addAttribute("reciprocal-estimates", llvm::join(Recips.begin(), Recips.end(), ",")); a1548 2 if (CodeGenOpts.Backchain) FuncAttrs.addAttribute("backchain"); a1596 15 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { // Conservatively, mark all functions and calls in CUDA as convergent // (meaning, they may call an intrinsically convergent op, such as // __syncthreads(), and so can't have certain optimizations applied around // them). LLVM will remove this attribute where it safely can. FuncAttrs.addAttribute(llvm::Attribute::Convergent); // Exceptions aren't supported in CUDA device code. FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Respect -fcuda-flush-denormals-to-zero. if (getLangOpts().CUDADeviceFlushDenormalsToZero) FuncAttrs.addAttribute("nvptx-f32ftz", "true"); } a1622 3 case ABIArgInfo::CoerceAndExpand: break; a1641 2 bool hasUsedSRet = false; a1645 1 hasUsedSRet = true; d1730 1 a1730 2 case ABIArgInfo::CoerceAndExpand: break; a1747 35 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.addAttribute(llvm::Attribute::getWithAlignment(getLLVMContext(), info.second.getQuantity())); } break; } case ParameterABI::SwiftErrorResult: Attrs.addAttribute(llvm::Attribute::SwiftError); break; case ParameterABI::SwiftContext: Attrs.addAttribute(llvm::Attribute::SwiftSelf); break; } a1812 12 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); } }; } d1838 1 a1838 1 SmallVector FnArgs; d1859 1 a1859 1 auto AI = cast(FnArgs[IRFunctionArgs.getSRetArgNo()]); d1947 2 a1948 2 llvm::Value *V = FnArgs[FirstIRArg]; auto AI = cast(V); a2016 19 // LLVM expects swifterror parameters to be used in very restricted // ways. Copy the value into a less-restricted temporary. 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(NormalCleanup, temp, arg); } d2024 7 a2102 23 case ABIArgInfo::CoerceAndExpand: { // Reconstruct into a temporary. Address alloca = CreateMemTemp(Ty, getContext().getDeclAlign(Arg)); ArgVals.push_back(ParamValue::forIndirect(alloca)); auto coercionType = ArgI.getCoerceAndExpandType(); alloca = Builder.CreateElementBitCast(alloca, coercionType); auto layout = CGM.getDataLayout().getStructLayout(coercionType); unsigned argIndex = FirstIRArg; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; auto eltAddr = Builder.CreateStructGEP(alloca, i, layout); auto elt = FnArgs[argIndex++]; Builder.CreateStore(elt, eltAddr); } assert(argIndex == FirstIRArg + NumIRArgs); break; } d2167 1 a2167 1 SmallVector InstsToKill; d2180 1 a2180 1 InstsToKill.push_back(bitcast); d2213 1 a2213 1 InstsToKill.push_back(prev); d2220 1 a2220 1 InstsToKill.push_back(call); d2226 1 a2226 1 InstsToKill.push_back(bitcast); d2231 3 a2233 2 for (auto *I : InstsToKill) I->eraseFromParent(); a2464 16 #ifndef NDEBUG // Type::isObjCRetainabletype has to be called on a QualType that hasn't // been stripped of the typedefs, so we cannot use RetTy here. Get the // original return type of FunctionDecl, CurCodeDecl, and BlockDecl from // CurCodeDecl or BlockInfo. QualType RT; if (auto *FD = dyn_cast(CurCodeDecl)) RT = FD->getReturnType(); else if (auto *MD = dyn_cast(CurCodeDecl)) RT = MD->getReturnType(); else if (isa(CurCodeDecl)) RT = BlockInfo->BlockExpression->getFunctionType()->getReturnType(); else llvm_unreachable("Unexpected function/method type"); d2467 1 a2467 2 RT->isObjCRetainableType()); #endif a2475 34 case ABIArgInfo::CoerceAndExpand: { auto coercionType = RetAI.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); // Load all of the coerced elements out into results. llvm::SmallVector results; Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType); for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { auto coercedEltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(coercedEltType)) continue; auto eltAddr = Builder.CreateStructGEP(addr, i, layout); auto elt = Builder.CreateLoad(eltAddr); results.push_back(elt); } // If we have one result, it's the single direct result type. if (results.size() == 1) { RV = results[0]; // Otherwise, we need to make a first-class aggregate. } else { // Construct a return type that lacks padding elements. llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType(); RV = llvm::UndefValue::get(returnType); for (unsigned i = 0, e = results.size(); i != e; ++i) { RV = Builder.CreateInsertValue(RV, results[i], i); } } break; } d2492 1 a2492 1 SanitizerHandler::NonnullReturn, StaticData, None); d2514 3 a2516 2 llvm::Type *IRPtrTy = IRTy->getPointerTo(); llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo()); a2520 1 Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align); d2539 13 d2555 1 a2555 24 // GetAddrOfLocalVar returns a pointer-to-pointer for references, // but the argument needs to be the original pointer. if (type->isReferenceType()) { args.add(RValue::get(Builder.CreateLoad(local)), type); // In ARC, move out of consumed arguments so that the release cleanup // entered by StartFunction doesn't cause an over-release. This isn't // optimal -O0 code generation, but it should get cleaned up when // optimization is enabled. This also assumes that delegate calls are // performed exactly once for a set of arguments, but that should be safe. } else if (getLangOpts().ObjCAutoRefCount && param->hasAttr() && type->isObjCRetainableType()) { llvm::Value *ptr = Builder.CreateLoad(local); auto null = llvm::ConstantPointerNull::get(cast(ptr->getType())); Builder.CreateStore(null, local); args.add(RValue::get(ptr), type); // For the most part, we just need to load the alloca, except that // aggregate r-values are actually pointers to temporaries. } else { args.add(convertTempToRValue(local, type, loc), type); } d2562 4 d2578 1 a2578 1 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer()); d2718 1 a2718 1 bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer()); d2789 1 a2789 1 assert(!StackBase); d2826 1 a2826 1 SanitizerHandler::NonnullArg, StaticData, None); d2832 1 a2832 2 const FunctionDecl *CalleeDecl, unsigned ParamsToSkip, EvaluationOrder Order) { d2850 4 a2853 12 // because arguments are destroyed left to right in the callee. As a special // case, there are certain language constructs that require left-to-right // evaluation, and in those cases we consider the evaluation order requirement // to trump the "destruction order is reverse construction order" guarantee. bool LeftToRight = CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee() ? Order == EvaluationOrder::ForceLeftToRight : Order != EvaluationOrder::ForceRightToLeft; // Insert a stack save if we're going to need any inalloca args. bool HasInAllocaArgs = false; if (CGM.getTarget().getCXXABI().isMicrosoft()) { a2860 1 } d2862 9 a2870 11 // Evaluate each argument in the appropriate order. size_t CallArgsStart = Args.size(); for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) { unsigned Idx = LeftToRight ? I : E - I - 1; CallExpr::const_arg_iterator Arg = ArgRange.begin() + Idx; if (!LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg); EmitCallArg(Args, *Arg, ArgTypes[Idx]); EmitNonNullArgCheck(Args.back().RV, ArgTypes[Idx], (*Arg)->getExprLoc(), CalleeDecl, ParamsToSkip + Idx); if (LeftToRight) MaybeEmitImplicitObjectSize(Idx, *Arg); } a2871 1 if (!LeftToRight) { d2875 10 d2926 1 a2926 1 assert(getContext().hasSameUnqualifiedType(E->getType(), type)); d3049 11 d3063 2 a3064 1 getBundlesForFunclet(llvm::Value *Callee, llvm::Instruction *CurrentFuncletPad, d3066 1 a3066 2 // There is no need for a funclet operand bundle if we aren't inside a // funclet. a3077 13 /// Emits a simple call (never an invoke) to the given runtime function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { SmallVector BundleList; getBundlesForFunclet(callee, CurrentFuncletPad, BundleList); llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList, name); call->setCallingConv(getRuntimeCC()); return call; } d3101 2 a3102 1 /// Emits a call or invoke instruction to the given nullary runtime function. a3125 2 SmallVector BundleList; getBundlesForFunclet(Callee, CurrentFuncletPad, BundleList); d3129 1 a3129 1 Inst = Builder.CreateCall(Callee, Args, BundleList, Name); d3132 1 a3132 2 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList, Name); d3160 1 a3160 1 const CGCallee &Callee, d3163 1 a3166 2 assert(Callee.isOrdinary()); d3172 3 a3174 3 llvm::FunctionType *IRFuncTy = Callee.getFunctionType(); // 1. Set up the arguments. d3211 1 a3211 1 if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) { d3225 1 a3225 1 } else if (RetAI.isInAlloca()) { a3230 4 Address swiftErrorTemp = Address::invalid(); Address swiftErrorArg = Address::invalid(); // Translate all of the arguments as necessary to match the IR lowering. a3336 19 // Implement swifterror by copying into a new swifterror argument. // We'll write back in the normal path out of the call. if (CallInfo.getExtParameterInfo(ArgNo).getABI() == ParameterABI::SwiftErrorResult) { assert(!swiftErrorTemp.isValid() && "multiple swifterror args"); QualType pointeeTy = I->Ty->getPointeeType(); swiftErrorArg = Address(V, getContext().getTypeAlignInChars(pointeeTy)); swiftErrorTemp = CreateMemTemp(pointeeTy, getPointerAlign(), "swifterror.temp"); V = swiftErrorTemp.getPointer(); cast(V)->setSwiftError(true); llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg); Builder.CreateStore(errorValue, swiftErrorTemp); } a3346 1 a3404 45 case ABIArgInfo::CoerceAndExpand: { auto coercionType = ArgInfo.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); llvm::Value *tempSize = nullptr; Address addr = Address::invalid(); if (RV.isAggregate()) { addr = RV.getAggregateAddress(); } else { assert(RV.isScalar()); // complex should always just be direct llvm::Type *scalarType = RV.getScalarVal()->getType(); auto scalarSize = CGM.getDataLayout().getTypeAllocSize(scalarType); auto scalarAlign = CGM.getDataLayout().getPrefTypeAlignment(scalarType); tempSize = llvm::ConstantInt::get(CGM.Int64Ty, scalarSize); // Materialize to a temporary. addr = CreateTempAlloca(RV.getScalarVal()->getType(), CharUnits::fromQuantity(std::max(layout->getAlignment(), scalarAlign))); EmitLifetimeStart(scalarSize, addr.getPointer()); Builder.CreateStore(RV.getScalarVal(), addr); } addr = Builder.CreateElementBitCast(addr, coercionType); unsigned IRArgPos = FirstIRArg; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; Address eltAddr = Builder.CreateStructGEP(addr, i, layout); llvm::Value *elt = Builder.CreateLoad(eltAddr); IRCallArgs[IRArgPos++] = elt; } assert(IRArgPos == FirstIRArg + NumIRArgs); if (tempSize) { EmitLifetimeEnd(tempSize, addr.getPointer()); } break; } a3412 3 llvm::Value *CalleePtr = Callee.getFunctionPointer(); // If we're using inalloca, set up that argument. d3420 4 a3423 3 unsigned CalleeAS = CalleePtr->getType()->getPointerAddressSpace(); auto FnTy = getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS); CalleePtr = Builder.CreateBitCast(CalleePtr, FnTy); d3447 2 a3448 1 // 2. Prepare the function pointer. d3450 21 a3470 32 // If the callee is a bitcast of a non-variadic function to have a // variadic function pointer type, check to see if we can remove the // bitcast. This comes up with unprototyped functions. // // This makes the IR nicer, but more importantly it ensures that we // can inline the function at -O0 if it is marked always_inline. auto simplifyVariadicCallee = [](llvm::Value *Ptr) -> llvm::Value* { llvm::FunctionType *CalleeFT = cast(Ptr->getType()->getPointerElementType()); if (!CalleeFT->isVarArg()) return Ptr; llvm::ConstantExpr *CE = dyn_cast(Ptr); if (!CE || CE->getOpcode() != llvm::Instruction::BitCast) return Ptr; llvm::Function *OrigFn = dyn_cast(CE->getOperand(0)); if (!OrigFn) return Ptr; llvm::FunctionType *OrigFT = OrigFn->getFunctionType(); // If the original type is variadic, or if any of the component types // disagree, we cannot remove the cast. if (OrigFT->isVarArg() || OrigFT->getNumParams() != CalleeFT->getNumParams() || OrigFT->getReturnType() != CalleeFT->getReturnType()) return Ptr; for (unsigned i = 0, e = OrigFT->getNumParams(); i != e; ++i) if (OrigFT->getParamType(i) != CalleeFT->getParamType(i)) return Ptr; d3472 7 a3478 10 return OrigFn; }; CalleePtr = simplifyVariadicCallee(CalleePtr); // 3. Perform the actual call. // Deactivate any cleanups that we're supposed to do immediately before // the call. if (!CallArgs.getCleanupsToDeactivate().empty()) deactivateArgCleanupsBeforeCall(*this, CallArgs); a3479 5 // Assert that the arguments we computed match up. The IR verifier // will catch this, but this is a common enough source of problems // during IRGen changes that it's way better for debugging to catch // it ourselves here. #ifndef NDEBUG a3488 1 #endif a3489 1 // Compute the calling convention and attributes. d3492 1 a3492 2 CGM.ConstructAttributeList(CalleePtr->getName(), CallInfo, Callee.getAbstractInfo(), a3497 22 // Apply some call-site-specific attributes. // TODO: work this into building the attribute set. // Apply always_inline to all calls within flatten functions. // FIXME: should this really take priority over __try, below? if (CurCodeDecl && CurCodeDecl->hasAttr() && !(Callee.getAbstractInfo().getCalleeDecl() && Callee.getAbstractInfo().getCalleeDecl()->hasAttr())) { Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::AlwaysInline); } // Disable inlining inside SEH __try blocks. if (isSEHTryScope()) { Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoInline); } // Decide whether to use a call or an invoke. d3500 1 a3500 1 // SEH cares about asynchronous exceptions, so everything can "throw." d3505 1 a3505 2 // exception is thrown during a cleanup outside of a try/catch. // We don't need to model anything in IR to get this behavior. d3508 1 a3508 1 // Otherwise, nounwind call sites will never throw. d3515 1 a3515 1 getBundlesForFunclet(CalleePtr, CurrentFuncletPad, BundleList); a3516 1 // Emit the actual call/invoke instruction. d3519 1 a3519 1 CS = Builder.CreateCall(CalleePtr, IRCallArgs, BundleList); d3522 1 a3522 1 CS = Builder.CreateInvoke(CalleePtr, Cont, InvokeDest, IRCallArgs, a3525 1 llvm::Instruction *CI = CS.getInstruction(); d3527 13 a3539 1 *callOrInvoke = CI; a3540 1 // Apply the attributes and calling convention. a3543 12 // Apply various metadata. if (!CI->getType()->isVoidTy()) CI->setName("call"); // Insert instrumentation or attach profile metadata at indirect call sites. // For more details, see the comment before the definition of // IPVK_IndirectCallTarget in InstrProfData.inc. if (!CS.getCalledFunction()) PGO.valueProfile(Builder, llvm::IPVK_IndirectCallTarget, CI, CalleePtr); d3547 1 a3547 10 AddObjCARCExceptionMetadata(CI); // Suppress tail calls if requested. if (llvm::CallInst *Call = dyn_cast(CI)) { const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl(); if (TargetDecl && TargetDecl->hasAttr()) Call->setTailCallKind(llvm::CallInst::TCK_NoTail); } // 4. Finish the call. d3550 1 a3550 1 // insertion point; this allows the rest of IRGen to discard d3569 3 a3571 5 // Perform the swifterror writeback. if (swiftErrorTemp.isValid()) { llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp); Builder.CreateStore(errorResult, swiftErrorArg); } d3573 2 a3574 2 // Emit any call-associated writebacks immediately. Arguably this // should happen after any return-value munging. d3582 6 a3587 1 // Extract the return value. a3589 25 case ABIArgInfo::CoerceAndExpand: { auto coercionType = RetAI.getCoerceAndExpandType(); auto layout = CGM.getDataLayout().getStructLayout(coercionType); Address addr = SRetPtr; addr = Builder.CreateElementBitCast(addr, coercionType); assert(CI->getType() == RetAI.getUnpaddedCoerceAndExpandType()); bool requiresExtract = isa(CI->getType()); unsigned unpaddedIndex = 0; for (unsigned i = 0, e = coercionType->getNumElements(); i != e; ++i) { llvm::Type *eltType = coercionType->getElementType(i); if (ABIArgInfo::isPaddingForCoerceAndExpand(eltType)) continue; Address eltAddr = Builder.CreateStructGEP(addr, i, layout); llvm::Value *elt = CI; if (requiresExtract) elt = Builder.CreateExtractValue(elt, unpaddedIndex++); else assert(unpaddedIndex == 0); Builder.CreateStore(elt, eltAddr); } // FALLTHROUGH } d3659 2 a3660 2 // Emit the assume_aligned check on the return value. const Decl *TargetDecl = Callee.getAbstractInfo().getCalleeDecl(); @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @d53 1 a53 1 case CC_Win64: return llvm::CallingConv::Win64; d104 1 a104 29 static void addExtParameterInfosForCall( llvm::SmallVectorImpl ¶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 d109 13 a121 5 CanQual 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?"); d126 1 a126 2 unsigned PrefixSize = prefix.size(); // In the vast majority of cases, we'll have precisely FPT->getNumParams() d131 1 a131 2 auto ExtInfos = FPT->getExtParameterInfos(); assert(ExtInfos.size() == FPT->getNumParams()); d134 1 a134 1 if (ExtInfos[I].hasPassObjectSize()) a136 3 addExtParameterInfosForCall(paramInfos, FPT.getTypePtr(), PrefixSize, prefix.size()); d150 1 a150 1 appendParameterTypes(CGT, prefix, paramInfos, FTP); d196 1 a196 1 return IsWindows ? CC_C : CC_Win64; d289 1 a289 1 appendParameterTypes(*this, argTypes, paramInfos, FTP); d291 1 a291 11 CGCXXABI::AddedStructorArgs AddedArgs = TheCXXABI.buildStructorSignature(MD, Type, 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{}); } d324 20 a354 7 /// /// 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. d359 1 a359 3 unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs) { a364 3 // +1 for implicit this, which should always be args[0]. unsigned TotalPrefixArgs = 1 + ExtraPrefixArgs; d366 1 a366 2 RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, TotalPrefixArgs + ExtraSuffixArgs, D); d375 2 a376 8 llvm::SmallVector 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()); } a619 3 /// /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It /// does not count `this`. d623 4 a626 6 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. d628 1 a628 1 getExtParameterInfosForCall(proto, numPrefixArgs + 1, args.size()); a670 6 namespace clang { namespace CodeGen { void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI); } } d683 1 a683 1 [](CanQualType T) { return T.isCanonicalAsParam(); })); d705 1 a705 1 d707 3 a709 5 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) { a710 2 } else { getABIInfo().computeInfo(*FI); a751 1 FI->NoCallerSavedRegs = info.getNoCallerSavedRegs(); d1250 1 a1250 1 Dst = CGF.Builder.CreateElementBitCast(Dst, SrcTy); d1550 1 a1550 1 // indirect arguments are always on the stack, which is alloca addr space. d1552 1 a1552 2 ArgTypes[FirstIRArg] = LTy->getPointerTo( CGM.getDataLayout().getAllocaAddrSpace()); a1622 98 void CodeGenModule::ConstructDefaultFnAttrList(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.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 { // Attributes that should go on the function, but not the call site. if (!CodeGenOpts.DisableFPElim) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); } else if (CodeGenOpts.OmitLeafFramePointer) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } else { FuncAttrs.addAttribute("no-frame-pointer-elim", "true"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } FuncAttrs.addAttribute("less-precise-fpmad", llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); if (!CodeGenOpts.FPDenormalMode.empty()) FuncAttrs.addAttribute("denormal-fp-math", CodeGenOpts.FPDenormalMode); FuncAttrs.addAttribute("no-trapping-math", llvm::toStringRef(CodeGenOpts.NoTrappingMath)); // TODO: Are these all needed? // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags. FuncAttrs.addAttribute("no-infs-fp-math", llvm::toStringRef(CodeGenOpts.NoInfsFPMath)); FuncAttrs.addAttribute("no-nans-fp-math", llvm::toStringRef(CodeGenOpts.NoNaNsFPMath)); FuncAttrs.addAttribute("unsafe-fp-math", llvm::toStringRef(CodeGenOpts.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(CodeGenOpts.NoSignedZeros)); FuncAttrs.addAttribute( "correctly-rounded-divide-sqrt-fp-math", llvm::toStringRef(CodeGenOpts.CorrectlyRoundedDivSqrt)); // TODO: Reciprocal estimate codegen options should apply to instructions? std::vector &Recips = getTarget().getTargetOpts().Reciprocals; if (!Recips.empty()) FuncAttrs.addAttribute("reciprocal-estimates", llvm::join(Recips.begin(), Recips.end(), ",")); if (CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("stackrealign"); if (CodeGenOpts.Backchain) FuncAttrs.addAttribute("backchain"); } if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { // Conservatively, mark all functions and calls in CUDA as convergent // (meaning, they may call an intrinsically convergent op, such as // __syncthreads(), and so can't have certain optimizations applied around // them). LLVM will remove this attribute where it safely can. FuncAttrs.addAttribute(llvm::Attribute::Convergent); // Exceptions aren't supported in CUDA device code. FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Respect -fcuda-flush-denormals-to-zero. if (getLangOpts().CUDADeviceFlushDenormalsToZero) FuncAttrs.addAttribute("nvptx-f32ftz", "true"); } } void CodeGenModule::AddDefaultFnAttrs(llvm::Function &F) { llvm::AttrBuilder FuncAttrs; ConstructDefaultFnAttrList(F.getName(), F.hasFnAttribute(llvm::Attribute::OptimizeNone), /* AttrOnCallsite = */ false, FuncAttrs); F.addAttributes(llvm::AttributeList::FunctionIndex, FuncAttrs); } d1625 1 a1625 1 llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite) { d1628 1 d1631 1 d1642 1 a1642 1 bool HasOptnone = false; a1650 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::Cold); a1680 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute("no_caller_saved_registers"); d1682 1 d1694 7 a1700 1 ConstructDefaultFnAttrList(Name, HasOptnone, AttrOnCallSite, FuncAttrs); d1702 4 d1710 19 a1728 1 if (!AttrOnCallSite) { d1730 44 a1773 5 CodeGenOpts.DisableTailCalls || (TargetDecl && (TargetDecl->hasAttr() || TargetDecl->hasAttr())); FuncAttrs.addAttribute("disable-tail-calls", llvm::toStringRef(DisableTailCalls)); d1797 2 a1798 2 if (ParsedAttr.Architecture != "") TargetCPU = ParsedAttr.Architecture; d1822 15 d1879 6 a1885 1 SmallVector ArgAttrs(IRFunctionArgs.totalIRArgs()); d1894 2 a1895 2 ArgAttrs[IRFunctionArgs.getSRetArgNo()] = llvm::AttributeSet::get(getLLVMContext(), SRETAttrs); d1902 2 a1903 2 ArgAttrs[IRFunctionArgs.getInallocaArgNo()] = llvm::AttributeSet::get(getLLVMContext(), Attrs); d1916 4 a1919 6 if (AI.getPaddingInReg()) { ArgAttrs[IRFunctionArgs.getPaddingArgNo(ArgNo)] = llvm::AttributeSet::get( getLLVMContext(), llvm::AttrBuilder().addAttribute(llvm::Attribute::InReg)); } d2034 2 a2035 2 ArgAttrs[FirstIRArg + i] = llvm::AttributeSet::get(getLLVMContext(), Attrs); d2040 5 a2044 3 AttrList = llvm::AttributeList::get( getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), FuncAttrs), llvm::AttributeSet::get(getLLVMContext(), RetAttrs), ArgAttrs); d2155 2 a2156 1 AI->addAttr(llvm::Attribute::NoAlias); d2247 3 a2249 1 AI->addAttr(llvm::Attribute::NonNull); d2266 2 a2267 1 AI->addAttrs(Attrs); d2269 3 a2271 1 AI->addAttr(llvm::Attribute::NonNull); d2281 3 a2283 1 AI->addAttr(llvm::Attribute::NonNull); d2290 1 a2290 1 if (AVAttr) { d2295 8 a2302 3 unsigned Alignment = std::min((unsigned)AlignmentCI->getZExtValue(), +llvm::Value::MaximumAlignment); AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment)); d2307 3 a2309 1 AI->addAttr(llvm::Attribute::NoAlias); d2367 2 a2368 1 AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy); d2861 13 a2873 1 EmitReturnValueCheck(RV); a2882 59 void CodeGenFunction::EmitReturnValueCheck(llvm::Value *RV) { // A current decl may not be available when emitting vtable thunks. if (!CurCodeDecl) return; ReturnsNonNullAttr *RetNNAttr = nullptr; if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) RetNNAttr = CurCodeDecl->getAttr(); if (!RetNNAttr && !requiresReturnValueNullabilityCheck()) return; // Prefer the returns_nonnull attribute if it's present. SourceLocation AttrLoc; SanitizerMask CheckKind; SanitizerHandler Handler; if (RetNNAttr) { assert(!requiresReturnValueNullabilityCheck() && "Cannot check nullability and the nonnull attribute"); AttrLoc = RetNNAttr->getLocation(); CheckKind = SanitizerKind::ReturnsNonnullAttribute; Handler = SanitizerHandler::NonnullReturn; } else { if (auto *DD = dyn_cast(CurCodeDecl)) if (auto *TSI = DD->getTypeSourceInfo()) if (auto FTL = TSI->getTypeLoc().castAs()) AttrLoc = FTL.getReturnLoc().findNullabilityLoc(); CheckKind = SanitizerKind::NullabilityReturn; Handler = SanitizerHandler::NullabilityReturn; } SanitizerScope SanScope(this); // Make sure the "return" source location is valid. If we're checking a // nullability annotation, make sure the preconditions for the check are met. llvm::BasicBlock *Check = createBasicBlock("nullcheck"); llvm::BasicBlock *NoCheck = createBasicBlock("no.nullcheck"); llvm::Value *SLocPtr = Builder.CreateLoad(ReturnLocation, "return.sloc.load"); llvm::Value *CanNullCheck = Builder.CreateIsNotNull(SLocPtr); if (requiresReturnValueNullabilityCheck()) CanNullCheck = Builder.CreateAnd(CanNullCheck, RetValNullabilityPrecondition); Builder.CreateCondBr(CanNullCheck, Check, NoCheck); EmitBlock(Check); // Now do the null check. llvm::Value *Cond = Builder.CreateIsNotNull(RV); llvm::Constant *StaticData[] = {EmitCheckSourceLocation(AttrLoc)}; llvm::Value *DynamicData[] = {SLocPtr}; EmitCheck(std::make_pair(Cond, CheckKind), Handler, StaticData, DynamicData); EmitBlock(NoCheck); #ifndef NDEBUG // The return location should not be used after the check has been emitted. ReturnLocation = Address::invalid(); #endif } d3191 1 a3191 1 AbstractCallee AC, d3193 1 a3193 2 if (!AC.getDecl() || !(SanOpts.has(SanitizerKind::NonnullAttribute) || SanOpts.has(SanitizerKind::NullabilityArg))) d3195 1 a3195 3 // The param decl may be missing in a variadic function. auto PVD = ParmNum < AC.getNumParams() ? AC.getParamDecl(ParmNum) : nullptr; d3197 2 a3198 15 // Prefer the nonnull attribute if it's present. const NonNullAttr *NNAttr = nullptr; if (SanOpts.has(SanitizerKind::NonnullAttribute)) NNAttr = getNonNullAttr(AC.getDecl(), PVD, ArgType, ArgNo); bool CanCheckNullability = false; if (SanOpts.has(SanitizerKind::NullabilityArg) && !NNAttr && PVD) { auto Nullability = PVD->getType()->getNullability(getContext()); CanCheckNullability = Nullability && *Nullability == NullabilityKind::NonNull && PVD->getTypeSourceInfo(); } if (!NNAttr && !CanCheckNullability) a3199 14 SourceLocation AttrLoc; SanitizerMask CheckKind; SanitizerHandler Handler; if (NNAttr) { AttrLoc = NNAttr->getLocation(); CheckKind = SanitizerKind::NonnullAttribute; Handler = SanitizerHandler::NonnullArg; } else { AttrLoc = PVD->getTypeSourceInfo()->getTypeLoc().findNullabilityLoc(); CheckKind = SanitizerKind::NullabilityArg; Handler = SanitizerHandler::NullabilityArg; } d3206 2 a3207 1 EmitCheckSourceLocation(ArgLoc), EmitCheckSourceLocation(AttrLoc), d3210 2 a3211 1 EmitCheck(std::make_pair(Cond, CheckKind), Handler, StaticData, None); d3217 2 a3218 1 AbstractCallee AC, unsigned ParamsToSkip, EvaluationOrder Order) { d3221 14 a3244 21 auto MaybeEmitImplicitObjectSize = [&](unsigned I, const Expr *Arg, RValue EmittedArg) { if (!AC.hasFunctionDecl() || I >= AC.getNumParams()) return; auto *PS = AC.getParamDecl(I)->getAttr(); if (PS == nullptr) return; const auto &Context = getContext(); auto SizeTy = Context.getSizeType(); auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy)); assert(EmittedArg.getScalarVal() && "We emitted nothing for the arg?"); llvm::Value *V = evaluateOrEmitBuiltinObjectSize(Arg, PS->getType(), T, EmittedArg.getScalarVal()); Args.add(RValue::get(V), SizeTy); // If we're emitting args in reverse, be sure to do so with // pass_object_size, as well. if (!LeftToRight) std::swap(Args.back(), *(&Args.back() - 1)); }; d3262 1 a3262 9 unsigned InitialArgSize = Args.size(); // If *Arg is an ObjCIndirectCopyRestoreExpr, check that either the types of // the argument and parameter match or the objc method is parameterized. assert((!isa(*Arg) || getContext().hasSameUnqualifiedType((*Arg)->getType(), ArgTypes[Idx]) || (isa(AC.getDecl()) && isObjCMethodWithTypeParams(cast(AC.getDecl())))) && "Argument and parameter types don't match"); d3264 3 a3266 12 // In particular, we depend on it being the last arg in Args, and the // objectsize bits depend on there only being one arg if !LeftToRight. assert(InitialArgSize + 1 == Args.size() && "The code below depends on only adding one arg per EmitCallArg"); (void)InitialArgSize; RValue RVArg = Args.back().RV; EmitNonNullArgCheck(RVArg, ArgTypes[Idx], (*Arg)->getExprLoc(), AC, ParamsToSkip + Idx); // @@llvm.objectsize should never have side-effects and shouldn't need // destruction/cleanups, so we can safely "emit" it after its arg, // regardless of right-to-leftness MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg); d3314 1 d3574 1 a3574 2 const llvm::DataLayout &DL = CGM.getDataLayout(); ArgMemoryLayout = DL.getStructLayout(ArgStruct); d3579 1 a3579 2 AI = new llvm::AllocaInst(ArgStruct, DL.getAllocaAddrSpace(), "argmem", IP); d3678 1 a3678 2 Address Addr = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign(), "indirect-arg-temp", false); d3707 1 a3707 2 Address AI = CreateMemTemp(I->Ty, ArgInfo.getIndirectAlign(), "byval-temp", false); d3975 1 a3975 1 llvm::AttributeList Attrs; d3977 2 a3978 1 Callee.getAbstractInfo(), Attrs, CallingConv, d3980 2 d3992 2 a3993 1 Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex, d4000 1 a4000 1 Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex, d4017 1 a4017 1 CannotThrow = Attrs.hasAttribute(llvm::AttributeList::FunctionIndex, a4129 1 LLVM_FALLTHROUGH; a4212 4 } else if (const auto *AA = TargetDecl->getAttr()) { llvm::Value *ParamVal = CallArgs[AA->getParamIndex() - 1].RV.getScalarVal(); EmitAlignmentAssumption(Ret.getScalarVal(), ParamVal); @ 1.1.1.11.4.1 log @Sync with HEAD @ text @a31 1 #include "llvm/Transforms/Utils/Local.h" d34 1 a35 1 #include "llvm/IR/CallingConv.h" d38 1 d40 1 a40 1 #include "llvm/IR/Intrinsics.h" a257 10 /// Set calling convention for CUDA/HIP kernel. static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD) { if (FD->hasAttr()) { const FunctionType *FT = FTy->getAs(); CGM.getTargetCodeGenInfo().setCUDAKernelCallingConvention(FT); FTy = FT->getCanonicalTypeUnqualified(); } } d267 1 a267 3 CanQualType FT = GetFormalType(MD).getAs(); setCUDAKernelCallingConvention(FT, CGM, MD); auto prototype = FT.getAs(); a426 1 setCUDAKernelCallingConvention(FTy, CGM, FD); a457 1 SmallVector extParamInfos(2); a462 3 auto extParamInfo = FunctionProtoType::ExtParameterInfo().withIsNoEscape( I->hasAttr()); extParamInfos.push_back(extParamInfo); d478 1 a478 1 /*chainCall=*/false, argTys, einfo, extParamInfos, required); d512 2 a513 2 CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) { assert(MD->isVirtual() && "only methods have thunks"); a801 1 FI->NoCfCheck = info.getNoCfCheck(); d903 2 a904 1 if (FD->isZeroLengthBitField(Context)) d925 2 a926 1 if (FD->isZeroLengthBitField(Context)) d1039 1 a1039 1 QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, d1043 6 a1048 10 Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : 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); }); d1050 1 a1050 2 Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : Arg.getKnownRValue().getAggregateAddress(); d1056 1 a1056 1 CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType()); d1059 1 a1059 1 ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs, d1065 2 a1066 3 CallArg FldArg = CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType()); ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs, d1070 1 a1070 1 ComplexPairTy CV = Arg.getKnownRValue().getComplexVal(); a1074 1 auto RV = Arg.getKnownRValue(); d1226 1 a1226 2 Src = CGF.Builder.CreateBitCast(Src, Ty->getPointerTo(Src.getAddressSpace())); d1232 2 a1233 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address SrcCasted = CGF.Builder.CreateBitCast(Src, CGF.AllocaInt8PtrTy); d1314 2 a1315 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address DstCasted = CGF.Builder.CreateBitCast(Dst, CGF.AllocaInt8PtrTy); d1477 1 a1477 2 const auto &RI = FI.getReturnInfo(); return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet()); d1670 1 a1670 1 FPT->isNothrow()) a1717 5 // 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"); a1735 4 if (getLangOpts().OpenCL) FuncAttrs.addAttribute("denorms-are-zero", llvm::toStringRef(CodeGenOpts.FlushDenorm)); d1737 1 a1737 1 const std::vector &Recips = CodeGenOpts.Reciprocals; d1740 1 a1740 6 llvm::join(Recips, ",")); if (!CodeGenOpts.PreferVectorWidth.empty() && CodeGenOpts.PreferVectorWidth != "none") FuncAttrs.addAttribute("prefer-vector-width", CodeGenOpts.PreferVectorWidth); d1748 5 a1752 6 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. a1753 1 } a1754 1 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { d1783 1 a1783 1 // attributes from there. a1831 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck); d1836 4 a1839 3 if (AllocSize->getNumElemsParam().isValid()) NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex(); FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(), d1850 39 a1888 6 // Add NonLazyBind attribute to function declarations when -fno-plt // is used. if (TargetDecl && CodeGenOpts.NoPLT) { if (auto *Fn = dyn_cast(TargetDecl)) { if (!Fn->isDefined() && !AttrOnCallSite) { FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind); a1889 7 } } if (TargetDecl && TargetDecl->hasAttr()) { if (getLangOpts().OpenCLVersion <= 120) { // OpenCL v1.2 Work groups are always uniform FuncAttrs.addAttribute("uniform-work-group-size", "true"); d1891 10 a1900 23 // 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)); } } if (!AttrOnCallSite) { bool DisableTailCalls = false; if (CodeGenOpts.DisableTailCalls) DisableTailCalls = true; else if (TargetDecl) { if (TargetDecl->hasAttr() || TargetDecl->hasAttr()) DisableTailCalls = true; else if (CodeGenOpts.NoEscapingBlockTailCalls) { if (const auto *BD = dyn_cast(TargetDecl)) if (!BD->doesNotEscape()) DisableTailCalls = true; a1902 4 FuncAttrs.addAttribute("disable-tail-calls", llvm::toStringRef(DisableTailCalls)); GetCPUAndFeaturesAttributes(TargetDecl, FuncAttrs); d1911 1 a1911 1 if (RetAI.isSignExt()) d1913 1 a1913 1 else d1915 1 a1915 1 LLVM_FALLTHROUGH; d1992 1 a1992 1 if (AI.isSignExt()) d1994 7 a2000 3 else Attrs.addAttribute(llvm::Attribute::ZExt); LLVM_FALLTHROUGH; a2094 3 if (FI.getExtParameterInfo(ArgNo).isNoEscape()) Attrs.addAttribute(llvm::Attribute::NoCapture); d2238 1 a2242 6 // 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())); a2740 6 if (FI.isNoReturn()) { // Noreturn functions don't return. EmitUnreachable(EndLoc); return; } d2999 1 a2999 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); a3038 13 // Deactivate the cleanup for the callee-destructed param that was pushed. if (hasAggregateEvaluationKind(type) && !CurFuncIsThunk && type->getAs()->getDecl()->isParamDestroyedInCallee() && type.isDestructedType()) { EHScopeStack::stable_iterator cleanup = CalleeDestructedParamCleanups.lookup(cast(param)); assert(cleanup.isValid() && "cleanup for callee-destructed param not recorded"); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *isActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(cleanup, isActive); } d3057 1 a3057 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3119 1 d3197 1 a3197 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3405 7 a3411 11 // Since pointer argument are never emitted as LValue, it is safe to emit // non-null argument check for r-value only. if (!Args.back().hasLValue()) { RValue RVArg = Args.back().getKnownRValue(); EmitNonNullArgCheck(RVArg, ArgTypes[Idx], (*Arg)->getExprLoc(), AC, ParamsToSkip + Idx); // @@llvm.objectsize should never have side-effects and shouldn't need // destruction/cleanups, so we can safely "emit" it after its arg, // regardless of right-to-leftness MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg); } d3431 4 a3434 9 QualType::DestructionKind DtorKind = Ty.isDestructedType(); if (DtorKind == QualType::DK_cxx_destructor) { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } else { CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Ty)); } a3452 27 RValue CallArg::getRValue(CodeGenFunction &CGF) const { if (!HasLV) return RV; LValue Copy = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty), Ty); CGF.EmitAggregateCopy(Copy, LV, Ty, AggValueSlot::DoesNotOverlap, LV.isVolatile()); IsUsed = true; return RValue::getAggregate(Copy.getAddress()); } void CallArg::copyInto(CodeGenFunction &CGF, Address Addr) const { LValue Dst = CGF.MakeAddrLValue(Addr, Ty); if (!HasLV && RV.isScalar()) CGF.EmitStoreOfScalar(RV.getScalarVal(), Dst, /*init=*/true); else if (!HasLV && RV.isComplex()) CGF.EmitStoreOfComplex(RV.getComplexVal(), Dst, /*init=*/true); else { auto Addr = HasLV ? LV.getAddress() : RV.getAggregateAddress(); LValue SrcLV = CGF.MakeAddrLValue(Addr, Ty); // We assume that call args are never copied into subobjects. CGF.EmitAggregateCopy(Dst, SrcLV, Ty, AggValueSlot::DoesNotOverlap, HasLV ? LV.isVolatileQualified() : RV.isVolatileQualified()); } IsUsed = true; } d3476 1 a3476 1 type->getAs()->getDecl()->isParamDestroyedInCallee()) { d3485 4 a3488 6 bool DestroyedInCallee = true, NeedsEHCleanup = true; if (const auto *RD = type->getAsCXXRecordDecl()) DestroyedInCallee = RD->hasNonTrivialDestructor(); else NeedsEHCleanup = needsEHCleanup(type.isDestructedType()); d3496 1 a3496 1 if (DestroyedInCallee && NeedsEHCleanup) { d3513 9 a3521 1 args.addUncopiedAggregate(L, type); d3583 3 a3585 3 SmallVector CodeGenFunction::getBundlesForFunclet(llvm::Value *Callee) { SmallVector BundleList; d3589 1 a3589 1 return BundleList; d3594 1 a3594 1 return BundleList; a3596 1 return BundleList; d3604 4 a3607 2 llvm::CallInst *call = Builder.CreateCall(callee, args, getBundlesForFunclet(callee), name); d3615 2 a3616 2 SmallVector BundleList = getBundlesForFunclet(callee); d3659 2 a3660 2 SmallVector BundleList = getBundlesForFunclet(Callee); d3680 10 d3699 1 a3699 2 llvm::Instruction **callOrInvoke, SourceLocation Loc) { d3702 1 a3702 1 assert(Callee.isOrdinary() || Callee.isVirtual()); d3749 1 a3749 2 Address SRetAlloca = Address::invalid(); llvm::Value *UnusedReturnSizePtr = nullptr; d3754 1 a3754 1 SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca); d3758 2 a3759 1 UnusedReturnSizePtr = EmitLifetimeStart(size, SRetAlloca.getPointer()); d3781 1 d3795 1 a3795 1 if (I->isAggregate()) { a3796 3 Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3798 1 a3798 1 cast(Addr.getPointer()); d3801 1 a3801 1 Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex()); d3814 2 a3815 1 I->copyInto(*this, Addr); d3822 1 a3822 1 if (!I->isAggregate()) { d3824 2 a3825 2 Address Addr = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "indirect-arg-temp"); d3828 2 a3829 1 I->copyInto(*this, Addr); d3837 3 a3839 6 // 3. If the argument is byval, but RV is not located in default // or alloca address space. Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); llvm::Value *V = Addr.getPointer(); d3842 11 a3852 25 assert((FirstIRArg >= IRFuncTy->getNumParams() || IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() == TD->getAllocaAddrSpace()) && "indirect argument must be in alloca address space"); bool NeedCopy = false; if (Addr.getAlignment() < Align && llvm::getOrEnforceKnownAlignment(V, Align.getQuantity(), *TD) < Align.getQuantity()) { NeedCopy = true; } else if (I->hasLValue()) { auto LV = I->getKnownLValue(); auto AS = LV.getAddressSpace(); if ((!ArgInfo.getIndirectByVal() && (LV.getAlignment() >= getContext().getTypeAlignInChars(I->Ty))) || (ArgInfo.getIndirectByVal() && ((AS != LangAS::Default && AS != LangAS::opencl_private && AS != CGM.getASTAllocaAddressSpace())))) { NeedCopy = true; } } if (NeedCopy) { d3854 2 a3855 2 Address AI = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "byval-temp"); d3857 1 a3857 1 I->copyInto(*this, AI); d3860 1 a3860 5 auto *T = V->getType()->getPointerElementType()->getPointerTo( CGM.getDataLayout().getAllocaAddrSpace()); IRCallArgs[FirstIRArg] = getTargetHooks().performAddrSpaceCast( *this, V, LangAS::Default, CGM.getASTAllocaAddressSpace(), T, true); d3877 2 a3878 2 if (!I->isAggregate()) V = I->getKnownRValue().getScalarVal(); d3880 1 a3880 3 V = Builder.CreateLoad( I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress()); d3918 1 a3918 1 if (!I->isAggregate()) { d3920 2 a3921 1 I->copyInto(*this, Src); d3923 1 a3923 2 Src = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3949 1 a3949 2 Src = Builder.CreateBitCast(Src, STy->getPointerTo(Src.getAddressSpace())); d3976 2 a3977 5 Address AllocaAddr = Address::invalid(); if (I->isAggregate()) { addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); a3978 1 RValue RV = I->getKnownRValue(); d3985 2 d3989 3 a3991 5 CharUnits::fromQuantity(std::max( layout->getAlignment(), scalarAlign)), "tmp", /*ArraySize=*/nullptr, &AllocaAddr); tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer()); d4009 1 a4009 1 EmitLifetimeEnd(tempSize, AllocaAddr.getPointer()); d4017 1 a4017 1 ExpandTypeToArgs(I->Ty, *I, IRFuncTy, IRCallArgs, IRArgPos); d4023 1 a4023 2 const CGCallee &ConcreteCallee = Callee.prepareConcreteCallee(*this); llvm::Value *CalleePtr = ConcreteCallee.getFunctionPointer(); a4163 9 // If we made a temporary, be sure to clean up after ourselves. Note that we // can't depend on being inside of an ExprWithCleanups, so we need to manually // pop this cleanup later on. Being eager about this is OK, since this // temporary is 'invisible' outside of the callee. if (UnusedReturnSizePtr) pushFullExprCleanup(NormalEHLifetimeMarker, SRetAlloca, UnusedReturnSizePtr); d4166 2 a4167 2 SmallVector BundleList = getBundlesForFunclet(CalleePtr); d4217 3 a4219 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4221 1 a4221 9 // Strip away the noreturn attribute to better diagnose unreachable UB. if (SanOpts.has(SanitizerKind::Unreachable)) { if (auto *F = CS.getCalledFunction()) F->removeFnAttr(llvm::Attribute::NoReturn); CS.removeAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoReturn); } EmitUnreachable(Loc); d4280 3 a4282 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4360 1 a4360 2 CallArgs[AA->getParamIndex().getLLVMIndex()].getRValue( *this).getScalarVal(); a4367 11 CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const { if (isVirtual()) { const CallExpr *CE = getVirtualCallExpr(); return CGF.CGM.getCXXABI().getVirtualFunctionPointer( CGF, getVirtualMethodDecl(), getThisAddress(), getFunctionType(), CE ? CE->getLocStart() : SourceLocation()); } return *this; } @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @a31 1 #include "llvm/Transforms/Utils/Local.h" d34 1 a35 1 #include "llvm/IR/CallingConv.h" d38 1 d40 1 a40 1 #include "llvm/IR/Intrinsics.h" a257 10 /// Set calling convention for CUDA/HIP kernel. static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD) { if (FD->hasAttr()) { const FunctionType *FT = FTy->getAs(); CGM.getTargetCodeGenInfo().setCUDAKernelCallingConvention(FT); FTy = FT->getCanonicalTypeUnqualified(); } } d267 1 a267 3 CanQualType FT = GetFormalType(MD).getAs(); setCUDAKernelCallingConvention(FT, CGM, MD); auto prototype = FT.getAs(); a426 1 setCUDAKernelCallingConvention(FTy, CGM, FD); a457 1 SmallVector extParamInfos(2); a462 3 auto extParamInfo = FunctionProtoType::ExtParameterInfo().withIsNoEscape( I->hasAttr()); extParamInfos.push_back(extParamInfo); d478 1 a478 1 /*chainCall=*/false, argTys, einfo, extParamInfos, required); d512 2 a513 2 CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) { assert(MD->isVirtual() && "only methods have thunks"); a801 1 FI->NoCfCheck = info.getNoCfCheck(); d903 2 a904 1 if (FD->isZeroLengthBitField(Context)) d925 2 a926 1 if (FD->isZeroLengthBitField(Context)) d1039 1 a1039 1 QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, d1043 6 a1048 10 Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : 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); }); d1050 1 a1050 2 Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : Arg.getKnownRValue().getAggregateAddress(); d1056 1 a1056 1 CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType()); d1059 1 a1059 1 ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs, d1065 2 a1066 3 CallArg FldArg = CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType()); ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs, d1070 1 a1070 1 ComplexPairTy CV = Arg.getKnownRValue().getComplexVal(); a1074 1 auto RV = Arg.getKnownRValue(); d1226 1 a1226 2 Src = CGF.Builder.CreateBitCast(Src, Ty->getPointerTo(Src.getAddressSpace())); d1232 2 a1233 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address SrcCasted = CGF.Builder.CreateBitCast(Src, CGF.AllocaInt8PtrTy); d1314 2 a1315 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address DstCasted = CGF.Builder.CreateBitCast(Dst, CGF.AllocaInt8PtrTy); d1477 1 a1477 2 const auto &RI = FI.getReturnInfo(); return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet()); d1670 1 a1670 1 FPT->isNothrow()) a1717 5 // 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"); a1735 4 if (getLangOpts().OpenCL) FuncAttrs.addAttribute("denorms-are-zero", llvm::toStringRef(CodeGenOpts.FlushDenorm)); d1737 1 a1737 1 const std::vector &Recips = CodeGenOpts.Reciprocals; d1740 1 a1740 6 llvm::join(Recips, ",")); if (!CodeGenOpts.PreferVectorWidth.empty() && CodeGenOpts.PreferVectorWidth != "none") FuncAttrs.addAttribute("prefer-vector-width", CodeGenOpts.PreferVectorWidth); d1748 5 a1752 6 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. a1753 1 } a1754 1 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { d1783 1 a1783 1 // attributes from there. a1831 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck); d1836 4 a1839 3 if (AllocSize->getNumElemsParam().isValid()) NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex(); FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(), d1850 39 a1888 6 // Add NonLazyBind attribute to function declarations when -fno-plt // is used. if (TargetDecl && CodeGenOpts.NoPLT) { if (auto *Fn = dyn_cast(TargetDecl)) { if (!Fn->isDefined() && !AttrOnCallSite) { FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind); a1889 7 } } if (TargetDecl && TargetDecl->hasAttr()) { if (getLangOpts().OpenCLVersion <= 120) { // OpenCL v1.2 Work groups are always uniform FuncAttrs.addAttribute("uniform-work-group-size", "true"); d1891 10 a1900 23 // 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)); } } if (!AttrOnCallSite) { bool DisableTailCalls = false; if (CodeGenOpts.DisableTailCalls) DisableTailCalls = true; else if (TargetDecl) { if (TargetDecl->hasAttr() || TargetDecl->hasAttr()) DisableTailCalls = true; else if (CodeGenOpts.NoEscapingBlockTailCalls) { if (const auto *BD = dyn_cast(TargetDecl)) if (!BD->doesNotEscape()) DisableTailCalls = true; a1902 4 FuncAttrs.addAttribute("disable-tail-calls", llvm::toStringRef(DisableTailCalls)); GetCPUAndFeaturesAttributes(TargetDecl, FuncAttrs); d1911 1 a1911 1 if (RetAI.isSignExt()) d1913 1 a1913 1 else d1915 1 a1915 1 LLVM_FALLTHROUGH; d1992 1 a1992 1 if (AI.isSignExt()) d1994 7 a2000 3 else Attrs.addAttribute(llvm::Attribute::ZExt); LLVM_FALLTHROUGH; a2094 3 if (FI.getExtParameterInfo(ArgNo).isNoEscape()) Attrs.addAttribute(llvm::Attribute::NoCapture); d2238 1 a2242 6 // 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())); a2740 6 if (FI.isNoReturn()) { // Noreturn functions don't return. EmitUnreachable(EndLoc); return; } d2999 1 a2999 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); a3038 13 // Deactivate the cleanup for the callee-destructed param that was pushed. if (hasAggregateEvaluationKind(type) && !CurFuncIsThunk && type->getAs()->getDecl()->isParamDestroyedInCallee() && type.isDestructedType()) { EHScopeStack::stable_iterator cleanup = CalleeDestructedParamCleanups.lookup(cast(param)); assert(cleanup.isValid() && "cleanup for callee-destructed param not recorded"); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *isActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(cleanup, isActive); } d3057 1 a3057 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3119 1 d3197 1 a3197 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3405 7 a3411 11 // Since pointer argument are never emitted as LValue, it is safe to emit // non-null argument check for r-value only. if (!Args.back().hasLValue()) { RValue RVArg = Args.back().getKnownRValue(); EmitNonNullArgCheck(RVArg, ArgTypes[Idx], (*Arg)->getExprLoc(), AC, ParamsToSkip + Idx); // @@llvm.objectsize should never have side-effects and shouldn't need // destruction/cleanups, so we can safely "emit" it after its arg, // regardless of right-to-leftness MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg); } d3431 4 a3434 9 QualType::DestructionKind DtorKind = Ty.isDestructedType(); if (DtorKind == QualType::DK_cxx_destructor) { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } else { CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Ty)); } a3452 27 RValue CallArg::getRValue(CodeGenFunction &CGF) const { if (!HasLV) return RV; LValue Copy = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty), Ty); CGF.EmitAggregateCopy(Copy, LV, Ty, AggValueSlot::DoesNotOverlap, LV.isVolatile()); IsUsed = true; return RValue::getAggregate(Copy.getAddress()); } void CallArg::copyInto(CodeGenFunction &CGF, Address Addr) const { LValue Dst = CGF.MakeAddrLValue(Addr, Ty); if (!HasLV && RV.isScalar()) CGF.EmitStoreOfScalar(RV.getScalarVal(), Dst, /*init=*/true); else if (!HasLV && RV.isComplex()) CGF.EmitStoreOfComplex(RV.getComplexVal(), Dst, /*init=*/true); else { auto Addr = HasLV ? LV.getAddress() : RV.getAggregateAddress(); LValue SrcLV = CGF.MakeAddrLValue(Addr, Ty); // We assume that call args are never copied into subobjects. CGF.EmitAggregateCopy(Dst, SrcLV, Ty, AggValueSlot::DoesNotOverlap, HasLV ? LV.isVolatileQualified() : RV.isVolatileQualified()); } IsUsed = true; } d3476 1 a3476 1 type->getAs()->getDecl()->isParamDestroyedInCallee()) { d3485 4 a3488 6 bool DestroyedInCallee = true, NeedsEHCleanup = true; if (const auto *RD = type->getAsCXXRecordDecl()) DestroyedInCallee = RD->hasNonTrivialDestructor(); else NeedsEHCleanup = needsEHCleanup(type.isDestructedType()); d3496 1 a3496 1 if (DestroyedInCallee && NeedsEHCleanup) { d3513 9 a3521 1 args.addUncopiedAggregate(L, type); d3583 3 a3585 3 SmallVector CodeGenFunction::getBundlesForFunclet(llvm::Value *Callee) { SmallVector BundleList; d3589 1 a3589 1 return BundleList; d3594 1 a3594 1 return BundleList; a3596 1 return BundleList; d3604 4 a3607 2 llvm::CallInst *call = Builder.CreateCall(callee, args, getBundlesForFunclet(callee), name); d3615 2 a3616 2 SmallVector BundleList = getBundlesForFunclet(callee); d3659 2 a3660 2 SmallVector BundleList = getBundlesForFunclet(Callee); d3680 10 d3699 1 a3699 2 llvm::Instruction **callOrInvoke, SourceLocation Loc) { d3702 1 a3702 1 assert(Callee.isOrdinary() || Callee.isVirtual()); d3749 1 a3749 2 Address SRetAlloca = Address::invalid(); llvm::Value *UnusedReturnSizePtr = nullptr; d3754 1 a3754 1 SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca); d3758 2 a3759 1 UnusedReturnSizePtr = EmitLifetimeStart(size, SRetAlloca.getPointer()); d3781 1 d3795 1 a3795 1 if (I->isAggregate()) { a3796 3 Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3798 1 a3798 1 cast(Addr.getPointer()); d3801 1 a3801 1 Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex()); d3814 2 a3815 1 I->copyInto(*this, Addr); d3822 1 a3822 1 if (!I->isAggregate()) { d3824 2 a3825 2 Address Addr = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "indirect-arg-temp"); d3828 2 a3829 1 I->copyInto(*this, Addr); d3837 3 a3839 6 // 3. If the argument is byval, but RV is not located in default // or alloca address space. Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); llvm::Value *V = Addr.getPointer(); d3842 11 a3852 25 assert((FirstIRArg >= IRFuncTy->getNumParams() || IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() == TD->getAllocaAddrSpace()) && "indirect argument must be in alloca address space"); bool NeedCopy = false; if (Addr.getAlignment() < Align && llvm::getOrEnforceKnownAlignment(V, Align.getQuantity(), *TD) < Align.getQuantity()) { NeedCopy = true; } else if (I->hasLValue()) { auto LV = I->getKnownLValue(); auto AS = LV.getAddressSpace(); if ((!ArgInfo.getIndirectByVal() && (LV.getAlignment() >= getContext().getTypeAlignInChars(I->Ty))) || (ArgInfo.getIndirectByVal() && ((AS != LangAS::Default && AS != LangAS::opencl_private && AS != CGM.getASTAllocaAddressSpace())))) { NeedCopy = true; } } if (NeedCopy) { d3854 2 a3855 2 Address AI = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "byval-temp"); d3857 1 a3857 1 I->copyInto(*this, AI); d3860 1 a3860 5 auto *T = V->getType()->getPointerElementType()->getPointerTo( CGM.getDataLayout().getAllocaAddrSpace()); IRCallArgs[FirstIRArg] = getTargetHooks().performAddrSpaceCast( *this, V, LangAS::Default, CGM.getASTAllocaAddressSpace(), T, true); d3877 2 a3878 2 if (!I->isAggregate()) V = I->getKnownRValue().getScalarVal(); d3880 1 a3880 3 V = Builder.CreateLoad( I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress()); d3918 1 a3918 1 if (!I->isAggregate()) { d3920 2 a3921 1 I->copyInto(*this, Src); d3923 1 a3923 2 Src = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3949 1 a3949 2 Src = Builder.CreateBitCast(Src, STy->getPointerTo(Src.getAddressSpace())); d3976 2 a3977 5 Address AllocaAddr = Address::invalid(); if (I->isAggregate()) { addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); a3978 1 RValue RV = I->getKnownRValue(); d3985 2 d3989 3 a3991 5 CharUnits::fromQuantity(std::max( layout->getAlignment(), scalarAlign)), "tmp", /*ArraySize=*/nullptr, &AllocaAddr); tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer()); d4009 1 a4009 1 EmitLifetimeEnd(tempSize, AllocaAddr.getPointer()); d4017 1 a4017 1 ExpandTypeToArgs(I->Ty, *I, IRFuncTy, IRCallArgs, IRArgPos); d4023 1 a4023 2 const CGCallee &ConcreteCallee = Callee.prepareConcreteCallee(*this); llvm::Value *CalleePtr = ConcreteCallee.getFunctionPointer(); a4163 9 // If we made a temporary, be sure to clean up after ourselves. Note that we // can't depend on being inside of an ExprWithCleanups, so we need to manually // pop this cleanup later on. Being eager about this is OK, since this // temporary is 'invisible' outside of the callee. if (UnusedReturnSizePtr) pushFullExprCleanup(NormalEHLifetimeMarker, SRetAlloca, UnusedReturnSizePtr); d4166 2 a4167 2 SmallVector BundleList = getBundlesForFunclet(CalleePtr); d4217 3 a4219 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4221 1 a4221 9 // Strip away the noreturn attribute to better diagnose unreachable UB. if (SanOpts.has(SanitizerKind::Unreachable)) { if (auto *F = CS.getCalledFunction()) F->removeFnAttr(llvm::Attribute::NoReturn); CS.removeAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoReturn); } EmitUnreachable(Loc); d4280 3 a4282 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4360 1 a4360 2 CallArgs[AA->getParamIndex().getLLVMIndex()].getRValue( *this).getScalarVal(); a4367 11 CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const { if (isVirtual()) { const CallExpr *CE = getVirtualCallExpr(); return CGF.CGM.getCXXABI().getVirtualFunctionPointer( CGF, getVirtualMethodDecl(), getThisAddress(), getFunctionType(), CE ? CE->getLocStart() : SourceLocation()); } return *this; } @ 1.1.1.12 log @Import clang r337282 from trunk @ text @a31 1 #include "llvm/Transforms/Utils/Local.h" d34 1 a35 1 #include "llvm/IR/CallingConv.h" d38 1 d40 1 a40 1 #include "llvm/IR/Intrinsics.h" a257 10 /// Set calling convention for CUDA/HIP kernel. static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD) { if (FD->hasAttr()) { const FunctionType *FT = FTy->getAs(); CGM.getTargetCodeGenInfo().setCUDAKernelCallingConvention(FT); FTy = FT->getCanonicalTypeUnqualified(); } } d267 1 a267 3 CanQualType FT = GetFormalType(MD).getAs(); setCUDAKernelCallingConvention(FT, CGM, MD); auto prototype = FT.getAs(); a426 1 setCUDAKernelCallingConvention(FTy, CGM, FD); a457 1 SmallVector extParamInfos(2); a462 3 auto extParamInfo = FunctionProtoType::ExtParameterInfo().withIsNoEscape( I->hasAttr()); extParamInfos.push_back(extParamInfo); d478 1 a478 1 /*chainCall=*/false, argTys, einfo, extParamInfos, required); d512 2 a513 2 CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) { assert(MD->isVirtual() && "only methods have thunks"); a801 1 FI->NoCfCheck = info.getNoCfCheck(); d903 2 a904 1 if (FD->isZeroLengthBitField(Context)) d925 2 a926 1 if (FD->isZeroLengthBitField(Context)) d1039 1 a1039 1 QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, d1043 6 a1048 10 Address Addr = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : 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); }); d1050 1 a1050 2 Address This = Arg.hasLValue() ? Arg.getKnownLValue().getAddress() : Arg.getKnownRValue().getAggregateAddress(); d1056 1 a1056 1 CallArg BaseArg = CallArg(RValue::getAggregate(Base), BS->getType()); d1059 1 a1059 1 ExpandTypeToArgs(BS->getType(), BaseArg, IRFuncTy, IRCallArgs, d1065 2 a1066 3 CallArg FldArg = CallArg(EmitRValueForField(LV, FD, SourceLocation()), FD->getType()); ExpandTypeToArgs(FD->getType(), FldArg, IRFuncTy, IRCallArgs, d1070 1 a1070 1 ComplexPairTy CV = Arg.getKnownRValue().getComplexVal(); a1074 1 auto RV = Arg.getKnownRValue(); d1226 1 a1226 2 Src = CGF.Builder.CreateBitCast(Src, Ty->getPointerTo(Src.getAddressSpace())); d1232 2 a1233 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address SrcCasted = CGF.Builder.CreateBitCast(Src, CGF.AllocaInt8PtrTy); d1314 2 a1315 2 Address Casted = CGF.Builder.CreateBitCast(Tmp, CGF.AllocaInt8PtrTy); Address DstCasted = CGF.Builder.CreateBitCast(Dst, CGF.AllocaInt8PtrTy); d1477 1 a1477 2 const auto &RI = FI.getReturnInfo(); return RI.isIndirect() || (RI.isInAlloca() && RI.getInAllocaSRet()); d1670 1 a1670 1 FPT->isNothrow()) a1717 5 // 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"); a1735 4 if (getLangOpts().OpenCL) FuncAttrs.addAttribute("denorms-are-zero", llvm::toStringRef(CodeGenOpts.FlushDenorm)); d1737 1 a1737 1 const std::vector &Recips = CodeGenOpts.Reciprocals; d1740 1 a1740 6 llvm::join(Recips, ",")); if (!CodeGenOpts.PreferVectorWidth.empty() && CodeGenOpts.PreferVectorWidth != "none") FuncAttrs.addAttribute("prefer-vector-width", CodeGenOpts.PreferVectorWidth); d1748 5 a1752 6 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. a1753 1 } a1754 1 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { d1783 1 a1783 1 // attributes from there. a1831 2 if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoCfCheck); d1836 4 a1839 3 if (AllocSize->getNumElemsParam().isValid()) NumElemsParam = AllocSize->getNumElemsParam().getLLVMIndex(); FuncAttrs.addAllocSizeAttr(AllocSize->getElemSizeParam().getLLVMIndex(), d1850 39 a1888 6 // Add NonLazyBind attribute to function declarations when -fno-plt // is used. if (TargetDecl && CodeGenOpts.NoPLT) { if (auto *Fn = dyn_cast(TargetDecl)) { if (!Fn->isDefined() && !AttrOnCallSite) { FuncAttrs.addAttribute(llvm::Attribute::NonLazyBind); a1889 7 } } if (TargetDecl && TargetDecl->hasAttr()) { if (getLangOpts().OpenCLVersion <= 120) { // OpenCL v1.2 Work groups are always uniform FuncAttrs.addAttribute("uniform-work-group-size", "true"); d1891 10 a1900 23 // 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)); } } if (!AttrOnCallSite) { bool DisableTailCalls = false; if (CodeGenOpts.DisableTailCalls) DisableTailCalls = true; else if (TargetDecl) { if (TargetDecl->hasAttr() || TargetDecl->hasAttr()) DisableTailCalls = true; else if (CodeGenOpts.NoEscapingBlockTailCalls) { if (const auto *BD = dyn_cast(TargetDecl)) if (!BD->doesNotEscape()) DisableTailCalls = true; a1902 4 FuncAttrs.addAttribute("disable-tail-calls", llvm::toStringRef(DisableTailCalls)); GetCPUAndFeaturesAttributes(TargetDecl, FuncAttrs); d1911 1 a1911 1 if (RetAI.isSignExt()) d1913 1 a1913 1 else d1915 1 a1915 1 LLVM_FALLTHROUGH; d1992 1 a1992 1 if (AI.isSignExt()) d1994 7 a2000 3 else Attrs.addAttribute(llvm::Attribute::ZExt); LLVM_FALLTHROUGH; a2094 3 if (FI.getExtParameterInfo(ArgNo).isNoEscape()) Attrs.addAttribute(llvm::Attribute::NoCapture); d2238 1 a2242 6 // 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())); a2740 6 if (FI.isNoReturn()) { // Noreturn functions don't return. EmitUnreachable(EndLoc); return; } d2999 1 a2999 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); a3038 13 // Deactivate the cleanup for the callee-destructed param that was pushed. if (hasAggregateEvaluationKind(type) && !CurFuncIsThunk && type->getAs()->getDecl()->isParamDestroyedInCallee() && type.isDestructedType()) { EHScopeStack::stable_iterator cleanup = CalleeDestructedParamCleanups.lookup(cast(param)); assert(cleanup.isValid() && "cleanup for callee-destructed param not recorded"); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *isActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(cleanup, isActive); } d3057 1 a3057 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3119 1 d3197 1 a3197 2 bool provablyNonNull = llvm::isKnownNonZero(srcAddr.getPointer(), CGF.CGM.getDataLayout()); d3405 7 a3411 11 // Since pointer argument are never emitted as LValue, it is safe to emit // non-null argument check for r-value only. if (!Args.back().hasLValue()) { RValue RVArg = Args.back().getKnownRValue(); EmitNonNullArgCheck(RVArg, ArgTypes[Idx], (*Arg)->getExprLoc(), AC, ParamsToSkip + Idx); // @@llvm.objectsize should never have side-effects and shouldn't need // destruction/cleanups, so we can safely "emit" it after its arg, // regardless of right-to-leftness MaybeEmitImplicitObjectSize(Idx, *Arg, RVArg); } d3431 4 a3434 9 QualType::DestructionKind DtorKind = Ty.isDestructedType(); if (DtorKind == QualType::DK_cxx_destructor) { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } else { CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Ty)); } a3452 27 RValue CallArg::getRValue(CodeGenFunction &CGF) const { if (!HasLV) return RV; LValue Copy = CGF.MakeAddrLValue(CGF.CreateMemTemp(Ty), Ty); CGF.EmitAggregateCopy(Copy, LV, Ty, AggValueSlot::DoesNotOverlap, LV.isVolatile()); IsUsed = true; return RValue::getAggregate(Copy.getAddress()); } void CallArg::copyInto(CodeGenFunction &CGF, Address Addr) const { LValue Dst = CGF.MakeAddrLValue(Addr, Ty); if (!HasLV && RV.isScalar()) CGF.EmitStoreOfScalar(RV.getScalarVal(), Dst, /*init=*/true); else if (!HasLV && RV.isComplex()) CGF.EmitStoreOfComplex(RV.getComplexVal(), Dst, /*init=*/true); else { auto Addr = HasLV ? LV.getAddress() : RV.getAggregateAddress(); LValue SrcLV = CGF.MakeAddrLValue(Addr, Ty); // We assume that call args are never copied into subobjects. CGF.EmitAggregateCopy(Dst, SrcLV, Ty, AggValueSlot::DoesNotOverlap, HasLV ? LV.isVolatileQualified() : RV.isVolatileQualified()); } IsUsed = true; } d3476 1 a3476 1 type->getAs()->getDecl()->isParamDestroyedInCallee()) { d3485 4 a3488 6 bool DestroyedInCallee = true, NeedsEHCleanup = true; if (const auto *RD = type->getAsCXXRecordDecl()) DestroyedInCallee = RD->hasNonTrivialDestructor(); else NeedsEHCleanup = needsEHCleanup(type.isDestructedType()); d3496 1 a3496 1 if (DestroyedInCallee && NeedsEHCleanup) { d3513 9 a3521 1 args.addUncopiedAggregate(L, type); d3583 3 a3585 3 SmallVector CodeGenFunction::getBundlesForFunclet(llvm::Value *Callee) { SmallVector BundleList; d3589 1 a3589 1 return BundleList; d3594 1 a3594 1 return BundleList; a3596 1 return BundleList; d3604 4 a3607 2 llvm::CallInst *call = Builder.CreateCall(callee, args, getBundlesForFunclet(callee), name); d3615 2 a3616 2 SmallVector BundleList = getBundlesForFunclet(callee); d3659 2 a3660 2 SmallVector BundleList = getBundlesForFunclet(Callee); d3680 10 d3699 1 a3699 2 llvm::Instruction **callOrInvoke, SourceLocation Loc) { d3702 1 a3702 1 assert(Callee.isOrdinary() || Callee.isVirtual()); d3749 1 a3749 2 Address SRetAlloca = Address::invalid(); llvm::Value *UnusedReturnSizePtr = nullptr; d3754 1 a3754 1 SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca); d3758 2 a3759 1 UnusedReturnSizePtr = EmitLifetimeStart(size, SRetAlloca.getPointer()); d3781 1 d3795 1 a3795 1 if (I->isAggregate()) { a3796 3 Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3798 1 a3798 1 cast(Addr.getPointer()); d3801 1 a3801 1 Addr = createInAllocaStructGEP(ArgInfo.getInAllocaFieldIndex()); d3814 2 a3815 1 I->copyInto(*this, Addr); d3822 1 a3822 1 if (!I->isAggregate()) { d3824 2 a3825 2 Address Addr = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "indirect-arg-temp"); d3828 2 a3829 1 I->copyInto(*this, Addr); d3837 3 a3839 6 // 3. If the argument is byval, but RV is not located in default // or alloca address space. Address Addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); llvm::Value *V = Addr.getPointer(); d3842 11 a3852 25 assert((FirstIRArg >= IRFuncTy->getNumParams() || IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace() == TD->getAllocaAddrSpace()) && "indirect argument must be in alloca address space"); bool NeedCopy = false; if (Addr.getAlignment() < Align && llvm::getOrEnforceKnownAlignment(V, Align.getQuantity(), *TD) < Align.getQuantity()) { NeedCopy = true; } else if (I->hasLValue()) { auto LV = I->getKnownLValue(); auto AS = LV.getAddressSpace(); if ((!ArgInfo.getIndirectByVal() && (LV.getAlignment() >= getContext().getTypeAlignInChars(I->Ty))) || (ArgInfo.getIndirectByVal() && ((AS != LangAS::Default && AS != LangAS::opencl_private && AS != CGM.getASTAllocaAddressSpace())))) { NeedCopy = true; } } if (NeedCopy) { d3854 2 a3855 2 Address AI = CreateMemTempWithoutCast( I->Ty, ArgInfo.getIndirectAlign(), "byval-temp"); d3857 1 a3857 1 I->copyInto(*this, AI); d3860 1 a3860 5 auto *T = V->getType()->getPointerElementType()->getPointerTo( CGM.getDataLayout().getAllocaAddrSpace()); IRCallArgs[FirstIRArg] = getTargetHooks().performAddrSpaceCast( *this, V, LangAS::Default, CGM.getASTAllocaAddressSpace(), T, true); d3877 2 a3878 2 if (!I->isAggregate()) V = I->getKnownRValue().getScalarVal(); d3880 1 a3880 3 V = Builder.CreateLoad( I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress()); d3918 1 a3918 1 if (!I->isAggregate()) { d3920 2 a3921 1 I->copyInto(*this, Src); d3923 1 a3923 2 Src = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); d3949 1 a3949 2 Src = Builder.CreateBitCast(Src, STy->getPointerTo(Src.getAddressSpace())); d3976 2 a3977 5 Address AllocaAddr = Address::invalid(); if (I->isAggregate()) { addr = I->hasLValue() ? I->getKnownLValue().getAddress() : I->getKnownRValue().getAggregateAddress(); a3978 1 RValue RV = I->getKnownRValue(); d3985 2 d3989 3 a3991 5 CharUnits::fromQuantity(std::max( layout->getAlignment(), scalarAlign)), "tmp", /*ArraySize=*/nullptr, &AllocaAddr); tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer()); d4009 1 a4009 1 EmitLifetimeEnd(tempSize, AllocaAddr.getPointer()); d4017 1 a4017 1 ExpandTypeToArgs(I->Ty, *I, IRFuncTy, IRCallArgs, IRArgPos); d4023 1 a4023 2 const CGCallee &ConcreteCallee = Callee.prepareConcreteCallee(*this); llvm::Value *CalleePtr = ConcreteCallee.getFunctionPointer(); a4163 9 // If we made a temporary, be sure to clean up after ourselves. Note that we // can't depend on being inside of an ExprWithCleanups, so we need to manually // pop this cleanup later on. Being eager about this is OK, since this // temporary is 'invisible' outside of the callee. if (UnusedReturnSizePtr) pushFullExprCleanup(NormalEHLifetimeMarker, SRetAlloca, UnusedReturnSizePtr); d4166 2 a4167 2 SmallVector BundleList = getBundlesForFunclet(CalleePtr); d4217 3 a4219 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4221 1 a4221 9 // Strip away the noreturn attribute to better diagnose unreachable UB. if (SanOpts.has(SanitizerKind::Unreachable)) { if (auto *F = CS.getCalledFunction()) F->removeFnAttr(llvm::Attribute::NoReturn); CS.removeAttribute(llvm::AttributeList::FunctionIndex, llvm::Attribute::NoReturn); } EmitUnreachable(Loc); d4280 3 a4282 2 if (UnusedReturnSizePtr) PopCleanupBlock(); d4360 1 a4360 2 CallArgs[AA->getParamIndex().getLLVMIndex()].getRValue( *this).getScalarVal(); a4367 11 CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const { if (isVirtual()) { const CallExpr *CE = getVirtualCallExpr(); return CGF.CGM.getCXXABI().getVirtualFunctionPointer( CGF, getVirtualMethodDecl(), getThisAddress(), getFunctionType(), CE ? CE->getLocStart() : SourceLocation()); } return *this; } @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file CGCall.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 3117 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 3117 //===--- CGCall.cpp - Encapsulate calling convention details --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // These classes wrap the information about a call or function // definition used to handle ABI compliancy. // //===----------------------------------------------------------------------===// #include "CGCall.h" #include "ABIInfo.h" #include "CGCXXABI.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Transforms/Utils/Local.h" using namespace clang; using namespace CodeGen; /***/ static unsigned 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_X86ThisCall: return llvm::CallingConv::X86_ThisCall; case CC_X86_64Win64: return llvm::CallingConv::X86_64_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 CC_X86Pascal to llvm } } /// Derives the 'this' type for codegen purposes, i.e. ignoring method /// qualification. /// FIXME: address space qualification? static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) { QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal(); return Context.getPointerType(CanQualType::CreateUnsafe(RecTy)); } /// Returns the canonical formal type of the given C++ method. static CanQual GetFormalType(const CXXMethodDecl *MD) { return MD->getType()->getCanonicalTypeUnqualified() .getAs(); } /// 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 FTNP) { // When translating an unprototyped function type, always use a // variadic type. return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(), false, None, FTNP->getExtInfo(), RequiredArgs(0)); } /// Arrange the LLVM function layout for a value of the given function /// type, on top of any implicit parameters already stored. Use the /// given ExtInfo instead of the ExtInfo from the function type. static const CGFunctionInfo &arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool IsInstanceMethod, SmallVectorImpl &prefix, CanQual FTP, FunctionType::ExtInfo extInfo) { RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, prefix.size()); // FIXME: Kill copy. for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) prefix.push_back(FTP->getParamType(i)); CanQualType resultType = FTP->getReturnType().getUnqualifiedType(); return CGT.arrangeLLVMFunctionInfo(resultType, IsInstanceMethod, prefix, extInfo, required); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { return arrangeLLVMFunctionInfo(CGT, false, prefix, FTP, FTP->getExtInfo()); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeCXXMethodType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(CGT, true, prefix, FTP, extInfo); } /// Arrange the argument and result information for a value of the /// given freestanding function type. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionType(CanQual FTP) { SmallVector argTypes; return ::arrangeFreeFunctionType(*this, argTypes, FTP); } static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) { // Set the appropriate calling convention for the Function. if (D->hasAttr()) return CC_X86StdCall; if (D->hasAttr()) return CC_X86FastCall; if (D->hasAttr()) return CC_X86ThisCall; if (D->hasAttr()) return CC_X86Pascal; if (PcsAttr *PCS = D->getAttr()) return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP); if (D->hasAttr()) return CC_PnaclCall; if (D->hasAttr()) return CC_IntelOclBicc; if (D->hasAttr()) return IsWindows ? CC_C : CC_X86_64Win64; if (D->hasAttr()) return IsWindows ? CC_X86_64SysV : CC_C; return CC_C; } static bool isAAPCSVFP(const CGFunctionInfo &FI, const TargetInfo &Target) { switch (FI.getEffectiveCallingConvention()) { case llvm::CallingConv::C: switch (Target.getTriple().getEnvironment()) { case llvm::Triple::EABIHF: case llvm::Triple::GNUEABIHF: return true; default: return false; } case llvm::CallingConv::ARM_AAPCS_VFP: return true; default: return false; } } /// Arrange the argument and result information for a call to an /// unknown C++ non-static member function of the given abstract type. /// (Zero value of 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) { SmallVector argTypes; // Add the 'this' pointer. if (RD) argTypes.push_back(GetThisType(Context, RD)); else argTypes.push_back(Context.VoidPtrTy); return ::arrangeCXXMethodType(*this, argTypes, FTP->getCanonicalTypeUnqualified().getAs()); } /// 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(MD) && "wrong method for constructors!"); assert(!isa(MD) && "wrong method for destructors!"); CanQual prototype = GetFormalType(MD); if (MD->isInstance()) { // The abstract case is perfectly fine. const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD); return arrangeCXXMethodType(ThisType, prototype.getTypePtr()); } return arrangeFreeFunctionType(prototype); } /// Arrange the argument and result information for a declaration /// or definition to the given constructor variant. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorDeclaration(const CXXConstructorDecl *D, CXXCtorType ctorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, ctorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; CanQual FTP = GetFormalType(D); // Add the formal parameters. for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) argTypes.push_back(FTP->getParamType(i)); TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes); RequiredArgs required = (D->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraArgs) { // FIXME: Kill copy. SmallVector ArgTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) ArgTypes.push_back(Context.getCanonicalParamType(i->Ty)); CanQual FPT = GetFormalType(D); RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs); GlobalDecl GD(D, CtorKind); CanQualType ResultType = TheCXXABI.HasThisReturn(GD) ? ArgTypes.front() : Context.VoidTy; FunctionType::ExtInfo Info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(ResultType, true, ArgTypes, Info, Required); } /// Arrange the argument and result information for a declaration, /// definition, or call to the given destructor variant. It so /// happens that all three cases produce the same information. const CGFunctionInfo & CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D, CXXDtorType dtorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, dtorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes); CanQual FTP = GetFormalType(D); assert(FTP->getNumParams() == 0 && "dtor with formal parameters"); assert(FTP->isVariadic() == 0 && "dtor with formal parameters"); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, RequiredArgs::All); } /// 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(FD)) if (MD->isInstance()) return arrangeCXXMethodDeclaration(MD); CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified(); assert(isa(FTy)); // When declaring a function without a prototype, always use a // non-variadic type. if (isa(FTy)) { CanQual noProto = FTy.getAs(); return arrangeLLVMFunctionInfo(noProto->getReturnType(), false, None, noProto->getExtInfo(), RequiredArgs::All); } assert(isa(FTy)); return arrangeFreeFunctionType(FTy.getAs()); } /// 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 argTys; argTys.push_back(Context.getCanonicalParamType(receiverType)); argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType())); // FIXME: Kill copy? for (const auto *I : MD->params()) { argTys.push_back(Context.getCanonicalParamType(I->getType())); } FunctionType::ExtInfo einfo; bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows(); einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows)); if (getContext().getLangOpts().ObjCAutoRefCount && MD->hasAttr()) einfo = einfo.withProducesResult(true); RequiredArgs required = (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(MD->getReturnType()), false, argTys, einfo, required); } const CGFunctionInfo & CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { // FIXME: Do we need to handle ObjCMethodDecl? const FunctionDecl *FD = cast(GD.getDecl()); if (const CXXConstructorDecl *CD = dyn_cast(FD)) return arrangeCXXConstructorDeclaration(CD, GD.getCtorType()); if (const CXXDestructorDecl *DD = dyn_cast(FD)) return arrangeCXXDestructor(DD, GD.getDtorType()); return arrangeFunctionDeclaration(FD); } /// 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) { assert(args.size() >= numExtraRequiredArgs); // 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(fnType)) { if (proto->isVariadic()) required = RequiredArgs(proto->getNumParams() + numExtraRequiredArgs); // 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(fnType))) { required = RequiredArgs(args.size()); } return CGT.arrangeFreeFunctionCall(fnType->getReturnType(), args, fnType->getExtInfo(), 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) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 0); } /// A block function call is essentially a free-function call with an /// extra implicit argument. const CGFunctionInfo & CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *fnType) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1); } const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionCall(QualType resultType, const CallArgList &args, FunctionType::ExtInfo info, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *FPT, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); FunctionType::ExtInfo info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(GetReturnType(FPT->getReturnType()), true, argTypes, info, required); } const CGFunctionInfo &CodeGenTypes::arrangeFreeFunctionDeclaration( QualType resultType, const FunctionArgList &args, const FunctionType::ExtInfo &info, bool isVariadic) { // FIXME: Kill copy. SmallVector argTypes; for (FunctionArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType((*i)->getType())); RequiredArgs required = (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, required); } const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { return arrangeLLVMFunctionInfo(getContext().VoidTy, false, None, FunctionType::ExtInfo(), RequiredArgs::All); } /// 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 IsInstanceMethod, ArrayRef argTypes, FunctionType::ExtInfo info, RequiredArgs required) { #ifndef NDEBUG for (ArrayRef::const_iterator I = argTypes.begin(), E = argTypes.end(); I != E; ++I) assert(I->isCanonicalAsParam()); #endif unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); // Lookup or create unique function info. llvm::FoldingSetNodeID ID; CGFunctionInfo::Profile(ID, IsInstanceMethod, info, required, resultType, argTypes); void *insertPos = nullptr; CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); if (FI) return *FI; // Construct the function info. We co-allocate the ArgInfos. FI = CGFunctionInfo::create(CC, IsInstanceMethod, info, resultType, argTypes, required); FunctionInfos.InsertNode(FI, insertPos); bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted; assert(inserted && "Recursively being processed?"); // Compute ABI information. 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 IsInstanceMethod, const FunctionType::ExtInfo &info, CanQualType resultType, ArrayRef argTypes, RequiredArgs required) { void *buffer = operator new(sizeof(CGFunctionInfo) + sizeof(ArgInfo) * (argTypes.size() + 1)); CGFunctionInfo *FI = new(buffer) CGFunctionInfo(); FI->CallingConvention = llvmCC; FI->EffectiveCallingConvention = llvmCC; FI->ASTCallingConvention = info.getCC(); FI->InstanceMethod = IsInstanceMethod; FI->NoReturn = info.getNoReturn(); FI->ReturnsRetained = info.getProducesResult(); FI->Required = required; FI->HasRegParm = info.getHasRegParm(); FI->RegParm = info.getRegParm(); FI->ArgStruct = nullptr; FI->NumArgs = argTypes.size(); FI->getArgsBuffer()[0].type = resultType; for (unsigned i = 0, e = argTypes.size(); i != e; ++i) FI->getArgsBuffer()[i + 1].type = argTypes[i]; return FI; } /***/ void CodeGenTypes::GetExpandedTypes(QualType type, SmallVectorImpl &expandedTypes) { if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) { uint64_t NumElts = AT->getSize().getZExtValue(); for (uint64_t Elt = 0; Elt < NumElts; ++Elt) GetExpandedTypes(AT->getElementType(), expandedTypes); } else if (const RecordType *RT = type->getAs()) { 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()) { assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) GetExpandedTypes(LargestFD->getType(), expandedTypes); } else { for (const auto *I : RD->fields()) { assert(!I->isBitField() && "Cannot expand structure with bit-field members."); GetExpandedTypes(I->getType(), expandedTypes); } } } else if (const ComplexType *CT = type->getAs()) { llvm::Type *EltTy = ConvertType(CT->getElementType()); expandedTypes.push_back(EltTy); expandedTypes.push_back(EltTy); } else expandedTypes.push_back(ConvertType(type)); } llvm::Function::arg_iterator CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, llvm::Function::arg_iterator AI) { assert(LV.isSimple() && "Unexpected non-simple lvalue during struct expansion."); if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt); LValue LV = MakeAddrLValue(EltAddr, EltTy); AI = ExpandTypeFromArgs(EltTy, LV, AI); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); 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()) { assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, LargestFD); AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI); } } else { for (const auto *FD : RD->fields()) { QualType FT = FD->getType(); // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, FD); AI = ExpandTypeFromArgs(FT, SubLV, AI); } } } else if (const ComplexType *CT = Ty->getAs()) { QualType EltTy = CT->getElementType(); llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy)); llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy)); } else { EmitStoreThroughLValue(RValue::get(AI), LV); ++AI; } return AI; } /// 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 llvm::Value * EnterStructPointerForCoercedAccess(llvm::Value *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. uint64_t FirstEltSize = CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt); if (FirstEltSize < DstSize && FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy)) return SrcPtr; // GEP into the first element. SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive"); // If the first element is a struct, recurse. llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); if (llvm::StructType *SrcSTy = dyn_cast(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(Val->getType())) { // If this is Pointer->Pointer avoid conversion to and from int. if (isa(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(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(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. /// /// 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(llvm::Value *SrcPtr, llvm::Type *Ty, CodeGenFunction &CGF) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); // If SrcTy and Ty are the same, just do a load. if (SrcTy == Ty) return CGF.Builder.CreateLoad(SrcPtr); uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty); if (llvm::StructType *SrcSTy = dyn_cast(SrcTy)) { SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); SrcTy = cast(SrcPtr->getType())->getElementType(); } uint64_t 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(Ty) || isa(Ty)) && (isa(SrcTy) || isa(SrcTy))) { llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr); return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF); } // If load is legal, just bitcast the src pointer. if (SrcSize >= DstSize) { // 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. llvm::Value *Casted = CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty)); llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); // FIXME: Use better alignment / avoid requiring aligned load. Load->setAlignment(1); return Load; } // Otherwise do coercion through memory. This is stupid, but // simple. llvm::Value *Tmp = CGF.CreateTempAlloca(Ty); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(Casted, SrcCasted, llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize), 1, false); 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? static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, llvm::Value *DestPtr, bool DestIsVolatile, bool LowAlignment) { // Prefer scalar stores to first-class aggregate stores. if (llvm::StructType *STy = dyn_cast(Val->getType())) { for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i); llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i); llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } else { llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, /// where the source and destination may have different types. /// /// 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, llvm::Value *DstPtr, bool DstIsVolatile, CodeGenFunction &CGF) { llvm::Type *SrcTy = Src->getType(); llvm::Type *DstTy = cast(DstPtr->getType())->getElementType(); if (SrcTy == DstTy) { CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); if (llvm::StructType *DstSTy = dyn_cast(DstTy)) { DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF); DstTy = cast(DstPtr->getType())->getElementType(); } // If the source and destination are integer or pointer types, just do an // extension or truncation to the desired type. if ((isa(SrcTy) || isa(SrcTy)) && (isa(DstTy) || isa(DstTy))) { Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF); CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy); // If store is legal, just bitcast the src pointer. if (SrcSize <= DstSize) { llvm::Value *Casted = CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy)); // FIXME: Use better alignment / avoid requiring aligned store. BuildAggStore(CGF, Src, Casted, DstIsVolatile, true); } 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. llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy); CGF.Builder.CreateStore(Src, Tmp); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(DstCasted, Casted, llvm::ConstantInt::get(CGF.IntPtrTy, DstSize), 1, false); } } /***/ bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { return FI.getReturnInfo().isIndirect(); } bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) { return ReturnTypeUsesSRet(FI) && getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs(); } bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { if (const BuiltinType *BT = ResultType->getAs()) { 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()) { if (const BuiltinType *BT = CT->getElementType()->getAs()) { 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); (void)Inserted; assert(Inserted && "Recursively being processed?"); bool SwapThisWithSRet = false; SmallVector argTypes; llvm::Type *resultType = nullptr; const ABIArgInfo &retAI = FI.getReturnInfo(); switch (retAI.getKind()) { case ABIArgInfo::Expand: 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: { assert(!retAI.getIndirectAlign() && "Align unused on indirect return."); resultType = llvm::Type::getVoidTy(getLLVMContext()); QualType ret = FI.getReturnType(); llvm::Type *ty = ConvertType(ret); unsigned addressSpace = Context.getTargetAddressSpace(ret); argTypes.push_back(llvm::PointerType::get(ty, addressSpace)); SwapThisWithSRet = retAI.isSRetAfterThis(); break; } case ABIArgInfo::Ignore: resultType = llvm::Type::getVoidTy(getLLVMContext()); break; } // Add in all of the required arguments. CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie; if (FI.isVariadic()) { ie = it + FI.getRequiredArgs().getNumRequiredArgs(); } else { ie = FI.arg_end(); } for (; it != ie; ++it) { const ABIArgInfo &argAI = it->info; // Insert a padding type to ensure proper alignment. if (llvm::Type *PaddingType = argAI.getPaddingType()) argTypes.push_back(PaddingType); switch (argAI.getKind()) { case ABIArgInfo::Ignore: case ABIArgInfo::InAlloca: break; case ABIArgInfo::Indirect: { // indirect arguments are always on the stack, which is addr space #0. llvm::Type *LTy = ConvertTypeForMem(it->type); argTypes.push_back(LTy->getPointerTo()); break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If the coerce-to type is a first class aggregate, flatten it. Either // way is semantically identical, but fast-isel and the optimizer // generally likes scalar values better than FCAs. // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. llvm::Type *argType = argAI.getCoerceToType(); llvm::StructType *st = dyn_cast(argType); if (st && !isAAPCSVFP(FI, getTarget())) { for (unsigned i = 0, e = st->getNumElements(); i != e; ++i) argTypes.push_back(st->getElementType(i)); } else { argTypes.push_back(argType); } break; } case ABIArgInfo::Expand: GetExpandedTypes(it->type, argTypes); break; } } // Add the inalloca struct as the last parameter type. if (llvm::StructType *ArgStruct = FI.getArgStruct()) argTypes.push_back(ArgStruct->getPointerTo()); if (SwapThisWithSRet) std::swap(argTypes[0], argTypes[1]); 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(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); if (!isFuncTypeConvertible(FPT)) return llvm::StructType::get(getLLVMContext()); const CGFunctionInfo *Info; if (isa(MD)) Info = &arrangeCXXDestructor(cast(MD), GD.getDtorType()); else Info = &arrangeCXXMethodDeclaration(MD); return GetFunctionType(*Info); } void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, const Decl *TargetDecl, AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) { llvm::AttrBuilder FuncAttrs; llvm::AttrBuilder RetAttrs; CallingConv = FI.getEffectiveCallingConvention(); if (FI.isNoReturn()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); // FIXME: handle sseregparm someday... if (TargetDecl) { if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate); if (const FunctionDecl *Fn = dyn_cast(TargetDecl)) { const FunctionProtoType *FPT = Fn->getType()->getAs(); if (FPT && FPT->isNothrow(getContext())) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Don't use [[noreturn]] or _Noreturn for a call to a virtual function. // These attributes are not inherited by overloads. const CXXMethodDecl *MD = dyn_cast(Fn); if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual())) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); } // 'const' and 'pure' attribute functions are also nounwind. if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadNone); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } else if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadOnly); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } if (TargetDecl->hasAttr()) RetAttrs.addAttribute(llvm::Attribute::NoAlias); if (TargetDecl->hasAttr()) RetAttrs.addAttribute(llvm::Attribute::NonNull); } 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.NoImplicitFloat) FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat); if (CodeGenOpts.EnableSegmentedStacks && !(TargetDecl && TargetDecl->hasAttr())) FuncAttrs.addAttribute("split-stack"); if (AttrOnCallSite) { // Attributes that should go on the call site only. if (!CodeGenOpts.SimplifyLibCalls) FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); } else { // Attributes that should go on the function, but not the call site. if (!CodeGenOpts.DisableFPElim) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); } else if (CodeGenOpts.OmitLeafFramePointer) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } else { FuncAttrs.addAttribute("no-frame-pointer-elim", "true"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } FuncAttrs.addAttribute("less-precise-fpmad", llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); FuncAttrs.addAttribute("no-infs-fp-math", llvm::toStringRef(CodeGenOpts.NoInfsFPMath)); FuncAttrs.addAttribute("no-nans-fp-math", llvm::toStringRef(CodeGenOpts.NoNaNsFPMath)); FuncAttrs.addAttribute("unsafe-fp-math", llvm::toStringRef(CodeGenOpts.UnsafeFPMath)); FuncAttrs.addAttribute("use-soft-float", llvm::toStringRef(CodeGenOpts.SoftFloat)); FuncAttrs.addAttribute("stack-protector-buffer-size", llvm::utostr(CodeGenOpts.SSPBufferSize)); if (!CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("no-realign-stack"); } QualType RetTy = FI.getReturnType(); unsigned Index = 1; bool SwapThisWithSRet = false; const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::Extend: if (RetTy->hasSignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::SExt); else if (RetTy->hasUnsignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: if (RetAI.getInReg()) RetAttrs.addAttribute(llvm::Attribute::InReg); break; case ABIArgInfo::Ignore: break; case ABIArgInfo::InAlloca: { // inalloca disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } case ABIArgInfo::Indirect: { llvm::AttrBuilder SRETAttrs; SRETAttrs.addAttribute(llvm::Attribute::StructRet); if (RetAI.getInReg()) SRETAttrs.addAttribute(llvm::Attribute::InReg); SwapThisWithSRet = RetAI.isSRetAfterThis(); PAL.push_back(llvm::AttributeSet::get( getLLVMContext(), SwapThisWithSRet ? 2 : Index, SRETAttrs)); if (!SwapThisWithSRet) ++Index; // sret disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } if (const auto *RefTy = RetTy->getAs()) { QualType PTy = RefTy->getPointeeType(); if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) RetAttrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy) .getQuantity()); else if (getContext().getTargetAddressSpace(PTy) == 0) RetAttrs.addAttribute(llvm::Attribute::NonNull); } if (RetAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs)); for (const auto &I : FI.arguments()) { QualType ParamType = I.type; const ABIArgInfo &AI = I.info; llvm::AttrBuilder Attrs; // Skip over the sret parameter when it comes second. We already handled it // above. if (Index == 2 && SwapThisWithSRet) ++Index; if (AI.getPaddingType()) { if (AI.getPaddingInReg()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, llvm::Attribute::InReg)); // Increment Index if there is padding. ++Index; } // '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 (ParamType->isSignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::SExt); else if (ParamType->isUnsignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: { if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); // FIXME: handle sseregparm someday... llvm::StructType *STy = dyn_cast(AI.getCoerceToType()); if (!isAAPCSVFP(FI, getTarget()) && STy) { unsigned Extra = STy->getNumElements()-1; // 1 will be added below. if (Attrs.hasAttributes()) for (unsigned I = 0; I < Extra; ++I) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I, Attrs)); Index += Extra; } break; } case ABIArgInfo::Indirect: if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); if (AI.getIndirectByVal()) Attrs.addAttribute(llvm::Attribute::ByVal); Attrs.addAlignmentAttr(AI.getIndirectAlign()); // byval disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; case ABIArgInfo::Ignore: // Skip increment, no matching LLVM parameter. continue; case ABIArgInfo::InAlloca: // inalloca disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); // Skip increment, no matching LLVM parameter. continue; case ABIArgInfo::Expand: { SmallVector types; // FIXME: This is rather inefficient. Do we ever actually need to do // anything here? The result should be just reconstructed on the other // side, so extension should be a non-issue. getTypes().GetExpandedTypes(ParamType, types); Index += types.size(); continue; } } if (const auto *RefTy = ParamType->getAs()) { QualType PTy = RefTy->getPointeeType(); if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) Attrs.addDereferenceableAttr(getContext().getTypeSizeInChars(PTy) .getQuantity()); else if (getContext().getTargetAddressSpace(PTy) == 0) Attrs.addAttribute(llvm::Attribute::NonNull); } if (Attrs.hasAttributes()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); ++Index; } // Add the inalloca attribute to the trailing inalloca parameter if present. if (FI.usesInAlloca()) { llvm::AttrBuilder Attrs; Attrs.addAttribute(llvm::Attribute::InAlloca); PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); } if (FuncAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs)); } /// 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(varType)) return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote"); return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote"); } void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args) { // 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(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. // Emit allocs for param decls. Give the LLVM Argument nodes names. llvm::Function::arg_iterator AI = Fn->arg_begin(); // 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. llvm::Value *ArgStruct = nullptr; if (FI.usesInAlloca()) { llvm::Function::arg_iterator EI = Fn->arg_end(); --EI; ArgStruct = EI; assert(ArgStruct->getType() == FI.getArgStruct()->getPointerTo()); } // Name the struct return parameter, which can come first or second. const ABIArgInfo &RetAI = FI.getReturnInfo(); bool SwapThisWithSRet = false; if (RetAI.isIndirect()) { SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) ++AI; AI->setName("agg.result"); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); if (SwapThisWithSRet) --AI; // Go back to the beginning for 'this'. else ++AI; // Skip the sret parameter. } // Get the function-level nonnull attribute if it exists. const NonNullAttr *NNAtt = CurCodeDecl ? CurCodeDecl->getAttr() : nullptr; // 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. enum ValOrPointer { HaveValue = 0, HavePointer = 1 }; typedef llvm::PointerIntPair ValueAndIsPtr; SmallVector 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 = 1; 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; QualType Ty = info_it->type; const ABIArgInfo &ArgI = info_it->info; bool isPromoted = isa(Arg) && cast(Arg)->isKNRPromoted(); // Skip the dummy padding argument. if (ArgI.getPaddingType()) ++AI; switch (ArgI.getKind()) { case ABIArgInfo::InAlloca: { llvm::Value *V = Builder.CreateStructGEP( ArgStruct, ArgI.getInAllocaFieldIndex(), Arg->getName()); ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); continue; // Don't increment AI! } case ABIArgInfo::Indirect: { llvm::Value *V = AI; if (!hasScalarEvaluationKind(Ty)) { // Aggregates and complex variables are accessed by reference. All we // need to do is realign the value, if requested if (ArgI.getIndirectRealign()) { llvm::Value *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. llvm::Type *I8PtrTy = Builder.getInt8PtrTy(); CharUnits Size = getContext().getTypeSizeInChars(Ty); llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy); llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy); Builder.CreateMemCpy(Dst, Src, llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()), ArgI.getIndirectAlign(), false); V = AlignedTemp; } ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); } else { // Load scalar value from indirect argument. CharUnits Alignment = getContext().getTypeAlignInChars(Ty); V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); } break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If we have the trivial case, handle it with no muss and fuss. if (!isa(ArgI.getCoerceToType()) && ArgI.getCoerceToType() == ConvertType(Ty) && ArgI.getDirectOffset() == 0) { assert(AI != Fn->arg_end() && "Argument mismatch!"); llvm::Value *V = AI; if (const ParmVarDecl *PVD = dyn_cast(Arg)) { if ((NNAtt && NNAtt->isNonNull(PVD->getFunctionScopeIndex())) || PVD->hasAttr()) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, 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(); uint64_t ArrSize = ArrTy->getSize().getZExtValue(); if (!ETy->isIncompleteType() && ETy->isConstantSizeType() && ArrSize) { llvm::AttrBuilder Attrs; Attrs.addDereferenceableAttr( getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, Attrs)); } else if (getContext().getTargetAddressSpace(ETy) == 0) { AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, 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 && !getContext().getTargetAddressSpace(ArrTy->getElementType())) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NonNull)); } } if (Arg->getType().isRestrictQualified()) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); // 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); if (const CXXMethodDecl *MD = dyn_cast_or_null(CurCodeDecl)) { if (MD->isVirtual() && Arg == CXXABIThisDecl) V = CGM.getCXXABI(). adjustThisParameterInVirtualFunctionPrologue(*this, CurGD, 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(ValueAndIsPtr(V, HaveValue)); break; } llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName()); // The alignment we need to use is the max of the requested alignment for // the argument plus the alignment required by our access code below. unsigned AlignmentToUse = CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType()); AlignmentToUse = std::max(AlignmentToUse, (unsigned)getContext().getDeclAlign(Arg).getQuantity()); Alloca->setAlignment(AlignmentToUse); llvm::Value *V = Alloca; llvm::Value *Ptr = V; // Pointer to store into. // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgI.getDirectOffset()) { Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy()); Ptr = Builder.CreateConstGEP1_32(Ptr, Offs); Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ArgI.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. llvm::StructType *STy = dyn_cast(ArgI.getCoerceToType()); if (!isAAPCSVFP(FI, getTarget()) && STy && STy->getNumElements() > 1) { uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy); llvm::Type *DstTy = cast(Ptr->getType())->getElementType(); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy); if (SrcSize <= DstSize) { Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy)); for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i); Builder.CreateStore(AI++, EltPtr); } } else { llvm::AllocaInst *TempAlloca = CreateTempAlloca(ArgI.getCoerceToType(), "coerce"); TempAlloca->setAlignment(AlignmentToUse); llvm::Value *TempV = TempAlloca; for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i); Builder.CreateStore(AI++, EltPtr); } Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse); } } else { // Simple case, just do a coerced store of the argument into the alloca. assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce"); CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this); } // Match to what EmitParmDecl is expecting for this type. if (CodeGenFunction::hasScalarEvaluationKind(Ty)) { V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); } else { ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); } continue; // Skip ++AI increment, already done. } case ABIArgInfo::Expand: { // If this structure was expanded into multiple arguments then // we need to create a temporary and reconstruct it from the // arguments. llvm::AllocaInst *Alloca = CreateMemTemp(Ty); CharUnits Align = getContext().getDeclAlign(Arg); Alloca->setAlignment(Align.getQuantity()); LValue LV = MakeAddrLValue(Alloca, Ty, Align); llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI); ArgVals.push_back(ValueAndIsPtr(Alloca, HavePointer)); // Name the arguments used in expansion and increment AI. unsigned Index = 0; for (; AI != End; ++AI, ++Index) AI->setName(Arg->getName() + "." + Twine(Index)); continue; } case ABIArgInfo::Ignore: // Initialize the local variable appropriately. if (!hasScalarEvaluationKind(Ty)) { ArgVals.push_back(ValueAndIsPtr(CreateMemTemp(Ty), HavePointer)); } else { llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType())); ArgVals.push_back(ValueAndIsPtr(U, HaveValue)); } // Skip increment, no matching LLVM parameter. continue; } ++AI; if (ArgNo == 1 && SwapThisWithSRet) ++AI; // Skip the sret parameter. } if (FI.usesInAlloca()) ++AI; assert(AI == Fn->arg_end() && "Argument mismatch!"); if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { for (int I = Args.size() - 1; I >= 0; --I) EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); } else { for (unsigned I = 0, E = Args.size(); I != E; ++I) EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); } } static void eraseUnusedBitCasts(llvm::Instruction *insn) { while (insn->use_empty()) { llvm::BitCastInst *bitcast = dyn_cast(insn); if (!bitcast) return; // This is "safe" because we would have used a ConstantExpr otherwise. insn = cast(bitcast->getOperand(0)); bitcast->eraseFromParent(); } } /// Try to emit a fused autorelease of a return result. static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // We must be immediately followed the cast. llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock(); if (BB->empty()) return nullptr; if (&BB->back() != result) return nullptr; llvm::Type *resultType = result->getType(); // result is in a BasicBlock and is therefore an Instruction. llvm::Instruction *generator = cast(result); SmallVector insnsToKill; // Look for: // %generator = bitcast %type1* %generator2 to %type2* while (llvm::BitCastInst *bitcast = dyn_cast(generator)) { // We would have emitted this as a constant if the operand weren't // an Instruction. generator = cast(bitcast->getOperand(0)); // Require the generator to be immediately followed by the cast. if (generator->getNextNode() != bitcast) return nullptr; insnsToKill.push_back(bitcast); } // Look for: // %generator = call i8* @@objc_retain(i8* %originalResult) // or // %generator = call i8* @@objc_retainAutoreleasedReturnValue(i8* %originalResult) llvm::CallInst *call = dyn_cast(generator); if (!call) return nullptr; bool doRetainAutorelease; if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) { doRetainAutorelease = true; } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints() .objc_retainAutoreleasedReturnValue) { doRetainAutorelease = false; // If we emitted an assembly marker for this call (and the // ARCEntrypoints field should have been set if so), go looking // for that call. If we can't find it, we can't do this // optimization. But it should always be the immediately previous // instruction, unless we needed bitcasts around the call. if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) { llvm::Instruction *prev = call->getPrevNode(); assert(prev); if (isa(prev)) { prev = prev->getPrevNode(); assert(prev); } assert(isa(prev)); assert(cast(prev)->getCalledValue() == CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker); insnsToKill.push_back(prev); } } else { return nullptr; } result = call->getArgOperand(0); insnsToKill.push_back(call); // Keep killing bitcasts, for sanity. Note that we no longer care // about precise ordering as long as there's exactly one use. while (llvm::BitCastInst *bitcast = dyn_cast(result)) { if (!bitcast->hasOneUse()) break; insnsToKill.push_back(bitcast); result = bitcast->getOperand(0); } // Delete all the unnecessary instructions, from latest to earliest. for (SmallVectorImpl::iterator i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i) (*i)->eraseFromParent(); // Do the fused retain/autorelease if we were asked to. if (doRetainAutorelease) result = CGF.EmitARCRetainAutoreleaseReturnValue(result); // Cast back to the result type. return CGF.Builder.CreateBitCast(result, resultType); } /// If this is a +1 of the value of an immutable 'self', remove it. static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result) { // This is only applicable to a method with an immutable 'self'. const ObjCMethodDecl *method = dyn_cast_or_null(CGF.CurCodeDecl); if (!method) return nullptr; const VarDecl *self = method->getSelfDecl(); if (!self->getType().isConstQualified()) return nullptr; // Look for a retain call. llvm::CallInst *retainCall = dyn_cast(result->stripPointerCasts()); if (!retainCall || retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain) return nullptr; // Look for an ordinary load of 'self'. llvm::Value *retainedValue = retainCall->getArgOperand(0); llvm::LoadInst *load = dyn_cast(retainedValue->stripPointerCasts()); if (!load || load->isAtomic() || load->isVolatile() || load->getPointerOperand() != CGF.GetAddrOfLocalVar(self)) return nullptr; // Okay! Burn it all down. This relies for correctness on the // assumption that the retain is emitted as part of the return and // that thereafter everything is used "linearly". llvm::Type *resultType = result->getType(); eraseUnusedBitCasts(cast(result)); assert(retainCall->use_empty()); retainCall->eraseFromParent(); eraseUnusedBitCasts(cast(retainedValue)); return CGF.Builder.CreateBitCast(load, resultType); } /// Emit an ARC autorelease of the result of a function. /// /// \return the value to actually return from the function static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // If we're returning 'self', kill the initial retain. This is a // heuristic attempt to "encourage correctness" in the really unfortunate // case where we have a return of self during a dealloc and we desperately // need to avoid the possible autorelease. if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result)) return self; // At -O0, try to emit a fused retain/autorelease. if (CGF.shouldUseFusedARCCalls()) if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result)) return fused; return CGF.EmitARCAutoreleaseReturnValue(result); } /// Heuristically search for a dominating store to the return-value slot. static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { // If there are multiple uses of the return-value slot, just check // for something immediately preceding the IP. Sometimes this can // happen with how we generate implicit-returns; it can also happen // with noreturn cleanups. if (!CGF.ReturnValue->hasOneUse()) { llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); if (IP->empty()) return nullptr; llvm::StoreInst *store = dyn_cast(&IP->back()); if (!store) return nullptr; if (store->getPointerOperand() != CGF.ReturnValue) return nullptr; assert(!store->isAtomic() && !store->isVolatile()); // see below return store; } llvm::StoreInst *store = dyn_cast(CGF.ReturnValue->user_back()); if (!store) return nullptr; // These aren't actually possible for non-coerced returns, and we // only care about non-coerced returns on this code path. assert(!store->isAtomic() && !store->isVolatile()); // Now do a first-and-dirty dominance check: just walk up the // single-predecessors chain from the current insertion point. llvm::BasicBlock *StoreBB = store->getParent(); llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); while (IP != StoreBB) { if (!(IP = IP->getSinglePredecessor())) return nullptr; } // Okay, the store's basic block dominates the insertion point; we // can do our thing. return store; } void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc) { // Functions with no result always return void. if (!ReturnValue) { Builder.CreateRetVoid(); return; } llvm::DebugLoc RetDbgLoc; llvm::Value *RV = nullptr; QualType RetTy = FI.getReturnType(); const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: // Aggregrates get evaluated directly into the destination. Sometimes we // need to return the sret value in a register, though. assert(hasAggregateEvaluationKind(RetTy)); if (RetAI.getInAllocaSRet()) { llvm::Function::arg_iterator EI = CurFn->arg_end(); --EI; llvm::Value *ArgStruct = EI; llvm::Value *SRet = Builder.CreateStructGEP(ArgStruct, RetAI.getInAllocaFieldIndex()); RV = Builder.CreateLoad(SRet, "sret"); } break; case ABIArgInfo::Indirect: { auto AI = CurFn->arg_begin(); if (RetAI.isSRetAfterThis()) ++AI; switch (getEvaluationKind(RetTy)) { case TEK_Complex: { ComplexPairTy RT = EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy), EndLoc); EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(AI, RetTy), /*isInit*/ true); break; } case TEK_Aggregate: // Do nothing; aggregrates get evaluated directly into the destination. break; case TEK_Scalar: EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), MakeNaturalAlignAddrLValue(AI, RetTy), /*isInit*/ true); break; } break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: if (RetAI.getCoerceToType() == ConvertType(RetTy) && RetAI.getDirectOffset() == 0) { // The internal return value temp always will have pointer-to-return-type // type, just do a load. // If there is a dominating store to ReturnValue, we can elide // the load, zap the store, and usually zap the alloca. if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) { // Reuse the debug location from the store unless there is // cleanup code to be emitted between the store and return // instruction. if (EmitRetDbgLoc && !AutoreleaseResult) RetDbgLoc = SI->getDebugLoc(); // Get the stored value and nuke the now-dead store. RV = SI->getValueOperand(); SI->eraseFromParent(); // If that was the only use of the return value, nuke it as well now. if (ReturnValue->use_empty() && isa(ReturnValue)) { cast(ReturnValue)->eraseFromParent(); ReturnValue = nullptr; } // Otherwise, we have to do a simple load. } else { RV = Builder.CreateLoad(ReturnValue); } } else { llvm::Value *V = ReturnValue; // If the value is offset in memory, apply the offset now. if (unsigned Offs = RetAI.getDirectOffset()) { V = Builder.CreateBitCast(V, Builder.getInt8PtrTy()); V = Builder.CreateConstGEP1_32(V, Offs); V = Builder.CreateBitCast(V, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this); } // In ARC, end functions that return a retainable type with a call // to objc_autoreleaseReturnValue. if (AutoreleaseResult) { assert(getLangOpts().ObjCAutoRefCount && !FI.isReturnsRetained() && RetTy->isObjCRetainableType()); RV = emitAutoreleaseOfResult(*this, RV); } break; case ABIArgInfo::Ignore: break; case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid(); if (!RetDbgLoc.isUnknown()) Ret->setDebugLoc(RetDbgLoc); } static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) { const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory; } static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty) { // FIXME: Generate IR in one pass, rather than going back and fixing up these // placeholders. llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty); llvm::Value *Placeholder = llvm::UndefValue::get(IRTy->getPointerTo()->getPointerTo()); Placeholder = CGF.Builder.CreateLoad(Placeholder); return AggValueSlot::forAddr(Placeholder, CharUnits::Zero(), Ty.getQualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); } void CodeGenFunction::EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc) { // StartFunction converted the ABI-lowered parameter(s) into a // local alloca. We need to turn that into an r-value suitable // for EmitCall. llvm::Value *local = GetAddrOfLocalVar(param); QualType type = param->getType(); // For the most part, we just need to load the alloca, except: // 1) aggregate r-values are actually pointers to temporaries, and // 2) references to non-scalars are pointers directly to the aggregate. // I don't know why references to scalars are different here. if (const ReferenceType *ref = type->getAs()) { if (!hasScalarEvaluationKind(ref->getPointeeType())) return args.add(RValue::getAggregate(local), type); // Locals which are references to scalars are represented // with allocas holding the pointer. return args.add(RValue::get(Builder.CreateLoad(local)), type); } assert(!isInAllocaArgument(CGM.getCXXABI(), type) && "cannot emit delegate call arguments for inalloca arguments!"); args.add(convertTempToRValue(local, type, loc), type); } static bool isProvablyNull(llvm::Value *addr) { return isa(addr); } static bool isProvablyNonNull(llvm::Value *addr) { return isa(addr); } /// Emit the actual writing-back of a writeback. static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback) { const LValue &srcLV = writeback.Source; llvm::Value *srcAddr = srcLV.getAddress(); assert(!isProvablyNull(srcAddr) && "shouldn't have writeback for provably null argument"); llvm::BasicBlock *contBB = nullptr; // If the argument wasn't provably non-null, we need to null check // before doing the store. bool provablyNonNull = isProvablyNonNull(srcAddr); if (!provablyNonNull) { llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback"); contBB = CGF.createBasicBlock("icr.done"); llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); CGF.Builder.CreateCondBr(isNull, contBB, writebackBB); CGF.EmitBlock(writebackBB); } // Load the value to writeback. llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary); // Cast it back, in case we're writing an id to a Foo* or something. value = CGF.Builder.CreateBitCast(value, cast(srcAddr->getType())->getElementType(), "icr.writeback-cast"); // Perform the writeback. // If we have a "to use" value, it's something we need to emit a use // of. This has to be carefully threaded in: if it's done after the // release it's potentially undefined behavior (and the optimizer // will ignore it), and if it happens before the retain then the // optimizer could move the release there. if (writeback.ToUse) { assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong); // Retain the new value. No need to block-copy here: the block's // being passed up the stack. value = CGF.EmitARCRetainNonBlock(value); // Emit the intrinsic use here. CGF.EmitARCIntrinsicUse(writeback.ToUse); // Load the old value (primitively). llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation()); // Put the new value in place (primitively). CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false); // Release the old value. CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime()); // Otherwise, we can just do a normal lvalue store. } else { CGF.EmitStoreThroughLValue(RValue::get(value), srcLV); } // Jump to the continuation block. if (!provablyNonNull) CGF.EmitBlock(contBB); } static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args) { for (const auto &I : args.writebacks()) emitWriteback(CGF, I); } static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs) { assert(CGF.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()); ArrayRef Cleanups = CallArgs.getCleanupsToDeactivate(); // Iterate in reverse to increase the likelihood of popping the cleanup. for (ArrayRef::reverse_iterator I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) { CGF.DeactivateCleanupBlock(I->Cleanup, I->IsActiveIP); I->IsActiveIP->eraseFromParent(); } } static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) { if (const UnaryOperator *uop = dyn_cast(E->IgnoreParens())) if (uop->getOpcode() == UO_AddrOf) return uop->getSubExpr(); return nullptr; } /// Emit an argument that's being passed call-by-writeback. That is, /// we are passing the address of static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE) { LValue srcLV; // Make an optimistic effort to emit the address as an l-value. // This can fail if the the argument expression is more complicated. if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) { srcLV = CGF.EmitLValue(lvExpr); // Otherwise, just emit it as a scalar. } else { llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr()); QualType srcAddrType = CRE->getSubExpr()->getType()->castAs()->getPointeeType(); srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType); } llvm::Value *srcAddr = srcLV.getAddress(); // The dest and src types don't necessarily match in LLVM terms // because of the crazy ObjC compatibility rules. llvm::PointerType *destType = cast(CGF.ConvertType(CRE->getType())); // If the address is a constant null, just pass the appropriate null. if (isProvablyNull(srcAddr)) { args.add(RValue::get(llvm::ConstantPointerNull::get(destType)), CRE->getType()); return; } // Create the temporary. llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(), "icr.temp"); // Loading an l-value can introduce a cleanup if the l-value is __weak, // and that cleanup will be conditional if we can't prove that the l-value // isn't null, so we need to register a dominating point so that the cleanups // system will make valid IR. CodeGenFunction::ConditionalEvaluation condEval(CGF); // Zero-initialize it if we're not doing a copy-initialization. bool shouldCopy = CRE->shouldCopy(); if (!shouldCopy) { llvm::Value *null = llvm::ConstantPointerNull::get( cast(destType->getElementType())); CGF.Builder.CreateStore(null, temp); } llvm::BasicBlock *contBB = nullptr; llvm::BasicBlock *originBB = nullptr; // If the address is *not* known to be non-null, we need to switch. llvm::Value *finalArgument; bool provablyNonNull = isProvablyNonNull(srcAddr); if (provablyNonNull) { finalArgument = temp; } else { llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); finalArgument = CGF.Builder.CreateSelect(isNull, llvm::ConstantPointerNull::get(destType), temp, "icr.argument"); // If we need to copy, then the load has to be conditional, which // means we need control flow. if (shouldCopy) { originBB = CGF.Builder.GetInsertBlock(); contBB = CGF.createBasicBlock("icr.cont"); llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy"); CGF.Builder.CreateCondBr(isNull, contBB, copyBB); CGF.EmitBlock(copyBB); condEval.begin(CGF); } } llvm::Value *valueToUse = nullptr; // Perform a copy if necessary. if (shouldCopy) { RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation()); assert(srcRV.isScalar()); llvm::Value *src = srcRV.getScalarVal(); src = CGF.Builder.CreateBitCast(src, destType->getElementType(), "icr.cast"); // Use an ordinary store, not a store-to-lvalue. CGF.Builder.CreateStore(src, temp); // If optimization is enabled, and the value was held in a // __strong variable, we need to tell the optimizer that this // value has to stay alive until we're doing the store back. // This is because the temporary is effectively unretained, // and so otherwise we can violate the high-level semantics. if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 && srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) { valueToUse = src; } } // Finish the control flow if we needed it. if (shouldCopy && !provablyNonNull) { llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock(); CGF.EmitBlock(contBB); // Make a phi for the value to intrinsically use. if (valueToUse) { llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2, "icr.to-use"); phiToUse->addIncoming(valueToUse, copyBB); phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()), originBB); valueToUse = phiToUse; } condEval.end(CGF); } args.addWriteback(srcLV, temp, valueToUse); args.add(RValue::get(finalArgument), CRE->getType()); } void CallArgList::allocateArgumentMemory(CodeGenFunction &CGF) { assert(!StackBase && !StackCleanup.isValid()); // Save the stack. llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave); StackBase = CGF.Builder.CreateCall(F, "inalloca.save"); // Control gets really tied up in landing pads, so we have to spill the // stacksave to an alloca to avoid violating SSA form. // TODO: This is dead if we never emit the cleanup. We should create the // alloca and store lazily on the first cleanup emission. StackBaseMem = CGF.CreateTempAlloca(CGF.Int8PtrTy, "inalloca.spmem"); CGF.Builder.CreateStore(StackBase, StackBaseMem); CGF.pushStackRestore(EHCleanup, StackBaseMem); StackCleanup = CGF.EHStack.getInnermostEHScope(); assert(StackCleanup.isValid()); } void CallArgList::freeArgumentMemory(CodeGenFunction &CGF) const { if (StackBase) { CGF.DeactivateCleanupBlock(StackCleanup, StackBase); llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore); // We could load StackBase from StackBaseMem, but in the non-exceptional // case we can skip it. CGF.Builder.CreateCall(F, StackBase); } } void CodeGenFunction::EmitCallArgs(CallArgList &Args, ArrayRef ArgTypes, CallExpr::const_arg_iterator ArgBeg, CallExpr::const_arg_iterator ArgEnd, bool ForceColumnInfo) { CGDebugInfo *DI = getDebugInfo(); SourceLocation CallLoc; if (DI) CallLoc = DI->getLocation(); // We *have* to evaluate arguments from right to left in the MS C++ ABI, // because arguments are destroyed left to right in the callee. if (CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { // Insert a stack save if we're going to need any inalloca args. bool HasInAllocaArgs = false; for (ArrayRef::iterator I = ArgTypes.begin(), E = ArgTypes.end(); I != E && !HasInAllocaArgs; ++I) HasInAllocaArgs = isInAllocaArgument(CGM.getCXXABI(), *I); if (HasInAllocaArgs) { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); Args.allocateArgumentMemory(*this); } // Evaluate each argument. size_t CallArgsStart = Args.size(); for (int I = ArgTypes.size() - 1; I >= 0; --I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } // Un-reverse the arguments we just evaluated so they match up with the LLVM // IR function. std::reverse(Args.begin() + CallArgsStart, Args.end()); return; } for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; assert(Arg != ArgEnd); EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } } namespace { struct DestroyUnpassedArg : EHScopeStack::Cleanup { DestroyUnpassedArg(llvm::Value *Addr, QualType Ty) : Addr(Addr), Ty(Ty) {} llvm::Value *Addr; QualType Ty; void Emit(CodeGenFunction &CGF, Flags flags) override { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } }; } void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E, QualType type) { if (const ObjCIndirectCopyRestoreExpr *CRE = dyn_cast(E)) { assert(getLangOpts().ObjCAutoRefCount); assert(getContext().hasSameType(E->getType(), type)); return emitWritebackArg(*this, args, CRE); } assert(type->isReferenceType() == E->isGLValue() && "reference binding to unmaterialized r-value!"); if (E->isGLValue()) { assert(E->getObjectKind() == OK_Ordinary); return args.add(EmitReferenceBindingToExpr(E), type); } bool HasAggregateEvalKind = hasAggregateEvaluationKind(type); // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee. // However, we still have to push an EH-only cleanup in case we unwind before // we make it to the call. if (HasAggregateEvalKind && CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { // If we're using inalloca, use the argument memory. Otherwise, use a // temporary. AggValueSlot Slot; if (args.isUsingInAlloca()) Slot = createPlaceholderSlot(*this, type); else Slot = CreateAggTemp(type, "agg.tmp"); const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); bool DestroyedInCallee = RD && RD->hasNonTrivialDestructor() && CGM.getCXXABI().getRecordArgABI(RD) != CGCXXABI::RAA_Default; if (DestroyedInCallee) Slot.setExternallyDestructed(); EmitAggExpr(E, Slot); RValue RV = Slot.asRValue(); args.add(RV, type); if (DestroyedInCallee) { // Create a no-op GEP between the placeholder and the cleanup so we can // RAUW it successfully. It also serves as a marker of the first // instruction where the cleanup is active. pushFullExprCleanup(EHCleanup, Slot.getAddr(), type); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *IsActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive); } return; } if (HasAggregateEvalKind && isa(E) && cast(E)->getCastKind() == CK_LValueToRValue) { LValue L = EmitLValue(cast(E)->getSubExpr()); assert(L.isSimple()); if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) { args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true); } else { // We can't represent a misaligned lvalue in the CallArgList, so copy // to an aligned temporary now. llvm::Value *tmp = CreateMemTemp(type); EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile(), L.getAlignment()); args.add(RValue::getAggregate(tmp), type); } return; } args.add(EmitAnyExprToTemp(E), type); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. void CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) { if (CGM.getCodeGenOpts().OptimizationLevel != 0 && !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions) Inst->setMetadata("clang.arc.no_objc_arc_exceptions", CGM.getNoObjCARCExceptionsMetadata()); } /// Emits a call to the given no-arguments nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitNounwindRuntimeCall(callee, ArrayRef(), name); } /// Emits a call to the given nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = EmitRuntimeCall(callee, args, name); call->setDoesNotThrow(); return call; } /// Emits a simple call (never an invoke) to the given no-arguments /// runtime function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitRuntimeCall(callee, ArrayRef(), name); } /// Emits a simple call (never an invoke) to the given runtime /// function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = Builder.CreateCall(callee, args, name); call->setCallingConv(getRuntimeCC()); return call; } /// Emits a call or invoke to the given noreturn runtime function. void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args) { if (getInvokeDest()) { llvm::InvokeInst *invoke = Builder.CreateInvoke(callee, getUnreachableBlock(), getInvokeDest(), args); invoke->setDoesNotReturn(); invoke->setCallingConv(getRuntimeCC()); } else { llvm::CallInst *call = Builder.CreateCall(callee, args); call->setDoesNotReturn(); call->setCallingConv(getRuntimeCC()); Builder.CreateUnreachable(); } PGO.setCurrentRegionUnreachable(); } /// Emits a call or invoke instruction to the given nullary runtime /// function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, const Twine &name) { return EmitRuntimeCallOrInvoke(callee, ArrayRef(), name); } /// Emits a call or invoke instruction to the given runtime function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args, const Twine &name) { llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name); callSite.setCallingConv(getRuntimeCC()); return callSite; } llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, const Twine &Name) { return EmitCallOrInvoke(Callee, ArrayRef(), Name); } /// Emits a call or invoke instruction to the given function, depending /// on the current state of the EH stack. llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, ArrayRef Args, const Twine &Name) { llvm::BasicBlock *InvokeDest = getInvokeDest(); llvm::Instruction *Inst; if (!InvokeDest) Inst = Builder.CreateCall(Callee, Args, Name); else { llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont"); Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name); EmitBlock(ContBB); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(Inst); return Inst; } static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo, llvm::FunctionType *FTy) { if (ArgNo < FTy->getNumParams()) assert(Elt->getType() == FTy->getParamType(ArgNo)); else assert(FTy->isVarArg()); ++ArgNo; } void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV, SmallVectorImpl &Args, llvm::FunctionType *IRFuncTy) { if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); llvm::Value *Addr = RV.getAggregateAddr(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt); RValue EltRV = convertTempToRValue(EltAddr, EltTy, SourceLocation()); ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); assert(RV.isAggregate() && "Unexpected rvalue during struct expansion"); LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty); if (RD->isUnion()) { const FieldDecl *LargestFD = nullptr; CharUnits UnionSize = CharUnits::Zero(); for (const auto *FD : RD->fields()) { assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { RValue FldRV = EmitRValueForField(LV, LargestFD, SourceLocation()); ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy); } } else { for (const auto *FD : RD->fields()) { RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy); } } } else if (Ty->isAnyComplexType()) { ComplexPairTy CV = RV.getComplexVal(); Args.push_back(CV.first); Args.push_back(CV.second); } else { assert(RV.isScalar() && "Unexpected non-scalar rvalue during struct expansion."); // Insert a bitcast as needed. llvm::Value *V = RV.getScalarVal(); if (Args.size() < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(Args.size())) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size())); Args.push_back(V); } } /// \brief Store a non-aggregate value to an address to initialize it. For /// initialization, a non-atomic store will be used. static void EmitInitStoreOfNonAggregate(CodeGenFunction &CGF, RValue Src, LValue Dst) { if (Src.isScalar()) CGF.EmitStoreOfScalar(Src.getScalarVal(), Dst, /*init=*/true); else CGF.EmitStoreOfComplex(Src.getComplexVal(), Dst, /*init=*/true); } void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New) { DeferredReplacements.push_back(std::make_pair(Old, New)); } RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &CallArgs, const Decl *TargetDecl, llvm::Instruction **callOrInvoke) { // FIXME: We no longer need the types from CallArgs; lift up and simplify. SmallVector Args; // Handle struct-return functions by passing a pointer to the // location that we would like to return into. QualType RetTy = CallInfo.getReturnType(); const ABIArgInfo &RetAI = CallInfo.getReturnInfo(); // IRArgNo - Keep track of the argument number in the callee we're looking at. unsigned IRArgNo = 0; llvm::FunctionType *IRFuncTy = cast( cast(Callee->getType())->getElementType()); // If we're using inalloca, insert the allocation after the stack save. // FIXME: Do this earlier rather than hacking it in here! llvm::Value *ArgMemory = nullptr; if (llvm::StructType *ArgStruct = CallInfo.getArgStruct()) { llvm::Instruction *IP = CallArgs.getStackBase(); llvm::AllocaInst *AI; if (IP) { IP = IP->getNextNode(); AI = new llvm::AllocaInst(ArgStruct, "argmem", IP); } else { AI = CreateTempAlloca(ArgStruct, "argmem"); } AI->setUsedWithInAlloca(true); assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca()); ArgMemory = AI; } // If the call returns a temporary with struct return, create a temporary // alloca to hold the result, unless one is given to us. llvm::Value *SRetPtr = nullptr; bool SwapThisWithSRet = false; if (RetAI.isIndirect() || RetAI.isInAlloca()) { SRetPtr = ReturnValue.getValue(); if (!SRetPtr) SRetPtr = CreateMemTemp(RetTy); if (RetAI.isIndirect()) { Args.push_back(SRetPtr); SwapThisWithSRet = RetAI.isSRetAfterThis(); if (SwapThisWithSRet) IRArgNo = 1; checkArgMatches(SRetPtr, IRArgNo, IRFuncTy); if (SwapThisWithSRet) IRArgNo = 0; } else { llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, RetAI.getInAllocaFieldIndex()); Builder.CreateStore(SRetPtr, Addr); } } assert(CallInfo.arg_size() == CallArgs.size() && "Mismatch between function signature & arguments."); CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin(); for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); I != E; ++I, ++info_it) { const ABIArgInfo &ArgInfo = info_it->info; RValue RV = I->RV; // Skip 'sret' if it came second. if (IRArgNo == 1 && SwapThisWithSRet) ++IRArgNo; CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty); // Insert a padding argument to ensure proper alignment. if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) { Args.push_back(llvm::UndefValue::get(PaddingType)); ++IRArgNo; } switch (ArgInfo.getKind()) { case ABIArgInfo::InAlloca: { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); if (RV.isAggregate()) { // Replace the placeholder with the appropriate argument slot GEP. llvm::Instruction *Placeholder = cast(RV.getAggregateAddr()); CGBuilderTy::InsertPoint IP = Builder.saveIP(); Builder.SetInsertPoint(Placeholder); llvm::Value *Addr = Builder.CreateStructGEP( ArgMemory, ArgInfo.getInAllocaFieldIndex()); Builder.restoreIP(IP); deferPlaceholderReplacement(Placeholder, Addr); } else { // Store the RValue into the argument struct. llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex()); unsigned AS = Addr->getType()->getPointerAddressSpace(); llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS); // There are some cases where a trivial bitcast is not avoidable. The // definition of a type later in a translation unit may change it's type // from {}* to (%struct.foo*)*. if (Addr->getType() != MemType) Addr = Builder.CreateBitCast(Addr, MemType); LValue argLV = MakeAddrLValue(Addr, I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); } break; // Don't increment IRArgNo! } case ABIArgInfo::Indirect: { if (RV.isScalar() || RV.isComplex()) { // Make a temporary alloca to pass the argument. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (ArgInfo.getIndirectAlign() > AI->getAlignment()) AI->setAlignment(ArgInfo.getIndirectAlign()); Args.push_back(AI); LValue argLV = MakeAddrLValue(Args.back(), I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // We want to avoid creating an unnecessary temporary+copy here; // however, we need one in three cases: // 1. If the argument is not byval, and we are required to copy the // source. (This case doesn't occur on any common architecture.) // 2. If the argument is byval, RV is not sufficiently aligned, and // we cannot force it to be sufficiently aligned. // 3. If the argument is byval, but RV is located in an address space // different than that of the argument (0). llvm::Value *Addr = RV.getAggregateAddr(); unsigned Align = ArgInfo.getIndirectAlign(); const llvm::DataLayout *TD = &CGM.getDataLayout(); const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace(); const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ? IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0); if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) || (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align && llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) || (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) { // Create an aligned temporary, and copy to it. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (Align > AI->getAlignment()) AI->setAlignment(Align); Args.push_back(AI); EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified()); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // Skip the extra memcpy call. Args.push_back(Addr); // Validate argument match. checkArgMatches(Addr, IRArgNo, IRFuncTy); } } break; } case ABIArgInfo::Ignore: break; case ABIArgInfo::Extend: case ABIArgInfo::Direct: { if (!isa(ArgInfo.getCoerceToType()) && ArgInfo.getCoerceToType() == ConvertType(info_it->type) && ArgInfo.getDirectOffset() == 0) { llvm::Value *V; if (RV.isScalar()) V = RV.getScalarVal(); else V = Builder.CreateLoad(RV.getAggregateAddr()); // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. if (IRArgNo < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(IRArgNo)) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo)); Args.push_back(V); checkArgMatches(V, IRArgNo, IRFuncTy); break; } // FIXME: Avoid the conversion through memory if possible. llvm::Value *SrcPtr; if (RV.isScalar() || RV.isComplex()) { SrcPtr = CreateMemTemp(I->Ty, "coerce"); LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, SrcLV); } else SrcPtr = RV.getAggregateAddr(); // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgInfo.getDirectOffset()) { SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy()); SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs); SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(ArgInfo.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. // We cannot do this for functions using the AAPCS calling convention, // as structures are treated differently by that calling convention. llvm::StructType *STy = dyn_cast(ArgInfo.getCoerceToType()); if (STy && !isAAPCSVFP(CallInfo, getTarget())) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy); // If the source type is smaller than the destination type of the // coerce-to logic, copy the source value into a temp alloca the size // of the destination type to allow loading all of it. The bits past // the source value are left undef. if (SrcSize < DstSize) { llvm::AllocaInst *TempAlloca = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce"); Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0); SrcPtr = TempAlloca; } else { SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(STy)); } for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i); llvm::LoadInst *LI = Builder.CreateLoad(EltPtr); // We don't know what we're loading from. LI->setAlignment(1); Args.push_back(LI); // Validate argument match. checkArgMatches(LI, IRArgNo, IRFuncTy); } } else { // In the simple case, just pass the coerced loaded value. Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), *this)); // Validate argument match. checkArgMatches(Args.back(), IRArgNo, IRFuncTy); } break; } case ABIArgInfo::Expand: ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy); IRArgNo = Args.size(); break; } } if (SwapThisWithSRet) std::swap(Args[0], Args[1]); if (ArgMemory) { llvm::Value *Arg = ArgMemory; if (CallInfo.isVariadic()) { // When passing non-POD arguments by value to variadic functions, we will // end up with a variadic prototype and an inalloca call site. In such // cases, we can't do any parameter mismatch checks. Give up and bitcast // the callee. unsigned CalleeAS = cast(Callee->getType())->getAddressSpace(); Callee = Builder.CreateBitCast( Callee, getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS)); } else { llvm::Type *LastParamTy = IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1); if (Arg->getType() != LastParamTy) { #ifndef NDEBUG // Assert that these structs have equivalent element types. llvm::StructType *FullTy = CallInfo.getArgStruct(); llvm::StructType *DeclaredTy = cast( cast(LastParamTy)->getElementType()); assert(DeclaredTy->getNumElements() == FullTy->getNumElements()); for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(), DE = DeclaredTy->element_end(), FI = FullTy->element_begin(); DI != DE; ++DI, ++FI) assert(*DI == *FI); #endif Arg = Builder.CreateBitCast(Arg, LastParamTy); } } Args.push_back(Arg); } if (!CallArgs.getCleanupsToDeactivate().empty()) deactivateArgCleanupsBeforeCall(*this, CallArgs); // If the callee is a bitcast of a function to a varargs pointer to function // type, check to see if we can remove the bitcast. This handles some cases // with unprototyped functions. if (llvm::ConstantExpr *CE = dyn_cast(Callee)) if (llvm::Function *CalleeF = dyn_cast(CE->getOperand(0))) { llvm::PointerType *CurPT=cast(Callee->getType()); llvm::FunctionType *CurFT = cast(CurPT->getElementType()); llvm::FunctionType *ActualFT = CalleeF->getFunctionType(); if (CE->getOpcode() == llvm::Instruction::BitCast && ActualFT->getReturnType() == CurFT->getReturnType() && ActualFT->getNumParams() == CurFT->getNumParams() && ActualFT->getNumParams() == Args.size() && (CurFT->isVarArg() || !ActualFT->isVarArg())) { bool ArgsMatch = true; for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i) if (ActualFT->getParamType(i) != CurFT->getParamType(i)) { ArgsMatch = false; break; } // Strip the cast if we can get away with it. This is a nice cleanup, // but also allows us to inline the function at -O0 if it is marked // always_inline. if (ArgsMatch) Callee = CalleeF; } } unsigned CallingConv; CodeGen::AttributeListType AttributeList; CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, CallingConv, true); llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), AttributeList); llvm::BasicBlock *InvokeDest = nullptr; if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind)) InvokeDest = getInvokeDest(); llvm::CallSite CS; if (!InvokeDest) { CS = Builder.CreateCall(Callee, Args); } else { llvm::BasicBlock *Cont = createBasicBlock("invoke.cont"); CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args); EmitBlock(Cont); } if (callOrInvoke) *callOrInvoke = CS.getInstruction(); if (CurCodeDecl && CurCodeDecl->hasAttr() && !CS.hasFnAttr(llvm::Attribute::NoInline)) Attrs = Attrs.addAttribute(getLLVMContext(), llvm::AttributeSet::FunctionIndex, llvm::Attribute::AlwaysInline); CS.setAttributes(Attrs); CS.setCallingConv(static_cast(CallingConv)); // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(CS.getInstruction()); // If the call doesn't return, finish the basic block and clear the // insertion point; this allows the rest of IRgen to discard // unreachable code. if (CS.doesNotReturn()) { Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); // FIXME: For now, emit a dummy basic block because expr emitters in // generally are not ready to handle emitting expressions at unreachable // points. EnsureInsertPoint(); // Return a reasonable RValue. return GetUndefRValue(RetTy); } llvm::Instruction *CI = CS.getInstruction(); if (Builder.isNamePreserving() && !CI->getType()->isVoidTy()) CI->setName("call"); // Emit any writebacks immediately. Arguably this should happen // after any return-value munging. if (CallArgs.hasWritebacks()) emitWritebacks(*this, CallArgs); // The stack cleanup for inalloca arguments has to run out of the normal // lexical order, so deactivate it and run it manually here. CallArgs.freeArgumentMemory(*this); switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: case ABIArgInfo::Indirect: return convertTempToRValue(SRetPtr, RetTy, SourceLocation()); case ABIArgInfo::Ignore: // If we are ignoring an argument that had a result, make sure to // construct the appropriate return value for our caller. return GetUndefRValue(RetTy); case ABIArgInfo::Extend: case ABIArgInfo::Direct: { llvm::Type *RetIRTy = ConvertType(RetTy); if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { llvm::Value *Real = Builder.CreateExtractValue(CI, 0); llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); return RValue::getComplex(std::make_pair(Real, Imag)); } case TEK_Aggregate: { llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "agg.tmp"); DestIsVolatile = false; } BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); return RValue::getAggregate(DestPtr); } case TEK_Scalar: { // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. llvm::Value *V = CI; if (V->getType() != RetIRTy) V = Builder.CreateBitCast(V, RetIRTy); return RValue::get(V); } } llvm_unreachable("bad evaluation kind"); } llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "coerce"); DestIsVolatile = false; } // If the value is offset in memory, apply the offset now. llvm::Value *StorePtr = DestPtr; if (unsigned Offs = RetAI.getDirectOffset()) { StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); StorePtr = Builder.CreateBitCast(StorePtr, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); return convertTempToRValue(DestPtr, RetTy, SourceLocation()); } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm_unreachable("Unhandled ABIArgInfo::Kind"); } /* VarArg handling */ llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) { return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this); } @ 1.1.1.5.4.1 log @file CGCall.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 2967 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 2967 //===--- CGCall.cpp - Encapsulate calling convention details --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // These classes wrap the information about a call or function // definition used to handle ABI compliancy. // //===----------------------------------------------------------------------===// #include "CGCall.h" #include "ABIInfo.h" #include "CGCXXABI.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/CallSite.h" #include "llvm/Transforms/Utils/Local.h" using namespace clang; using namespace CodeGen; /***/ static unsigned 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_X86ThisCall: return llvm::CallingConv::X86_ThisCall; case CC_X86_64Win64: return llvm::CallingConv::X86_64_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 CC_X86Pascal to llvm } } /// Derives the 'this' type for codegen purposes, i.e. ignoring method /// qualification. /// FIXME: address space qualification? static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) { QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal(); return Context.getPointerType(CanQualType::CreateUnsafe(RecTy)); } /// Returns the canonical formal type of the given C++ method. static CanQual GetFormalType(const CXXMethodDecl *MD) { return MD->getType()->getCanonicalTypeUnqualified() .getAs(); } /// 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 FTNP) { // When translating an unprototyped function type, always use a // variadic type. return arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(), false, None, FTNP->getExtInfo(), RequiredArgs(0)); } /// Arrange the LLVM function layout for a value of the given function /// type, on top of any implicit parameters already stored. Use the /// given ExtInfo instead of the ExtInfo from the function type. static const CGFunctionInfo &arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool IsInstanceMethod, SmallVectorImpl &prefix, CanQual FTP, FunctionType::ExtInfo extInfo) { RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, prefix.size()); // FIXME: Kill copy. for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) prefix.push_back(FTP->getParamType(i)); CanQualType resultType = FTP->getReturnType().getUnqualifiedType(); return CGT.arrangeLLVMFunctionInfo(resultType, IsInstanceMethod, prefix, extInfo, required); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { return arrangeLLVMFunctionInfo(CGT, false, prefix, FTP, FTP->getExtInfo()); } /// Arrange the argument and result information for a free function (i.e. /// not a C++ or ObjC instance method) of the given type. static const CGFunctionInfo &arrangeCXXMethodType(CodeGenTypes &CGT, SmallVectorImpl &prefix, CanQual FTP) { FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(CGT, true, prefix, FTP, extInfo); } /// Arrange the argument and result information for a value of the /// given freestanding function type. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionType(CanQual FTP) { SmallVector argTypes; return ::arrangeFreeFunctionType(*this, argTypes, FTP); } static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) { // Set the appropriate calling convention for the Function. if (D->hasAttr()) return CC_X86StdCall; if (D->hasAttr()) return CC_X86FastCall; if (D->hasAttr()) return CC_X86ThisCall; if (D->hasAttr()) return CC_X86Pascal; if (PcsAttr *PCS = D->getAttr()) return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP); if (D->hasAttr()) return CC_PnaclCall; if (D->hasAttr()) return CC_IntelOclBicc; if (D->hasAttr()) return IsWindows ? CC_C : CC_X86_64Win64; if (D->hasAttr()) return IsWindows ? CC_X86_64SysV : CC_C; 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. /// (Zero value of 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) { SmallVector argTypes; // Add the 'this' pointer. if (RD) argTypes.push_back(GetThisType(Context, RD)); else argTypes.push_back(Context.VoidPtrTy); return ::arrangeCXXMethodType(*this, argTypes, FTP->getCanonicalTypeUnqualified().getAs()); } /// 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(MD) && "wrong method for constructors!"); assert(!isa(MD) && "wrong method for destructors!"); CanQual prototype = GetFormalType(MD); if (MD->isInstance()) { // The abstract case is perfectly fine. const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD); return arrangeCXXMethodType(ThisType, prototype.getTypePtr()); } return arrangeFreeFunctionType(prototype); } /// Arrange the argument and result information for a declaration /// or definition to the given constructor variant. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorDeclaration(const CXXConstructorDecl *D, CXXCtorType ctorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, ctorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; CanQual FTP = GetFormalType(D); // Add the formal parameters. for (unsigned i = 0, e = FTP->getNumParams(); i != e; ++i) argTypes.push_back(FTP->getParamType(i)); TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes); RequiredArgs required = (D->isVariadic() ? RequiredArgs(argTypes.size()) : RequiredArgs::All); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraArgs) { // FIXME: Kill copy. SmallVector ArgTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) ArgTypes.push_back(Context.getCanonicalParamType(i->Ty)); CanQual FPT = GetFormalType(D); RequiredArgs Required = RequiredArgs::forPrototypePlus(FPT, 1 + ExtraArgs); GlobalDecl GD(D, CtorKind); CanQualType ResultType = TheCXXABI.HasThisReturn(GD) ? ArgTypes.front() : Context.VoidTy; FunctionType::ExtInfo Info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(ResultType, true, ArgTypes, Info, Required); } /// Arrange the argument and result information for a declaration, /// definition, or call to the given destructor variant. It so /// happens that all three cases produce the same information. const CGFunctionInfo & CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D, CXXDtorType dtorKind) { SmallVector argTypes; argTypes.push_back(GetThisType(Context, D->getParent())); GlobalDecl GD(D, dtorKind); CanQualType resultType = TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes); CanQual FTP = GetFormalType(D); assert(FTP->getNumParams() == 0 && "dtor with formal parameters"); assert(FTP->isVariadic() == 0 && "dtor with formal parameters"); FunctionType::ExtInfo extInfo = FTP->getExtInfo(); return arrangeLLVMFunctionInfo(resultType, true, argTypes, extInfo, RequiredArgs::All); } /// 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(FD)) if (MD->isInstance()) return arrangeCXXMethodDeclaration(MD); CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified(); assert(isa(FTy)); // When declaring a function without a prototype, always use a // non-variadic type. if (isa(FTy)) { CanQual noProto = FTy.getAs(); return arrangeLLVMFunctionInfo(noProto->getReturnType(), false, None, noProto->getExtInfo(), RequiredArgs::All); } assert(isa(FTy)); return arrangeFreeFunctionType(FTy.getAs()); } /// 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 argTys; argTys.push_back(Context.getCanonicalParamType(receiverType)); argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType())); // FIXME: Kill copy? for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(), e = MD->param_end(); i != e; ++i) { argTys.push_back(Context.getCanonicalParamType((*i)->getType())); } FunctionType::ExtInfo einfo; bool IsWindows = getContext().getTargetInfo().getTriple().isOSWindows(); einfo = einfo.withCallingConv(getCallingConventionForDecl(MD, IsWindows)); if (getContext().getLangOpts().ObjCAutoRefCount && MD->hasAttr()) einfo = einfo.withProducesResult(true); RequiredArgs required = (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(MD->getReturnType()), false, argTys, einfo, required); } const CGFunctionInfo & CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { // FIXME: Do we need to handle ObjCMethodDecl? const FunctionDecl *FD = cast(GD.getDecl()); if (const CXXConstructorDecl *CD = dyn_cast(FD)) return arrangeCXXConstructorDeclaration(CD, GD.getCtorType()); if (const CXXDestructorDecl *DD = dyn_cast(FD)) return arrangeCXXDestructor(DD, GD.getDtorType()); return arrangeFunctionDeclaration(FD); } /// 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) { assert(args.size() >= numExtraRequiredArgs); // 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(fnType)) { if (proto->isVariadic()) required = RequiredArgs(proto->getNumParams() + numExtraRequiredArgs); // 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(fnType))) { required = RequiredArgs(args.size()); } return CGT.arrangeFreeFunctionCall(fnType->getReturnType(), args, fnType->getExtInfo(), 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) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 0); } /// A block function call is essentially a free-function call with an /// extra implicit argument. const CGFunctionInfo & CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *fnType) { return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1); } const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionCall(QualType resultType, const CallArgList &args, FunctionType::ExtInfo info, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, required); } /// Arrange a call to a C++ method, passing the given arguments. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *FPT, RequiredArgs required) { // FIXME: Kill copy. SmallVector argTypes; for (CallArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType(i->Ty)); FunctionType::ExtInfo info = FPT->getExtInfo(); return arrangeLLVMFunctionInfo(GetReturnType(FPT->getReturnType()), true, argTypes, info, required); } const CGFunctionInfo &CodeGenTypes::arrangeFreeFunctionDeclaration( QualType resultType, const FunctionArgList &args, const FunctionType::ExtInfo &info, bool isVariadic) { // FIXME: Kill copy. SmallVector argTypes; for (FunctionArgList::const_iterator i = args.begin(), e = args.end(); i != e; ++i) argTypes.push_back(Context.getCanonicalParamType((*i)->getType())); RequiredArgs required = (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All); return arrangeLLVMFunctionInfo(GetReturnType(resultType), false, argTypes, info, required); } const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { return arrangeLLVMFunctionInfo(getContext().VoidTy, false, None, FunctionType::ExtInfo(), RequiredArgs::All); } /// 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 IsInstanceMethod, ArrayRef argTypes, FunctionType::ExtInfo info, RequiredArgs required) { #ifndef NDEBUG for (ArrayRef::const_iterator I = argTypes.begin(), E = argTypes.end(); I != E; ++I) assert(I->isCanonicalAsParam()); #endif unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); // Lookup or create unique function info. llvm::FoldingSetNodeID ID; CGFunctionInfo::Profile(ID, IsInstanceMethod, info, required, resultType, argTypes); void *insertPos = 0; CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); if (FI) return *FI; // Construct the function info. We co-allocate the ArgInfos. FI = CGFunctionInfo::create(CC, IsInstanceMethod, info, resultType, argTypes, required); FunctionInfos.InsertNode(FI, insertPos); bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted; assert(inserted && "Recursively being processed?"); // Compute ABI information. 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() == 0) retInfo.setCoerceToType(ConvertType(FI->getReturnType())); for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end(); I != E; ++I) if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0) 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 IsInstanceMethod, const FunctionType::ExtInfo &info, CanQualType resultType, ArrayRef argTypes, RequiredArgs required) { void *buffer = operator new(sizeof(CGFunctionInfo) + sizeof(ArgInfo) * (argTypes.size() + 1)); CGFunctionInfo *FI = new(buffer) CGFunctionInfo(); FI->CallingConvention = llvmCC; FI->EffectiveCallingConvention = llvmCC; FI->ASTCallingConvention = info.getCC(); FI->InstanceMethod = IsInstanceMethod; FI->NoReturn = info.getNoReturn(); FI->ReturnsRetained = info.getProducesResult(); FI->Required = required; FI->HasRegParm = info.getHasRegParm(); FI->RegParm = info.getRegParm(); FI->ArgStruct = 0; FI->NumArgs = argTypes.size(); FI->getArgsBuffer()[0].type = resultType; for (unsigned i = 0, e = argTypes.size(); i != e; ++i) FI->getArgsBuffer()[i + 1].type = argTypes[i]; return FI; } /***/ void CodeGenTypes::GetExpandedTypes(QualType type, SmallVectorImpl &expandedTypes) { if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) { uint64_t NumElts = AT->getSize().getZExtValue(); for (uint64_t Elt = 0; Elt < NumElts; ++Elt) GetExpandedTypes(AT->getElementType(), expandedTypes); } else if (const RecordType *RT = type->getAs()) { 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 = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) GetExpandedTypes(LargestFD->getType(), expandedTypes); } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { assert(!i->isBitField() && "Cannot expand structure with bit-field members."); GetExpandedTypes(i->getType(), expandedTypes); } } } else if (const ComplexType *CT = type->getAs()) { llvm::Type *EltTy = ConvertType(CT->getElementType()); expandedTypes.push_back(EltTy); expandedTypes.push_back(EltTy); } else expandedTypes.push_back(ConvertType(type)); } llvm::Function::arg_iterator CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, llvm::Function::arg_iterator AI) { assert(LV.isSimple() && "Unexpected non-simple lvalue during struct expansion."); if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt); LValue LV = MakeAddrLValue(EltAddr, EltTy); AI = ExpandTypeFromArgs(EltTy, LV, AI); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); 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 = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, LargestFD); AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI); } } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; QualType FT = FD->getType(); // FIXME: What are the right qualifiers here? LValue SubLV = EmitLValueForField(LV, FD); AI = ExpandTypeFromArgs(FT, SubLV, AI); } } } else if (const ComplexType *CT = Ty->getAs()) { QualType EltTy = CT->getElementType(); llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy)); llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag"); EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy)); } else { EmitStoreThroughLValue(RValue::get(AI), LV); ++AI; } return AI; } /// 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 llvm::Value * EnterStructPointerForCoercedAccess(llvm::Value *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. uint64_t FirstEltSize = CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt); if (FirstEltSize < DstSize && FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy)) return SrcPtr; // GEP into the first element. SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive"); // If the first element is a struct, recurse. llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); if (llvm::StructType *SrcSTy = dyn_cast(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(Val->getType())) { // If this is Pointer->Pointer avoid conversion to and from int. if (isa(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(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.getTypeAllocSizeInBits(Val->getType()); uint64_t DstSize = DL.getTypeAllocSizeInBits(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(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. /// /// 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(llvm::Value *SrcPtr, llvm::Type *Ty, CodeGenFunction &CGF) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); // If SrcTy and Ty are the same, just do a load. if (SrcTy == Ty) return CGF.Builder.CreateLoad(SrcPtr); uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty); if (llvm::StructType *SrcSTy = dyn_cast(SrcTy)) { SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); SrcTy = cast(SrcPtr->getType())->getElementType(); } uint64_t 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(Ty) || isa(Ty)) && (isa(SrcTy) || isa(SrcTy))) { llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr); return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF); } // If load is legal, just bitcast the src pointer. if (SrcSize >= DstSize) { // 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. llvm::Value *Casted = CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty)); llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); // FIXME: Use better alignment / avoid requiring aligned load. Load->setAlignment(1); return Load; } // Otherwise do coercion through memory. This is stupid, but // simple. llvm::Value *Tmp = CGF.CreateTempAlloca(Ty); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(Casted, SrcCasted, llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize), 1, false); 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? static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, llvm::Value *DestPtr, bool DestIsVolatile, bool LowAlignment) { // Prefer scalar stores to first-class aggregate stores. if (llvm::StructType *STy = dyn_cast(Val->getType())) { for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i); llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i); llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } else { llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile); if (LowAlignment) SI->setAlignment(1); } } /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, /// where the source and destination may have different types. /// /// 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, llvm::Value *DstPtr, bool DstIsVolatile, CodeGenFunction &CGF) { llvm::Type *SrcTy = Src->getType(); llvm::Type *DstTy = cast(DstPtr->getType())->getElementType(); if (SrcTy == DstTy) { CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); if (llvm::StructType *DstSTy = dyn_cast(DstTy)) { DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF); DstTy = cast(DstPtr->getType())->getElementType(); } // If the source and destination are integer or pointer types, just do an // extension or truncation to the desired type. if ((isa(SrcTy) || isa(SrcTy)) && (isa(DstTy) || isa(DstTy))) { Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF); CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); return; } uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy); // If store is legal, just bitcast the src pointer. if (SrcSize <= DstSize) { llvm::Value *Casted = CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy)); // FIXME: Use better alignment / avoid requiring aligned store. BuildAggStore(CGF, Src, Casted, DstIsVolatile, true); } 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. llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy); CGF.Builder.CreateStore(Src, Tmp); llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy); // FIXME: Use better alignment. CGF.Builder.CreateMemCpy(DstCasted, Casted, llvm::ConstantInt::get(CGF.IntPtrTy, DstSize), 1, false); } } /***/ bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { return FI.getReturnInfo().isIndirect(); } bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { if (const BuiltinType *BT = ResultType->getAs()) { 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()) { if (const BuiltinType *BT = CT->getElementType()->getAs()) { 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); (void)Inserted; assert(Inserted && "Recursively being processed?"); SmallVector argTypes; llvm::Type *resultType = 0; const ABIArgInfo &retAI = FI.getReturnInfo(); switch (retAI.getKind()) { case ABIArgInfo::Expand: 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: { assert(!retAI.getIndirectAlign() && "Align unused on indirect return."); resultType = llvm::Type::getVoidTy(getLLVMContext()); QualType ret = FI.getReturnType(); llvm::Type *ty = ConvertType(ret); unsigned addressSpace = Context.getTargetAddressSpace(ret); argTypes.push_back(llvm::PointerType::get(ty, addressSpace)); break; } case ABIArgInfo::Ignore: resultType = llvm::Type::getVoidTy(getLLVMContext()); break; } // Add in all of the required arguments. CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie; if (FI.isVariadic()) { ie = it + FI.getRequiredArgs().getNumRequiredArgs(); } else { ie = FI.arg_end(); } for (; it != ie; ++it) { const ABIArgInfo &argAI = it->info; // Insert a padding type to ensure proper alignment. if (llvm::Type *PaddingType = argAI.getPaddingType()) argTypes.push_back(PaddingType); switch (argAI.getKind()) { case ABIArgInfo::Ignore: case ABIArgInfo::InAlloca: break; case ABIArgInfo::Indirect: { // indirect arguments are always on the stack, which is addr space #0. llvm::Type *LTy = ConvertTypeForMem(it->type); argTypes.push_back(LTy->getPointerTo()); break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If the coerce-to type is a first class aggregate, flatten it. Either // way is semantically identical, but fast-isel and the optimizer // generally likes scalar values better than FCAs. llvm::Type *argType = argAI.getCoerceToType(); if (llvm::StructType *st = dyn_cast(argType)) { for (unsigned i = 0, e = st->getNumElements(); i != e; ++i) argTypes.push_back(st->getElementType(i)); } else { argTypes.push_back(argType); } break; } case ABIArgInfo::Expand: GetExpandedTypes(it->type, argTypes); break; } } // Add the inalloca struct as the last parameter type. if (llvm::StructType *ArgStruct = FI.getArgStruct()) argTypes.push_back(ArgStruct->getPointerTo()); 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(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); if (!isFuncTypeConvertible(FPT)) return llvm::StructType::get(getLLVMContext()); const CGFunctionInfo *Info; if (isa(MD)) Info = &arrangeCXXDestructor(cast(MD), GD.getDtorType()); else Info = &arrangeCXXMethodDeclaration(MD); return GetFunctionType(*Info); } void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, const Decl *TargetDecl, AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) { llvm::AttrBuilder FuncAttrs; llvm::AttrBuilder RetAttrs; CallingConv = FI.getEffectiveCallingConvention(); if (FI.isNoReturn()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); // FIXME: handle sseregparm someday... if (TargetDecl) { if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); if (TargetDecl->hasAttr()) FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate); if (const FunctionDecl *Fn = dyn_cast(TargetDecl)) { const FunctionProtoType *FPT = Fn->getType()->getAs(); if (FPT && FPT->isNothrow(getContext())) FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); // Don't use [[noreturn]] or _Noreturn for a call to a virtual function. // These attributes are not inherited by overloads. const CXXMethodDecl *MD = dyn_cast(Fn); if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual())) FuncAttrs.addAttribute(llvm::Attribute::NoReturn); } // 'const' and 'pure' attribute functions are also nounwind. if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadNone); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } else if (TargetDecl->hasAttr()) { FuncAttrs.addAttribute(llvm::Attribute::ReadOnly); FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); } if (TargetDecl->hasAttr()) RetAttrs.addAttribute(llvm::Attribute::NoAlias); } 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.NoImplicitFloat) FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat); if (AttrOnCallSite) { // Attributes that should go on the call site only. if (!CodeGenOpts.SimplifyLibCalls) FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); } else { // Attributes that should go on the function, but not the call site. if (!CodeGenOpts.DisableFPElim) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); } else if (CodeGenOpts.OmitLeafFramePointer) { FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } else { FuncAttrs.addAttribute("no-frame-pointer-elim", "true"); FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); } FuncAttrs.addAttribute("less-precise-fpmad", llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); FuncAttrs.addAttribute("no-infs-fp-math", llvm::toStringRef(CodeGenOpts.NoInfsFPMath)); FuncAttrs.addAttribute("no-nans-fp-math", llvm::toStringRef(CodeGenOpts.NoNaNsFPMath)); FuncAttrs.addAttribute("unsafe-fp-math", llvm::toStringRef(CodeGenOpts.UnsafeFPMath)); FuncAttrs.addAttribute("use-soft-float", llvm::toStringRef(CodeGenOpts.SoftFloat)); FuncAttrs.addAttribute("stack-protector-buffer-size", llvm::utostr(CodeGenOpts.SSPBufferSize)); if (!CodeGenOpts.StackRealignment) FuncAttrs.addAttribute("no-realign-stack"); } QualType RetTy = FI.getReturnType(); unsigned Index = 1; const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::Extend: if (RetTy->hasSignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::SExt); else if (RetTy->hasUnsignedIntegerRepresentation()) RetAttrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: if (RetAI.getInReg()) RetAttrs.addAttribute(llvm::Attribute::InReg); break; case ABIArgInfo::Ignore: break; case ABIArgInfo::InAlloca: { // inalloca disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } case ABIArgInfo::Indirect: { llvm::AttrBuilder SRETAttrs; SRETAttrs.addAttribute(llvm::Attribute::StructRet); if (RetAI.getInReg()) SRETAttrs.addAttribute(llvm::Attribute::InReg); PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), Index, SRETAttrs)); ++Index; // sret disables readnone and readonly FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } if (RetAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::ReturnIndex, RetAttrs)); for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie = FI.arg_end(); it != ie; ++it) { QualType ParamType = it->type; const ABIArgInfo &AI = it->info; llvm::AttrBuilder Attrs; if (AI.getPaddingType()) { if (AI.getPaddingInReg()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, llvm::Attribute::InReg)); // Increment Index if there is padding. ++Index; } // '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 (ParamType->isSignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::SExt); else if (ParamType->isUnsignedIntegerOrEnumerationType()) Attrs.addAttribute(llvm::Attribute::ZExt); // FALL THROUGH case ABIArgInfo::Direct: if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); // FIXME: handle sseregparm someday... if (llvm::StructType *STy = dyn_cast(AI.getCoerceToType())) { unsigned Extra = STy->getNumElements()-1; // 1 will be added below. if (Attrs.hasAttributes()) for (unsigned I = 0; I < Extra; ++I) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I, Attrs)); Index += Extra; } break; case ABIArgInfo::Indirect: if (AI.getInReg()) Attrs.addAttribute(llvm::Attribute::InReg); if (AI.getIndirectByVal()) Attrs.addAttribute(llvm::Attribute::ByVal); Attrs.addAlignmentAttr(AI.getIndirectAlign()); // byval disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); break; case ABIArgInfo::Ignore: // Skip increment, no matching LLVM parameter. continue; case ABIArgInfo::InAlloca: // inalloca disables readnone and readonly. FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) .removeAttribute(llvm::Attribute::ReadNone); // Skip increment, no matching LLVM parameter. continue; case ABIArgInfo::Expand: { SmallVector types; // FIXME: This is rather inefficient. Do we ever actually need to do // anything here? The result should be just reconstructed on the other // side, so extension should be a non-issue. getTypes().GetExpandedTypes(ParamType, types); Index += types.size(); continue; } } if (Attrs.hasAttributes()) PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); ++Index; } // Add the inalloca attribute to the trailing inalloca parameter if present. if (FI.usesInAlloca()) { llvm::AttrBuilder Attrs; Attrs.addAttribute(llvm::Attribute::InAlloca); PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); } if (FuncAttrs.hasAttributes()) PAL.push_back(llvm:: AttributeSet::get(getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs)); } /// 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(varType)) return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote"); return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote"); } void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args) { // 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(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. // Emit allocs for param decls. Give the LLVM Argument nodes names. llvm::Function::arg_iterator AI = Fn->arg_begin(); // 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. llvm::Value *ArgStruct = 0; if (FI.usesInAlloca()) { llvm::Function::arg_iterator EI = Fn->arg_end(); --EI; ArgStruct = EI; assert(ArgStruct->getType() == FI.getArgStruct()->getPointerTo()); } // Name the struct return argument. if (CGM.ReturnTypeUsesSRet(FI)) { AI->setName("agg.result"); AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); ++AI; } // 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. enum ValOrPointer { HaveValue = 0, HavePointer = 1 }; typedef llvm::PointerIntPair ValueAndIsPtr; SmallVector 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 = 1; 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; QualType Ty = info_it->type; const ABIArgInfo &ArgI = info_it->info; bool isPromoted = isa(Arg) && cast(Arg)->isKNRPromoted(); // Skip the dummy padding argument. if (ArgI.getPaddingType()) ++AI; switch (ArgI.getKind()) { case ABIArgInfo::InAlloca: { llvm::Value *V = Builder.CreateStructGEP( ArgStruct, ArgI.getInAllocaFieldIndex(), Arg->getName()); ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); continue; // Don't increment AI! } case ABIArgInfo::Indirect: { llvm::Value *V = AI; if (!hasScalarEvaluationKind(Ty)) { // Aggregates and complex variables are accessed by reference. All we // need to do is realign the value, if requested if (ArgI.getIndirectRealign()) { llvm::Value *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. llvm::Type *I8PtrTy = Builder.getInt8PtrTy(); CharUnits Size = getContext().getTypeSizeInChars(Ty); llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy); llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy); Builder.CreateMemCpy(Dst, Src, llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()), ArgI.getIndirectAlign(), false); V = AlignedTemp; } ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); } else { // Load scalar value from indirect argument. CharUnits Alignment = getContext().getTypeAlignInChars(Ty); V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); } break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: { // If we have the trivial case, handle it with no muss and fuss. if (!isa(ArgI.getCoerceToType()) && ArgI.getCoerceToType() == ConvertType(Ty) && ArgI.getDirectOffset() == 0) { assert(AI != Fn->arg_end() && "Argument mismatch!"); llvm::Value *V = AI; if (Arg->getType().isRestrictQualified()) AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), AI->getArgNo() + 1, llvm::Attribute::NoAlias)); // 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); if (const CXXMethodDecl *MD = dyn_cast_or_null(CurCodeDecl)) { if (MD->isVirtual() && Arg == CXXABIThisDecl) V = CGM.getCXXABI(). adjustThisParameterInVirtualFunctionPrologue(*this, CurGD, 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(ValueAndIsPtr(V, HaveValue)); break; } llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName()); // The alignment we need to use is the max of the requested alignment for // the argument plus the alignment required by our access code below. unsigned AlignmentToUse = CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType()); AlignmentToUse = std::max(AlignmentToUse, (unsigned)getContext().getDeclAlign(Arg).getQuantity()); Alloca->setAlignment(AlignmentToUse); llvm::Value *V = Alloca; llvm::Value *Ptr = V; // Pointer to store into. // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgI.getDirectOffset()) { Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy()); Ptr = Builder.CreateConstGEP1_32(Ptr, Offs); Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ArgI.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. llvm::StructType *STy = dyn_cast(ArgI.getCoerceToType()); if (STy && STy->getNumElements() > 1) { uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy); llvm::Type *DstTy = cast(Ptr->getType())->getElementType(); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy); if (SrcSize <= DstSize) { Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy)); for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i); Builder.CreateStore(AI++, EltPtr); } } else { llvm::AllocaInst *TempAlloca = CreateTempAlloca(ArgI.getCoerceToType(), "coerce"); TempAlloca->setAlignment(AlignmentToUse); llvm::Value *TempV = TempAlloca; for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce" + Twine(i)); llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i); Builder.CreateStore(AI++, EltPtr); } Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse); } } else { // Simple case, just do a coerced store of the argument into the alloca. assert(AI != Fn->arg_end() && "Argument mismatch!"); AI->setName(Arg->getName() + ".coerce"); CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this); } // Match to what EmitParmDecl is expecting for this type. if (CodeGenFunction::hasScalarEvaluationKind(Ty)) { V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty, Arg->getLocStart()); if (isPromoted) V = emitArgumentDemotion(*this, Arg, V); ArgVals.push_back(ValueAndIsPtr(V, HaveValue)); } else { ArgVals.push_back(ValueAndIsPtr(V, HavePointer)); } continue; // Skip ++AI increment, already done. } case ABIArgInfo::Expand: { // If this structure was expanded into multiple arguments then // we need to create a temporary and reconstruct it from the // arguments. llvm::AllocaInst *Alloca = CreateMemTemp(Ty); CharUnits Align = getContext().getDeclAlign(Arg); Alloca->setAlignment(Align.getQuantity()); LValue LV = MakeAddrLValue(Alloca, Ty, Align); llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI); ArgVals.push_back(ValueAndIsPtr(Alloca, HavePointer)); // Name the arguments used in expansion and increment AI. unsigned Index = 0; for (; AI != End; ++AI, ++Index) AI->setName(Arg->getName() + "." + Twine(Index)); continue; } case ABIArgInfo::Ignore: // Initialize the local variable appropriately. if (!hasScalarEvaluationKind(Ty)) { ArgVals.push_back(ValueAndIsPtr(CreateMemTemp(Ty), HavePointer)); } else { llvm::Value *U = llvm::UndefValue::get(ConvertType(Arg->getType())); ArgVals.push_back(ValueAndIsPtr(U, HaveValue)); } // Skip increment, no matching LLVM parameter. continue; } ++AI; } if (FI.usesInAlloca()) ++AI; assert(AI == Fn->arg_end() && "Argument mismatch!"); if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { for (int I = Args.size() - 1; I >= 0; --I) EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); } else { for (unsigned I = 0, E = Args.size(); I != E; ++I) EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(), I + 1); } } static void eraseUnusedBitCasts(llvm::Instruction *insn) { while (insn->use_empty()) { llvm::BitCastInst *bitcast = dyn_cast(insn); if (!bitcast) return; // This is "safe" because we would have used a ConstantExpr otherwise. insn = cast(bitcast->getOperand(0)); bitcast->eraseFromParent(); } } /// Try to emit a fused autorelease of a return result. static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // We must be immediately followed the cast. llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock(); if (BB->empty()) return 0; if (&BB->back() != result) return 0; llvm::Type *resultType = result->getType(); // result is in a BasicBlock and is therefore an Instruction. llvm::Instruction *generator = cast(result); SmallVector insnsToKill; // Look for: // %generator = bitcast %type1* %generator2 to %type2* while (llvm::BitCastInst *bitcast = dyn_cast(generator)) { // We would have emitted this as a constant if the operand weren't // an Instruction. generator = cast(bitcast->getOperand(0)); // Require the generator to be immediately followed by the cast. if (generator->getNextNode() != bitcast) return 0; insnsToKill.push_back(bitcast); } // Look for: // %generator = call i8* @@objc_retain(i8* %originalResult) // or // %generator = call i8* @@objc_retainAutoreleasedReturnValue(i8* %originalResult) llvm::CallInst *call = dyn_cast(generator); if (!call) return 0; bool doRetainAutorelease; if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) { doRetainAutorelease = true; } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints() .objc_retainAutoreleasedReturnValue) { doRetainAutorelease = false; // If we emitted an assembly marker for this call (and the // ARCEntrypoints field should have been set if so), go looking // for that call. If we can't find it, we can't do this // optimization. But it should always be the immediately previous // instruction, unless we needed bitcasts around the call. if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) { llvm::Instruction *prev = call->getPrevNode(); assert(prev); if (isa(prev)) { prev = prev->getPrevNode(); assert(prev); } assert(isa(prev)); assert(cast(prev)->getCalledValue() == CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker); insnsToKill.push_back(prev); } } else { return 0; } result = call->getArgOperand(0); insnsToKill.push_back(call); // Keep killing bitcasts, for sanity. Note that we no longer care // about precise ordering as long as there's exactly one use. while (llvm::BitCastInst *bitcast = dyn_cast(result)) { if (!bitcast->hasOneUse()) break; insnsToKill.push_back(bitcast); result = bitcast->getOperand(0); } // Delete all the unnecessary instructions, from latest to earliest. for (SmallVectorImpl::iterator i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i) (*i)->eraseFromParent(); // Do the fused retain/autorelease if we were asked to. if (doRetainAutorelease) result = CGF.EmitARCRetainAutoreleaseReturnValue(result); // Cast back to the result type. return CGF.Builder.CreateBitCast(result, resultType); } /// If this is a +1 of the value of an immutable 'self', remove it. static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result) { // This is only applicable to a method with an immutable 'self'. const ObjCMethodDecl *method = dyn_cast_or_null(CGF.CurCodeDecl); if (!method) return 0; const VarDecl *self = method->getSelfDecl(); if (!self->getType().isConstQualified()) return 0; // Look for a retain call. llvm::CallInst *retainCall = dyn_cast(result->stripPointerCasts()); if (!retainCall || retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain) return 0; // Look for an ordinary load of 'self'. llvm::Value *retainedValue = retainCall->getArgOperand(0); llvm::LoadInst *load = dyn_cast(retainedValue->stripPointerCasts()); if (!load || load->isAtomic() || load->isVolatile() || load->getPointerOperand() != CGF.GetAddrOfLocalVar(self)) return 0; // Okay! Burn it all down. This relies for correctness on the // assumption that the retain is emitted as part of the return and // that thereafter everything is used "linearly". llvm::Type *resultType = result->getType(); eraseUnusedBitCasts(cast(result)); assert(retainCall->use_empty()); retainCall->eraseFromParent(); eraseUnusedBitCasts(cast(retainedValue)); return CGF.Builder.CreateBitCast(load, resultType); } /// Emit an ARC autorelease of the result of a function. /// /// \return the value to actually return from the function static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { // If we're returning 'self', kill the initial retain. This is a // heuristic attempt to "encourage correctness" in the really unfortunate // case where we have a return of self during a dealloc and we desperately // need to avoid the possible autorelease. if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result)) return self; // At -O0, try to emit a fused retain/autorelease. if (CGF.shouldUseFusedARCCalls()) if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result)) return fused; return CGF.EmitARCAutoreleaseReturnValue(result); } /// Heuristically search for a dominating store to the return-value slot. static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { // If there are multiple uses of the return-value slot, just check // for something immediately preceding the IP. Sometimes this can // happen with how we generate implicit-returns; it can also happen // with noreturn cleanups. if (!CGF.ReturnValue->hasOneUse()) { llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); if (IP->empty()) return 0; llvm::StoreInst *store = dyn_cast(&IP->back()); if (!store) return 0; if (store->getPointerOperand() != CGF.ReturnValue) return 0; assert(!store->isAtomic() && !store->isVolatile()); // see below return store; } llvm::StoreInst *store = dyn_cast(CGF.ReturnValue->use_back()); if (!store) return 0; // These aren't actually possible for non-coerced returns, and we // only care about non-coerced returns on this code path. assert(!store->isAtomic() && !store->isVolatile()); // Now do a first-and-dirty dominance check: just walk up the // single-predecessors chain from the current insertion point. llvm::BasicBlock *StoreBB = store->getParent(); llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); while (IP != StoreBB) { if (!(IP = IP->getSinglePredecessor())) return 0; } // Okay, the store's basic block dominates the insertion point; we // can do our thing. return store; } void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc) { // Functions with no result always return void. if (ReturnValue == 0) { Builder.CreateRetVoid(); return; } llvm::DebugLoc RetDbgLoc; llvm::Value *RV = 0; QualType RetTy = FI.getReturnType(); const ABIArgInfo &RetAI = FI.getReturnInfo(); switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: // Aggregrates get evaluated directly into the destination. Sometimes we // need to return the sret value in a register, though. assert(hasAggregateEvaluationKind(RetTy)); if (RetAI.getInAllocaSRet()) { llvm::Function::arg_iterator EI = CurFn->arg_end(); --EI; llvm::Value *ArgStruct = EI; llvm::Value *SRet = Builder.CreateStructGEP(ArgStruct, RetAI.getInAllocaFieldIndex()); RV = Builder.CreateLoad(SRet, "sret"); } break; case ABIArgInfo::Indirect: { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { ComplexPairTy RT = EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy), EndLoc); EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), /*isInit*/ true); break; } case TEK_Aggregate: // Do nothing; aggregrates get evaluated directly into the destination. break; case TEK_Scalar: EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), /*isInit*/ true); break; } break; } case ABIArgInfo::Extend: case ABIArgInfo::Direct: if (RetAI.getCoerceToType() == ConvertType(RetTy) && RetAI.getDirectOffset() == 0) { // The internal return value temp always will have pointer-to-return-type // type, just do a load. // If there is a dominating store to ReturnValue, we can elide // the load, zap the store, and usually zap the alloca. if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) { // Reuse the debug location from the store unless there is // cleanup code to be emitted between the store and return // instruction. if (EmitRetDbgLoc && !AutoreleaseResult) RetDbgLoc = SI->getDebugLoc(); // Get the stored value and nuke the now-dead store. RV = SI->getValueOperand(); SI->eraseFromParent(); // If that was the only use of the return value, nuke it as well now. if (ReturnValue->use_empty() && isa(ReturnValue)) { cast(ReturnValue)->eraseFromParent(); ReturnValue = 0; } // Otherwise, we have to do a simple load. } else { RV = Builder.CreateLoad(ReturnValue); } } else { llvm::Value *V = ReturnValue; // If the value is offset in memory, apply the offset now. if (unsigned Offs = RetAI.getDirectOffset()) { V = Builder.CreateBitCast(V, Builder.getInt8PtrTy()); V = Builder.CreateConstGEP1_32(V, Offs); V = Builder.CreateBitCast(V, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this); } // In ARC, end functions that return a retainable type with a call // to objc_autoreleaseReturnValue. if (AutoreleaseResult) { assert(getLangOpts().ObjCAutoRefCount && !FI.isReturnsRetained() && RetTy->isObjCRetainableType()); RV = emitAutoreleaseOfResult(*this, RV); } break; case ABIArgInfo::Ignore: break; case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid(); if (!RetDbgLoc.isUnknown()) Ret->setDebugLoc(RetDbgLoc); } static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) { const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory; } static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty) { // FIXME: Generate IR in one pass, rather than going back and fixing up these // placeholders. llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty); llvm::Value *Placeholder = llvm::UndefValue::get(IRTy->getPointerTo()->getPointerTo()); Placeholder = CGF.Builder.CreateLoad(Placeholder); return AggValueSlot::forAddr(Placeholder, CharUnits::Zero(), Ty.getQualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); } void CodeGenFunction::EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc) { // StartFunction converted the ABI-lowered parameter(s) into a // local alloca. We need to turn that into an r-value suitable // for EmitCall. llvm::Value *local = GetAddrOfLocalVar(param); QualType type = param->getType(); // For the most part, we just need to load the alloca, except: // 1) aggregate r-values are actually pointers to temporaries, and // 2) references to non-scalars are pointers directly to the aggregate. // I don't know why references to scalars are different here. if (const ReferenceType *ref = type->getAs()) { if (!hasScalarEvaluationKind(ref->getPointeeType())) return args.add(RValue::getAggregate(local), type); // Locals which are references to scalars are represented // with allocas holding the pointer. return args.add(RValue::get(Builder.CreateLoad(local)), type); } if (isInAllocaArgument(CGM.getCXXABI(), type)) { AggValueSlot Slot = createPlaceholderSlot(*this, type); Slot.setExternallyDestructed(); // FIXME: Either emit a copy constructor call, or figure out how to do // guaranteed tail calls with perfect forwarding in LLVM. CGM.ErrorUnsupported(param, "non-trivial argument copy for thunk"); EmitNullInitialization(Slot.getAddr(), type); RValue RV = Slot.asRValue(); args.add(RV, type); return; } args.add(convertTempToRValue(local, type, loc), type); } static bool isProvablyNull(llvm::Value *addr) { return isa(addr); } static bool isProvablyNonNull(llvm::Value *addr) { return isa(addr); } /// Emit the actual writing-back of a writeback. static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback) { const LValue &srcLV = writeback.Source; llvm::Value *srcAddr = srcLV.getAddress(); assert(!isProvablyNull(srcAddr) && "shouldn't have writeback for provably null argument"); llvm::BasicBlock *contBB = 0; // If the argument wasn't provably non-null, we need to null check // before doing the store. bool provablyNonNull = isProvablyNonNull(srcAddr); if (!provablyNonNull) { llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback"); contBB = CGF.createBasicBlock("icr.done"); llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); CGF.Builder.CreateCondBr(isNull, contBB, writebackBB); CGF.EmitBlock(writebackBB); } // Load the value to writeback. llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary); // Cast it back, in case we're writing an id to a Foo* or something. value = CGF.Builder.CreateBitCast(value, cast(srcAddr->getType())->getElementType(), "icr.writeback-cast"); // Perform the writeback. // If we have a "to use" value, it's something we need to emit a use // of. This has to be carefully threaded in: if it's done after the // release it's potentially undefined behavior (and the optimizer // will ignore it), and if it happens before the retain then the // optimizer could move the release there. if (writeback.ToUse) { assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong); // Retain the new value. No need to block-copy here: the block's // being passed up the stack. value = CGF.EmitARCRetainNonBlock(value); // Emit the intrinsic use here. CGF.EmitARCIntrinsicUse(writeback.ToUse); // Load the old value (primitively). llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation()); // Put the new value in place (primitively). CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false); // Release the old value. CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime()); // Otherwise, we can just do a normal lvalue store. } else { CGF.EmitStoreThroughLValue(RValue::get(value), srcLV); } // Jump to the continuation block. if (!provablyNonNull) CGF.EmitBlock(contBB); } static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args) { for (CallArgList::writeback_iterator i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i) emitWriteback(CGF, *i); } static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs) { assert(CGF.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()); ArrayRef Cleanups = CallArgs.getCleanupsToDeactivate(); // Iterate in reverse to increase the likelihood of popping the cleanup. for (ArrayRef::reverse_iterator I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) { CGF.DeactivateCleanupBlock(I->Cleanup, I->IsActiveIP); I->IsActiveIP->eraseFromParent(); } } static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) { if (const UnaryOperator *uop = dyn_cast(E->IgnoreParens())) if (uop->getOpcode() == UO_AddrOf) return uop->getSubExpr(); return 0; } /// Emit an argument that's being passed call-by-writeback. That is, /// we are passing the address of static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE) { LValue srcLV; // Make an optimistic effort to emit the address as an l-value. // This can fail if the the argument expression is more complicated. if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) { srcLV = CGF.EmitLValue(lvExpr); // Otherwise, just emit it as a scalar. } else { llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr()); QualType srcAddrType = CRE->getSubExpr()->getType()->castAs()->getPointeeType(); srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType); } llvm::Value *srcAddr = srcLV.getAddress(); // The dest and src types don't necessarily match in LLVM terms // because of the crazy ObjC compatibility rules. llvm::PointerType *destType = cast(CGF.ConvertType(CRE->getType())); // If the address is a constant null, just pass the appropriate null. if (isProvablyNull(srcAddr)) { args.add(RValue::get(llvm::ConstantPointerNull::get(destType)), CRE->getType()); return; } // Create the temporary. llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(), "icr.temp"); // Loading an l-value can introduce a cleanup if the l-value is __weak, // and that cleanup will be conditional if we can't prove that the l-value // isn't null, so we need to register a dominating point so that the cleanups // system will make valid IR. CodeGenFunction::ConditionalEvaluation condEval(CGF); // Zero-initialize it if we're not doing a copy-initialization. bool shouldCopy = CRE->shouldCopy(); if (!shouldCopy) { llvm::Value *null = llvm::ConstantPointerNull::get( cast(destType->getElementType())); CGF.Builder.CreateStore(null, temp); } llvm::BasicBlock *contBB = 0; llvm::BasicBlock *originBB = 0; // If the address is *not* known to be non-null, we need to switch. llvm::Value *finalArgument; bool provablyNonNull = isProvablyNonNull(srcAddr); if (provablyNonNull) { finalArgument = temp; } else { llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); finalArgument = CGF.Builder.CreateSelect(isNull, llvm::ConstantPointerNull::get(destType), temp, "icr.argument"); // If we need to copy, then the load has to be conditional, which // means we need control flow. if (shouldCopy) { originBB = CGF.Builder.GetInsertBlock(); contBB = CGF.createBasicBlock("icr.cont"); llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy"); CGF.Builder.CreateCondBr(isNull, contBB, copyBB); CGF.EmitBlock(copyBB); condEval.begin(CGF); } } llvm::Value *valueToUse = 0; // Perform a copy if necessary. if (shouldCopy) { RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation()); assert(srcRV.isScalar()); llvm::Value *src = srcRV.getScalarVal(); src = CGF.Builder.CreateBitCast(src, destType->getElementType(), "icr.cast"); // Use an ordinary store, not a store-to-lvalue. CGF.Builder.CreateStore(src, temp); // If optimization is enabled, and the value was held in a // __strong variable, we need to tell the optimizer that this // value has to stay alive until we're doing the store back. // This is because the temporary is effectively unretained, // and so otherwise we can violate the high-level semantics. if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 && srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) { valueToUse = src; } } // Finish the control flow if we needed it. if (shouldCopy && !provablyNonNull) { llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock(); CGF.EmitBlock(contBB); // Make a phi for the value to intrinsically use. if (valueToUse) { llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2, "icr.to-use"); phiToUse->addIncoming(valueToUse, copyBB); phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()), originBB); valueToUse = phiToUse; } condEval.end(CGF); } args.addWriteback(srcLV, temp, valueToUse); args.add(RValue::get(finalArgument), CRE->getType()); } void CallArgList::allocateArgumentMemory(CodeGenFunction &CGF) { assert(!StackBase && !StackCleanup.isValid()); // Save the stack. llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave); StackBase = CGF.Builder.CreateCall(F, "inalloca.save"); // Control gets really tied up in landing pads, so we have to spill the // stacksave to an alloca to avoid violating SSA form. // TODO: This is dead if we never emit the cleanup. We should create the // alloca and store lazily on the first cleanup emission. StackBaseMem = CGF.CreateTempAlloca(CGF.Int8PtrTy, "inalloca.spmem"); CGF.Builder.CreateStore(StackBase, StackBaseMem); CGF.pushStackRestore(EHCleanup, StackBaseMem); StackCleanup = CGF.EHStack.getInnermostEHScope(); assert(StackCleanup.isValid()); } void CallArgList::freeArgumentMemory(CodeGenFunction &CGF) const { if (StackBase) { CGF.DeactivateCleanupBlock(StackCleanup, StackBase); llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore); // We could load StackBase from StackBaseMem, but in the non-exceptional // case we can skip it. CGF.Builder.CreateCall(F, StackBase); } } void CodeGenFunction::EmitCallArgs(CallArgList &Args, ArrayRef ArgTypes, CallExpr::const_arg_iterator ArgBeg, CallExpr::const_arg_iterator ArgEnd, bool ForceColumnInfo) { CGDebugInfo *DI = getDebugInfo(); SourceLocation CallLoc; if (DI) CallLoc = DI->getLocation(); // We *have* to evaluate arguments from right to left in the MS C++ ABI, // because arguments are destroyed left to right in the callee. if (CGM.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) { // Insert a stack save if we're going to need any inalloca args. bool HasInAllocaArgs = false; for (ArrayRef::iterator I = ArgTypes.begin(), E = ArgTypes.end(); I != E && !HasInAllocaArgs; ++I) HasInAllocaArgs = isInAllocaArgument(CGM.getCXXABI(), *I); if (HasInAllocaArgs) { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); Args.allocateArgumentMemory(*this); } // Evaluate each argument. size_t CallArgsStart = Args.size(); for (int I = ArgTypes.size() - 1; I >= 0; --I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } // Un-reverse the arguments we just evaluated so they match up with the LLVM // IR function. std::reverse(Args.begin() + CallArgsStart, Args.end()); return; } for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) { CallExpr::const_arg_iterator Arg = ArgBeg + I; assert(Arg != ArgEnd); EmitCallArg(Args, *Arg, ArgTypes[I]); // Restore the debug location. if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); } } namespace { struct DestroyUnpassedArg : EHScopeStack::Cleanup { DestroyUnpassedArg(llvm::Value *Addr, QualType Ty) : Addr(Addr), Ty(Ty) {} llvm::Value *Addr; QualType Ty; void Emit(CodeGenFunction &CGF, Flags flags) { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, /*Delegating=*/false, Addr); } }; } void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E, QualType type) { if (const ObjCIndirectCopyRestoreExpr *CRE = dyn_cast(E)) { assert(getLangOpts().ObjCAutoRefCount); assert(getContext().hasSameType(E->getType(), type)); return emitWritebackArg(*this, args, CRE); } assert(type->isReferenceType() == E->isGLValue() && "reference binding to unmaterialized r-value!"); if (E->isGLValue()) { assert(E->getObjectKind() == OK_Ordinary); return args.add(EmitReferenceBindingToExpr(E), type); } bool HasAggregateEvalKind = hasAggregateEvaluationKind(type); // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee. // However, we still have to push an EH-only cleanup in case we unwind before // we make it to the call. if (HasAggregateEvalKind && args.isUsingInAlloca()) { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); AggValueSlot Slot = createPlaceholderSlot(*this, type); Slot.setExternallyDestructed(); EmitAggExpr(E, Slot); RValue RV = Slot.asRValue(); args.add(RV, type); const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); if (RD->hasNonTrivialDestructor()) { // Create a no-op GEP between the placeholder and the cleanup so we can // RAUW it successfully. It also serves as a marker of the first // instruction where the cleanup is active. pushFullExprCleanup(EHCleanup, Slot.getAddr(), type); // This unreachable is a temporary marker which will be removed later. llvm::Instruction *IsActive = Builder.CreateUnreachable(); args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive); } return; } if (HasAggregateEvalKind && isa(E) && cast(E)->getCastKind() == CK_LValueToRValue) { LValue L = EmitLValue(cast(E)->getSubExpr()); assert(L.isSimple()); if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) { args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true); } else { // We can't represent a misaligned lvalue in the CallArgList, so copy // to an aligned temporary now. llvm::Value *tmp = CreateMemTemp(type); EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile(), L.getAlignment()); args.add(RValue::getAggregate(tmp), type); } return; } args.add(EmitAnyExprToTemp(E), type); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. void CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) { if (CGM.getCodeGenOpts().OptimizationLevel != 0 && !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions) Inst->setMetadata("clang.arc.no_objc_arc_exceptions", CGM.getNoObjCARCExceptionsMetadata()); } /// Emits a call to the given no-arguments nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitNounwindRuntimeCall(callee, ArrayRef(), name); } /// Emits a call to the given nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = EmitRuntimeCall(callee, args, name); call->setDoesNotThrow(); return call; } /// Emits a simple call (never an invoke) to the given no-arguments /// runtime function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, const llvm::Twine &name) { return EmitRuntimeCall(callee, ArrayRef(), name); } /// Emits a simple call (never an invoke) to the given runtime /// function. llvm::CallInst * CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, ArrayRef args, const llvm::Twine &name) { llvm::CallInst *call = Builder.CreateCall(callee, args, name); call->setCallingConv(getRuntimeCC()); return call; } /// Emits a call or invoke to the given noreturn runtime function. void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args) { if (getInvokeDest()) { llvm::InvokeInst *invoke = Builder.CreateInvoke(callee, getUnreachableBlock(), getInvokeDest(), args); invoke->setDoesNotReturn(); invoke->setCallingConv(getRuntimeCC()); } else { llvm::CallInst *call = Builder.CreateCall(callee, args); call->setDoesNotReturn(); call->setCallingConv(getRuntimeCC()); Builder.CreateUnreachable(); } PGO.setCurrentRegionUnreachable(); } /// Emits a call or invoke instruction to the given nullary runtime /// function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, const Twine &name) { return EmitRuntimeCallOrInvoke(callee, ArrayRef(), name); } /// Emits a call or invoke instruction to the given runtime function. llvm::CallSite CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef args, const Twine &name) { llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name); callSite.setCallingConv(getRuntimeCC()); return callSite; } llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, const Twine &Name) { return EmitCallOrInvoke(Callee, ArrayRef(), Name); } /// Emits a call or invoke instruction to the given function, depending /// on the current state of the EH stack. llvm::CallSite CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, ArrayRef Args, const Twine &Name) { llvm::BasicBlock *InvokeDest = getInvokeDest(); llvm::Instruction *Inst; if (!InvokeDest) Inst = Builder.CreateCall(Callee, Args, Name); else { llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont"); Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name); EmitBlock(ContBB); } // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(Inst); return Inst; } static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo, llvm::FunctionType *FTy) { if (ArgNo < FTy->getNumParams()) assert(Elt->getType() == FTy->getParamType(ArgNo)); else assert(FTy->isVarArg()); ++ArgNo; } void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV, SmallVectorImpl &Args, llvm::FunctionType *IRFuncTy) { if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { unsigned NumElts = AT->getSize().getZExtValue(); QualType EltTy = AT->getElementType(); llvm::Value *Addr = RV.getAggregateAddr(); for (unsigned Elt = 0; Elt < NumElts; ++Elt) { llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt); RValue EltRV = convertTempToRValue(EltAddr, EltTy, SourceLocation()); ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy); } } else if (const RecordType *RT = Ty->getAs()) { RecordDecl *RD = RT->getDecl(); assert(RV.isAggregate() && "Unexpected rvalue during struct expansion"); LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty); if (RD->isUnion()) { const FieldDecl *LargestFD = 0; CharUnits UnionSize = CharUnits::Zero(); for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { const FieldDecl *FD = *i; assert(!FD->isBitField() && "Cannot expand structure with bit-field members."); CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); if (UnionSize < FieldSize) { UnionSize = FieldSize; LargestFD = FD; } } if (LargestFD) { RValue FldRV = EmitRValueForField(LV, LargestFD, SourceLocation()); ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy); } } else { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy); } } } else if (Ty->isAnyComplexType()) { ComplexPairTy CV = RV.getComplexVal(); Args.push_back(CV.first); Args.push_back(CV.second); } else { assert(RV.isScalar() && "Unexpected non-scalar rvalue during struct expansion."); // Insert a bitcast as needed. llvm::Value *V = RV.getScalarVal(); if (Args.size() < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(Args.size())) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size())); Args.push_back(V); } } /// \brief Store a non-aggregate value to an address to initialize it. For /// initialization, a non-atomic store will be used. static void EmitInitStoreOfNonAggregate(CodeGenFunction &CGF, RValue Src, LValue Dst) { if (Src.isScalar()) CGF.EmitStoreOfScalar(Src.getScalarVal(), Dst, /*init=*/true); else CGF.EmitStoreOfComplex(Src.getComplexVal(), Dst, /*init=*/true); } void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New) { DeferredReplacements.push_back(std::make_pair(Old, New)); } RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &CallArgs, const Decl *TargetDecl, llvm::Instruction **callOrInvoke) { // FIXME: We no longer need the types from CallArgs; lift up and simplify. SmallVector Args; // Handle struct-return functions by passing a pointer to the // location that we would like to return into. QualType RetTy = CallInfo.getReturnType(); const ABIArgInfo &RetAI = CallInfo.getReturnInfo(); // IRArgNo - Keep track of the argument number in the callee we're looking at. unsigned IRArgNo = 0; llvm::FunctionType *IRFuncTy = cast( cast(Callee->getType())->getElementType()); // If we're using inalloca, insert the allocation after the stack save. // FIXME: Do this earlier rather than hacking it in here! llvm::Value *ArgMemory = 0; if (llvm::StructType *ArgStruct = CallInfo.getArgStruct()) { llvm::AllocaInst *AI = new llvm::AllocaInst( ArgStruct, "argmem", CallArgs.getStackBase()->getNextNode()); AI->setUsedWithInAlloca(true); assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca()); ArgMemory = AI; } // If the call returns a temporary with struct return, create a temporary // alloca to hold the result, unless one is given to us. llvm::Value *SRetPtr = 0; if (CGM.ReturnTypeUsesSRet(CallInfo) || RetAI.isInAlloca()) { SRetPtr = ReturnValue.getValue(); if (!SRetPtr) SRetPtr = CreateMemTemp(RetTy); if (CGM.ReturnTypeUsesSRet(CallInfo)) { Args.push_back(SRetPtr); checkArgMatches(SRetPtr, IRArgNo, IRFuncTy); } else { llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, RetAI.getInAllocaFieldIndex()); Builder.CreateStore(SRetPtr, Addr); } } assert(CallInfo.arg_size() == CallArgs.size() && "Mismatch between function signature & arguments."); CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin(); for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); I != E; ++I, ++info_it) { const ABIArgInfo &ArgInfo = info_it->info; RValue RV = I->RV; CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty); // Insert a padding argument to ensure proper alignment. if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) { Args.push_back(llvm::UndefValue::get(PaddingType)); ++IRArgNo; } switch (ArgInfo.getKind()) { case ABIArgInfo::InAlloca: { assert(getTarget().getTriple().getArch() == llvm::Triple::x86); if (RV.isAggregate()) { // Replace the placeholder with the appropriate argument slot GEP. llvm::Instruction *Placeholder = cast(RV.getAggregateAddr()); CGBuilderTy::InsertPoint IP = Builder.saveIP(); Builder.SetInsertPoint(Placeholder); llvm::Value *Addr = Builder.CreateStructGEP( ArgMemory, ArgInfo.getInAllocaFieldIndex()); Builder.restoreIP(IP); deferPlaceholderReplacement(Placeholder, Addr); } else { // Store the RValue into the argument struct. llvm::Value *Addr = Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex()); LValue argLV = MakeAddrLValue(Addr, I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); } break; // Don't increment IRArgNo! } case ABIArgInfo::Indirect: { if (RV.isScalar() || RV.isComplex()) { // Make a temporary alloca to pass the argument. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (ArgInfo.getIndirectAlign() > AI->getAlignment()) AI->setAlignment(ArgInfo.getIndirectAlign()); Args.push_back(AI); LValue argLV = MakeAddrLValue(Args.back(), I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, argLV); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // We want to avoid creating an unnecessary temporary+copy here; // however, we need one in three cases: // 1. If the argument is not byval, and we are required to copy the // source. (This case doesn't occur on any common architecture.) // 2. If the argument is byval, RV is not sufficiently aligned, and // we cannot force it to be sufficiently aligned. // 3. If the argument is byval, but RV is located in an address space // different than that of the argument (0). llvm::Value *Addr = RV.getAggregateAddr(); unsigned Align = ArgInfo.getIndirectAlign(); const llvm::DataLayout *TD = &CGM.getDataLayout(); const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace(); const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ? IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0); if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) || (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align && llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) || (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) { // Create an aligned temporary, and copy to it. llvm::AllocaInst *AI = CreateMemTemp(I->Ty); if (Align > AI->getAlignment()) AI->setAlignment(Align); Args.push_back(AI); EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified()); // Validate argument match. checkArgMatches(AI, IRArgNo, IRFuncTy); } else { // Skip the extra memcpy call. Args.push_back(Addr); // Validate argument match. checkArgMatches(Addr, IRArgNo, IRFuncTy); } } break; } case ABIArgInfo::Ignore: break; case ABIArgInfo::Extend: case ABIArgInfo::Direct: { if (!isa(ArgInfo.getCoerceToType()) && ArgInfo.getCoerceToType() == ConvertType(info_it->type) && ArgInfo.getDirectOffset() == 0) { llvm::Value *V; if (RV.isScalar()) V = RV.getScalarVal(); else V = Builder.CreateLoad(RV.getAggregateAddr()); // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. if (IRArgNo < IRFuncTy->getNumParams() && V->getType() != IRFuncTy->getParamType(IRArgNo)) V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo)); Args.push_back(V); checkArgMatches(V, IRArgNo, IRFuncTy); break; } // FIXME: Avoid the conversion through memory if possible. llvm::Value *SrcPtr; if (RV.isScalar() || RV.isComplex()) { SrcPtr = CreateMemTemp(I->Ty, "coerce"); LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign); EmitInitStoreOfNonAggregate(*this, RV, SrcLV); } else SrcPtr = RV.getAggregateAddr(); // If the value is offset in memory, apply the offset now. if (unsigned Offs = ArgInfo.getDirectOffset()) { SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy()); SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs); SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(ArgInfo.getCoerceToType())); } // If the coerce-to type is a first class aggregate, we flatten it and // pass the elements. Either way is semantically identical, but fast-isel // and the optimizer generally likes scalar values better than FCAs. if (llvm::StructType *STy = dyn_cast(ArgInfo.getCoerceToType())) { llvm::Type *SrcTy = cast(SrcPtr->getType())->getElementType(); uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy); uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy); // If the source type is smaller than the destination type of the // coerce-to logic, copy the source value into a temp alloca the size // of the destination type to allow loading all of it. The bits past // the source value are left undef. if (SrcSize < DstSize) { llvm::AllocaInst *TempAlloca = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce"); Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0); SrcPtr = TempAlloca; } else { SrcPtr = Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(STy)); } for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i); llvm::LoadInst *LI = Builder.CreateLoad(EltPtr); // We don't know what we're loading from. LI->setAlignment(1); Args.push_back(LI); // Validate argument match. checkArgMatches(LI, IRArgNo, IRFuncTy); } } else { // In the simple case, just pass the coerced loaded value. Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), *this)); // Validate argument match. checkArgMatches(Args.back(), IRArgNo, IRFuncTy); } break; } case ABIArgInfo::Expand: ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy); IRArgNo = Args.size(); break; } } if (ArgMemory) { llvm::Value *Arg = ArgMemory; llvm::Type *LastParamTy = IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1); if (Arg->getType() != LastParamTy) { #ifndef NDEBUG // Assert that these structs have equivalent element types. llvm::StructType *FullTy = CallInfo.getArgStruct(); llvm::StructType *Prefix = cast( cast(LastParamTy)->getElementType()); // For variadic functions, the caller might supply a larger struct than // the callee expects, and that's OK. assert(Prefix->getNumElements() == FullTy->getNumElements() || (CallInfo.isVariadic() && Prefix->getNumElements() <= FullTy->getNumElements())); for (llvm::StructType::element_iterator PI = Prefix->element_begin(), PE = Prefix->element_end(), FI = FullTy->element_begin(); PI != PE; ++PI, ++FI) assert(*PI == *FI); #endif Arg = Builder.CreateBitCast(Arg, LastParamTy); } Args.push_back(Arg); } if (!CallArgs.getCleanupsToDeactivate().empty()) deactivateArgCleanupsBeforeCall(*this, CallArgs); // If the callee is a bitcast of a function to a varargs pointer to function // type, check to see if we can remove the bitcast. This handles some cases // with unprototyped functions. if (llvm::ConstantExpr *CE = dyn_cast(Callee)) if (llvm::Function *CalleeF = dyn_cast(CE->getOperand(0))) { llvm::PointerType *CurPT=cast(Callee->getType()); llvm::FunctionType *CurFT = cast(CurPT->getElementType()); llvm::FunctionType *ActualFT = CalleeF->getFunctionType(); if (CE->getOpcode() == llvm::Instruction::BitCast && ActualFT->getReturnType() == CurFT->getReturnType() && ActualFT->getNumParams() == CurFT->getNumParams() && ActualFT->getNumParams() == Args.size() && (CurFT->isVarArg() || !ActualFT->isVarArg())) { bool ArgsMatch = true; for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i) if (ActualFT->getParamType(i) != CurFT->getParamType(i)) { ArgsMatch = false; break; } // Strip the cast if we can get away with it. This is a nice cleanup, // but also allows us to inline the function at -O0 if it is marked // always_inline. if (ArgsMatch) Callee = CalleeF; } } unsigned CallingConv; CodeGen::AttributeListType AttributeList; CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, CallingConv, true); llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), AttributeList); llvm::BasicBlock *InvokeDest = 0; if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind)) InvokeDest = getInvokeDest(); llvm::CallSite CS; if (!InvokeDest) { CS = Builder.CreateCall(Callee, Args); } else { llvm::BasicBlock *Cont = createBasicBlock("invoke.cont"); CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args); EmitBlock(Cont); } if (callOrInvoke) *callOrInvoke = CS.getInstruction(); CS.setAttributes(Attrs); CS.setCallingConv(static_cast(CallingConv)); // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC // optimizer it can aggressively ignore unwind edges. if (CGM.getLangOpts().ObjCAutoRefCount) AddObjCARCExceptionMetadata(CS.getInstruction()); // If the call doesn't return, finish the basic block and clear the // insertion point; this allows the rest of IRgen to discard // unreachable code. if (CS.doesNotReturn()) { Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); // FIXME: For now, emit a dummy basic block because expr emitters in // generally are not ready to handle emitting expressions at unreachable // points. EnsureInsertPoint(); // Return a reasonable RValue. return GetUndefRValue(RetTy); } llvm::Instruction *CI = CS.getInstruction(); if (Builder.isNamePreserving() && !CI->getType()->isVoidTy()) CI->setName("call"); // Emit any writebacks immediately. Arguably this should happen // after any return-value munging. if (CallArgs.hasWritebacks()) emitWritebacks(*this, CallArgs); // The stack cleanup for inalloca arguments has to run out of the normal // lexical order, so deactivate it and run it manually here. CallArgs.freeArgumentMemory(*this); switch (RetAI.getKind()) { case ABIArgInfo::InAlloca: case ABIArgInfo::Indirect: return convertTempToRValue(SRetPtr, RetTy, SourceLocation()); case ABIArgInfo::Ignore: // If we are ignoring an argument that had a result, make sure to // construct the appropriate return value for our caller. return GetUndefRValue(RetTy); case ABIArgInfo::Extend: case ABIArgInfo::Direct: { llvm::Type *RetIRTy = ConvertType(RetTy); if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { switch (getEvaluationKind(RetTy)) { case TEK_Complex: { llvm::Value *Real = Builder.CreateExtractValue(CI, 0); llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); return RValue::getComplex(std::make_pair(Real, Imag)); } case TEK_Aggregate: { llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "agg.tmp"); DestIsVolatile = false; } BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); return RValue::getAggregate(DestPtr); } case TEK_Scalar: { // If the argument doesn't match, perform a bitcast to coerce it. This // can happen due to trivial type mismatches. llvm::Value *V = CI; if (V->getType() != RetIRTy) V = Builder.CreateBitCast(V, RetIRTy); return RValue::get(V); } } llvm_unreachable("bad evaluation kind"); } llvm::Value *DestPtr = ReturnValue.getValue(); bool DestIsVolatile = ReturnValue.isVolatile(); if (!DestPtr) { DestPtr = CreateMemTemp(RetTy, "coerce"); DestIsVolatile = false; } // If the value is offset in memory, apply the offset now. llvm::Value *StorePtr = DestPtr; if (unsigned Offs = RetAI.getDirectOffset()) { StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); StorePtr = Builder.CreateBitCast(StorePtr, llvm::PointerType::getUnqual(RetAI.getCoerceToType())); } CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); return convertTempToRValue(DestPtr, RetTy, SourceLocation()); } case ABIArgInfo::Expand: llvm_unreachable("Invalid ABI kind for return argument"); } llvm_unreachable("Unhandled ABIArgInfo::Kind"); } /* VarArg handling */ llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) { return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this); } @