[PATCH 62/73] enum: Support machine mode attributes on enumeration types

[Bart Van Assche <bvanassche@acm.org>]

Support GCC machine mode attributes (such as mode(__byte__)) on both
enum declarations and enum type definitions:
- Apply prefix and postfix mode attributes on enum definitions to the
  enum's underlying type, size, alignment, and rank when no C23 fixed
  underlying type is present.
- Inspect underlying SYM_NODE and SYM_ENUM signedness in to_*_mode()
  so unsigned enums preserve unsignedness when converted to a mode.
- Expand validation/enum+mode.c and remove check-known-to-fail.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 parse.c                | 84 ++++++++++++++++++++++++++++++------------
 symbol.c               |  2 +-
 symbol.h               |  1 +
 validation/enum+mode.c | 26 ++++++++++++-
 4 files changed, 87 insertions(+), 26 deletions(-)

diff --git a/parse.c b/parse.c
index d89f60113152..b686d2d55c36 100644
--- a/parse.c
+++ b/parse.c
@@ -992,6 +992,20 @@ static struct token *struct_union_enum_specifier(enum type type,
 		else
 			warning(token->pos, "attribute __transparent_union__ applied to non-union type");
 	}
+	if (sym->type == SYM_ENUM && attr.mode && attr.mode->to_mode &&
+	    !sym->fixed_type && sym->ctype.base_type &&
+	    is_int_type(sym->ctype.base_type)) {
+		struct symbol *mtype = attr.mode->to_mode(sym);
+		if (mtype) {
+			sym->ctype.base_type = mtype;
+			sym->has_mode = 1;
+			sym->ctype.modifiers &= ~MOD_SIGNEDNESS;
+			sym->ctype.modifiers |= (mtype->ctype.modifiers & MOD_SIGNEDNESS);
+			sym->bit_size = mtype->bit_size;
+			sym->ctype.alignment = mtype->ctype.alignment;
+			sym->rank = mtype->rank;
+		}
+	}
 
 	sym->endpos = token->pos;
 
@@ -1599,62 +1613,86 @@ static struct token *attribute_address_space(struct token *token, struct symbol
 	return token;
 }
 
+static inline bool is_int_or_enum(struct symbol *ctype)
+{
+	if (!ctype)
+		return false;
+	if (ctype->type == SYM_ENUM)
+		return true;
+	if (ctype->ctype.base_type == &int_type)
+		return true;
+	if (ctype->type == SYM_NODE && ctype->ctype.base_type &&
+	    (ctype->ctype.base_type->type == SYM_ENUM ||
+	     ctype->ctype.base_type->ctype.base_type == &int_type))
+		return true;
+	return false;
+}
+
+static inline bool is_unsigned_mode_type(struct symbol *ctype)
+{
+	if (!ctype)
+		return false;
+	if (ctype->type == SYM_NODE || ctype->type == SYM_ENUM)
+		examine_symbol_type(ctype);
+	while (ctype && (ctype->type == SYM_NODE || ctype->type == SYM_ENUM)) {
+		if (ctype->ctype.modifiers & MOD_UNSIGNED)
+			return true;
+		if (ctype->ctype.modifiers & MOD_SIGNED)
+			return false;
+		ctype = ctype->ctype.base_type;
+	}
+	return ctype && (ctype->ctype.modifiers & MOD_UNSIGNED);
+}
+
 static struct symbol *to_QI_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	if (ctype == &char_ctype)
-		return ctype;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uchar_ctype
-						     : &schar_ctype;
+	if (cbase_type(ctype) == &char_ctype)
+		return &char_ctype;
+	return is_unsigned_mode_type(ctype) ? &uchar_ctype : &schar_ctype;
 }
 
 static struct symbol *to_HI_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ushort_ctype
-						     : &sshort_ctype;
+	return is_unsigned_mode_type(ctype) ? &ushort_ctype : &sshort_ctype;
 }
 
 static struct symbol *to_SI_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uint_ctype
-						     : &sint_ctype;
+	return is_unsigned_mode_type(ctype) ? &uint_ctype : &sint_ctype;
 }
 
 static struct symbol *to_DI_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ullong_ctype
-						     : &sllong_ctype;
+	return is_unsigned_mode_type(ctype) ? &ullong_ctype : &sllong_ctype;
 }
 
 static struct symbol *to_TI_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uint128_ctype
-						     : &sint128_ctype;
+	return is_unsigned_mode_type(ctype) ? &uint128_ctype : &sint128_ctype;
 }
 
 static struct symbol *to_pointer_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? uintptr_ctype
-						     :  intptr_ctype;
+	return is_unsigned_mode_type(ctype) ? uintptr_ctype : intptr_ctype;
 }
 
 static struct symbol *to_word_mode(struct symbol *ctype)
 {
-	if (ctype->ctype.base_type != &int_type)
+	if (!is_int_or_enum(ctype))
 		return NULL;
-	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ulong_ctype
-						     : &slong_ctype;
+	return is_unsigned_mode_type(ctype) ? &ulong_ctype : &slong_ctype;
 }
 
 static struct token *attribute_mode(struct token *token, struct symbol *attr, struct decl_state *ctx)
diff --git a/symbol.c b/symbol.c
index 721dd1e81ae5..d4b945d9e161 100644
--- a/symbol.c
+++ b/symbol.c
@@ -592,7 +592,7 @@ static struct symbol *examine_enum_type(struct symbol *sym)
 	struct symbol *base_type = examine_base_type(sym);
 
 	sym->ctype.modifiers |= (base_type->ctype.modifiers & MOD_SIGNEDNESS);
-	if (sym->fixed_type) {
+	if (sym->fixed_type || sym->has_mode) {
 		if (base_type == &bool_ctype)
 			sym->bit_size = bits_to_bytes(bits_in_bool) * bits_in_char;
 		else
diff --git a/symbol.h b/symbol.h
index bb063dc622e0..aa180ac4f514 100644
--- a/symbol.h
+++ b/symbol.h
@@ -214,6 +214,7 @@ struct symbol {
 			unsigned int kr_args : 1;
 			unsigned int underspecified : 1;
 			unsigned int c23_auto : 1;
+			unsigned int has_mode : 1;
 			int		rank:3;	// arithmetic's rank
 			struct expression *array_size;
 			struct ctype ctype;
diff --git a/validation/enum+mode.c b/validation/enum+mode.c
index 182af1895d49..cfd037e8617b 100644
--- a/validation/enum+mode.c
+++ b/validation/enum+mode.c
@@ -3,6 +3,7 @@ enum e { ZERO, ONE, TWO };
 struct s {
 	enum e __attribute__ ((mode(__byte__))) b;
 	enum e __attribute__ ((mode(__word__))) w;
+	enum e __attribute__ ((mode(__DI__))) d;
 	enum e __attribute__ ((mode(__TI__))) t;
 };
 
@@ -10,9 +11,30 @@ static struct s s;
 
 _Static_assert(sizeof(s.b) == 1, "");
 _Static_assert(sizeof(s.w) == sizeof(long), "");
-_Static_assert(sizeof(s.t) == sizeof(long long), "");
+_Static_assert(sizeof(s.d) == sizeof(long long), "");
+_Static_assert(sizeof(s.t) == 16, "");
+
+typedef enum { M_ZERO, M_ONE } __attribute__((mode(__byte__))) byte_enum_t;
+_Static_assert(sizeof(byte_enum_t) == 1, "typedef anon enum mode");
+_Static_assert((byte_enum_t)-1 > 0, "unsigned enum mode stays unsigned");
+
+typedef enum tagged_m { TM_0, TM_1 } __attribute__((mode(__byte__))) tagged_byte_t;
+_Static_assert(sizeof(tagged_byte_t) == 1, "typedef tagged enum mode");
+_Static_assert(sizeof(enum tagged_m) == 1, "tagged enum itself gets mode");
+
+enum __attribute__((mode(__HI__))) hi_enum { HI_0 = -1, HI_1 = 1 };
+_Static_assert(sizeof(enum hi_enum) == 2, "prefix mode on enum");
+_Static_assert((enum hi_enum)-1 < 0, "signed enum mode stays signed");
+
+enum post_qi { PQ_0 = 0, PQ_1 = 200 } __attribute__((mode(__QI__)));
+_Static_assert(sizeof(enum post_qi) == 1, "postfix mode on enum");
+_Static_assert((enum post_qi)-1 > 0, "postfix QI mode unsigned");
+
+typedef enum { UE_0 = 0, UE_1 = 1 } uenum_t;
+static uenum_t __attribute__((mode(__byte__))) ub;
+_Static_assert(sizeof(ub) == 1, "typedef var mode size");
+_Static_assert((typeof(ub))-1 > 0, "typedef var mode unsigned");
 
 /*
  * check-name: enum+mode
- * check-known-to-fail
  */