[Sema] Implicitly apply the may_alias attribute to std::byte

[majnemer]

Summary

std::byte, when defined as an enum, needs to be given special treatment
with regards to its aliasing properties. An array of std::byte is
allowed to be used as storage for other types.

This fixes PR33916.

[rsmith]

I would prefer to handle std::byte explicitly in the places where it matters, rather than adding an attribute to it and otherwise treating it like any other enumeration. We're going to want to be able to identify std::byte for warning emission and probably other codegen purposes too -- it's more a new fundamental type that happens to be defined in the library (like std::nullptr_t) than a type that just happens to be mayalias. Maybe a Type::is[Std]Byte, analogous to Type::isAlignValT?

As far as I can see, nowhere in Clang cares about MayAliasAttr on enums other than CodeGenTBAA.cpp.

[majnemer]

• Address review feedback.

[• Quuxplusone]

test/CodeGenCXX/std-byte.cpp

8

Would it be worth adding an explicit test that ::byte, ::my::byte, ::my::std::byte are or are not handled in the same way?

[majnemer]

• Address review comments

[rsmith]

LGTM with a tweaked comment. Thanks!

lib/CodeGen/CodeGenTBAA.cpp

88–90 ↗

(On Diff #108166)

[basic.lval]p10: "If a program attempts to access the stored value of an object through a glvalue of other than one of the following types the behavior is undefined: [...] a char, unsigned char, or std::byte type."

... is the relevant quotation for the purpose of aliasing.

lib/Sema/SemaDecl.cpp

else if (UnderlyingType.get()) {
       }
     }
   }
 
   DeclContext *SearchDC = CurContext;
   DeclContext *DC = CurContext;
   bool isStdBadAlloc = false;
   bool isStdAlignValT = false;
+  bool isStdByte = false;
 
   RedeclarationKind Redecl = ForRedeclaration;
   if (TUK == TUK_Friend || TUK == TUK_Reference)
     Redecl = NotForRedeclaration;
 
   /// Create a new tag decl in C/ObjC. Since the ODR-like semantics for ObjC/C
   /// implemented asks for structural equivalence checking, the returned decl
   /// here is passed back to the parser, allowing the tag body to be parsed.
if (Name->isStr("bad_alloc")) {
       // name lookup), fill in this implicit declaration as the previous
       // declaration, so that the declarations get chained appropriately.
       if (Previous.empty() && StdBadAlloc)
         Previous.addDecl(getStdBadAlloc());
     } else if (Name->isStr("align_val_t")) {
       isStdAlignValT = true;
       if (Previous.empty() && StdAlignValT)
         Previous.addDecl(getStdAlignValT());
+    } else if (Name->isStr("byte")) {
+      isStdByte = true;
     }
   }
 
   // If we didn't find a previous declaration, and this is a reference
   // (or friend reference), move to the correct scope.  In C++, we
   // also need to do a redeclaration lookup there, just in case
   // there's a shadow friend decl.
   if (Name && Previous.empty() &&
if (Kind == TTK_Enum) {
     // enum X { A, B, C } D;    D should chain to X.
     New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
                            cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
                            ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
 
     if (isStdAlignValT && (!StdAlignValT || getStdAlignValT()->isImplicit()))
       StdAlignValT = cast<EnumDecl>(New);
 
+    // C++1z [intro.object]p3: If a complete object is created (5.3.4) in
+    // storage associated with another object e of type "array of N unsigned
+    // char" or "array of N std::byte", that array provides storage for the
+    // created object [...].
+    if (isStdByte)
+      New->addAttr(MayAliasAttr::CreateImplicit(Context, New->getLocation()));
+
     // If this is an undefined enum, warn.
     if (TUK != TUK_Definition && !Invalid) {
       TagDecl *Def;
       if (!EnumUnderlyingIsImplicit &&
           (getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
           cast<EnumDecl>(New)->isFixed()) {
         // C++0x: 7.2p2: opaque-enum-declaration.
         // Conflicts are diagnosed above. Do nothing.

test/CodeGenCXX/std-byte.cpp

+// RUN: %clang_cc1 -std=c++1z -Werror -triple i386-unknown-unknown -emit-llvm -O1 -disable-llvm-passes -o - %s | FileCheck %s
+
+// std::byte should be considered equivalent to char for aliasing.
+
+namespace std {
+enum byte : unsigned char {};
+}
+
+void test0(std::byte *sb, int *i) {
+  // CHECK: store i8 0, i8* %{{.*}}, !tbaa [[TAG_STD_BYTE:!.*]]
+  // PATH: store i8 0, i8* %{{.*}}, !tbaa [[TAG_STD_BYTE:!.*]]
+  *sb = std::byte{0};
+
+  // CHECK: store i32 1, i32* %{{.*}}, !tbaa [[TAG_INT:!.*]]
+  // PATH: store i32 1, i32* %{{.*}}, !tbaa [[TAG_INT:!.*]]
+  *i = 1;
+}
+
+// CHECK:  !"any pointer", [[TYPE_CHAR:!.*]],
+// CHECK: [[TYPE_CHAR]] = !{!"omnipotent char", [[TAG_CXX_TBAA:!.*]],
+// CHECK: [[TAG_CXX_TBAA]] = !{!"Simple C++ TBAA"}
+// CHECK: [[TAG_STD_BYTE]] = !{[[TYPE_STD_BYTE:!.*]], [[TYPE_STD_BYTE]], i64 0}
+// CHECK: [[TYPE_STD_BYTE]] = !{!"_ZTSSt4byte", [[TYPE_CHAR]], i64 0}
+// CHECK: [[TAG_INT]] = !{[[TYPE_INT:!.*]], [[TYPE_INT]], i64 0}
+// CHECK: [[TYPE_INT]] = !{!"int", [[TYPE_CHAR]]