r263191 - Preserve ExtParameterInfos into CGFunctionInfo.
Nico Weber via cfe-commits
cfe-commits at lists.llvm.org
Fri Apr 1 15:50:07 PDT 2016
On Thu, Mar 10, 2016 at 8:30 PM, John McCall via cfe-commits <
cfe-commits at lists.llvm.org> wrote:
> Author: rjmccall
> Date: Thu Mar 10 22:30:31 2016
> New Revision: 263191
>
> URL: http://llvm.org/viewvc/llvm-project?rev=263191&view=rev
> Log:
> Preserve ExtParameterInfos into CGFunctionInfo.
>
> As part of this, make the function-arrangement interfaces
> a little simpler and more semantic.
>
> NFC.
>
> Modified:
> cfe/trunk/include/clang/AST/CanonicalType.h
> cfe/trunk/include/clang/CodeGen/CGFunctionInfo.h
> cfe/trunk/lib/CodeGen/CGAtomic.cpp
> cfe/trunk/lib/CodeGen/CGBlocks.cpp
> cfe/trunk/lib/CodeGen/CGBuiltin.cpp
> cfe/trunk/lib/CodeGen/CGCall.cpp
> cfe/trunk/lib/CodeGen/CGDeclCXX.cpp
> cfe/trunk/lib/CodeGen/CGException.cpp
> cfe/trunk/lib/CodeGen/CGExpr.cpp
> cfe/trunk/lib/CodeGen/CGObjC.cpp
> cfe/trunk/lib/CodeGen/CGObjCMac.cpp
> cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp
> cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> cfe/trunk/lib/CodeGen/CGStmt.cpp
> cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
> cfe/trunk/lib/CodeGen/CodeGenABITypes.cpp
> cfe/trunk/lib/CodeGen/CodeGenTypes.h
> cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
>
> Modified: cfe/trunk/include/clang/AST/CanonicalType.h
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/CanonicalType.h?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/include/clang/AST/CanonicalType.h (original)
> +++ cfe/trunk/include/clang/AST/CanonicalType.h Thu Mar 10 22:30:31 2016
> @@ -484,6 +484,9 @@ struct CanProxyAdaptor<FunctionProtoType
> LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
> LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)
> LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumParams)
> + LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasExtParameterInfos)
> + LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(
> + ArrayRef<FunctionProtoType::ExtParameterInfo>,
> getExtParameterInfos)
> CanQualType getParamType(unsigned i) const {
> return CanQualType::CreateUnsafe(this->getTypePtr()->getParamType(i));
> }
>
> Modified: cfe/trunk/include/clang/CodeGen/CGFunctionInfo.h
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/CodeGen/CGFunctionInfo.h?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/include/clang/CodeGen/CGFunctionInfo.h (original)
> +++ cfe/trunk/include/clang/CodeGen/CGFunctionInfo.h Thu Mar 10 22:30:31
> 2016
> @@ -343,8 +343,10 @@ struct CGFunctionInfoArgInfo {
> /// function definition.
> class CGFunctionInfo final
> : public llvm::FoldingSetNode,
> - private llvm::TrailingObjects<CGFunctionInfo,
> CGFunctionInfoArgInfo> {
> + private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
> + FunctionProtoType::ExtParameterInfo> {
> typedef CGFunctionInfoArgInfo ArgInfo;
> + typedef FunctionProtoType::ExtParameterInfo ExtParameterInfo;
>
> /// The LLVM::CallingConv to use for this function (as specified by the
> /// user).
> @@ -378,7 +380,8 @@ class CGFunctionInfo final
> /// The struct representing all arguments passed in memory. Only used
> when
> /// passing non-trivial types with inalloca. Not part of the profile.
> llvm::StructType *ArgStruct;
> - unsigned ArgStructAlign;
> + unsigned ArgStructAlign : 31;
> + unsigned HasExtParameterInfos : 1;
>
> unsigned NumArgs;
>
> @@ -389,7 +392,19 @@ class CGFunctionInfo final
> return getTrailingObjects<ArgInfo>();
> }
>
> - size_t numTrailingObjects(OverloadToken<ArgInfo>) { return NumArgs + 1;
> }
> + ExtParameterInfo *getExtParameterInfosBuffer() {
> + return getTrailingObjects<ExtParameterInfo>();
> + }
> + const ExtParameterInfo *getExtParameterInfosBuffer() const{
> + return getTrailingObjects<ExtParameterInfo>();
> + }
> +
> + size_t numTrailingObjects(OverloadToken<ArgInfo>) const {
> + return NumArgs + 1;
> + }
> + size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
> + return (HasExtParameterInfos ? NumArgs : 0);
> + }
> friend class TrailingObjects;
>
> CGFunctionInfo() : Required(RequiredArgs::All) {}
> @@ -399,6 +414,7 @@ public:
> bool instanceMethod,
> bool chainCall,
> const FunctionType::ExtInfo &extInfo,
> + ArrayRef<ExtParameterInfo> paramInfos,
> CanQualType resultType,
> ArrayRef<CanQualType> argTypes,
> RequiredArgs required);
> @@ -472,6 +488,16 @@ public:
> ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
> const ABIArgInfo &getReturnInfo() const { return
> getArgsBuffer()[0].info; }
>
> + ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
> + if (!HasExtParameterInfos) return {};
> + return llvm::makeArrayRef(getExtParameterInfosBuffer(), NumArgs);
> + }
> + ExtParameterInfo getExtParameterInfo(unsigned argIndex) const {
> + assert(argIndex <= NumArgs);
> + if (!HasExtParameterInfos) return ExtParameterInfo();
> + return getExtParameterInfos()[argIndex];
> + }
> +
> /// \brief Return true if this function uses inalloca arguments.
> bool usesInAlloca() const { return ArgStruct; }
>
> @@ -494,6 +520,11 @@ public:
> ID.AddBoolean(HasRegParm);
> ID.AddInteger(RegParm);
> ID.AddInteger(Required.getOpaqueData());
> + ID.AddBoolean(HasExtParameterInfos);
> + if (HasExtParameterInfos) {
> + for (auto paramInfo : getExtParameterInfos())
> + ID.AddInteger(paramInfo.getOpaqueValue());
> + }
> getReturnType().Profile(ID);
> for (const auto &I : arguments())
> I.type.Profile(ID);
> @@ -502,6 +533,7 @@ public:
> bool InstanceMethod,
> bool ChainCall,
> const FunctionType::ExtInfo &info,
> + ArrayRef<ExtParameterInfo> paramInfos,
> RequiredArgs required,
> CanQualType resultType,
> ArrayRef<CanQualType> argTypes) {
> @@ -513,6 +545,11 @@ public:
> ID.AddBoolean(info.getHasRegParm());
> ID.AddInteger(info.getRegParm());
> ID.AddInteger(required.getOpaqueData());
> + ID.AddBoolean(!paramInfos.empty());
> + if (!paramInfos.empty()) {
> + for (auto paramInfo : paramInfos)
> + ID.AddInteger(paramInfo.getOpaqueValue());
> + }
> resultType.Profile(ID);
> for (ArrayRef<CanQualType>::iterator
> i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
>
> Modified: cfe/trunk/lib/CodeGen/CGAtomic.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGAtomic.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGAtomic.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGAtomic.cpp Thu Mar 10 22:30:31 2016
> @@ -323,8 +323,7 @@ static RValue emitAtomicLibcall(CodeGenF
> QualType resultType,
> CallArgList &args) {
> const CGFunctionInfo &fnInfo =
> - CGF.CGM.getTypes().arrangeFreeFunctionCall(resultType, args,
> - FunctionType::ExtInfo(), RequiredArgs::All);
> + CGF.CGM.getTypes().arrangeBuiltinFunctionCall(resultType, args);
> llvm::FunctionType *fnTy = CGF.CGM.getTypes().GetFunctionType(fnInfo);
> llvm::Constant *fn = CGF.CGM.CreateRuntimeFunction(fnTy, fnName);
> return CGF.EmitCall(fnInfo, fn, ReturnValueSlot(), args);
>
> Modified: cfe/trunk/lib/CodeGen/CGBlocks.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGBlocks.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGBlocks.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGBlocks.cpp Thu Mar 10 22:30:31 2016
> @@ -1174,9 +1174,8 @@ CodeGenFunction::GenerateBlockFunction(G
>
> // Create the function declaration.
> const FunctionProtoType *fnType =
> blockInfo.getBlockExpr()->getFunctionType();
> - const CGFunctionInfo &fnInfo =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - fnType->getReturnType(), args, fnType->getExtInfo(),
> - fnType->isVariadic());
> + const CGFunctionInfo &fnInfo =
> + CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args);
> if (CGM.ReturnSlotInterferesWithArgs(fnInfo))
> blockInfo.UsesStret = true;
>
> @@ -1329,8 +1328,8 @@ CodeGenFunction::GenerateCopyHelperFunct
> C.VoidPtrTy);
> args.push_back(&srcDecl);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args);
>
> // FIXME: it would be nice if these were mergeable with things with
> // identical semantics.
> @@ -1505,8 +1504,8 @@ CodeGenFunction::GenerateDestroyHelperFu
> C.VoidPtrTy);
> args.push_back(&srcDecl);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args);
>
> // FIXME: We'd like to put these into a mergable by content, with
> // internal linkage.
> @@ -1791,8 +1790,8 @@ generateByrefCopyHelper(CodeGenFunction
> Context.VoidPtrTy);
> args.push_back(&src);
>
> - const CGFunctionInfo &FI =
> CGF.CGM.getTypes().arrangeFreeFunctionDeclaration(
> - R, args, FunctionType::ExtInfo(), /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args);
>
> llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);
>
> @@ -1864,8 +1863,8 @@ generateByrefDisposeHelper(CodeGenFuncti
> Context.VoidPtrTy);
> args.push_back(&src);
>
> - const CGFunctionInfo &FI =
> CGF.CGM.getTypes().arrangeFreeFunctionDeclaration(
> - R, args, FunctionType::ExtInfo(), /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args);
>
> llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);
>
>
> Modified: cfe/trunk/lib/CodeGen/CGBuiltin.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGBuiltin.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGBuiltin.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGBuiltin.cpp Thu Mar 10 22:30:31 2016
> @@ -1330,9 +1330,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(
> Args.add(RValue::get(llvm::Constant::getNullValue(VoidPtrTy)),
> getContext().VoidPtrTy);
> const CGFunctionInfo &FuncInfo =
> - CGM.getTypes().arrangeFreeFunctionCall(E->getType(), Args,
> - FunctionType::ExtInfo(),
> - RequiredArgs::All);
> + CGM.getTypes().arrangeBuiltinFunctionCall(E->getType(), Args);
> llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
> llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
> return EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
>
> Modified: cfe/trunk/lib/CodeGen/CGCall.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCall.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGCall.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGCall.cpp Thu Mar 10 22:30:31 2016
> @@ -91,15 +91,25 @@ CodeGenTypes::arrangeFreeFunctionType(Ca
> return
> arrangeLLVMFunctionInfo(FTNP->getReturnType().getUnqualifiedType(),
> /*instanceMethod=*/false,
> /*chainCall=*/false, None,
> - FTNP->getExtInfo(), RequiredArgs(0));
> + FTNP->getExtInfo(), {}, RequiredArgs(0));
> }
>
> /// 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<CanQualType> &prefix,
> - const CanQual<FunctionProtoType> &FPT,
> + SmallVectorImpl<FunctionProtoType::ExtParameterInfo>
> ¶mInfos,
> + CanQual<FunctionProtoType> FPT,
> const FunctionDecl *FD) {
> + // 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(paramInfos.begin(), paramInfos.end());
> + }
> +
> // Fast path: unknown target.
> if (FD == nullptr) {
> prefix.append(FPT->param_type_begin(), FPT->param_type_end());
> @@ -126,13 +136,16 @@ arrangeLLVMFunctionInfo(CodeGenTypes &CG
> SmallVectorImpl<CanQualType> &prefix,
> CanQual<FunctionProtoType> FTP,
> const FunctionDecl *FD) {
> + SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
> RequiredArgs required = RequiredArgs::forPrototypePlus(FTP,
> prefix.size());
> // FIXME: Kill copy.
> - appendParameterTypes(CGT, prefix, FTP, FD);
> + appendParameterTypes(CGT, prefix, paramInfos, FTP, FD);
> CanQualType resultType = FTP->getReturnType().getUnqualifiedType();
> +
> return CGT.arrangeLLVMFunctionInfo(resultType, instanceMethod,
> /*chainCall=*/false, prefix,
> - FTP->getExtInfo(), required);
> + FTP->getExtInfo(), paramInfos,
> + required);
> }
>
> /// Arrange the argument and result information for a value of the
> @@ -225,6 +238,7 @@ CodeGenTypes::arrangeCXXStructorDeclarat
> StructorType Type) {
>
> SmallVector<CanQualType, 16> argTypes;
> + SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
> argTypes.push_back(GetThisType(Context, MD->getParent()));
>
> GlobalDecl GD;
> @@ -238,7 +252,7 @@ CodeGenTypes::arrangeCXXStructorDeclarat
> CanQual<FunctionProtoType> FTP = GetFormalType(MD);
>
> // Add the formal parameters.
> - appendParameterTypes(*this, argTypes, FTP, MD);
> + appendParameterTypes(*this, argTypes, paramInfos, FTP, MD);
>
> TheCXXABI.buildStructorSignature(MD, Type, argTypes);
>
> @@ -253,7 +267,53 @@ CodeGenTypes::arrangeCXXStructorDeclarat
> : Context.VoidTy;
> return arrangeLLVMFunctionInfo(resultType, /*instanceMethod=*/true,
> /*chainCall=*/false, argTypes, extInfo,
> - required);
> + paramInfos, required);
> +}
> +
> +static SmallVector<CanQualType, 16>
> +getArgTypesForCall(ASTContext &ctx, const CallArgList &args) {
> + SmallVector<CanQualType, 16> argTypes;
> + for (auto &arg : args)
> + argTypes.push_back(ctx.getCanonicalParamType(arg.Ty));
> + return argTypes;
> +}
> +
> +static SmallVector<CanQualType, 16>
> +getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) {
> + SmallVector<CanQualType, 16> argTypes;
> + for (auto &arg : args)
> + argTypes.push_back(ctx.getCanonicalParamType(arg->getType()));
> + return argTypes;
> +}
> +
> +static void addExtParameterInfosForCall(
> + llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo>
> ¶mInfos,
> + const FunctionProtoType *proto,
> + unsigned prefixArgs,
> + unsigned totalArgs) {
> + assert(proto->hasExtParameterInfos());
> + assert(paramInfos.size() <= prefixArgs);
> + assert(proto->getNumParams() + prefixArgs <= totalArgs);
> +
> + // 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<FunctionProtoType::ExtParameterInfo, 16>
> +getExtParameterInfosForCall(const FunctionProtoType *proto,
> + unsigned prefixArgs, unsigned totalArgs) {
> + llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> result;
> + if (proto->hasExtParameterInfos()) {
> + addExtParameterInfosForCall(result, proto, prefixArgs, totalArgs);
> + }
> + return result;
> }
>
> /// Arrange a call to a C++ method, passing the given arguments.
> @@ -277,9 +337,11 @@ CodeGenTypes::arrangeCXXConstructorCall(
> : Context.VoidTy;
>
> FunctionType::ExtInfo Info = FPT->getExtInfo();
> + auto ParamInfos = getExtParameterInfosForCall(FPT.getTypePtr(), 1 +
> ExtraArgs,
> + ArgTypes.size());
> return arrangeLLVMFunctionInfo(ResultType, /*instanceMethod=*/true,
> /*chainCall=*/false, ArgTypes, Info,
> - Required);
> + ParamInfos, Required);
> }
>
> /// Arrange the argument and result information for the declaration or
> @@ -300,7 +362,7 @@ CodeGenTypes::arrangeFunctionDeclaration
> CanQual<FunctionNoProtoType> noProto =
> FTy.getAs<FunctionNoProtoType>();
> return arrangeLLVMFunctionInfo(
> noProto->getReturnType(), /*instanceMethod=*/false,
> - /*chainCall=*/false, None, noProto->getExtInfo(),
> RequiredArgs::All);
> + /*chainCall=*/false, None, noProto->getExtInfo(),
> {},RequiredArgs::All);
> }
>
> assert(isa<FunctionProtoType>(FTy));
> @@ -346,7 +408,18 @@ CodeGenTypes::arrangeObjCMessageSendSign
>
> return arrangeLLVMFunctionInfo(
> GetReturnType(MD->getReturnType()), /*instanceMethod=*/false,
> - /*chainCall=*/false, argTys, einfo, required);
> + /*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);
> }
>
> const CGFunctionInfo &
> @@ -375,7 +448,7 @@ CodeGenTypes::arrangeMSMemberPointerThun
> CanQualType ArgTys[] = { GetThisType(Context, MD->getParent()) };
> return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/false,
> /*chainCall=*/false, ArgTys,
> - FTP->getExtInfo(), RequiredArgs(1));
> + FTP->getExtInfo(), {}, RequiredArgs(1));
> }
>
> const CGFunctionInfo &
> @@ -395,7 +468,8 @@ CodeGenTypes::arrangeMSCtorClosure(const
> /*IsVariadic=*/false, /*IsCXXMethod=*/true);
> return arrangeLLVMFunctionInfo(Context.VoidTy, /*instanceMethod=*/true,
> /*chainCall=*/false, ArgTys,
> - FunctionType::ExtInfo(CC),
> RequiredArgs::All);
> + FunctionType::ExtInfo(CC), {},
> + RequiredArgs::All);
> }
>
> /// Arrange a call as unto a free function, except possibly with an
> @@ -409,6 +483,8 @@ arrangeFreeFunctionLikeCall(CodeGenTypes
> bool chainCall) {
> assert(args.size() >= numExtraRequiredArgs);
>
> + llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
> +
> // In most cases, there are no optional arguments.
> RequiredArgs required = RequiredArgs::All;
>
> @@ -418,6 +494,10 @@ arrangeFreeFunctionLikeCall(CodeGenTypes
> if (proto->isVariadic())
> required = RequiredArgs(proto->getNumParams() +
> numExtraRequiredArgs);
>
> + if (proto->hasExtParameterInfos())
> + addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs,
> + args.size());
> +
> // If we don't have a prototype at all, but we're supposed to
> // explicitly use the variadic convention for unprototyped calls,
> // treat all of the arguments as required but preserve the nominal
> @@ -434,7 +514,8 @@ arrangeFreeFunctionLikeCall(CodeGenTypes
> argTypes.push_back(CGT.getContext().getCanonicalParamType(arg.Ty));
> return
> CGT.arrangeLLVMFunctionInfo(GetReturnType(fnType->getReturnType()),
> /*instanceMethod=*/false, chainCall,
> - argTypes, fnType->getExtInfo(),
> required);
> + argTypes, fnType->getExtInfo(),
> paramInfos,
> + required);
> }
>
> /// Figure out the rules for calling a function with the given formal
> @@ -449,7 +530,7 @@ CodeGenTypes::arrangeFreeFunctionCall(co
> chainCall ? 1 : 0, chainCall);
> }
>
> -/// A block function call is essentially a free-function call with an
> +/// A block function is essentially a free function with an
> /// extra implicit argument.
> const CGFunctionInfo &
> CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
> @@ -459,54 +540,99 @@ CodeGenTypes::arrangeBlockFunctionCall(c
> }
>
> const CGFunctionInfo &
> -CodeGenTypes::arrangeFreeFunctionCall(QualType resultType,
> - const CallArgList &args,
> - FunctionType::ExtInfo info,
> - RequiredArgs required) {
> +CodeGenTypes::arrangeBlockFunctionDeclaration(const FunctionProtoType
> *proto,
> + const FunctionArgList
> ¶ms) {
> + auto paramInfos = getExtParameterInfosForCall(proto, 1, params.size());
> + auto argTypes = getArgTypesForDeclaration(Context, params);
> +
> + return arrangeLLVMFunctionInfo(GetReturnType(proto->getReturnType()),
> + /*instanceMethod*/ false, /*chainCall*/
> false,
> + argTypes, proto->getExtInfo(),
> paramInfos,
> + RequiredArgs::forPrototypePlus(proto,
> 1));
> +}
> +
> +const CGFunctionInfo &
> +CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType,
> + const CallArgList &args) {
> // FIXME: Kill copy.
> SmallVector<CanQualType, 16> argTypes;
> for (const auto &Arg : args)
> argTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
> return arrangeLLVMFunctionInfo(
> GetReturnType(resultType), /*instanceMethod=*/false,
> - /*chainCall=*/false, argTypes, info, required);
> + /*chainCall=*/false, argTypes, FunctionType::ExtInfo(),
> + /*paramInfos=*/ {}, RequiredArgs::All);
> }
>
> -/// 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<CanQualType, 16> argTypes;
> - for (const auto &Arg : args)
> - argTypes.push_back(Context.getCanonicalParamType(Arg.Ty));
> +CodeGenTypes::arrangeBuiltinFunctionDeclaration(QualType resultType,
> + const FunctionArgList
> &args) {
> + auto argTypes = getArgTypesForDeclaration(Context, args);
>
> - FunctionType::ExtInfo info = FPT->getExtInfo();
> return arrangeLLVMFunctionInfo(
> - GetReturnType(FPT->getReturnType()), /*instanceMethod=*/true,
> - /*chainCall=*/false, argTypes, info, required);
> + GetReturnType(resultType), /*instanceMethod=*/false,
> /*chainCall=*/false,
> + argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
> }
>
> -const CGFunctionInfo &CodeGenTypes::arrangeFreeFunctionDeclaration(
> - QualType resultType, const FunctionArgList &args,
> - const FunctionType::ExtInfo &info, bool isVariadic) {
> +const CGFunctionInfo &
> +CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType,
> + ArrayRef<CanQualType>
> argTypes) {
> + return arrangeLLVMFunctionInfo(
> + resultType, /*instanceMethod=*/false, /*chainCall=*/false,
> + argTypes, FunctionType::ExtInfo(), {}, RequiredArgs::All);
> +}
> +
> +
> +/// Arrange a call to a C++ method, passing the given arguments.
> +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());
> +
> // FIXME: Kill copy.
> - SmallVector<CanQualType, 16> argTypes;
> - for (auto Arg : args)
> - argTypes.push_back(Context.getCanonicalParamType(Arg->getType()));
> + auto argTypes = getArgTypesForCall(Context, args);
>
> - RequiredArgs required =
> - (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All);
> + FunctionType::ExtInfo info = proto->getExtInfo();
> return arrangeLLVMFunctionInfo(
> - GetReturnType(resultType), /*instanceMethod=*/false,
> - /*chainCall=*/false, argTypes, info, required);
> + GetReturnType(proto->getReturnType()), /*instanceMethod=*/true,
> + /*chainCall=*/false, argTypes, info, paramInfos, required);
> }
>
> const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
> return arrangeLLVMFunctionInfo(
> getContext().VoidTy, /*instanceMethod=*/false, /*chainCall=*/false,
> - None, FunctionType::ExtInfo(), RequiredArgs::All);
> + None, FunctionType::ExtInfo(), {}, RequiredArgs::All);
> +}
> +
> +const CGFunctionInfo &
> +CodeGenTypes::arrangeCall(const CGFunctionInfo &signature,
> + const CallArgList &args) {
> + assert(signature.arg_size() <= args.size());
> + if (signature.arg_size() == args.size())
> + return signature;
> +
> + SmallVector<FunctionProtoType::ExtParameterInfo, 16> paramInfos;
> + auto sigParamInfos = signature.getExtParameterInfos();
> + if (!sigParamInfos.empty()) {
> + paramInfos.append(sigParamInfos.begin(), sigParamInfos.end());
> + paramInfos.resize(args.size());
> + }
> +
> + auto argTypes = getArgTypesForCall(Context, args);
> +
> + assert(signature.getRequiredArgs().allowsOptionalArgs());
> + return arrangeLLVMFunctionInfo(signature.getReturnType(),
> + signature.isInstanceMethod(),
> + signature.isChainCall(),
> + argTypes,
> + signature.getExtInfo(),
> + paramInfos,
> + signature.getRequiredArgs());
> }
>
> /// Arrange the argument and result information for an abstract value
> @@ -518,25 +644,26 @@ CodeGenTypes::arrangeLLVMFunctionInfo(Ca
> bool chainCall,
> ArrayRef<CanQualType> argTypes,
> FunctionType::ExtInfo info,
> + ArrayRef<FunctionProtoType::ExtParameterInfo>
> paramInfos,
> RequiredArgs required) {
> assert(std::all_of(argTypes.begin(), argTypes.end(),
> std::mem_fun_ref(&CanQualType::isCanonicalAsParam)));
>
> - unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
> -
> // Lookup or create unique function info.
> llvm::FoldingSetNodeID ID;
> - CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, required,
> - resultType, argTypes);
> + CGFunctionInfo::Profile(ID, instanceMethod, chainCall, info, paramInfos,
> + required, resultType, argTypes);
>
> void *insertPos = nullptr;
> CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
> if (FI)
> return *FI;
>
> + unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
> +
> // Construct the function info. We co-allocate the ArgInfos.
> FI = CGFunctionInfo::create(CC, instanceMethod, chainCall, info,
> - resultType, argTypes, required);
> + paramInfos, resultType, argTypes, required);
> FunctionInfos.InsertNode(FI, insertPos);
>
> bool inserted = FunctionsBeingProcessed.insert(FI).second;
> @@ -567,10 +694,16 @@ CGFunctionInfo *CGFunctionInfo::create(u
> bool instanceMethod,
> bool chainCall,
> const FunctionType::ExtInfo &info,
> + ArrayRef<ExtParameterInfo>
> paramInfos,
> CanQualType resultType,
> ArrayRef<CanQualType> argTypes,
> RequiredArgs required) {
> - void *buffer = operator new(totalSizeToAlloc<ArgInfo>(argTypes.size() +
> 1));
> + assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
>
This assert fires on e.g.
$ cat test.mm
struct S {
S(__attribute((ns_consumed)) id object, int policy);
};
void f() {
S s(0, 0);
}
$ bin/clang -c test.mm -fobjc-arc
Assertion failed: (paramInfos.empty() || paramInfos.size() ==
argTypes.size()), function create, file
/b/build/slave/build_and_upload_clang/build/src/third_party/llvm/tools/clang/lib/CodeGen/CGCall.cpp,
line 709.
Can you take a look, please?
> +
> + void *buffer =
> + operator new(totalSizeToAlloc<ArgInfo, ExtParameterInfo>(
> + argTypes.size() + 1,
> paramInfos.size()));
> +
> CGFunctionInfo *FI = new(buffer) CGFunctionInfo();
> FI->CallingConvention = llvmCC;
> FI->EffectiveCallingConvention = llvmCC;
> @@ -585,9 +718,12 @@ CGFunctionInfo *CGFunctionInfo::create(u
> FI->ArgStruct = nullptr;
> FI->ArgStructAlign = 0;
> FI->NumArgs = argTypes.size();
> + FI->HasExtParameterInfos = !paramInfos.empty();
> FI->getArgsBuffer()[0].type = resultType;
> for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
> FI->getArgsBuffer()[i + 1].type = argTypes[i];
> + for (unsigned i = 0, e = paramInfos.size(); i != e; ++i)
> + FI->getExtParameterInfosBuffer()[i] = paramInfos[i];
> return FI;
> }
>
>
> Modified: cfe/trunk/lib/CodeGen/CGDeclCXX.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDeclCXX.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGDeclCXX.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGDeclCXX.cpp Thu Mar 10 22:30:31 2016
> @@ -598,8 +598,8 @@ llvm::Function *CodeGenFunction::generat
> getContext().VoidPtrTy);
> args.push_back(&dst);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - getContext().VoidTy, args, FunctionType::ExtInfo(),
> /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy,
> args);
> llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
> llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(
> FTy, "__cxx_global_array_dtor", FI, VD->getLocation());
>
> Modified: cfe/trunk/lib/CodeGen/CGException.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGException.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGException.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGException.cpp Thu Mar 10 22:30:31 2016
> @@ -1426,12 +1426,8 @@ struct PerformSEHFinally final : EHScope
> Args.add(RValue::get(FP), ArgTys[1]);
>
> // Arrange a two-arg function info and type.
> - FunctionProtoType::ExtProtoInfo EPI;
> - const auto *FPT = cast<FunctionProtoType>(
> - Context.getFunctionType(Context.VoidTy, ArgTys, EPI));
> const CGFunctionInfo &FnInfo =
> - CGM.getTypes().arrangeFreeFunctionCall(Args, FPT,
> - /*chainCall=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args);
>
> CGF.EmitCall(FnInfo, OutlinedFinally, ReturnValueSlot(), Args);
> }
> @@ -1659,8 +1655,8 @@ void CodeGenFunction::startOutlinedSEHHe
> QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy;
>
> llvm::Function *ParentFn = ParentCGF.CurFn;
> - const CGFunctionInfo &FnInfo =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - RetTy, Args, FunctionType::ExtInfo(), /*isVariadic=*/false);
> + const CGFunctionInfo &FnInfo =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args);
>
> llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
> llvm::Function *Fn = llvm::Function::Create(
>
> Modified: cfe/trunk/lib/CodeGen/CGExpr.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExpr.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGExpr.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGExpr.cpp Thu Mar 10 22:30:31 2016
> @@ -2616,8 +2616,8 @@ void CodeGenFunction::EmitCfiCheckFail()
> Args.push_back(&ArgData);
> Args.push_back(&ArgAddr);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - getContext().VoidTy, Args, FunctionType::ExtInfo(),
> /*variadic=*/false);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy,
> Args);
>
> llvm::Function *F = llvm::Function::Create(
> llvm::FunctionType::get(VoidTy, {VoidPtrTy, VoidPtrTy}, false),
>
> Modified: cfe/trunk/lib/CodeGen/CGObjC.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGObjC.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGObjC.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGObjC.cpp Thu Mar 10 22:30:31 2016
> @@ -590,9 +590,7 @@ static void emitStructGetterCall(CodeGen
> args.add(RValue::get(CGF.Builder.getInt1(hasStrong)), Context.BoolTy);
>
> llvm::Value *fn = CGF.CGM.getObjCRuntime().GetGetStructFunction();
> - CGF.EmitCall(CGF.getTypes().arrangeFreeFunctionCall(Context.VoidTy,
> args,
> -
> FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + CGF.EmitCall(CGF.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy,
> args),
> fn, ReturnValueSlot(), args);
> }
>
> @@ -856,10 +854,8 @@ static void emitCPPObjectAtomicGetterCal
>
> llvm::Value *copyCppAtomicObjectFn =
> CGF.CGM.getObjCRuntime().GetCppAtomicObjectGetFunction();
> -
> CGF.EmitCall(CGF.getTypes().arrangeFreeFunctionCall(CGF.getContext().VoidTy,
> - args,
> -
> FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + CGF.EmitCall(
> + CGF.getTypes().arrangeBuiltinFunctionCall(CGF.getContext().VoidTy,
> args),
> copyCppAtomicObjectFn, ReturnValueSlot(), args);
> }
>
> @@ -950,8 +946,7 @@ CodeGenFunction::generateObjCGetterBody(
> // runtime already should have computed it to build the function.
> llvm::Instruction *CallInstruction;
> RValue RV = EmitCall(
> - getTypes().arrangeFreeFunctionCall(
> - propType, args, FunctionType::ExtInfo(), RequiredArgs::All),
> + getTypes().arrangeBuiltinFunctionCall(propType, args),
> getPropertyFn, ReturnValueSlot(), args, CGCalleeInfo(),
> &CallInstruction);
> if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
> @@ -1067,10 +1062,8 @@ static void emitStructSetterCall(CodeGen
> args.add(RValue::get(CGF.Builder.getFalse()), CGF.getContext().BoolTy);
>
> llvm::Value *copyStructFn =
> CGF.CGM.getObjCRuntime().GetSetStructFunction();
> -
> CGF.EmitCall(CGF.getTypes().arrangeFreeFunctionCall(CGF.getContext().VoidTy,
> - args,
> -
> FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + CGF.EmitCall(
> + CGF.getTypes().arrangeBuiltinFunctionCall(CGF.getContext().VoidTy,
> args),
> copyStructFn, ReturnValueSlot(), args);
> }
>
> @@ -1105,10 +1098,8 @@ static void emitCPPObjectAtomicSetterCal
>
> llvm::Value *copyCppAtomicObjectFn =
> CGF.CGM.getObjCRuntime().GetCppAtomicObjectSetFunction();
> -
> CGF.EmitCall(CGF.getTypes().arrangeFreeFunctionCall(CGF.getContext().VoidTy,
> - args,
> -
> FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + CGF.EmitCall(
> + CGF.getTypes().arrangeBuiltinFunctionCall(CGF.getContext().VoidTy,
> args),
> copyCppAtomicObjectFn, ReturnValueSlot(), args);
> }
>
> @@ -1238,9 +1229,7 @@ CodeGenFunction::generateObjCSetterBody(
> if (setOptimizedPropertyFn) {
> args.add(RValue::get(arg), getContext().getObjCIdType());
> args.add(RValue::get(ivarOffset),
> getContext().getPointerDiffType());
> - EmitCall(getTypes().arrangeFreeFunctionCall(getContext().VoidTy,
> args,
> - FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + EmitCall(getTypes().arrangeBuiltinFunctionCall(getContext().VoidTy,
> args),
> setOptimizedPropertyFn, ReturnValueSlot(), args);
> } else {
> args.add(RValue::get(ivarOffset),
> getContext().getPointerDiffType());
> @@ -1251,9 +1240,7 @@ CodeGenFunction::generateObjCSetterBody(
> getContext().BoolTy);
> // FIXME: We shouldn't need to get the function info here, the
> runtime
> // already should have computed it to build the function.
> - EmitCall(getTypes().arrangeFreeFunctionCall(getContext().VoidTy,
> args,
> - FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + EmitCall(getTypes().arrangeBuiltinFunctionCall(getContext().VoidTy,
> args),
> setPropertyFn, ReturnValueSlot(), args);
> }
>
> @@ -1610,9 +1597,8 @@ void CodeGenFunction::EmitObjCForCollect
> Args2.add(RValue::get(V), getContext().getObjCIdType());
> // FIXME: We shouldn't need to get the function info here, the runtime
> already
> // should have computed it to build the function.
> - EmitCall(CGM.getTypes().arrangeFreeFunctionCall(getContext().VoidTy,
> Args2,
> - FunctionType::ExtInfo(),
> - RequiredArgs::All),
> + EmitCall(
> + CGM.getTypes().arrangeBuiltinFunctionCall(getContext().VoidTy,
> Args2),
> EnumerationMutationFn, ReturnValueSlot(), Args2);
>
> // Otherwise, or if the mutation function returns, just continue.
> @@ -3210,8 +3196,8 @@ CodeGenFunction::GenerateObjCAtomicSette
> ImplicitParamDecl srcDecl(getContext(), FD, SourceLocation(), nullptr,
> SrcTy);
> args.push_back(&srcDecl);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, args, FunctionType::ExtInfo(), RequiredArgs::All);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args);
>
> llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
>
> @@ -3291,8 +3277,8 @@ CodeGenFunction::GenerateObjCAtomicGette
> ImplicitParamDecl srcDecl(getContext(), FD, SourceLocation(), nullptr,
> SrcTy);
> args.push_back(&srcDecl);
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, args, FunctionType::ExtInfo(), RequiredArgs::All);
> + const CGFunctionInfo &FI =
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args);
>
> llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
>
>
> Modified: cfe/trunk/lib/CodeGen/CGObjCMac.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGObjCMac.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGObjCMac.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGObjCMac.cpp Thu Mar 10 22:30:31 2016
> @@ -244,9 +244,8 @@ public:
>
> Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
> Params.push_back(Ctx.BoolTy);
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(
> - IdType, false, false, Params, FunctionType::ExtInfo(),
> - RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
> return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
> }
>
> @@ -264,9 +263,8 @@ public:
> Params.push_back(Ctx.BoolTy);
> Params.push_back(Ctx.BoolTy);
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(
> - Ctx.VoidTy, false, false, Params, FunctionType::ExtInfo(),
> - RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
> return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
> }
>
> @@ -290,9 +288,8 @@ public:
> Params.push_back(IdType);
>
> Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(
> - Ctx.VoidTy, false, false, Params, FunctionType::ExtInfo(),
> - RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
> const char *name;
> if (atomic && copy)
> name = "objc_setProperty_atomic_copy";
> @@ -317,9 +314,8 @@ public:
> Params.push_back(Ctx.BoolTy);
> Params.push_back(Ctx.BoolTy);
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(
> - Ctx.VoidTy, false, false, Params, FunctionType::ExtInfo(),
> - RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
> return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
> }
>
> @@ -336,10 +332,8 @@ public:
> Params.push_back(Ctx.VoidPtrTy);
> Params.push_back(Ctx.VoidPtrTy);
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy,
> false, false,
> - Params,
> -
> FunctionType::ExtInfo(),
> -
> RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
> return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
> }
>
> @@ -350,9 +344,8 @@ public:
> SmallVector<CanQualType,1> Params;
> Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
> llvm::FunctionType *FTy =
> - Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(
> - Ctx.VoidTy, false, false, Params, FunctionType::ExtInfo(),
> - RequiredArgs::All));
> + Types.GetFunctionType(
> + Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
> return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
> }
>
>
> Modified: cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp Thu Mar 10 22:30:31 2016
> @@ -363,25 +363,15 @@ CGObjCRuntime::getMessageSendInfo(const
> llvm::PointerType *signatureType =
> CGM.getTypes().GetFunctionType(signature)->getPointerTo();
>
> - // If that's not variadic, there's no need to recompute the ABI
> - // arrangement.
> - if (!signature.isVariadic())
> - return MessageSendInfo(signature, signatureType);
> + const CGFunctionInfo &signatureForCall =
> + CGM.getTypes().arrangeCall(signature, callArgs);
>
> - // Otherwise, there is.
> - FunctionType::ExtInfo einfo = signature.getExtInfo();
> - const CGFunctionInfo &argsInfo =
> - CGM.getTypes().arrangeFreeFunctionCall(resultType, callArgs, einfo,
> - signature.getRequiredArgs());
> -
> - return MessageSendInfo(argsInfo, signatureType);
> + return MessageSendInfo(signatureForCall, signatureType);
> }
>
> // There's no method; just use a default CC.
> const CGFunctionInfo &argsInfo =
> - CGM.getTypes().arrangeFreeFunctionCall(resultType, callArgs,
> - FunctionType::ExtInfo(),
> - RequiredArgs::All);
> + CGM.getTypes().arrangeUnprototypedObjCMessageSend(resultType,
> callArgs);
>
> // Derive the signature to call from that.
> llvm::PointerType *signatureType =
>
> Modified: cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp Thu Mar 10 22:30:31 2016
> @@ -628,10 +628,8 @@ emitCombinerOrInitializer(CodeGenModule
> /*Id=*/nullptr, PtrTy);
> Args.push_back(&OmpInParm);
> Args.push_back(&OmpOutParm);
> - FunctionType::ExtInfo Info;
> auto &FnInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(C.VoidTy, Args, Info,
> - /*isVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, Args);
> auto *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
> auto *Fn = llvm::Function::Create(
> FnTy, llvm::GlobalValue::InternalLinkage,
> @@ -1531,9 +1529,8 @@ llvm::Function *CGOpenMPRuntime::emitThr
> /*Id=*/nullptr, CGM.getContext().VoidPtrTy);
> Args.push_back(&Dst);
>
> - auto &FI = CGM.getTypes().arrangeFreeFunctionDeclaration(
> - CGM.getContext().VoidPtrTy, Args, FunctionType::ExtInfo(),
> - /*isVariadic=*/false);
> + auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
> + CGM.getContext().VoidPtrTy, Args);
> auto FTy = CGM.getTypes().GetFunctionType(FI);
> auto Fn = CGM.CreateGlobalInitOrDestructFunction(
> FTy, ".__kmpc_global_ctor_.", FI, Loc);
> @@ -1563,9 +1560,8 @@ llvm::Function *CGOpenMPRuntime::emitThr
> /*Id=*/nullptr, CGM.getContext().VoidPtrTy);
> Args.push_back(&Dst);
>
> - auto &FI = CGM.getTypes().arrangeFreeFunctionDeclaration(
> - CGM.getContext().VoidTy, Args, FunctionType::ExtInfo(),
> - /*isVariadic=*/false);
> + auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
> + CGM.getContext().VoidTy, Args);
> auto FTy = CGM.getTypes().GetFunctionType(FI);
> auto Fn = CGM.CreateGlobalInitOrDestructFunction(
> FTy, ".__kmpc_global_dtor_.", FI, Loc);
> @@ -1937,9 +1933,7 @@ static llvm::Value *emitCopyprivateCopyF
> C.VoidPtrTy);
> Args.push_back(&LHSArg);
> Args.push_back(&RHSArg);
> - FunctionType::ExtInfo EI;
> - auto &CGFI = CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, Args, EI, /*isVariadic=*/false);
> + auto &CGFI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy,
> Args);
> auto *Fn = llvm::Function::Create(
> CGM.getTypes().GetFunctionType(CGFI),
> llvm::GlobalValue::InternalLinkage,
> ".omp.copyprivate.copy_func", &CGM.getModule());
> @@ -2490,9 +2484,7 @@ createOffloadingBinaryDescriptorFunction
>
> CodeGenFunction CGF(CGM);
> GlobalDecl();
> - auto &FI = CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, Args, FunctionType::ExtInfo(),
> - /*isVariadic=*/false);
> + auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy,
> Args);
> auto FTy = CGM.getTypes().GetFunctionType(FI);
> auto *Fn =
> CGM.CreateGlobalInitOrDestructFunction(FTy, Name, FI,
> SourceLocation());
> @@ -2970,10 +2962,8 @@ emitProxyTaskFunction(CodeGenModule &CGM
>
> KmpTaskTWithPrivatesPtrQTy.withRestrict());
> Args.push_back(&GtidArg);
> Args.push_back(&TaskTypeArg);
> - FunctionType::ExtInfo Info;
> auto &TaskEntryFnInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(KmpInt32Ty, Args,
> Info,
> - /*isVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(KmpInt32Ty, Args);
> auto *TaskEntryTy = CGM.getTypes().GetFunctionType(TaskEntryFnInfo);
> auto *TaskEntry =
> llvm::Function::Create(TaskEntryTy,
> llvm::GlobalValue::InternalLinkage,
> @@ -3040,8 +3030,7 @@ static llvm::Value *emitDestructorsFunct
> Args.push_back(&TaskTypeArg);
> FunctionType::ExtInfo Info;
> auto &DestructorFnInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(KmpInt32Ty, Args,
> Info,
> - /*isVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(KmpInt32Ty, Args);
> auto *DestructorFnTy = CGM.getTypes().GetFunctionType(DestructorFnInfo);
> auto *DestructorFn =
> llvm::Function::Create(DestructorFnTy,
> llvm::GlobalValue::InternalLinkage,
> @@ -3115,10 +3104,8 @@ emitTaskPrivateMappingFunction(CodeGenMo
> PrivateVarsPos[VD] = Counter;
> ++Counter;
> }
> - FunctionType::ExtInfo Info;
> auto &TaskPrivatesMapFnInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(C.VoidTy, Args, Info,
> - /*isVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, Args);
> auto *TaskPrivatesMapTy =
> CGM.getTypes().GetFunctionType(TaskPrivatesMapFnInfo);
> auto *TaskPrivatesMap = llvm::Function::Create(
> @@ -3625,9 +3612,7 @@ static llvm::Value *emitReductionFunctio
> C.VoidPtrTy);
> Args.push_back(&LHSArg);
> Args.push_back(&RHSArg);
> - FunctionType::ExtInfo EI;
> - auto &CGFI = CGM.getTypes().arrangeFreeFunctionDeclaration(
> - C.VoidTy, Args, EI, /*isVariadic=*/false);
> + auto &CGFI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy,
> Args);
> auto *Fn = llvm::Function::Create(
> CGM.getTypes().GetFunctionType(CGFI),
> llvm::GlobalValue::InternalLinkage,
> ".omp.reduction.reduction_func", &CGM.getModule());
>
> Modified: cfe/trunk/lib/CodeGen/CGStmt.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmt.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGStmt.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGStmt.cpp Thu Mar 10 22:30:31 2016
> @@ -2159,8 +2159,7 @@ CodeGenFunction::GenerateCapturedStmtFun
> // Create the function declaration.
> FunctionType::ExtInfo ExtInfo;
> const CGFunctionInfo &FuncInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args,
> ExtInfo,
> - /*IsVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
> llvm::FunctionType *FuncLLVMTy =
> CGM.getTypes().GetFunctionType(FuncInfo);
>
> llvm::Function *F =
>
> Modified: cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp Thu Mar 10 22:30:31 2016
> @@ -173,8 +173,7 @@ CodeGenFunction::GenerateOpenMPCapturedS
> // Create the function declaration.
> FunctionType::ExtInfo ExtInfo;
> const CGFunctionInfo &FuncInfo =
> - CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args,
> ExtInfo,
> - /*IsVariadic=*/false);
> + CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
> llvm::FunctionType *FuncLLVMTy =
> CGM.getTypes().GetFunctionType(FuncInfo);
>
> llvm::Function *F = llvm::Function::Create(
>
> Modified: cfe/trunk/lib/CodeGen/CodeGenABITypes.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenABITypes.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CodeGenABITypes.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CodeGenABITypes.cpp Thu Mar 10 22:30:31 2016
> @@ -66,5 +66,5 @@ const CGFunctionInfo &CodeGenABITypes::a
> FunctionType::ExtInfo info, RequiredArgs args) {
> return CGM->getTypes().arrangeLLVMFunctionInfo(
> returnType, /*IsInstanceMethod=*/false, /*IsChainCall=*/false,
> argTypes,
> - info, args);
> + info, {}, args);
> }
>
> Modified: cfe/trunk/lib/CodeGen/CodeGenTypes.h
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenTypes.h?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CodeGenTypes.h (original)
> +++ cfe/trunk/lib/CodeGen/CodeGenTypes.h Thu Mar 10 22:30:31 2016
> @@ -220,10 +220,6 @@ public:
> /// gets assigned to a class.
> void RefreshTypeCacheForClass(const CXXRecordDecl *RD);
>
> - /// getNullaryFunctionInfo - Get the function info for a void()
> - /// function with standard CC.
> - const CGFunctionInfo &arrangeNullaryFunction();
> -
> // The arrangement methods are split into three families:
> // - those meant to drive the signature and prologue/epilogue
> // of a function declaration or definition,
> @@ -245,16 +241,55 @@ public:
> // this for compatibility reasons.
>
> const CGFunctionInfo &arrangeGlobalDeclaration(GlobalDecl GD);
> +
> + /// Given a function info for a declaration, return the function info
> + /// for a call with the given arguments.
> + ///
> + /// Often this will be able to simply return the declaration info.
> + const CGFunctionInfo &arrangeCall(const CGFunctionInfo &declFI,
> + const CallArgList &args);
> +
> + /// Free functions are functions that are compatible with an ordinary
> + /// C function pointer type.
> const CGFunctionInfo &arrangeFunctionDeclaration(const FunctionDecl
> *FD);
> + const CGFunctionInfo &arrangeFreeFunctionCall(const CallArgList &Args,
> + const FunctionType *Ty,
> + bool ChainCall);
> + const CGFunctionInfo
> &arrangeFreeFunctionType(CanQual<FunctionProtoType> Ty,
> + const FunctionDecl *FD);
> + const CGFunctionInfo
> &arrangeFreeFunctionType(CanQual<FunctionNoProtoType> Ty);
> +
> + /// A nullary function is a freestanding function of type 'void ()'.
> + /// This method works for both calls and declarations.
> + const CGFunctionInfo &arrangeNullaryFunction();
> +
> + /// A builtin function is a freestanding function using the default
> + /// C conventions.
> + const CGFunctionInfo &
> + arrangeBuiltinFunctionDeclaration(QualType resultType,
> + const FunctionArgList &args);
> const CGFunctionInfo &
> - arrangeFreeFunctionDeclaration(QualType ResTy, const FunctionArgList
> &Args,
> - const FunctionType::ExtInfo &Info,
> - bool isVariadic);
> + arrangeBuiltinFunctionDeclaration(CanQualType resultType,
> + ArrayRef<CanQualType> argTypes);
> + const CGFunctionInfo &arrangeBuiltinFunctionCall(QualType resultType,
> + const CallArgList
> &args);
>
> + /// Objective-C methods are C functions with some implicit parameters.
> const CGFunctionInfo &arrangeObjCMethodDeclaration(const ObjCMethodDecl
> *MD);
> const CGFunctionInfo &arrangeObjCMessageSendSignature(const
> ObjCMethodDecl *MD,
> QualType
> receiverType);
> + const CGFunctionInfo &arrangeUnprototypedObjCMessageSend(
> + QualType returnType,
> + const CallArgList
> &args);
> +
> + /// Block invocation functions are C functions with an implicit
> parameter.
> + const CGFunctionInfo &arrangeBlockFunctionDeclaration(
> + const FunctionProtoType
> *type,
> + const FunctionArgList
> &args);
> + const CGFunctionInfo &arrangeBlockFunctionCall(const CallArgList &args,
> + const FunctionType
> *type);
>
> + /// C++ methods have some special rules and also have implicit
> parameters.
> const CGFunctionInfo &arrangeCXXMethodDeclaration(const CXXMethodDecl
> *MD);
> const CGFunctionInfo &arrangeCXXStructorDeclaration(const CXXMethodDecl
> *MD,
> StructorType Type);
> @@ -262,15 +297,6 @@ public:
> const
> CXXConstructorDecl *D,
> CXXCtorType CtorKind,
> unsigned ExtraArgs);
> - const CGFunctionInfo &arrangeFreeFunctionCall(const CallArgList &Args,
> - const FunctionType *Ty,
> - bool ChainCall);
> - const CGFunctionInfo &arrangeFreeFunctionCall(QualType ResTy,
> - const CallArgList &args,
> - FunctionType::ExtInfo
> info,
> - RequiredArgs required);
> - const CGFunctionInfo &arrangeBlockFunctionCall(const CallArgList &args,
> - const FunctionType
> *type);
>
> const CGFunctionInfo &arrangeCXXMethodCall(const CallArgList &args,
> const FunctionProtoType
> *type,
> @@ -278,9 +304,6 @@ public:
> const CGFunctionInfo &arrangeMSMemberPointerThunk(const CXXMethodDecl
> *MD);
> const CGFunctionInfo &arrangeMSCtorClosure(const CXXConstructorDecl *CD,
> CXXCtorType CT);
> - const CGFunctionInfo
> &arrangeFreeFunctionType(CanQual<FunctionProtoType> Ty,
> - const FunctionDecl *FD);
> - const CGFunctionInfo
> &arrangeFreeFunctionType(CanQual<FunctionNoProtoType> Ty);
> const CGFunctionInfo &arrangeCXXMethodType(const CXXRecordDecl *RD,
> const FunctionProtoType *FTP,
> const CXXMethodDecl *MD);
> @@ -296,6 +319,7 @@ public:
> bool chainCall,
> ArrayRef<CanQualType>
> argTypes,
> FunctionType::ExtInfo
> info,
> + ArrayRef<FunctionProtoType::ExtParameterInfo>
> paramInfos,
> RequiredArgs args);
>
> /// \brief Compute a new LLVM record layout object for the given record.
>
> Modified: cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp?rev=263191&r1=263190&r2=263191&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp (original)
> +++ cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp Thu Mar 10 22:30:31 2016
> @@ -2186,9 +2186,8 @@ ItaniumCXXABI::getOrCreateThreadLocalWra
> if (RetQT->isReferenceType())
> RetQT = RetQT.getNonReferenceType();
>
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - getContext().getPointerType(RetQT), FunctionArgList(),
> - FunctionType::ExtInfo(), false);
> + const CGFunctionInfo &FI =
> CGM.getTypes().arrangeBuiltinFunctionDeclaration(
> + getContext().getPointerType(RetQT), FunctionArgList());
>
> llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
> llvm::Function *Wrapper =
> @@ -2275,9 +2274,7 @@ void ItaniumCXXABI::EmitThreadLocalInitF
> Init = llvm::Function::Create(
> FnTy, llvm::GlobalVariable::ExternalWeakLinkage,
> InitFnName.str(),
> &CGM.getModule());
> - const CGFunctionInfo &FI =
> CGM.getTypes().arrangeFreeFunctionDeclaration(
> - CGM.getContext().VoidTy, FunctionArgList(),
> FunctionType::ExtInfo(),
> - false);
> + const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
> CGM.SetLLVMFunctionAttributes(nullptr, FI,
> cast<llvm::Function>(Init));
> }
>
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20160401/9d679e0c/attachment-0001.html>
More information about the cfe-commits
mailing list