Fix handling of bit-fields in a union

[shafik]

Summary

When laying out bit-fields we don't properly take into account when they are in a union, they will all have a zero offset.

[teemperor]

Should we maybe check that the offset is 0 instead of skipping the sanity check? Otherwise this LGTM.

[shafik]

Add a check to make sure the bit offset is zero for fields in a union.

[teemperor]

LGTM, thanks!

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (tag == DW_TAG_member) {
             } else {
               this_field_info.bit_offset += bit_offset;
             }
           }
 
           // The ObjC runtime knows the byte offset but we still need to provide
           // the bit-offset in the layout. It just means something different then
           // what it does in C and C++. So we skip this check for ObjC types.
+          //
+          // We also skip this for fields of a union since they will all have a
+          // zero offset.
           if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) &&
+              !(parent_die.Tag() == DW_TAG_union_type && this_field_info.bit_offset == 0) &&
               ((this_field_info.bit_offset >= parent_bit_size) ||
                (last_field_info.IsBitfield() &&
                 !last_field_info.NextBitfieldOffsetIsValid(
                     this_field_info.bit_offset)))) {
             ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
             objfile->GetModule()->ReportWarning(
                 "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
                 "bit offset (0x%8.8" PRIx64

lldb/test/API/lang/cpp/bitfields/TestCppBitfields.py

def test_and_run_command(self):
                     substrs=['unsigned int', '3'])
         self.expect("expr (lbc.c)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['unsigned int', '4'])
         self.expect("expr (lbd.a)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['unsigned int', '5'])
         self.expect("expr (clang_example.f.a)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['uint64_t', '1'])
 
+        self.expect("expr uwbf",
+            substrs=['a = 255',
+                    'b = 65535',
+                    'c = 4294967295',
+                    'x = 4294967295'] )
+
+        self.expect("expr uwubf",
+            substrs=['a = 16777215',
+                    'x = 4294967295'] )
+
         self.expect(
             "frame variable --show-types lba",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 '(int:32)  = ',
                 '(unsigned int:20) a = 2',
                 ])
 

lldb/test/API/lang/cpp/bitfields/main.cpp

int main(int argc, char const *argv[]) {
   f.d = 0;
   f.e = 1;
   f.f = 0;
   f.g = 1;
   f.h = 0;
   f.i = 1;
   f.j = 0;
   f.k = 1;
-    } 
+    }
   } clang_example;
 
   class B {
   public:
     uint32_t b_a;
   };
 
   class D : public B {
   public:
     uint32_t d_a : 1;
   } derived;
 
+  union union_with_bitfields {
+      unsigned int a : 8;
+      unsigned int b : 16;
+      unsigned int c : 32;
+      unsigned int x;
+  } uwbf;
+
+  union union_with_unnamed_bitfield {
+   unsigned int : 16, a : 24;
+   unsigned int x;
+  } uwubf;
+
   lba.a = 2;
 
   lbb.a = 1;
   lbb.b = 3;
 
   lbc.a = 1;
   lbc.b = 0;
   lbc.c = 4;
   lbc.d = 1;
   lbc.e = 20;
 
   lbd.arr[0] = 'a';
   lbd.arr[1] = 'b';
   lbd.arr[2] = '\0';
   lbd.a = 5;
 
   derived.b_a = 2;
   derived.d_a = 1;
 
+  uwbf.x = 0xFFFFFFFF;
+  uwubf.x = 0xFFFFFFFF;
+
   return 0; // Set break point at this line.
 }