//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===// // // 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 // //===----------------------------------------------------------------------===// // // This file implements type-related semantic analysis. // //===----------------------------------------------------------------------===// #include "TypeLocBuilder.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTMutationListener.h" #include "clang/AST/ASTStructuralEquivalence.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprObjC.h" #include "clang/AST/LocInfoType.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ParsedAttr.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaOpenMP.h" #include "clang/Sema/Template.h" #include "clang/Sema/TemplateInstCallback.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" #include <bitset> #include <optional> usingnamespaceclang; enum TypeDiagSelector { … }; /// isOmittedBlockReturnType - Return true if this declarator is missing a /// return type because this is a omitted return type on a block literal. static bool isOmittedBlockReturnType(const Declarator &D) { … } /// diagnoseBadTypeAttribute - Diagnoses a type attribute which /// doesn't apply to the given type. static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type) { … } // objc_gc applies to Objective-C pointers or, otherwise, to the // smallest available pointer type (i.e. 'void*' in 'void**'). #define OBJC_POINTER_TYPE_ATTRS_CASELIST … // Calling convention attributes. #define CALLING_CONV_ATTRS_CASELIST … // Function type attributes. #define FUNCTION_TYPE_ATTRS_CASELIST … // Microsoft-specific type qualifiers. #define MS_TYPE_ATTRS_CASELIST … // Nullability qualifiers. #define NULLABILITY_TYPE_ATTRS_CASELIST … namespace { /// An object which stores processing state for the entire /// GetTypeForDeclarator process. class TypeProcessingState { … }; } // end anonymous namespace static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList) { … } /// The location of a type attribute. enum TypeAttrLocation { … }; static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, CUDAFunctionTarget CFT = CUDAFunctionTarget::HostDevice); static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, CUDAFunctionTarget CFT); static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type); static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type); static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type); static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) { … } /// Given the index of a declarator chunk, check whether that chunk /// directly specifies the return type of a function and, if so, find /// an appropriate place for it. /// /// \param i - a notional index which the search will start /// immediately inside /// /// \param onlyBlockPointers Whether we should only look into block /// pointer types (vs. all pointer types). static DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers) { … } /// Given that an objc_gc attribute was written somewhere on a /// declaration *other* than on the declarator itself (for which, use /// distributeObjCPointerTypeAttrFromDeclarator), and given that it /// didn't apply in whatever position it was written in, try to move /// it to a more appropriate position. static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type) { … } /// Distribute an objc_gc type attribute that was written on the /// declarator. static void distributeObjCPointerTypeAttrFromDeclarator( TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType) { … } /// A function type attribute was written somewhere in a declaration /// *other* than on the declarator itself or in the decl spec. Given /// that it didn't apply in whatever position it was written in, try /// to move it to a more appropriate position. static void distributeFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type) { … } /// Try to distribute a function type attribute to the innermost /// function chunk or type. Returns true if the attribute was /// distributed, false if no location was found. static bool distributeFunctionTypeAttrToInnermost( TypeProcessingState &state, ParsedAttr &attr, ParsedAttributesView &attrList, QualType &declSpecType, CUDAFunctionTarget CFT) { … } /// A function type attribute was written in the decl spec. Try to /// apply it somewhere. static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT) { … } /// A function type attribute was written on the declarator or declaration. /// Try to apply it somewhere. /// `Attrs` is the attribute list containing the declaration (either of the /// declarator or the declaration). static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT) { … } /// Given that there are attributes written on the declarator or declaration /// itself, try to distribute any type attributes to the appropriate /// declarator chunk. /// /// These are attributes like the following: /// int f ATTR; /// int (f ATTR)(); /// but not necessarily this: /// int f() ATTR; /// /// `Attrs` is the attribute list containing the declaration (either of the /// declarator or the declaration). static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType, CUDAFunctionTarget CFT) { … } /// Add a synthetic '()' to a block-literal declarator if it is /// required, given the return type. static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType) { … } static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID) { … } /// Return true if this is omitted block return type. Also check type /// attributes and type qualifiers when returning true. static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result) { … } static OpenCLAccessAttr::Spelling getImageAccess(const ParsedAttributesView &Attrs) { … } static UnaryTransformType::UTTKind TSTToUnaryTransformType(DeclSpec::TST SwitchTST) { … } /// Convert the specified declspec to the appropriate type /// object. /// \param state Specifies the declarator containing the declaration specifier /// to be converted, along with other associated processing state. /// \returns The type described by the declaration specifiers. This function /// never returns null. static QualType ConvertDeclSpecToType(TypeProcessingState &state) { … } static std::string getPrintableNameForEntity(DeclarationName Entity) { … } static bool isDependentOrGNUAutoType(QualType T) { … } QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS) { … } QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRAU, const DeclSpec *DS) { … } QualType Sema::BuildParenType(QualType T) { … } /// Given that we're building a pointer or reference to the given static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference) { … } static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){ … } namespace { /// Kinds of declarator that cannot contain a qualified function type. /// /// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6: /// a function type with a cv-qualifier or a ref-qualifier can only appear /// at the topmost level of a type. /// /// Parens and member pointers are permitted. We don't diagnose array and /// function declarators, because they don't allow function types at all. /// /// The values of this enum are used in diagnostics. enum QualifiedFunctionKind { … }; } // end anonymous namespace /// Check whether the type T is a qualified function type, and if it is, /// diagnose that it cannot be contained within the given kind of declarator. static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK) { … } bool Sema::CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc) { … } // Helper to deduce addr space of a pointee type in OpenCL mode. static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) { … } QualType Sema::BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity) { … } QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, SourceLocation Loc, DeclarationName Entity) { … } QualType Sema::BuildReadPipeType(QualType T, SourceLocation Loc) { … } QualType Sema::BuildWritePipeType(QualType T, SourceLocation Loc) { … } QualType Sema::BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc) { … } /// Check whether the specified array bound can be evaluated using the relevant /// language rules. If so, returns the possibly-converted expression and sets /// SizeVal to the size. If not, but the expression might be a VLA bound, /// returns ExprResult(). Otherwise, produces a diagnostic and returns /// ExprError(). static ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError) { … } bool Sema::checkArrayElementAlignment(QualType EltTy, SourceLocation Loc) { … } QualType Sema::BuildArrayType(QualType T, ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) { … } QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr, SourceLocation AttrLoc) { … } QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc) { … } QualType Sema::BuildMatrixType(QualType ElementTy, Expr *NumRows, Expr *NumCols, SourceLocation AttrLoc) { … } bool Sema::CheckFunctionReturnType(QualType T, SourceLocation Loc) { … } /// Check the extended parameter information. Most of the necessary /// checking should occur when applying the parameter attribute; the /// only other checks required are positional restrictions. static void checkExtParameterInfos(Sema &S, ArrayRef<QualType> paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref<SourceLocation(unsigned)> getParamLoc) { … } QualType Sema::BuildFunctionType(QualType T, MutableArrayRef<QualType> ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI) { … } QualType Sema::BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity) { … } QualType Sema::BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity) { … } QualType Sema::GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo) { … } static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex); /// Given that this is the declaration of a parameter under ARC, /// attempt to infer attributes and such for pointer-to-whatever /// types. static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType) { … } void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc, SourceLocation VolatileQualLoc, SourceLocation RestrictQualLoc, SourceLocation AtomicQualLoc, SourceLocation UnalignedQualLoc) { … } // Diagnose pointless type qualifiers on the return type of a function. static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex) { … } static std::pair<QualType, TypeSourceInfo *> InventTemplateParameter(TypeProcessingState &state, QualType T, TypeSourceInfo *TrailingTSI, AutoType *Auto, InventedTemplateParameterInfo &Info) { … } static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo); static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo) { … } /// Produce an appropriate diagnostic for an ambiguity between a function /// declarator and a C++ direct-initializer. static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT) { … } /// Produce an appropriate diagnostic for a declarator with top-level /// parentheses. static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T) { … } /// Helper for figuring out the default CC for a function declarator type. If /// this is the outermost chunk, then we can determine the CC from the /// declarator context. If not, then this could be either a member function /// type or normal function type. static CallingConv getCCForDeclaratorChunk( Sema &S, Declarator &D, const ParsedAttributesView &AttrList, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex) { … } namespace { /// A simple notion of pointer kinds, which matches up with the various /// pointer declarators. enum class SimplePointerKind { … }; } // end anonymous namespace IdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) { … } /// Check whether there is a nullability attribute of any kind in the given /// attribute list. static bool hasNullabilityAttr(const ParsedAttributesView &attrs) { … } namespace { /// Describes the kind of a pointer a declarator describes. enum class PointerDeclaratorKind { … }; /// Describes a declarator chunk wrapping a pointer that marks inference as /// unexpected. // These values must be kept in sync with diagnostics. enum class PointerWrappingDeclaratorKind { … }; } // end anonymous namespace /// Classify the given declarator, whose type-specified is \c type, based on /// what kind of pointer it refers to. /// /// This is used to determine the default nullability. static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind) { … } static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc) { … } /// Creates a fix-it to insert a C-style nullability keyword at \p pointerLoc, /// taking into account whitespace before and after. template <typename DiagBuilderT> static void fixItNullability(Sema &S, DiagBuilderT &Diag, SourceLocation PointerLoc, NullabilityKind Nullability) { … } static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc) { … } /// Complains about missing nullability if the file containing \p pointerLoc /// has other uses of nullability (either the keywords or the \c assume_nonnull /// pragma). /// /// If the file has \e not seen other uses of nullability, this particular /// pointer is saved for possible later diagnosis. See recordNullabilitySeen(). static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc = SourceLocation()) { … } /// Marks that a nullability feature has been used in the file containing /// \p loc. /// /// If this file already had pointer types in it that were missing nullability, /// the first such instance is retroactively diagnosed. /// /// \sa checkNullabilityConsistency static void recordNullabilitySeen(Sema &S, SourceLocation loc) { … } /// Returns true if any of the declarator chunks before \p endIndex include a /// level of indirection: array, pointer, reference, or pointer-to-member. /// /// Because declarator chunks are stored in outer-to-inner order, testing /// every chunk before \p endIndex is testing all chunks that embed the current /// chunk as part of their type. /// /// It is legal to pass the result of Declarator::getNumTypeObjects() as the /// end index, in which case all chunks are tested. static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex) { … } static bool IsNoDerefableChunk(const DeclaratorChunk &Chunk) { … } template<typename AttrT> static AttrT *createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL) { … } static Attr *createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK) { … } // Diagnose whether this is a case with the multiple addr spaces. // Returns true if this is an invalid case. // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified // by qualifiers for two or more different address spaces." static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc) { … } // Whether this is a type broadly expected to have nullability attached. // These types are affected by `#pragma assume_nonnull`, and missing nullability // will be diagnosed with -Wnullability-completeness. static bool shouldHaveNullability(QualType T) { … } static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) { … } TypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D) { … } static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership) { … } static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex) { … } /// Used for transferring ownership in casts resulting in l-values. static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership) { … } TypeSourceInfo *Sema::GetTypeForDeclaratorCast(Declarator &D, QualType FromTy) { … } static void fillAttributedTypeLoc(AttributedTypeLoc TL, TypeProcessingState &State) { … } static void fillHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL, TypeProcessingState &State) { … } static void fillMatrixTypeLoc(MatrixTypeLoc MTL, const ParsedAttributesView &Attrs) { … } namespace { class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> { … }; class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> { … }; } // end anonymous namespace static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) { … } static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, const ParsedAttributesView &Attrs) { … } /// Create and instantiate a TypeSourceInfo with type source information. /// /// \param T QualType referring to the type as written in source code. /// /// \param ReturnTypeInfo For declarators whose return type does not show /// up in the normal place in the declaration specifiers (such as a C++ /// conversion function), this pointer will refer to a type source information /// for that return type. static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo) { … } /// Create a LocInfoType to hold the given QualType and TypeSourceInfo. ParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) { … } void LocInfoType::getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const { … } TypeResult Sema::ActOnTypeName(Declarator &D) { … } //===----------------------------------------------------------------------===// // Type Attribute Processing //===----------------------------------------------------------------------===// /// Build an AddressSpace index from a constant expression and diagnose any /// errors related to invalid address_spaces. Returns true on successfully /// building an AddressSpace index. static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc) { … } QualType Sema::BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc) { … } QualType Sema::BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace, SourceLocation AttrLoc) { … } static void HandleBTFTypeTagAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State) { … } /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the /// specified type. The attribute contains 1 argument, the id of the address /// space for the type. static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State) { … } /// handleObjCOwnershipTypeAttr - Process an objc_ownership /// attribute on the specified type. /// /// Returns 'true' if the attribute was handled. static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) { … } /// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type /// attribute on the specified type. Returns true to indicate that /// the attribute was handled, false to indicate that the type does /// not permit the attribute. static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) { … } namespace { /// A helper class to unwrap a type down to a function for the /// purposes of applying attributes there. /// /// Use: /// FunctionTypeUnwrapper unwrapped(SemaRef, T); /// if (unwrapped.isFunctionType()) { /// const FunctionType *fn = unwrapped.get(); /// // change fn somehow /// T = unwrapped.wrap(fn); /// } struct FunctionTypeUnwrapper { … }; } // end anonymous namespace static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State, ParsedAttr &PAttr, QualType &Type) { … } static bool HandleWebAssemblyFuncrefAttr(TypeProcessingState &State, QualType &QT, ParsedAttr &PAttr) { … } /// Rebuild an attributed type without the nullability attribute on it. static QualType rebuildAttributedTypeWithoutNullability(ASTContext &Ctx, QualType Type) { … } /// Map a nullability attribute kind to a nullability kind. static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind) { … } static bool CheckNullabilityTypeSpecifier( Sema &S, TypeProcessingState *State, ParsedAttr *PAttr, QualType &QT, NullabilityKind Nullability, SourceLocation NullabilityLoc, bool IsContextSensitive, bool AllowOnArrayType, bool OverrideExisting) { … } static bool CheckNullabilityTypeSpecifier(TypeProcessingState &State, QualType &Type, ParsedAttr &Attr, bool AllowOnArrayType) { … } bool Sema::CheckImplicitNullabilityTypeSpecifier(QualType &Type, NullabilityKind Nullability, SourceLocation DiagLoc, bool AllowArrayTypes, bool OverrideExisting) { … } /// Check the application of the Objective-C '__kindof' qualifier to /// the given type. static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, ParsedAttr &attr) { … } /// Distribute a nullability type attribute that cannot be applied to /// the type specifier to a pointer, block pointer, or member pointer /// declarator, complaining if necessary. /// /// \returns true if the nullability annotation was distributed, false /// otherwise. static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr) { … } static Attr *getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr) { … } std::optional<FunctionEffectMode> Sema::ActOnEffectExpression(Expr *CondExpr, StringRef AttributeName) { … } static bool handleNonBlockingNonAllocatingTypeAttr(TypeProcessingState &TPState, ParsedAttr &PAttr, QualType &QT, FunctionTypeUnwrapper &Unwrapped) { … } static bool checkMutualExclusion(TypeProcessingState &state, const FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, AttributeCommonInfo::Kind OtherKind) { … } static bool handleArmStateAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, FunctionType::ArmStateValue State) { … } /// Process an individual function attribute. Returns true to /// indicate that the attribute was handled, false if it wasn't. static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, CUDAFunctionTarget CFT) { … } bool Sema::hasExplicitCallingConv(QualType T) { … } void Sema::adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc) { … } /// HandleVectorSizeAttribute - this attribute is only applicable to integral /// and float scalars, although arrays, pointers, and function return values are /// allowed in conjunction with this construct. Aggregates with this attribute /// are invalid, even if they are of the same size as a corresponding scalar. /// The raw attribute should contain precisely 1 argument, the vector size for /// the variable, measured in bytes. If curType and rawAttr are well formed, /// this routine will return a new vector type. static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S) { … } /// Process the OpenCL-like ext_vector_type attribute when it occurs on /// a type. static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S) { … } static bool isPermittedNeonBaseType(QualType &Ty, VectorKind VecKind, Sema &S) { … } static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr, llvm::APSInt &Result) { … } /// HandleNeonVectorTypeAttr - The "neon_vector_type" and /// "neon_polyvector_type" attributes are used to create vector types that /// are mangled according to ARM's ABI. Otherwise, these types are identical /// to those created with the "vector_size" attribute. Unlike "vector_size" /// the argument to these Neon attributes is the number of vector elements, /// not the vector size in bytes. The vector width and element type must /// match one of the standard Neon vector types. static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorKind VecKind) { … } /// HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is /// used to create fixed-length versions of sizeless SVE types defined by /// the ACLE, such as svint32_t and svbool_t. static void HandleArmSveVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S) { … } static void HandleArmMveStrictPolymorphismAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr) { … } /// HandleRISCVRVVVectorBitsTypeAttr - The "riscv_rvv_vector_bits" attribute is /// used to create fixed-length versions of sizeless RVV types such as /// vint8m1_t_t. static void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S) { … } /// Handle OpenCL Access Qualifier Attribute. static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S) { … } /// HandleMatrixTypeAttr - "matrix_type" attribute, like ext_vector_type static void HandleMatrixTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S) { … } static void HandleAnnotateTypeAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &PA) { … } static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr) { … } static void HandleHLSLParamModifierAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &Attr, Sema &S) { … } static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, CUDAFunctionTarget CFT) { … } void Sema::completeExprArrayBound(Expr *E) { … } QualType Sema::getCompletedType(Expr *E) { … } bool Sema::RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser) { … } bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) { … } bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser) { … } bool Sema::hasStructuralCompatLayout(Decl *D, Decl *Suggested) { … } bool Sema::hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete) { … } /// Determine whether there is any declaration of \p D that was ever a /// definition (perhaps before module merging) and is currently visible. /// \param D The definition of the entity. /// \param Suggested Filled in with the declaration that should be made visible /// in order to provide a definition of this entity. /// \param OnlyNeedComplete If \c true, we only need the type to be complete, /// not defined. This only matters for enums with a fixed underlying /// type, since in all other cases, a type is complete if and only if it /// is defined. bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete) { … } /// Determine whether there is any declaration of \p D that was ever a /// definition (perhaps before module merging) and is currently /// reachable. /// \param D The definition of the entity. /// \param Suggested Filled in with the declaration that should be made /// reachable /// in order to provide a definition of this entity. /// \param OnlyNeedComplete If \c true, we only need the type to be complete, /// not defined. This only matters for enums with a fixed underlying /// type, since in all other cases, a type is complete if and only if it /// is defined. bool Sema::hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete) { … } /// Locks in the inheritance model for the given class and all of its bases. static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) { … } bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser *Diagnoser) { … } bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, unsigned DiagID) { … } /// Get diagnostic %select index for tag kind for /// literal type diagnostic message. /// WARNING: Indexes apply to particular diagnostics only! /// /// \returns diagnostic %select index. static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) { … } bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser) { … } bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) { … } QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl) { … } QualType Sema::BuildTypeofExprType(Expr *E, TypeOfKind Kind) { … } static void BuildTypeCoupledDecls(Expr *E, llvm::SmallVectorImpl<TypeCoupledDeclRefInfo> &Decls) { … } QualType Sema::BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull) { … } /// getDecltypeForExpr - Given an expr, will return the decltype for /// that expression, according to the rules in C++11 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18. QualType Sema::getDecltypeForExpr(Expr *E) { … } QualType Sema::BuildDecltypeType(Expr *E, bool AsUnevaluated) { … } QualType Sema::ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc) { … } QualType Sema::BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted, ArrayRef<QualType> Expansions) { … } static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType, SourceLocation Loc) { … } QualType Sema::BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc) { … } QualType Sema::BuiltinAddPointer(QualType BaseType, SourceLocation Loc) { … } QualType Sema::BuiltinRemovePointer(QualType BaseType, SourceLocation Loc) { … } QualType Sema::BuiltinDecay(QualType BaseType, SourceLocation Loc) { … } QualType Sema::BuiltinAddReference(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } QualType Sema::BuiltinRemoveExtent(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } QualType Sema::BuiltinRemoveReference(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } QualType Sema::BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType, bool IsMakeSigned, SourceLocation Loc) { … } QualType Sema::BuiltinChangeSignedness(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } QualType Sema::BuildUnaryTransformType(QualType BaseType, UTTKind UKind, SourceLocation Loc) { … } QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) { … }
Codebase Browser
llvm