[lldb] Fix [[no_unique_address]] and libstdc++ 11's std::unique_ptr

[jankratochvil]

Summary

libstc++ 11 started using [[no_unique_address]] which crashes LLDB:

echo -e '#include <memory>\nstd::unique_ptr<int> p;'|clang -Wall -g -c -o a.o -x c++ -;lldb -b ./a.o -o 'p p'
lldb: clang/lib/CodeGen/CGRecordLayoutBuilder.cpp:742: void (anonymous namespace)::CGRecordLowering::clipTailPadding(): Assertion `Prior->Kind == MemberInfo::Field && "Only storage fields have tail padding!"' failed.

As DWARF does not contain the [[no_unique_address]] attribute the patch adds it to every record member, could it be a problem?
This patch requires: D101236, D103910 and D103966.

[jankratochvil]

lldb/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

103

This is in fact unrelated patch, it could be 3/3 in the series. It was failing on TestDataFormatterStdUniquePtr.py line 41:

self.assertFalse(frame.GetValueForVariablePath("iup.deleter").IsValid())

But whole TestDataFormatterStdUniquePtr.py does not yet PASS even with this patch, there are some unrelated other issues on later testcases.

lldb/test/Shell/SymbolFile/NativePDB/bitfields.cpp

47 ↗

(On Diff #340293)

There is now always a new leaf element:

| | |-IntegerLiteral 0x260af78 <<invalid sloc>> 'int' 5 
| | `-NoUniqueAddressAttr 0x260aff0 <<invalid sloc>> Implicit

[dblaikie]

As DWARF does not contain the [[no_unique_address]] attribute the patch adds it to every record member, could it be a problem?

Given that no_unique_address changes the layout of data structures ( https://clang.llvm.org/docs/AttributeReference.html#no-unique-address ) adding it to a member that doesn't actually have it specified I believe would break layout of structures (have you tried it on the lldb test suite/experimented with examples? I would expect a lot of tests to fail if I'm understanding this correctly)

If it were correct to interpret every field as having no_unique_address, then we wouldn't need users to write the attribute/wouldn't need the attribute, right?

So I suspect the only way to get the layout right is to add the information to the DWARF in some way (probably an extension form/propose it for standardization)?

(@aprantl ?)

[jankratochvil]

In D101237#2714953, @dblaikie wrote:

Given that no_unique_address changes the layout of data structures ( https://clang.llvm.org/docs/AttributeReference.html#no-unique-address ) adding it to a member that doesn't actually have it specified I believe would break layout of structures

Not so because LLDB sends FieldOffsets (from DW_AT_data_member_locations) to clang. I believe it should work but then I understand it is a bit bold change. clang is already forced for the DWARF-compliant layout by FieldOffsets.

Before this patch LLDB still sends FieldOffsets to clang but clang wants a larger layout because it does not see the [[no_unique_address]] attribute. And therefore it asserts then because the clang offsets cannot fit the FieldOffsets from DW_AT_data_member_locations.

Thanks for this possible catch but I hope the patch does solve that.

(have you tried it on the lldb test suite/experimented with examples? I would expect a lot of tests to fail if I'm understanding this correctly)

Sure the clang+llvm+lldb testsuites do PASS with this patch. (Otherwise I would not send this patch for approval, at least I would mark it by RFC/WIP which I did not.)

[dblaikie]

In D101237#2714962, @jankratochvil wrote:

In D101237#2714953, @dblaikie wrote:

Given that no_unique_address changes the layout of data structures ( https://clang.llvm.org/docs/AttributeReference.html#no-unique-address ) adding it to a member that doesn't actually have it specified I believe would break layout of structures

Not so because LLDB sends FieldOffsets (from DW_AT_data_member_locations) to clang. I believe it should work but then I understand it is a bit bold change. clang is already forced for the DWARF-compliant layout by FieldOffsets.

Before this patch LLDB still sends FieldOffsets to clang but clang wants a larger layout because it does not see the [[no_unique_address]] attribute. And therefore it asserts then because the clang offsets cannot fit the FieldOffsets from DW_AT_data_member_locations.

Thanks for this possible catch but I hope the patch does solve that.

(have you tried it on the lldb test suite/experimented with examples? I would expect a lot of tests to fail if I'm understanding this correctly)

Sure the clang+llvm+lldb testsuites do PASS with this patch. (Otherwise I would not send this patch for approval, at least I would mark it by RFC/WIP which I did not.)

Fair enough - I'd be a bit worried - but if it all seems to work, I don't have any further knowledge to suggest it's invalid given the offsets are derived from the authoritative offsets given in the DWARF.

[teemperor]

grep tells me that attribute also influences a bunch of other things in subtle ways (It seems to potentially influence ABIs and Obj-C encodings?) and we don't really know what other things this might influence in the future. So I have the suspicion that putting that attr on all record fields might break something in a subtle way.

In any case, what LLDB is usually doing is these situations is inferring from the existing debug information. I assume by looking at the DW_AT_data_member_locations values we could determine what the no_unique_address fields are in our record (and then only put the attributes on that)? Not sure what all the corner cases are but the ones I checked (e.g., two empty record fields with only one having the attr at start/end/middle) are surprisingly not ambiguous.

[jankratochvil]

In D101237#2714971, @teemperor wrote:

grep tells me that attribute also influences a bunch of other things in subtle ways (It seems to potentially influence ABIs and Obj-C encodings?) and we don't really know what other things this might influence in the future. So I have the suspicion that putting that attr on all record fields might break something in a subtle way.

I have a similar feeling but without a proof of anything ...

In any case, what LLDB is usually doing is these situations is inferring from the existing debug information. I assume by looking at the DW_AT_data_member_locations values we could determine what the no_unique_address fields are in our record (and then only put the attributes on that)?

... LLDB can become overcomplicated as if you remove the [[no_unique_address]] from this testcase's class B the only effect on DWARF is for class C:

 0x00000033:   DW_TAG_structure_type
                 DW_AT_calling_convention       (DW_CC_pass_by_value)
                 DW_AT_name     ("C")
-                DW_AT_byte_size        (0x01)
+                DW_AT_byte_size        (0x02)
                 DW_AT_decl_file        ("uniqX.C")
                 DW_AT_decl_line        (5)

 0x0000003c:     DW_TAG_inheritance
                   DW_AT_type   (0x0000004f "B")
                   DW_AT_data_member_location   (0x00)

 0x00000042:     DW_TAG_member
                   DW_AT_name   ("c")
                   DW_AT_type   (0x0000006e "char")
                   DW_AT_decl_file      ("uniqX.C")
                   DW_AT_decl_line      (6)
-                  DW_AT_data_member_location   (0x00)
+                  DW_AT_data_member_location   (0x01)

 0x0000004e:     NULL

As LLDB could be already using class B as CompilerType LLDB will need to create a second/new CompilerType for class B when creating CompilerType for class C.

[teemperor]

This comment was removed by teemperor.

[teemperor]

Ignore my comments above. I assumed we didn't have a minimal crash reproducer from the comment in the dependent patch.

[clayborg]

A bit of history on laying out classes: layout used to be a problem before we were able to give all of the field offsets directly to clang to assist in laying out. The main issues were:

• #pragma pack directives are not in DWARF so we must use the DW_AT_data_member_location
• Some DWARF optimizations cause class definitions to be omitted and we can have a class A that inherits from class B but we have no real definition for class B, just a forward declaration. In this case we will create a class A that inherits from a class B that has nothing in it, but the field offsets will ensure we show all other instance variables of class A correctly. Furthermore, we have code that can detect when we have such a case and it can grab the right definition for class B when it is imported into another AST, such as when evaluating an expression. This will only happen if class B is in another shared library from class A, and if we do have debug info for class B.
• any other keywords or attributes such as [[no_unique_address]] that can affect layout that don't appear in DWARF.

It seems it would be a nice attribute to have add to DWARF in case the current solution affects things adversely.

I will let the expression parser experts comment on the viability of always setting "[[no_unique_address]]" on every field. Seems dangerous to me, but I will defer to expression experts.

[shafik]

I think @dblaikie original idea of adding a DWARF attribute for this case is the right way to go here. AFAICT this will change the answer to basic questions such as what size a struct is and this will likely lead to confusion from our users who will expect the answers in expression parsing to match what they are seeing elsewhere e.g.:

struct X {
    int i;
    [[no_unique_address]] Empty e;
};
 
struct X2 {
    int i;
    Empty e;
};
 
struct Z {
    char c;
    [[no_unique_address]] Empty e1, e2;
};

struct Z2 {
    char c;
    Empty e1, e2;
};


struct W {
    char c[2];
    [[no_unique_address]] Empty e1, e2;
};

struct W2 {
    char c[2];
    Empty e1, e2;
};


int main()
{
    std::cout << sizeof(Empty) << "\n"
              << "X: " << sizeof(X) << "\n"
              << "X2: " << sizeof(X2) << "\n"
              << "Z: " << sizeof(Z) << "\n"
              << "Z2: " << sizeof(Z2) << "\n"
              << "W: " << sizeof(W) << "\n"
              << "W2: " << sizeof(W2) << "\n";
  
}

See godbolt which shows this result:

1
X: 4
X2: 8
Z: 2
Z2: 3
W: 3
W2: 4

[jankratochvil]

In D101237#2718456, @shafik wrote:

AFAICT this will change the answer to basic questions such as what size a struct is and this will likely lead to confusion from our users who will expect the answers in expression parsing to match what they are seeing elsewhere e.g.:

OK, that justifies the new DW_AT_*. I did not notice there is this difference. For my needs the new DW_AT_* thus needs to be implemented also in GCC.

[dblaikie]

In D101237#2718456, @shafik wrote:

I think @dblaikie original idea of adding a DWARF attribute for this case is the right way to go here. AFAICT this will change the answer to basic questions such as what size a struct is and this will likely lead to confusion from our users who will expect the answers in expression parsing to match what they are seeing elsewhere e.g.:

struct X {
    int i;
    [[no_unique_address]] Empty e;
};
 
struct X2 {
    int i;
    Empty e;
};
 
struct Z {
    char c;
    [[no_unique_address]] Empty e1, e2;
};

struct Z2 {
    char c;
    Empty e1, e2;
};


struct W {
    char c[2];
    [[no_unique_address]] Empty e1, e2;
};

struct W2 {
    char c[2];
    Empty e1, e2;
};


int main()
{
    std::cout << sizeof(Empty) << "\n"
              << "X: " << sizeof(X) << "\n"
              << "X2: " << sizeof(X2) << "\n"
              << "Z: " << sizeof(Z) << "\n"
              << "Z2: " << sizeof(Z2) << "\n"
              << "W: " << sizeof(W) << "\n"
              << "W2: " << sizeof(W2) << "\n";
  
}

See godbolt which shows this result:

1
X: 4
X2: 8
Z: 2
Z2: 3
W: 3
W2: 4

Hmm, but is this still a problem for the particular way lldb does things - where it simultaneiously marks all the fields as no_unique_address (in this patch), but then still tells clang exactly where the fields will go? (and it could tell clang exactly how large the structure is too - from the DWARF)

@jankratochvil - have you been able to use these examples from @shafik to demonstrate problems with this patch when applied to lldb? What sort of problems arise in lldb?

(that said, an extension flag attribute should be fairly low cost to add and nice to explicitly encode this parameter in any case, I think - but I'd like to understand the tradeoffs/justification/etc)

[teemperor]

(and it could tell clang exactly how large the structure is too - from the DWARF)

We are actually doing that to my knowledge and return the DW_AT_byte_size value for the record type. The relevant API that LLDB implements to get layout/size info back to Clang is:

bool layoutRecordType(
    const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
    llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &BaseOffsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &VirtualBaseOffsets) override;

I think the sizeof part actually works* in this regard as we just return whatever we got from DWARF. I get the correct results for the example above (both with and without this patch). There might be some weirder corner cases that could go wrong but I think the main concern are more complicated situations like in the crash that is fixed here.

FWIW, I took a look at the DWARF standard and I think that is actually something we should already emit in the form of a DW_AT_byte_size 0 attribute at the field? Quote:

If the size of a data member is not the same as the size of the type given for the data member, the data member has either a DW_AT_byte_size or a DW_AT_bit_size attribute whose integer constant value (see Section 2.19) is the amount of storage needed to hold the value of the data member.

I am not a DWARF laywer so maybe I understand that part wrong.

(*I actually found a bug that miscalculated empty structs while testing, but that's unrelated. Patch incoming).

[dblaikie]

In D101237#2728726, @teemperor wrote:

(and it could tell clang exactly how large the structure is too - from the DWARF)

We are actually doing that to my knowledge and return the DW_AT_byte_size value for the record type. The relevant API that LLDB implements to get layout/size info back to Clang is:

bool layoutRecordType(
    const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
    llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &BaseOffsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &VirtualBaseOffsets) override;

I think the sizeof part actually works* in this regard as we just return whatever we got from DWARF. I get the correct results for the example above (both with and without this patch). There might be some weirder corner cases that could go wrong but I think the main concern are more complicated situations like in the crash that is fixed here.

FWIW, I took a look at the DWARF standard and I think that is actually something we should already emit in the form of a DW_AT_byte_size 0 attribute at the field? Quote:

If the size of a data member is not the same as the size of the type given for the data member, the data member has either a DW_AT_byte_size or a DW_AT_bit_size attribute whose integer constant value (see Section 2.19) is the amount of storage needed to hold the value of the data member.

I am not a DWARF laywer so maybe I understand that part wrong.

(*I actually found a bug that miscalculated empty structs while testing, but that's unrelated. Patch incoming).

Hmm, sounds sort of plausible - but might not be right. The cppreference article on no_unique_address presents some interesting challenges that will be maybe surprising (well, I guess not, given the need to render these situations for empty bases already) - yeah, I guess probably the question to ask is: How are empty bases rendered today? I think the trick is they're rendered not as zero length, but as having a location that overlaps with another field - and having a length of 1 (which is the real length of the "empty" object).

[jankratochvil]

IIUC it will get replaced by D101950.
I will just provide some testcase for this case if not already contained therein.

[jankratochvil]

Reopening as D101950 may take some time.

[jankratochvil]

DW_AT_byte_size 0 implementation as suggested by @teemperor.

[jankratochvil]

llvm/include/llvm/IR/DebugInfoFlags.def

62 ↗

(On Diff #350361)

This would need to be handled better if approved.

[jankratochvil]

[Dwarf-Discuss] How to map [[no_unique_address]] into DWARF: http://lists.dwarfstd.org/pipermail/dwarf-discuss-dwarfstd.org/2021-June/004825.html

[jankratochvil]

This patch now requires: D101236, D103910 and D103966.

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
 
   FieldDecl *ToField;
   if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
                               ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
                               ToType, ToTInfo, ToBitWidth, D->isMutable(),
                               D->getInClassInitStyle()))
     return ToField;
 
+  // FieldDecl::isZeroSize may need to check these.
+  if (const Attr *FromAttr = D->getAttr<NoUniqueAddressAttr>()) {
+    if (auto ToAttrOrErr = Importer.Import(FromAttr))
+      ToField->addAttr(*ToAttrOrErr);
+    else
+      return ToAttrOrErr.takeError();
+    RecordType *FromRT =
+        const_cast<RecordType *>(D->getType()->getAs<RecordType>());
+    // Is this field a struct? FieldDecl::isZeroSize will need its definition.
+    if (FromRT) {
+      RecordDecl *FromRD = FromRT->getDecl();
+      RecordType *ToRT =
+          const_cast<RecordType *>(ToField->getType()->getAs<RecordType>());
+      assert(ToRT && "RecordType import has different type");
+      RecordDecl *ToRD = ToRT->getDecl();
+      if (FromRD->isCompleteDefinition() && !ToRD->isCompleteDefinition()) {
+        if (Error Err = ImportDefinition(FromRD, ToRD, IDK_Basic))
+          return std::move(Err);
+      }
+    }
+  }
+
   ToField->setAccess(D->getAccess());
   ToField->setLexicalDeclContext(LexicalDC);
   if (ToInitializer)
     ToField->setInClassInitializer(ToInitializer);
   ToField->setImplicit(D->isImplicit());
   if (ToCapturedVLAType)
     ToField->setCapturedVLAType(cast<VariableArrayType>(ToCapturedVLAType));
   LexicalDC->addDeclInternal(ToField);
Expected<Decl *> ASTImporter::Import(Decl *FromD) {
   if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
     setImportDeclError(FromD, *Error);
     return make_error<ImportError>(*Error);
   }
 
   // Make sure that ImportImpl registered the imported decl.
   assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
 
+  // There may have been NoUniqueAddressAttr for FieldDecl::isZeroSize.
+  ToD->dropAttrs();
   if (FromD->hasAttrs())
     for (const Attr *FromAttr : FromD->getAttrs()) {
       auto ToAttrOrErr = Import(FromAttr);
       if (ToAttrOrErr)
         ToD->addAttr(*ToAttrOrErr);
       else
         return ToAttrOrErr.takeError();
     }

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLExtensionTypes.def"
   llvm::DINodeArray
   CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TS,
                            llvm::DIFile *F);
 
   llvm::DIType *createFieldType(StringRef name, QualType type,
                                 SourceLocation loc, AccessSpecifier AS,
                                 uint64_t offsetInBits, uint32_t AlignInBits,
                                 llvm::DIFile *tunit, llvm::DIScope *scope,
+                                bool IsZeroSize,
                                 const RecordDecl *RD = nullptr);
 
   llvm::DIType *createFieldType(StringRef name, QualType type,
                                 SourceLocation loc, AccessSpecifier AS,
                                 uint64_t offsetInBits, llvm::DIFile *tunit,
-                                llvm::DIScope *scope,
+                                llvm::DIScope *scope, bool IsZeroSize,
                                 const RecordDecl *RD = nullptr) {
     return createFieldType(name, type, loc, AS, offsetInBits, 0, tunit, scope,
-                           RD);
+                           IsZeroSize, RD);
   }
 
   /// Create new bit field member.
   llvm::DIType *createBitFieldType(const FieldDecl *BitFieldDecl,
                                    llvm::DIScope *RecordTy,
                                    const RecordDecl *RD);
 
   /// Helpers for collecting fields of a record.

clang/lib/CodeGen/CGDebugInfo.cpp

if (CGM.getDataLayout().isBigEndian())
     Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset;
   uint64_t OffsetInBits = StorageOffsetInBits + Offset;
   llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
   return DBuilder.createBitFieldMemberType(
       RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
       Flags, DebugType);
 }
 
-llvm::DIType *
-CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc,
-                             AccessSpecifier AS, uint64_t offsetInBits,
-                             uint32_t AlignInBits, llvm::DIFile *tunit,
-                             llvm::DIScope *scope, const RecordDecl *RD) {
+llvm::DIType *CGDebugInfo::createFieldType(
+    StringRef name, QualType type, SourceLocation loc, AccessSpecifier AS,
+    uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit,
+    llvm::DIScope *scope, bool IsZeroSize, const RecordDecl *RD) {
   llvm::DIType *debugType = getOrCreateType(type, tunit);
 
   // Get the location for the field.
   llvm::DIFile *file = getOrCreateFile(loc);
   const unsigned line = getLineNumber(loc.isValid() ? loc : CurLoc);
 
   uint64_t SizeInBits = 0;
   auto Align = AlignInBits;
   if (!type->isIncompleteArrayType()) {
     TypeInfo TI = CGM.getContext().getTypeInfo(type);
     SizeInBits = TI.Width;
     if (!Align)
       Align = getTypeAlignIfRequired(type, CGM.getContext());
   }
 
   llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
+  if (IsZeroSize)
+    flags |= llvm::DINode::FlagIsZeroSize;
   return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
                                    offsetInBits, flags, debugType);
 }
 
 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;
+    bool IsZeroSize = false;
+    assert(!Field->isZeroSize(CGM.getContext()) &&
+           "lambdas cannot use [[no_unique_address]]!");
     if (C.capturesVariable()) {
       SourceLocation Loc = C.getLocation();
       assert(!Field->isBitField() && "lambdas don't have bitfield members!");
       VarDecl *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);
+      llvm::DIType *FieldType =
+          createFieldType(VName, Field->getType(), Loc, Field->getAccess(),
+                          layout.getFieldOffset(fieldno), Align, VUnit,
+                          RecordTy, IsZeroSize, 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
       // used as 'this' for semantic references.
       FieldDecl *f = *Field;
       llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
       QualType type = f->getType();
       llvm::DIType *fieldType = createFieldType(
           "this", type, f->getLocation(), f->getAccess(),
-          layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
+          layout.getFieldOffset(fieldno), VUnit, RecordTy, IsZeroSize, CXXDecl);
 
       elements.push_back(fieldType);
     }
   }
 }
 
 llvm::DIDerivedType *
 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
void CGDebugInfo::CollectRecordNormalField(
   if (name.empty() && !type->isRecordType())
     return;
 
   llvm::DIType *FieldType;
   if (field->isBitField()) {
     FieldType = createBitFieldType(field, RecordTy, RD);
   } else {
     auto Align = getDeclAlignIfRequired(field, CGM.getContext());
+    bool IsZeroSize = field->isZeroSize(CGM.getContext());
     FieldType =
         createFieldType(name, type, field->getLocation(), field->getAccess(),
-                        OffsetInBits, Align, tunit, RecordTy, RD);
+                        OffsetInBits, Align, tunit, RecordTy, IsZeroSize, RD);
   }
 
   elements.push_back(FieldType);
 }
 
 void CGDebugInfo::CollectRecordNestedType(
     const TypeDecl *TD, SmallVectorImpl<llvm::Metadata *> &elements) {
   QualType Ty = CGM.getContext().getTypeDeclType(TD);
bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
   return l.OffsetInBits < r.OffsetInBits;
 }
 } // namespace
 
 void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
     const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc,
     const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
     SmallVectorImpl<llvm::Metadata *> &Fields) {
+  bool IsZeroSize = false;
   // Blocks in OpenCL have unique constraints which make the standard fields
   // redundant while requiring size and align fields for enqueue_kernel. See
   // initializeForBlockHeader in CGBlocks.cpp
   if (CGM.getLangOpts().OpenCL) {
     Fields.push_back(createFieldType("__size", Context.IntTy, Loc, AS_public,
                                      BlockLayout.getElementOffsetInBits(0),
-                                     Unit, Unit));
+                                     Unit, Unit, IsZeroSize));
     Fields.push_back(createFieldType("__align", Context.IntTy, Loc, AS_public,
                                      BlockLayout.getElementOffsetInBits(1),
-                                     Unit, Unit));
+                                     Unit, Unit, IsZeroSize));
   } else {
     Fields.push_back(createFieldType("__isa", Context.VoidPtrTy, Loc, AS_public,
                                      BlockLayout.getElementOffsetInBits(0),
-                                     Unit, Unit));
+                                     Unit, Unit, IsZeroSize));
     Fields.push_back(createFieldType("__flags", Context.IntTy, Loc, AS_public,
                                      BlockLayout.getElementOffsetInBits(1),
-                                     Unit, Unit));
-    Fields.push_back(
-        createFieldType("__reserved", Context.IntTy, Loc, AS_public,
-                        BlockLayout.getElementOffsetInBits(2), Unit, Unit));
+                                     Unit, Unit, IsZeroSize));
+    Fields.push_back(createFieldType(
+        "__reserved", Context.IntTy, Loc, AS_public,
+        BlockLayout.getElementOffsetInBits(2), Unit, Unit, IsZeroSize));
     auto *FnTy = Block.getBlockExpr()->getFunctionType();
     auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
     Fields.push_back(createFieldType("__FuncPtr", FnPtrType, Loc, AS_public,
                                      BlockLayout.getElementOffsetInBits(3),
-                                     Unit, Unit));
+                                     Unit, Unit, IsZeroSize));
     Fields.push_back(createFieldType(
         "__descriptor",
         Context.getPointerType(Block.NeedsCopyDispose
                                    ? Context.getBlockDescriptorExtendedType()
                                    : Context.getBlockDescriptorType()),
-        Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
+        Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit,
+        IsZeroSize));
   }
 }
 
 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
                                                        StringRef Name,
                                                        unsigned ArgNo,
                                                        llvm::AllocaInst *Alloca,
                                                        CGBuilderTy &Builder) {
if (!capture) {
       if (auto *Method =
               cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext()))
         type = Method->getThisType();
       else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent()))
         type = QualType(RDecl->getTypeForDecl(), 0);
       else
         llvm_unreachable("unexpected block declcontext");
 
+      bool IsZeroSize = false;
       fields.push_back(createFieldType("this", type, loc, AS_public,
-                                       offsetInBits, tunit, tunit));
+                                       offsetInBits, tunit, tunit, IsZeroSize));
       continue;
     }
 
     const VarDecl *variable = capture->getVariable();
     StringRef name = variable->getName();
 
     llvm::DIType *fieldType;
     if (capture->isByRef()) {
       TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
       auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0;
       // FIXME: This recomputes the layout of the BlockByRefWrapper.
       uint64_t xoffset;
       fieldType =
           EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
       fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
       fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
                                             PtrInfo.Width, Align, offsetInBits,
                                             llvm::DINode::FlagZero, fieldType);
     } else {
       auto Align = getDeclAlignIfRequired(variable, CGM.getContext());
-      fieldType = createFieldType(name, variable->getType(), loc, AS_public,
-                                  offsetInBits, Align, tunit, tunit);
+      bool IsZeroSize = false;
+      fieldType =
+          createFieldType(name, variable->getType(), loc, AS_public,
+                          offsetInBits, Align, tunit, tunit, IsZeroSize);
     }
     fields.push_back(fieldType);
   }
 
   SmallString<36> typeName;
   llvm::raw_svector_ostream(typeName)
       << "__block_literal_" << CGM.getUniqueBlockCount();
 

lldb/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

bool LibStdcppUniquePtrSyntheticFrontEnd::Update() {
 
   std::unique_ptr<SyntheticChildrenFrontEnd> tuple_frontend(
       LibStdcppTupleSyntheticFrontEndCreator(nullptr, tuple_sp));
 
   ValueObjectSP ptr_obj = tuple_frontend->GetChildAtIndex(0);
   if (ptr_obj)
     m_ptr_obj = ptr_obj->Clone(ConstString("pointer")).get();
 
+  // GCC 11 std::default_delete<...> has existing child with GetByteSize()==1.
+  if (tuple_sp->GetByteSize() > ptr_obj->GetByteSize()) {
     ValueObjectSP del_obj = tuple_frontend->GetChildAtIndex(1);
     if (del_obj)
       m_del_obj = del_obj->Clone(ConstString("deleter")).get();
+  }
 
   if (m_ptr_obj) {
     Status error;
     ValueObjectSP obj_obj = m_ptr_obj->Dereference(error);
     if (error.Success()) {
       m_obj_obj = obj_obj->Clone(ConstString("object")).get();
     }
   }

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

if (attributes.ExtractFormValueAtIndex(i, form_value)) {
       case DW_AT_description:
       case DW_AT_mutable:
       case DW_AT_visibility:
       case DW_AT_sibling:
         break;
       }
     }
   }
+  bool IsZeroSize = byte_size && *byte_size == 0;
 
   if (prop_name) {
     ConstString fixed_setter;
 
     // Check if the property getter/setter were provided as full names.
     // We want basenames, so we extract them.
 
     if (prop_getter_name && prop_getter_name[0] == '-') {
if (tag == DW_TAG_member) {
                   m_ast.CreateArrayType(member_array_element_type, 0, false);
             }
           }
         }
 
         RequireCompleteType(member_clang_type);
 
         field_decl = TypeSystemClang::AddFieldToRecordType(
-            class_clang_type, name, member_clang_type, accessibility,
-            bit_size);
+            class_clang_type, name, member_clang_type, accessibility, bit_size,
+            IsZeroSize);
 
         m_ast.SetMetadataAsUserID(field_decl, die.GetID());
 
         layout_info.field_offsets.insert(
             std::make_pair(field_decl, field_bit_offset));
       } else {
         if (name)
           module_sp->ReportError(

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp

if (!ti.isSimple()) {
     }
   }
 
   clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti));
   m_ast_builder.CompleteType(member_qt);
 
   lldb::AccessType access = TranslateMemberAccess(data_member.getAccess());
 
+  bool IsZeroSize = false; // FIXME: Is there [[no_unique_address]] in PDB?
   clang::FieldDecl *decl = TypeSystemClang::AddFieldToRecordType(
       m_derived_ct, data_member.Name, m_ast_builder.ToCompilerType(member_qt),
-      access, bitfield_width);
+      access, bitfield_width, IsZeroSize);
   // FIXME: Add a PdbSymUid namespace for field list members and update
   // the m_uid_to_decl map with this decl.
 
   m_layout.field_offsets.insert(std::make_pair(decl, offset));
 
   return Error::success();
 }
 

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

while (auto member = members_enum.getNext()) {
     switch (member->getDataKind()) {
     case PDB_DataKind::Member: {
       auto location_type = member->getLocationType();
 
       auto bit_size = member->getLength();
       if (location_type == PDB_LocType::ThisRel)
         bit_size *= 8;
 
+      bool IsZeroSize = false; // FIXME: Is there [[no_unique_address]] in PDB?
       auto decl = TypeSystemClang::AddFieldToRecordType(
-          record_type, member_name.c_str(), member_comp_type, access, bit_size);
+          record_type, member_name.c_str(), member_comp_type, access, bit_size,
+          IsZeroSize);
       if (!decl)
         continue;
 
       m_uid_to_decl[member->getSymIndexId()] = decl;
 
       auto offset = member->getOffset() * 8;
       if (location_type == PDB_LocType::BitField)
         offset += member->getBitPosition();

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if child_decl_ctx
   // could not be found in decl_ctx.
   uint32_t CountDeclLevels(clang::DeclContext *frame_decl_ctx,
                            clang::DeclContext *child_decl_ctx,
                            ConstString *child_name = nullptr,
                            CompilerType *child_type = nullptr);
 
   // Modifying RecordType
-  static clang::FieldDecl *AddFieldToRecordType(const CompilerType &type,
-                                                llvm::StringRef name,
-                                                const CompilerType &field_type,
-                                                lldb::AccessType access,
-                                                uint32_t bitfield_bit_size);
+  static clang::FieldDecl *
+  AddFieldToRecordType(const CompilerType &type, llvm::StringRef name,
+                       const CompilerType &field_type, lldb::AccessType access,
+                       uint32_t bitfield_bit_size, bool IsZeroSize = false);
 
   static void BuildIndirectFields(const CompilerType &type);
 
   static void SetIsPacked(const CompilerType &type);
 
   static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
                                                  llvm::StringRef name,
                                                  const CompilerType &var_type,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

TypeSystemClang::GetAsObjCInterfaceDecl(const CompilerType &type) {
   if (objc_class_type)
     return objc_class_type->getInterface();
   return nullptr;
 }
 
 clang::FieldDecl *TypeSystemClang::AddFieldToRecordType(
     const CompilerType &type, llvm::StringRef name,
     const CompilerType &field_clang_type, AccessType access,
-    uint32_t bitfield_bit_size) {
+    uint32_t bitfield_bit_size, bool IsZeroSize) {
   if (!type.IsValid() || !field_clang_type.IsValid())
     return nullptr;
   TypeSystemClang *ast =
       llvm::dyn_cast_or_null<TypeSystemClang>(type.GetTypeSystem());
   if (!ast)
     return nullptr;
   clang::ASTContext &clang_ast = ast->getASTContext();
   clang::IdentifierInfo *ident = nullptr;
clang::FieldDecl *TypeSystemClang::AddFieldToRecordType(
   if (record_decl) {
     field = clang::FieldDecl::CreateDeserialized(clang_ast, 0);
     field->setDeclContext(record_decl);
     field->setDeclName(ident);
     field->setType(ClangUtil::GetQualType(field_clang_type));
     if (bit_width)
       field->setBitWidth(bit_width);
     SetMemberOwningModule(field, record_decl);
+    if (IsZeroSize)
+      field->addAttr(NoUniqueAddressAttr::CreateImplicit(ast->getASTContext()));
 
     if (name.empty()) {
       // Determine whether this field corresponds to an anonymous struct or
       // union.
       if (const clang::TagType *TagT =
               field->getType()->getAs<clang::TagType>()) {
         if (clang::RecordDecl *Rec =
                 llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))

lldb/test/Shell/Expr/no_unique_address.cpp

+// Test LLDB does not assert on miscalculated field offsets.
+
+// RUN: %clang_host %s -g -c -o %t.o
+// RUN: %lldb %t.o -o "p c.c" -o exit | FileCheck %s
+
+// CHECK: (lldb) p c.c
+// CHECK-NEXT: (char) $0 = '\0'
+
+struct A {};
+struct B {
+  [[no_unique_address]] A a;
+};
+struct C : B {
+  char c;
+} c;

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (IsBitfield) {
         if (Asm->getDataLayout().isLittleEndian())
           Offset = FieldSize - (Offset + Size);
 
         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
         OffsetInBytes = FieldOffset >> 3;
       } else {
         addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
       }
+      assert(!(DT->getFlags() & DINode::FlagIsZeroSize) &&
+             "bitfields cannot have [[no_unique_address]]");
     } else {
       // This is not a bitfield.
       OffsetInBytes = DT->getOffsetInBits() / 8;
       if (AlignInBytes)
         addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
                 AlignInBytes);
+      if (DT->getFlags() & DINode::FlagIsZeroSize)
+        addUInt(MemberDie, dwarf::DW_AT_byte_size, None, 0);
     }
 
     if (DD->getDwarfVersion() <= 2) {
       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
     } else if (!IsBitfield || DD->useDWARF2Bitfields())