[Clang][DebugInfo] Emit zero size bitfields in the debug info to delimit bitfields in different allocation units.

[jmmartinez]

Summary

I'm looking for some feedback, this is definitively not the final solution.
I was wondering if there was an alternative to pass this information in the dwarf debug-info.

Consider the following sturctures when targetting:

struct foo {
  int space[4];
  char a : 8;
  char b : 8;
  char x : 8;
  char y : 8;
};

struct bar {
  int space[4];
  char a : 8;
  char b : 8;
  char : 0;
  char x : 8;
  char y : 8;
};

Even if both structs have the same layout in memory, they are handled
differenlty by the AMDGPU ABI.

With the following code:

// clang --target=amdgcn-amd-amdhsa -g -O1 example.c -S
char use_foo(struct foo f) { return f.y; }
char use_bar(struct bar b) { return b.y; }

For use_foo, the 'y' field is passed in v4
; v_ashrrev_i32_e32 v0, 24, v4
; s_setpc_b64 s[30:31]

For use_bar, the 'y' field is passed in v5
; v_bfe_i32 v0, v5, 8, 8
; s_setpc_b64 s[30:31]

To make this distinction, we record a single 0-size bitfield for every member that is preceded
by it.

[dblaikie]

Haven't followed the patch in detail - but why does this require changes to the RecordLayout code? (I'd expect this to only require charnges to the debug info code - maybe with a shared helper utility function that both the AMDGPU ABI implementation, and the debug info can use to observe this property, if it's non-trivial code to duplicate in both places? (but doesn't look like it's sharing code with the ABI implementation, or moving the logic out of the ABI implementation into the record layout code for reuse there))

[jmmartinez]

Update:

• Took into account remarks and got my ideas straight.

[probinson]

clang/lib/CodeGen/CGDebugInfo.cpp

1569

I might not be following this correctly, but it feels like EmitSeparator will end up true if the last field is a bitfield, even if there are no zero-length bitfields in front of it. The test does not cover this case (to show that the no-zero-bitfields case is handled properly).

[jmmartinez]

• Fixed the loop and added test case

[jmmartinez]

clang/lib/CodeGen/CGDebugInfo.cpp

1569

Ouch! I feel ashamed about that loop I originally wrote.

I've added a case covering the non-zero-bitfields case and fixed the code.

[probinson]

Is it possible you need to look only at the immediately preceding field, and not iterate? For example,

struct zero_bitfield {
  char a : 8;
  char : 0;
  char b : 8;
  char c : 8;
};

If processing b sees the zero-length bitfield and does the needful, then when processing c it's sufficient to see that b is a preceding bitfield and know that the needful has been done.

I'm now also curious whether this ABI aspect affects non-bitfields. For example:

struct non_adjacent_bitfields {
  char d;
  char : 0;
  char e;
  char f : 8;
};

(1) Is e affected by the presence of the zero-length bitfield? (2) is f affected? (3) If the answers are "no" and "yes" then you do need to iterate looking for the zero-length bitfield, but otherwise I think it's sufficient to look only at the preceding field.

(Of course it's possible that finding the preceding field can be done only by iterating, but I'd hope that isn't necessary.)

[jmmartinez]

In D144870#4202121, @probinson wrote:

(Of course it's possible that finding the preceding field can be done only by iterating, but I'd hope that isn't necessary.)

Sadly, this is the case. field_iterator and the underlying decl_iterator used to implement it are forward iterators.

However, your comment made me realize that we could forward the elements array from CGDebugInfoCollectRecordNormalFields which contains the already created debug-info for the previous fields. By using this array I could get pretty much the same effect. What do you think?

In D144870#4202121, @probinson wrote:

struct non_adjacent_bitfields {
  char d;
  char : 0;
  char e;
  char f : 8;
};

(1) Is e affected by the presence of the zero-length bitfield? (2) is f affected? (3) If the answers are "no" and "yes" then you do need to iterate looking for the zero-length bitfield, but otherwise I think it's sufficient to look only at the preceding field.

(1) and (2): They do not get affected by the precense of the annonymous bitfield. Only sequences of bitfields get "squashed" in the same integer.

[jmmartinez]

• Updated to use elements array to avoid the complicated loop.

[probinson]

Still one question, and haven't dug into the test in detail yet.

clang/lib/CodeGen/CGDebugInfo.cpp

1563

Maybe a comment here,
// If we already emitted metadata for a 0-length bitfield, nothing to do here.
(I was briefly confused by "if the previous field is a 0-length bitfield, do nothing" until I realized this is looking at the metadata not the decl.

1574

Is this true for cases like

struct nonadjacent {
  char a : 8;
  char : 0;
  int b;
  char d : 8;
};

where the field d has a predecessor that is not a bitfield? (This might be my ignorance of how Decls are put together, but asserting that advance is guaranteed to get you a bitfield just seems a little odd.)

clang/lib/CodeGen/CGDebugInfo.h

327

Please keep that final .

333

[jmmartinez]

• Took remarks into account

clang/lib/CodeGen/CGDebugInfo.cpp

1574

In that case the assert is never reached.

When emiting the debug-info for d, when looking at the metadata generated for the previous field the function should exit early on this condition:

if (!PreviousMDField || !PreviousMDField->isBitField() ||
    PreviousMDField->getSizeInBits() == 0)
  return nullptr;

[probinson]

One entirely optional suggestion on the test. LGTM.

clang/lib/CodeGen/CGDebugInfo.cpp

1574

Ah, you are right. Thanks!

clang/test/CodeGen/debug-info-bitfield-0-struct.c

41

Maybe use something like SECONDDUP instead of SECONDD which can look like a typo.

[jmmartinez]

In D144870#4225437, @probinson wrote:

One entirely optional suggestion on the test. LGTM.

Thanks! I used SECONDDUP and FIRSTDUP.

And thanks a lot for the reviews!

clang/lib/CodeGen/CGDebugInfo.h

llvm::DIType *createFieldType(StringRef name, QualType type,
                                 SourceLocation loc, AccessSpecifier AS,
                                 uint64_t offsetInBits, llvm::DIFile *tunit,
                                 llvm::DIScope *scope,
                                 const RecordDecl *RD = nullptr) {
     return createFieldType(name, type, loc, AS, offsetInBits, 0, tunit, scope,
                            RD);
   }
 
-  /// Create new bit field member.
+  /// Create new bit field member and zero-size separator if needed.
   llvm::DIType *createBitFieldType(const FieldDecl *BitFieldDecl,
                                    llvm::DIScope *RecordTy,
                                    const RecordDecl *RD);
 
+  llvm::DIType *
+  createBitFieldZeroLengthSeparatorType(const FieldDecl *BitFieldDecl,
+                                        llvm::DIScope *RecordTy,
+                                        const RecordDecl *RD);
+
   /// Helpers for collecting fields of a record.
   /// @{
   void CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl,
                                  SmallVectorImpl<llvm::Metadata *> &E,
                                  llvm::DIType *RecordTy);
   llvm::DIDerivedType *CreateRecordStaticField(const VarDecl *Var,
                                                llvm::DIType *RecordTy,
                                                const RecordDecl *RD);

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
   }
 
   llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
   llvm::DIType *F = DBuilder.createSubroutineType(
       EltTypeArray, Flags, getDwarfCC(Ty->getCallConv()));
   return F;
 }
 
+llvm::DIType *CGDebugInfo::createBitFieldZeroLengthSeparatorType(
+    const FieldDecl *BitFieldDecl, llvm::DIScope *RecordTy,
+    const RecordDecl *RD) {
+  const CGBitFieldInfo &BitFieldInfo =
+      CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
+
+  FieldDecl *ZeroLengthSeparator = BitFieldInfo.RunStartedBy0LenghtBitField;
+  if (!ZeroLengthSeparator)
+    return nullptr;
+
+  // This bitfield doesn't really exist in practice. Make it point to the
+  // begining of the storage offset (the word in the struct). This works for any
+  // endianness.
+  uint64_t StorageOffsetInBits =
+      CGM.getContext().toBits(BitFieldInfo.StorageOffset);
+  uint64_t OffsetInBits = StorageOffsetInBits;
+
+  QualType Ty = ZeroLengthSeparator->getType();
+  SourceLocation Loc = ZeroLengthSeparator->getLocation();
+  llvm::DIFile *VUnit = getOrCreateFile(Loc);
+  llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
+
+  llvm::DIFile *File = getOrCreateFile(Loc);
+  unsigned ZeroLine = getLineNumber(Loc);
+  return DBuilder.createBitFieldMemberType(
+      RecordTy, "", File, ZeroLine, 0, OffsetInBits, StorageOffsetInBits,
+      llvm::DINode::DIFlags::FlagZero, DebugType, {});
+}
+
 llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
                                               llvm::DIScope *RecordTy,
                                               const RecordDecl *RD) {
   StringRef Name = BitFieldDecl->getName();
   QualType Ty = BitFieldDecl->getType();
   SourceLocation Loc = BitFieldDecl->getLocation();
   llvm::DIFile *VUnit = getOrCreateFile(Loc);
   llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);

 void CGDebugInfo::CollectRecordLambdaFields(
     const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
     llvm::DIType *RecordTy) {
   // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
   // has the name and the location of the variable so we should iterate over
   // both concurrently.
   const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
   RecordDecl::field_iterator Field = CXXDecl->field_begin();
   unsigned fieldno = 0;
   for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
                                              E = CXXDecl->captures_end();
        I != E; ++I, ++Field, ++fieldno) {
     const LambdaCapture &C = *I;
     if (C.capturesVariable()) {
       SourceLocation Loc = C.getLocation();
       assert(!Field->isBitField() && "lambdas don't have bitfield members!");
       ValueDecl *V = C.getCapturedVar();
       StringRef VName = V->getName();
       llvm::DIFile *VUnit = getOrCreateFile(Loc);
       auto Align = getDeclAlignIfRequired(V, CGM.getContext());
       llvm::DIType *FieldType = createFieldType(
           VName, Field->getType(), Loc, Field->getAccess(),
           layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
       elements.push_back(FieldType);
     } else if (C.capturesThis()) {
       // TODO: Need to handle 'this' in some way by probably renaming the
       // this of the lambda class and having a field member of 'this' or
       // by using AT_object_pointer for the function and having that be
void CGDebugInfo::CollectRecordNormalField(
   QualType type = field->getType();
 
   // Ignore unnamed fields unless they're anonymous structs/unions.
   if (name.empty() && !type->isRecordType())
     return;
 
   llvm::DIType *FieldType;
   if (field->isBitField()) {
+    if (llvm::DIType *RunSeparator =
+            createBitFieldZeroLengthSeparatorType(field, RecordTy, RD))
+      elements.push_back(RunSeparator);
     FieldType = createBitFieldType(field, RecordTy, RD);
   } else {
     auto Align = getDeclAlignIfRequired(field, CGM.getContext());
     llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(field);
     FieldType =
         createFieldType(name, type, field->getLocation(), field->getAccess(),
                         OffsetInBits, Align, tunit, RecordTy, RD, Annotations);
   }

clang/lib/CodeGen/CGRecordLayout.h

struct CGBitFieldInfo {
 
   /// The storage size in bits which should be used when accessing this
   /// bitfield.
   unsigned VolatileStorageSize;
 
   /// The offset of the bitfield storage from the start of the struct.
   CharUnits VolatileStorageOffset;
 
+  /// On AMDGPU, the calling convention states that adjacent bitfields
+  /// (not separated by a 0-length annonymous bitfield) are considered as a
+  /// whole field passed together in the same register.
+  FieldDecl *RunStartedBy0LenghtBitField;
+
   CGBitFieldInfo()
       : Offset(), Size(), IsSigned(), StorageSize(), VolatileOffset(),
-        VolatileStorageSize() {}
+        VolatileStorageSize(), RunStartedBy0LenghtBitField(nullptr) {}
 
   CGBitFieldInfo(unsigned Offset, unsigned Size, bool IsSigned,
                  unsigned StorageSize, CharUnits StorageOffset)
       : Offset(Offset), Size(Size), IsSigned(IsSigned),
-        StorageSize(StorageSize), StorageOffset(StorageOffset) {}
+        StorageSize(StorageSize), StorageOffset(StorageOffset),
+        RunStartedBy0LenghtBitField(nullptr) {}
+
+  void setRunStartedBy0Length0BitField(FieldDecl *Zero) {
+    RunStartedBy0LenghtBitField = Zero;
+  }
 
   void print(raw_ostream &OS) const;
   void dump() const;
 
   /// Given a bit-field decl, build an appropriate helper object for
   /// accessing that field (which is expected to have the given offset and
   /// size).
   static CGBitFieldInfo MakeInfo(class CodeGenTypes &Types,

clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

 //===--- CGRecordLayoutBuilder.cpp - CGRecordLayout builder  ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Builder implementation for CGRecordLayout objects.
 //
 //===----------------------------------------------------------------------===//
 
-#include "CGRecordLayout.h"
 #include "CGCXXABI.h"
+#include "CGRecordLayout.h"
 #include "CodeGenTypes.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/Basic/CodeGenOptions.h"
if (StartBitOffset %
             Context.toBits(getAlignment(getIntNType(OffsetInRecord))) !=
         0)
       return false;
     return true;
   };
 
   // The start field is better as a single field run.
   bool StartFieldAsSingleRun = false;
+  FieldDecl *ZeroBitfieldStartingRun = nullptr;
+
   for (;;) {
     // Check to see if we need to start a new run.
     if (Run == FieldEnd) {
       // If we're out of fields, return.
       if (Field == FieldEnd)
         break;
       // Any non-zero-length bitfield can start a new run.
       if (!Field->isZeroLengthBitField(Context)) {
         Run = Field;
         StartBitOffset = getFieldBitOffset(*Field);
         Tail = StartBitOffset + Field->getBitWidthValue(Context);
         StartFieldAsSingleRun = IsBetterAsSingleFieldRun(Tail - StartBitOffset,
                                                          StartBitOffset);
+
+        if (ZeroBitfieldStartingRun) {
+          BitFields[*Field].setRunStartedBy0Length0BitField(
+              ZeroBitfieldStartingRun);
+          ZeroBitfieldStartingRun = nullptr;
+        }
+      } else {
+        if (getFieldBitOffset(*Field) != 0)
+          ZeroBitfieldStartingRun = *Field;
       }
       ++Field;
       continue;
     }
 
     // If the start field of a new run is better as a single run, or
     // if current field (or consecutive fields) is better as a single run, or
     // if current field has zero width bitfield and either
     // UseZeroLengthBitfieldAlignment or UseBitFieldTypeAlignment is set to
-    // true, or
     // if the offset of current field is inconsistent with the offset of
     // previous field plus its offset,
     // skip the block below and go ahead to emit the storage.
     // Otherwise, try to add bitfields to the run.
     if (!StartFieldAsSingleRun && Field != FieldEnd &&
         !IsBetterAsSingleFieldRun(Tail - StartBitOffset, StartBitOffset) &&
         (!Field->isZeroLengthBitField(Context) ||
          (!Context.getTargetInfo().useZeroLengthBitfieldAlignment() &&

 
 void CGBitFieldInfo::print(raw_ostream &OS) const {
   OS << "<CGBitFieldInfo"
      << " Offset:" << Offset << " Size:" << Size << " IsSigned:" << IsSigned
      << " StorageSize:" << StorageSize
      << " StorageOffset:" << StorageOffset.getQuantity()
      << " VolatileOffset:" << VolatileOffset
      << " VolatileStorageSize:" << VolatileStorageSize
-     << " VolatileStorageOffset:" << VolatileStorageOffset.getQuantity() << ">";
+     << " VolatileStorageOffset:" << VolatileStorageOffset.getQuantity()
+     << " RunStarteddByLenght0BitField:"
+     << (RunStartedBy0LenghtBitField ? "true" : "false") << ">";
 }
 
 LLVM_DUMP_METHOD void CGBitFieldInfo::dump() const {
   print(llvm::errs());
 }

clang/test/CodeGen/debug-info-bitfield-0-struct.c

+// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -debug-info-kind=limited %s | FileCheck %s
+
+struct First {
+  // CHECK-DAG: ![[FIRST:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "First", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 32, elements: ![[FIRST_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[FIRST_ELEMENTS]] = !{![[FIRST_X:[0-9]+]], ![[FIRST_Y:[0-9]+]]}
+  // CHECK-DAG: ![[FIRST_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[FIRST]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[FIRST_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[FIRST]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 4, flags: DIFlagBitField, extraData: i64 0)
+  int : 0;
+  int x : 4;
+  int y : 4;
+};
+
+struct FirstDuplicate {
+  // CHECK-DAG: ![[FIRSTD:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "FirstDuplicate", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 32, elements: ![[FIRSTD_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[FIRSTD_ELEMENTS]] = !{![[FIRSTD_X:[0-9]+]], ![[FIRSTD_Y:[0-9]+]]}
+  // CHECK-DAG: ![[FIRSTD_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[FIRSTD]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[FIRSTD_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[FIRSTD]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 4, flags: DIFlagBitField, extraData: i64 0)
+  int : 0;
+  int : 0;
+  int x : 4;
+  int y : 4;
+};
+
+struct Second {
+  // CHECK-DAG: ![[SECOND:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Second", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 64, elements: ![[SECOND_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[SECOND_ELEMENTS]] = !{![[SECOND_X:[0-9]+]], ![[SECOND_ZERO:[0-9]+]], ![[SECOND_Y:[0-9]+]]}
+  // CHECK-DAG: ![[SECOND_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[SECOND]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[SECOND_ZERO]] = !DIDerivedType(tag: DW_TAG_member, scope: ![[SECOND]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[SECOND_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[SECOND]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  int x : 4;
+  int : 0;
+  int y : 4;
+};
+
+struct SecondDuplicate {
+  // CHECK-DAG: ![[SECONDD:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "SecondDuplicate", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 64, elements: ![[SECONDD_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[SECONDD_ELEMENTS]] = !{![[SECONDD_X:[0-9]+]], ![[SECONDD_ZERO:[0-9]+]], ![[SECONDD_Y:[0-9]+]]}
+  // CHECK-DAG: ![[SECONDD_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[SECONDD]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[SECONDD_ZERO]] = !DIDerivedType(tag: DW_TAG_member, scope: ![[SECONDD]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[SECONDD_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[SECONDD]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  int x : 4;
+  int : 0;
+  int : 0;
+  int y : 4;
+};
+
+struct Last {
+  // CHECK-DAG: ![[LAST:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Last", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 32, elements: ![[LAST_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[LAST_ELEMENTS]] = !{![[LAST_X:[0-9]+]], ![[LAST_Y:[0-9]+]]}
+  // CHECK-DAG: ![[LAST_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[LAST]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[LAST_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[LAST]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 4, flags: DIFlagBitField, extraData: i64 0)
+  int x : 4;
+  int y : 4;
+  int : 0;
+};
+
+struct Several {
+  // CHECK-DAG: ![[SEVERAL:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Several", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 96, elements: ![[SEVERAL_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[SEVERAL_ELEMENTS]] = !{![[SEVERAL_X:[0-9]+]], ![[SEVERAL_FIRST_ZERO:[0-9]+]], ![[SEVERAL_Y:[0-9]+]], ![[SEVERAL_SECOND_ZERO:[0-9]+]], ![[SEVERAL_Z:[0-9]+]]}
+  // CHECK-DAG: ![[SEVERAL_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[SEVERAL]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, flags: DIFlagBitField, extraData: i64 0)
+  // CHECK-DAG: ![[SEVERAL_FIRST_ZERO]] = !DIDerivedType(tag: DW_TAG_member, scope: ![[SEVERAL]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[SEVERAL_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[SEVERAL]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[SEVERAL_SECOND_ZERO]] = !DIDerivedType(tag: DW_TAG_member, scope: ![[SEVERAL]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, offset: 64, flags: DIFlagBitField, extraData: i64 64)
+  // CHECK-DAG: ![[SEVERAL_Z]] = !DIDerivedType(tag: DW_TAG_member, name: "z", scope: ![[SEVERAL]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 64, flags: DIFlagBitField, extraData: i64 64)
+  int x : 4;
+  int : 0;
+  int y : 4;
+  int : 0;
+  int z : 4;
+};
+
+struct None {
+  // CHECK-DAG: ![[NONE:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "None", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 64, elements: ![[NONE_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[NONE_ELEMENTS]] = !{![[NONE_FIELD:[0-9]+]], ![[NONE_X:[0-9]+]]}
+  // CHECK-DAG: ![[NONE_FIELD]] = !DIDerivedType(tag: DW_TAG_member, name: "field", scope: ![[NONE]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 32)
+  // CHECK-DAG: ![[NONE_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[NONE]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  int : 0;
+  int field;
+  int x : 4;
+};
+
+struct Mixed {
+  // CHECK-DAG: ![[MIXED:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Mixed", file: !{{[0-9]+}}, line: {{[0-9]+}}, size: 64, elements: ![[MIXED_ELEMENTS:[0-9]+]])
+  // CHECK-DAG: ![[MIXED_ELEMENTS]] = !{![[MIXED_FIELD:[0-9]+]], ![[MIXED_ZERO:[0-9]+]], ![[MIXED_X:[0-9]+]], ![[MIXED_Y:[0-9]+]]}
+  // CHECK-DAG: ![[MIXED_FIELD]] = !DIDerivedType(tag: DW_TAG_member, name: "field", scope: ![[MIXED]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 32)
+  // CHECK-DAG: ![[MIXED_ZERO]] = !DIDerivedType(tag: DW_TAG_member, scope: ![[MIXED]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[MIXED_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: ![[MIXED]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 32, flags: DIFlagBitField, extraData: i64 32)
+  // CHECK-DAG: ![[MIXED_Y]] = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: ![[MIXED]], file: !{{[0-9]+}}, line: {{[0-9]+}}, baseType: !{{[0-9]+}}, size: 4, offset: 36, flags: DIFlagBitField, extraData: i64 32)
+  int field;
+  int : 0;
+  int x : 4;
+  int y : 4;
+};
+
+void foo(struct First f, struct FirstDuplicate fs, struct Second s, struct SecondDuplicate sd, struct Last l, struct Several ss, struct None n, struct Mixed m) {
+  return;
+}