[PATCH 04/73] bitfield: Pack consecutive _Bool bitfields into byte containers

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

Round bitfield base storage unit sizes smaller than a byte up to
bits_in_char in bitfield_base_size() and widen sub-byte bitfield access
containers to uchar_ctype in bitfield_base_type() so _Bool bitfields use
an 8-bit storage unit during both struct layout and IR linearization.

Allow consecutive _Bool bitfields to pack into a single byte in
examine_struct_union_type() and emit bitfield extract and insert
instructions at each member's bit_offset, matching the System V ABI,
GCC, and Clang. Remove check-known-to-fail from
validation/bitfield-bool-layout.c.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 evaluate.c                        | 18 ++++++-------
 linearize.c                       |  2 ++
 symbol.c                          |  2 ++
 symbol.h                          |  2 ++
 validation/bitfield-bool-layout.c |  9 +++----
 validation/linear/bitfield-bool.c | 44 +++++++++++++++++++++++++++++++
 6 files changed, 62 insertions(+), 15 deletions(-)
 create mode 100644 validation/linear/bitfield-bool.c

diff --git a/evaluate.c b/evaluate.c
index 988ace95abed..40778f4e8a63 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -1406,12 +1406,12 @@ static int check_assignment_types(struct symbol *target, struct expression **rp,
 				return 1;
 		} else if (!(sclass & TYPE_RESTRICT))
 			goto Cast;
-                if (t == &bool_ctype) {
-                        if (is_fouled_type(s))
-                                warning((*rp)->pos, "%s degrades to integer",
-                                        show_typename(s->ctype.base_type));
-                        goto Cast;
-                }
+		if (is_bool_type(t)) {
+			if (is_fouled_type(s))
+				warning((*rp)->pos, "%s degrades to integer",
+					show_typename(s->ctype.base_type));
+			goto Cast;
+		}
 		*typediff = "different base types";
 		return 0;
 	}
@@ -1475,7 +1475,7 @@ static int check_assignment_types(struct symbol *target, struct expression **rp,
 
 	if (tclass & TYPE_NUM) {
 		/* XXX: need to turn into comparison with NULL */
-		if (t == &bool_ctype && (sclass & TYPE_PTR))
+		if (is_bool_type(t) && (sclass & TYPE_PTR))
 			goto Cast;
 		*typediff = "different base types";
 		return 0;
@@ -3064,7 +3064,7 @@ static struct symbol *evaluate_cast(struct expression *expr)
 			warning(expr->pos, "cast to %s",
 				show_typename(ttype));
 		if (sclass & TYPE_RESTRICT) {
-			if (ttype == &bool_ctype) {
+			if (is_bool_type(ttype)) {
 				if (sclass & TYPE_FOULED)
 					warning(expr->pos, "%s degrades to integer",
 						show_typename(stype));
@@ -3111,7 +3111,7 @@ static struct symbol *evaluate_cast(struct expression *expr)
 		}
 	}
 
-	if (ttype == &bool_ctype)
+	if (is_bool_type(ttype))
 		cast_to_bool(expr);
 
 	// checks pointers to restricted
diff --git a/linearize.c b/linearize.c
index 5bdd6119260f..75850df0a90f 100644
--- a/linearize.c
+++ b/linearize.c
@@ -934,6 +934,8 @@ static struct symbol *bitfield_base_type(struct symbol *sym)
 			base = base->ctype.base_type;
 		if (base->type == SYM_BITFIELD) {
 			base = base->ctype.base_type;
+			if (base->bit_size < bits_in_char)
+				base = &uchar_ctype;
 			if (sym->packed) {
 				int size = bits_to_bytes(sym->bit_offset + sym->bit_size);
 				sym = __alloc_symbol(0);
diff --git a/symbol.c b/symbol.c
index 5470880db271..feaaed3b8a2d 100644
--- a/symbol.c
+++ b/symbol.c
@@ -113,6 +113,8 @@ static int bitfield_base_size(struct symbol *sym)
 		sym = sym->ctype.base_type;
 	if (sym->type == SYM_BITFIELD)
 		sym = sym->ctype.base_type;
+	if (sym->bit_size < bits_in_char)
+		return bits_in_char;
 	return sym->bit_size;
 }
 
diff --git a/symbol.h b/symbol.h
index 9ff2733021b8..bd163450628b 100644
--- a/symbol.h
+++ b/symbol.h
@@ -477,6 +477,8 @@ static inline int is_bool_type(struct symbol *type)
 {
 	if (type->type == SYM_NODE)
 		type = type->ctype.base_type;
+	if (type->type == SYM_BITFIELD)
+		type = type->ctype.base_type;
 	return type == &bool_ctype;
 }
 
diff --git a/validation/bitfield-bool-layout.c b/validation/bitfield-bool-layout.c
index 4e0a2b4a2b60..2f559f98491f 100644
--- a/validation/bitfield-bool-layout.c
+++ b/validation/bitfield-bool-layout.c
@@ -12,14 +12,11 @@ struct bfb foo(struct bfb s)
 
 /*
  * check-name: bitfield-bool-layout
- * check-description: given that bool is here 1-bit wide
- *	each field here above completely 'fill' a bool.
- *	Thus 3 bools need to be allocated, but since the
- *	alignment is 1-byte the result has a size of 3
- *	bytes, 24 bits thus instead of 8.
+ * check-description: Verify that consecutive _Bool bitfields pack into a
+ *	single 1-byte (8-bit) storage unit rather than allocating a separate
+ *	byte per bitfield (24 bits).
  * check-command: test-linearize -Wno-decl $file
  *
- * check-known-to-fail
  * check-output-ignore
  * check-output-excludes: ret\\.24
  * check-output-contains: ret\\.8
diff --git a/validation/linear/bitfield-bool.c b/validation/linear/bitfield-bool.c
new file mode 100644
index 000000000000..91c9111eb91d
--- /dev/null
+++ b/validation/linear/bitfield-bool.c
@@ -0,0 +1,44 @@
+struct bfb {
+	_Bool a:1;
+	_Bool f:1;
+	_Bool z:1;
+};
+
+_Bool get_z(struct bfb *p)
+{
+	return p->z;
+}
+
+void set_f_one(struct bfb *p)
+{
+	p->f = 1;
+}
+
+void set_f_two(struct bfb *p)
+{
+	p->f = 2;
+}
+
+void set_f_ptr(struct bfb *p, int *ptr)
+{
+	p->f = ptr;
+}
+
+int init_bfb(void)
+{
+	struct bfb s = { .a = 1, .z = 1 };
+	return s.a + s.f + s.z;
+}
+
+/*
+ * check-name: bitfield-bool-linearize
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-ignore
+ * check-output-excludes: load\\.1
+ * check-output-excludes: store\\.1
+ * check-output-contains: load\\.8
+ * check-output-contains: store\\.8
+ * check-output-pattern(2): or\\.8.*\\$2
+ * check-output-contains: ret\\.32.*\\$2
+ */