Visual Studio packs bit-fields differently

Author: kroening

appveyor.yml

@@ -70,7 +70,6 @@ test_script:
     rmdir /s /q ansi-c\arch_flags_mthumb_good
     rmdir /s /q ansi-c\Forward_Declaration2
     rmdir /s /q ansi-c\Incomplete_Type1
-    rmdir /s /q ansi-c\Union_Padding1
     rmdir /s /q ansi-c\Universal_characters1
     rmdir /s /q ansi-c\function_return1
     rmdir /s /q ansi-c\gcc_attributes7

buildspec-windows.yml

@@ -34,7 +34,6 @@ phases:
         Remove-Item ansi-c\arch_flags_mthumb_good -Force -Recurse
         Remove-Item ansi-c\Forward_Declaration2 -Force -Recurse
         Remove-Item ansi-c\Incomplete_Type1 -Force -Recurse
-        Remove-Item ansi-c\Union_Padding1 -Force -Recurse
         Remove-Item ansi-c\Universal_characters1 -Force -Recurse
         Remove-Item ansi-c\function_return1 -Force -Recurse
         Remove-Item ansi-c\gcc_attributes7 -Force -Recurse

regression/ansi-c/Struct_Padding5/main.c

@@ -28,6 +28,46 @@ STATIC_ASSERT(sizeof(struct flowi)==8);
 STATIC_ASSERT(__builtin_offsetof(struct flowi, flexible)==1);
 #endif
 
+// bit-fields are very evil
+#pragma pack(push, 1)
+struct bit_field0
+{
+  int i : 23;
+};
+
+struct bit_field1
+{
+  int i : 1;
+  unsigned int j : 1;
+  // in MSC, it matters that the underlying type changes!
+  short c : 1;
+};
+
+struct bit_field2
+{
+  int i : 23;
+  char ch;
+};
+#pragma pack(pop)
+
+struct bit_field3
+{
+  int i : 23;
+  char ch;
+};
+
+#ifdef _MSC_VER
+STATIC_ASSERT(sizeof(struct bit_field0) == 4);
+STATIC_ASSERT(sizeof(struct bit_field1) == 6);
+STATIC_ASSERT(sizeof(struct bit_field2) == 5);
+STATIC_ASSERT(sizeof(struct bit_field3) == 8);
+#else
+STATIC_ASSERT(sizeof(struct bit_field0) == 3);
+STATIC_ASSERT(sizeof(struct bit_field1) == 1);
+STATIC_ASSERT(sizeof(struct bit_field2) == 4);
+STATIC_ASSERT(sizeof(struct bit_field3) == 4);
+#endif
+
 int main()
 {
 }

regression/ansi-c/Union_Padding1/main.c

@@ -41,14 +41,16 @@ STATIC_ASSERT(sizeof(union some_union3)==sizeof(int));
 #ifdef _MSC_VER
 
 // bit-fields are evil
-#pragma pack(1)
+#pragma pack(push, 1)
 union some_union4
 {
   int i:23;
 };
+#pragma pack(pop)
 
 // Visual Studio ignores the 'packed'
 STATIC_ASSERT(sizeof(union some_union4)==sizeof(int));
+STATIC_ASSERT(__alignof(union some_union4) == 1);
 
 #else
 
@@ -59,34 +61,38 @@ union some_union4
 } __attribute__((__packed__));
 
 STATIC_ASSERT(sizeof(union some_union4)==3);
+STATIC_ASSERT(_Alignof(union some_union4) == 1);
 
 #endif
 
-#ifdef _MSC_VER
-
 union some_union5
 {
   int i;
 };
 
-STATIC_ASSERT(__alignof(union some_union5)==1);
-
+#ifdef _MSC_VER
+STATIC_ASSERT(__alignof(union some_union5) == 4);
 #else
+STATIC_ASSERT(_Alignof(union some_union5) == 4);
+#endif
 
-union some_union5
-{
+#ifdef _MSC_VER
+#pragma pack(push, 1)
+union some_union6 {
   int i;
 };
+#pragma pack(pop)
 
+// Packing may affect alignment
+STATIC_ASSERT(__alignof(union some_union6) == 1);
+#else
 union some_union6
 {
   int i;
 } __attribute__((__packed__));
 
 // Packing may affect alignment
-STATIC_ASSERT(_Alignof(union some_union5)==4);
 STATIC_ASSERT(_Alignof(union some_union6)==1);
-
 #endif
 
 int main()

src/ansi-c/padding.cpp

@@ -100,15 +100,98 @@ mp_integer alignment(const typet &type, const namespacet &ns)
   return result;
 }
 
-void add_padding(struct_typet &type, const namespacet &ns)
+std::size_t underlying_width(const c_bit_field_typet &type)
+{
+  return type.subtype().get_size_t(ID_width);
+}
+
+struct_typet::componentst::iterator pad_bit_field(
+  struct_typet::componentst &components,
+  struct_typet::componentst::iterator where,
+  std::size_t pad_bits)
+{
+  c_bit_field_typet padding_type(unsignedbv_typet(pad_bits), pad_bits);
+
+  struct_typet::componentt component;
+  component.type() = padding_type;
+  component.set_name(
+    "$bit_field_pad" + std::to_string(where - components.begin()));
+  component.set_is_padding(true);
+
+  auto it = components.insert(where, component);
+  it++;
+  return it;
+}
+
+void bit_field_padding(struct_typet &type, const namespacet &ns)
 {
   struct_typet::componentst &components=type.components();
 
-  // First do padding for bit-fields to make them
-  // appear on byte boundaries.
+  // bit-field padding depends greatly on compiler
+  if(config.ansi_c.mode == configt::ansi_ct::flavourt::VISUAL_STUDIO)
+  {
+    std::size_t bit_field_bits = 0, underlying_bits = 0;
+
+    for(struct_typet::componentst::iterator it = components.begin();
+        it != components.end();
+        it++)
+    {
+      if(
+        it->type().id() == ID_c_bit_field &&
+        to_c_bit_field_type(it->type()).get_width() != 0)
+      {
+        const auto &bit_field_type = to_c_bit_field_type(it->type());
+
+        std::size_t new_underlying_bits = underlying_width(bit_field_type);
+
+        CHECK_RETURN(new_underlying_bits != 0);
+
+        if(underlying_bits == 0)
+        {
+          underlying_bits = new_underlying_bits;
+          bit_field_bits = 0;
+        }
+        else if(new_underlying_bits != underlying_bits)
+        {
+          // new underlying width, we pad up
+          if((bit_field_bits % underlying_bits) != 0)
+          {
+            std::size_t pad =
+              underlying_bits - (bit_field_bits % underlying_bits);
+            it = pad_bit_field(components, it, pad);
+          }
+
+          underlying_bits = new_underlying_bits;
+          bit_field_bits = 0;
+        }
+
+        // count the bits
+        std::size_t width = bit_field_type.get_width();
+        bit_field_bits += width;
+      }
+      else
+      {
+        // pad up
+        if(underlying_bits != 0 && (bit_field_bits % underlying_bits) != 0)
+        {
+          std::size_t pad =
+            underlying_bits - (bit_field_bits % underlying_bits);
+          it = pad_bit_field(components, it, pad);
+          underlying_bits = bit_field_bits = 0;
+        }
+      }
+    }
 
+    // Add padding at the end?
+    if(underlying_bits != 0 && (bit_field_bits % underlying_bits) != 0)
+    {
+      std::size_t pad = underlying_bits - (bit_field_bits % underlying_bits);
+      pad_bit_field(components, components.end(), pad);
+    }
+  }
+  else
   {
-    std::size_t padding_counter=0;
+    // Make bit-fields appear on byte boundaries
     std::size_t bit_field_bits=0;
 
     for(struct_typet::componentst::iterator
@@ -129,18 +212,7 @@ void add_padding(struct_typet &type, const namespacet &ns)
         if((bit_field_bits%8)!=0)
         {
           std::size_t pad=8-bit_field_bits%8;
-          c_bit_field_typet padding_type(unsignedbv_typet(pad), pad);
-
-          struct_typet::componentt component;
-          component.type()=padding_type;
-          component.set_name(
-            "$bit_field_pad"+std::to_string(padding_counter++));
-          component.set_is_padding(true);
-
-          it=components.insert(it, component);
-          it++; // skip over
-
-          bit_field_bits+=pad;
+          it = pad_bit_field(components, it, pad);
         }
 
         bit_field_bits=0;
@@ -151,16 +223,14 @@ void add_padding(struct_typet &type, const namespacet &ns)
     if((bit_field_bits%8)!=0)
     {
       std::size_t pad=8-bit_field_bits%8;
-      c_bit_field_typet padding_type(unsignedbv_typet(pad), pad);
-
-      struct_typet::componentt component;
-      component.type()=padding_type;
-      component.set_name("$bit_field_pad"+std::to_string(padding_counter++));
-      component.set_is_padding(true);
-
-      components.push_back(component);
+      pad_bit_field(components, components.end(), pad);
     }
   }
+}
+
+void add_padding(struct_typet &type, const namespacet &ns)
+{
+  bit_field_padding(type, ns);
 
   // Is the struct packed, without any alignment specification?
   if(type.get_bool(ID_C_packed) &&
@@ -172,6 +242,8 @@ void add_padding(struct_typet &type, const namespacet &ns)
   mp_integer max_alignment=0;
   std::size_t bit_field_bits=0;
 
+  struct_typet::componentst &components = type.components();
+
   for(struct_typet::componentst::iterator
       it=components.begin();
       it!=components.end();
@@ -313,6 +385,19 @@ void add_padding(union_typet &type, const namespacet &ns)
     max_alignment_bits=8;
   }
 
+  if(config.ansi_c.mode == configt::ansi_ct::flavourt::VISUAL_STUDIO)
+  {
+    // Visual Studio pads up to the underlying width of
+    // any bit field.
+    for(const auto &c : type.components())
+      if(c.type().id() == ID_c_bit_field)
+      {
+        std::size_t w = underlying_width(to_c_bit_field_type(c.type()));
+        if(w > max_alignment_bits)
+          max_alignment_bits = w;
+      }
+  }
+
   // The size must be a multiple of the alignment, or
   // we add a padding member to the union.