Fix struct layout some more

Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.

Michael Matz committed 10 years ago

Commit 78c70961 parent ddecb0e2 files · +199 −40Browse files

Unified · Split

2 files

tccgen.c +113 −40
tests/tcctest.c +86 −0

tccgen.c+113−40

     Sym *s = type->ref;
     v |= SYM_FIELD;
     while ((s = s->next) != NULL) {
-	if ((s->v & SYM_FIELD) && (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
+	if ((s->v & SYM_FIELD) &&
+	    (s->type.t & VT_BTYPE) == VT_STRUCT &&
+	    (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
 	    Sym *ret = find_field (&s->type, v);
 	    if (ret)
 	        return ret;
     return s;
 }
+static void struct_add_offset (Sym *s, int offset)
+{
+    while ((s = s->next) != NULL) {
+	if ((s->v & SYM_FIELD) &&
+	    (s->type.t & VT_BTYPE) == VT_STRUCT &&
+	    (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
+	    struct_add_offset(s->type.ref, offset);
+	} else
+	  s->c += offset;
+    }
+}
 static void struct_layout(CType *type, AttributeDef *ad)
 {
-    int align, maxalign, offset, c;
+    int align, maxalign, offset, c, bit_pos;
     Sym *f;
-    maxalign = 1;
+    if (ad->a.aligned)
+      maxalign = ad->a.aligned;
+    else
+      maxalign = 1;
     offset = 0;
     c = 0;
+    bit_pos = 0;
     for (f = type->ref->next; f; f = f->next) {
-	int extra_bytes = f->c;
+	int extra_bytes = 0;
-	int bit_pos;
+	int typealign, bit_size;
-	int size = type_size(&f->type, &align);
+	int size = type_size(&f->type, &typealign);
-	if (f->type.t & VT_BITFIELD)
+	int pcc = !tcc_state->ms_bitfields;
-	  bit_pos = (f->type.t >> VT_STRUCT_SHIFT) & 0x3f;
+	if (f->type.t & VT_BITFIELD) {
-	else
+	    bit_size = (f->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
-	  bit_pos = 0;
+	    /* without ms-bitfields, allocate the
-	if (f->r) {
+	     * minimum number of bytes necessary,
+	     * adding single bytes as needed */
+	    if (!tcc_state->ms_bitfields) {
+		if (bit_pos == 0)
+		  /* minimum bytes for new bitfield */
+		  size = (bit_size + 7) / 8;
+		else {
+		    /* enough spare bits already allocated? */
+		    int add_size = (bit_pos - 1) % 8 + 1 + bit_size;
+		    if (add_size > 8) /* doesn't fit */
+		      extra_bytes = (add_size - 1) / 8;
+		}
+	    }
+	} else
+	  bit_size = -1;
+	if (bit_size == 0 && pcc) {
+	    /* Zero-width bit-fields in PCC mode aren't affected
+	       by any packing (attribute or pragma).  */
+	    align = typealign;
+	} else if (f->r > 1) {
 	    align = f->r;
-	} else if (ad->a.packed) {
+	} else if (ad->a.packed || f->r == 1) {
 	    align = 1;
+	    typealign = 1;
+	} else {
+	    align = typealign;
 	}
-	if (extra_bytes) c += extra_bytes;
+	/*if (extra_bytes) c += extra_bytes;
-	else if (bit_pos == 0) {
+	else*/ if (bit_size < 0) {
+	    int addbytes = (bit_pos + 7) >> 3;
 	    if (type->ref->type.t == TOK_STRUCT) {
-		c = (c + align - 1) & -align;
+		c = (c + addbytes + align - 1) & -align;
 		offset = c;
 		if (size > 0)
 		  c += size;
 	    } else {
 		offset = 0;
+		if (addbytes > c)
+		  c = addbytes;
 		if (size > c)
 		  c = size;
 	    }
 	    if (align > maxalign)
 	      maxalign = align;
+	    bit_pos = 0;
+	} else {
+	    /* A bit-field.  Layout is more complicated.  There are two
+	       options TCC implements: PCC compatible and MS compatible
+	       (PCC compatible is what GCC uses for almost all targets).  */
+	    if (!bit_pos) {
+		if (type->ref->type.t == TOK_STRUCT) {
+		    /* Don't align c here.  That's only to be done
+		       in certain cases.  */
+		    offset = c;
+		} else {
+		    offset = 0;
+		}
+	    }
+	    if (pcc) {
+		/* In PCC layout a non-packed bit-field is placed adjacent
+		   to the preceding bit-fields, except if it would overflow
+		   its container (depending on base type) or it's a zero-width
+		   bit-field.  Packed non-zero-width bit-fields always are
+		   placed adjacent.  */
+		if (typealign != 1 &&
+		    (bit_pos + bit_size > size * 8 ||
+		     bit_size == 0)) {
+		    c = (c + ((bit_pos + 7) >> 3) + typealign - 1) & -typealign;
+		    offset = c;
+		    bit_pos = 0;
+		}
+		/* In PCC layout named bit-fields influence the alignment
+		   of the containing struct using the base types alignment,
+		   except for packed fields or zero-width fields.  */
+		if (bit_size > 0) {
+		    if (align > maxalign)
+		      maxalign = align;
+		    if (typealign > maxalign)
+		      maxalign = typealign;
+		}
+	    } else {
+		tcc_error("ms bit-field layout not implemented");
+	    }
+	    f->type.t = (f->type.t & ~(0x3f << VT_STRUCT_SHIFT))
+		        | (bit_pos << VT_STRUCT_SHIFT);
+	    bit_pos += bit_size;
+	    if (bit_pos >= size * 8) {
+		c += size;
+		bit_pos -= size * 8;
+	    }
 	}
 #if 0
-	printf("set field %s offset=%d",
+	printf("set field %s offset=%d c=%d",
-	       get_tok_str(f->v & ~SYM_FIELD, NULL), offset);
+	       get_tok_str(f->v & ~SYM_FIELD, NULL), offset, c);
 	if (f->type.t & VT_BITFIELD) {
 	    printf(" pos=%d size=%d",
 		   (f->type.t >> VT_STRUCT_SHIFT) & 0x3f,
 		}
 		*pps = NULL;
 	    }
-	    ass = f->type.ref;
+	    struct_add_offset(f->type.ref, offset);
-	    while ((ass = ass->next) != NULL)
-	      ass->c += offset;
 	    f->c = 0;
 	} else {
 	    f->c = offset;
 	f->r = 0;
     }
     /* store size and alignment */
-    type->ref->c = (c + maxalign - 1) & -maxalign;
+    type->ref->c = (c + ((bit_pos + 7) >> 3) + maxalign - 1) & -maxalign;
     type->ref->r = maxalign;
 }
                         } else if (bit_size == bsize) {
                             /* no need for bit fields */
                             bit_pos = 0;
-                        } else if (bit_size == 0) {
-                            /* XXX: what to do if only padding in a
-                               structure ? */
-                            /* zero size: means to pad */
-                            bit_pos = 0;
                         } else {
                             /* if type change, union, or will overrun
                              * allignment slot, start at a newly
                             type1.t |= VT_BITFIELD |
                                 (bit_pos << VT_STRUCT_SHIFT) |
                                 (bit_size << (VT_STRUCT_SHIFT + 6));
-                            /* without ms-bitfields, allocate the
-                             * minimum number of bytes necessary,
-                             * adding single bytes as needed */
-                            if (!tcc_state->ms_bitfields) {
-                                if (bit_pos == 0)
-                                    /* minimum bytes for new bitfield */
-                                    size = (bit_size + 7) / 8;
-                                else {
-                                    /* enough spare bits already allocated? */
-                                    int add_size = (bit_pos - 1) % 8 + 1 + bit_size;
-                                    if (add_size > 8) /* doesn't fit */
-                                        extra_bytes = (add_size - 1) / 8;
-                                }
-                            }
                             bit_pos += bit_size;
                         }
                         prevbt = bt;
 			   anonymous member of struct type.  */
 		        v = anon_sym++;
 		    }
+		    if (v == 0 && bit_size >= 0) {
+			/* Need to remember anon bit-fields as well.
+			   They influence layout.  */
+			v = anon_sym++;
+		    }
                     if (v) {
                         ss = sym_push(v | SYM_FIELD, &type1, alignoverride, extra_bytes);
                         *ps = ss;

tests/tcctest.c+86−0

@@ -1026,10 +1026,67 @@ struct aligntest4 { · 1025 unmodified lines
1026	double a[0];	1026	double a[0];
1027	};	1027	};
1028		1028
		1029	struct __attribute__((aligned(16))) aligntest5
		1030	{
		1031	int i;
		1032	};
		1033	struct aligntest6
		1034	{
		1035	int i;
		1036	} __attribute__((aligned(16)));
		1037	struct aligntest7
		1038	{
		1039	int i;
		1040	};
		1041	struct aligntest5 altest5[2];
		1042	struct aligntest6 altest6[2];
		1043	int pad1;
		1044	/* altest7 is correctly aligned to 16 bytes also with TCC,
		1045	but __alignof__ returns the wrong result (4) because we
		1046	can't store the alignment yet when specified on symbols
		1047	directly (it's stored in the type so we'd need to make
		1048	a copy of it).
		1049	struct aligntest7 altest7[2] __attribute__((aligned(16)));*/
		1050
		1051	struct Large {
		1052	unsigned long flags;
		1053	union {
		1054	void *u1;
		1055	int *u2;
		1056	};
		1057
		1058	struct {
		1059	union {
		1060	unsigned long index;
		1061	void *freelist;
		1062	};
		1063	union {
		1064	unsigned long counters;
		1065	struct {
		1066	int bla;
		1067	};
		1068	};
		1069	};
		1070
		1071	union {
		1072	struct {
		1073	long u3;
		1074	long u4;
		1075	};
		1076	void *u5;
		1077	struct {
		1078	unsigned long compound_head;
		1079	unsigned int compound_dtor;
		1080	unsigned int compound_order;
		1081	};
		1082	};
		1083	} __attribute__((aligned(2 * sizeof(long))));
		1084
1029	void struct_test()	1085	void struct_test()
1030	{	1086	{
1031	struct1 *s;	1087	struct1 *s;
1032	union union2 u;	1088	union union2 u;
		1089	struct Large ls;
1033		1090
1034	printf("struct:\n");	1091	printf("struct:\n");
1035	printf("sizes: %d %d %d %d\n",	1092	printf("sizes: %d %d %d %d\n",
@@ -1037,6 +1094,7 @@ void struct_test() · 1 unmodified line
1037	sizeof(struct struct2),	1094	sizeof(struct struct2),
1038	sizeof(union union1),	1095	sizeof(union union1),
1039	sizeof(union union2));	1096	sizeof(union union2));
		1097	printf("offsets: %d\n", (int)((char)&st1.u.v1 - (char)&st1));
1040	st1.f1 = 1;	1098	st1.f1 = 1;
1041	st1.f2 = 2;	1099	st1.f2 = 2;
1042	st1.f3 = 3;	1100	st1.f3 = 3;
@@ -1065,10 +1123,27 @@ void struct_test() · 22 unmodified lines
1065	sizeof(struct aligntest3), __alignof__(struct aligntest3));	1123	sizeof(struct aligntest3), __alignof__(struct aligntest3));
1066	printf("aligntest4 sizeof=%d alignof=%d\n",	1124	printf("aligntest4 sizeof=%d alignof=%d\n",
1067	sizeof(struct aligntest4), __alignof__(struct aligntest4));	1125	sizeof(struct aligntest4), __alignof__(struct aligntest4));
		1126	printf("aligntest5 sizeof=%d alignof=%d\n",
		1127	sizeof(struct aligntest5), __alignof__(struct aligntest5));
		1128	printf("aligntest6 sizeof=%d alignof=%d\n",
		1129	sizeof(struct aligntest6), __alignof__(struct aligntest6));
		1130	printf("aligntest7 sizeof=%d alignof=%d\n",
		1131	sizeof(struct aligntest7), __alignof__(struct aligntest7));
		1132	printf("altest5 sizeof=%d alignof=%d\n",
		1133	sizeof(altest5), __alignof__(altest5));
		1134	printf("altest6 sizeof=%d alignof=%d\n",
		1135	sizeof(altest6), __alignof__(altest6));
		1136	/*printf("altest7 sizeof=%d alignof=%d\n",
		1137	sizeof(altest7), __alignof__(altest7));*/
1068		1138
1069	/* empty structures (GCC extension) */	1139	/* empty structures (GCC extension) */
1070	printf("sizeof(struct empty) = %d\n", sizeof(struct empty));	1140	printf("sizeof(struct empty) = %d\n", sizeof(struct empty));
1071	printf("alignof(struct empty) = %d\n", __alignof__(struct empty));	1141	printf("alignof(struct empty) = %d\n", __alignof__(struct empty));
		1142
		1143	printf("Large: sizeof=%d\n", sizeof(ls));
		1144	memset(&ls, 0, sizeof(ls));
		1145	ls.compound_head = 42;
		1146	printf("Large: offsetof(compound_head)=%d\n", (int)((char)&ls.compound_head - (char)&ls));
1072	}	1147	}
1073		1148
1074	/* XXX: depend on endianness */	1149	/* XXX: depend on endianness */
@@ -3547,11 +3622,22 @@ typedef struct Spacked3_s { · 2472 unmodified lines
3547	int c;	3622	int c;
3548	} __attribute__((__packed__)) Spacked3;	3623	} __attribute__((__packed__)) Spacked3;
3549	Spacked3 spacked3;	3624	Spacked3 spacked3;
		3625	struct gate_struct64 {
		3626	unsigned short offset_low;
		3627	unsigned short segment;
		3628	unsigned ist : 3, zero0 : 5, type : 5, dpl : 2, p : 1;
		3629	unsigned short offset_middle;
		3630	unsigned offset_high;
		3631	unsigned zero1;
		3632	} __attribute__((packed));
		3633	typedef struct gate_struct64 gate_desc;
		3634	gate_desc a_gate_desc;
3550	void attrib_test(void)	3635	void attrib_test(void)
3551	{	3636	{
3552	printf("attr: %d %d %d %d\n", sizeof(struct Spacked),	3637	printf("attr: %d %d %d %d\n", sizeof(struct Spacked),
3553	sizeof(spacked), sizeof(Spacked2), sizeof(spacked2));	3638	sizeof(spacked), sizeof(Spacked2), sizeof(spacked2));
3554	printf("attr: %d %d\n", sizeof(Spacked3), sizeof(spacked3));	3639	printf("attr: %d %d\n", sizeof(Spacked3), sizeof(spacked3));
		3640	printf("attr: %d %d\n", sizeof(gate_desc), sizeof(a_gate_desc));
3555	}	3641	}
3556	extern __attribute__((__unused__)) char * __attribute__((__unused__)) *	3642	extern __attribute__((__unused__)) char * __attribute__((__unused__)) *
3557	strange_attrib_placement (void);	3643	strange_attrib_placement (void);

Fix struct layout some more

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code