[clang] [Clang] NFC: Move Arm type attributes to separate trailing object. (PR #78424)
Sander de Smalen via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 17 02:51:13 PST 2024
https://github.com/sdesmalen-arm created https://github.com/llvm/llvm-project/pull/78424
This decouples the Arm type attributes from other bits, which means
the data will only be allocated when a function uses these Arm
attributes.
The first patch adds the bit `HasArmTypeAttributes` to
`FunctionTypeBitfields`, which grows from 62 bits to 63 bits.
In the second patch, I've moved this bit (`HasArmTypeAttributes`) to
`FunctionTypeExtraBitfields`, because it looks like the bits in
`FunctionTypeBitfields` are precious and we really don't want that struct
to grow beyond 64 bits.
I've split this out into two patches to explain the rationale, but those
can be squashed before merging.
>From 00748e8fe0a58ec350053487179c15cb988ad9f7 Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Wed, 17 Jan 2024 09:27:21 +0000
Subject: [PATCH 1/2] [Clang] NFC: Move Arm type attributes to separate
trailing object.
This decouples the Arm type attributes from other bits, which means
the data will only be allocated when a function uses these Arm
attributes.
The first patch adds the bit `HasArmTypeAttributes` to
`FunctionTypeBitfields`, which grows from 62 bits to 63 bits.
In the second patch, I've moved this bit (`HasArmTypeAttributes`) to
`FunctionTypeExtraBitfields`, because it looks like the bits in
`FunctionTypeBitfields` are precious and we really don't want that struct
to grow beyond 64 bits.
I've split this out into two patches to explain the rationale, but those
can be squashed before merging.
---
clang/include/clang/AST/Type.h | 58 ++++++++++++++++++++++++----------
clang/lib/AST/ASTContext.cpp | 7 ++--
clang/lib/AST/Type.cpp | 12 +++++--
3 files changed, 55 insertions(+), 22 deletions(-)
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index a7efe78591635e..63624a7ff1c554 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -1754,6 +1754,10 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
LLVM_PREFERRED_TYPE(bool)
unsigned HasExtraBitfields : 1;
+ /// Whether this function has a trailing object for Arm type attributes.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasArmTypeAttributes : 1;
+
/// Whether the function is variadic.
LLVM_PREFERRED_TYPE(bool)
unsigned Variadic : 1;
@@ -4029,6 +4033,18 @@ class FunctionType : public Type {
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };
+ /// A simple holder for various uncommon bits which do not fit in
+ /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
+ /// alignment of subsequent objects in TrailingObjects.
+ struct alignas(void *) FunctionTypeExtraBitfields {
+ /// The number of types in the exception specification.
+ /// A whole unsigned is not needed here and according to
+ /// [implimits] 8 bits would be enough here.
+ unsigned NumExceptionType : 10;
+
+ FunctionTypeExtraBitfields() : NumExceptionType(0) {}
+ };
+
/// The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number
/// of function type attributes that can be set on function types, including
/// function pointers.
@@ -4042,7 +4058,8 @@ class FunctionType : public Type {
SME_ZAMask = 0b111 << SME_ZAShift,
SME_AttributeMask = 0b111'111 // We only support maximum 6 bits because of
- // the bitmask in FunctionTypeExtraBitfields.
+ // the bitmask in FunctionTypeArmAttributes
+ // and ExtProtoInfo.
};
enum ArmStateValue : unsigned {
@@ -4057,20 +4074,15 @@ class FunctionType : public Type {
return (ArmStateValue)((AttrBits & SME_ZAMask) >> SME_ZAShift);
}
- /// A simple holder for various uncommon bits which do not fit in
- /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
- /// alignment of subsequent objects in TrailingObjects.
- struct alignas(void *) FunctionTypeExtraBitfields {
- /// The number of types in the exception specification.
- /// A whole unsigned is not needed here and according to
- /// [implimits] 8 bits would be enough here.
- unsigned NumExceptionType : 10;
-
+ /// A holder for Arm type attributes as described in the Arm C/C++
+ /// Language extensions which are not particularly common to all
+ /// types and therefore accounted separately from FunctionTypeBitfields.
+ struct alignas(void *) FunctionTypeArmAttributes {
/// Any AArch64 SME ACLE type attributes that need to be propagated
/// on declarations and function pointers.
unsigned AArch64SMEAttributes : 6;
- FunctionTypeExtraBitfields()
- : NumExceptionType(0), AArch64SMEAttributes(SME_NormalFunction) {}
+
+ FunctionTypeArmAttributes() : AArch64SMEAttributes(SME_NormalFunction) {}
};
protected:
@@ -4169,7 +4181,8 @@ class FunctionProtoType final
public llvm::FoldingSetNode,
private llvm::TrailingObjects<
FunctionProtoType, QualType, SourceLocation,
- FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
+ FunctionType::FunctionTypeExtraBitfields,
+ FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;
@@ -4275,8 +4288,11 @@ class FunctionProtoType final
}
bool requiresFunctionProtoTypeExtraBitfields() const {
- return ExceptionSpec.Type == EST_Dynamic ||
- AArch64SMEAttributes != SME_NormalFunction;
+ return ExceptionSpec.Type == EST_Dynamic;
+ }
+
+ bool requiresFunctionProtoTypeArmAttributes() const {
+ return AArch64SMEAttributes != SME_NormalFunction;
}
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable = true) {
@@ -4296,6 +4312,10 @@ class FunctionProtoType final
return isVariadic();
}
+ unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>) const {
+ return hasArmTypeAttributes();
+ }
+
unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
return hasExtraBitfields();
}
@@ -4384,6 +4404,10 @@ class FunctionProtoType final
}
+ bool hasArmTypeAttributes() const {
+ return FunctionTypeBits.HasArmTypeAttributes;
+ }
+
bool hasExtQualifiers() const {
return FunctionTypeBits.HasExtQuals;
}
@@ -4595,9 +4619,9 @@ class FunctionProtoType final
/// Return a bitmask describing the SME attributes on the function type, see
/// AArch64SMETypeAttributes for their values.
unsigned getAArch64SMEAttributes() const {
- if (!hasExtraBitfields())
+ if (!hasArmTypeAttributes())
return SME_NormalFunction;
- return getTrailingObjects<FunctionTypeExtraBitfields>()
+ return getTrailingObjects<FunctionTypeArmAttributes>()
->AArch64SMEAttributes;
}
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index d9cefcaa84d7e5..0fc0831b221aab 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -4484,10 +4484,11 @@ QualType ASTContext::getFunctionTypeInternal(
EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
size_t Size = FunctionProtoType::totalSizeToAlloc<
QualType, SourceLocation, FunctionType::FunctionTypeExtraBitfields,
- FunctionType::ExceptionType, Expr *, FunctionDecl *,
- FunctionProtoType::ExtParameterInfo, Qualifiers>(
+ FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
+ Expr *, FunctionDecl *, FunctionProtoType::ExtParameterInfo, Qualifiers>(
NumArgs, EPI.Variadic, EPI.requiresFunctionProtoTypeExtraBitfields(),
- ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
+ EPI.requiresFunctionProtoTypeArmAttributes(), ESH.NumExceptionType,
+ ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
EPI.ExtParameterInfos ? NumArgs : 0,
EPI.TypeQuals.hasNonFastQualifiers() ? 1 : 0);
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index b419fc8836b032..eb891982d58a1b 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -3459,6 +3459,14 @@ FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
FunctionTypeBits.HasExtraBitfields = false;
}
+ if (epi.requiresFunctionProtoTypeArmAttributes()) {
+ FunctionTypeBits.HasArmTypeAttributes = true;
+ auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
+ ArmTypeAttrs = FunctionTypeArmAttributes();
+ } else {
+ FunctionTypeBits.HasArmTypeAttributes = false;
+ }
+
// Fill in the trailing argument array.
auto *argSlot = getTrailingObjects<QualType>();
@@ -3470,10 +3478,10 @@ FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
// Propagate the SME ACLE attributes.
if (epi.AArch64SMEAttributes != SME_NormalFunction) {
- auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
+ auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
assert(epi.AArch64SMEAttributes <= SME_AttributeMask &&
"Not enough bits to encode SME attributes");
- ExtraBits.AArch64SMEAttributes = epi.AArch64SMEAttributes;
+ ArmTypeAttrs.AArch64SMEAttributes = epi.AArch64SMEAttributes;
}
// Fill in the exception type array if present.
>From bbf241a442fad0dc9dbb040a0e98f16ba884b3d3 Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Wed, 17 Jan 2024 09:59:08 +0000
Subject: [PATCH 2/2] Move HasArmTypeAttributes bit to the
FunctionTypeExtraBitfields [to squash]
---
clang/include/clang/AST/Type.h | 17 ++++++++++-------
clang/lib/AST/Type.cpp | 8 ++++----
2 files changed, 14 insertions(+), 11 deletions(-)
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 63624a7ff1c554..259e920acf9ff3 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -1754,10 +1754,6 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
LLVM_PREFERRED_TYPE(bool)
unsigned HasExtraBitfields : 1;
- /// Whether this function has a trailing object for Arm type attributes.
- LLVM_PREFERRED_TYPE(bool)
- unsigned HasArmTypeAttributes : 1;
-
/// Whether the function is variadic.
LLVM_PREFERRED_TYPE(bool)
unsigned Variadic : 1;
@@ -4042,7 +4038,11 @@ class FunctionType : public Type {
/// [implimits] 8 bits would be enough here.
unsigned NumExceptionType : 10;
- FunctionTypeExtraBitfields() : NumExceptionType(0) {}
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasArmTypeAttributes : 1;
+
+ FunctionTypeExtraBitfields()
+ : NumExceptionType(0), HasArmTypeAttributes(false) {}
};
/// The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number
@@ -4288,7 +4288,8 @@ class FunctionProtoType final
}
bool requiresFunctionProtoTypeExtraBitfields() const {
- return ExceptionSpec.Type == EST_Dynamic;
+ return ExceptionSpec.Type == EST_Dynamic ||
+ requiresFunctionProtoTypeArmAttributes();
}
bool requiresFunctionProtoTypeArmAttributes() const {
@@ -4405,7 +4406,9 @@ class FunctionProtoType final
}
bool hasArmTypeAttributes() const {
- return FunctionTypeBits.HasArmTypeAttributes;
+ return FunctionTypeBits.HasExtraBitfields &&
+ getTrailingObjects<FunctionTypeExtraBitfields>()
+ ->HasArmTypeAttributes;
}
bool hasExtQualifiers() const {
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index eb891982d58a1b..3db5ae182f32c4 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -3460,13 +3460,13 @@ FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
}
if (epi.requiresFunctionProtoTypeArmAttributes()) {
- FunctionTypeBits.HasArmTypeAttributes = true;
auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
ArmTypeAttrs = FunctionTypeArmAttributes();
- } else {
- FunctionTypeBits.HasArmTypeAttributes = false;
- }
+ // Also set the bit in FunctionTypeExtraBitfields
+ auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
+ ExtraBits.HasArmTypeAttributes = true;
+ }
// Fill in the trailing argument array.
auto *argSlot = getTrailingObjects<QualType>();
More information about the cfe-commits
mailing list