[analyzer] Fix calculating offset for fields with an empty type

[jubnzv]

Summary

Fix offset calculation routines in padding checker to avoid assertion errors described in the following issue: https://bugs.llvm.org/show_bug.cgi?id=50426.
The fields that are subojbects of zero size, marked with [[no_unique_address]] or empty bitfields will be excluded from the padding calculation routines.

[NoQ]

This looks correct, thanks!

I think there are some weird rules with respect to [[no_unique_address]] on two consecutive fields when there's only one other field in the structure, eg.

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

will have a size of two bytes according to https://en.cppreference.com/w/cpp/language/attributes/no_unique_address.

It's probably worth a test case to see if we still calculate padding correctly in such cases but I don't insist.

[jubnzv]

Added two tests that check whether we still calculate padding correctly for structs with [[no_unique_address]] on two consecutive fields

clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp

public:
   }
 
   static CharUnits calculateBaselinePad(const RecordDecl *RD,
                                         const ASTContext &ASTContext,
                                         const ASTRecordLayout &RL) {
     CharUnits PaddingSum;
     CharUnits Offset = ASTContext.toCharUnitsFromBits(RL.getFieldOffset(0));
     for (const FieldDecl *FD : RD->fields()) {
+      // Skip field that is a subobject of zero size, marked with
+      // [[no_unique_address]] or an empty bitfield, because its address can be
+      // set the same as the other fields addresses.
+      if (FD->isZeroSize(ASTContext))
+        continue;
       // This checker only cares about the padded size of the
       // field, and not the data size. If the field is a record
       // with tail padding, then we won't put that number in our
       // total because reordering fields won't fix that problem.
       CharUnits FieldSize = ASTContext.getTypeSizeInChars(FD->getType());
       auto FieldOffsetBits = RL.getFieldOffset(FD->getFieldIndex());
       CharUnits FieldOffset = ASTContext.toCharUnitsFromBits(FieldOffsetBits);
       PaddingSum += (FieldOffset - Offset);
struct FieldInfo {
       }
     };
     SmallVector<FieldInfo, 20> Fields;
     auto GatherSizesAndAlignments = [](const FieldDecl *FD) {
       FieldInfo RetVal;
       RetVal.Field = FD;
       auto &Ctx = FD->getASTContext();
       auto Info = Ctx.getTypeInfoInChars(FD->getType());
-      RetVal.Size = Info.Width;
+      RetVal.Size = FD->isZeroSize(Ctx) ? CharUnits::Zero() : Info.Width;
       RetVal.Align = Info.Align;
       assert(llvm::isPowerOf2_64(RetVal.Align.getQuantity()));
       if (auto Max = FD->getMaxAlignment())
         RetVal.Align = std::max(Ctx.toCharUnitsFromBits(Max), RetVal.Align);
       return RetVal;
     };
     std::transform(RD->field_begin(), RD->field_end(),
                    std::back_inserter(Fields), GatherSizesAndAlignments);

clang/test/Analysis/padding_no_unique_address.cpp

+// RUN: %clang_analyze_cc1 -std=c++14 -triple x86_64-linux-gnu -analyzer-checker=optin.performance -analyzer-config optin.performance.Padding:AllowedPad=2 -verify %s
+
+class Empty {}; // no-warning
+
+// expected-warning@+1{{Excessive padding in 'struct NoUniqueAddressWarn1' (6 padding}}
+struct NoUniqueAddressWarn1 {
+  char c1;
+  [[no_unique_address]] Empty empty;
+  int i;
+  char c2;
+};
+
+// expected-warning@+1{{Excessive padding in 'struct NoUniqueAddressWarn2' (6 padding}}
+struct NoUniqueAddressWarn2 {
+    char c1;
+    [[no_unique_address]] Empty e1, e2;
+    int i;
+    char c2;
+};
+
+struct NoUniqueAddressNoWarn1 {
+  char c1;
+  [[no_unique_address]] Empty empty;
+  char c2;
+};
+
+struct NoUniqueAddressNoWarn2 {
+  char c1;
+  [[no_unique_address]] Empty e1, e2;
+};