[clang] [llvm] [WIP] Clang ABI Types (PR #133080)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 27 04:43:53 PDT 2025
https://github.com/easyonaadit updated https://github.com/llvm/llvm-project/pull/133080
>From 16f156dbd83fe0b272f9d485584b1fb9d9a04015 Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Fri, 21 Mar 2025 11:37:31 +0530
Subject: [PATCH 1/4] temp commit have annotated the code with some parts of
understanding.
---
LLVMABI/CGFunctionInfo.h | 841 +++++++++++++++++++
clang/include/clang/CodeGen/CGFunctionInfo.h | 2 +-
clang/lib/CodeGen/ABIInfoImpl.cpp | 2 +-
clang/lib/CodeGen/CGCall.cpp | 18 +-
clang/lib/CodeGen/CodeGenAction.cpp | 2 +-
clang/lib/CodeGen/CodeGenModule.cpp | 6 +-
clang/lib/CodeGen/ModuleBuilder.cpp | 2 +-
clang/lib/CodeGen/Targets/AMDGPU.cpp | 2 +-
clang/lib/Parse/ParseAST.cpp | 10 +-
clang/lib/Parse/Parser.cpp | 2 +-
llvm/include/llvm/ADT/FoldingSet.h | 2 +-
11 files changed, 865 insertions(+), 24 deletions(-)
create mode 100644 LLVMABI/CGFunctionInfo.h
diff --git a/LLVMABI/CGFunctionInfo.h b/LLVMABI/CGFunctionInfo.h
new file mode 100644
index 0000000000000..91276e743a8c6
--- /dev/null
+++ b/LLVMABI/CGFunctionInfo.h
@@ -0,0 +1,841 @@
+//==-- CGFunctionInfo.h - Representation of function argument/return 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines CGFunctionInfo and associated types used in representing the
+// LLVM source types and ABI-coerced types for function arguments and
+// return values.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+
+#include "clang/AST/CanonicalType.h"
+#include "clang/AST/CharUnits.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Type.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/TrailingObjects.h"
+#include <cassert>
+
+namespace clang {
+namespace CodeGen {
+
+/// ABIArgInfo - Helper class to encapsulate information about how a
+/// specific C type should be passed to or returned from a function.
+class ABIArgInfo {
+public:
+ enum Kind : uint8_t {
+ /// Direct - Pass the argument directly using the normal converted LLVM
+ /// type, or by coercing to another specified type stored in
+ /// 'CoerceToType'). If an offset is specified (in UIntData), then the
+ /// argument passed is offset by some number of bytes in the memory
+ /// representation. A dummy argument is emitted before the real argument
+ /// if the specified type stored in "PaddingType" is not zero.
+ Direct,
+
+ /// Extend - Valid only for integer argument types. Same as 'direct'
+ /// but also emit a zero/sign extension attribute.
+ Extend,
+
+ /// Indirect - Pass the argument indirectly via a hidden pointer with the
+ /// specified alignment (0 indicates default alignment) and address space.
+ Indirect,
+
+ /// IndirectAliased - Similar to Indirect, but the pointer may be to an
+ /// object that is otherwise referenced. The object is known to not be
+ /// modified through any other references for the duration of the call, and
+ /// the callee must not itself modify the object. Because C allows
+ /// parameter variables to be modified and guarantees that they have unique
+ /// addresses, the callee must defensively copy the object into a local
+ /// variable if it might be modified or its address might be compared.
+ /// Since those are uncommon, in principle this convention allows programs
+ /// to avoid copies in more situations. However, it may introduce *extra*
+ /// copies if the callee fails to prove that a copy is unnecessary and the
+ /// caller naturally produces an unaliased object for the argument.
+ IndirectAliased,
+
+ /// Ignore - Ignore the argument (treat as void). Useful for void and
+ /// empty structs.
+ Ignore,
+
+ /// Expand - Only valid for aggregate argument types. The structure should
+ /// be expanded into consecutive arguments for its constituent fields.
+ /// Currently expand is only allowed on structures whose fields
+ /// are all scalar types or are themselves expandable types.
+ Expand,
+
+ /// CoerceAndExpand - Only valid for aggregate argument types. The
+ /// structure should be expanded into consecutive arguments corresponding
+ /// to the non-array elements of the type stored in CoerceToType.
+ /// Array elements in the type are assumed to be padding and skipped.
+ CoerceAndExpand,
+
+ /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
+ /// This is similar to indirect with byval, except it only applies to
+ /// arguments stored in memory and forbids any implicit copies. When
+ /// applied to a return type, it means the value is returned indirectly via
+ /// an implicit sret parameter stored in the argument struct.
+ InAlloca,
+ KindFirst = Direct,
+ KindLast = InAlloca
+ };
+
+private:
+ llvm::Type *TypeData; // canHaveCoerceToType()
+ union {
+ llvm::Type *PaddingType; // canHavePaddingType()
+ llvm::Type *UnpaddedCoerceAndExpandType; // isCoerceAndExpand()
+ };
+ struct DirectAttrInfo {
+ unsigned Offset;
+ unsigned Align;
+ };
+ struct IndirectAttrInfo {
+ unsigned Align;
+ unsigned AddrSpace;
+ };
+ union {
+ DirectAttrInfo DirectAttr; // isDirect() || isExtend()
+ IndirectAttrInfo IndirectAttr; // isIndirect()
+ unsigned AllocaFieldIndex; // isInAlloca()
+ };
+ Kind TheKind;
+ bool PaddingInReg : 1;
+ bool InAllocaSRet : 1; // isInAlloca()
+ bool InAllocaIndirect : 1;// isInAlloca()
+ bool IndirectByVal : 1; // isIndirect()
+ bool IndirectRealign : 1; // isIndirect()
+ bool SRetAfterThis : 1; // isIndirect()
+ bool InReg : 1; // isDirect() || isExtend() || isIndirect()
+ bool CanBeFlattened: 1; // isDirect()
+ bool SignExt : 1; // isExtend()
+ bool ZeroExt : 1; // isExtend()
+
+ bool canHavePaddingType() const {
+ return isDirect() || isExtend() || isIndirect() || isIndirectAliased() ||
+ isExpand();
+ }
+ void setPaddingType(llvm::Type *T) {
+ assert(canHavePaddingType());
+ PaddingType = T;
+ }
+
+ void setUnpaddedCoerceToType(llvm::Type *T) {
+ assert(isCoerceAndExpand());
+ UnpaddedCoerceAndExpandType = T;
+ }
+
+public:
+ ABIArgInfo(Kind K = Direct)
+ : TypeData(nullptr), PaddingType(nullptr), DirectAttr{0, 0}, TheKind(K),
+ PaddingInReg(false), InAllocaSRet(false),
+ InAllocaIndirect(false), IndirectByVal(false), IndirectRealign(false),
+ SRetAfterThis(false), InReg(false), CanBeFlattened(false),
+ SignExt(false), ZeroExt(false) {}
+
+ static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
+ llvm::Type *Padding = nullptr,
+ bool CanBeFlattened = true, unsigned Align = 0) {
+ auto AI = ABIArgInfo(Direct);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(Padding);
+ AI.setDirectOffset(Offset);
+ AI.setDirectAlign(Align);
+ AI.setCanBeFlattened(CanBeFlattened);
+ return AI;
+ }
+ static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
+ auto AI = getDirect(T);
+ AI.setInReg(true);
+ return AI;
+ }
+
+ static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ AI.setSignExt(true);
+ return AI;
+ }
+
+ static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ AI.setZeroExt(true);
+ return AI;
+ }
+
+ // ABIArgInfo will record the argument as being extended based on the sign
+ // of its type. Produces a sign or zero extension.
+ static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ if (Ty->hasSignedIntegerRepresentation())
+ return getSignExtend(Ty, T);
+ return getZeroExtend(Ty, T);
+ }
+
+ // Struct in register marked explicitly as not needing extension.
+ static ABIArgInfo getNoExtend(llvm::IntegerType *T) {
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ return AI;
+ }
+
+ static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) {
+ auto AI = getExtend(Ty, T);
+ AI.setInReg(true);
+ return AI;
+ }
+ static ABIArgInfo getIgnore() {
+ return ABIArgInfo(Ignore);
+ }
+ static ABIArgInfo getIndirect(CharUnits Alignment, unsigned AddrSpace,
+ bool ByVal = true, bool Realign = false,
+ llvm::Type *Padding = nullptr) {
+ auto AI = ABIArgInfo(Indirect);
+ AI.setIndirectAlign(Alignment);
+ AI.setIndirectByVal(ByVal);
+ AI.setIndirectRealign(Realign);
+ AI.setSRetAfterThis(false);
+ AI.setPaddingType(Padding);
+ AI.setIndirectAddrSpace(AddrSpace);
+ return AI;
+ }
+
+ /// Pass this in memory using the IR byref attribute.
+ static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace,
+ bool Realign = false,
+ llvm::Type *Padding = nullptr) {
+ auto AI = ABIArgInfo(IndirectAliased);
+ AI.setIndirectAlign(Alignment);
+ AI.setIndirectRealign(Realign);
+ AI.setPaddingType(Padding);
+ AI.setIndirectAddrSpace(AddrSpace);
+ return AI;
+ }
+
+ static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal = true,
+ bool Realign = false) {
+ auto AI = getIndirect(Alignment, 0, ByVal, Realign);
+ AI.setInReg(true);
+ return AI;
+ }
+ static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect = false) {
+ auto AI = ABIArgInfo(InAlloca);
+ AI.setInAllocaFieldIndex(FieldIndex);
+ AI.setInAllocaIndirect(Indirect);
+ return AI;
+ }
+ static ABIArgInfo getExpand() {
+ auto AI = ABIArgInfo(Expand);
+ AI.setPaddingType(nullptr);
+ return AI;
+ }
+ static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
+ llvm::Type *Padding) {
+ auto AI = getExpand();
+ AI.setPaddingInReg(PaddingInReg);
+ AI.setPaddingType(Padding);
+ return AI;
+ }
+
+ /// \param unpaddedCoerceToType The coerce-to type with padding elements
+ /// removed, canonicalized to a single element if it would otherwise
+ /// have exactly one element.
+ static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType,
+ llvm::Type *unpaddedCoerceToType) {
+#ifndef NDEBUG
+ // Check that unpaddedCoerceToType has roughly the right shape.
+
+ // Assert that we only have a struct type if there are multiple elements.
+ auto unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoerceToType);
+ assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1);
+
+ // Assert that all the non-padding elements have a corresponding element
+ // in the unpadded type.
+ unsigned unpaddedIndex = 0;
+ for (auto eltType : coerceToType->elements()) {
+ if (isPaddingForCoerceAndExpand(eltType))
+ continue;
+ unpaddedIndex++;
+ }
+
+ // Assert that there aren't extra elements in the unpadded type.
+ if (unpaddedStruct) {
+ assert(unpaddedStruct->getNumElements() == unpaddedIndex);
+ } else {
+ assert(unpaddedIndex == 1);
+ }
+#endif
+
+ auto AI = ABIArgInfo(CoerceAndExpand);
+ AI.setCoerceToType(coerceToType);
+ AI.setUnpaddedCoerceToType(unpaddedCoerceToType);
+ return AI;
+ }
+
+ static bool isPaddingForCoerceAndExpand(llvm::Type *eltType) {
+ return eltType->isArrayTy() &&
+ eltType->getArrayElementType()->isIntegerTy(8);
+ }
+
+ Kind getKind() const { return TheKind; }
+ bool isDirect() const { return TheKind == Direct; }
+ bool isInAlloca() const { return TheKind == InAlloca; }
+ bool isExtend() const { return TheKind == Extend; }
+ bool isIgnore() const { return TheKind == Ignore; }
+ bool isIndirect() const { return TheKind == Indirect; }
+ bool isIndirectAliased() const { return TheKind == IndirectAliased; }
+ bool isExpand() const { return TheKind == Expand; }
+ bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
+
+ bool canHaveCoerceToType() const {
+ return isDirect() || isExtend() || isCoerceAndExpand();
+ }
+
+ // Direct/Extend accessors
+ unsigned getDirectOffset() const {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ return DirectAttr.Offset;
+ }
+ void setDirectOffset(unsigned Offset) {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ DirectAttr.Offset = Offset;
+ }
+
+ unsigned getDirectAlign() const {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ return DirectAttr.Align;
+ }
+ void setDirectAlign(unsigned Align) {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ DirectAttr.Align = Align;
+ }
+
+ bool isSignExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return SignExt;
+ }
+ void setSignExt(bool SExt) {
+ assert(isExtend() && "Invalid kind!");
+ SignExt = SExt;
+ }
+
+ bool isZeroExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return ZeroExt;
+ }
+ void setZeroExt(bool ZExt) {
+ assert(isExtend() && "Invalid kind!");
+ ZeroExt = ZExt;
+ }
+
+ bool isNoExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return !SignExt && !ZeroExt;
+ }
+
+ llvm::Type *getPaddingType() const {
+ return (canHavePaddingType() ? PaddingType : nullptr);
+ }
+
+ bool getPaddingInReg() const {
+ return PaddingInReg;
+ }
+ void setPaddingInReg(bool PIR) {
+ PaddingInReg = PIR;
+ }
+
+ llvm::Type *getCoerceToType() const {
+ assert(canHaveCoerceToType() && "Invalid kind!");
+ return TypeData;
+ }
+
+ void setCoerceToType(llvm::Type *T) {
+ assert(canHaveCoerceToType() && "Invalid kind!");
+ TypeData = T;
+ }
+
+ llvm::StructType *getCoerceAndExpandType() const {
+ assert(isCoerceAndExpand());
+ return cast<llvm::StructType>(TypeData);
+ }
+
+ llvm::Type *getUnpaddedCoerceAndExpandType() const {
+ assert(isCoerceAndExpand());
+ return UnpaddedCoerceAndExpandType;
+ }
+
+ ArrayRef<llvm::Type *>getCoerceAndExpandTypeSequence() const {
+ assert(isCoerceAndExpand());
+ if (auto structTy =
+ dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) {
+ return structTy->elements();
+ } else {
+ return llvm::ArrayRef(&UnpaddedCoerceAndExpandType, 1);
+ }
+ }
+
+ bool getInReg() const {
+ assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+ return InReg;
+ }
+
+ void setInReg(bool IR) {
+ assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+ InReg = IR;
+ }
+
+ // Indirect accessors
+ CharUnits getIndirectAlign() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return CharUnits::fromQuantity(IndirectAttr.Align);
+ }
+ void setIndirectAlign(CharUnits IA) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectAttr.Align = IA.getQuantity();
+ }
+
+ bool getIndirectByVal() const {
+ assert(isIndirect() && "Invalid kind!");
+ return IndirectByVal;
+ }
+ void setIndirectByVal(bool IBV) {
+ assert(isIndirect() && "Invalid kind!");
+ IndirectByVal = IBV;
+ }
+
+ unsigned getIndirectAddrSpace() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return IndirectAttr.AddrSpace;
+ }
+
+ void setIndirectAddrSpace(unsigned AddrSpace) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectAttr.AddrSpace = AddrSpace;
+ }
+
+ bool getIndirectRealign() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return IndirectRealign;
+ }
+ void setIndirectRealign(bool IR) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectRealign = IR;
+ }
+
+ bool isSRetAfterThis() const {
+ assert(isIndirect() && "Invalid kind!");
+ return SRetAfterThis;
+ }
+ void setSRetAfterThis(bool AfterThis) {
+ assert(isIndirect() && "Invalid kind!");
+ SRetAfterThis = AfterThis;
+ }
+
+ unsigned getInAllocaFieldIndex() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return AllocaFieldIndex;
+ }
+ void setInAllocaFieldIndex(unsigned FieldIndex) {
+ assert(isInAlloca() && "Invalid kind!");
+ AllocaFieldIndex = FieldIndex;
+ }
+
+ unsigned getInAllocaIndirect() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return InAllocaIndirect;
+ }
+ void setInAllocaIndirect(bool Indirect) {
+ assert(isInAlloca() && "Invalid kind!");
+ InAllocaIndirect = Indirect;
+ }
+
+ /// Return true if this field of an inalloca struct should be returned
+ /// to implement a struct return calling convention.
+ bool getInAllocaSRet() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return InAllocaSRet;
+ }
+
+ void setInAllocaSRet(bool SRet) {
+ assert(isInAlloca() && "Invalid kind!");
+ InAllocaSRet = SRet;
+ }
+
+ bool getCanBeFlattened() const {
+ assert(isDirect() && "Invalid kind!");
+ return CanBeFlattened;
+ }
+
+ void setCanBeFlattened(bool Flatten) {
+ assert(isDirect() && "Invalid kind!");
+ CanBeFlattened = Flatten;
+ }
+
+ void dump() const;
+};
+
+/// A class for recording the number of arguments that a function
+/// signature requires.
+class RequiredArgs {
+ /// The number of required arguments, or ~0 if the signature does
+ /// not permit optional arguments.
+ unsigned NumRequired;
+public:
+ enum All_t { All };
+
+ RequiredArgs(All_t _) : NumRequired(~0U) {}
+ explicit RequiredArgs(unsigned n) : NumRequired(n) {
+ assert(n != ~0U);
+ }
+
+ /// Compute the arguments required by the given formal prototype,
+ /// given that there may be some additional, non-formal arguments
+ /// in play.
+ ///
+ /// If FD is not null, this will consider pass_object_size params in FD.
+ static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype,
+ unsigned additional) {
+ if (!prototype->isVariadic()) return All;
+
+ if (prototype->hasExtParameterInfos())
+ additional += llvm::count_if(
+ prototype->getExtParameterInfos(),
+ [](const FunctionProtoType::ExtParameterInfo &ExtInfo) {
+ return ExtInfo.hasPassObjectSize();
+ });
+
+ return RequiredArgs(prototype->getNumParams() + additional);
+ }
+
+ static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype,
+ unsigned additional) {
+ return forPrototypePlus(prototype.getTypePtr(), additional);
+ }
+
+ static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
+ return forPrototypePlus(prototype, 0);
+ }
+
+ static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) {
+ return forPrototypePlus(prototype.getTypePtr(), 0);
+ }
+
+ bool allowsOptionalArgs() const { return NumRequired != ~0U; }
+ unsigned getNumRequiredArgs() const {
+ assert(allowsOptionalArgs());
+ return NumRequired;
+ }
+
+ /// Return true if the argument at a given index is required.
+ bool isRequiredArg(unsigned argIdx) const {
+ return argIdx == ~0U || argIdx < NumRequired;
+ }
+
+ unsigned getOpaqueData() const { return NumRequired; }
+ static RequiredArgs getFromOpaqueData(unsigned value) {
+ if (value == ~0U) return All;
+ return RequiredArgs(value);
+ }
+};
+
+// Implementation detail of CGFunctionInfo, factored out so it can be named
+// in the TrailingObjects base class of CGFunctionInfo.
+struct CGFunctionInfoArgInfo {
+ CanQualType type;
+ ABIArgInfo info;
+};
+
+/// CGFunctionInfo - Class to encapsulate the information about a
+/// function definition.
+class CGFunctionInfo final
+ : public llvm::FoldingSetNode,
+ 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).
+ unsigned CallingConvention : 8;
+
+ /// The LLVM::CallingConv to actually use for this function, which may
+ /// depend on the ABI.
+ unsigned EffectiveCallingConvention : 8;
+
+ /// The clang::CallingConv that this was originally created with.
+ LLVM_PREFERRED_TYPE(CallingConv)
+ unsigned ASTCallingConvention : 6;
+
+ /// Whether this is an instance method.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned InstanceMethod : 1;
+
+ /// Whether this is a chain call.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned ChainCall : 1;
+
+ /// Whether this function is called by forwarding arguments.
+ /// This doesn't support inalloca or varargs.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned DelegateCall : 1;
+
+ /// Whether this function is a CMSE nonsecure call
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned CmseNSCall : 1;
+
+ /// Whether this function is noreturn.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoReturn : 1;
+
+ /// Whether this function is returns-retained.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned ReturnsRetained : 1;
+
+ /// Whether this function saved caller registers.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoCallerSavedRegs : 1;
+
+ /// How many arguments to pass inreg.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasRegParm : 1;
+ unsigned RegParm : 3;
+
+ /// Whether this function has nocf_check attribute.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoCfCheck : 1;
+
+ /// Log 2 of the maximum vector width.
+ unsigned MaxVectorWidth : 4;
+
+ RequiredArgs Required;
+
+ /// 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 : 31;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExtParameterInfos : 1;
+
+ unsigned NumArgs;
+
+ ArgInfo *getArgsBuffer() {
+ return getTrailingObjects<ArgInfo>();
+ }
+ const ArgInfo *getArgsBuffer() const {
+ return getTrailingObjects<ArgInfo>();
+ }
+
+ ExtParameterInfo *getExtParameterInfosBuffer() {
+ return getTrailingObjects<ExtParameterInfo>();
+ }
+ const ExtParameterInfo *getExtParameterInfosBuffer() const{
+ return getTrailingObjects<ExtParameterInfo>();
+ }
+
+ CGFunctionInfo() : Required(RequiredArgs::All) {}
+
+public:
+ static CGFunctionInfo *
+ create(unsigned llvmCC, bool instanceMethod, bool chainCall,
+ bool delegateCall, const FunctionType::ExtInfo &extInfo,
+ ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType,
+ ArrayRef<CanQualType> argTypes, RequiredArgs required);
+ void operator delete(void *p) { ::operator delete(p); }
+
+ // Friending class TrailingObjects is apparently not good enough for MSVC,
+ // so these have to be public.
+ friend class TrailingObjects;
+ size_t numTrailingObjects(OverloadToken<ArgInfo>) const {
+ return NumArgs + 1;
+ }
+ size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
+ return (HasExtParameterInfos ? NumArgs : 0);
+ }
+
+ typedef const ArgInfo *const_arg_iterator;
+ typedef ArgInfo *arg_iterator;
+
+ MutableArrayRef<ArgInfo> arguments() {
+ return MutableArrayRef<ArgInfo>(arg_begin(), NumArgs);
+ }
+ ArrayRef<ArgInfo> arguments() const {
+ return ArrayRef<ArgInfo>(arg_begin(), NumArgs);
+ }
+
+ const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
+ const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
+ arg_iterator arg_begin() { return getArgsBuffer() + 1; }
+ arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
+
+ unsigned arg_size() const { return NumArgs; }
+
+ bool isVariadic() const { return Required.allowsOptionalArgs(); }
+ RequiredArgs getRequiredArgs() const { return Required; }
+ unsigned getNumRequiredArgs() const {
+ return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size();
+ }
+
+ bool isInstanceMethod() const { return InstanceMethod; }
+
+ bool isChainCall() const { return ChainCall; }
+
+ bool isDelegateCall() const { return DelegateCall; }
+
+ bool isCmseNSCall() const { return CmseNSCall; }
+
+ bool isNoReturn() const { return NoReturn; }
+
+ /// In ARC, whether this function retains its return value. This
+ /// is not always reliable for call sites.
+ bool isReturnsRetained() const { return ReturnsRetained; }
+
+ /// Whether this function no longer saves caller registers.
+ bool isNoCallerSavedRegs() const { return NoCallerSavedRegs; }
+
+ /// Whether this function has nocf_check attribute.
+ bool isNoCfCheck() const { return NoCfCheck; }
+
+ /// getASTCallingConvention() - Return the AST-specified calling
+ /// convention.
+ CallingConv getASTCallingConvention() const {
+ return CallingConv(ASTCallingConvention);
+ }
+
+ /// getCallingConvention - Return the user specified calling
+ /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
+ unsigned getCallingConvention() const { return CallingConvention; }
+
+ /// getEffectiveCallingConvention - Return the actual calling convention to
+ /// use, which may depend on the ABI.
+ unsigned getEffectiveCallingConvention() const {
+ return EffectiveCallingConvention;
+ }
+ void setEffectiveCallingConvention(unsigned Value) {
+ EffectiveCallingConvention = Value;
+ }
+
+ bool getHasRegParm() const { return HasRegParm; }
+ unsigned getRegParm() const { return RegParm; }
+
+ FunctionType::ExtInfo getExtInfo() const {
+ return FunctionType::ExtInfo(isNoReturn(), getHasRegParm(), getRegParm(),
+ getASTCallingConvention(), isReturnsRetained(),
+ isNoCallerSavedRegs(), isNoCfCheck(),
+ isCmseNSCall());
+ }
+
+ CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
+
+ ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
+ const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
+
+ ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
+ if (!HasExtParameterInfos) return {};
+ return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs);
+ }
+ ExtParameterInfo getExtParameterInfo(unsigned argIndex) const {
+ assert(argIndex <= NumArgs);
+ if (!HasExtParameterInfos) return ExtParameterInfo();
+ return getExtParameterInfos()[argIndex];
+ }
+
+ /// Return true if this function uses inalloca arguments.
+ bool usesInAlloca() const { return ArgStruct; }
+
+ /// Get the struct type used to represent all the arguments in memory.
+ llvm::StructType *getArgStruct() const { return ArgStruct; }
+ CharUnits getArgStructAlignment() const {
+ return CharUnits::fromQuantity(ArgStructAlign);
+ }
+ void setArgStruct(llvm::StructType *Ty, CharUnits Align) {
+ ArgStruct = Ty;
+ ArgStructAlign = Align.getQuantity();
+ }
+
+ /// Return the maximum vector width in the arguments.
+ unsigned getMaxVectorWidth() const {
+ return MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0;
+ }
+
+ /// Set the maximum vector width in the arguments.
+ void setMaxVectorWidth(unsigned Width) {
+ assert(llvm::isPowerOf2_32(Width) && "Expected power of 2 vector");
+ MaxVectorWidth = llvm::countr_zero(Width) + 1;
+ }
+
+ void Profile(llvm::FoldingSetNodeID &ID) {
+ ID.AddInteger(getASTCallingConvention());
+ ID.AddBoolean(InstanceMethod);
+ ID.AddBoolean(ChainCall);
+ ID.AddBoolean(DelegateCall);
+ ID.AddBoolean(NoReturn);
+ ID.AddBoolean(ReturnsRetained);
+ ID.AddBoolean(NoCallerSavedRegs);
+ ID.AddBoolean(HasRegParm);
+ ID.AddInteger(RegParm);
+ ID.AddBoolean(NoCfCheck);
+ ID.AddBoolean(CmseNSCall);
+ 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);
+ }
+ static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod,
+ bool ChainCall, bool IsDelegateCall,
+ const FunctionType::ExtInfo &info,
+ ArrayRef<ExtParameterInfo> paramInfos,
+ RequiredArgs required, CanQualType resultType,
+ ArrayRef<CanQualType> argTypes) {
+ ID.AddInteger(info.getCC());
+ ID.AddBoolean(InstanceMethod);
+ ID.AddBoolean(ChainCall);
+ ID.AddBoolean(IsDelegateCall);
+ ID.AddBoolean(info.getNoReturn());
+ ID.AddBoolean(info.getProducesResult());
+ ID.AddBoolean(info.getNoCallerSavedRegs());
+ ID.AddBoolean(info.getHasRegParm());
+ ID.AddInteger(info.getRegParm());
+ ID.AddBoolean(info.getNoCfCheck());
+ ID.AddBoolean(info.getCmseNSCall());
+ 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) {
+ i->Profile(ID);
+ }
+ }
+};
+
+} // end namespace CodeGen
+} // end namespace clang
+
+#endif
diff --git a/clang/include/clang/CodeGen/CGFunctionInfo.h b/clang/include/clang/CodeGen/CGFunctionInfo.h
index 040ee025afaa8..91276e743a8c6 100644
--- a/clang/include/clang/CodeGen/CGFunctionInfo.h
+++ b/clang/include/clang/CodeGen/CGFunctionInfo.h
@@ -721,7 +721,7 @@ class CGFunctionInfo final
}
/// getCallingConvention - Return the user specified calling
- /// convention, which has been translated into an LLVM CC.
+ /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
unsigned getCallingConvention() const { return CallingConvention; }
/// getEffectiveCallingConvention - Return the actual calling convention to
diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp
index 0a612d3461dc2..dcccebb8daad7 100644
--- a/clang/lib/CodeGen/ABIInfoImpl.cpp
+++ b/clang/lib/CodeGen/ABIInfoImpl.cpp
@@ -62,7 +62,7 @@ ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
: getContext().LongLongTy))
return getNaturalAlignIndirect(RetTy,
getDataLayout().getAllocaAddrSpace());
-
+// what is a promotable integer type?
return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
: ABIArgInfo::getDirect());
}
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 7aa77e55dbfcc..0f0b7788fc450 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -46,7 +46,7 @@ using namespace clang;
using namespace CodeGen;
/***/
-
+// clang and llvm have different calling conventions? what is it used for? what does it do?
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
switch (CC) {
default: return llvm::CallingConv::C;
@@ -217,7 +217,7 @@ arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
}
/// Arrange the argument and result information for a value of the
-/// given freestanding function type.
+/// given freestanding function type. // what does this mean??
const CGFunctionInfo &
CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
SmallVector<CanQualType, 16> argTypes;
@@ -800,7 +800,7 @@ 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.
+/// above functions ultimately defer to. // this is important, what is this? what does it mean?
const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
CanQualType resultType, FnInfoOpts opts, ArrayRef<CanQualType> argTypes,
FunctionType::ExtInfo info,
@@ -830,13 +830,13 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
// Construct the function info. We co-allocate the ArgInfos.
FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
info, paramInfos, resultType, argTypes, required);
- FunctionInfos.InsertNode(FI, insertPos);
+ FunctionInfos.InsertNode(FI, insertPos); //what is this inserting? is it inserting a function call node in the IR module?
bool inserted = FunctionsBeingProcessed.insert(FI).second;
(void)inserted;
assert(inserted && "Recursively being processed?");
- // Compute ABI information.
+ // Compute ABI information. //why do we need the ABI info at this point? is it that first we add the positino of the funciton call in the IR module? and then before putting any of the parameters or any of the inputs or anything, we need to use the abi info.
if (CC == llvm::CallingConv::SPIR_KERNEL) {
// Force target independent argument handling for the host visible
// kernel functions.
@@ -844,7 +844,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
} else if (info.getCC() == CC_Swift || info.getCC() == CC_SwiftAsync) {
swiftcall::computeABIInfo(CGM, *FI);
} else {
- CGM.getABIInfo().computeInfo(*FI);
+ CGM.getABIInfo().computeInfo(*FI); //this is going into compute info. but what is it doing there? is it just setting up the information needed for lowering, or is it actually doing the lowering?
}
// Loop over all of the computed argument and return value info. If any of
@@ -863,7 +863,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
return *FI;
}
-
+// this is important. this object seems to hold both information about the clang calling convention as well as the llvm calling convention. maybe its a mapping between the two. also it has an AST field.
CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, bool instanceMethod,
bool chainCall, bool delegateCall,
const FunctionType::ExtInfo &info,
@@ -5187,7 +5187,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
ArgMemory = RawAddress(AI, ArgStruct, Align);
}
- ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
+ ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); // --> this seems imp
SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
// If the call returns a temporary with struct return, create a temporary
@@ -5251,7 +5251,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
"Mismatch between function signature & arguments.");
unsigned ArgNo = 0;
CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
- for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
+ for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); // -> for all the function parameters, handle it based on abi info.
I != E; ++I, ++info_it, ++ArgNo) {
const ABIArgInfo &ArgInfo = info_it->info;
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 4321efd49af36..b3a897e20ddaa 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -162,7 +162,7 @@ bool BackendConsumer::HandleTopLevelDecl(DeclGroupRef D) {
Context->getSourceManager(),
"LLVM IR generation of declaration");
- // Recurse.
+ // Recurse. //if we are starting ir generation, then we stop the frontend timer and start the ir gen timer.
if (TimerIsEnabled && !LLVMIRGenerationRefCount++)
CI.getFrontendTimer().yieldTo(LLVMIRGeneration);
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index ecce52ef9eaf5..34baf6734bbc8 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -103,7 +103,7 @@ static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
llvm_unreachable("invalid C++ ABI kind");
}
-
+// this is importatnt!! this is the start of the abi info part.
static std::unique_ptr<TargetCodeGenInfo>
createTargetCodeGenInfo(CodeGenModule &CGM) {
const TargetInfo &Target = CGM.getTarget();
@@ -3889,7 +3889,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) {
}
}
- // Ignore declarations, they will be emitted on their first use.
+ // Ignore declarations, they will be emitted on their first use. //If we have just declared a function, dont parse it now, that will be handled when it is first used.
if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
// Update deferred annotations with the latest declaration if the function
// function was already used or defined.
@@ -6105,7 +6105,7 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
llvm::GlobalValue *GV) {
const auto *D = cast<FunctionDecl>(GD.getDecl());
-
+// THIS IS THE PLACE!!
// Compute the function info and LLVM type.
const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 09a7d79ae4afb..0b4d0ee580435 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -185,7 +185,7 @@ namespace {
HandlingTopLevelDeclRAII HandlingDecl(*this);
- // Make sure to emit all elements of a Decl.
+ // Make sure to emit all elements of a Decl. //What is a Decl really, what components does it have? what are we looping over? are we looping over its children?
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
Builder->EmitTopLevelDecl(*I);
diff --git a/clang/lib/CodeGen/Targets/AMDGPU.cpp b/clang/lib/CodeGen/Targets/AMDGPU.cpp
index e3c8243cbb0b5..a4c5adc6ef426 100644
--- a/clang/lib/CodeGen/Targets/AMDGPU.cpp
+++ b/clang/lib/CodeGen/Targets/AMDGPU.cpp
@@ -112,7 +112,7 @@ unsigned AMDGPUABIInfo::numRegsForType(QualType Ty) const {
void AMDGPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
llvm::CallingConv::ID CC = FI.getCallingConvention();
-
+// what is this, this is important.
if (!getCXXABI().classifyReturnType(FI))
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
diff --git a/clang/lib/Parse/ParseAST.cpp b/clang/lib/Parse/ParseAST.cpp
index 761f84070681e..0200fa4f9ca04 100644
--- a/clang/lib/Parse/ParseAST.cpp
+++ b/clang/lib/Parse/ParseAST.cpp
@@ -111,7 +111,7 @@ void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
}
-
+// is this specific to clang fronend? what about if some other frontend wants to do this? where do the frontends diverge and what parts are common?
void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
// Collect global stats on Decls/Stmts (until we have a module streamer).
if (PrintStats) {
@@ -131,7 +131,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
std::unique_ptr<Parser> ParseOP(
new Parser(S.getPreprocessor(), S, SkipFunctionBodies));
- Parser &P = *ParseOP.get();
+ Parser &P = *ParseOP.get(); // we have the AST and now we are getting a parser which will parse that ast.
llvm::CrashRecoveryContextCleanupRegistrar<const void, ResetStackCleanup>
CleanupPrettyStack(llvm::SavePrettyStackState());
@@ -161,12 +161,12 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
}
return M;
});
- P.Initialize();
+ P.Initialize(); // this sets up the parser and gets the first token i guess?
Parser::DeclGroupPtrTy ADecl;
Sema::ModuleImportState ImportState;
EnterExpressionEvaluationContext PotentiallyEvaluated(
S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
-
+// I think translational unit decls are the top level decls. everything else is counted as a "sub-decl"/ other type of decl. so this loop works for each translational unit. i guess.
for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {
// If we got a null return and something *was* parsed, ignore it. This
@@ -191,7 +191,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
finalize(S.TemplateInstCallbacks, S);
std::swap(OldCollectStats, S.CollectStats);
- if (PrintStats) {
+ if (true) {
llvm::errs() << "\nSTATISTICS:\n";
if (HaveLexer) P.getActions().PrintStats();
S.getASTContext().PrintStats();
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 6128bc58d69c0..03d6bf5d4f157 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -631,7 +631,7 @@ bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,
bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
Sema::ModuleImportState &ImportState) {
DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
-
+// to parseTopLevelDecl, we get the first token from the lexer. and then based on the kind of that token, we do some special handling if needed, otherwise we just return.
Result = nullptr;
switch (Tok.getKind()) {
case tok::annot_pragma_unused:
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index 3c2eaade57e47..cd28963a5da61 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -509,7 +509,7 @@ template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
/// InsertNode - Insert the specified node into the folding set, knowing that
/// it is not already in the folding set. InsertPos must be obtained from
- /// FindNodeOrInsertPos.
+ /// FindNodeOrInsertPos. //what is the folding set?
void InsertNode(T *N, void *InsertPos) {
FoldingSetBase::InsertNode(N, InsertPos, Derived::getFoldingSetInfo());
}
>From 4cd2a1a61a690ca3d93e7c70fe24a77eff953a2c Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Wed, 26 Mar 2025 18:29:53 +0530
Subject: [PATCH 2/4] Implementation logic for ABI Library
---
clang/include/clang/CodeGen/CGFunctionInfo.h | 2 +-
clang/lib/CodeGen/ABIInfoImpl.cpp | 2 +-
clang/lib/CodeGen/CGCall.cpp | 44 +++++++++++++++-----
clang/lib/CodeGen/CodeGenAction.cpp | 2 +-
clang/lib/CodeGen/CodeGenModule.cpp | 6 +--
clang/lib/CodeGen/ModuleBuilder.cpp | 2 +-
clang/lib/CodeGen/Targets/AMDGPU.cpp | 2 +-
clang/lib/Parse/ParseAST.cpp | 10 ++---
clang/lib/Parse/Parser.cpp | 2 +-
llvm/include/llvm/ADT/FoldingSet.h | 2 +-
10 files changed, 48 insertions(+), 26 deletions(-)
diff --git a/clang/include/clang/CodeGen/CGFunctionInfo.h b/clang/include/clang/CodeGen/CGFunctionInfo.h
index 91276e743a8c6..040ee025afaa8 100644
--- a/clang/include/clang/CodeGen/CGFunctionInfo.h
+++ b/clang/include/clang/CodeGen/CGFunctionInfo.h
@@ -721,7 +721,7 @@ class CGFunctionInfo final
}
/// getCallingConvention - Return the user specified calling
- /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
+ /// convention, which has been translated into an LLVM CC.
unsigned getCallingConvention() const { return CallingConvention; }
/// getEffectiveCallingConvention - Return the actual calling convention to
diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp
index dcccebb8daad7..0a612d3461dc2 100644
--- a/clang/lib/CodeGen/ABIInfoImpl.cpp
+++ b/clang/lib/CodeGen/ABIInfoImpl.cpp
@@ -62,7 +62,7 @@ ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
: getContext().LongLongTy))
return getNaturalAlignIndirect(RetTy,
getDataLayout().getAllocaAddrSpace());
-// what is a promotable integer type?
+
return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
: ABIArgInfo::getDirect());
}
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 0f0b7788fc450..c5dae55b8b40e 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -46,7 +46,6 @@ using namespace clang;
using namespace CodeGen;
/***/
-// clang and llvm have different calling conventions? what is it used for? what does it do?
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
switch (CC) {
default: return llvm::CallingConv::C;
@@ -217,7 +216,7 @@ arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
}
/// Arrange the argument and result information for a value of the
-/// given freestanding function type. // what does this mean??
+/// given freestanding function type.
const CGFunctionInfo &
CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
SmallVector<CanQualType, 16> argTypes;
@@ -800,7 +799,7 @@ 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. // this is important, what is this? what does it mean?
+/// above functions ultimately defer to.
const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
CanQualType resultType, FnInfoOpts opts, ArrayRef<CanQualType> argTypes,
FunctionType::ExtInfo info,
@@ -809,6 +808,29 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
assert(llvm::all_of(argTypes,
[](CanQualType T) { return T.isCanonicalAsParam(); }));
+// first convert each of these types into ABI::types. -> info, paramInfos, required, resultType, argTypes
+// then in the library, create abi::functionInfo type, same as how CGFunctionInfo is created.
+// then in the library, lower abi::functionInfo to abi::x_86_abiArgInfo
+// then return that. then the frontend has to lower that to llvm-ir.
+// so clang will have to map that to clang::CGFunctionInfo.
+ ABIType resultTypeABI = getABIType(resultType);
+
+ std::vector<ABIType> abiTypes;
+ abiTypes.reserve(canQualTypes.size());
+
+ for (const llvm::CanQualType &element : argTypes) {
+ abiTypes.push_back(getABIType(element));
+ }
+ llvm::ArrayRef<ABIType> argTypesABI = llvm::ArrayRef<ABIType>(abiTypes);
+
+ ABIFunctionInfo *ABIFI = ABIFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
+ info, paramInfos, resultType, argTypes, required);
+
+ // TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() ;
+ ABIInfo::computeFunctionInfo(CodeGenModule::getTargetCodeGenInfo(), ABIFI);
+
+ CGFunctionInfo *FI = mapABIFunctionInfoToCGFunctionInfo(ABIFI);
+
// Lookup or create unique function info.
llvm::FoldingSetNodeID ID;
bool isInstanceMethod =
@@ -828,15 +850,15 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
// Construct the function info. We co-allocate the ArgInfos.
- FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
- info, paramInfos, resultType, argTypes, required);
- FunctionInfos.InsertNode(FI, insertPos); //what is this inserting? is it inserting a function call node in the IR module?
+ // FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
+ // info, paramInfos, resultType, argTypes, required);
+ FunctionInfos.InsertNode(FI, insertPos);
bool inserted = FunctionsBeingProcessed.insert(FI).second;
(void)inserted;
assert(inserted && "Recursively being processed?");
- // Compute ABI information. //why do we need the ABI info at this point? is it that first we add the positino of the funciton call in the IR module? and then before putting any of the parameters or any of the inputs or anything, we need to use the abi info.
+ // Compute ABI information.
if (CC == llvm::CallingConv::SPIR_KERNEL) {
// Force target independent argument handling for the host visible
// kernel functions.
@@ -844,7 +866,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
} else if (info.getCC() == CC_Swift || info.getCC() == CC_SwiftAsync) {
swiftcall::computeABIInfo(CGM, *FI);
} else {
- CGM.getABIInfo().computeInfo(*FI); //this is going into compute info. but what is it doing there? is it just setting up the information needed for lowering, or is it actually doing the lowering?
+ CGM.getABIInfo().computeInfo(*FI);
}
// Loop over all of the computed argument and return value info. If any of
@@ -863,7 +885,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
return *FI;
}
-// this is important. this object seems to hold both information about the clang calling convention as well as the llvm calling convention. maybe its a mapping between the two. also it has an AST field.
+
CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, bool instanceMethod,
bool chainCall, bool delegateCall,
const FunctionType::ExtInfo &info,
@@ -5187,7 +5209,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
ArgMemory = RawAddress(AI, ArgStruct, Align);
}
- ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); // --> this seems imp
+ ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
// If the call returns a temporary with struct return, create a temporary
@@ -5251,7 +5273,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
"Mismatch between function signature & arguments.");
unsigned ArgNo = 0;
CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
- for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); // -> for all the function parameters, handle it based on abi info.
+ for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
I != E; ++I, ++info_it, ++ArgNo) {
const ABIArgInfo &ArgInfo = info_it->info;
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index b3a897e20ddaa..4321efd49af36 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -162,7 +162,7 @@ bool BackendConsumer::HandleTopLevelDecl(DeclGroupRef D) {
Context->getSourceManager(),
"LLVM IR generation of declaration");
- // Recurse. //if we are starting ir generation, then we stop the frontend timer and start the ir gen timer.
+ // Recurse.
if (TimerIsEnabled && !LLVMIRGenerationRefCount++)
CI.getFrontendTimer().yieldTo(LLVMIRGeneration);
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 34baf6734bbc8..ecce52ef9eaf5 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -103,7 +103,7 @@ static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
llvm_unreachable("invalid C++ ABI kind");
}
-// this is importatnt!! this is the start of the abi info part.
+
static std::unique_ptr<TargetCodeGenInfo>
createTargetCodeGenInfo(CodeGenModule &CGM) {
const TargetInfo &Target = CGM.getTarget();
@@ -3889,7 +3889,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) {
}
}
- // Ignore declarations, they will be emitted on their first use. //If we have just declared a function, dont parse it now, that will be handled when it is first used.
+ // Ignore declarations, they will be emitted on their first use.
if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
// Update deferred annotations with the latest declaration if the function
// function was already used or defined.
@@ -6105,7 +6105,7 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
llvm::GlobalValue *GV) {
const auto *D = cast<FunctionDecl>(GD.getDecl());
-// THIS IS THE PLACE!!
+
// Compute the function info and LLVM type.
const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 0b4d0ee580435..09a7d79ae4afb 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -185,7 +185,7 @@ namespace {
HandlingTopLevelDeclRAII HandlingDecl(*this);
- // Make sure to emit all elements of a Decl. //What is a Decl really, what components does it have? what are we looping over? are we looping over its children?
+ // Make sure to emit all elements of a Decl.
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
Builder->EmitTopLevelDecl(*I);
diff --git a/clang/lib/CodeGen/Targets/AMDGPU.cpp b/clang/lib/CodeGen/Targets/AMDGPU.cpp
index a4c5adc6ef426..e3c8243cbb0b5 100644
--- a/clang/lib/CodeGen/Targets/AMDGPU.cpp
+++ b/clang/lib/CodeGen/Targets/AMDGPU.cpp
@@ -112,7 +112,7 @@ unsigned AMDGPUABIInfo::numRegsForType(QualType Ty) const {
void AMDGPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
llvm::CallingConv::ID CC = FI.getCallingConvention();
-// what is this, this is important.
+
if (!getCXXABI().classifyReturnType(FI))
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
diff --git a/clang/lib/Parse/ParseAST.cpp b/clang/lib/Parse/ParseAST.cpp
index 0200fa4f9ca04..761f84070681e 100644
--- a/clang/lib/Parse/ParseAST.cpp
+++ b/clang/lib/Parse/ParseAST.cpp
@@ -111,7 +111,7 @@ void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
}
-// is this specific to clang fronend? what about if some other frontend wants to do this? where do the frontends diverge and what parts are common?
+
void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
// Collect global stats on Decls/Stmts (until we have a module streamer).
if (PrintStats) {
@@ -131,7 +131,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
std::unique_ptr<Parser> ParseOP(
new Parser(S.getPreprocessor(), S, SkipFunctionBodies));
- Parser &P = *ParseOP.get(); // we have the AST and now we are getting a parser which will parse that ast.
+ Parser &P = *ParseOP.get();
llvm::CrashRecoveryContextCleanupRegistrar<const void, ResetStackCleanup>
CleanupPrettyStack(llvm::SavePrettyStackState());
@@ -161,12 +161,12 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
}
return M;
});
- P.Initialize(); // this sets up the parser and gets the first token i guess?
+ P.Initialize();
Parser::DeclGroupPtrTy ADecl;
Sema::ModuleImportState ImportState;
EnterExpressionEvaluationContext PotentiallyEvaluated(
S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
-// I think translational unit decls are the top level decls. everything else is counted as a "sub-decl"/ other type of decl. so this loop works for each translational unit. i guess.
+
for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {
// If we got a null return and something *was* parsed, ignore it. This
@@ -191,7 +191,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
finalize(S.TemplateInstCallbacks, S);
std::swap(OldCollectStats, S.CollectStats);
- if (true) {
+ if (PrintStats) {
llvm::errs() << "\nSTATISTICS:\n";
if (HaveLexer) P.getActions().PrintStats();
S.getASTContext().PrintStats();
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 03d6bf5d4f157..6128bc58d69c0 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -631,7 +631,7 @@ bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,
bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
Sema::ModuleImportState &ImportState) {
DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
-// to parseTopLevelDecl, we get the first token from the lexer. and then based on the kind of that token, we do some special handling if needed, otherwise we just return.
+
Result = nullptr;
switch (Tok.getKind()) {
case tok::annot_pragma_unused:
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index cd28963a5da61..3c2eaade57e47 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -509,7 +509,7 @@ template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
/// InsertNode - Insert the specified node into the folding set, knowing that
/// it is not already in the folding set. InsertPos must be obtained from
- /// FindNodeOrInsertPos. //what is the folding set?
+ /// FindNodeOrInsertPos.
void InsertNode(T *N, void *InsertPos) {
FoldingSetBase::InsertNode(N, InsertPos, Derived::getFoldingSetInfo());
}
>From 930a979d01b443900fe3e784fbb55710c88edcc6 Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Thu, 27 Mar 2025 14:59:58 +0530
Subject: [PATCH 3/4] Implemented some basic ABI Type system. Made a mapping
from clang qualtypes to the abi types.
---
LLVMABI/CGFunctionInfo.h | 20 +-
LLVMABI/Type.h | 1371 ++++++++++++++++++++++++++++++++++
clang/lib/CodeGen/CGCall.cpp | 95 ++-
3 files changed, 1447 insertions(+), 39 deletions(-)
create mode 100644 LLVMABI/Type.h
diff --git a/LLVMABI/CGFunctionInfo.h b/LLVMABI/CGFunctionInfo.h
index 91276e743a8c6..f6030f8c666c7 100644
--- a/LLVMABI/CGFunctionInfo.h
+++ b/LLVMABI/CGFunctionInfo.h
@@ -15,6 +15,7 @@
#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+#include "LLVMABI/Type.h"
#include "clang/AST/CanonicalType.h"
#include "clang/AST/CharUnits.h"
#include "clang/AST/Decl.h"
@@ -559,18 +560,19 @@ class RequiredArgs {
// Implementation detail of CGFunctionInfo, factored out so it can be named
// in the TrailingObjects base class of CGFunctionInfo.
-struct CGFunctionInfoArgInfo {
- CanQualType type;
+struct ABIFunctionInfoArgInfo {
+ ABIType type;
ABIArgInfo info;
};
/// CGFunctionInfo - Class to encapsulate the information about a
/// function definition.
-class CGFunctionInfo final
- : public llvm::FoldingSetNode,
- private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
- FunctionProtoType::ExtParameterInfo> {
- typedef CGFunctionInfoArgInfo ArgInfo;
+class ABIFunctionInfo final{
+ // : public llvm::FoldingSetNode,
+ // private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
+ // FunctionProtoType::ExtParameterInfo> {
+
+ typedef ABIFunctionInfoArgInfo ArgInfo;
typedef FunctionProtoType::ExtParameterInfo ExtParameterInfo;
/// The LLVM::CallingConv to use for this function (as specified by the
@@ -651,10 +653,10 @@ class CGFunctionInfo final
return getTrailingObjects<ExtParameterInfo>();
}
- CGFunctionInfo() : Required(RequiredArgs::All) {}
+ ABIFunctionInfo() : Required(RequiredArgs::All) {}
public:
- static CGFunctionInfo *
+ static ABIFunctionInfo *
create(unsigned llvmCC, bool instanceMethod, bool chainCall,
bool delegateCall, const FunctionType::ExtInfo &extInfo,
ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType,
diff --git a/LLVMABI/Type.h b/LLVMABI/Type.h
new file mode 100644
index 0000000000000..49b070565a4ef
--- /dev/null
+++ b/LLVMABI/Type.h
@@ -0,0 +1,1371 @@
+#ifndef TYPE_H
+#define TYPE_H
+
+
+namespace ABI{
+class Type {
+ public:
+ enum TypeClass {
+Builtin
+ };
+ explicit Type(TypeClass TC) : Tc(TC) {}
+
+ TypeClass getTypeClass() const { return Tc; }
+ virtual ~Type() = default;
+
+ private:
+ //save the type class
+ TypeClass Tc;
+ }
+
+
+class ABIBuiltinType : public Type {
+ public:
+ enum Kind {
+ Void,
+ Bool,
+ Integer,
+ SignedInteger,
+ UnsignedInteger,
+ Int128,
+ FloatingPoint
+ };
+
+ private:
+ Kind kind;
+
+ public:
+ ABIBuiltinType(Kind K)
+ : Type(Builtin), kind(K){}
+ // ABIType(Kind K = Integer);
+ Kind getKind() const { return kind;}
+
+ bool isInteger() const {
+ return getKind() == Kind::Integer || getKind() == Kind::SignedInteger || getKind() == Kind::UnsignedInteger || getKind() == Kind::Int128;
+ }
+
+ bool isSignedInteger() const {
+ return getKind() == Kind::SignedInteger;
+ }
+
+ bool isUnsignedInteger() const {
+ return getKind() == Kind::UnsignedInteger;
+ }
+
+ bool isFloatingPoint() const {
+ return getKind() == Kind::FloatingPoint;
+ }
+
+}
+
+}
+
+#endif
+
+
+
+
+
+
+
+
+
+
+/// Base class that is common to both the \c ExtQuals and \c Type
+/// classes, which allows \c QualType to access the common fields between the
+/// two.
+class ExtQualsTypeCommonBase {
+ friend class ExtQuals;
+ friend class QualType;
+ friend class Type;
+ friend class ASTReader;
+
+ /// The "base" type of an extended qualifiers type (\c ExtQuals) or
+ /// a self-referential pointer (for \c Type).
+ ///
+ /// This pointer allows an efficient mapping from a QualType to its
+ /// underlying type pointer.
+ const Type *const BaseType;
+
+ /// The canonical type of this type. A QualType.
+ QualType CanonicalType;
+
+ ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
+ : BaseType(baseType), CanonicalType(canon) {}
+};
+
+
+
+/// We can encode up to four bits in the low bits of a
+/// type pointer, but there are many more type qualifiers that we want
+/// to be able to apply to an arbitrary type. Therefore we have this
+/// struct, intended to be heap-allocated and used by QualType to
+/// store qualifiers.
+///
+/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
+/// in three low bits on the QualType pointer; a fourth bit records whether
+/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
+/// Objective-C GC attributes) are much more rare.
+class alignas(TypeAlignment) ExtQuals : public ExtQualsTypeCommonBase,
+ public llvm::FoldingSetNode {
+ // NOTE: changing the fast qualifiers should be straightforward as
+ // long as you don't make 'const' non-fast.
+ // 1. Qualifiers:
+ // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
+ // Fast qualifiers must occupy the low-order bits.
+ // b) Update Qualifiers::FastWidth and FastMask.
+ // 2. QualType:
+ // a) Update is{Volatile,Restrict}Qualified(), defined inline.
+ // b) Update remove{Volatile,Restrict}, defined near the end of
+ // this header.
+ // 3. ASTContext:
+ // a) Update get{Volatile,Restrict}Type.
+
+ /// The immutable set of qualifiers applied by this node. Always contains
+ /// extended qualifiers.
+ Qualifiers Quals;
+
+ ExtQuals *this_() { return this; }
+
+public:
+ ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
+ : ExtQualsTypeCommonBase(baseType,
+ canon.isNull() ? QualType(this_(), 0) : canon),
+ Quals(quals) {
+ assert(Quals.hasNonFastQualifiers()
+ && "ExtQuals created with no fast qualifiers");
+ assert(!Quals.hasFastQualifiers()
+ && "ExtQuals created with fast qualifiers");
+ }
+
+ Qualifiers getQualifiers() const { return Quals; }
+
+ bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
+ Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
+
+ bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
+ Qualifiers::ObjCLifetime getObjCLifetime() const {
+ return Quals.getObjCLifetime();
+ }
+
+ bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
+ LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
+
+ const Type *getBaseType() const { return BaseType; }
+
+public:
+ void Profile(llvm::FoldingSetNodeID &ID) const {
+ Profile(ID, getBaseType(), Quals);
+ }
+
+ static void Profile(llvm::FoldingSetNodeID &ID,
+ const Type *BaseType,
+ Qualifiers Quals) {
+ assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!");
+ ID.AddPointer(BaseType);
+ Quals.Profile(ID);
+ }
+};
+
+
+
+/// The base class of the type hierarchy.
+///
+/// A central concept with types is that each type always has a canonical
+/// type. A canonical type is the type with any typedef names stripped out
+/// of it or the types it references. For example, consider:
+///
+/// typedef int foo;
+/// typedef foo* bar;
+/// 'int *' 'foo *' 'bar'
+///
+/// There will be a Type object created for 'int'. Since int is canonical, its
+/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
+/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
+/// there is a PointerType that represents 'int*', which, like 'int', is
+/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
+/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
+/// is also 'int*'.
+///
+/// Non-canonical types are useful for emitting diagnostics, without losing
+/// information about typedefs being used. Canonical types are useful for type
+/// comparisons (they allow by-pointer equality tests) and useful for reasoning
+/// about whether something has a particular form (e.g. is a function type),
+/// because they implicitly, recursively, strip all typedefs out of a type.
+///
+/// Types, once created, are immutable.
+///
+class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
+public:
+ enum TypeClass {
+#define TYPE(Class, Base) Class,
+#define LAST_TYPE(Class) TypeLast = Class
+#define ABSTRACT_TYPE(Class, Base)
+#include "clang/AST/TypeNodes.inc"
+ };
+
+private:
+ /// Bitfields required by the Type class.
+ class TypeBitfields {
+ friend class Type;
+ template <class T> friend class TypePropertyCache;
+
+ /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
+ LLVM_PREFERRED_TYPE(TypeClass)
+ unsigned TC : 8;
+
+ /// Store information on the type dependency.
+ LLVM_PREFERRED_TYPE(TypeDependence)
+ unsigned Dependence : llvm::BitWidth<TypeDependence>;
+
+ /// True if the cache (i.e. the bitfields here starting with
+ /// 'Cache') is valid.
+ LLVM_PREFERRED_TYPE(bool)
+ mutable unsigned CacheValid : 1;
+
+ /// Linkage of this type.
+ LLVM_PREFERRED_TYPE(Linkage)
+ mutable unsigned CachedLinkage : 3;
+
+ /// Whether this type involves and local or unnamed types.
+ LLVM_PREFERRED_TYPE(bool)
+ mutable unsigned CachedLocalOrUnnamed : 1;
+
+ /// Whether this type comes from an AST file.
+ LLVM_PREFERRED_TYPE(bool)
+ mutable unsigned FromAST : 1;
+
+ bool isCacheValid() const {
+ return CacheValid;
+ }
+
+ Linkage getLinkage() const {
+ assert(isCacheValid() && "getting linkage from invalid cache");
+ return static_cast<Linkage>(CachedLinkage);
+ }
+
+ bool hasLocalOrUnnamedType() const {
+ assert(isCacheValid() && "getting linkage from invalid cache");
+ return CachedLocalOrUnnamed;
+ }
+ };
+ enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
+
+protected:
+ // These classes allow subclasses to somewhat cleanly pack bitfields
+ // into Type.
+
+ class ArrayTypeBitfields {
+ friend class ArrayType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// CVR qualifiers from declarations like
+ /// 'int X[static restrict 4]'. For function parameters only.
+ LLVM_PREFERRED_TYPE(Qualifiers)
+ unsigned IndexTypeQuals : 3;
+
+ /// Storage class qualifiers from declarations like
+ /// 'int X[static restrict 4]'. For function parameters only.
+ LLVM_PREFERRED_TYPE(ArraySizeModifier)
+ unsigned SizeModifier : 3;
+ };
+ enum { NumArrayTypeBits = NumTypeBits + 6 };
+
+ class ConstantArrayTypeBitfields {
+ friend class ConstantArrayType;
+
+ LLVM_PREFERRED_TYPE(ArrayTypeBitfields)
+ unsigned : NumArrayTypeBits;
+
+ /// Whether we have a stored size expression.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExternalSize : 1;
+
+ LLVM_PREFERRED_TYPE(unsigned)
+ unsigned SizeWidth : 5;
+ };
+
+ class BuiltinTypeBitfields {
+ friend class BuiltinType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The kind (BuiltinType::Kind) of builtin type this is.
+ static constexpr unsigned NumOfBuiltinTypeBits = 9;
+ unsigned Kind : NumOfBuiltinTypeBits;
+ };
+
+public:
+ static constexpr int FunctionTypeNumParamsWidth = 16;
+ static constexpr int FunctionTypeNumParamsLimit = (1 << 16) - 1;
+
+protected:
+ /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
+ /// Only common bits are stored here. Additional uncommon bits are stored
+ /// in a trailing object after FunctionProtoType.
+ class FunctionTypeBitfields {
+ friend class FunctionProtoType;
+ friend class FunctionType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The ref-qualifier associated with a \c FunctionProtoType.
+ ///
+ /// This is a value of type \c RefQualifierKind.
+ LLVM_PREFERRED_TYPE(RefQualifierKind)
+ unsigned RefQualifier : 2;
+
+ /// Used only by FunctionProtoType, put here to pack with the
+ /// other bitfields.
+ /// The qualifiers are part of FunctionProtoType because...
+ ///
+ /// C++ 8.3.5p4: The return type, the parameter type list and the
+ /// cv-qualifier-seq, [...], are part of the function type.
+ LLVM_PREFERRED_TYPE(Qualifiers)
+ unsigned FastTypeQuals : Qualifiers::FastWidth;
+ /// Whether this function has extended Qualifiers.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExtQuals : 1;
+
+ /// The type of exception specification this function has.
+ LLVM_PREFERRED_TYPE(ExceptionSpecificationType)
+ unsigned ExceptionSpecType : 4;
+
+ /// Whether this function has extended parameter information.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExtParameterInfos : 1;
+
+ /// Whether this function has extra bitfields for the prototype.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExtraBitfields : 1;
+
+ /// Whether the function is variadic.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned Variadic : 1;
+
+ /// Whether this function has a trailing return type.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasTrailingReturn : 1;
+
+ /// Extra information which affects how the function is called, like
+ /// regparm and the calling convention.
+ LLVM_PREFERRED_TYPE(CallingConv)
+ unsigned ExtInfo : 14;
+
+ /// The number of parameters this function has, not counting '...'.
+ /// According to [implimits] 8 bits should be enough here but this is
+ /// somewhat easy to exceed with metaprogramming and so we would like to
+ /// keep NumParams as wide as reasonably possible.
+ unsigned NumParams : FunctionTypeNumParamsWidth;
+ };
+
+ class ObjCObjectTypeBitfields {
+ friend class ObjCObjectType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The number of type arguments stored directly on this object type.
+ unsigned NumTypeArgs : 7;
+
+ /// The number of protocols stored directly on this object type.
+ unsigned NumProtocols : 6;
+
+ /// Whether this is a "kindof" type.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned IsKindOf : 1;
+ };
+
+ class ReferenceTypeBitfields {
+ friend class ReferenceType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// True if the type was originally spelled with an lvalue sigil.
+ /// This is never true of rvalue references but can also be false
+ /// on lvalue references because of C++0x [dcl.typedef]p9,
+ /// as follows:
+ ///
+ /// typedef int &ref; // lvalue, spelled lvalue
+ /// typedef int &&rvref; // rvalue
+ /// ref &a; // lvalue, inner ref, spelled lvalue
+ /// ref &&a; // lvalue, inner ref
+ /// rvref &a; // lvalue, inner ref, spelled lvalue
+ /// rvref &&a; // rvalue, inner ref
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned SpelledAsLValue : 1;
+
+ /// True if the inner type is a reference type. This only happens
+ /// in non-canonical forms.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned InnerRef : 1;
+ };
+
+ class TypeWithKeywordBitfields {
+ friend class TypeWithKeyword;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// An ElaboratedTypeKeyword. 8 bits for efficient access.
+ LLVM_PREFERRED_TYPE(ElaboratedTypeKeyword)
+ unsigned Keyword : 8;
+ };
+
+ enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
+
+ class ElaboratedTypeBitfields {
+ friend class ElaboratedType;
+
+ LLVM_PREFERRED_TYPE(TypeWithKeywordBitfields)
+ unsigned : NumTypeWithKeywordBits;
+
+ /// Whether the ElaboratedType has a trailing OwnedTagDecl.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasOwnedTagDecl : 1;
+ };
+
+ class VectorTypeBitfields {
+ friend class VectorType;
+ friend class DependentVectorType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The kind of vector, either a generic vector type or some
+ /// target-specific vector type such as for AltiVec or Neon.
+ LLVM_PREFERRED_TYPE(VectorKind)
+ unsigned VecKind : 4;
+ /// The number of elements in the vector.
+ uint32_t NumElements;
+ };
+
+ class AttributedTypeBitfields {
+ friend class AttributedType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ LLVM_PREFERRED_TYPE(attr::Kind)
+ unsigned AttrKind : 32 - NumTypeBits;
+ };
+
+ class AutoTypeBitfields {
+ friend class AutoType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
+ /// or '__auto_type'? AutoTypeKeyword value.
+ LLVM_PREFERRED_TYPE(AutoTypeKeyword)
+ unsigned Keyword : 2;
+
+ /// The number of template arguments in the type-constraints, which is
+ /// expected to be able to hold at least 1024 according to [implimits].
+ /// However as this limit is somewhat easy to hit with template
+ /// metaprogramming we'd prefer to keep it as large as possible.
+ /// At the moment it has been left as a non-bitfield since this type
+ /// safely fits in 64 bits as an unsigned, so there is no reason to
+ /// introduce the performance impact of a bitfield.
+ unsigned NumArgs;
+ };
+
+ class TypeOfBitfields {
+ friend class TypeOfType;
+ friend class TypeOfExprType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+ LLVM_PREFERRED_TYPE(TypeOfKind)
+ unsigned Kind : 1;
+ };
+
+ class UsingBitfields {
+ friend class UsingType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// True if the underlying type is different from the declared one.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned hasTypeDifferentFromDecl : 1;
+ };
+
+ class TypedefBitfields {
+ friend class TypedefType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// True if the underlying type is different from the declared one.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned hasTypeDifferentFromDecl : 1;
+ };
+
+ class TemplateTypeParmTypeBitfields {
+ friend class TemplateTypeParmType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The depth of the template parameter.
+ unsigned Depth : 15;
+
+ /// Whether this is a template parameter pack.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned ParameterPack : 1;
+
+ /// The index of the template parameter.
+ unsigned Index : 16;
+ };
+
+ class SubstTemplateTypeParmTypeBitfields {
+ friend class SubstTemplateTypeParmType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasNonCanonicalUnderlyingType : 1;
+
+ LLVM_PREFERRED_TYPE(SubstTemplateTypeParmTypeFlag)
+ unsigned SubstitutionFlag : 1;
+
+ // The index of the template parameter this substitution represents.
+ unsigned Index : 15;
+
+ /// Represents the index within a pack if this represents a substitution
+ /// from a pack expansion. This index starts at the end of the pack and
+ /// increments towards the beginning.
+ /// Positive non-zero number represents the index + 1.
+ /// Zero means this is not substituted from an expansion.
+ unsigned PackIndex : 16;
+ };
+
+ class SubstTemplateTypeParmPackTypeBitfields {
+ friend class SubstTemplateTypeParmPackType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ // The index of the template parameter this substitution represents.
+ unsigned Index : 16;
+
+ /// The number of template arguments in \c Arguments, which is
+ /// expected to be able to hold at least 1024 according to [implimits].
+ /// However as this limit is somewhat easy to hit with template
+ /// metaprogramming we'd prefer to keep it as large as possible.
+ unsigned NumArgs : 16;
+ };
+
+ class TemplateSpecializationTypeBitfields {
+ friend class TemplateSpecializationType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// Whether this template specialization type is a substituted type alias.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned TypeAlias : 1;
+
+ /// The number of template arguments named in this class template
+ /// specialization, which is expected to be able to hold at least 1024
+ /// according to [implimits]. However, as this limit is somewhat easy to
+ /// hit with template metaprogramming we'd prefer to keep it as large
+ /// as possible. At the moment it has been left as a non-bitfield since
+ /// this type safely fits in 64 bits as an unsigned, so there is no reason
+ /// to introduce the performance impact of a bitfield.
+ unsigned NumArgs;
+ };
+
+ class DependentTemplateSpecializationTypeBitfields {
+ friend class DependentTemplateSpecializationType;
+
+ LLVM_PREFERRED_TYPE(TypeWithKeywordBitfields)
+ unsigned : NumTypeWithKeywordBits;
+
+ /// The number of template arguments named in this class template
+ /// specialization, which is expected to be able to hold at least 1024
+ /// according to [implimits]. However, as this limit is somewhat easy to
+ /// hit with template metaprogramming we'd prefer to keep it as large
+ /// as possible. At the moment it has been left as a non-bitfield since
+ /// this type safely fits in 64 bits as an unsigned, so there is no reason
+ /// to introduce the performance impact of a bitfield.
+ unsigned NumArgs;
+ };
+
+ class PackExpansionTypeBitfields {
+ friend class PackExpansionType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ /// The number of expansions that this pack expansion will
+ /// generate when substituted (+1), which is expected to be able to
+ /// hold at least 1024 according to [implimits]. However, as this limit
+ /// is somewhat easy to hit with template metaprogramming we'd prefer to
+ /// keep it as large as possible. At the moment it has been left as a
+ /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
+ /// there is no reason to introduce the performance impact of a bitfield.
+ ///
+ /// This field will only have a non-zero value when some of the parameter
+ /// packs that occur within the pattern have been substituted but others
+ /// have not.
+ unsigned NumExpansions;
+ };
+
+ class CountAttributedTypeBitfields {
+ friend class CountAttributedType;
+
+ LLVM_PREFERRED_TYPE(TypeBitfields)
+ unsigned : NumTypeBits;
+
+ static constexpr unsigned NumCoupledDeclsBits = 4;
+ unsigned NumCoupledDecls : NumCoupledDeclsBits;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned CountInBytes : 1;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned OrNull : 1;
+ };
+ static_assert(sizeof(CountAttributedTypeBitfields) <= sizeof(unsigned));
+
+ union {
+ TypeBitfields TypeBits;
+ ArrayTypeBitfields ArrayTypeBits;
+ ConstantArrayTypeBitfields ConstantArrayTypeBits;
+ AttributedTypeBitfields AttributedTypeBits;
+ AutoTypeBitfields AutoTypeBits;
+ TypeOfBitfields TypeOfBits;
+ TypedefBitfields TypedefBits;
+ UsingBitfields UsingBits;
+ BuiltinTypeBitfields BuiltinTypeBits;
+ FunctionTypeBitfields FunctionTypeBits;
+ ObjCObjectTypeBitfields ObjCObjectTypeBits;
+ ReferenceTypeBitfields ReferenceTypeBits;
+ TypeWithKeywordBitfields TypeWithKeywordBits;
+ ElaboratedTypeBitfields ElaboratedTypeBits;
+ VectorTypeBitfields VectorTypeBits;
+ TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits;
+ SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits;
+ SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
+ TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
+ DependentTemplateSpecializationTypeBitfields
+ DependentTemplateSpecializationTypeBits;
+ PackExpansionTypeBitfields PackExpansionTypeBits;
+ CountAttributedTypeBitfields CountAttributedTypeBits;
+ };
+
+private:
+ template <class T> friend class TypePropertyCache;
+
+ /// Set whether this type comes from an AST file.
+ void setFromAST(bool V = true) const {
+ TypeBits.FromAST = V;
+ }
+
+protected:
+ friend class ASTContext;
+
+ Type(TypeClass tc, QualType canon, TypeDependence Dependence)
+ : ExtQualsTypeCommonBase(this,
+ canon.isNull() ? QualType(this_(), 0) : canon) {
+ static_assert(sizeof(*this) <=
+ alignof(decltype(*this)) + sizeof(ExtQualsTypeCommonBase),
+ "changing bitfields changed sizeof(Type)!");
+ static_assert(alignof(decltype(*this)) % TypeAlignment == 0,
+ "Insufficient alignment!");
+ TypeBits.TC = tc;
+ TypeBits.Dependence = static_cast<unsigned>(Dependence);
+ TypeBits.CacheValid = false;
+ TypeBits.CachedLocalOrUnnamed = false;
+ TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
+ TypeBits.FromAST = false;
+ }
+
+ // silence VC++ warning C4355: 'this' : used in base member initializer list
+ Type *this_() { return this; }
+
+ void setDependence(TypeDependence D) {
+ TypeBits.Dependence = static_cast<unsigned>(D);
+ }
+
+ void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
+
+public:
+ friend class ASTReader;
+ friend class ASTWriter;
+ template <class T> friend class serialization::AbstractTypeReader;
+ template <class T> friend class serialization::AbstractTypeWriter;
+
+ Type(const Type &) = delete;
+ Type(Type &&) = delete;
+ Type &operator=(const Type &) = delete;
+ Type &operator=(Type &&) = delete;
+
+ TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
+
+ /// Whether this type comes from an AST file.
+ bool isFromAST() const { return TypeBits.FromAST; }
+
+ /// Whether this type is or contains an unexpanded parameter
+ /// pack, used to support C++0x variadic templates.
+ ///
+ /// A type that contains a parameter pack shall be expanded by the
+ /// ellipsis operator at some point. For example, the typedef in the
+ /// following example contains an unexpanded parameter pack 'T':
+ ///
+ /// \code
+ /// template<typename ...T>
+ /// struct X {
+ /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
+ /// };
+ /// \endcode
+ ///
+ /// Note that this routine does not specify which
+ bool containsUnexpandedParameterPack() const {
+ return getDependence() & TypeDependence::UnexpandedPack;
+ }
+
+ /// Determines if this type would be canonical if it had no further
+ /// qualification.
+ bool isCanonicalUnqualified() const {
+ return CanonicalType == QualType(this, 0);
+ }
+
+ /// Pull a single level of sugar off of this locally-unqualified type.
+ /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
+ /// or QualType::getSingleStepDesugaredType(const ASTContext&).
+ QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
+
+ /// As an extension, we classify types as one of "sized" or "sizeless";
+ /// every type is one or the other. Standard types are all sized;
+ /// sizeless types are purely an extension.
+ ///
+ /// Sizeless types contain data with no specified size, alignment,
+ /// or layout.
+ bool isSizelessType() const;
+ bool isSizelessBuiltinType() const;
+
+ /// Returns true for all scalable vector types.
+ bool isSizelessVectorType() const;
+
+ /// Returns true for SVE scalable vector types.
+ bool isSVESizelessBuiltinType() const;
+
+ /// Returns true for RVV scalable vector types.
+ bool isRVVSizelessBuiltinType() const;
+
+ /// Check if this is a WebAssembly Externref Type.
+ bool isWebAssemblyExternrefType() const;
+
+ /// Returns true if this is a WebAssembly table type: either an array of
+ /// reference types, or a pointer to a reference type (which can only be
+ /// created by array to pointer decay).
+ bool isWebAssemblyTableType() const;
+
+ /// Determines if this is a sizeless type supported by the
+ /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
+ /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
+ bool isSveVLSBuiltinType() const;
+
+ /// Returns the representative type for the element of an SVE builtin type.
+ /// This is used to represent fixed-length SVE vectors created with the
+ /// 'arm_sve_vector_bits' type attribute as VectorType.
+ QualType getSveEltType(const ASTContext &Ctx) const;
+
+ /// Determines if this is a sizeless type supported by the
+ /// 'riscv_rvv_vector_bits' type attribute, which can be applied to a single
+ /// RVV vector or mask.
+ bool isRVVVLSBuiltinType() const;
+
+ /// Returns the representative type for the element of an RVV builtin type.
+ /// This is used to represent fixed-length RVV vectors created with the
+ /// 'riscv_rvv_vector_bits' type attribute as VectorType.
+ QualType getRVVEltType(const ASTContext &Ctx) const;
+
+ /// Returns the representative type for the element of a sizeless vector
+ /// builtin type.
+ QualType getSizelessVectorEltType(const ASTContext &Ctx) const;
+
+ /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
+ /// object types, function types, and incomplete types.
+
+ /// Return true if this is an incomplete type.
+ /// A type that can describe objects, but which lacks information needed to
+ /// determine its size (e.g. void, or a fwd declared struct). Clients of this
+ /// routine will need to determine if the size is actually required.
+ ///
+ /// Def If non-null, and the type refers to some kind of declaration
+ /// that can be completed (such as a C struct, C++ class, or Objective-C
+ /// class), will be set to the declaration.
+ bool isIncompleteType(NamedDecl **Def = nullptr) const;
+
+ /// Return true if this is an incomplete or object
+ /// type, in other words, not a function type.
+ bool isIncompleteOrObjectType() const {
+ return !isFunctionType();
+ }
+
+ /// Determine whether this type is an object type.
+ bool isObjectType() const {
+ // C++ [basic.types]p8:
+ // An object type is a (possibly cv-qualified) type that is not a
+ // function type, not a reference type, and not a void type.
+ return !isReferenceType() && !isFunctionType() && !isVoidType();
+ }
+
+ /// Return true if this is a literal type
+ /// (C++11 [basic.types]p10)
+ bool isLiteralType(const ASTContext &Ctx) const;
+
+ /// Determine if this type is a structural type, per C++20 [temp.param]p7.
+ bool isStructuralType() const;
+
+ /// Test if this type is a standard-layout type.
+ /// (C++0x [basic.type]p9)
+ bool isStandardLayoutType() const;
+
+ /// Helper methods to distinguish type categories. All type predicates
+ /// operate on the canonical type, ignoring typedefs and qualifiers.
+
+ /// Returns true if the type is a builtin type.
+ bool isBuiltinType() const;
+
+ /// Test for a particular builtin type.
+ bool isSpecificBuiltinType(unsigned K) const;
+
+ /// Test for a type which does not represent an actual type-system type but
+ /// is instead used as a placeholder for various convenient purposes within
+ /// Clang. All such types are BuiltinTypes.
+ bool isPlaceholderType() const;
+ const BuiltinType *getAsPlaceholderType() const;
+
+ /// Test for a specific placeholder type.
+ bool isSpecificPlaceholderType(unsigned K) const;
+
+ /// Test for a placeholder type other than Overload; see
+ /// BuiltinType::isNonOverloadPlaceholderType.
+ bool isNonOverloadPlaceholderType() const;
+
+ /// isIntegerType() does *not* include complex integers (a GCC extension).
+ /// isComplexIntegerType() can be used to test for complex integers.
+ bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
+ bool isEnumeralType() const;
+
+ /// Determine whether this type is a scoped enumeration type.
+ bool isScopedEnumeralType() const;
+ bool isBooleanType() const;
+ bool isCharType() const;
+ bool isWideCharType() const;
+ bool isChar8Type() const;
+ bool isChar16Type() const;
+ bool isChar32Type() const;
+ bool isAnyCharacterType() const;
+ bool isIntegralType(const ASTContext &Ctx) const;
+
+ /// Determine whether this type is an integral or enumeration type.
+ bool isIntegralOrEnumerationType() const;
+
+ /// Determine whether this type is an integral or unscoped enumeration type.
+ bool isIntegralOrUnscopedEnumerationType() const;
+ bool isUnscopedEnumerationType() const;
+
+ /// Floating point categories.
+ bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
+ /// isComplexType() does *not* include complex integers (a GCC extension).
+ /// isComplexIntegerType() can be used to test for complex integers.
+ bool isComplexType() const; // C99 6.2.5p11 (complex)
+ bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
+ bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
+ bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
+ bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
+ bool isFloat32Type() const;
+ bool isDoubleType() const;
+ bool isBFloat16Type() const;
+ bool isMFloat8Type() const;
+ bool isFloat128Type() const;
+ bool isIbm128Type() const;
+ bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
+ bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
+ bool isVoidType() const; // C99 6.2.5p19
+ bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
+ bool isAggregateType() const;
+ bool isFundamentalType() const;
+ bool isCompoundType() const;
+
+ // Type Predicates: Check to see if this type is structurally the specified
+ // type, ignoring typedefs and qualifiers.
+ bool isFunctionType() const;
+ bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
+ bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
+ bool isPointerType() const;
+ bool isPointerOrReferenceType() const;
+ bool isSignableType() const;
+ bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
+ bool isCountAttributedType() const;
+ bool isBlockPointerType() const;
+ bool isVoidPointerType() const;
+ bool isReferenceType() const;
+ bool isLValueReferenceType() const;
+ bool isRValueReferenceType() const;
+ bool isObjectPointerType() const;
+ bool isFunctionPointerType() const;
+ bool isFunctionReferenceType() const;
+ bool isMemberPointerType() const;
+ bool isMemberFunctionPointerType() const;
+ bool isMemberDataPointerType() const;
+ bool isArrayType() const;
+ bool isConstantArrayType() const;
+ bool isIncompleteArrayType() const;
+ bool isVariableArrayType() const;
+ bool isArrayParameterType() const;
+ bool isDependentSizedArrayType() const;
+ bool isRecordType() const;
+ bool isClassType() const;
+ bool isStructureType() const;
+ bool isStructureTypeWithFlexibleArrayMember() const;
+ bool isObjCBoxableRecordType() const;
+ bool isInterfaceType() const;
+ bool isStructureOrClassType() const;
+ bool isUnionType() const;
+ bool isComplexIntegerType() const; // GCC _Complex integer type.
+ bool isVectorType() const; // GCC vector type.
+ bool isExtVectorType() const; // Extended vector type.
+ bool isExtVectorBoolType() const; // Extended vector type with bool element.
+ // Extended vector type with bool element that is packed. HLSL doesn't pack
+ // its bool vectors.
+ bool isPackedVectorBoolType(const ASTContext &ctx) const;
+ bool isSubscriptableVectorType() const;
+ bool isMatrixType() const; // Matrix type.
+ bool isConstantMatrixType() const; // Constant matrix type.
+ bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
+ bool isObjCObjectPointerType() const; // pointer to ObjC object
+ bool isObjCRetainableType() const; // ObjC object or block pointer
+ bool isObjCLifetimeType() const; // (array of)* retainable type
+ bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
+ bool isObjCNSObjectType() const; // __attribute__((NSObject))
+ bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
+ // FIXME: change this to 'raw' interface type, so we can used 'interface' type
+ // for the common case.
+ bool isObjCObjectType() const; // NSString or typeof(*(id)0)
+ bool isObjCQualifiedInterfaceType() const; // NSString<foo>
+ bool isObjCQualifiedIdType() const; // id<foo>
+ bool isObjCQualifiedClassType() const; // Class<foo>
+ bool isObjCObjectOrInterfaceType() const;
+ bool isObjCIdType() const; // id
+ bool isDecltypeType() const;
+ /// Was this type written with the special inert-in-ARC __unsafe_unretained
+ /// qualifier?
+ ///
+ /// This approximates the answer to the following question: if this
+ /// translation unit were compiled in ARC, would this type be qualified
+ /// with __unsafe_unretained?
+ bool isObjCInertUnsafeUnretainedType() const {
+ return hasAttr(attr::ObjCInertUnsafeUnretained);
+ }
+
+ /// Whether the type is Objective-C 'id' or a __kindof type of an
+ /// object type, e.g., __kindof NSView * or __kindof id
+ /// <NSCopying>.
+ ///
+ /// \param bound Will be set to the bound on non-id subtype types,
+ /// which will be (possibly specialized) Objective-C class type, or
+ /// null for 'id.
+ bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
+ const ObjCObjectType *&bound) const;
+
+ bool isObjCClassType() const; // Class
+
+ /// Whether the type is Objective-C 'Class' or a __kindof type of an
+ /// Class type, e.g., __kindof Class <NSCopying>.
+ ///
+ /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
+ /// here because Objective-C's type system cannot express "a class
+ /// object for a subclass of NSFoo".
+ bool isObjCClassOrClassKindOfType() const;
+
+ bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
+ bool isObjCSelType() const; // Class
+ bool isObjCBuiltinType() const; // 'id' or 'Class'
+ bool isObjCARCBridgableType() const;
+ bool isCARCBridgableType() const;
+ bool isTemplateTypeParmType() const; // C++ template type parameter
+ bool isNullPtrType() const; // C++11 std::nullptr_t or
+ // C23 nullptr_t
+ bool isNothrowT() const; // C++ std::nothrow_t
+ bool isAlignValT() const; // C++17 std::align_val_t
+ bool isStdByteType() const; // C++17 std::byte
+ bool isAtomicType() const; // C11 _Atomic()
+ bool isUndeducedAutoType() const; // C++11 auto or
+ // C++14 decltype(auto)
+ bool isTypedefNameType() const; // typedef or alias template
+
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ bool is##Id##Type() const;
+#include "clang/Basic/OpenCLImageTypes.def"
+
+ bool isImageType() const; // Any OpenCL image type
+
+ bool isSamplerT() const; // OpenCL sampler_t
+ bool isEventT() const; // OpenCL event_t
+ bool isClkEventT() const; // OpenCL clk_event_t
+ bool isQueueT() const; // OpenCL queue_t
+ bool isReserveIDT() const; // OpenCL reserve_id_t
+
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
+ bool is##Id##Type() const;
+#include "clang/Basic/OpenCLExtensionTypes.def"
+ // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
+ bool isOCLIntelSubgroupAVCType() const;
+ bool isOCLExtOpaqueType() const; // Any OpenCL extension type
+
+ bool isPipeType() const; // OpenCL pipe type
+ bool isBitIntType() const; // Bit-precise integer type
+ bool isOpenCLSpecificType() const; // Any OpenCL specific type
+
+#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) bool is##Id##Type() const;
+#include "clang/Basic/HLSLIntangibleTypes.def"
+ bool isHLSLSpecificType() const; // Any HLSL specific type
+ bool isHLSLBuiltinIntangibleType() const; // Any HLSL builtin intangible type
+ bool isHLSLAttributedResourceType() const;
+ bool isHLSLResourceRecord() const;
+ bool isHLSLIntangibleType()
+ const; // Any HLSL intangible type (builtin, array, class)
+
+ /// Determines if this type, which must satisfy
+ /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
+ /// than implicitly __strong.
+ bool isObjCARCImplicitlyUnretainedType() const;
+
+ /// Check if the type is the CUDA device builtin surface type.
+ bool isCUDADeviceBuiltinSurfaceType() const;
+ /// Check if the type is the CUDA device builtin texture type.
+ bool isCUDADeviceBuiltinTextureType() const;
+
+ /// Return the implicit lifetime for this type, which must not be dependent.
+ Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
+
+ enum ScalarTypeKind {
+ STK_CPointer,
+ STK_BlockPointer,
+ STK_ObjCObjectPointer,
+ STK_MemberPointer,
+ STK_Bool,
+ STK_Integral,
+ STK_Floating,
+ STK_IntegralComplex,
+ STK_FloatingComplex,
+ STK_FixedPoint
+ };
+
+ /// Given that this is a scalar type, classify it.
+ ScalarTypeKind getScalarTypeKind() const;
+
+ TypeDependence getDependence() const {
+ return static_cast<TypeDependence>(TypeBits.Dependence);
+ }
+
+ /// Whether this type is an error type.
+ bool containsErrors() const {
+ return getDependence() & TypeDependence::Error;
+ }
+
+ /// Whether this type is a dependent type, meaning that its definition
+ /// somehow depends on a template parameter (C++ [temp.dep.type]).
+ bool isDependentType() const {
+ return getDependence() & TypeDependence::Dependent;
+ }
+
+ /// Determine whether this type is an instantiation-dependent type,
+ /// meaning that the type involves a template parameter (even if the
+ /// definition does not actually depend on the type substituted for that
+ /// template parameter).
+ bool isInstantiationDependentType() const {
+ return getDependence() & TypeDependence::Instantiation;
+ }
+
+ /// Determine whether this type is an undeduced type, meaning that
+ /// it somehow involves a C++11 'auto' type or similar which has not yet been
+ /// deduced.
+ bool isUndeducedType() const;
+
+ /// Whether this type is a variably-modified type (C99 6.7.5).
+ bool isVariablyModifiedType() const {
+ return getDependence() & TypeDependence::VariablyModified;
+ }
+
+ /// Whether this type involves a variable-length array type
+ /// with a definite size.
+ bool hasSizedVLAType() const;
+
+ /// Whether this type is or contains a local or unnamed type.
+ bool hasUnnamedOrLocalType() const;
+
+ bool isOverloadableType() const;
+
+ /// Determine wither this type is a C++ elaborated-type-specifier.
+ bool isElaboratedTypeSpecifier() const;
+
+ bool canDecayToPointerType() const;
+
+ /// Whether this type is represented natively as a pointer. This includes
+ /// pointers, references, block pointers, and Objective-C interface,
+ /// qualified id, and qualified interface types, as well as nullptr_t.
+ bool hasPointerRepresentation() const;
+
+ /// Whether this type can represent an objective pointer type for the
+ /// purpose of GC'ability
+ bool hasObjCPointerRepresentation() const;
+
+ /// Determine whether this type has an integer representation
+ /// of some sort, e.g., it is an integer type or a vector.
+ bool hasIntegerRepresentation() const;
+
+ /// Determine whether this type has an signed integer representation
+ /// of some sort, e.g., it is an signed integer type or a vector.
+ bool hasSignedIntegerRepresentation() const;
+
+ /// Determine whether this type has an unsigned integer representation
+ /// of some sort, e.g., it is an unsigned integer type or a vector.
+ bool hasUnsignedIntegerRepresentation() const;
+
+ /// Determine whether this type has a floating-point representation
+ /// of some sort, e.g., it is a floating-point type or a vector thereof.
+ bool hasFloatingRepresentation() const;
+
+ // Type Checking Functions: Check to see if this type is structurally the
+ // specified type, ignoring typedefs and qualifiers, and return a pointer to
+ // the best type we can.
+ const RecordType *getAsStructureType() const;
+ /// NOTE: getAs*ArrayType are methods on ASTContext.
+ const RecordType *getAsUnionType() const;
+ const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
+ const ObjCObjectType *getAsObjCInterfaceType() const;
+
+ // The following is a convenience method that returns an ObjCObjectPointerType
+ // for object declared using an interface.
+ const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
+ const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
+ const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
+ const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
+
+ /// Retrieves the CXXRecordDecl that this type refers to, either
+ /// because the type is a RecordType or because it is the injected-class-name
+ /// type of a class template or class template partial specialization.
+ CXXRecordDecl *getAsCXXRecordDecl() const;
+
+ /// Retrieves the RecordDecl this type refers to.
+ RecordDecl *getAsRecordDecl() const;
+
+ /// Retrieves the TagDecl that this type refers to, either
+ /// because the type is a TagType or because it is the injected-class-name
+ /// type of a class template or class template partial specialization.
+ TagDecl *getAsTagDecl() const;
+
+ /// If this is a pointer or reference to a RecordType, return the
+ /// CXXRecordDecl that the type refers to.
+ ///
+ /// If this is not a pointer or reference, or the type being pointed to does
+ /// not refer to a CXXRecordDecl, returns NULL.
+ const CXXRecordDecl *getPointeeCXXRecordDecl() const;
+
+ /// Get the DeducedType whose type will be deduced for a variable with
+ /// an initializer of this type. This looks through declarators like pointer
+ /// types, but not through decltype or typedefs.
+ DeducedType *getContainedDeducedType() const;
+
+ /// Get the AutoType whose type will be deduced for a variable with
+ /// an initializer of this type. This looks through declarators like pointer
+ /// types, but not through decltype or typedefs.
+ AutoType *getContainedAutoType() const {
+ return dyn_cast_or_null<AutoType>(getContainedDeducedType());
+ }
+
+ /// Determine whether this type was written with a leading 'auto'
+ /// corresponding to a trailing return type (possibly for a nested
+ /// function type within a pointer to function type or similar).
+ bool hasAutoForTrailingReturnType() const;
+
+ /// Member-template getAs<specific type>'. Look through sugar for
+ /// an instance of \<specific type>. This scheme will eventually
+ /// replace the specific getAsXXXX methods above.
+ ///
+ /// There are some specializations of this member template listed
+ /// immediately following this class.
+ template <typename T> const T *getAs() const;
+
+ /// Member-template getAsAdjusted<specific type>. Look through specific kinds
+ /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
+ /// This is used when you need to walk over sugar nodes that represent some
+ /// kind of type adjustment from a type that was written as a \<specific type>
+ /// to another type that is still canonically a \<specific type>.
+ template <typename T> const T *getAsAdjusted() const;
+
+ /// A variant of getAs<> for array types which silently discards
+ /// qualifiers from the outermost type.
+ const ArrayType *getAsArrayTypeUnsafe() const;
+
+ /// Member-template castAs<specific type>. Look through sugar for
+ /// the underlying instance of \<specific type>.
+ ///
+ /// This method has the same relationship to getAs<T> as cast<T> has
+ /// to dyn_cast<T>; which is to say, the underlying type *must*
+ /// have the intended type, and this method will never return null.
+ template <typename T> const T *castAs() const;
+
+ /// A variant of castAs<> for array type which silently discards
+ /// qualifiers from the outermost type.
+ const ArrayType *castAsArrayTypeUnsafe() const;
+
+ /// Determine whether this type had the specified attribute applied to it
+ /// (looking through top-level type sugar).
+ bool hasAttr(attr::Kind AK) const;
+
+ /// Get the base element type of this type, potentially discarding type
+ /// qualifiers. This should never be used when type qualifiers
+ /// are meaningful.
+ const Type *getBaseElementTypeUnsafe() const;
+
+ /// If this is an array type, return the element type of the array,
+ /// potentially with type qualifiers missing.
+ /// This should never be used when type qualifiers are meaningful.
+ const Type *getArrayElementTypeNoTypeQual() const;
+
+ /// If this is a pointer type, return the pointee type.
+ /// If this is an array type, return the array element type.
+ /// This should never be used when type qualifiers are meaningful.
+ const Type *getPointeeOrArrayElementType() const;
+
+ /// If this is a pointer, ObjC object pointer, or block
+ /// pointer, this returns the respective pointee.
+ QualType getPointeeType() const;
+
+ /// Return the specified type with any "sugar" removed from the type,
+ /// removing any typedefs, typeofs, etc., as well as any qualifiers.
+ const Type *getUnqualifiedDesugaredType() const;
+
+ /// Return true if this is an integer type that is
+ /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
+ /// or an enum decl which has a signed representation.
+ bool isSignedIntegerType() const;
+
+ /// Return true if this is an integer type that is
+ /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
+ /// or an enum decl which has an unsigned representation.
+ bool isUnsignedIntegerType() const;
+
+ /// Determines whether this is an integer type that is signed or an
+ /// enumeration types whose underlying type is a signed integer type.
+ bool isSignedIntegerOrEnumerationType() const;
+
+ /// Determines whether this is an integer type that is unsigned or an
+ /// enumeration types whose underlying type is a unsigned integer type.
+ bool isUnsignedIntegerOrEnumerationType() const;
+
+ /// Return true if this is a fixed point type according to
+ /// ISO/IEC JTC1 SC22 WG14 N1169.
+ bool isFixedPointType() const;
+
+ /// Return true if this is a fixed point or integer type.
+ bool isFixedPointOrIntegerType() const;
+
+ /// Return true if this can be converted to (or from) a fixed point type.
+ bool isConvertibleToFixedPointType() const;
+
+ /// Return true if this is a saturated fixed point type according to
+ /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
+ bool isSaturatedFixedPointType() const;
+
+ /// Return true if this is a saturated fixed point type according to
+ /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
+ bool isUnsaturatedFixedPointType() const;
+
+ /// Return true if this is a fixed point type that is signed according
+ /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
+ bool isSignedFixedPointType() const;
+
+ /// Return true if this is a fixed point type that is unsigned according
+ /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
+ bool isUnsignedFixedPointType() const;
+
+ /// Return true if this is not a variable sized type,
+ /// according to the rules of C99 6.7.5p3. It is not legal to call this on
+ /// incomplete types.
+ bool isConstantSizeType() const;
+
+ /// Returns true if this type can be represented by some
+ /// set of type specifiers.
+ bool isSpecifierType() const;
+
+ /// Determine the linkage of this type.
+ Linkage getLinkage() const;
+
+ /// Determine the visibility of this type.
+ Visibility getVisibility() const {
+ return getLinkageAndVisibility().getVisibility();
+ }
+
+ /// Return true if the visibility was explicitly set is the code.
+ bool isVisibilityExplicit() const {
+ return getLinkageAndVisibility().isVisibilityExplicit();
+ }
+
+ /// Determine the linkage and visibility of this type.
+ LinkageInfo getLinkageAndVisibility() const;
+
+ /// True if the computed linkage is valid. Used for consistency
+ /// checking. Should always return true.
+ bool isLinkageValid() const;
+
+ /// Determine the nullability of the given type.
+ ///
+ /// Note that nullability is only captured as sugar within the type
+ /// system, not as part of the canonical type, so nullability will
+ /// be lost by canonicalization and desugaring.
+ std::optional<NullabilityKind> getNullability() const;
+
+ /// Determine whether the given type can have a nullability
+ /// specifier applied to it, i.e., if it is any kind of pointer type.
+ ///
+ /// \param ResultIfUnknown The value to return if we don't yet know whether
+ /// this type can have nullability because it is dependent.
+ bool canHaveNullability(bool ResultIfUnknown = true) const;
+
+ /// Retrieve the set of substitutions required when accessing a member
+ /// of the Objective-C receiver type that is declared in the given context.
+ ///
+ /// \c *this is the type of the object we're operating on, e.g., the
+ /// receiver for a message send or the base of a property access, and is
+ /// expected to be of some object or object pointer type.
+ ///
+ /// \param dc The declaration context for which we are building up a
+ /// substitution mapping, which should be an Objective-C class, extension,
+ /// category, or method within.
+ ///
+ /// \returns an array of type arguments that can be substituted for
+ /// the type parameters of the given declaration context in any type described
+ /// within that context, or an empty optional to indicate that no
+ /// substitution is required.
+ std::optional<ArrayRef<QualType>>
+ getObjCSubstitutions(const DeclContext *dc) const;
+
+ /// Determines if this is an ObjC interface type that may accept type
+ /// parameters.
+ bool acceptsObjCTypeParams() const;
+
+ const char *getTypeClassName() const;
+
+ QualType getCanonicalTypeInternal() const {
+ return CanonicalType;
+ }
+
+ CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
+ void dump() const;
+ void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
+};
\ No newline at end of file
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index c5dae55b8b40e..bccc5305fb6b2 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -11,6 +11,7 @@
//
//===----------------------------------------------------------------------===//
+#include "LLVMABI/Type.h"
#include "CGCall.h"
#include "ABIInfo.h"
#include "ABIInfoImpl.h"
@@ -44,6 +45,7 @@
#include <optional>
using namespace clang;
using namespace CodeGen;
+using namespace ABI;
/***/
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
@@ -797,6 +799,43 @@ void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
}
}
+std::unique_ptr<ABI::ABIBuiltinType> *getABIType(QualType QT){
+ const clang::Type *BaseType = QT.getTypePtr();
+
+ switch (BaseType->getTypeClass()) {
+ case clang::Type::Builtin: {
+ // Cast to BuiltinType to access its kind
+ auto *BT = llvm::cast<clang::BuiltinType>(BaseType);
+
+ ABIBuiltinType::Kind ABIKind;
+ switch (BT->getKind()) {
+ case clang::BuiltinType::Void:
+ ABIKind = ABIBuiltinType::Void;
+ break;
+ case clang::BuiltinType::Bool:
+ ABIKind = ABIBuiltinType::Bool;
+ break;
+ case clang::BuiltinType::Int:
+ ABIKind = ABIBuiltinType::Integer;
+ break;
+ case clang::BuiltinType::UInt:
+ ABIKind = ABIBuiltinType::UnsignedInteger;
+ break;
+ case clang::BuiltinType::Float:
+ ABIKind = ABIBuiltinType::FloatingPoint;
+ break;
+ default:
+ // TODO: support additional types
+ return std::make_unique<ABIBuiltinType>(ABI::ABIBuiltinType::Kind::Void);
+ }
+ return std::make_unique<ABIBuiltinType>(ABIKind);
+ }
+ default :
+ // TODO: support additonal types
+ return std::make_unique<ABIBuiltinType>(ABI::ABIBuiltinType::Kind::Bool);
+}
+}
+
/// 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.
@@ -808,29 +847,6 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
assert(llvm::all_of(argTypes,
[](CanQualType T) { return T.isCanonicalAsParam(); }));
-// first convert each of these types into ABI::types. -> info, paramInfos, required, resultType, argTypes
-// then in the library, create abi::functionInfo type, same as how CGFunctionInfo is created.
-// then in the library, lower abi::functionInfo to abi::x_86_abiArgInfo
-// then return that. then the frontend has to lower that to llvm-ir.
-// so clang will have to map that to clang::CGFunctionInfo.
- ABIType resultTypeABI = getABIType(resultType);
-
- std::vector<ABIType> abiTypes;
- abiTypes.reserve(canQualTypes.size());
-
- for (const llvm::CanQualType &element : argTypes) {
- abiTypes.push_back(getABIType(element));
- }
- llvm::ArrayRef<ABIType> argTypesABI = llvm::ArrayRef<ABIType>(abiTypes);
-
- ABIFunctionInfo *ABIFI = ABIFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
- info, paramInfos, resultType, argTypes, required);
-
- // TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() ;
- ABIInfo::computeFunctionInfo(CodeGenModule::getTargetCodeGenInfo(), ABIFI);
-
- CGFunctionInfo *FI = mapABIFunctionInfoToCGFunctionInfo(ABIFI);
-
// Lookup or create unique function info.
llvm::FoldingSetNodeID ID;
bool isInstanceMethod =
@@ -849,14 +865,25 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
- // Construct the function info. We co-allocate the ArgInfos.
+ // map clang::QualType -> abi::Type
+ // implicit conversion from clang::CanQualType to clang::QualType
+ std::unique_ptr<ABI::ABIBuiltinType> resultTypeABI = getABIType(resultType);
+
+ std::vector<ABI::ABIBuiltinType> abiTypes;
+ abiTypes.reserve(argTypes.size());
+
+ for (const llvm::CanQualType &element : argTypes) {
+ abiTypes.push_back(*getABIType(element)); // Move unique_ptr into the vector
+ }
+
+ llvm::ArrayRef<ABI::ABIBuiltinType> argTypesABI(abiTypes);
+
+ // map the abi::Types -> abi::FunctionInfo type, done by the library
+ ABIFunctionInfo *ABIFI = ABIFunctionInfo::create(CC, resultTypeABI.get(), argTypesABI);
+
+ // // Construct the function info. We co-allocate the ArgInfos.
// FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
// info, paramInfos, resultType, argTypes, required);
- FunctionInfos.InsertNode(FI, insertPos);
-
- bool inserted = FunctionsBeingProcessed.insert(FI).second;
- (void)inserted;
- assert(inserted && "Recursively being processed?");
// Compute ABI information.
if (CC == llvm::CallingConv::SPIR_KERNEL) {
@@ -866,9 +893,17 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
} else if (info.getCC() == CC_Swift || info.getCC() == CC_SwiftAsync) {
swiftcall::computeABIInfo(CGM, *FI);
} else {
- CGM.getABIInfo().computeInfo(*FI);
+ // inject the required ABI information into the function. done by the library
+ ABI::computeFunctionInfo(CodeGenModule::getTargetCodeGenInfo(), ABIFI);
}
+ // lower the ABI::FunctionInfo Type to Clang::CGFunctionInfo
+ CGFunctionInfo *FI = mapABIFunctionInfoToCGFunctionInfo(ABIFI);
+ FunctionInfos.InsertNode(FI, insertPos);
+ bool inserted = FunctionsBeingProcessed.insert(FI).second;
+ (void)inserted;
+ assert(inserted && "Recursively being processed?");
+
// Loop over all of the computed argument and return value info. If any of
// them are direct or extend without a specified coerce type, specify the
// default now.
>From 7fb658a8adcab586b1d84cbdd1b1ddb2dc40cb90 Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Thu, 27 Mar 2025 17:12:16 +0530
Subject: [PATCH 4/4] Adding support for ABIFunctionInfo. Hopefully this is in
the right direction.
---
LLVMABI/ABIFunctionInfo.h | 117 +++
LLVMABI/CGFunctionInfo.h | 843 ---------------------
LLVMABI/Type.h | 1375 +---------------------------------
clang/lib/CodeGen/CGCall.cpp | 25 +-
4 files changed, 163 insertions(+), 2197 deletions(-)
create mode 100644 LLVMABI/ABIFunctionInfo.h
delete mode 100644 LLVMABI/CGFunctionInfo.h
diff --git a/LLVMABI/ABIFunctionInfo.h b/LLVMABI/ABIFunctionInfo.h
new file mode 100644
index 0000000000000..b298f95b35290
--- /dev/null
+++ b/LLVMABI/ABIFunctionInfo.h
@@ -0,0 +1,117 @@
+#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+
+#include "LLVMABI/Type.h"
+// Does the leaf leave the tree or the tree let go of the leaf?
+
+namespace ABIFunction{
+
+
+/// ABIArgInfo - Helper class to encapsulate information about how a
+/// specific C type should be passed to or returned from a function.
+class ABIArgInfo {
+public:
+ enum Kind : uint8_t {
+ /// Direct - Pass the argument directly using the normal converted LLVM
+ /// type, or by coercing to another specified type stored in
+ /// 'CoerceToType'). If an offset is specified (in UIntData), then the
+ /// argument passed is offset by some number of bytes in the memory
+ /// representation. A dummy argument is emitted before the real argument
+ /// if the specified type stored in "PaddingType" is not zero.
+ Direct,
+
+ /// Extend - Valid only for integer argument types. Same as 'direct'
+ /// but also emit a zero/sign extension attribute.
+ Extend,
+
+ /// Indirect - Pass the argument indirectly via a hidden pointer with the
+ /// specified alignment (0 indicates default alignment) and address space.
+ Indirect,
+
+ /// IndirectAliased - Similar to Indirect, but the pointer may be to an
+ /// object that is otherwise referenced. The object is known to not be
+ /// modified through any other references for the duration of the call, and
+ /// the callee must not itself modify the object. Because C allows
+ /// parameter variables to be modified and guarantees that they have unique
+ /// addresses, the callee must defensively copy the object into a local
+ /// variable if it might be modified or its address might be compared.
+ /// Since those are uncommon, in principle this convention allows programs
+ /// to avoid copies in more situations. However, it may introduce *extra*
+ /// copies if the callee fails to prove that a copy is unnecessary and the
+ /// caller naturally produces an unaliased object for the argument.
+ IndirectAliased,
+
+ /// Ignore - Ignore the argument (treat as void). Useful for void and
+ /// empty structs.
+ Ignore,
+
+ /// Expand - Only valid for aggregate argument types. The structure should
+ /// be expanded into consecutive arguments for its constituent fields.
+ /// Currently expand is only allowed on structures whose fields
+ /// are all scalar types or are themselves expandable types.
+ Expand,
+
+ /// CoerceAndExpand - Only valid for aggregate argument types. The
+ /// structure should be expanded into consecutive arguments corresponding
+ /// to the non-array elements of the type stored in CoerceToType.
+ /// Array elements in the type are assumed to be padding and skipped.
+ CoerceAndExpand,
+
+ /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
+ /// This is similar to indirect with byval, except it only applies to
+ /// arguments stored in memory and forbids any implicit copies. When
+ /// applied to a return type, it means the value is returned indirectly via
+ /// an implicit sret parameter stored in the argument struct.
+ InAlloca,
+ KindFirst = Direct,
+ KindLast = InAlloca
+ };
+
+private:
+ Kind TheKind;
+
+public:
+ ABIArgInfo(Kind K = Direct) : TheKind(K) {}
+
+ Kind getKind() const { return TheKind; }
+
+ void dump() const;
+};
+
+enum CallingConv {
+ CC_C, // __attribute__((cdecl))
+ CC_X86StdCall // __attribute__((stdcall))
+};
+
+struct ABIFunctionInfoArgInfo {
+ ABI::ABIBuiltinType type;
+ ABIArgInfo info;
+};
+
+class ABIFunctionInfo {
+ typedef ABIFunctionInfoArgInfo ArgInfo;
+
+ private:
+ CallingConv CC;
+ std::vector<ArgInfo> Parameters;
+ ArgInfo RetInfo;
+
+ public:
+ ABIFunctionInfo(CallingConv cc, std::vector<ABI::ABIBuiltinType> parameters, ABI::ABIBuiltinType ReturnInfo);
+
+ static ABIFunctionInfo *
+ create(CallingConv cc, std::vector<ABI::ABIBuiltinType> parameters, ABI::ABIBuiltinType ReturnInfo);
+
+ const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
+ const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
+ arg_iterator arg_begin() { return getArgsBuffer() + 1; }
+ arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
+
+ unsigned getCallingConvention() const { return CC; }
+
+ ABIBuiltinType getReturnType() const { return getArgsBuffer()[0].type; }
+
+ ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
+};
+
+}
diff --git a/LLVMABI/CGFunctionInfo.h b/LLVMABI/CGFunctionInfo.h
deleted file mode 100644
index f6030f8c666c7..0000000000000
--- a/LLVMABI/CGFunctionInfo.h
+++ /dev/null
@@ -1,843 +0,0 @@
-//==-- CGFunctionInfo.h - Representation of function argument/return 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Defines CGFunctionInfo and associated types used in representing the
-// LLVM source types and ABI-coerced types for function arguments and
-// return values.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
-#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
-
-#include "LLVMABI/Type.h"
-#include "clang/AST/CanonicalType.h"
-#include "clang/AST/CharUnits.h"
-#include "clang/AST/Decl.h"
-#include "clang/AST/Type.h"
-#include "llvm/IR/DerivedTypes.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/Support/TrailingObjects.h"
-#include <cassert>
-
-namespace clang {
-namespace CodeGen {
-
-/// ABIArgInfo - Helper class to encapsulate information about how a
-/// specific C type should be passed to or returned from a function.
-class ABIArgInfo {
-public:
- enum Kind : uint8_t {
- /// Direct - Pass the argument directly using the normal converted LLVM
- /// type, or by coercing to another specified type stored in
- /// 'CoerceToType'). If an offset is specified (in UIntData), then the
- /// argument passed is offset by some number of bytes in the memory
- /// representation. A dummy argument is emitted before the real argument
- /// if the specified type stored in "PaddingType" is not zero.
- Direct,
-
- /// Extend - Valid only for integer argument types. Same as 'direct'
- /// but also emit a zero/sign extension attribute.
- Extend,
-
- /// Indirect - Pass the argument indirectly via a hidden pointer with the
- /// specified alignment (0 indicates default alignment) and address space.
- Indirect,
-
- /// IndirectAliased - Similar to Indirect, but the pointer may be to an
- /// object that is otherwise referenced. The object is known to not be
- /// modified through any other references for the duration of the call, and
- /// the callee must not itself modify the object. Because C allows
- /// parameter variables to be modified and guarantees that they have unique
- /// addresses, the callee must defensively copy the object into a local
- /// variable if it might be modified or its address might be compared.
- /// Since those are uncommon, in principle this convention allows programs
- /// to avoid copies in more situations. However, it may introduce *extra*
- /// copies if the callee fails to prove that a copy is unnecessary and the
- /// caller naturally produces an unaliased object for the argument.
- IndirectAliased,
-
- /// Ignore - Ignore the argument (treat as void). Useful for void and
- /// empty structs.
- Ignore,
-
- /// Expand - Only valid for aggregate argument types. The structure should
- /// be expanded into consecutive arguments for its constituent fields.
- /// Currently expand is only allowed on structures whose fields
- /// are all scalar types or are themselves expandable types.
- Expand,
-
- /// CoerceAndExpand - Only valid for aggregate argument types. The
- /// structure should be expanded into consecutive arguments corresponding
- /// to the non-array elements of the type stored in CoerceToType.
- /// Array elements in the type are assumed to be padding and skipped.
- CoerceAndExpand,
-
- /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
- /// This is similar to indirect with byval, except it only applies to
- /// arguments stored in memory and forbids any implicit copies. When
- /// applied to a return type, it means the value is returned indirectly via
- /// an implicit sret parameter stored in the argument struct.
- InAlloca,
- KindFirst = Direct,
- KindLast = InAlloca
- };
-
-private:
- llvm::Type *TypeData; // canHaveCoerceToType()
- union {
- llvm::Type *PaddingType; // canHavePaddingType()
- llvm::Type *UnpaddedCoerceAndExpandType; // isCoerceAndExpand()
- };
- struct DirectAttrInfo {
- unsigned Offset;
- unsigned Align;
- };
- struct IndirectAttrInfo {
- unsigned Align;
- unsigned AddrSpace;
- };
- union {
- DirectAttrInfo DirectAttr; // isDirect() || isExtend()
- IndirectAttrInfo IndirectAttr; // isIndirect()
- unsigned AllocaFieldIndex; // isInAlloca()
- };
- Kind TheKind;
- bool PaddingInReg : 1;
- bool InAllocaSRet : 1; // isInAlloca()
- bool InAllocaIndirect : 1;// isInAlloca()
- bool IndirectByVal : 1; // isIndirect()
- bool IndirectRealign : 1; // isIndirect()
- bool SRetAfterThis : 1; // isIndirect()
- bool InReg : 1; // isDirect() || isExtend() || isIndirect()
- bool CanBeFlattened: 1; // isDirect()
- bool SignExt : 1; // isExtend()
- bool ZeroExt : 1; // isExtend()
-
- bool canHavePaddingType() const {
- return isDirect() || isExtend() || isIndirect() || isIndirectAliased() ||
- isExpand();
- }
- void setPaddingType(llvm::Type *T) {
- assert(canHavePaddingType());
- PaddingType = T;
- }
-
- void setUnpaddedCoerceToType(llvm::Type *T) {
- assert(isCoerceAndExpand());
- UnpaddedCoerceAndExpandType = T;
- }
-
-public:
- ABIArgInfo(Kind K = Direct)
- : TypeData(nullptr), PaddingType(nullptr), DirectAttr{0, 0}, TheKind(K),
- PaddingInReg(false), InAllocaSRet(false),
- InAllocaIndirect(false), IndirectByVal(false), IndirectRealign(false),
- SRetAfterThis(false), InReg(false), CanBeFlattened(false),
- SignExt(false), ZeroExt(false) {}
-
- static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
- llvm::Type *Padding = nullptr,
- bool CanBeFlattened = true, unsigned Align = 0) {
- auto AI = ABIArgInfo(Direct);
- AI.setCoerceToType(T);
- AI.setPaddingType(Padding);
- AI.setDirectOffset(Offset);
- AI.setDirectAlign(Align);
- AI.setCanBeFlattened(CanBeFlattened);
- return AI;
- }
- static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
- auto AI = getDirect(T);
- AI.setInReg(true);
- return AI;
- }
-
- static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T = nullptr) {
- assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
- auto AI = ABIArgInfo(Extend);
- AI.setCoerceToType(T);
- AI.setPaddingType(nullptr);
- AI.setDirectOffset(0);
- AI.setDirectAlign(0);
- AI.setSignExt(true);
- return AI;
- }
-
- static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T = nullptr) {
- assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
- auto AI = ABIArgInfo(Extend);
- AI.setCoerceToType(T);
- AI.setPaddingType(nullptr);
- AI.setDirectOffset(0);
- AI.setDirectAlign(0);
- AI.setZeroExt(true);
- return AI;
- }
-
- // ABIArgInfo will record the argument as being extended based on the sign
- // of its type. Produces a sign or zero extension.
- static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) {
- assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
- if (Ty->hasSignedIntegerRepresentation())
- return getSignExtend(Ty, T);
- return getZeroExtend(Ty, T);
- }
-
- // Struct in register marked explicitly as not needing extension.
- static ABIArgInfo getNoExtend(llvm::IntegerType *T) {
- auto AI = ABIArgInfo(Extend);
- AI.setCoerceToType(T);
- AI.setPaddingType(nullptr);
- AI.setDirectOffset(0);
- AI.setDirectAlign(0);
- return AI;
- }
-
- static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) {
- auto AI = getExtend(Ty, T);
- AI.setInReg(true);
- return AI;
- }
- static ABIArgInfo getIgnore() {
- return ABIArgInfo(Ignore);
- }
- static ABIArgInfo getIndirect(CharUnits Alignment, unsigned AddrSpace,
- bool ByVal = true, bool Realign = false,
- llvm::Type *Padding = nullptr) {
- auto AI = ABIArgInfo(Indirect);
- AI.setIndirectAlign(Alignment);
- AI.setIndirectByVal(ByVal);
- AI.setIndirectRealign(Realign);
- AI.setSRetAfterThis(false);
- AI.setPaddingType(Padding);
- AI.setIndirectAddrSpace(AddrSpace);
- return AI;
- }
-
- /// Pass this in memory using the IR byref attribute.
- static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace,
- bool Realign = false,
- llvm::Type *Padding = nullptr) {
- auto AI = ABIArgInfo(IndirectAliased);
- AI.setIndirectAlign(Alignment);
- AI.setIndirectRealign(Realign);
- AI.setPaddingType(Padding);
- AI.setIndirectAddrSpace(AddrSpace);
- return AI;
- }
-
- static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal = true,
- bool Realign = false) {
- auto AI = getIndirect(Alignment, 0, ByVal, Realign);
- AI.setInReg(true);
- return AI;
- }
- static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect = false) {
- auto AI = ABIArgInfo(InAlloca);
- AI.setInAllocaFieldIndex(FieldIndex);
- AI.setInAllocaIndirect(Indirect);
- return AI;
- }
- static ABIArgInfo getExpand() {
- auto AI = ABIArgInfo(Expand);
- AI.setPaddingType(nullptr);
- return AI;
- }
- static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
- llvm::Type *Padding) {
- auto AI = getExpand();
- AI.setPaddingInReg(PaddingInReg);
- AI.setPaddingType(Padding);
- return AI;
- }
-
- /// \param unpaddedCoerceToType The coerce-to type with padding elements
- /// removed, canonicalized to a single element if it would otherwise
- /// have exactly one element.
- static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType,
- llvm::Type *unpaddedCoerceToType) {
-#ifndef NDEBUG
- // Check that unpaddedCoerceToType has roughly the right shape.
-
- // Assert that we only have a struct type if there are multiple elements.
- auto unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoerceToType);
- assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1);
-
- // Assert that all the non-padding elements have a corresponding element
- // in the unpadded type.
- unsigned unpaddedIndex = 0;
- for (auto eltType : coerceToType->elements()) {
- if (isPaddingForCoerceAndExpand(eltType))
- continue;
- unpaddedIndex++;
- }
-
- // Assert that there aren't extra elements in the unpadded type.
- if (unpaddedStruct) {
- assert(unpaddedStruct->getNumElements() == unpaddedIndex);
- } else {
- assert(unpaddedIndex == 1);
- }
-#endif
-
- auto AI = ABIArgInfo(CoerceAndExpand);
- AI.setCoerceToType(coerceToType);
- AI.setUnpaddedCoerceToType(unpaddedCoerceToType);
- return AI;
- }
-
- static bool isPaddingForCoerceAndExpand(llvm::Type *eltType) {
- return eltType->isArrayTy() &&
- eltType->getArrayElementType()->isIntegerTy(8);
- }
-
- Kind getKind() const { return TheKind; }
- bool isDirect() const { return TheKind == Direct; }
- bool isInAlloca() const { return TheKind == InAlloca; }
- bool isExtend() const { return TheKind == Extend; }
- bool isIgnore() const { return TheKind == Ignore; }
- bool isIndirect() const { return TheKind == Indirect; }
- bool isIndirectAliased() const { return TheKind == IndirectAliased; }
- bool isExpand() const { return TheKind == Expand; }
- bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
-
- bool canHaveCoerceToType() const {
- return isDirect() || isExtend() || isCoerceAndExpand();
- }
-
- // Direct/Extend accessors
- unsigned getDirectOffset() const {
- assert((isDirect() || isExtend()) && "Not a direct or extend kind");
- return DirectAttr.Offset;
- }
- void setDirectOffset(unsigned Offset) {
- assert((isDirect() || isExtend()) && "Not a direct or extend kind");
- DirectAttr.Offset = Offset;
- }
-
- unsigned getDirectAlign() const {
- assert((isDirect() || isExtend()) && "Not a direct or extend kind");
- return DirectAttr.Align;
- }
- void setDirectAlign(unsigned Align) {
- assert((isDirect() || isExtend()) && "Not a direct or extend kind");
- DirectAttr.Align = Align;
- }
-
- bool isSignExt() const {
- assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
- return SignExt;
- }
- void setSignExt(bool SExt) {
- assert(isExtend() && "Invalid kind!");
- SignExt = SExt;
- }
-
- bool isZeroExt() const {
- assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
- return ZeroExt;
- }
- void setZeroExt(bool ZExt) {
- assert(isExtend() && "Invalid kind!");
- ZeroExt = ZExt;
- }
-
- bool isNoExt() const {
- assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
- return !SignExt && !ZeroExt;
- }
-
- llvm::Type *getPaddingType() const {
- return (canHavePaddingType() ? PaddingType : nullptr);
- }
-
- bool getPaddingInReg() const {
- return PaddingInReg;
- }
- void setPaddingInReg(bool PIR) {
- PaddingInReg = PIR;
- }
-
- llvm::Type *getCoerceToType() const {
- assert(canHaveCoerceToType() && "Invalid kind!");
- return TypeData;
- }
-
- void setCoerceToType(llvm::Type *T) {
- assert(canHaveCoerceToType() && "Invalid kind!");
- TypeData = T;
- }
-
- llvm::StructType *getCoerceAndExpandType() const {
- assert(isCoerceAndExpand());
- return cast<llvm::StructType>(TypeData);
- }
-
- llvm::Type *getUnpaddedCoerceAndExpandType() const {
- assert(isCoerceAndExpand());
- return UnpaddedCoerceAndExpandType;
- }
-
- ArrayRef<llvm::Type *>getCoerceAndExpandTypeSequence() const {
- assert(isCoerceAndExpand());
- if (auto structTy =
- dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) {
- return structTy->elements();
- } else {
- return llvm::ArrayRef(&UnpaddedCoerceAndExpandType, 1);
- }
- }
-
- bool getInReg() const {
- assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
- return InReg;
- }
-
- void setInReg(bool IR) {
- assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
- InReg = IR;
- }
-
- // Indirect accessors
- CharUnits getIndirectAlign() const {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- return CharUnits::fromQuantity(IndirectAttr.Align);
- }
- void setIndirectAlign(CharUnits IA) {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- IndirectAttr.Align = IA.getQuantity();
- }
-
- bool getIndirectByVal() const {
- assert(isIndirect() && "Invalid kind!");
- return IndirectByVal;
- }
- void setIndirectByVal(bool IBV) {
- assert(isIndirect() && "Invalid kind!");
- IndirectByVal = IBV;
- }
-
- unsigned getIndirectAddrSpace() const {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- return IndirectAttr.AddrSpace;
- }
-
- void setIndirectAddrSpace(unsigned AddrSpace) {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- IndirectAttr.AddrSpace = AddrSpace;
- }
-
- bool getIndirectRealign() const {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- return IndirectRealign;
- }
- void setIndirectRealign(bool IR) {
- assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
- IndirectRealign = IR;
- }
-
- bool isSRetAfterThis() const {
- assert(isIndirect() && "Invalid kind!");
- return SRetAfterThis;
- }
- void setSRetAfterThis(bool AfterThis) {
- assert(isIndirect() && "Invalid kind!");
- SRetAfterThis = AfterThis;
- }
-
- unsigned getInAllocaFieldIndex() const {
- assert(isInAlloca() && "Invalid kind!");
- return AllocaFieldIndex;
- }
- void setInAllocaFieldIndex(unsigned FieldIndex) {
- assert(isInAlloca() && "Invalid kind!");
- AllocaFieldIndex = FieldIndex;
- }
-
- unsigned getInAllocaIndirect() const {
- assert(isInAlloca() && "Invalid kind!");
- return InAllocaIndirect;
- }
- void setInAllocaIndirect(bool Indirect) {
- assert(isInAlloca() && "Invalid kind!");
- InAllocaIndirect = Indirect;
- }
-
- /// Return true if this field of an inalloca struct should be returned
- /// to implement a struct return calling convention.
- bool getInAllocaSRet() const {
- assert(isInAlloca() && "Invalid kind!");
- return InAllocaSRet;
- }
-
- void setInAllocaSRet(bool SRet) {
- assert(isInAlloca() && "Invalid kind!");
- InAllocaSRet = SRet;
- }
-
- bool getCanBeFlattened() const {
- assert(isDirect() && "Invalid kind!");
- return CanBeFlattened;
- }
-
- void setCanBeFlattened(bool Flatten) {
- assert(isDirect() && "Invalid kind!");
- CanBeFlattened = Flatten;
- }
-
- void dump() const;
-};
-
-/// A class for recording the number of arguments that a function
-/// signature requires.
-class RequiredArgs {
- /// The number of required arguments, or ~0 if the signature does
- /// not permit optional arguments.
- unsigned NumRequired;
-public:
- enum All_t { All };
-
- RequiredArgs(All_t _) : NumRequired(~0U) {}
- explicit RequiredArgs(unsigned n) : NumRequired(n) {
- assert(n != ~0U);
- }
-
- /// Compute the arguments required by the given formal prototype,
- /// given that there may be some additional, non-formal arguments
- /// in play.
- ///
- /// If FD is not null, this will consider pass_object_size params in FD.
- static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype,
- unsigned additional) {
- if (!prototype->isVariadic()) return All;
-
- if (prototype->hasExtParameterInfos())
- additional += llvm::count_if(
- prototype->getExtParameterInfos(),
- [](const FunctionProtoType::ExtParameterInfo &ExtInfo) {
- return ExtInfo.hasPassObjectSize();
- });
-
- return RequiredArgs(prototype->getNumParams() + additional);
- }
-
- static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype,
- unsigned additional) {
- return forPrototypePlus(prototype.getTypePtr(), additional);
- }
-
- static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
- return forPrototypePlus(prototype, 0);
- }
-
- static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) {
- return forPrototypePlus(prototype.getTypePtr(), 0);
- }
-
- bool allowsOptionalArgs() const { return NumRequired != ~0U; }
- unsigned getNumRequiredArgs() const {
- assert(allowsOptionalArgs());
- return NumRequired;
- }
-
- /// Return true if the argument at a given index is required.
- bool isRequiredArg(unsigned argIdx) const {
- return argIdx == ~0U || argIdx < NumRequired;
- }
-
- unsigned getOpaqueData() const { return NumRequired; }
- static RequiredArgs getFromOpaqueData(unsigned value) {
- if (value == ~0U) return All;
- return RequiredArgs(value);
- }
-};
-
-// Implementation detail of CGFunctionInfo, factored out so it can be named
-// in the TrailingObjects base class of CGFunctionInfo.
-struct ABIFunctionInfoArgInfo {
- ABIType type;
- ABIArgInfo info;
-};
-
-/// CGFunctionInfo - Class to encapsulate the information about a
-/// function definition.
-class ABIFunctionInfo final{
- // : public llvm::FoldingSetNode,
- // private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
- // FunctionProtoType::ExtParameterInfo> {
-
- typedef ABIFunctionInfoArgInfo ArgInfo;
- typedef FunctionProtoType::ExtParameterInfo ExtParameterInfo;
-
- /// The LLVM::CallingConv to use for this function (as specified by the
- /// user).
- unsigned CallingConvention : 8;
-
- /// The LLVM::CallingConv to actually use for this function, which may
- /// depend on the ABI.
- unsigned EffectiveCallingConvention : 8;
-
- /// The clang::CallingConv that this was originally created with.
- LLVM_PREFERRED_TYPE(CallingConv)
- unsigned ASTCallingConvention : 6;
-
- /// Whether this is an instance method.
- LLVM_PREFERRED_TYPE(bool)
- unsigned InstanceMethod : 1;
-
- /// Whether this is a chain call.
- LLVM_PREFERRED_TYPE(bool)
- unsigned ChainCall : 1;
-
- /// Whether this function is called by forwarding arguments.
- /// This doesn't support inalloca or varargs.
- LLVM_PREFERRED_TYPE(bool)
- unsigned DelegateCall : 1;
-
- /// Whether this function is a CMSE nonsecure call
- LLVM_PREFERRED_TYPE(bool)
- unsigned CmseNSCall : 1;
-
- /// Whether this function is noreturn.
- LLVM_PREFERRED_TYPE(bool)
- unsigned NoReturn : 1;
-
- /// Whether this function is returns-retained.
- LLVM_PREFERRED_TYPE(bool)
- unsigned ReturnsRetained : 1;
-
- /// Whether this function saved caller registers.
- LLVM_PREFERRED_TYPE(bool)
- unsigned NoCallerSavedRegs : 1;
-
- /// How many arguments to pass inreg.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasRegParm : 1;
- unsigned RegParm : 3;
-
- /// Whether this function has nocf_check attribute.
- LLVM_PREFERRED_TYPE(bool)
- unsigned NoCfCheck : 1;
-
- /// Log 2 of the maximum vector width.
- unsigned MaxVectorWidth : 4;
-
- RequiredArgs Required;
-
- /// 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 : 31;
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasExtParameterInfos : 1;
-
- unsigned NumArgs;
-
- ArgInfo *getArgsBuffer() {
- return getTrailingObjects<ArgInfo>();
- }
- const ArgInfo *getArgsBuffer() const {
- return getTrailingObjects<ArgInfo>();
- }
-
- ExtParameterInfo *getExtParameterInfosBuffer() {
- return getTrailingObjects<ExtParameterInfo>();
- }
- const ExtParameterInfo *getExtParameterInfosBuffer() const{
- return getTrailingObjects<ExtParameterInfo>();
- }
-
- ABIFunctionInfo() : Required(RequiredArgs::All) {}
-
-public:
- static ABIFunctionInfo *
- create(unsigned llvmCC, bool instanceMethod, bool chainCall,
- bool delegateCall, const FunctionType::ExtInfo &extInfo,
- ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType,
- ArrayRef<CanQualType> argTypes, RequiredArgs required);
- void operator delete(void *p) { ::operator delete(p); }
-
- // Friending class TrailingObjects is apparently not good enough for MSVC,
- // so these have to be public.
- friend class TrailingObjects;
- size_t numTrailingObjects(OverloadToken<ArgInfo>) const {
- return NumArgs + 1;
- }
- size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
- return (HasExtParameterInfos ? NumArgs : 0);
- }
-
- typedef const ArgInfo *const_arg_iterator;
- typedef ArgInfo *arg_iterator;
-
- MutableArrayRef<ArgInfo> arguments() {
- return MutableArrayRef<ArgInfo>(arg_begin(), NumArgs);
- }
- ArrayRef<ArgInfo> arguments() const {
- return ArrayRef<ArgInfo>(arg_begin(), NumArgs);
- }
-
- const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
- const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
- arg_iterator arg_begin() { return getArgsBuffer() + 1; }
- arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
-
- unsigned arg_size() const { return NumArgs; }
-
- bool isVariadic() const { return Required.allowsOptionalArgs(); }
- RequiredArgs getRequiredArgs() const { return Required; }
- unsigned getNumRequiredArgs() const {
- return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size();
- }
-
- bool isInstanceMethod() const { return InstanceMethod; }
-
- bool isChainCall() const { return ChainCall; }
-
- bool isDelegateCall() const { return DelegateCall; }
-
- bool isCmseNSCall() const { return CmseNSCall; }
-
- bool isNoReturn() const { return NoReturn; }
-
- /// In ARC, whether this function retains its return value. This
- /// is not always reliable for call sites.
- bool isReturnsRetained() const { return ReturnsRetained; }
-
- /// Whether this function no longer saves caller registers.
- bool isNoCallerSavedRegs() const { return NoCallerSavedRegs; }
-
- /// Whether this function has nocf_check attribute.
- bool isNoCfCheck() const { return NoCfCheck; }
-
- /// getASTCallingConvention() - Return the AST-specified calling
- /// convention.
- CallingConv getASTCallingConvention() const {
- return CallingConv(ASTCallingConvention);
- }
-
- /// getCallingConvention - Return the user specified calling
- /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
- unsigned getCallingConvention() const { return CallingConvention; }
-
- /// getEffectiveCallingConvention - Return the actual calling convention to
- /// use, which may depend on the ABI.
- unsigned getEffectiveCallingConvention() const {
- return EffectiveCallingConvention;
- }
- void setEffectiveCallingConvention(unsigned Value) {
- EffectiveCallingConvention = Value;
- }
-
- bool getHasRegParm() const { return HasRegParm; }
- unsigned getRegParm() const { return RegParm; }
-
- FunctionType::ExtInfo getExtInfo() const {
- return FunctionType::ExtInfo(isNoReturn(), getHasRegParm(), getRegParm(),
- getASTCallingConvention(), isReturnsRetained(),
- isNoCallerSavedRegs(), isNoCfCheck(),
- isCmseNSCall());
- }
-
- CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
-
- ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
- const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
-
- ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
- if (!HasExtParameterInfos) return {};
- return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs);
- }
- ExtParameterInfo getExtParameterInfo(unsigned argIndex) const {
- assert(argIndex <= NumArgs);
- if (!HasExtParameterInfos) return ExtParameterInfo();
- return getExtParameterInfos()[argIndex];
- }
-
- /// Return true if this function uses inalloca arguments.
- bool usesInAlloca() const { return ArgStruct; }
-
- /// Get the struct type used to represent all the arguments in memory.
- llvm::StructType *getArgStruct() const { return ArgStruct; }
- CharUnits getArgStructAlignment() const {
- return CharUnits::fromQuantity(ArgStructAlign);
- }
- void setArgStruct(llvm::StructType *Ty, CharUnits Align) {
- ArgStruct = Ty;
- ArgStructAlign = Align.getQuantity();
- }
-
- /// Return the maximum vector width in the arguments.
- unsigned getMaxVectorWidth() const {
- return MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0;
- }
-
- /// Set the maximum vector width in the arguments.
- void setMaxVectorWidth(unsigned Width) {
- assert(llvm::isPowerOf2_32(Width) && "Expected power of 2 vector");
- MaxVectorWidth = llvm::countr_zero(Width) + 1;
- }
-
- void Profile(llvm::FoldingSetNodeID &ID) {
- ID.AddInteger(getASTCallingConvention());
- ID.AddBoolean(InstanceMethod);
- ID.AddBoolean(ChainCall);
- ID.AddBoolean(DelegateCall);
- ID.AddBoolean(NoReturn);
- ID.AddBoolean(ReturnsRetained);
- ID.AddBoolean(NoCallerSavedRegs);
- ID.AddBoolean(HasRegParm);
- ID.AddInteger(RegParm);
- ID.AddBoolean(NoCfCheck);
- ID.AddBoolean(CmseNSCall);
- 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);
- }
- static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod,
- bool ChainCall, bool IsDelegateCall,
- const FunctionType::ExtInfo &info,
- ArrayRef<ExtParameterInfo> paramInfos,
- RequiredArgs required, CanQualType resultType,
- ArrayRef<CanQualType> argTypes) {
- ID.AddInteger(info.getCC());
- ID.AddBoolean(InstanceMethod);
- ID.AddBoolean(ChainCall);
- ID.AddBoolean(IsDelegateCall);
- ID.AddBoolean(info.getNoReturn());
- ID.AddBoolean(info.getProducesResult());
- ID.AddBoolean(info.getNoCallerSavedRegs());
- ID.AddBoolean(info.getHasRegParm());
- ID.AddInteger(info.getRegParm());
- ID.AddBoolean(info.getNoCfCheck());
- ID.AddBoolean(info.getCmseNSCall());
- 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) {
- i->Profile(ID);
- }
- }
-};
-
-} // end namespace CodeGen
-} // end namespace clang
-
-#endif
diff --git a/LLVMABI/Type.h b/LLVMABI/Type.h
index 49b070565a4ef..8348564957b29 100644
--- a/LLVMABI/Type.h
+++ b/LLVMABI/Type.h
@@ -5,9 +5,7 @@
namespace ABI{
class Type {
public:
- enum TypeClass {
-Builtin
- };
+ enum TypeClass { Builtin };
explicit Type(TypeClass TC) : Tc(TC) {}
TypeClass getTypeClass() const { return Tc; }
@@ -18,1354 +16,45 @@ Builtin
TypeClass Tc;
}
+ class ABIBuiltinType : public Type {
+ public:
+ enum Kind {
+ Void,
+ Bool,
+ Integer,
+ SignedInteger,
+ UnsignedInteger,
+ Int128,
+ FloatingPoint
+ };
-class ABIBuiltinType : public Type {
- public:
- enum Kind {
- Void,
- Bool,
- Integer,
- SignedInteger,
- UnsignedInteger,
- Int128,
- FloatingPoint
- };
+ private:
+ Kind kind;
- private:
- Kind kind;
+ public:
+ ABIBuiltinType(Kind K)
+ : Type(Builtin), kind(K){}
+ // ABIType(Kind K = Integer);
+ Kind getKind() const { return kind;}
- public:
- ABIBuiltinType(Kind K)
- : Type(Builtin), kind(K){}
- // ABIType(Kind K = Integer);
- Kind getKind() const { return kind;}
+ bool isInteger() const {
+ return getKind() == Kind::Integer || getKind() == Kind::SignedInteger || getKind() == Kind::UnsignedInteger || getKind() == Kind::Int128;
+ }
- bool isInteger() const {
- return getKind() == Kind::Integer || getKind() == Kind::SignedInteger || getKind() == Kind::UnsignedInteger || getKind() == Kind::Int128;
- }
+ bool isSignedInteger() const {
+ return getKind() == Kind::SignedInteger;
+ }
- bool isSignedInteger() const {
- return getKind() == Kind::SignedInteger;
- }
+ bool isUnsignedInteger() const {
+ return getKind() == Kind::UnsignedInteger;
+ }
- bool isUnsignedInteger() const {
- return getKind() == Kind::UnsignedInteger;
- }
+ bool isFloatingPoint() const {
+ return getKind() == Kind::FloatingPoint;
+ }
- bool isFloatingPoint() const {
- return getKind() == Kind::FloatingPoint;
}
}
-}
-
-#endif
-
-
-
-
-
-
-
-
-
-
-/// Base class that is common to both the \c ExtQuals and \c Type
-/// classes, which allows \c QualType to access the common fields between the
-/// two.
-class ExtQualsTypeCommonBase {
- friend class ExtQuals;
- friend class QualType;
- friend class Type;
- friend class ASTReader;
-
- /// The "base" type of an extended qualifiers type (\c ExtQuals) or
- /// a self-referential pointer (for \c Type).
- ///
- /// This pointer allows an efficient mapping from a QualType to its
- /// underlying type pointer.
- const Type *const BaseType;
-
- /// The canonical type of this type. A QualType.
- QualType CanonicalType;
-
- ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
- : BaseType(baseType), CanonicalType(canon) {}
-};
-
-
-
-/// We can encode up to four bits in the low bits of a
-/// type pointer, but there are many more type qualifiers that we want
-/// to be able to apply to an arbitrary type. Therefore we have this
-/// struct, intended to be heap-allocated and used by QualType to
-/// store qualifiers.
-///
-/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
-/// in three low bits on the QualType pointer; a fourth bit records whether
-/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
-/// Objective-C GC attributes) are much more rare.
-class alignas(TypeAlignment) ExtQuals : public ExtQualsTypeCommonBase,
- public llvm::FoldingSetNode {
- // NOTE: changing the fast qualifiers should be straightforward as
- // long as you don't make 'const' non-fast.
- // 1. Qualifiers:
- // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
- // Fast qualifiers must occupy the low-order bits.
- // b) Update Qualifiers::FastWidth and FastMask.
- // 2. QualType:
- // a) Update is{Volatile,Restrict}Qualified(), defined inline.
- // b) Update remove{Volatile,Restrict}, defined near the end of
- // this header.
- // 3. ASTContext:
- // a) Update get{Volatile,Restrict}Type.
-
- /// The immutable set of qualifiers applied by this node. Always contains
- /// extended qualifiers.
- Qualifiers Quals;
-
- ExtQuals *this_() { return this; }
-
-public:
- ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
- : ExtQualsTypeCommonBase(baseType,
- canon.isNull() ? QualType(this_(), 0) : canon),
- Quals(quals) {
- assert(Quals.hasNonFastQualifiers()
- && "ExtQuals created with no fast qualifiers");
- assert(!Quals.hasFastQualifiers()
- && "ExtQuals created with fast qualifiers");
- }
-
- Qualifiers getQualifiers() const { return Quals; }
-
- bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
- Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
-
- bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
- Qualifiers::ObjCLifetime getObjCLifetime() const {
- return Quals.getObjCLifetime();
- }
-
- bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
- LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
-
- const Type *getBaseType() const { return BaseType; }
-
-public:
- void Profile(llvm::FoldingSetNodeID &ID) const {
- Profile(ID, getBaseType(), Quals);
- }
-
- static void Profile(llvm::FoldingSetNodeID &ID,
- const Type *BaseType,
- Qualifiers Quals) {
- assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!");
- ID.AddPointer(BaseType);
- Quals.Profile(ID);
- }
-};
-
-
-
-/// The base class of the type hierarchy.
-///
-/// A central concept with types is that each type always has a canonical
-/// type. A canonical type is the type with any typedef names stripped out
-/// of it or the types it references. For example, consider:
-///
-/// typedef int foo;
-/// typedef foo* bar;
-/// 'int *' 'foo *' 'bar'
-///
-/// There will be a Type object created for 'int'. Since int is canonical, its
-/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
-/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
-/// there is a PointerType that represents 'int*', which, like 'int', is
-/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
-/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
-/// is also 'int*'.
-///
-/// Non-canonical types are useful for emitting diagnostics, without losing
-/// information about typedefs being used. Canonical types are useful for type
-/// comparisons (they allow by-pointer equality tests) and useful for reasoning
-/// about whether something has a particular form (e.g. is a function type),
-/// because they implicitly, recursively, strip all typedefs out of a type.
-///
-/// Types, once created, are immutable.
-///
-class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
-public:
- enum TypeClass {
-#define TYPE(Class, Base) Class,
-#define LAST_TYPE(Class) TypeLast = Class
-#define ABSTRACT_TYPE(Class, Base)
-#include "clang/AST/TypeNodes.inc"
- };
-
-private:
- /// Bitfields required by the Type class.
- class TypeBitfields {
- friend class Type;
- template <class T> friend class TypePropertyCache;
-
- /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
- LLVM_PREFERRED_TYPE(TypeClass)
- unsigned TC : 8;
-
- /// Store information on the type dependency.
- LLVM_PREFERRED_TYPE(TypeDependence)
- unsigned Dependence : llvm::BitWidth<TypeDependence>;
-
- /// True if the cache (i.e. the bitfields here starting with
- /// 'Cache') is valid.
- LLVM_PREFERRED_TYPE(bool)
- mutable unsigned CacheValid : 1;
-
- /// Linkage of this type.
- LLVM_PREFERRED_TYPE(Linkage)
- mutable unsigned CachedLinkage : 3;
-
- /// Whether this type involves and local or unnamed types.
- LLVM_PREFERRED_TYPE(bool)
- mutable unsigned CachedLocalOrUnnamed : 1;
-
- /// Whether this type comes from an AST file.
- LLVM_PREFERRED_TYPE(bool)
- mutable unsigned FromAST : 1;
-
- bool isCacheValid() const {
- return CacheValid;
- }
-
- Linkage getLinkage() const {
- assert(isCacheValid() && "getting linkage from invalid cache");
- return static_cast<Linkage>(CachedLinkage);
- }
-
- bool hasLocalOrUnnamedType() const {
- assert(isCacheValid() && "getting linkage from invalid cache");
- return CachedLocalOrUnnamed;
- }
- };
- enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
-
-protected:
- // These classes allow subclasses to somewhat cleanly pack bitfields
- // into Type.
-
- class ArrayTypeBitfields {
- friend class ArrayType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// CVR qualifiers from declarations like
- /// 'int X[static restrict 4]'. For function parameters only.
- LLVM_PREFERRED_TYPE(Qualifiers)
- unsigned IndexTypeQuals : 3;
-
- /// Storage class qualifiers from declarations like
- /// 'int X[static restrict 4]'. For function parameters only.
- LLVM_PREFERRED_TYPE(ArraySizeModifier)
- unsigned SizeModifier : 3;
- };
- enum { NumArrayTypeBits = NumTypeBits + 6 };
-
- class ConstantArrayTypeBitfields {
- friend class ConstantArrayType;
-
- LLVM_PREFERRED_TYPE(ArrayTypeBitfields)
- unsigned : NumArrayTypeBits;
-
- /// Whether we have a stored size expression.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasExternalSize : 1;
-
- LLVM_PREFERRED_TYPE(unsigned)
- unsigned SizeWidth : 5;
- };
-
- class BuiltinTypeBitfields {
- friend class BuiltinType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The kind (BuiltinType::Kind) of builtin type this is.
- static constexpr unsigned NumOfBuiltinTypeBits = 9;
- unsigned Kind : NumOfBuiltinTypeBits;
- };
-
-public:
- static constexpr int FunctionTypeNumParamsWidth = 16;
- static constexpr int FunctionTypeNumParamsLimit = (1 << 16) - 1;
-
-protected:
- /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
- /// Only common bits are stored here. Additional uncommon bits are stored
- /// in a trailing object after FunctionProtoType.
- class FunctionTypeBitfields {
- friend class FunctionProtoType;
- friend class FunctionType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The ref-qualifier associated with a \c FunctionProtoType.
- ///
- /// This is a value of type \c RefQualifierKind.
- LLVM_PREFERRED_TYPE(RefQualifierKind)
- unsigned RefQualifier : 2;
-
- /// Used only by FunctionProtoType, put here to pack with the
- /// other bitfields.
- /// The qualifiers are part of FunctionProtoType because...
- ///
- /// C++ 8.3.5p4: The return type, the parameter type list and the
- /// cv-qualifier-seq, [...], are part of the function type.
- LLVM_PREFERRED_TYPE(Qualifiers)
- unsigned FastTypeQuals : Qualifiers::FastWidth;
- /// Whether this function has extended Qualifiers.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasExtQuals : 1;
-
- /// The type of exception specification this function has.
- LLVM_PREFERRED_TYPE(ExceptionSpecificationType)
- unsigned ExceptionSpecType : 4;
-
- /// Whether this function has extended parameter information.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasExtParameterInfos : 1;
-
- /// Whether this function has extra bitfields for the prototype.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasExtraBitfields : 1;
-
- /// Whether the function is variadic.
- LLVM_PREFERRED_TYPE(bool)
- unsigned Variadic : 1;
-
- /// Whether this function has a trailing return type.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasTrailingReturn : 1;
-
- /// Extra information which affects how the function is called, like
- /// regparm and the calling convention.
- LLVM_PREFERRED_TYPE(CallingConv)
- unsigned ExtInfo : 14;
-
- /// The number of parameters this function has, not counting '...'.
- /// According to [implimits] 8 bits should be enough here but this is
- /// somewhat easy to exceed with metaprogramming and so we would like to
- /// keep NumParams as wide as reasonably possible.
- unsigned NumParams : FunctionTypeNumParamsWidth;
- };
-
- class ObjCObjectTypeBitfields {
- friend class ObjCObjectType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The number of type arguments stored directly on this object type.
- unsigned NumTypeArgs : 7;
-
- /// The number of protocols stored directly on this object type.
- unsigned NumProtocols : 6;
-
- /// Whether this is a "kindof" type.
- LLVM_PREFERRED_TYPE(bool)
- unsigned IsKindOf : 1;
- };
-
- class ReferenceTypeBitfields {
- friend class ReferenceType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// True if the type was originally spelled with an lvalue sigil.
- /// This is never true of rvalue references but can also be false
- /// on lvalue references because of C++0x [dcl.typedef]p9,
- /// as follows:
- ///
- /// typedef int &ref; // lvalue, spelled lvalue
- /// typedef int &&rvref; // rvalue
- /// ref &a; // lvalue, inner ref, spelled lvalue
- /// ref &&a; // lvalue, inner ref
- /// rvref &a; // lvalue, inner ref, spelled lvalue
- /// rvref &&a; // rvalue, inner ref
- LLVM_PREFERRED_TYPE(bool)
- unsigned SpelledAsLValue : 1;
-
- /// True if the inner type is a reference type. This only happens
- /// in non-canonical forms.
- LLVM_PREFERRED_TYPE(bool)
- unsigned InnerRef : 1;
- };
-
- class TypeWithKeywordBitfields {
- friend class TypeWithKeyword;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// An ElaboratedTypeKeyword. 8 bits for efficient access.
- LLVM_PREFERRED_TYPE(ElaboratedTypeKeyword)
- unsigned Keyword : 8;
- };
-
- enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
-
- class ElaboratedTypeBitfields {
- friend class ElaboratedType;
-
- LLVM_PREFERRED_TYPE(TypeWithKeywordBitfields)
- unsigned : NumTypeWithKeywordBits;
-
- /// Whether the ElaboratedType has a trailing OwnedTagDecl.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasOwnedTagDecl : 1;
- };
-
- class VectorTypeBitfields {
- friend class VectorType;
- friend class DependentVectorType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The kind of vector, either a generic vector type or some
- /// target-specific vector type such as for AltiVec or Neon.
- LLVM_PREFERRED_TYPE(VectorKind)
- unsigned VecKind : 4;
- /// The number of elements in the vector.
- uint32_t NumElements;
- };
-
- class AttributedTypeBitfields {
- friend class AttributedType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- LLVM_PREFERRED_TYPE(attr::Kind)
- unsigned AttrKind : 32 - NumTypeBits;
- };
-
- class AutoTypeBitfields {
- friend class AutoType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
- /// or '__auto_type'? AutoTypeKeyword value.
- LLVM_PREFERRED_TYPE(AutoTypeKeyword)
- unsigned Keyword : 2;
-
- /// The number of template arguments in the type-constraints, which is
- /// expected to be able to hold at least 1024 according to [implimits].
- /// However as this limit is somewhat easy to hit with template
- /// metaprogramming we'd prefer to keep it as large as possible.
- /// At the moment it has been left as a non-bitfield since this type
- /// safely fits in 64 bits as an unsigned, so there is no reason to
- /// introduce the performance impact of a bitfield.
- unsigned NumArgs;
- };
-
- class TypeOfBitfields {
- friend class TypeOfType;
- friend class TypeOfExprType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
- LLVM_PREFERRED_TYPE(TypeOfKind)
- unsigned Kind : 1;
- };
-
- class UsingBitfields {
- friend class UsingType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// True if the underlying type is different from the declared one.
- LLVM_PREFERRED_TYPE(bool)
- unsigned hasTypeDifferentFromDecl : 1;
- };
-
- class TypedefBitfields {
- friend class TypedefType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// True if the underlying type is different from the declared one.
- LLVM_PREFERRED_TYPE(bool)
- unsigned hasTypeDifferentFromDecl : 1;
- };
-
- class TemplateTypeParmTypeBitfields {
- friend class TemplateTypeParmType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The depth of the template parameter.
- unsigned Depth : 15;
-
- /// Whether this is a template parameter pack.
- LLVM_PREFERRED_TYPE(bool)
- unsigned ParameterPack : 1;
-
- /// The index of the template parameter.
- unsigned Index : 16;
- };
-
- class SubstTemplateTypeParmTypeBitfields {
- friend class SubstTemplateTypeParmType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasNonCanonicalUnderlyingType : 1;
-
- LLVM_PREFERRED_TYPE(SubstTemplateTypeParmTypeFlag)
- unsigned SubstitutionFlag : 1;
-
- // The index of the template parameter this substitution represents.
- unsigned Index : 15;
-
- /// Represents the index within a pack if this represents a substitution
- /// from a pack expansion. This index starts at the end of the pack and
- /// increments towards the beginning.
- /// Positive non-zero number represents the index + 1.
- /// Zero means this is not substituted from an expansion.
- unsigned PackIndex : 16;
- };
-
- class SubstTemplateTypeParmPackTypeBitfields {
- friend class SubstTemplateTypeParmPackType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- // The index of the template parameter this substitution represents.
- unsigned Index : 16;
-
- /// The number of template arguments in \c Arguments, which is
- /// expected to be able to hold at least 1024 according to [implimits].
- /// However as this limit is somewhat easy to hit with template
- /// metaprogramming we'd prefer to keep it as large as possible.
- unsigned NumArgs : 16;
- };
-
- class TemplateSpecializationTypeBitfields {
- friend class TemplateSpecializationType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// Whether this template specialization type is a substituted type alias.
- LLVM_PREFERRED_TYPE(bool)
- unsigned TypeAlias : 1;
-
- /// The number of template arguments named in this class template
- /// specialization, which is expected to be able to hold at least 1024
- /// according to [implimits]. However, as this limit is somewhat easy to
- /// hit with template metaprogramming we'd prefer to keep it as large
- /// as possible. At the moment it has been left as a non-bitfield since
- /// this type safely fits in 64 bits as an unsigned, so there is no reason
- /// to introduce the performance impact of a bitfield.
- unsigned NumArgs;
- };
-
- class DependentTemplateSpecializationTypeBitfields {
- friend class DependentTemplateSpecializationType;
-
- LLVM_PREFERRED_TYPE(TypeWithKeywordBitfields)
- unsigned : NumTypeWithKeywordBits;
-
- /// The number of template arguments named in this class template
- /// specialization, which is expected to be able to hold at least 1024
- /// according to [implimits]. However, as this limit is somewhat easy to
- /// hit with template metaprogramming we'd prefer to keep it as large
- /// as possible. At the moment it has been left as a non-bitfield since
- /// this type safely fits in 64 bits as an unsigned, so there is no reason
- /// to introduce the performance impact of a bitfield.
- unsigned NumArgs;
- };
-
- class PackExpansionTypeBitfields {
- friend class PackExpansionType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- /// The number of expansions that this pack expansion will
- /// generate when substituted (+1), which is expected to be able to
- /// hold at least 1024 according to [implimits]. However, as this limit
- /// is somewhat easy to hit with template metaprogramming we'd prefer to
- /// keep it as large as possible. At the moment it has been left as a
- /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
- /// there is no reason to introduce the performance impact of a bitfield.
- ///
- /// This field will only have a non-zero value when some of the parameter
- /// packs that occur within the pattern have been substituted but others
- /// have not.
- unsigned NumExpansions;
- };
-
- class CountAttributedTypeBitfields {
- friend class CountAttributedType;
-
- LLVM_PREFERRED_TYPE(TypeBitfields)
- unsigned : NumTypeBits;
-
- static constexpr unsigned NumCoupledDeclsBits = 4;
- unsigned NumCoupledDecls : NumCoupledDeclsBits;
- LLVM_PREFERRED_TYPE(bool)
- unsigned CountInBytes : 1;
- LLVM_PREFERRED_TYPE(bool)
- unsigned OrNull : 1;
- };
- static_assert(sizeof(CountAttributedTypeBitfields) <= sizeof(unsigned));
-
- union {
- TypeBitfields TypeBits;
- ArrayTypeBitfields ArrayTypeBits;
- ConstantArrayTypeBitfields ConstantArrayTypeBits;
- AttributedTypeBitfields AttributedTypeBits;
- AutoTypeBitfields AutoTypeBits;
- TypeOfBitfields TypeOfBits;
- TypedefBitfields TypedefBits;
- UsingBitfields UsingBits;
- BuiltinTypeBitfields BuiltinTypeBits;
- FunctionTypeBitfields FunctionTypeBits;
- ObjCObjectTypeBitfields ObjCObjectTypeBits;
- ReferenceTypeBitfields ReferenceTypeBits;
- TypeWithKeywordBitfields TypeWithKeywordBits;
- ElaboratedTypeBitfields ElaboratedTypeBits;
- VectorTypeBitfields VectorTypeBits;
- TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits;
- SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits;
- SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
- TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
- DependentTemplateSpecializationTypeBitfields
- DependentTemplateSpecializationTypeBits;
- PackExpansionTypeBitfields PackExpansionTypeBits;
- CountAttributedTypeBitfields CountAttributedTypeBits;
- };
-
-private:
- template <class T> friend class TypePropertyCache;
-
- /// Set whether this type comes from an AST file.
- void setFromAST(bool V = true) const {
- TypeBits.FromAST = V;
- }
-
-protected:
- friend class ASTContext;
-
- Type(TypeClass tc, QualType canon, TypeDependence Dependence)
- : ExtQualsTypeCommonBase(this,
- canon.isNull() ? QualType(this_(), 0) : canon) {
- static_assert(sizeof(*this) <=
- alignof(decltype(*this)) + sizeof(ExtQualsTypeCommonBase),
- "changing bitfields changed sizeof(Type)!");
- static_assert(alignof(decltype(*this)) % TypeAlignment == 0,
- "Insufficient alignment!");
- TypeBits.TC = tc;
- TypeBits.Dependence = static_cast<unsigned>(Dependence);
- TypeBits.CacheValid = false;
- TypeBits.CachedLocalOrUnnamed = false;
- TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
- TypeBits.FromAST = false;
- }
-
- // silence VC++ warning C4355: 'this' : used in base member initializer list
- Type *this_() { return this; }
-
- void setDependence(TypeDependence D) {
- TypeBits.Dependence = static_cast<unsigned>(D);
- }
-
- void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
-
-public:
- friend class ASTReader;
- friend class ASTWriter;
- template <class T> friend class serialization::AbstractTypeReader;
- template <class T> friend class serialization::AbstractTypeWriter;
-
- Type(const Type &) = delete;
- Type(Type &&) = delete;
- Type &operator=(const Type &) = delete;
- Type &operator=(Type &&) = delete;
-
- TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
-
- /// Whether this type comes from an AST file.
- bool isFromAST() const { return TypeBits.FromAST; }
-
- /// Whether this type is or contains an unexpanded parameter
- /// pack, used to support C++0x variadic templates.
- ///
- /// A type that contains a parameter pack shall be expanded by the
- /// ellipsis operator at some point. For example, the typedef in the
- /// following example contains an unexpanded parameter pack 'T':
- ///
- /// \code
- /// template<typename ...T>
- /// struct X {
- /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
- /// };
- /// \endcode
- ///
- /// Note that this routine does not specify which
- bool containsUnexpandedParameterPack() const {
- return getDependence() & TypeDependence::UnexpandedPack;
- }
-
- /// Determines if this type would be canonical if it had no further
- /// qualification.
- bool isCanonicalUnqualified() const {
- return CanonicalType == QualType(this, 0);
- }
-
- /// Pull a single level of sugar off of this locally-unqualified type.
- /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
- /// or QualType::getSingleStepDesugaredType(const ASTContext&).
- QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
-
- /// As an extension, we classify types as one of "sized" or "sizeless";
- /// every type is one or the other. Standard types are all sized;
- /// sizeless types are purely an extension.
- ///
- /// Sizeless types contain data with no specified size, alignment,
- /// or layout.
- bool isSizelessType() const;
- bool isSizelessBuiltinType() const;
-
- /// Returns true for all scalable vector types.
- bool isSizelessVectorType() const;
-
- /// Returns true for SVE scalable vector types.
- bool isSVESizelessBuiltinType() const;
-
- /// Returns true for RVV scalable vector types.
- bool isRVVSizelessBuiltinType() const;
-
- /// Check if this is a WebAssembly Externref Type.
- bool isWebAssemblyExternrefType() const;
-
- /// Returns true if this is a WebAssembly table type: either an array of
- /// reference types, or a pointer to a reference type (which can only be
- /// created by array to pointer decay).
- bool isWebAssemblyTableType() const;
-
- /// Determines if this is a sizeless type supported by the
- /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
- /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
- bool isSveVLSBuiltinType() const;
-
- /// Returns the representative type for the element of an SVE builtin type.
- /// This is used to represent fixed-length SVE vectors created with the
- /// 'arm_sve_vector_bits' type attribute as VectorType.
- QualType getSveEltType(const ASTContext &Ctx) const;
-
- /// Determines if this is a sizeless type supported by the
- /// 'riscv_rvv_vector_bits' type attribute, which can be applied to a single
- /// RVV vector or mask.
- bool isRVVVLSBuiltinType() const;
-
- /// Returns the representative type for the element of an RVV builtin type.
- /// This is used to represent fixed-length RVV vectors created with the
- /// 'riscv_rvv_vector_bits' type attribute as VectorType.
- QualType getRVVEltType(const ASTContext &Ctx) const;
-
- /// Returns the representative type for the element of a sizeless vector
- /// builtin type.
- QualType getSizelessVectorEltType(const ASTContext &Ctx) const;
-
- /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
- /// object types, function types, and incomplete types.
-
- /// Return true if this is an incomplete type.
- /// A type that can describe objects, but which lacks information needed to
- /// determine its size (e.g. void, or a fwd declared struct). Clients of this
- /// routine will need to determine if the size is actually required.
- ///
- /// Def If non-null, and the type refers to some kind of declaration
- /// that can be completed (such as a C struct, C++ class, or Objective-C
- /// class), will be set to the declaration.
- bool isIncompleteType(NamedDecl **Def = nullptr) const;
-
- /// Return true if this is an incomplete or object
- /// type, in other words, not a function type.
- bool isIncompleteOrObjectType() const {
- return !isFunctionType();
- }
-
- /// Determine whether this type is an object type.
- bool isObjectType() const {
- // C++ [basic.types]p8:
- // An object type is a (possibly cv-qualified) type that is not a
- // function type, not a reference type, and not a void type.
- return !isReferenceType() && !isFunctionType() && !isVoidType();
- }
-
- /// Return true if this is a literal type
- /// (C++11 [basic.types]p10)
- bool isLiteralType(const ASTContext &Ctx) const;
-
- /// Determine if this type is a structural type, per C++20 [temp.param]p7.
- bool isStructuralType() const;
-
- /// Test if this type is a standard-layout type.
- /// (C++0x [basic.type]p9)
- bool isStandardLayoutType() const;
-
- /// Helper methods to distinguish type categories. All type predicates
- /// operate on the canonical type, ignoring typedefs and qualifiers.
-
- /// Returns true if the type is a builtin type.
- bool isBuiltinType() const;
-
- /// Test for a particular builtin type.
- bool isSpecificBuiltinType(unsigned K) const;
-
- /// Test for a type which does not represent an actual type-system type but
- /// is instead used as a placeholder for various convenient purposes within
- /// Clang. All such types are BuiltinTypes.
- bool isPlaceholderType() const;
- const BuiltinType *getAsPlaceholderType() const;
-
- /// Test for a specific placeholder type.
- bool isSpecificPlaceholderType(unsigned K) const;
-
- /// Test for a placeholder type other than Overload; see
- /// BuiltinType::isNonOverloadPlaceholderType.
- bool isNonOverloadPlaceholderType() const;
-
- /// isIntegerType() does *not* include complex integers (a GCC extension).
- /// isComplexIntegerType() can be used to test for complex integers.
- bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
- bool isEnumeralType() const;
-
- /// Determine whether this type is a scoped enumeration type.
- bool isScopedEnumeralType() const;
- bool isBooleanType() const;
- bool isCharType() const;
- bool isWideCharType() const;
- bool isChar8Type() const;
- bool isChar16Type() const;
- bool isChar32Type() const;
- bool isAnyCharacterType() const;
- bool isIntegralType(const ASTContext &Ctx) const;
-
- /// Determine whether this type is an integral or enumeration type.
- bool isIntegralOrEnumerationType() const;
-
- /// Determine whether this type is an integral or unscoped enumeration type.
- bool isIntegralOrUnscopedEnumerationType() const;
- bool isUnscopedEnumerationType() const;
-
- /// Floating point categories.
- bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
- /// isComplexType() does *not* include complex integers (a GCC extension).
- /// isComplexIntegerType() can be used to test for complex integers.
- bool isComplexType() const; // C99 6.2.5p11 (complex)
- bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
- bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
- bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
- bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
- bool isFloat32Type() const;
- bool isDoubleType() const;
- bool isBFloat16Type() const;
- bool isMFloat8Type() const;
- bool isFloat128Type() const;
- bool isIbm128Type() const;
- bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
- bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
- bool isVoidType() const; // C99 6.2.5p19
- bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
- bool isAggregateType() const;
- bool isFundamentalType() const;
- bool isCompoundType() const;
-
- // Type Predicates: Check to see if this type is structurally the specified
- // type, ignoring typedefs and qualifiers.
- bool isFunctionType() const;
- bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
- bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
- bool isPointerType() const;
- bool isPointerOrReferenceType() const;
- bool isSignableType() const;
- bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
- bool isCountAttributedType() const;
- bool isBlockPointerType() const;
- bool isVoidPointerType() const;
- bool isReferenceType() const;
- bool isLValueReferenceType() const;
- bool isRValueReferenceType() const;
- bool isObjectPointerType() const;
- bool isFunctionPointerType() const;
- bool isFunctionReferenceType() const;
- bool isMemberPointerType() const;
- bool isMemberFunctionPointerType() const;
- bool isMemberDataPointerType() const;
- bool isArrayType() const;
- bool isConstantArrayType() const;
- bool isIncompleteArrayType() const;
- bool isVariableArrayType() const;
- bool isArrayParameterType() const;
- bool isDependentSizedArrayType() const;
- bool isRecordType() const;
- bool isClassType() const;
- bool isStructureType() const;
- bool isStructureTypeWithFlexibleArrayMember() const;
- bool isObjCBoxableRecordType() const;
- bool isInterfaceType() const;
- bool isStructureOrClassType() const;
- bool isUnionType() const;
- bool isComplexIntegerType() const; // GCC _Complex integer type.
- bool isVectorType() const; // GCC vector type.
- bool isExtVectorType() const; // Extended vector type.
- bool isExtVectorBoolType() const; // Extended vector type with bool element.
- // Extended vector type with bool element that is packed. HLSL doesn't pack
- // its bool vectors.
- bool isPackedVectorBoolType(const ASTContext &ctx) const;
- bool isSubscriptableVectorType() const;
- bool isMatrixType() const; // Matrix type.
- bool isConstantMatrixType() const; // Constant matrix type.
- bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
- bool isObjCObjectPointerType() const; // pointer to ObjC object
- bool isObjCRetainableType() const; // ObjC object or block pointer
- bool isObjCLifetimeType() const; // (array of)* retainable type
- bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
- bool isObjCNSObjectType() const; // __attribute__((NSObject))
- bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
- // FIXME: change this to 'raw' interface type, so we can used 'interface' type
- // for the common case.
- bool isObjCObjectType() const; // NSString or typeof(*(id)0)
- bool isObjCQualifiedInterfaceType() const; // NSString<foo>
- bool isObjCQualifiedIdType() const; // id<foo>
- bool isObjCQualifiedClassType() const; // Class<foo>
- bool isObjCObjectOrInterfaceType() const;
- bool isObjCIdType() const; // id
- bool isDecltypeType() const;
- /// Was this type written with the special inert-in-ARC __unsafe_unretained
- /// qualifier?
- ///
- /// This approximates the answer to the following question: if this
- /// translation unit were compiled in ARC, would this type be qualified
- /// with __unsafe_unretained?
- bool isObjCInertUnsafeUnretainedType() const {
- return hasAttr(attr::ObjCInertUnsafeUnretained);
- }
-
- /// Whether the type is Objective-C 'id' or a __kindof type of an
- /// object type, e.g., __kindof NSView * or __kindof id
- /// <NSCopying>.
- ///
- /// \param bound Will be set to the bound on non-id subtype types,
- /// which will be (possibly specialized) Objective-C class type, or
- /// null for 'id.
- bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
- const ObjCObjectType *&bound) const;
-
- bool isObjCClassType() const; // Class
-
- /// Whether the type is Objective-C 'Class' or a __kindof type of an
- /// Class type, e.g., __kindof Class <NSCopying>.
- ///
- /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
- /// here because Objective-C's type system cannot express "a class
- /// object for a subclass of NSFoo".
- bool isObjCClassOrClassKindOfType() const;
-
- bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
- bool isObjCSelType() const; // Class
- bool isObjCBuiltinType() const; // 'id' or 'Class'
- bool isObjCARCBridgableType() const;
- bool isCARCBridgableType() const;
- bool isTemplateTypeParmType() const; // C++ template type parameter
- bool isNullPtrType() const; // C++11 std::nullptr_t or
- // C23 nullptr_t
- bool isNothrowT() const; // C++ std::nothrow_t
- bool isAlignValT() const; // C++17 std::align_val_t
- bool isStdByteType() const; // C++17 std::byte
- bool isAtomicType() const; // C11 _Atomic()
- bool isUndeducedAutoType() const; // C++11 auto or
- // C++14 decltype(auto)
- bool isTypedefNameType() const; // typedef or alias template
-
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
- bool is##Id##Type() const;
-#include "clang/Basic/OpenCLImageTypes.def"
-
- bool isImageType() const; // Any OpenCL image type
-
- bool isSamplerT() const; // OpenCL sampler_t
- bool isEventT() const; // OpenCL event_t
- bool isClkEventT() const; // OpenCL clk_event_t
- bool isQueueT() const; // OpenCL queue_t
- bool isReserveIDT() const; // OpenCL reserve_id_t
-
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- bool is##Id##Type() const;
-#include "clang/Basic/OpenCLExtensionTypes.def"
- // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
- bool isOCLIntelSubgroupAVCType() const;
- bool isOCLExtOpaqueType() const; // Any OpenCL extension type
-
- bool isPipeType() const; // OpenCL pipe type
- bool isBitIntType() const; // Bit-precise integer type
- bool isOpenCLSpecificType() const; // Any OpenCL specific type
-
-#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) bool is##Id##Type() const;
-#include "clang/Basic/HLSLIntangibleTypes.def"
- bool isHLSLSpecificType() const; // Any HLSL specific type
- bool isHLSLBuiltinIntangibleType() const; // Any HLSL builtin intangible type
- bool isHLSLAttributedResourceType() const;
- bool isHLSLResourceRecord() const;
- bool isHLSLIntangibleType()
- const; // Any HLSL intangible type (builtin, array, class)
-
- /// Determines if this type, which must satisfy
- /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
- /// than implicitly __strong.
- bool isObjCARCImplicitlyUnretainedType() const;
-
- /// Check if the type is the CUDA device builtin surface type.
- bool isCUDADeviceBuiltinSurfaceType() const;
- /// Check if the type is the CUDA device builtin texture type.
- bool isCUDADeviceBuiltinTextureType() const;
-
- /// Return the implicit lifetime for this type, which must not be dependent.
- Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
-
- enum ScalarTypeKind {
- STK_CPointer,
- STK_BlockPointer,
- STK_ObjCObjectPointer,
- STK_MemberPointer,
- STK_Bool,
- STK_Integral,
- STK_Floating,
- STK_IntegralComplex,
- STK_FloatingComplex,
- STK_FixedPoint
- };
-
- /// Given that this is a scalar type, classify it.
- ScalarTypeKind getScalarTypeKind() const;
-
- TypeDependence getDependence() const {
- return static_cast<TypeDependence>(TypeBits.Dependence);
- }
-
- /// Whether this type is an error type.
- bool containsErrors() const {
- return getDependence() & TypeDependence::Error;
- }
-
- /// Whether this type is a dependent type, meaning that its definition
- /// somehow depends on a template parameter (C++ [temp.dep.type]).
- bool isDependentType() const {
- return getDependence() & TypeDependence::Dependent;
- }
-
- /// Determine whether this type is an instantiation-dependent type,
- /// meaning that the type involves a template parameter (even if the
- /// definition does not actually depend on the type substituted for that
- /// template parameter).
- bool isInstantiationDependentType() const {
- return getDependence() & TypeDependence::Instantiation;
- }
-
- /// Determine whether this type is an undeduced type, meaning that
- /// it somehow involves a C++11 'auto' type or similar which has not yet been
- /// deduced.
- bool isUndeducedType() const;
-
- /// Whether this type is a variably-modified type (C99 6.7.5).
- bool isVariablyModifiedType() const {
- return getDependence() & TypeDependence::VariablyModified;
- }
-
- /// Whether this type involves a variable-length array type
- /// with a definite size.
- bool hasSizedVLAType() const;
-
- /// Whether this type is or contains a local or unnamed type.
- bool hasUnnamedOrLocalType() const;
-
- bool isOverloadableType() const;
-
- /// Determine wither this type is a C++ elaborated-type-specifier.
- bool isElaboratedTypeSpecifier() const;
-
- bool canDecayToPointerType() const;
-
- /// Whether this type is represented natively as a pointer. This includes
- /// pointers, references, block pointers, and Objective-C interface,
- /// qualified id, and qualified interface types, as well as nullptr_t.
- bool hasPointerRepresentation() const;
-
- /// Whether this type can represent an objective pointer type for the
- /// purpose of GC'ability
- bool hasObjCPointerRepresentation() const;
-
- /// Determine whether this type has an integer representation
- /// of some sort, e.g., it is an integer type or a vector.
- bool hasIntegerRepresentation() const;
-
- /// Determine whether this type has an signed integer representation
- /// of some sort, e.g., it is an signed integer type or a vector.
- bool hasSignedIntegerRepresentation() const;
-
- /// Determine whether this type has an unsigned integer representation
- /// of some sort, e.g., it is an unsigned integer type or a vector.
- bool hasUnsignedIntegerRepresentation() const;
-
- /// Determine whether this type has a floating-point representation
- /// of some sort, e.g., it is a floating-point type or a vector thereof.
- bool hasFloatingRepresentation() const;
-
- // Type Checking Functions: Check to see if this type is structurally the
- // specified type, ignoring typedefs and qualifiers, and return a pointer to
- // the best type we can.
- const RecordType *getAsStructureType() const;
- /// NOTE: getAs*ArrayType are methods on ASTContext.
- const RecordType *getAsUnionType() const;
- const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
- const ObjCObjectType *getAsObjCInterfaceType() const;
-
- // The following is a convenience method that returns an ObjCObjectPointerType
- // for object declared using an interface.
- const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
- const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
- const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
- const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
-
- /// Retrieves the CXXRecordDecl that this type refers to, either
- /// because the type is a RecordType or because it is the injected-class-name
- /// type of a class template or class template partial specialization.
- CXXRecordDecl *getAsCXXRecordDecl() const;
-
- /// Retrieves the RecordDecl this type refers to.
- RecordDecl *getAsRecordDecl() const;
-
- /// Retrieves the TagDecl that this type refers to, either
- /// because the type is a TagType or because it is the injected-class-name
- /// type of a class template or class template partial specialization.
- TagDecl *getAsTagDecl() const;
-
- /// If this is a pointer or reference to a RecordType, return the
- /// CXXRecordDecl that the type refers to.
- ///
- /// If this is not a pointer or reference, or the type being pointed to does
- /// not refer to a CXXRecordDecl, returns NULL.
- const CXXRecordDecl *getPointeeCXXRecordDecl() const;
-
- /// Get the DeducedType whose type will be deduced for a variable with
- /// an initializer of this type. This looks through declarators like pointer
- /// types, but not through decltype or typedefs.
- DeducedType *getContainedDeducedType() const;
-
- /// Get the AutoType whose type will be deduced for a variable with
- /// an initializer of this type. This looks through declarators like pointer
- /// types, but not through decltype or typedefs.
- AutoType *getContainedAutoType() const {
- return dyn_cast_or_null<AutoType>(getContainedDeducedType());
- }
-
- /// Determine whether this type was written with a leading 'auto'
- /// corresponding to a trailing return type (possibly for a nested
- /// function type within a pointer to function type or similar).
- bool hasAutoForTrailingReturnType() const;
-
- /// Member-template getAs<specific type>'. Look through sugar for
- /// an instance of \<specific type>. This scheme will eventually
- /// replace the specific getAsXXXX methods above.
- ///
- /// There are some specializations of this member template listed
- /// immediately following this class.
- template <typename T> const T *getAs() const;
-
- /// Member-template getAsAdjusted<specific type>. Look through specific kinds
- /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
- /// This is used when you need to walk over sugar nodes that represent some
- /// kind of type adjustment from a type that was written as a \<specific type>
- /// to another type that is still canonically a \<specific type>.
- template <typename T> const T *getAsAdjusted() const;
-
- /// A variant of getAs<> for array types which silently discards
- /// qualifiers from the outermost type.
- const ArrayType *getAsArrayTypeUnsafe() const;
-
- /// Member-template castAs<specific type>. Look through sugar for
- /// the underlying instance of \<specific type>.
- ///
- /// This method has the same relationship to getAs<T> as cast<T> has
- /// to dyn_cast<T>; which is to say, the underlying type *must*
- /// have the intended type, and this method will never return null.
- template <typename T> const T *castAs() const;
-
- /// A variant of castAs<> for array type which silently discards
- /// qualifiers from the outermost type.
- const ArrayType *castAsArrayTypeUnsafe() const;
-
- /// Determine whether this type had the specified attribute applied to it
- /// (looking through top-level type sugar).
- bool hasAttr(attr::Kind AK) const;
-
- /// Get the base element type of this type, potentially discarding type
- /// qualifiers. This should never be used when type qualifiers
- /// are meaningful.
- const Type *getBaseElementTypeUnsafe() const;
-
- /// If this is an array type, return the element type of the array,
- /// potentially with type qualifiers missing.
- /// This should never be used when type qualifiers are meaningful.
- const Type *getArrayElementTypeNoTypeQual() const;
-
- /// If this is a pointer type, return the pointee type.
- /// If this is an array type, return the array element type.
- /// This should never be used when type qualifiers are meaningful.
- const Type *getPointeeOrArrayElementType() const;
-
- /// If this is a pointer, ObjC object pointer, or block
- /// pointer, this returns the respective pointee.
- QualType getPointeeType() const;
-
- /// Return the specified type with any "sugar" removed from the type,
- /// removing any typedefs, typeofs, etc., as well as any qualifiers.
- const Type *getUnqualifiedDesugaredType() const;
-
- /// Return true if this is an integer type that is
- /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
- /// or an enum decl which has a signed representation.
- bool isSignedIntegerType() const;
-
- /// Return true if this is an integer type that is
- /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
- /// or an enum decl which has an unsigned representation.
- bool isUnsignedIntegerType() const;
-
- /// Determines whether this is an integer type that is signed or an
- /// enumeration types whose underlying type is a signed integer type.
- bool isSignedIntegerOrEnumerationType() const;
-
- /// Determines whether this is an integer type that is unsigned or an
- /// enumeration types whose underlying type is a unsigned integer type.
- bool isUnsignedIntegerOrEnumerationType() const;
-
- /// Return true if this is a fixed point type according to
- /// ISO/IEC JTC1 SC22 WG14 N1169.
- bool isFixedPointType() const;
-
- /// Return true if this is a fixed point or integer type.
- bool isFixedPointOrIntegerType() const;
-
- /// Return true if this can be converted to (or from) a fixed point type.
- bool isConvertibleToFixedPointType() const;
-
- /// Return true if this is a saturated fixed point type according to
- /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
- bool isSaturatedFixedPointType() const;
-
- /// Return true if this is a saturated fixed point type according to
- /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
- bool isUnsaturatedFixedPointType() const;
-
- /// Return true if this is a fixed point type that is signed according
- /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
- bool isSignedFixedPointType() const;
-
- /// Return true if this is a fixed point type that is unsigned according
- /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
- bool isUnsignedFixedPointType() const;
-
- /// Return true if this is not a variable sized type,
- /// according to the rules of C99 6.7.5p3. It is not legal to call this on
- /// incomplete types.
- bool isConstantSizeType() const;
-
- /// Returns true if this type can be represented by some
- /// set of type specifiers.
- bool isSpecifierType() const;
-
- /// Determine the linkage of this type.
- Linkage getLinkage() const;
-
- /// Determine the visibility of this type.
- Visibility getVisibility() const {
- return getLinkageAndVisibility().getVisibility();
- }
-
- /// Return true if the visibility was explicitly set is the code.
- bool isVisibilityExplicit() const {
- return getLinkageAndVisibility().isVisibilityExplicit();
- }
-
- /// Determine the linkage and visibility of this type.
- LinkageInfo getLinkageAndVisibility() const;
-
- /// True if the computed linkage is valid. Used for consistency
- /// checking. Should always return true.
- bool isLinkageValid() const;
-
- /// Determine the nullability of the given type.
- ///
- /// Note that nullability is only captured as sugar within the type
- /// system, not as part of the canonical type, so nullability will
- /// be lost by canonicalization and desugaring.
- std::optional<NullabilityKind> getNullability() const;
-
- /// Determine whether the given type can have a nullability
- /// specifier applied to it, i.e., if it is any kind of pointer type.
- ///
- /// \param ResultIfUnknown The value to return if we don't yet know whether
- /// this type can have nullability because it is dependent.
- bool canHaveNullability(bool ResultIfUnknown = true) const;
-
- /// Retrieve the set of substitutions required when accessing a member
- /// of the Objective-C receiver type that is declared in the given context.
- ///
- /// \c *this is the type of the object we're operating on, e.g., the
- /// receiver for a message send or the base of a property access, and is
- /// expected to be of some object or object pointer type.
- ///
- /// \param dc The declaration context for which we are building up a
- /// substitution mapping, which should be an Objective-C class, extension,
- /// category, or method within.
- ///
- /// \returns an array of type arguments that can be substituted for
- /// the type parameters of the given declaration context in any type described
- /// within that context, or an empty optional to indicate that no
- /// substitution is required.
- std::optional<ArrayRef<QualType>>
- getObjCSubstitutions(const DeclContext *dc) const;
-
- /// Determines if this is an ObjC interface type that may accept type
- /// parameters.
- bool acceptsObjCTypeParams() const;
-
- const char *getTypeClassName() const;
-
- QualType getCanonicalTypeInternal() const {
- return CanonicalType;
- }
-
- CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
- void dump() const;
- void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
-};
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index bccc5305fb6b2..0627776267306 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -12,6 +12,7 @@
//===----------------------------------------------------------------------===//
#include "LLVMABI/Type.h"
+#include "LLVMABI/ABIFunctionInfo.h"
#include "CGCall.h"
#include "ABIInfo.h"
#include "ABIInfoImpl.h"
@@ -48,6 +49,14 @@ using namespace CodeGen;
using namespace ABI;
/***/
+ABIFunction::CallingConv ClangCallConvToABICallConv(CallingConv CC) {
+ switch (CC) {
+ default: return ABIFunction::CallingConv::CC_C;
+ case CC_X86StdCall: return ABIFunction::CallingConv::CC_X86StdCall;
+ }
+}
+
+
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
switch (CC) {
default: return llvm::CallingConv::C;
@@ -799,7 +808,7 @@ void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
}
}
-std::unique_ptr<ABI::ABIBuiltinType> *getABIType(QualType QT){
+std::unique_ptr<ABI::ABIBuiltinType> getABIType(QualType QT){
const clang::Type *BaseType = QT.getTypePtr();
switch (BaseType->getTypeClass()) {
@@ -863,7 +872,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
if (FI)
return *FI;
- unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
+ ABIFunction::CallingConv CC = ClangCallConvToABICallConv(info.getCC());
// map clang::QualType -> abi::Type
// implicit conversion from clang::CanQualType to clang::QualType
@@ -872,21 +881,15 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
std::vector<ABI::ABIBuiltinType> abiTypes;
abiTypes.reserve(argTypes.size());
- for (const llvm::CanQualType &element : argTypes) {
+ for (CanQualType &element : argTypes) {
abiTypes.push_back(*getABIType(element)); // Move unique_ptr into the vector
}
- llvm::ArrayRef<ABI::ABIBuiltinType> argTypesABI(abiTypes);
-
// map the abi::Types -> abi::FunctionInfo type, done by the library
- ABIFunctionInfo *ABIFI = ABIFunctionInfo::create(CC, resultTypeABI.get(), argTypesABI);
-
- // // Construct the function info. We co-allocate the ArgInfos.
- // FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
- // info, paramInfos, resultType, argTypes, required);
+ ABIFunction::ABIFunctionInfo *ABIFI = ABIFunction::ABIFunctionInfo::create(CC, abiTypes, *(resultTypeABI.get()));
// Compute ABI information.
- if (CC == llvm::CallingConv::SPIR_KERNEL) {
+ if (ClangCallConvToLLVMCallConv(info.getCC()) == llvm::CallingConv::SPIR_KERNEL) {
// Force target independent argument handling for the host visible
// kernel functions.
computeSPIRKernelABIInfo(CGM, *FI);
More information about the llvm-commits
mailing list