[clang] [clang][C23] Support N3029 Improved Normal Enumerations (PR #103917)
Mariya Podchishchaeva via cfe-commits
cfe-commits at lists.llvm.org
Fri Sep 6 02:28:49 PDT 2024
https://github.com/Fznamznon updated https://github.com/llvm/llvm-project/pull/103917
>From eee57bcc211a8a045c0102ebb2f4410d52d657f6 Mon Sep 17 00:00:00 2001
From: "Podchishchaeva, Mariya" <mariya.podchishchaeva at intel.com>
Date: Wed, 14 Aug 2024 05:56:18 -0700
Subject: [PATCH 1/5] [clang][C23] Support N3029 Improved Normal Enumerations
Basically clang already implemented 90% of the feature as an extension.
This commit disables warnings for C23 and aligns types of enumerators
according to the recent wording.
---
clang/docs/ReleaseNotes.rst | 2 ++
clang/lib/Sema/SemaDecl.cpp | 44 +++++++++++++++------------
clang/test/C/C23/n3029.c | 59 +++++++++++++++++++++++++++++++++++++
clang/test/Sema/enum.c | 52 +++++++++++++++++++++++++-------
clang/www/c_status.html | 2 +-
5 files changed, 129 insertions(+), 30 deletions(-)
create mode 100644 clang/test/C/C23/n3029.c
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 6796a619ba97f8..376ed0facc8504 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -125,6 +125,8 @@ C2y Feature Support
C23 Feature Support
^^^^^^^^^^^^^^^^^^^
+- Clang now supports `N3029 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3017.htm>`_ Improved Normal Enumerations.
+
Non-comprehensive list of changes in this release
-------------------------------------------------
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 641b180527da55..03f14487d0b80e 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -19474,11 +19474,12 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// representable as an int.
// Complain if the value is not representable in an int.
- if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
- Diag(IdLoc, diag::ext_enum_value_not_int)
- << toString(EnumVal, 10) << Val->getSourceRange()
- << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
- else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
+ if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) {
+ if (!getLangOpts().C23)
+ Diag(IdLoc, diag::ext_enum_value_not_int)
+ << toString(EnumVal, 10) << Val->getSourceRange()
+ << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
+ } else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
// Force the type of the expression to 'int'.
Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
}
@@ -19553,12 +19554,12 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// If we're not in C++, diagnose the overflow of enumerator values,
// which in C99 means that the enumerator value is not representable in
- // an int (C99 6.7.2.2p2). However, we support GCC's extension that
- // permits enumerator values that are representable in some larger
- // integral type.
- if (!getLangOpts().CPlusPlus && !T.isNull())
+ // an int (C99 6.7.2.2p2). However C23 permits enumerator values that
+ // are representable in some larger integral type and we allow it in
+ // older language modes as an extension.
+ if (!getLangOpts().CPlusPlus && !getLangOpts().C23 && !T.isNull())
Diag(IdLoc, diag::warn_enum_value_overflow);
- } else if (!getLangOpts().CPlusPlus &&
+ } else if (!getLangOpts().CPlusPlus && !getLangOpts().C23 &&
!EltTy->isDependentType() &&
!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
// Enforce C99 6.7.2.2p2 even when we compute the next value.
@@ -19882,9 +19883,6 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
return;
}
- // TODO: If the result value doesn't fit in an int, it must be a long or long
- // long value. ISO C does not support this, but GCC does as an extension,
- // emit a warning.
unsigned IntWidth = Context.getTargetInfo().getIntWidth();
unsigned CharWidth = Context.getTargetInfo().getCharWidth();
unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
@@ -19893,13 +19891,14 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
// reverse the list.
unsigned NumNegativeBits = 0;
unsigned NumPositiveBits = 0;
+ bool MembersRepresentableByInt = true;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD =
cast_or_null<EnumConstantDecl>(Elements[i]);
if (!ECD) continue; // Already issued a diagnostic.
- const llvm::APSInt &InitVal = ECD->getInitVal();
+ llvm::APSInt InitVal = ECD->getInitVal();
// Keep track of the size of positive and negative values.
if (InitVal.isUnsigned() || InitVal.isNonNegative()) {
@@ -19911,6 +19910,8 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
NumNegativeBits =
std::max(NumNegativeBits, (unsigned)InitVal.getSignificantBits());
}
+ MembersRepresentableByInt &=
+ isRepresentableIntegerValue(Context, InitVal, Context.IntTy);
}
// If we have an empty set of enumerators we still need one bit.
@@ -19932,7 +19933,7 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
// int, long long int, or unsigned long long int.
// C99 6.4.4.3p2:
// An identifier declared as an enumeration constant has type int.
- // The C99 rule is modified by a gcc extension
+ // The C99 rule is modified by C23.
QualType BestPromotionType;
bool Packed = Enum->hasAttr<PackedAttr>();
@@ -20026,7 +20027,7 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
auto *ECD = cast_or_null<EnumConstantDecl>(D);
if (!ECD) continue; // Already issued a diagnostic.
- // Standard C says the enumerators have int type, but we allow, as an
+ // C99 says the enumerators have int type, but we allow, as an
// extension, the enumerators to be larger than int size. If each
// enumerator value fits in an int, type it as an int, otherwise type it the
// same as the enumerator decl itself. This means that in "enum { X = 1U }"
@@ -20040,9 +20041,14 @@ void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
QualType NewTy;
unsigned NewWidth;
bool NewSign;
- if (!getLangOpts().CPlusPlus &&
- !Enum->isFixed() &&
- isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
+ if (!getLangOpts().CPlusPlus && !Enum->isFixed() &&
+ MembersRepresentableByInt) {
+ // C23 6.7.3.3.3p15:
+ // The enumeration member type for an enumerated type without fixed
+ // underlying type upon completion is:
+ // - int if all the values of the enumeration are representable as an
+ // int; or,
+ // - the enumerated type
NewTy = Context.IntTy;
NewWidth = IntWidth;
NewSign = true;
diff --git a/clang/test/C/C23/n3029.c b/clang/test/C/C23/n3029.c
new file mode 100644
index 00000000000000..d0dccb02501133
--- /dev/null
+++ b/clang/test/C/C23/n3029.c
@@ -0,0 +1,59 @@
+// RUN: %clang_cc1 -verify -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic
+
+#include <limits.h>
+
+#define GET_TYPE_INT(x) _Generic(x, \
+ char: 1,\
+ unsigned char: 2,\
+ signed char: 3,\
+ short: 4,\
+ unsigned short: 5,\
+ int: 6,\
+ unsigned int: 7,\
+ long: 8,\
+ unsigned long: 9,\
+ long long: 10,\
+ unsigned long long: 11,\
+ default: 0xFF\
+ )\
+
+enum x {
+a = INT_MAX,
+b = ULLONG_MAX,
+a_type = GET_TYPE_INT(a),
+b_type = GET_TYPE_INT(b)
+};
+
+static_assert(GET_TYPE_INT(a) == GET_TYPE_INT(b));
+
+extern enum x e_a;
+extern __typeof(b) e_a;
+extern __typeof(a) e_a;
+
+enum a {
+ a0 = 0xFFFFFFFFFFFFFFFFULL
+};
+
+_Bool e () {
+ return a0;
+}
+
+int f () {
+ return a0; // expected-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 18446744073709551615 to -1}}
+}
+
+unsigned long g () {
+ return a0;
+}
+
+unsigned long long h () {
+ return a0;
+}
+
+enum big_enum {
+ big_enum_a = LONG_MAX,
+ big_enum_b = a + 1,
+ big_enum_c = ULLONG_MAX
+};
+
+static_assert(GET_TYPE_INT(big_enum_a) == GET_TYPE_INT(big_enum_b));
diff --git a/clang/test/Sema/enum.c b/clang/test/Sema/enum.c
index b0707914c0d852..d2cd27a0c02299 100644
--- a/clang/test/Sema/enum.c
+++ b/clang/test/Sema/enum.c
@@ -1,23 +1,23 @@
-// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify -pedantic
+// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify=expected,c99 -pedantic
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fsyntax-only -std=c23 -verify -pedantic
enum e {A,
- B = 42LL << 32, // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
+ B = 42LL << 32, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
C = -4, D = 12456 };
enum f { a = -2147483648, b = 2147483647 }; // ok.
enum g { // too negative
- c = -2147483649, // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
+ c = -2147483649, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
d = 2147483647 };
enum h { e = -2147483648, // too pos
- f = 2147483648, // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
- i = 0xFFFF0000 // expected-warning {{too large}}
+ f = 2147483648, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+ i = 0xFFFF0000 // c99-warning {{too large}}
};
// minll maxull
enum x // expected-warning {{enumeration values exceed range of largest integer}}
-{ y = -9223372036854775807LL-1, // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
-z = 9223372036854775808ULL }; // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
+{ y = -9223372036854775807LL-1, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+z = 9223372036854775808ULL }; // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
int test(void) {
return sizeof(enum e) ;
@@ -172,10 +172,8 @@ enum class GH42372_2 {
#if __STDC_VERSION__ >= 202311L
// FIXME: GCC picks __uint128_t as the underlying type for the enumeration
// value and Clang picks unsigned long long.
-// FIXME: Clang does not yet implement WG14 N3029, so the warning about
-// restricting enumerator values to 'int' is not correct.
enum GH59352 { // expected-warning {{enumeration values exceed range of largest integer}}
- BigVal = 66666666666666666666wb // expected-warning {{ISO C restricts enumerator values to range of 'int' (66666666666666666666 is too large)}}
+ BigVal = 66666666666666666666wb // c99-warning {{ISO C restricts enumerator values to range of 'int' (66666666666666666666 is too large)}}
};
_Static_assert(BigVal == 66666666666666666666wb); /* expected-error {{static assertion failed due to requirement 'BigVal == 66666666666666666666wb'}}
expected-note {{expression evaluates to '11326434445538011818 == 66666666666666666666'}}
@@ -191,4 +189,38 @@ _Static_assert(
__uint128_t : 1
)
);
+
+#include <limits.h>
+
+void fooinc23() {
+ enum E1 {
+ V1 = INT_MAX
+ } e1;
+
+ enum E2 {
+ V2 = INT_MAX,
+ V3
+ } e2;
+
+ enum E3 {
+ V4 = INT_MAX,
+ V5 = LONG_MIN
+ } e3;
+
+ enum E4 {
+ V6 = 1u,
+ V7 = 2wb
+ } e4;
+
+ _Static_assert(_Generic(V1, int : 1));
+ _Static_assert(_Generic(V2, int : 0, unsigned int : 1));
+ _Static_assert(_Generic(V3, int : 0, unsigned int : 1));
+ _Static_assert(_Generic(V4, int : 0, signed long : 1));
+ _Static_assert(_Generic(V5, int : 0, signed long : 1));
+ _Static_assert(_Generic(V6, int : 1));
+ _Static_assert(_Generic(V7, int : 1));
+ _Static_assert(_Generic((enum E4){}, unsigned int : 1));
+
+}
+
#endif // __STDC_VERSION__ >= 202311L
diff --git a/clang/www/c_status.html b/clang/www/c_status.html
index a5d04506b642bc..cc2c83d5225e98 100644
--- a/clang/www/c_status.html
+++ b/clang/www/c_status.html
@@ -1160,7 +1160,7 @@ <h2 id="c2x">C23 implementation status</h2>
<tr>
<td>Improved normal enumerations</td>
<td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3029.htm">N3029</a></td>
- <td class="unknown" align="center">Unknown</td>
+ <td class="unreleased" align="center">Clang 20</td>
</tr>
<tr>
<td>Relax requirements for va_start</td>
>From d766f1924d3724eb13c1b50e2018a0f3becefabb Mon Sep 17 00:00:00 2001
From: "Podchishchaeva, Mariya" <mariya.podchishchaeva at intel.com>
Date: Thu, 15 Aug 2024 03:47:15 -0700
Subject: [PATCH 2/5] Fix test on Windows
---
clang/test/C/C23/n3029.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/test/C/C23/n3029.c b/clang/test/C/C23/n3029.c
index d0dccb02501133..b5c331ab96c4de 100644
--- a/clang/test/C/C23/n3029.c
+++ b/clang/test/C/C23/n3029.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -verify -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic
+// RUN: %clang_cc1 -verify -triple x86_64-unknown-linux-gnu -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic
#include <limits.h>
>From 06c369998e8d2e3d1ea4b409f141928fc507503c Mon Sep 17 00:00:00 2001
From: "Podchishchaeva, Mariya" <mariya.podchishchaeva at intel.com>
Date: Mon, 2 Sep 2024 05:02:33 -0700
Subject: [PATCH 3/5] Add -Wpre-c23-compat warning
---
clang/docs/ReleaseNotes.rst | 2 +-
.../include/clang/Basic/DiagnosticSemaKinds.td | 9 ++++++---
clang/lib/Sema/SemaDecl.cpp | 18 ++++++++++--------
clang/test/C/C23/n3029.c | 16 ++++++++--------
clang/test/Misc/warning-flags.c | 2 +-
clang/test/Sema/enum.c | 10 +++++-----
6 files changed, 31 insertions(+), 26 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 376ed0facc8504..6af7769177ecbe 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -125,7 +125,7 @@ C2y Feature Support
C23 Feature Support
^^^^^^^^^^^^^^^^^^^
-- Clang now supports `N3029 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3017.htm>`_ Improved Normal Enumerations.
+- Clang now supports `N3029 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3029.htm>`_ Improved Normal Enumerations.
Non-comprehensive list of changes in this release
-------------------------------------------------
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 554dbaff2ce0d8..fa2ba4400ae052 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6185,9 +6185,12 @@ def err_misplaced_ivar : Error<
def warn_ivars_in_interface : Warning<
"declaration of instance variables in the interface is deprecated">,
InGroup<DiagGroup<"objc-interface-ivars">>, DefaultIgnore;
-def ext_enum_value_not_int : Extension<
- "ISO C restricts enumerator values to range of 'int' (%0 is too "
- "%select{small|large}1)">;
+def ext_c23_enum_value_not_int : Extension<
+ "enumerator values exceeding range of 'int' is a C23 extension (%0 is too "
+ "%select{small|large}1)">, InGroup<C23>;
+def warn_c17_compat_enum_value_not_int : Warning<
+ "enumerator values exceeding range of 'int' is incompatible with C standards before C23 (%0 is too "
+ "%select{small|large}1)">, DefaultIgnore, InGroup<CPre23Compat>;
def ext_enum_too_large : ExtWarn<
"enumeration values exceed range of largest integer">, InGroup<EnumTooLarge>;
def ext_enumerator_increment_too_large : ExtWarn<
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 03f14487d0b80e..d7e8e536431656 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -19475,10 +19475,11 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// Complain if the value is not representable in an int.
if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) {
- if (!getLangOpts().C23)
- Diag(IdLoc, diag::ext_enum_value_not_int)
- << toString(EnumVal, 10) << Val->getSourceRange()
- << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
+ Diag(IdLoc, (getLangOpts().C23)
+ ? diag::warn_c17_compat_enum_value_not_int
+ : diag::ext_c23_enum_value_not_int)
+ << toString(EnumVal, 10) << Val->getSourceRange()
+ << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
} else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
// Force the type of the expression to 'int'.
Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
@@ -19559,12 +19560,13 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// older language modes as an extension.
if (!getLangOpts().CPlusPlus && !getLangOpts().C23 && !T.isNull())
Diag(IdLoc, diag::warn_enum_value_overflow);
- } else if (!getLangOpts().CPlusPlus && !getLangOpts().C23 &&
- !EltTy->isDependentType() &&
+ } else if (!getLangOpts().CPlusPlus && !EltTy->isDependentType() &&
!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
// Enforce C99 6.7.2.2p2 even when we compute the next value.
- Diag(IdLoc, diag::ext_enum_value_not_int)
- << toString(EnumVal, 10) << 1;
+ Diag(IdLoc, (getLangOpts().C23)
+ ? diag::warn_c17_compat_enum_value_not_int
+ : diag::ext_c23_enum_value_not_int)
+ << toString(EnumVal, 10) << 1;
}
}
}
diff --git a/clang/test/C/C23/n3029.c b/clang/test/C/C23/n3029.c
index b5c331ab96c4de..40d23472c4bdcd 100644
--- a/clang/test/C/C23/n3029.c
+++ b/clang/test/C/C23/n3029.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -verify -triple x86_64-unknown-linux-gnu -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic
+// RUN: %clang_cc1 -verify -triple x86_64-unknown-linux-gnu -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic -Wpre-c23-compat
#include <limits.h>
@@ -19,19 +19,19 @@
enum x {
a = INT_MAX,
-b = ULLONG_MAX,
+b = ULLONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
a_type = GET_TYPE_INT(a),
b_type = GET_TYPE_INT(b)
};
-static_assert(GET_TYPE_INT(a) == GET_TYPE_INT(b));
+_Static_assert(GET_TYPE_INT(a) == GET_TYPE_INT(b), "ok");
extern enum x e_a;
extern __typeof(b) e_a;
extern __typeof(a) e_a;
enum a {
- a0 = 0xFFFFFFFFFFFFFFFFULL
+ a0 = 0xFFFFFFFFFFFFFFFFULL // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
};
_Bool e () {
@@ -51,9 +51,9 @@ unsigned long long h () {
}
enum big_enum {
- big_enum_a = LONG_MAX,
- big_enum_b = a + 1,
- big_enum_c = ULLONG_MAX
+ big_enum_a = LONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
+ big_enum_b = a + 1, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
+ big_enum_c = ULLONG_MAX // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
};
-static_assert(GET_TYPE_INT(big_enum_a) == GET_TYPE_INT(big_enum_b));
+_Static_assert(GET_TYPE_INT(big_enum_a) == GET_TYPE_INT(big_enum_b), "ok");
diff --git a/clang/test/Misc/warning-flags.c b/clang/test/Misc/warning-flags.c
index cdbe1e95cba965..6bcc41888a6343 100644
--- a/clang/test/Misc/warning-flags.c
+++ b/clang/test/Misc/warning-flags.c
@@ -88,4 +88,4 @@ CHECK-NEXT: warn_weak_import
The list of warnings in -Wpedantic should NEVER grow.
-CHECK: Number in -Wpedantic (not covered by other -W flags): 25
+CHECK: Number in -Wpedantic (not covered by other -W flags): 24
diff --git a/clang/test/Sema/enum.c b/clang/test/Sema/enum.c
index d2cd27a0c02299..b9183d3fb2b8c8 100644
--- a/clang/test/Sema/enum.c
+++ b/clang/test/Sema/enum.c
@@ -1,23 +1,23 @@
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify=expected,c99 -pedantic
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fsyntax-only -std=c23 -verify -pedantic
enum e {A,
- B = 42LL << 32, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+ B = 42LL << 32, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
C = -4, D = 12456 };
enum f { a = -2147483648, b = 2147483647 }; // ok.
enum g { // too negative
- c = -2147483649, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+ c = -2147483649, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
d = 2147483647 };
enum h { e = -2147483648, // too pos
- f = 2147483648, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+ f = 2147483648, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
i = 0xFFFF0000 // c99-warning {{too large}}
};
// minll maxull
enum x // expected-warning {{enumeration values exceed range of largest integer}}
-{ y = -9223372036854775807LL-1, // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
-z = 9223372036854775808ULL }; // c99-warning {{ISO C restricts enumerator values to range of 'int'}}
+{ y = -9223372036854775807LL-1, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
+z = 9223372036854775808ULL }; // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
int test(void) {
return sizeof(enum e) ;
>From 19e7922ab683652a1928fa36ff2d6ea854188c9a Mon Sep 17 00:00:00 2001
From: "Podchishchaeva, Mariya" <mariya.podchishchaeva at intel.com>
Date: Wed, 4 Sep 2024 09:27:20 -0700
Subject: [PATCH 4/5] Adjustments + cr feedback
---
.../clang/Basic/DiagnosticSemaKinds.td | 7 +++---
clang/lib/Sema/SemaDecl.cpp | 8 +++++--
clang/test/C/C23/n3029.c | 10 ++++-----
clang/test/Misc/warning-flags.c | 3 +--
clang/test/Sema/enum.c | 22 +++++++++++++------
5 files changed, 31 insertions(+), 19 deletions(-)
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index a1dece377f6823..2423aa750435f1 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1039,7 +1039,8 @@ def err_opencl_invalid_param : Error<
"declaring function parameter of type %0 is not allowed%select{; did you forget * ?|}1">;
def err_opencl_invalid_return : Error<
"declaring function return value of type %0 is not allowed %select{; did you forget * ?|}1">;
-def warn_enum_value_overflow : Warning<"overflow in enumeration value">;
+def ext_c23_enum_value_int_overflow : Extension<"incremented enumerator value that is exceeding range of 'int' is a C23 extension">, InGroup<C23>;
+def warn_c17_compat_enum_value_int_overflow : Warning<"incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23">, InGroup<CPre23Compat>;
def warn_pragma_options_align_reset_failed : Warning<
"#pragma options align=reset failed: %0">,
InGroup<IgnoredPragmas>;
@@ -6195,10 +6196,10 @@ def warn_ivars_in_interface : Warning<
"declaration of instance variables in the interface is deprecated">,
InGroup<DiagGroup<"objc-interface-ivars">>, DefaultIgnore;
def ext_c23_enum_value_not_int : Extension<
- "enumerator values exceeding range of 'int' is a C23 extension (%0 is too "
+ "enumerator values exceeding range of 'int' are a C23 extension (%0 is too "
"%select{small|large}1)">, InGroup<C23>;
def warn_c17_compat_enum_value_not_int : Warning<
- "enumerator values exceeding range of 'int' is incompatible with C standards before C23 (%0 is too "
+ "enumerator values exceeding range of 'int' are incompatible with C standards before C23 (%0 is too "
"%select{small|large}1)">, DefaultIgnore, InGroup<CPre23Compat>;
def ext_enum_too_large : ExtWarn<
"enumeration values exceed range of largest integer">, InGroup<EnumTooLarge>;
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 58a66617d326b4..96ab02a70c1b5b 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -19558,8 +19558,12 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// an int (C99 6.7.2.2p2). However C23 permits enumerator values that
// are representable in some larger integral type and we allow it in
// older language modes as an extension.
- if (!getLangOpts().CPlusPlus && !getLangOpts().C23 && !T.isNull())
- Diag(IdLoc, diag::warn_enum_value_overflow);
+ // Exclude fixed enumerators since they are diagnosed with an error for
+ // this case.
+ if (!getLangOpts().CPlusPlus && !T.isNull() && !Enum->isFixed())
+ Diag(IdLoc, (getLangOpts().C23)
+ ? diag::warn_c17_compat_enum_value_int_overflow
+ : diag::ext_c23_enum_value_int_overflow);
} else if (!getLangOpts().CPlusPlus && !EltTy->isDependentType() &&
!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
// Enforce C99 6.7.2.2p2 even when we compute the next value.
diff --git a/clang/test/C/C23/n3029.c b/clang/test/C/C23/n3029.c
index 40d23472c4bdcd..d1f8306fb7709a 100644
--- a/clang/test/C/C23/n3029.c
+++ b/clang/test/C/C23/n3029.c
@@ -19,7 +19,7 @@
enum x {
a = INT_MAX,
-b = ULLONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
+b = ULLONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
a_type = GET_TYPE_INT(a),
b_type = GET_TYPE_INT(b)
};
@@ -31,7 +31,7 @@ extern __typeof(b) e_a;
extern __typeof(a) e_a;
enum a {
- a0 = 0xFFFFFFFFFFFFFFFFULL // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
+ a0 = 0xFFFFFFFFFFFFFFFFULL // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
};
_Bool e () {
@@ -51,9 +51,9 @@ unsigned long long h () {
}
enum big_enum {
- big_enum_a = LONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
- big_enum_b = a + 1, // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
- big_enum_c = ULLONG_MAX // expected-warning {{enumerator values exceeding range of 'int' is incompatible with C standards before C23}}
+ big_enum_a = LONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
+ big_enum_b = a + 1, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
+ big_enum_c = ULLONG_MAX // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
};
_Static_assert(GET_TYPE_INT(big_enum_a) == GET_TYPE_INT(big_enum_b), "ok");
diff --git a/clang/test/Misc/warning-flags.c b/clang/test/Misc/warning-flags.c
index efadadc000e9cb..80c01099140f79 100644
--- a/clang/test/Misc/warning-flags.c
+++ b/clang/test/Misc/warning-flags.c
@@ -18,7 +18,7 @@ This test serves two purposes:
The list of warnings below should NEVER grow. It should gradually shrink to 0.
-CHECK: Warnings without flags (63):
+CHECK: Warnings without flags (62):
CHECK-NEXT: ext_expected_semi_decl_list
CHECK-NEXT: ext_missing_whitespace_after_macro_name
@@ -46,7 +46,6 @@ CHECK-NEXT: warn_drv_amdgpu_cov6
CHECK-NEXT: warn_drv_assuming_mfloat_abi_is
CHECK-NEXT: warn_drv_clang_unsupported
CHECK-NEXT: warn_drv_pch_not_first_include
-CHECK-NEXT: warn_enum_value_overflow
CHECK-NEXT: warn_expected_qualified_after_typename
CHECK-NEXT: warn_fe_backend_unsupported
CHECK-NEXT: warn_fe_cc_log_diagnostics_failure
diff --git a/clang/test/Sema/enum.c b/clang/test/Sema/enum.c
index b9183d3fb2b8c8..80be9d24c8d990 100644
--- a/clang/test/Sema/enum.c
+++ b/clang/test/Sema/enum.c
@@ -1,23 +1,23 @@
// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify=expected,c99 -pedantic
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fsyntax-only -std=c23 -verify -pedantic
enum e {A,
- B = 42LL << 32, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
+ B = 42LL << 32, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
C = -4, D = 12456 };
enum f { a = -2147483648, b = 2147483647 }; // ok.
enum g { // too negative
- c = -2147483649, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
+ c = -2147483649, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
d = 2147483647 };
enum h { e = -2147483648, // too pos
- f = 2147483648, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
+ f = 2147483648, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
i = 0xFFFF0000 // c99-warning {{too large}}
};
// minll maxull
enum x // expected-warning {{enumeration values exceed range of largest integer}}
-{ y = -9223372036854775807LL-1, // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
-z = 9223372036854775808ULL }; // c99-warning {{enumerator values exceeding range of 'int' is a C23 extension}}
+{ y = -9223372036854775807LL-1, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
+z = 9223372036854775808ULL }; // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
int test(void) {
return sizeof(enum e) ;
@@ -169,11 +169,19 @@ enum class GH42372_2 {
One
};
+enum IncOverflow {
+ V2 = __INT_MAX__,
+ V3 // c99-warning {{incremented enumerator value that is exceeding range of 'int' is a C23 extension}}
+#if __STDC_VERSION__ >= 202311L
+ // expected-warning at -2 {{incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23}}
+#endif
+};
+
#if __STDC_VERSION__ >= 202311L
// FIXME: GCC picks __uint128_t as the underlying type for the enumeration
// value and Clang picks unsigned long long.
enum GH59352 { // expected-warning {{enumeration values exceed range of largest integer}}
- BigVal = 66666666666666666666wb // c99-warning {{ISO C restricts enumerator values to range of 'int' (66666666666666666666 is too large)}}
+ BigVal = 66666666666666666666wb
};
_Static_assert(BigVal == 66666666666666666666wb); /* expected-error {{static assertion failed due to requirement 'BigVal == 66666666666666666666wb'}}
expected-note {{expression evaluates to '11326434445538011818 == 66666666666666666666'}}
@@ -199,7 +207,7 @@ void fooinc23() {
enum E2 {
V2 = INT_MAX,
- V3
+ V3 // expected-warning {{incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23}}
} e2;
enum E3 {
>From 9d4ff0f83399266dc8659bf205ba8f1f84fb22af Mon Sep 17 00:00:00 2001
From: "Podchishchaeva, Mariya" <mariya.podchishchaeva at intel.com>
Date: Fri, 6 Sep 2024 02:28:18 -0700
Subject: [PATCH 5/5] Accomodate review feedback
---
.../clang/Basic/DiagnosticSemaKinds.td | 11 ++++----
clang/lib/Sema/SemaDecl.cpp | 18 ++++++------
clang/test/C/C23/n3029.c | 28 +++++++++++--------
clang/test/Sema/enum.c | 23 +++++++--------
4 files changed, 41 insertions(+), 39 deletions(-)
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 757c7494102df5..9be11217775381 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1039,8 +1039,6 @@ def err_opencl_invalid_param : Error<
"declaring function parameter of type %0 is not allowed%select{; did you forget * ?|}1">;
def err_opencl_invalid_return : Error<
"declaring function return value of type %0 is not allowed %select{; did you forget * ?|}1">;
-def ext_c23_enum_value_int_overflow : Extension<"incremented enumerator value that is exceeding range of 'int' is a C23 extension">, InGroup<C23>;
-def warn_c17_compat_enum_value_int_overflow : Warning<"incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23">, InGroup<CPre23Compat>;
def warn_pragma_options_align_reset_failed : Warning<
"#pragma options align=reset failed: %0">,
InGroup<IgnoredPragmas>;
@@ -6196,11 +6194,12 @@ def warn_ivars_in_interface : Warning<
"declaration of instance variables in the interface is deprecated">,
InGroup<DiagGroup<"objc-interface-ivars">>, DefaultIgnore;
def ext_c23_enum_value_not_int : Extension<
- "enumerator values exceeding range of 'int' are a C23 extension (%0 is too "
- "%select{small|large}1)">, InGroup<C23>;
+ "%select{|incremented }0enumerator value which exceeds the range of 'int' is "
+ "a C23 extension (%1 is too %select{small|large}2)">, InGroup<C23>;
def warn_c17_compat_enum_value_not_int : Warning<
- "enumerator values exceeding range of 'int' are incompatible with C standards before C23 (%0 is too "
- "%select{small|large}1)">, DefaultIgnore, InGroup<CPre23Compat>;
+ "%select{|incremented }0enumerator value which exceeds the range of 'int' is "
+ "incompatible with C standards before C23 (%1 is too %select{small|large}2)">,
+ DefaultIgnore, InGroup<CPre23Compat>;
def ext_enum_too_large : ExtWarn<
"enumeration values exceed range of largest integer">, InGroup<EnumTooLarge>;
def ext_enumerator_increment_too_large : ExtWarn<
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 2d4082f7150943..c5ab6072f96361 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -19479,10 +19479,10 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// Complain if the value is not representable in an int.
if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) {
- Diag(IdLoc, (getLangOpts().C23)
+ Diag(IdLoc, getLangOpts().C23
? diag::warn_c17_compat_enum_value_not_int
: diag::ext_c23_enum_value_not_int)
- << toString(EnumVal, 10) << Val->getSourceRange()
+ << 0 << toString(EnumVal, 10) << Val->getSourceRange()
<< (EnumVal.isUnsigned() || EnumVal.isNonNegative());
} else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
// Force the type of the expression to 'int'.
@@ -19565,16 +19565,16 @@ EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
// Exclude fixed enumerators since they are diagnosed with an error for
// this case.
if (!getLangOpts().CPlusPlus && !T.isNull() && !Enum->isFixed())
- Diag(IdLoc, (getLangOpts().C23)
- ? diag::warn_c17_compat_enum_value_int_overflow
- : diag::ext_c23_enum_value_int_overflow);
+ Diag(IdLoc, getLangOpts().C23
+ ? diag::warn_c17_compat_enum_value_not_int
+ : diag::ext_c23_enum_value_not_int)
+ << 1 << toString(EnumVal, 10) << 1;
} else if (!getLangOpts().CPlusPlus && !EltTy->isDependentType() &&
!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
// Enforce C99 6.7.2.2p2 even when we compute the next value.
- Diag(IdLoc, (getLangOpts().C23)
- ? diag::warn_c17_compat_enum_value_not_int
- : diag::ext_c23_enum_value_not_int)
- << toString(EnumVal, 10) << 1;
+ Diag(IdLoc, getLangOpts().C23 ? diag::warn_c17_compat_enum_value_not_int
+ : diag::ext_c23_enum_value_not_int)
+ << 1 << toString(EnumVal, 10) << 1;
}
}
}
diff --git a/clang/test/C/C23/n3029.c b/clang/test/C/C23/n3029.c
index d1f8306fb7709a..26d6dfdcc60462 100644
--- a/clang/test/C/C23/n3029.c
+++ b/clang/test/C/C23/n3029.c
@@ -1,4 +1,5 @@
-// RUN: %clang_cc1 -verify -triple x86_64-unknown-linux-gnu -fsyntax-only --embed-dir=%S/Inputs -std=c23 %s -pedantic -Wpre-c23-compat
+// RUN: %clang_cc1 -verify=expected,all -triple x86_64-unknown-linux-gnu -fsyntax-only -std=c23 %s -Wpre-c23-compat
+// RUN: %clang_cc1 -verify=pedantic,all -triple x86_64-unknown-linux-gnu -fsyntax-only -std=c17 %s -pedantic
#include <limits.h>
@@ -19,7 +20,8 @@
enum x {
a = INT_MAX,
-b = ULLONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
+b = ULLONG_MAX, // expected-warning {{enumerator value which exceeds the range of 'int' is incompatible with C standards before C23}}
+ // pedantic-warning at -1 {{enumerator value which exceeds the range of 'int' is a C23 extension}}
a_type = GET_TYPE_INT(a),
b_type = GET_TYPE_INT(b)
};
@@ -31,29 +33,33 @@ extern __typeof(b) e_a;
extern __typeof(a) e_a;
enum a {
- a0 = 0xFFFFFFFFFFFFFFFFULL // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
+ a0 = 0xFFFFFFFFFFFFFFFFULL // expected-warning {{enumerator value which exceeds the range of 'int' is incompatible with C standards before C23}}
+ // pedantic-warning at -1 {{enumerator value which exceeds the range of 'int' is a C23 extension}}
};
-_Bool e () {
+_Bool e (void) {
return a0;
}
-int f () {
- return a0; // expected-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 18446744073709551615 to -1}}
+int f (void) {
+ return a0; // all-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 18446744073709551615 to -1}}
}
-unsigned long g () {
+unsigned long g (void) {
return a0;
}
-unsigned long long h () {
+unsigned long long h (void) {
return a0;
}
enum big_enum {
- big_enum_a = LONG_MAX, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
- big_enum_b = a + 1, // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
- big_enum_c = ULLONG_MAX // expected-warning {{enumerator values exceeding range of 'int' are incompatible with C standards before C23}}
+ big_enum_a = LONG_MAX, // expected-warning {{enumerator value which exceeds the range of 'int' is incompatible with C standards before C23}}
+ // pedantic-warning at -1 {{enumerator value which exceeds the range of 'int' is a C23 extension}}
+ big_enum_b = a + 1, // expected-warning {{enumerator value which exceeds the range of 'int' is incompatible with C standards before C23}}
+ // pedantic-warning at -1 {{enumerator value which exceeds the range of 'int' is a C23 extension}}
+ big_enum_c = ULLONG_MAX // expected-warning {{enumerator value which exceeds the range of 'int' is incompatible with C standards before C23}}
+ // pedantic-warning at -1 {{enumerator value which exceeds the range of 'int' is a C23 extension}}
};
_Static_assert(GET_TYPE_INT(big_enum_a) == GET_TYPE_INT(big_enum_b), "ok");
diff --git a/clang/test/Sema/enum.c b/clang/test/Sema/enum.c
index 80be9d24c8d990..4f6d04ba7f9182 100644
--- a/clang/test/Sema/enum.c
+++ b/clang/test/Sema/enum.c
@@ -1,23 +1,23 @@
-// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify=expected,c99 -pedantic
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fsyntax-only -std=c23 -verify -pedantic
+// RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify=expected,pre-c23 -pedantic
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -fsyntax-only -std=c23 -verify=expected -pedantic
enum e {A,
- B = 42LL << 32, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
+ B = 42LL << 32, // pre-c23-warning {{enumerator value which exceeds the range of 'int' is a C23 extension}}
C = -4, D = 12456 };
enum f { a = -2147483648, b = 2147483647 }; // ok.
enum g { // too negative
- c = -2147483649, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
+ c = -2147483649, // pre-c23-warning {{enumerator value which exceeds the range of 'int' is a C23 extension}}
d = 2147483647 };
enum h { e = -2147483648, // too pos
- f = 2147483648, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
- i = 0xFFFF0000 // c99-warning {{too large}}
+ f = 2147483648, // pre-c23-warning {{enumerator value which exceeds the range of 'int' is a C23 extension}}
+ i = 0xFFFF0000 // pre-c23-warning {{too large}}
};
// minll maxull
enum x // expected-warning {{enumeration values exceed range of largest integer}}
-{ y = -9223372036854775807LL-1, // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
-z = 9223372036854775808ULL }; // c99-warning {{enumerator values exceeding range of 'int' are a C23 extension}}
+{ y = -9223372036854775807LL-1, // pre-c23-warning {{enumerator value which exceeds the range of 'int' is a C23 extension}}
+z = 9223372036854775808ULL }; // pre-c23-warning {{enumerator value which exceeds the range of 'int' is a C23 extension}}
int test(void) {
return sizeof(enum e) ;
@@ -171,10 +171,7 @@ enum class GH42372_2 {
enum IncOverflow {
V2 = __INT_MAX__,
- V3 // c99-warning {{incremented enumerator value that is exceeding range of 'int' is a C23 extension}}
-#if __STDC_VERSION__ >= 202311L
- // expected-warning at -2 {{incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23}}
-#endif
+ V3 // pre-c23-warning {{incremented enumerator value which exceeds the range of 'int' is a C23 extension}}
};
#if __STDC_VERSION__ >= 202311L
@@ -207,7 +204,7 @@ void fooinc23() {
enum E2 {
V2 = INT_MAX,
- V3 // expected-warning {{incremented enumerator value that is exceeding range of 'int' is incompatible with C standards before C23}}
+ V3
} e2;
enum E3 {
More information about the cfe-commits
mailing list