[Clang] Consider preferred_type in bitfield warnings (#116760)

Very simply extends the bitfield sema checks for assignment to fields
with a preferred type specified to consider the preferred type if the
decl storage type is not explicitly an enum type.

This does mean that if the preferred and explicit types have different
storage requirements we may not warn in all possible cases, but that's
a scenario for which the warnings are much more complex and confusing.

Author: ojhunt

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6404,20 +6404,23 @@ def warn_bitfield_width_exceeds_type_width: Warning<
 def err_bitfield_too_wide : Error<
   "%select{bit-field %1|anonymous bit-field}0 is too wide (%2 bits)">;
 def warn_bitfield_too_small_for_enum : Warning<
-  "bit-field %0 is not wide enough to store all enumerators of %1">,
+  "bit-field %0 is not wide enough to store all enumerators of %select{|preferred type }1%2">,
   InGroup<BitFieldEnumConversion>, DefaultIgnore;
 def note_widen_bitfield : Note<
   "widen this field to %0 bits to store all values of %1">;
 def warn_unsigned_bitfield_assigned_signed_enum : Warning<
-  "assigning value of signed enum type %1 to unsigned bit-field %0; "
+  "assigning value of %select{|preferred }1signed enum type %2 to unsigned bit-field %0; "
   "negative enumerators of enum %1 will be converted to positive values">,
   InGroup<BitFieldEnumConversion>, DefaultIgnore;
 def warn_signed_bitfield_enum_conversion : Warning<
   "signed bit-field %0 needs an extra bit to represent the largest positive "
-  "enumerators of %1">,
+  "enumerators of %select{|preferred type }1%2">,
   InGroup<BitFieldEnumConversion>, DefaultIgnore;
 def note_change_bitfield_sign : Note<
   "consider making the bitfield type %select{unsigned|signed}0">;
+def note_bitfield_preferred_type : Note<
+  "preferred type for bitfield %0 specified here"
+>;
 
 def warn_missing_braces : Warning<
   "suggest braces around initialization of subobject">,

clang/lib/Sema/SemaChecking.cpp

@@ -10488,7 +10488,14 @@ static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init,
     // The RHS is not constant.  If the RHS has an enum type, make sure the
     // bitfield is wide enough to hold all the values of the enum without
     // truncation.
-    if (const auto *EnumTy = OriginalInit->getType()->getAs<EnumType>()) {
+    const auto *EnumTy = OriginalInit->getType()->getAs<EnumType>();
+    const PreferredTypeAttr *PTAttr = nullptr;
+    if (!EnumTy) {
+      PTAttr = Bitfield->getAttr<PreferredTypeAttr>();
+      if (PTAttr)
+        EnumTy = PTAttr->getType()->getAs<EnumType>();
+    }
+    if (EnumTy) {
       EnumDecl *ED = EnumTy->getDecl();
       bool SignedBitfield = BitfieldType->isSignedIntegerType();
 
@@ -10509,14 +10516,18 @@ static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init,
                  ED->getNumPositiveBits() == FieldWidth) {
         DiagID = diag::warn_signed_bitfield_enum_conversion;
       }
-
+      unsigned PreferredTypeDiagIndex = PTAttr != nullptr;
       if (DiagID) {
-        S.Diag(InitLoc, DiagID) << Bitfield << ED;
+        S.Diag(InitLoc, DiagID) << Bitfield << PreferredTypeDiagIndex << ED;
         TypeSourceInfo *TSI = Bitfield->getTypeSourceInfo();
         SourceRange TypeRange =
             TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange();
         S.Diag(Bitfield->getTypeSpecStartLoc(), diag::note_change_bitfield_sign)
             << SignedEnum << TypeRange;
+        if (PTAttr) {
+          S.Diag(PTAttr->getLocation(), diag::note_bitfield_preferred_type)
+              << ED;
+        }
       }
 
       // Compute the required bitwidth. If the enum has negative values, we need
@@ -10530,9 +10541,13 @@ static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init,
       if (BitsNeeded > FieldWidth) {
         Expr *WidthExpr = Bitfield->getBitWidth();
         S.Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
-            << Bitfield << ED;
+            << Bitfield << PreferredTypeDiagIndex << ED;
         S.Diag(WidthExpr->getExprLoc(), diag::note_widen_bitfield)
             << BitsNeeded << ED << WidthExpr->getSourceRange();
+        if (PTAttr) {
+          S.Diag(PTAttr->getLocation(), diag::note_bitfield_preferred_type)
+              << ED;
+        }
       }
     }
 

clang/test/Sema/bitfield-preferred-type-sizing.c

@@ -0,0 +1,108 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c11 -Wno-unused-value -Wno-unused-but-set-variable -Wbitfield-width -Wbitfield-enum-conversion
+
+enum A {
+  A_a,
+  A_b,
+  A_c,
+  A_d
+};
+
+struct S {
+  enum A a1 : 1; // #1
+  enum A a2 : 2;
+  enum A a3 : 8;
+  __attribute__((preferred_type(enum A))) // #preferred_a4
+  unsigned a4 : 1; // #2
+  __attribute__((preferred_type(enum A)))
+  unsigned a5 : 2;
+  __attribute__((preferred_type(enum A)))
+  unsigned a6 : 8;
+  __attribute__((preferred_type(enum A)))  // #preferred_a7
+  int a7 : 1; // #3
+  __attribute__((preferred_type(enum A))) // #preferred_a8
+  int a8 : 2; // #4
+  __attribute__((preferred_type(enum A)))
+  int a9 : 8;
+};
+
+void read_enum(struct S *s) {
+  enum A x;
+  x = s->a1;
+  x = s->a2;
+  x = s->a3;
+  x = s->a4;
+  x = s->a5;
+  x = s->a6;
+  x = s->a7;
+  x = s->a8;
+  x = s->a9;
+}
+
+void write_enum(struct S *s, enum A x) {
+  s->a1 = x;
+  // expected-warning@-1 {{bit-field 'a1' is not wide enough to store all enumerators of 'A'}}
+  // expected-note@#1 {{widen this field to 2 bits to store all values of 'A'}}
+  s->a2 = x;
+  s->a3 = x;
+  s->a4 = x;
+  // expected-warning@-1 {{bit-field 'a4' is not wide enough to store all enumerators of 'A'}}
+  // expected-note@#2 {{widen this field to 2 bits to store all values of 'A'}}
+  s->a5 = x;
+  s->a6 = x;
+  s->a7 = x;
+  // expected-warning@-1 {{bit-field 'a7' is not wide enough to store all enumerators of 'A'}}
+  // expected-note@#3 {{widen this field to 2 bits to store all values of 'A'}}
+  s->a8 = x;
+  // expected-warning@-1 {{signed bit-field 'a8' needs an extra bit to represent the largest positive enumerators of 'A'}}
+  // expected-note@#4 {{consider making the bitfield type unsigned}}
+  s->a9 = x;
+}
+
+void write_enum_int(struct S *s, int x) {
+  s->a1 = x;
+  s->a2 = x;
+  s->a3 = x;
+  s->a4 = x;
+  // expected-warning@-1 {{bit-field 'a4' is not wide enough to store all enumerators of preferred type 'A'}}
+  // expected-note@#2 {{widen this field to 2 bits to store all values of 'A'}}
+  // expected-note@#preferred_a4 {{preferred type for bitfield 'A' specified here}}
+  s->a5 = x;
+  s->a6 = x;
+  s->a7 = x;
+  // expected-warning@-1 {{bit-field 'a7' is not wide enough to store all enumerators of preferred type 'A'}}
+  // expected-note@#3 {{widen this field to 2 bits to store all values of 'A'}}
+  // expected-note@#preferred_a7 {{preferred type for bitfield 'A' specified here}}
+  s->a8 = x;
+  // expected-warning@-1 {{signed bit-field 'a8' needs an extra bit to represent the largest positive enumerators of preferred type 'A'}}
+  // expected-note@#4 {{consider making the bitfield type unsigned}}
+  // expected-note@#preferred_a8 {{preferred type for bitfield 'A' specified here}}
+  s->a9 = x;
+}
+
+void write_low_constant(struct S *s) {
+  s->a1 = A_a;
+  s->a2 = A_a;
+  s->a3 = A_a;
+  s->a4 = A_a;
+  s->a5 = A_a;
+  s->a6 = A_a;
+  s->a7 = A_a;
+  s->a8 = A_a;
+  s->a9 = A_a;
+};
+
+void write_high_constant(struct S *s) {
+  s->a1 = A_d;
+  // expected-warning@-1 {{implicit truncation from 'int' to bit-field changes value from 3 to 1}}
+  s->a2 = A_d;
+  s->a3 = A_d;
+  s->a4 = A_d;
+  // expected-warning@-1 {{implicit truncation from 'int' to bit-field changes value from 3 to 1}}
+  s->a5 = A_d;
+  s->a6 = A_d;
+  s->a7 = A_d;
+  // expected-warning@-1 {{implicit truncation from 'int' to bit-field changes value from 3 to -1}}
+  s->a8 = A_d;
+  // expected-warning@-1 {{implicit truncation from 'int' to bit-field changes value from 3 to -1}}
+  s->a9 = A_d;
+};