[analyzer] Added more tests for scalars and enums for StrictAliasingChecker

[ASDenysPetrov]

Summary

Added tests to check aliasing:

• scalars through enums;
• enums through enums;
• enums through scalars.

clang/test/Analysis/Checkers/StrictAliasingChecker/enam-ptr-to-scalar.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+template <typename T>
+T *create() { return new T; }
+
+#define CHECK(var, type) \
+  { auto y = *(type *)var; }
+
+#define CHECKS_NO_WARN \
+  CHECK(x, char)       \
+  CHECK(x, unsigned char)
+
+#define CHECKS                 \
+  CHECK(x, bool)               \
+  CHECK(x, short)              \
+  CHECK(x, int)                \
+  CHECK(x, long)               \
+  CHECK(x, long long)          \
+  CHECK(x, signed char)        \
+  CHECK(x, unsigned short)     \
+  CHECK(x, unsigned int)       \
+  CHECK(x, unsigned long)      \
+  CHECK(x, unsigned long long) \
+  CHECK(x, float)              \
+  CHECK(x, double)             \
+  CHECK(x, long double)
+
+void std_byte_test() {
+  auto *x = create<std::byte>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_OtherByte_test() {
+  auto *x = create<std::OtherByte>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnum_test() {
+  auto *x = create<ClassEnum>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumChar_test() {
+  auto *x = create<ClassEnumChar>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumUChar_test() {
+  auto *x = create<ClassEnumUChar>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumInt_test() {
+  auto *x = create<ClassEnumInt>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void Enum_test() {
+  auto *x = create<Enum>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumChar_test() {
+  auto *x = create<EnumChar>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumUChar_test() {
+  auto *x = create<EnumUChar>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumInt_test() {
+  auto *x = create<EnumInt>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void E_Dummy_test() {
+  auto *x = create<decltype(E_Dummy)>();
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_byte_test(std::byte *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_OtherByte_test(std::OtherByte *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnum_test(ClassEnum *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumChar_test(ClassEnumChar *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumUChar_test(ClassEnumUChar *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumInt_test(ClassEnumInt *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void Enum_test(Enum *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumChar_test(EnumChar *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumUChar_test(EnumUChar *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumInt_test(EnumInt *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void E_Dummy_test(decltype(E_Dummy) *x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}

clang/test/Analysis/Checkers/StrictAliasingChecker/enam-var-to-scalar.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+#define CHECK(var, type) \
+  { auto y = *(type *)&var; }
+
+#define CHECKS_NO_WARN \
+  CHECK(x, char)       \
+  CHECK(x, unsigned char)
+
+#define CHECKS                 \
+  CHECK(x, bool)               \
+  CHECK(x, short)              \
+  CHECK(x, int)                \
+  CHECK(x, long)               \
+  CHECK(x, long long)          \
+  CHECK(x, signed char)        \
+  CHECK(x, unsigned short)     \
+  CHECK(x, unsigned int)       \
+  CHECK(x, unsigned long)      \
+  CHECK(x, unsigned long long) \
+  CHECK(x, float)              \
+  CHECK(x, double)             \
+  CHECK(x, long double)
+
+void std_byte_test() {
+  std::byte x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_OtherByte_test() {
+  std::OtherByte x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnum_test() {
+  ClassEnum x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumChar_test() {
+  ClassEnumChar x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumUChar_test() {
+  ClassEnumUChar x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumInt_test() {
+  ClassEnumInt x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void Enum_test() {
+  Enum x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumChar_test() {
+  EnumChar x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumUChar_test() {
+  EnumUChar x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumInt_test() {
+  EnumInt x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void E_Dummy_test() {
+  decltype(E_Dummy) x{};
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_byte_test(std::byte x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void std_OtherByte_test(std::OtherByte x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnum_test(ClassEnum x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumChar_test(ClassEnumChar x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumUChar_test(ClassEnumUChar x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void ClassEnumInt_test(ClassEnumInt x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void Enum_test(Enum x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumChar_test(EnumChar x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumUChar_test(EnumUChar x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void EnumInt_test(EnumInt x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}
+
+void E_Dummy_test(decltype(E_Dummy) x) {
+  CHECKS_NO_WARN // no-warning
+      CHECKS     // expected-warning 13{{Undefined behavior}}
+}

clang/test/Analysis/Checkers/StrictAliasingChecker/enum-ptr-to-enum.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+template <typename T>
+T *create() { return new T{}; }
+
+#define CHECK(var, type) \
+  { auto y = *(type *)var; }
+
+void std_byte_test() {
+  auto *x = create<std::byte>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void std_OtherByte_test() {
+  auto *x = create<std::OtherByte>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // no-warning
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnum_test() {
+  auto *x = create<ClassEnum>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // no-warning
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumChar_test() {
+  auto *x = create<ClassEnumChar>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // no-warning
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumUChar_test() {
+  auto *x = create<ClassEnumUChar>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // no-warning
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumInt_test() {
+  auto *x = create<ClassEnumInt>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // no-warning
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void Enum_test() {
+  auto *x = create<Enum>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // no-warning
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumChar_test() {
+  auto *x = create<EnumChar>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // no-warning
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumUChar_test() {
+  auto *x = create<EnumUChar>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // no-warning
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumInt_test() {
+  auto *x = create<EnumInt>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // no-warning
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void E_Dummy_test() {
+  auto *x = create<decltype(E_Dummy)>();
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // no-warning
+}
+
+void std_byte_test(std::byte *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void std_OtherByte_test(std::OtherByte *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // no-warning
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnum_test(ClassEnum *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // no-warning
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumChar_test(ClassEnumChar *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // no-warning
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumUChar_test(ClassEnumUChar *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // no-warning
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumInt_test(ClassEnumInt *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // no-warning
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void Enum_test(Enum *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // no-warning
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumChar_test(EnumChar *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // no-warning
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumUChar_test(EnumUChar *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // no-warning
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumInt_test(EnumInt *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // no-warning
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void E_Dummy_test(decltype(E_Dummy) *x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // no-warning
+}

clang/test/Analysis/Checkers/StrictAliasingChecker/enum-var-to-enum.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+#define CHECK(var, type) \
+  { auto y = *(type *)&var; }
+
+void std_byte_test() {
+  std::byte x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void std_OtherByte_test() {
+  std::OtherByte x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // no-warning
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnum_test() {
+  ClassEnum x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // no-warning
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumChar_test() {
+  ClassEnumChar x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // no-warning
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumUChar_test() {
+  ClassEnumUChar x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // no-warning
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumInt_test() {
+  ClassEnumInt x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // no-warning
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void Enum_test() {
+  Enum x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // no-warning
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumChar_test() {
+  EnumChar x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // no-warning
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumUChar_test() {
+  EnumUChar x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // no-warning
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumInt_test() {
+  EnumInt x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // no-warning
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void E_Dummy_test() {
+  decltype(E_Dummy) x{};
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // no-warning
+}
+
+void std_byte_test(std::byte x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void std_OtherByte_test(std::OtherByte x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // no-warning
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnum_test(ClassEnum x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // no-warning
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumChar_test(ClassEnumChar x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // no-warning
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumUChar_test(ClassEnumUChar x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // no-warning
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void ClassEnumInt_test(ClassEnumInt x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // no-warning
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void Enum_test(Enum x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // no-warning
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumChar_test(EnumChar x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // no-warning
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumUChar_test(EnumUChar x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // no-warning
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void EnumInt_test(EnumInt x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // no-warning
+  CHECK(x, decltype(E_Dummy)) // expected-warning {{Undefined behavior}}
+}
+
+void E_Dummy_test(decltype(E_Dummy) x) {
+  CHECK(x, std::byte)         // no-warning
+  CHECK(x, std::OtherByte)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnum)         // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumChar)     // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumUChar)    // expected-warning {{Undefined behavior}}
+  CHECK(x, ClassEnumInt)      // expected-warning {{Undefined behavior}}
+  CHECK(x, Enum)              // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumChar)          // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumUChar)         // expected-warning {{Undefined behavior}}
+  CHECK(x, EnumInt)           // expected-warning {{Undefined behavior}}
+  CHECK(x, decltype(E_Dummy)) // no-warning
+}

clang/test/Analysis/Checkers/StrictAliasingChecker/enums.h

+#pragma once
+namespace std {
+enum class byte : unsigned char {};
+enum class OtherByte : unsigned char {};
+}; // namespace std
+enum class ClassEnum {};
+enum class ClassEnumChar : char {};
+enum class ClassEnumUChar : unsigned char {};
+enum class ClassEnumInt : int {};
+enum Enum {};
+enum EnumChar : char {};
+enum EnumUChar : unsigned char {};
+enum EnumInt : int {};
+enum { E_Dummy };

clang/test/Analysis/Checkers/StrictAliasingChecker/scalar-ptr-to-enum.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+template <typename T>
+T *create();
+
+#define CHECK(var, type) \
+  { auto y = *(type *)var; }
+
+#define CHECKS             \
+  CHECK(x, std::OtherByte) \
+  CHECK(x, ClassEnum)      \
+  CHECK(x, ClassEnumChar)  \
+  CHECK(x, ClassEnumUChar) \
+  CHECK(x, ClassEnumInt)   \
+  CHECK(x, Enum)           \
+  CHECK(x, EnumChar)       \
+  CHECK(x, EnumUChar)      \
+  CHECK(x, EnumInt)        \
+  CHECK(x, decltype(E_Dummy))
+
+void bool_test() {
+  auto *x = create<bool>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void char_test() {
+  auto *x = create<char>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void short_test() {
+  auto *x = create<short>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void int_test() {
+  auto *x = create<int>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_test() {
+  auto *x = create<long>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_long_test() {
+  auto *x = create<long long>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void schar_test() {
+  auto *x = create<signed char>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uchar_test() {
+  auto *x = create<unsigned char>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ushort_test() {
+  auto *x = create<unsigned short>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uint_test() {
+  auto *x = create<unsigned int>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_test() {
+  auto *x = create<unsigned long>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_long_test() {
+  auto *x = create<unsigned long long>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void float_test() {
+  auto *x = create<float>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void double_test() {
+  auto *x = create<double>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_double_test() {
+  auto *x = create<long double>();
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void bool_test(bool *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void char_test(char *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void short_test(short *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void int_test(int *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_test(long *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_long_test(long long *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uchar_test(unsigned char *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ushort_test(unsigned short *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uint_test(unsigned int *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_test(unsigned long *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_long_test(unsigned long long *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void float_test(float *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void double_test(double *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_double_test(long double *x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}

clang/test/Analysis/Checkers/StrictAliasingChecker/scalar-var-to-enum.cpp

+// RUN: %clang_cc1 -std=c++20 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=debug.ExprInspection,alpha.core.StrictAliasing -verify %s
+// NOTE: -relaxed-aliasing flag disables StrictAliasing checker.
+
+#include "enums.h"
+
+#define CHECK(var, type) \
+  { auto y = *(type *)&var; }
+
+#define CHECKS             \
+  CHECK(x, std::OtherByte) \
+  CHECK(x, ClassEnum)      \
+  CHECK(x, ClassEnumChar)  \
+  CHECK(x, ClassEnumUChar) \
+  CHECK(x, ClassEnumInt)   \
+  CHECK(x, Enum)           \
+  CHECK(x, EnumChar)       \
+  CHECK(x, EnumUChar)      \
+  CHECK(x, EnumInt)        \
+  CHECK(x, decltype(E_Dummy))
+
+void bool_test() {
+  bool x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void char_test() {
+  char x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void short_test() {
+  short x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void int_test() {
+  int x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_test() {
+  long x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_long_test() {
+  long long x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void schar_test() {
+  signed char x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uchar_test() {
+  unsigned char x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ushort_test() {
+  unsigned short x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uint_test() {
+  unsigned int x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_test() {
+  unsigned long x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_long_test() {
+  unsigned long long x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void float_test() {
+  float x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void double_test() {
+  double x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_double_test() {
+  long double x = 42;
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void bool_test(bool x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void char_test(char x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void short_test(short x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void int_test(int x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_test(long x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_long_test(long long x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uchar_test(unsigned char x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ushort_test(unsigned short x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void uint_test(unsigned int x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_test(unsigned long x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void ulong_long_test(unsigned long long x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void float_test(float x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void double_test(double x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}
+
+void long_double_test(long double x) {
+  CHECK(x, std::byte) // no-warning
+  CHECKS              // expected-warning 10{{Undefined behavior}}
+}