| //===--- ItaniumCXXABIUtils.cpp - Shared Itanium C++ ABI queries ----------===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/CodeGenUtils/ItaniumCXXABIUtils.h" | |
| #include "clang/AST/CXXInheritance.h" | |
| #include "clang/AST/RecordLayout.h" | |
| namespace clang::CodeGenUtils { | |
| CharUnits computeOffsetHint(ASTContext &Ctx, const CXXRecordDecl *Src, | |
| const CXXRecordDecl *Dst) { | |
| CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, | |
| /*DetectVirtual=*/false); | |
| // If Dst is not derived from Src we can skip the whole computation below and | |
| // return that Src is not a public base of Dst. Record all inheritance paths. | |
| if (!Dst->isDerivedFrom(Src, Paths)) | |
| return CharUnits::fromQuantity(-2ULL); | |
| unsigned NumPublicPaths = 0; | |
| CharUnits Offset; | |
| // Now walk all possible inheritance paths. | |
| for (const CXXBasePath &Path : Paths) { | |
| if (Path.Access != AS_public) // Ignore non-public inheritance. | |
| continue; | |
| ++NumPublicPaths; | |
| for (const CXXBasePathElement &PathElement : Path) { | |
| // If the path contains a virtual base class we can't give any hint. | |
| // -1: no hint. | |
| if (PathElement.Base->isVirtual()) | |
| return CharUnits::fromQuantity(-1ULL); | |
| if (NumPublicPaths > 1) // Won't use offsets, skip computation. | |
| continue; | |
| // Accumulate the base class offsets. | |
| const ASTRecordLayout &L = Ctx.getASTRecordLayout(PathElement.Class); | |
| Offset += L.getBaseClassOffset( | |
| PathElement.Base->getType()->getAsCXXRecordDecl()); | |
| } | |
| } | |
| // -2: Src is not a public base of Dst. | |
| if (NumPublicPaths == 0) | |
| return CharUnits::fromQuantity(-2ULL); | |
| // -3: Src is a multiple public base type but never a virtual base type. | |
| if (NumPublicPaths > 1) | |
| return CharUnits::fromQuantity(-3ULL); | |
| // Otherwise, the Src type is a unique public nonvirtual base type of Dst. | |
| // Return the offset of Src from the origin of Dst. | |
| return Offset; | |
| } | |
| bool canUseSingleInheritance(const CXXRecordDecl *RD) { | |
| // Check the number of bases. | |
| if (RD->getNumBases() != 1) | |
| return false; | |
| // Get the base. | |
| CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(); | |
| // Check that the base is not virtual. | |
| if (Base->isVirtual()) | |
| return false; | |
| // Check that the base is public. | |
| if (Base->getAccessSpecifier() != AS_public) | |
| return false; | |
| // Check that the class is dynamic iff the base is. | |
| auto *BaseDecl = Base->getType()->castAsCXXRecordDecl(); | |
| return BaseDecl->isEmpty() || | |
| BaseDecl->isDynamicClass() == RD->isDynamicClass(); | |
| } | |
| namespace { | |
| /// Contains virtual and non-virtual bases seen when traversing a class | |
| /// hierarchy. | |
| struct SeenBases { | |
| llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases; | |
| llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases; | |
| }; | |
| } // namespace | |
| static unsigned computeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base, | |
| SeenBases &Bases) { | |
| unsigned Flags = 0; | |
| auto *BaseDecl = Base->getType()->castAsCXXRecordDecl(); | |
| if (Base->isVirtual()) { | |
| // Mark the virtual base as seen. | |
| if (!Bases.VirtualBases.insert(BaseDecl).second) { | |
| // If this virtual base has been seen before, then the class is diamond | |
| // shaped. | |
| Flags |= VMI_DiamondShaped; | |
| } else { | |
| if (Bases.NonVirtualBases.count(BaseDecl)) | |
| Flags |= VMI_NonDiamondRepeat; | |
| } | |
| } else { | |
| // Mark the non-virtual base as seen. | |
| if (!Bases.NonVirtualBases.insert(BaseDecl).second) { | |
| // If this non-virtual base has been seen before, then the class has non- | |
| // diamond shaped repeated inheritance. | |
| Flags |= VMI_NonDiamondRepeat; | |
| } else { | |
| if (Bases.VirtualBases.count(BaseDecl)) | |
| Flags |= VMI_NonDiamondRepeat; | |
| } | |
| } | |
| // Walk all bases. | |
| for (const auto &I : BaseDecl->bases()) | |
| Flags |= computeVMIClassTypeInfoFlags(&I, Bases); | |
| return Flags; | |
| } | |
| unsigned computeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) { | |
| unsigned Flags = 0; | |
| SeenBases Bases; | |
| // Walk all bases. | |
| for (const auto &I : RD->bases()) | |
| Flags |= computeVMIClassTypeInfoFlags(&I, Bases); | |
| return Flags; | |
| } | |
| /// Returns whether the given record type is incomplete. | |
| static bool isIncompleteClassType(const RecordType *RecordTy) { | |
| return !RecordTy->getDecl()->getDefinitionOrSelf()->isCompleteDefinition(); | |
| } | |
| bool containsIncompleteClassType(QualType Ty) { | |
| if (const auto *RecordTy = dyn_cast<RecordType>(Ty)) { | |
| if (isIncompleteClassType(RecordTy)) | |
| return true; | |
| } | |
| if (const auto *PointerTy = dyn_cast<PointerType>(Ty)) | |
| return containsIncompleteClassType(PointerTy->getPointeeType()); | |
| if (const auto *MemberPointerTy = dyn_cast<MemberPointerType>(Ty)) { | |
| // Check if the class type is incomplete. | |
| if (!MemberPointerTy->getMostRecentCXXRecordDecl()->hasDefinition()) | |
| return true; | |
| return containsIncompleteClassType(MemberPointerTy->getPointeeType()); | |
| } | |
| return false; | |
| } | |
| unsigned extractPBaseFlags(const ASTContext &Ctx, QualType &Type) { | |
| unsigned Flags = 0; | |
| if (Type.isConstQualified()) | |
| Flags |= PTI_Const; | |
| if (Type.isVolatileQualified()) | |
| Flags |= PTI_Volatile; | |
| if (Type.isRestrictQualified()) | |
| Flags |= PTI_Restrict; | |
| Type = Type.getUnqualifiedType(); | |
| // Itanium C++ ABI 2.9.5p7: | |
| // When the abi::__pbase_type_info is for a direct or indirect pointer to an | |
| // incomplete class type, the incomplete target type flag is set. | |
| if (containsIncompleteClassType(Type)) | |
| Flags |= PTI_Incomplete; | |
| if (auto *Proto = Type->getAs<FunctionProtoType>()) { | |
| if (Proto->isNothrow()) { | |
| Flags |= PTI_Noexcept; | |
| Type = Ctx.getFunctionTypeWithExceptionSpec(Type, EST_None); | |
| } | |
| } | |
| return Flags; | |
| } | |
| /// Given a builtin type, returns whether the type info for that type is | |
| /// defined in the standard library. | |
| static bool typeInfoIsInStandardLibrary(const BuiltinType *Ty) { | |
| // Itanium C++ ABI 2.9.2: | |
| // Basic type information (e.g. for "int", "bool", etc.) will be kept in | |
| // the run-time support library. Specifically, the run-time support | |
| // library should contain type_info objects for the types X, X* and | |
| // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char, | |
| // unsigned char, signed char, short, unsigned short, int, unsigned int, | |
| // long, unsigned long, long long, unsigned long long, float, double, | |
| // long double, char16_t, char32_t, and the IEEE 754r decimal and | |
| // half-precision floating point types. | |
| // | |
| // GCC also emits RTTI for __int128. | |
| // FIXME: We do not emit RTTI information for decimal types here. | |
| // Types added here must also be added to EmitFundamentalRTTIDescriptors in | |
| // clang/lib/CodeGen/ItaniumCXXABI.cpp. | |
| switch (Ty->getKind()) { | |
| case BuiltinType::Void: | |
| case BuiltinType::NullPtr: | |
| case BuiltinType::Bool: | |
| case BuiltinType::WChar_S: | |
| case BuiltinType::WChar_U: | |
| case BuiltinType::Char_U: | |
| case BuiltinType::Char_S: | |
| case BuiltinType::UChar: | |
| case BuiltinType::SChar: | |
| case BuiltinType::Short: | |
| case BuiltinType::UShort: | |
| case BuiltinType::Int: | |
| case BuiltinType::UInt: | |
| case BuiltinType::Long: | |
| case BuiltinType::ULong: | |
| case BuiltinType::LongLong: | |
| case BuiltinType::ULongLong: | |
| case BuiltinType::Half: | |
| case BuiltinType::Float: | |
| case BuiltinType::Double: | |
| case BuiltinType::LongDouble: | |
| case BuiltinType::Float16: | |
| case BuiltinType::Float128: | |
| case BuiltinType::Ibm128: | |
| case BuiltinType::Char8: | |
| case BuiltinType::Char16: | |
| case BuiltinType::Char32: | |
| case BuiltinType::Int128: | |
| case BuiltinType::UInt128: | |
| return true; | |
| #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ | |
| case BuiltinType::Id: | |
| #include "clang/Basic/OpenCLImageTypes.def" | |
| #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id: | |
| #include "clang/Basic/OpenCLExtensionTypes.def" | |
| case BuiltinType::OCLSampler: | |
| case BuiltinType::OCLEvent: | |
| case BuiltinType::OCLClkEvent: | |
| case BuiltinType::OCLQueue: | |
| case BuiltinType::OCLReserveID: | |
| #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/AArch64ACLETypes.def" | |
| #define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id: | |
| #include "clang/Basic/PPCTypes.def" | |
| #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/RISCVVTypes.def" | |
| #define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/WebAssemblyReferenceTypes.def" | |
| #define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id: | |
| #include "clang/Basic/AMDGPUTypes.def" | |
| #define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/HLSLIntangibleTypes.def" | |
| #define HLSL_PACKED_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/HLSLPackedTypes.def" | |
| #define SPIRV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/Basic/SPIRVTypes.def" | |
| case BuiltinType::ShortAccum: | |
| case BuiltinType::Accum: | |
| case BuiltinType::LongAccum: | |
| case BuiltinType::UShortAccum: | |
| case BuiltinType::UAccum: | |
| case BuiltinType::ULongAccum: | |
| case BuiltinType::ShortFract: | |
| case BuiltinType::Fract: | |
| case BuiltinType::LongFract: | |
| case BuiltinType::UShortFract: | |
| case BuiltinType::UFract: | |
| case BuiltinType::ULongFract: | |
| case BuiltinType::SatShortAccum: | |
| case BuiltinType::SatAccum: | |
| case BuiltinType::SatLongAccum: | |
| case BuiltinType::SatUShortAccum: | |
| case BuiltinType::SatUAccum: | |
| case BuiltinType::SatULongAccum: | |
| case BuiltinType::SatShortFract: | |
| case BuiltinType::SatFract: | |
| case BuiltinType::SatLongFract: | |
| case BuiltinType::SatUShortFract: | |
| case BuiltinType::SatUFract: | |
| case BuiltinType::SatULongFract: | |
| case BuiltinType::BFloat16: | |
| case BuiltinType::MetaInfo: | |
| return false; | |
| case BuiltinType::Dependent: | |
| #define BUILTIN_TYPE(Id, SingletonId) | |
| #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: | |
| #include "clang/AST/BuiltinTypes.def" | |
| llvm_unreachable("asking for RRTI for a placeholder type!"); | |
| case BuiltinType::ObjCId: | |
| case BuiltinType::ObjCClass: | |
| case BuiltinType::ObjCSel: | |
| llvm_unreachable("FIXME: Objective-C types are unsupported!"); | |
| } | |
| llvm_unreachable("Invalid BuiltinType Kind!"); | |
| } | |
| static bool typeInfoIsInStandardLibrary(const PointerType *PointerTy) { | |
| QualType PointeeTy = PointerTy->getPointeeType(); | |
| const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy); | |
| if (!BuiltinTy) | |
| return false; | |
| // Check the qualifiers. | |
| Qualifiers Quals = PointeeTy.getQualifiers(); | |
| Quals.removeConst(); | |
| if (!Quals.empty()) | |
| return false; | |
| return typeInfoIsInStandardLibrary(BuiltinTy); | |
| } | |
| bool isStandardLibraryRTTIDescriptor(QualType Ty) { | |
| // Type info for builtin types is defined in the standard library. | |
| if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty)) | |
| return typeInfoIsInStandardLibrary(BuiltinTy); | |
| // Type info for some pointer types to builtin types is defined in the | |
| // standard library. | |
| if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty)) | |
| return typeInfoIsInStandardLibrary(PointerTy); | |
| return false; | |
| } | |
| } // namespace clang::CodeGenUtils |