Fix function types

various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.

Michael Matz committed 9 years ago

Commit 04418c71 parent 2acb04f3 files · +42 −11Browse files

Unified · Split

3 files

tccgen.c +19 −11
tests/tests2/39_typedef.c +18 −0
tests/tests2/82_attribs_position.c +5 −0

tccgen.c+19−11

     }
 }
+static void sym_to_attr(AttributeDef *ad, Sym *s)
+{
+    if (s->a.aligned && 0 == ad->a.aligned)
+        ad->a.aligned = s->a.aligned;
+    if (s->f.func_call && 0 == ad->f.func_call)
+        ad->f.func_call = s->f.func_call;
+    if (s->f.func_type && 0 == ad->f.func_type)
+        ad->f.func_type = s->f.func_type;
+    if (s->a.packed)
+        ad->a.packed = 1;
+}
 /* Add type qualifiers to a type. If the type is an array then the qualifiers
    are added to the element type, copied because it could be a typedef. */
 static void parse_btype_qualify(CType *type, int qualifiers)
             parse_expr_type(&type1);
             /* remove all storage modifiers except typedef */
             type1.t &= ~(VT_STORAGE&~VT_TYPEDEF);
+	    if (type1.ref)
+                sym_to_attr(ad, type1.ref);
             goto basic_type2;
         default:
             if (typespec_found)
                 parse_btype_qualify(type, t);
             t = type->t;
             /* get attributes from typedef */
-            if (s->a.aligned && 0 == ad->a.aligned)
+            sym_to_attr(ad, s);
-                ad->a.aligned = s->a.aligned;
-            if (s->f.func_call && 0 == ad->f.func_call)
-                ad->f.func_call = s->f.func_call;
-            if (s->a.packed)
-                ad->a.packed = 1;
             next();
             typespec_found = 1;
             st = bt = -2;
     ln = file->line_num;
     /* iterate while inline function are referenced */
-    for(;;) {
+    do {
         inline_generated = 0;
         for (i = 0; i < s->nb_inline_fns; ++i) {
             fn = s->inline_fns[i];
                 inline_generated = 1;
             }
         }
-        if (!inline_generated)
+    } while (inline_generated);
-            break;
-    }
     file->line_num = ln;
 }
                         sym = sym_push(v, &type, 0, 0);
                     }
                     sym->a = ad.a;
+                    sym->f = ad.f;
                 } else {
                     r = 0;
                     if ((type.t & VT_BTYPE) == VT_FUNC) {
                         /* external function definition */
                         /* specific case for func_call attribute */
-                        type.ref->a = ad.a;
+                        type.ref->f = ad.f;
                     } else if (!(type.t & VT_ARRAY)) {
                         /* not lvalue if array */
                         r |= lvalue_type(type.t);

tests/tests2/39_typedef.c+18−0

@@ -44,4 +44,22 @@ extern const int cb[1][2][3]; · 43 unmodified lines
44	extern B b;	44	extern B b;
45	extern int b[1][2][3];	45	extern int b[1][2][3];
46		46
		47	/* Funny but valid function declaration. */
		48	typedef int functype (int);
		49	extern functype func;
		50	int func(int i)
		51	{
		52	return i + 1;
		53	}
		54
		55	/* Even funnier function decl and definition using typeof. */
		56	int set_anon_super(void);
		57	int set_anon_super(void)
		58	{
		59	return 42;
		60	}
		61	typedef int sas_type (void);
		62	extern typeof(set_anon_super) set_anon_super;
		63	extern sas_type set_anon_super;
		64
47	/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/	65	/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

tests/tests2/82_attribs_position.c+5−0

@@ -11,4 +11,9 @@ typedef union __attribute__((packed)) Unaligned16b { · 10 unmodified lines
11	uint8_t b[2];	11	uint8_t b[2];
12	} Unaligned16b;	12	} Unaligned16b;
13		13
		14	extern void foo (void) __attribute__((stdcall));
		15	void __attribute__((stdcall)) foo (void)
		16	{
		17	}
		18
14	int main () { return 0; }	19	int main () { return 0; }

Fix function types

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code