further work on the type of enums in C

Author: Daniel Kroening

regression/ansi-c/gcc_types_compatible_p3/main.c

@@ -26,9 +26,34 @@ enum help_format_neg {
   N_HELP_FORMAT_WEB,
 };
 
+// The enum is signed if one of the values is negative
 enum help_format_neg help_format_neg = N_HELP_FORMAT_NONE;
 STATIC_ASSERT(__builtin_types_compatible_p(typeof(&help_format_neg), int*));
 
+// The underlying type gets unsigned as needed.
+enum unsigned_enum { UINT=0xffffffff };
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(UINT), unsigned int));
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(enum unsigned_enum), unsigned int));
+
+// The enum gets bigger as required, but note that the constant is now unsigned.
+enum large_enum1 { LARGE_CONSTANT1=0x100000000 };
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(LARGE_CONSTANT1), unsigned long));
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(enum large_enum1), unsigned long));
+
+// Also works when signed
+enum large_enum2 { NEG=-1, LARGE_CONSTANT2=0x100000000 };
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(LARGE_CONSTANT2), signed long));
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(enum large_enum2), signed long));
+
+// 'Packed' is interesting.
+enum __attribute__((packed)) packed_enum1 { POS_PACKED=1 };
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(POS_PACKED), signed int));
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(enum packed_enum1), unsigned char));
+
+enum __attribute__((packed)) packed_enum2 { NEG_PACKED=-1 };
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(NEG_PACKED), signed int));
+STATIC_ASSERT(__builtin_types_compatible_p(typeof(enum packed_enum2), signed char));
+
 #endif
 
 int main()

src/ansi-c/c_typecheck_base.h

@@ -205,9 +205,12 @@ class c_typecheck_baset:
   virtual void adjust_function_parameter(typet &type) const;
   virtual bool is_complete_type(const typet &type) const;
 
-  typet fitting_int_type(
+  typet enum_constant_type(
+    const mp_integer &min, const mp_integer &max) const;
+  
+  typet enum_underlying_type(
     const mp_integer &min, const mp_integer &max,
-    bool at_least_int) const;
+    bool is_packed) const;
 
   void make_already_typechecked(typet &dest)
   {

src/ansi-c/c_typecheck_type.cpp

@@ -1019,7 +1019,7 @@ void c_typecheck_baset::typecheck_compound_body(
 
 /*******************************************************************\
 
-Function: c_typecheck_baset::fitting_int_type
+Function: c_typecheck_baset::enum_constant_type
 
   Inputs:
 
@@ -1029,34 +1029,92 @@ Function: c_typecheck_baset::fitting_int_type
 
 \*******************************************************************/
 
-typet c_typecheck_baset::fitting_int_type(
+typet c_typecheck_baset::enum_constant_type(
   const mp_integer &min_value,
-  const mp_integer &max_value,
-  bool at_least_int) const
+  const mp_integer &max_value) const
 {
-  if(max_value<(mp_integer(1)<<(config.ansi_c.char_width-1)) &&
-     min_value>=-(mp_integer(1)<<(config.ansi_c.char_width-1)))
-    return at_least_int?signed_int_type():signed_char_type();
-  else if(max_value<(mp_integer(1)<<config.ansi_c.char_width) &&
-          min_value>=0)
-    return at_least_int?signed_int_type():unsigned_char_type();
-  else if(max_value<(mp_integer(1)<<(config.ansi_c.short_int_width-1)) &&
-          min_value>=-(mp_integer(1)<<(config.ansi_c.short_int_width-1)))
-    return at_least_int?signed_int_type():signed_short_int_type();
-  else if(max_value<(mp_integer(1)<<config.ansi_c.short_int_width) &&
-          min_value>=0)
-    return at_least_int?signed_int_type():unsigned_short_int_type();
-  else if(max_value<(mp_integer(1)<<(config.ansi_c.int_width-1)) &&
-          min_value>=-(mp_integer(1)<<(config.ansi_c.int_width-1)))
+  // enum constants are at least 'int', but may be made larger.
+  // 'Packing' has no influence.
+  if(max_value<(mp_integer(1)<<(config.ansi_c.int_width-1)) &&
+     min_value>=-(mp_integer(1)<<(config.ansi_c.int_width-1)))
     return signed_int_type();
   else if(max_value<(mp_integer(1)<<config.ansi_c.int_width) &&
           min_value>=0)
     return unsigned_int_type();
-  else if(max_value<(mp_integer(1)<<(config.ansi_c.long_long_int_width-1)) &&
-          min_value>=-(mp_integer(1)<<(config.ansi_c.long_long_int_width-1)))
+  else if(max_value<(mp_integer(1)<<config.ansi_c.long_int_width) &&
+          min_value>=0)
+    return unsigned_long_int_type();
+  else if(max_value<(mp_integer(1)<<config.ansi_c.long_long_int_width) &&
+          min_value>=0)
+    return unsigned_long_long_int_type();
+  else if(max_value<(mp_integer(1)<<(config.ansi_c.long_int_width-1)) &&
+          min_value>=-(mp_integer(1)<<(config.ansi_c.long_int_width-1)))
+    return signed_long_int_type();
+  else
     return signed_long_long_int_type();
+}
+
+/*******************************************************************\
+
+Function: c_typecheck_baset::enum_underlying_type
+
+  Inputs:
+
+ Outputs:
+
+ Purpose:
+
+\*******************************************************************/
+
+typet c_typecheck_baset::enum_underlying_type(
+  const mp_integer &min_value,
+  const mp_integer &max_value,
+  bool is_packed) const
+{
+  if(min_value<0)
+  {
+    // We'll want a signed type.
+
+    if(is_packed)
+    {
+      // If packed, there are smaller options.
+      if(max_value<(mp_integer(1)<<(config.ansi_c.char_width-1)) &&
+         min_value>=-(mp_integer(1)<<(config.ansi_c.char_width-1)))
+        return signed_char_type();
+      else if(max_value<(mp_integer(1)<<(config.ansi_c.short_int_width-1)) &&
+              min_value>=-(mp_integer(1)<<(config.ansi_c.short_int_width-1)))
+        return signed_short_int_type();
+    }
+      
+    if(max_value<(mp_integer(1)<<(config.ansi_c.int_width-1)) &&
+       min_value>=-(mp_integer(1)<<(config.ansi_c.int_width-1)))
+      return signed_int_type();
+    else if(max_value<(mp_integer(1)<<(config.ansi_c.long_int_width-1)) &&
+            min_value>=-(mp_integer(1)<<(config.ansi_c.long_int_width-1)))
+      return signed_long_int_type();
+    else
+      return signed_long_long_int_type();
+  }
   else
-    return unsigned_long_long_int_type();
+  {
+    // We'll want an unsigned type.
+    
+    if(is_packed)
+    {
+      // If packed, there are smaller options.
+      if(max_value<(mp_integer(1)<<config.ansi_c.char_width))
+        return unsigned_char_type();
+      else if(max_value<(mp_integer(1)<<config.ansi_c.short_int_width))
+        return unsigned_short_int_type();
+    }
+      
+    if(max_value<(mp_integer(1)<<config.ansi_c.int_width))
+      return unsigned_int_type();
+    else if(max_value<(mp_integer(1)<<config.ansi_c.long_int_width))
+      return unsigned_long_int_type();
+    else
+      return unsigned_long_long_int_type();
+  }
 }
 
 /*******************************************************************\
@@ -1129,13 +1187,12 @@ void c_typecheck_baset::typecheck_c_enum_type(typet &type)
     if(value<min_value) min_value=value;
     if(value>max_value) max_value=value;
 
-    // The type of the enum constant is 'int', unless it it's larger.
-    typet underlying_type=
-      fitting_int_type(min_value, max_value, true);
+    typet constant_type=
+      enum_constant_type(min_value, max_value);
 
-    v=from_integer(value, underlying_type);
+    v=from_integer(value, constant_type);
 
-    declaration.type()=underlying_type;    
+    declaration.type()=constant_type;    
     typecheck_declaration(declaration);
 
     irep_idt base_name=
@@ -1208,14 +1265,9 @@ void c_typecheck_baset::typecheck_c_enum_type(typet &type)
     body.push_back(*it);
 
   // We use a subtype to store the underlying type.
-  // This is at least 'int' unless packed if negative,
-  // and at least 'unsigned int' otherwise.
   typet underlying_type=
-    fitting_int_type(min_value, max_value, !is_packed);
-  if(underlying_type==signed_int_type() &&
-     min_value>=0)
-    underlying_type=unsigned_int_type();
-  
+    enum_underlying_type(min_value, max_value, is_packed);
+
   enum_tag_symbol.type.subtype()=underlying_type;
 
   // is it in the symbol table already?