enums and ints are compatible

But like GCC do warn about changes in signedness. The latter leads to some changes in gen_assign_cast to not also warn about unsigned* = int* (where GCC warns, but only with extra warnings).

Michael Matz committed 10 years ago

Commit 34fc6431 parent b1a906b4 files · +35 −14Browse files

Unified · Split

4 files

tcc.h +2 −1
tccasm.c +1 −1
tccgen.c +31 −11
tests/tcctest.c +1 −1

tcc.h+2−1

@@ -387,7 +387,8 @@ struct Attribute { · 386 unmodified lines
387	mode : 4,	387	mode : 4,
388	weak : 1,	388	weak : 1,
389	visibility : 2,	389	visibility : 2,
390	fill : 8; // 8 bits left to fit well in union below	390	unsigned_enum : 1,
		391	fill : 7; // 7 bits left to fit well in union below
391	};	392	};
392		393
393	/* GNUC attribute definition */	394	/* GNUC attribute definition */

tccasm.c+1−1

@@ -612,7 +612,7 @@ static void asm_parse_directive(TCCState *s1) · 611 unmodified lines
612	case TOK_ASMDIR_global:	612	case TOK_ASMDIR_global:
613	case TOK_ASMDIR_weak:	613	case TOK_ASMDIR_weak:
614	case TOK_ASMDIR_hidden:	614	case TOK_ASMDIR_hidden:
615	tok1 = tok;	615	tok1 = tok;
616	do {	616	do {
617	Sym *sym;	617	Sym *sym;
618		618

tccgen.c+31−11

         t1 &= ~VT_DEFSIGN;
         t2 &= ~VT_DEFSIGN;
     }
+    /* An enum is compatible with (unsigned) int.  Ideally we would
+       store the enums signedness in type->ref.a.<some_bit> and
+       only accept unsigned enums with unsigned int and vice versa.
+       But one of our callers (gen_assign_cast) always strips VT_UNSIGNED
+       from pointer target types, so we can't add it here either.  */
     if ((t1 & VT_BTYPE) == VT_ENUM) {
-	/* An enum is compatible with (unsigned) int.  */
+	t1 = VT_INT;
-	t1 = VT_INT | (t1 & ~VT_BTYPE);
+	if (type1->ref->a.unsigned_enum)
+	    t1 |= VT_UNSIGNED;
     }
     if ((t2 & VT_BTYPE) == VT_ENUM) {
-	/* An enum is compatible with (unsigned) int.  */
+	t2 = VT_INT;
-	t2 = VT_INT | (t2 & ~VT_BTYPE);
+	if (type2->ref->a.unsigned_enum)
+	    t2 |= VT_UNSIGNED;
     }
     /* XXX: bitfields ? */
     if (t1 != t2)
             (type2->t & VT_BTYPE) == VT_VOID) {
             /* void * can match anything */
         } else {
-            /* exact type match, except for unsigned */
+            /* exact type match, except for qualifiers */
             tmp_type1 = *type1;
             tmp_type2 = *type2;
-            tmp_type1.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT |
+            tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
-                             VT_VOLATILE);
+            tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
-            tmp_type2.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT |
+            if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
-                             VT_VOLATILE);
+		/* Like GCC don't warn by default for merely changes
-            if (!is_compatible_types(&tmp_type1, &tmp_type2))
+		   in pointer target signedness.  Do warn for different
-                tcc_warning("assignment from incompatible pointer type");
+		   base types, though, in particular for unsigned enums
+		   and signed int targets.  */
+		if ((tmp_type1.t & (VT_DEFSIGN | VT_UNSIGNED)) !=
+		    (tmp_type2.t & (VT_DEFSIGN | VT_UNSIGNED)) &&
+		    (tmp_type1.t & VT_BTYPE) == (tmp_type2.t & VT_BTYPE))
+		    ;
+		else
+		    tcc_warning("assignment from incompatible pointer type");
+	    }
         }
         /* check const and volatile */
         if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) ||
         c = 0;
         /* non empty enums are not allowed */
         if (a == TOK_ENUM) {
+	    int seen_neg = 0;
             for(;;) {
                 v = tok;
                 if (v < TOK_UIDENT)
                     next();
                     c = expr_const();
                 }
+		if (c < 0)
+		    seen_neg = 1;
                 /* enum symbols have static storage */
                 ss = sym_push(v, &int_type, VT_CONST, c);
                 ss->type.t |= VT_STATIC;
                 if (tok == '}')
                     break;
             }
+	    if (!seen_neg)
+	        s->a.unsigned_enum = 1;
             s->c = type_size(&int_type, &align);
             skip('}');
         } else {

tests/tcctest.c+1−1

@@ -591,7 +591,7 @@ void enum_test() · 590 unmodified lines
591	{	591	{
592	enum test b1;	592	enum test b1;
593	/* The following should give no warning */	593	/* The following should give no warning */
594	int *p = &b1;	594	unsigned *p = &b1;
595	printf("enum:\n%d %d %d %d %d %d\n",	595	printf("enum:\n%d %d %d %d %d %d\n",
596	E0, E1, E2, E3, E4, E5);	596	E0, E1, E2, E3, E4, E5);
597	b1 = 1;	597	b1 = 1;