struct-init: Correctly parse unnamed member initializers

For union U { struct {int a,b}; int c; }; union U u = {{ 1, 2, }}; The unnamed first member of union U needs to actually exist in the structure so initializer parsing isn't confused about the double braces. That means also the a and b members must be part of _that_, not of union U directly. Which in turn means we need to do a bit more work for field lookup. See the testcase extension for more things that need to work.

Michael Matz committed 10 years ago

Commit 9e86ebe1 parent 21da73c3 files · +78 −21Browse files

Unified · Split

3 files

tccgen.c +51 −21
tests/tests2/86-struct-init.c +23 −0
tests/tests2/86-struct-init.expect +4 −0

tccgen.c+51−21

     }
 }
+static Sym * find_field (CType *type, int v)
+{
+    Sym *s = type->ref;
+    v |= SYM_FIELD;
+    while ((s = s->next) != NULL) {
+	if ((s->v & SYM_FIELD) && (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
+	    Sym *ret = find_field (&s->type, v);
+	    if (ret)
+	        return ret;
+	}
+	if (s->v == v)
+	  break;
+    }
+    return s;
+}
 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
 static void struct_decl(CType *type, AttributeDef *ad, int u)
 {
 #endif
                     }
                     if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) {
+			/* An anonymous struct/union.  Adjust member offsets
+			   to reflect the real offset of our containing struct.
+			   Also set the offset of this anon member inside
+			   the outer struct to be zero.  Via this it
+			   works when accessing the field offset directly
+			   (from base object), as well as when recursing
+			   members in initializer handling.  */
+			int v2 = btype.ref->v;
+			if (!(v2 & SYM_FIELD) &&
+			    (v2 & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
+			    Sym **pps;
+			    /* This happens only with MS extensions.  The
+			       anon member has a named struct type, so it
+			       potentially is shared with other references.
+			       We need to unshare members so we can modify
+			       them.  */
+			    ass = type1.ref;
+			    type1.ref = sym_push(anon_sym++ | SYM_FIELD,
+						 &type1.ref->type, 0,
+						 type1.ref->c);
+			    pps = &type1.ref->next;
+			    while ((ass = ass->next) != NULL) {
+			        *pps = sym_push(ass->v, &ass->type, 0, ass->c);
+				pps = &((*pps)->next);
+			    }
+			    *pps = NULL;
+			}
                         ass = type1.ref;
-                        while ((ass = ass->next) != NULL) {
+                        while ((ass = ass->next) != NULL)
-                           ss = sym_push(ass->v, &ass->type, 0, offset + ass->c);
+			    ass->c += offset;
-                           *ps = ss;
+			offset = 0;
-                           ps = &ss->next;
+		        v = anon_sym++;
-                        }
+		    }
-                    } else if (v) {
+                    if (v) {
                         ss = sym_push(v | SYM_FIELD, &type1, 0, offset);
                         *ps = ss;
                         ps = &ss->next;
             next();
             if (tok == TOK_CINT || tok == TOK_CUINT)
                 expect("field name");
-            s = vtop->type.ref;
+	    s = find_field(&vtop->type, tok);
-            /* find field */
-            tok |= SYM_FIELD;
-            while ((s = s->next) != NULL) {
-                if (s->v == tok)
-                    break;
-            }
             if (!s)
                 tcc_error("field not found: %s",  get_tok_str(tok & ~SYM_FIELD, &tokc));
             /* add field offset to pointer */
         struct_field:
             if ((type->t & VT_BTYPE) != VT_STRUCT)
                 expect("struct/union type");
-            s = type->ref;
+	    f = find_field(type, l);
-            l |= SYM_FIELD;
-            f = s->next;
-            while (f) {
-                if (f->v == l)
-                    break;
-                f = f->next;
-            }
             if (!f)
                 expect("field");
             if (!notfirst)

tests/tests2/86-struct-init.c+23−0

@@ -77,6 +77,25 @@ struct SU { · 76 unmodified lines
77	};	77	};
78	struct SU gsu = {5,6};	78	struct SU gsu = {5,6};
79		79
		80	/* Unnamed struct/union members aren't ISO C, but it's a widely accepted
		81	extension. See below for further extensions to that under -fms-extension.*/
		82	union UV {
		83	struct {u8 a,b;};
		84	struct S s;
		85	};
		86	union UV guv = {{6,5}};
		87	union UV guv2 = {{.b = 7, .a = 8}};
		88	union UV guv3 = {.b = 8, .a = 7};
		89
		90	/* Under -fms-extensions also the following is valid:
		91	union UV2 {
		92	struct Anon {u8 a,b;}; // unnamed member, but tagged struct, ...
		93	struct S s;
		94	};
		95	struct Anon gan = { 10, 11 }; // ... which makes it available here.
		96	union UV2 guv4 = {{4,3}}; // and the other inits from above as well
		97	*/
		98
80	#include <stdio.h>	99	#include <stdio.h>
81	void print_ (const char name, const u8 p, long size)	100	void print_ (const char name, const u8 p, long size)
82	{	101	{
@@ -144,6 +163,10 @@ int main() · 61 unmodified lines
144	print(sinit16);	163	print(sinit16);
145	print(gw);	164	print(gw);
146	print(gsu);	165	print(gsu);
		166	print(guv);
		167	print(guv.b);
		168	print(guv2);
		169	print(guv3);
147	foo(&gw);	170	foo(&gw);
148	//printf("q: %s\n", q);	171	//printf("q: %s\n", q);
149	return 0;	172	return 0;

tests/tests2/86-struct-init.expect+4−0

@@ -13,6 +13,10 @@ gv3: 7 8 9 a 68 6f 68 6f 0 0 0 0 0 0 0 0 0 0 0 0 31 32 · 12 unmodified lines
13	sinit16: 1 0 0 0 2 0 0 0	13	sinit16: 1 0 0 0 2 0 0 0
14	gw: 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0	14	gw: 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
15	gsu: 5 6	15	gsu: 5 6
		16	guv: 6 5 0 0
		17	guv.b: 5
		18	guv2: 8 7 0 0
		19	guv3: 7 8 0 0
16	ls: 1 2 3 4	20	ls: 1 2 3 4
17	ls2: 1 2 3 4	21	ls2: 1 2 3 4
18	lt: 68 65 6c 6c 6f 0 0 0 0 0 0 0 0 0 0 0 2a	22	lt: 68 65 6c 6c 6f 0 0 0 0 0 0 0 0 0 0 0 2a

struct-init: Correctly parse unnamed member initializers

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code