//===--- CGCall.cpp - Encapsulate calling convention details --------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // These classes wrap the information about a call or function // definition used to handle ABI compliancy. // //===----------------------------------------------------------------------===// #include "CGCall.h" #include "ABIInfo.h" #include "ABIInfoImpl.h" #include "CGBlocks.h" #include "CGCXXABI.h" #include "CGCleanup.h" #include "CGRecordLayout.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/Basic/CodeGenOptions.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/CodeGen/SwiftCallingConv.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Analysis/ValueTracking.h" #include "llvm/IR/Assumptions.h" #include "llvm/IR/AttributeMask.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/Type.h" #include "llvm/Transforms/Utils/Local.h" #include <optional> usingnamespaceclang; usingnamespaceCodeGen; /***/ unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) { … } /// Derives the 'this' type for codegen purposes, i.e. ignoring method CVR /// qualification. Either or both of RD and MD may be null. A null RD indicates /// that there is no meaningful 'this' type, and a null MD can occur when /// calling a method pointer. CanQualType CodeGenTypes::DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD) { … } /// Returns the canonical formal type of the given C++ method. static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) { … } /// 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) { … } /// Arrange the argument and result information for a value of the given /// unprototyped freestanding function type. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) { … } static void addExtParameterInfosForCall( llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo> ¶mInfos, const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { … } /// Adds the formal parameters in FPT to the given prefix. If any parameter in /// FPT has pass_object_size attrs, then we'll add parameters for those, too. static void appendParameterTypes(const CodeGenTypes &CGT, SmallVectorImpl<CanQualType> &prefix, SmallVectorImpl<FunctionProtoType::ExtParameterInfo> ¶mInfos, CanQual<FunctionProtoType> FPT) { … } /// Arrange the LLVM function layout for a value of the given function /// type, on top of any implicit parameters already stored. static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl<CanQualType> &prefix, CanQual<FunctionProtoType> FTP) { … } /// Arrange the argument and result information for a value of the /// given freestanding function type. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) { … } static CallingConv getCallingConventionForDecl(const ObjCMethodDecl *D, bool IsWindows) { … } /// Arrange the argument and result information for a call to an /// unknown C++ non-static member function of the given abstract type. /// (A null RD means we don't have any meaningful "this" argument type, /// so fall back to a generic pointer type). /// The member function must be an ordinary function, i.e. not a /// constructor or destructor. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD) { … } /// Set calling convention for CUDA/HIP kernel. static void setCUDAKernelCallingConvention(CanQualType &FTy, CodeGenModule &CGM, const FunctionDecl *FD) { … } /// 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) { … } bool CodeGenTypes::inheritingCtorHasParams( const InheritedConstructor &Inherited, CXXCtorType Type) { … } const CGFunctionInfo & CodeGenTypes::arrangeCXXStructorDeclaration(GlobalDecl GD) { … } static SmallVector<CanQualType, 16> getArgTypesForCall(ASTContext &ctx, const CallArgList &args) { … } static SmallVector<CanQualType, 16> getArgTypesForDeclaration(ASTContext &ctx, const FunctionArgList &args) { … } static llvm::SmallVector<FunctionProtoType::ExtParameterInfo, 16> getExtParameterInfosForCall(const FunctionProtoType *proto, unsigned prefixArgs, unsigned totalArgs) { … } /// Arrange a call to a C++ method, passing the given arguments. /// /// ExtraPrefixArgs is the number of ABI-specific args passed after the `this` /// parameter. /// ExtraSuffixArgs is the number of ABI-specific args passed at the end of /// args. /// PassProtoArgs indicates whether `args` has args for the parameters in the /// given CXXConstructorDecl. const CGFunctionInfo & CodeGenTypes::arrangeCXXConstructorCall(const CallArgList &args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs) { … } /// Arrange the argument and result information for the declaration or /// definition of the given function. const CGFunctionInfo & CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) { … } /// Arrange the argument and result information for the declaration or /// definition of an Objective-C method. const CGFunctionInfo & CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) { … } /// 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) { … } const CGFunctionInfo & CodeGenTypes::arrangeUnprototypedObjCMessageSend(QualType returnType, const CallArgList &args) { … } const CGFunctionInfo & CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { … } /// Arrange a thunk that takes 'this' as the first parameter followed by /// varargs. Return a void pointer, regardless of the actual return type. /// The body of the thunk will end in a musttail call to a function of the /// correct type, and the caller will bitcast the function to the correct /// prototype. const CGFunctionInfo & CodeGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD) { … } const CGFunctionInfo & CodeGenTypes::arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT) { … } /// Arrange a call as unto a free function, except possibly with an /// additional number of formal parameters considered required. static const CGFunctionInfo & arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, CodeGenModule &CGM, const CallArgList &args, const FunctionType *fnType, unsigned numExtraRequiredArgs, bool chainCall) { … } /// Figure out the rules for calling a function with the given formal /// type using the given arguments. The arguments are necessary /// because the function might be unprototyped, in which case it's /// target-dependent in crazy ways. const CGFunctionInfo & CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args, const FunctionType *fnType, bool chainCall) { … } /// A block function is essentially a free function with an /// extra implicit argument. const CGFunctionInfo & CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *fnType) { … } const CGFunctionInfo & CodeGenTypes::arrangeBlockFunctionDeclaration(const FunctionProtoType *proto, const FunctionArgList ¶ms) { … } const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args) { … } const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args) { … } const CGFunctionInfo & CodeGenTypes::arrangeBuiltinFunctionDeclaration(CanQualType resultType, ArrayRef<CanQualType> argTypes) { … } /// Arrange a call to a C++ method, passing the given arguments. /// /// numPrefixArgs is the number of ABI-specific prefix arguments we have. It /// does not count `this`. const CGFunctionInfo & CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *proto, RequiredArgs required, unsigned numPrefixArgs) { … } const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { … } const CGFunctionInfo & CodeGenTypes::arrangeCall(const CGFunctionInfo &signature, const CallArgList &args) { … } namespace clang { namespace CodeGen { void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI); } } /// Arrange the argument and result information for an abstract value /// of a given function type. This is the method which all of the /// above functions ultimately defer to. const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo( CanQualType resultType, FnInfoOpts opts, ArrayRef<CanQualType> argTypes, FunctionType::ExtInfo info, ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos, RequiredArgs required) { … } CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, bool instanceMethod, bool chainCall, bool delegateCall, const FunctionType::ExtInfo &info, ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType, ArrayRef<CanQualType> argTypes, RequiredArgs required) { … } /***/ namespace { // ABIArgInfo::Expand implementation. // Specifies the way QualType passed as ABIArgInfo::Expand is expanded. struct TypeExpansion { … }; struct ConstantArrayExpansion : TypeExpansion { … }; struct RecordExpansion : TypeExpansion { … }; struct ComplexExpansion : TypeExpansion { … }; struct NoExpansion : TypeExpansion { … }; } // namespace static std::unique_ptr<TypeExpansion> getTypeExpansion(QualType Ty, const ASTContext &Context) { … } static int getExpansionSize(QualType Ty, const ASTContext &Context) { … } void CodeGenTypes::getExpandedTypes(QualType Ty, SmallVectorImpl<llvm::Type *>::iterator &TI) { … } static void forConstantArrayExpansion(CodeGenFunction &CGF, ConstantArrayExpansion *CAE, Address BaseAddr, llvm::function_ref<void(Address)> Fn) { … } void CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, llvm::Function::arg_iterator &AI) { … } void CodeGenFunction::ExpandTypeToArgs( QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, SmallVectorImpl<llvm::Value *> &IRCallArgs, unsigned &IRCallArgPos) { … } /// Create a temporary allocation for the purposes of coercion. static RawAddress CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty, CharUnits MinAlign, const Twine &Name = "tmp") { … } /// EnterStructPointerForCoercedAccess - Given a struct pointer that we are /// accessing some number of bytes out of it, try to gep into the struct to get /// at its inner goodness. Dive as deep as possible without entering an element /// with an in-memory size smaller than DstSize. static Address EnterStructPointerForCoercedAccess(Address SrcPtr, llvm::StructType *SrcSTy, uint64_t DstSize, CodeGenFunction &CGF) { … } /// 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) { … } /// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as /// a pointer to an object of type \arg Ty, known to be aligned to /// \arg SrcAlign bytes. /// /// This safely handles the case when the src type is smaller than the /// destination type; in this situation the values of bits which not /// present in the src are undefined. static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty, CodeGenFunction &CGF) { … } void CodeGenFunction::CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile) { … } static Address emitAddressAtOffset(CodeGenFunction &CGF, Address addr, const ABIArgInfo &info) { … } namespace { /// Encapsulates information about the way function arguments from /// CGFunctionInfo should be passed to actual LLVM IR function. class ClangToLLVMArgMapping { … }; void ClangToLLVMArgMapping::construct(const ASTContext &Context, const CGFunctionInfo &FI, bool OnlyRequiredArgs) { … } } // namespace /***/ bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { … } bool CodeGenModule::ReturnTypeHasInReg(const CGFunctionInfo &FI) { … } bool CodeGenModule::ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI) { … } bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { … } bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) { … } llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) { … } llvm::FunctionType * CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) { … } llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) { … } static void AddAttributesFromFunctionProtoType(ASTContext &Ctx, llvm::AttrBuilder &FuncAttrs, const FunctionProtoType *FPT) { … } static void AddAttributesFromOMPAssumes(llvm::AttrBuilder &FuncAttrs, const Decl *Callee) { … } bool CodeGenModule::MayDropFunctionReturn(const ASTContext &Context, QualType ReturnType) const { … } static bool HasStrictReturn(const CodeGenModule &Module, QualType RetTy, const Decl *TargetDecl) { … } /// Add denormal-fp-math and denormal-fp-math-f32 as appropriate for the /// requested denormal behavior, accounting for the overriding behavior of the /// -f32 case. static void addDenormalModeAttrs(llvm::DenormalMode FPDenormalMode, llvm::DenormalMode FP32DenormalMode, llvm::AttrBuilder &FuncAttrs) { … } /// Add default attributes to a function, which have merge semantics under /// -mlink-builtin-bitcode and should not simply overwrite any existing /// attributes in the linked library. static void addMergableDefaultFunctionAttributes(const CodeGenOptions &CodeGenOpts, llvm::AttrBuilder &FuncAttrs) { … } static void getTrivialDefaultFunctionAttributes( StringRef Name, bool HasOptnone, const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts, bool AttrOnCallSite, llvm::AttrBuilder &FuncAttrs) { … } /// Merges `target-features` from \TargetOpts and \F, and sets the result in /// \FuncAttr /// * features from \F are always kept /// * a feature from \TargetOpts is kept if itself and its opposite are absent /// from \F static void overrideFunctionFeaturesWithTargetFeatures(llvm::AttrBuilder &FuncAttr, const llvm::Function &F, const TargetOptions &TargetOpts) { … } void CodeGen::mergeDefaultFunctionDefinitionAttributes( llvm::Function &F, const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts, const TargetOptions &TargetOpts, bool WillInternalize) { … } void CodeGenModule::getTrivialDefaultFunctionAttributes( StringRef Name, bool HasOptnone, bool AttrOnCallSite, llvm::AttrBuilder &FuncAttrs) { … } void CodeGenModule::getDefaultFunctionAttributes(StringRef Name, bool HasOptnone, bool AttrOnCallSite, llvm::AttrBuilder &FuncAttrs) { … } void CodeGenModule::addDefaultFunctionDefinitionAttributes( llvm::AttrBuilder &attrs) { … } static void addNoBuiltinAttributes(llvm::AttrBuilder &FuncAttrs, const LangOptions &LangOpts, const NoBuiltinAttr *NBA = nullptr) { … } static bool DetermineNoUndef(QualType QTy, CodeGenTypes &Types, const llvm::DataLayout &DL, const ABIArgInfo &AI, bool CheckCoerce = true) { … } /// Check if the argument of a function has maybe_undef attribute. static bool IsArgumentMaybeUndef(const Decl *TargetDecl, unsigned NumRequiredArgs, unsigned ArgNo) { … } /// Test if it's legal to apply nofpclass for the given parameter type and it's /// lowered IR type. static bool canApplyNoFPClass(const ABIArgInfo &AI, QualType ParamType, bool IsReturn) { … } /// Return the nofpclass mask that can be applied to floating-point parameters. static llvm::FPClassTest getNoFPClassTestMask(const LangOptions &LangOpts) { … } void CodeGenModule::AdjustMemoryAttribute(StringRef Name, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs) { … } /// Construct the IR attribute list of a function or call. /// /// When adding an attribute, please consider where it should be handled: /// /// - getDefaultFunctionAttributes is for attributes that are essentially /// part of the global target configuration (but perhaps can be /// overridden on a per-function basis). Adding attributes there /// will cause them to also be set in frontends that build on Clang's /// target-configuration logic, as well as for code defined in library /// modules such as CUDA's libdevice. /// /// - ConstructAttributeList builds on top of getDefaultFunctionAttributes /// and adds declaration-specific, convention-specific, and /// frontend-specific logic. The last is of particular importance: /// attributes that restrict how the frontend generates code must be /// added here rather than getDefaultFunctionAttributes. /// void CodeGenModule::ConstructAttributeList(StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo, llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk) { … } /// 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) { … } /// 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) { … } namespace { struct CopyBackSwiftError final : EHScopeStack::Cleanup { … }; } void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args) { … } static void eraseUnusedBitCasts(llvm::Instruction *insn) { … } /// Try to emit a fused autorelease of a return result. static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result) { … } /// If this is a +1 of the value of an immutable 'self', remove it. static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result) { … } /// 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) { … } /// Heuristically search for a dominating store to the return-value slot. static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { … } // Helper functions for EmitCMSEClearRecord // Set the bits corresponding to a field having width `BitWidth` and located at // offset `BitOffset` (from the least significant bit) within a storage unit of // `Bits.size()` bytes. Each element of `Bits` corresponds to one target byte. // Use little-endian layout, i.e.`Bits[0]` is the LSB. static void setBitRange(SmallVectorImpl<uint64_t> &Bits, int BitOffset, int BitWidth, int CharWidth) { … } // Set the bits corresponding to a field having width `BitWidth` and located at // offset `BitOffset` (from the least significant bit) within a storage unit of // `StorageSize` bytes, located at `StorageOffset` in `Bits`. Each element of // `Bits` corresponds to one target byte. Use target endian layout. static void setBitRange(SmallVectorImpl<uint64_t> &Bits, int StorageOffset, int StorageSize, int BitOffset, int BitWidth, int CharWidth, bool BigEndian) { … } static void setUsedBits(CodeGenModule &, QualType, int, SmallVectorImpl<uint64_t> &); // Set the bits in `Bits`, which correspond to the value representations of // the actual members of the record type `RTy`. Note that this function does // not handle base classes, virtual tables, etc, since they cannot happen in // CMSE function arguments or return. The bit mask corresponds to the target // memory layout, i.e. it's endian dependent. static void setUsedBits(CodeGenModule &CGM, const RecordType *RTy, int Offset, SmallVectorImpl<uint64_t> &Bits) { … } // Set the bits in `Bits`, which correspond to the value representations of // the elements of an array type `ATy`. static void setUsedBits(CodeGenModule &CGM, const ConstantArrayType *ATy, int Offset, SmallVectorImpl<uint64_t> &Bits) { … } // Set the bits in `Bits`, which correspond to the value representations of // the type `QTy`. static void setUsedBits(CodeGenModule &CGM, QualType QTy, int Offset, SmallVectorImpl<uint64_t> &Bits) { … } static uint64_t buildMultiCharMask(const SmallVectorImpl<uint64_t> &Bits, int Pos, int Size, int CharWidth, bool BigEndian) { … } // Emit code to clear the bits in a record, which aren't a part of any user // declared member, when the record is a function return. llvm::Value *CodeGenFunction::EmitCMSEClearRecord(llvm::Value *Src, llvm::IntegerType *ITy, QualType QTy) { … } // Emit code to clear the bits in a record, which aren't a part of any user // declared member, when the record is a function argument. llvm::Value *CodeGenFunction::EmitCMSEClearRecord(llvm::Value *Src, llvm::ArrayType *ATy, QualType QTy) { … } void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc) { … } void CodeGenFunction::EmitReturnValueCheck(llvm::Value *RV) { … } static bool isInAllocaArgument(CGCXXABI &ABI, QualType type) { … } static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty) { … } void CodeGenFunction::EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc) { … } static bool isProvablyNull(llvm::Value *addr) { … } static bool isProvablyNonNull(Address Addr, CodeGenFunction &CGF) { … } /// Emit the actual writing-back of a writeback. static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback) { … } static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args) { … } static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs) { … } static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) { … } /// Emit an argument that's being passed call-by-writeback. That is, /// 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. static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE) { … } void CallArgList::allocateArgumentMemory(CodeGenFunction &CGF) { … } void CallArgList::freeArgumentMemory(CodeGenFunction &CGF) const { … } void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum) { … } void CodeGenFunction::EmitNonNullArgCheck(Address Addr, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum) { … } // Check if the call is going to use the inalloca convention. This needs to // agree with CGFunctionInfo::usesInAlloca. The CGFunctionInfo is arranged // later, so we can't check it directly. static bool hasInAllocaArgs(CodeGenModule &CGM, CallingConv ExplicitCC, ArrayRef<QualType> ArgTypes) { … } #ifndef NDEBUG // Determine whether the given argument is an Objective-C method // that may have type parameters in its signature. static bool isObjCMethodWithTypeParams(const ObjCMethodDecl *method) { const DeclContext *dc = method->getDeclContext(); if (const ObjCInterfaceDecl *classDecl = dyn_cast<ObjCInterfaceDecl>(dc)) { return classDecl->getTypeParamListAsWritten(); } if (const ObjCCategoryDecl *catDecl = dyn_cast<ObjCCategoryDecl>(dc)) { return catDecl->getTypeParamList(); } return false; } #endif /// EmitCallArgs - Emit call arguments for a function. void CodeGenFunction::EmitCallArgs( CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange, AbstractCallee AC, unsigned ParamsToSkip, EvaluationOrder Order) { … } namespace { struct DestroyUnpassedArg final : EHScopeStack::Cleanup { … }; struct DisableDebugLocationUpdates { … }; } // end anonymous namespace RValue CallArg::getRValue(CodeGenFunction &CGF) const { … } void CallArg::copyInto(CodeGenFunction &CGF, Address Addr) const { … } void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E, QualType type) { … } QualType CodeGenFunction::getVarArgType(const Expr *Arg) { … } // 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) { … } /// Emits a call to the given no-arguments nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const llvm::Twine &name) { … } /// Emits a call to the given nounwind runtime function. llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::FunctionCallee callee, ArrayRef<Address> args, const llvm::Twine &name) { … } llvm::CallInst * CodeGenFunction::EmitNounwindRuntimeCall(llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args, const llvm::Twine &name) { … } /// Emits a simple call (never an invoke) to the given no-arguments /// runtime function. llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee, const llvm::Twine &name) { … } // Calls which may throw must have operand bundles indicating which funclet // they are nested within. SmallVector<llvm::OperandBundleDef, 1> CodeGenFunction::getBundlesForFunclet(llvm::Value *Callee) { … } /// Emits a simple call (never an invoke) to the given runtime function. llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args, const llvm::Twine &name) { … } /// Emits a call or invoke to the given noreturn runtime function. void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke( llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args) { … } /// Emits a call or invoke instruction to the given nullary runtime function. llvm::CallBase * CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, const Twine &name) { … } /// Emits a call or invoke instruction to the given runtime function. llvm::CallBase * CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args, const Twine &name) { … } /// Emits a call or invoke instruction to the given function, depending /// on the current state of the EH stack. llvm::CallBase *CodeGenFunction::EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef<llvm::Value *> Args, const Twine &Name) { … } void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New) { … } namespace { /// Specify given \p NewAlign as the alignment of return value attribute. If /// such attribute already exists, re-set it to the maximal one of two options. [[nodiscard]] llvm::AttributeList maybeRaiseRetAlignmentAttribute(llvm::LLVMContext &Ctx, const llvm::AttributeList &Attrs, llvm::Align NewAlign) { … } template <typename AlignedAttrTy> class AbstractAssumeAlignedAttrEmitter { … }; /// Helper data structure to emit `AssumeAlignedAttr`. class AssumeAlignedAttrEmitter final : public AbstractAssumeAlignedAttrEmitter<AssumeAlignedAttr> { … }; /// Helper data structure to emit `AllocAlignAttr`. class AllocAlignAttrEmitter final : public AbstractAssumeAlignedAttrEmitter<AllocAlignAttr> { … }; } // namespace static unsigned getMaxVectorWidth(const llvm::Type *Ty) { … } RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &CallArgs, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk) { … } CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const { … } /* VarArg handling */ RValue CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr, AggValueSlot Slot) { … }
Codebase Browser
llvm