[ExprConstant] fix ICE from Evaluate on _Atomic structs

[nickdesaulniers]

Summary

Fixes two crashes reported by @efriedma and @ahatanak, as per
@ahatanak's analysis.

Link: https://reviews.llvm.org/D151587#4397446
Link: https://reviews.llvm.org/D151587#4399684

[ahatanak]

LGTM

[aaron.ballman]

Please add a release note for the fix, but otherwise LGTM. Thank you!

[nickdesaulniers]

• add release note

clang/docs/ReleaseNotes.rst

- Fix crash when passing a braced initializer list to a parentehsized aggregate
   (`#63008 <https://github.com/llvm/llvm-project/issues/63008>`_).
 - Reject increment of bool value in unevaluated contexts after C++17.
   (`#47517 <https://github.com/llvm/llvm-project/issues/47517>`_).
 - Fix assertion and quality of diagnostic messages in a for loop
   containing multiple declarations and a range specifier
   (`#63010 <https://github.com/llvm/llvm-project/issues/63010>`_).
 - Fix rejects-valid when consteval operator appears inside of a template.
   (`#62886 <https://github.com/llvm/llvm-project/issues/62886>`_).
+- Fix crash for code using ``_Atomic`` types in C++
+  (`See patch <https://reviews.llvm.org/D152303>`_).
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed a bug where attribute annotations on type specifiers (enums, classes,
   structs, unions, and scoped enums) were not properly ignored, resulting in

clang/lib/AST/ExprConstant.cpp

static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
   } else if (T->isAtomicType()) {
     QualType Unqual = T.getAtomicUnqualifiedType();
     if (Unqual->isArrayType() || Unqual->isRecordType()) {
       LValue LV;
       APValue &Value = Info.CurrentCall->createTemporary(
           E, Unqual, ScopeKind::FullExpression, LV);
       if (!EvaluateAtomic(E, &LV, Value, Info))
         return false;
+      Result = Value;
     } else {
       if (!EvaluateAtomic(E, nullptr, Result, Info))
         return false;
     }
   } else if (Info.getLangOpts().CPlusPlus11) {
     Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
     return false;
   } else {

clang/test/CodeGenCXX/atomicinit.cpp

 // RUN: %clang_cc1 -fno-inline-functions %s -emit-llvm -O1 -o - -triple=i686-apple-darwin9 -std=c++11 | FileCheck %s
 
 // CHECK-DAG: @PR22043 ={{.*}} local_unnamed_addr global i32 0, align 4
 typedef _Atomic(int) AtomicInt;
 AtomicInt PR22043 = AtomicInt();
 
 // CHECK-DAG: @_ZN7PR180978constant1aE ={{.*}} local_unnamed_addr global { i16, i8 } { i16 1, i8 6 }, align 4
 // CHECK-DAG: @_ZN7PR180978constant1bE ={{.*}} local_unnamed_addr global { i16, i8 } { i16 2, i8 6 }, align 4
 // CHECK-DAG: @_ZN7PR180978constant1cE ={{.*}} local_unnamed_addr global { i16, i8 } { i16 3, i8 6 }, align 4
 // CHECK-DAG: @_ZN7PR180978constant1yE ={{.*}} local_unnamed_addr global { { i16, i8 }, i32 } { { i16, i8 } { i16 4, i8 6 }, i32 5 }, align 4
+// CHECK-DAG: @_ZN7PR180978constant1zE ={{.*}} global i32 0, align 4
+// CHECK-DAG: @_ZN7PR180978constant2y2E ={{.*}} global %"struct.PR18097::constant::Y" zeroinitializer
+// CHECK-DAG: @_ZN7PR180978constant1gE ={{.*}} global %"struct.PR18097::constant::Struct0" zeroinitializer
+// CHECK-DAG: @_ZN7PR180978constantL1xE = internal {{.*}} constant { i16, i8 } { i16 1, i8 6 }
 
 struct A {
   _Atomic(int) i;
   A(int j);
   void v(int j);
 };
 // Storing to atomic values should be atomic
 // CHECK: store atomic i32 {{.*}} seq_cst, align 4
namespace constant {
     _Atomic(X) b(X(2));
     _Atomic(X) c{X(3)};
 
     struct Y {
       _Atomic(X) a;
       _Atomic(int) b;
     };
     Y y = { X(4), 5 };
+
+    // CHECK-LABEL: define {{.*}} @__cxx_global_var_init
+    // CHECK: tail call void @llvm.memcpy.p0.p0.i32(ptr{{.*}} @_ZN7PR180978constant2y2E, ptr{{.*}} @_ZN7PR180978constantL1xE, i32 3, i1 false)
+    // CHECK: %0 = load i32, ptr @_ZN7PR180978constant1zE
+    // CHECK: store i32 %0, ptr getelementptr inbounds (%"struct.PR18097::constant::Y", ptr @_ZN7PR180978constant2y2E, i32 0, i32 1)
+    int z;
+    constexpr X x{1};
+    Y y2 = { x, z };
+
+    typedef union {
+      unsigned int f0;
+    } Union0;
+
+    typedef struct {
+      _Atomic(Union0) f1;
+    } Struct0;
+
+    Struct0 g = {};
   }
 }