Look through calls to std::addressof to compute pointer alignment.

[efriedma]

Summary

This is sort of a followup to D37310; that basically fixed the same issue, but then the libstdc++ implementation of <atomic> changed. Re-fix the the issue in essentially the same way: look through the addressof operation to find the alignment of the underlying object.

Fixes https://github.com/llvm/llvm-project/issues/54963 . Alternative to D123642.

[rjmccall]

LGTM

clang/lib/CodeGen/CGExpr.cpp

if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
     if (UO->getOpcode() == UO_AddrOf) {
       LValue LV = EmitLValue(UO->getSubExpr());
       if (BaseInfo) *BaseInfo = LV.getBaseInfo();
       if (TBAAInfo) *TBAAInfo = LV.getTBAAInfo();
       return LV.getAddress(*this);
     }
   }
 
+  // std::addressof and variants.
+  if (auto *Call = dyn_cast<CallExpr>(E)) {
+    switch (Call->getBuiltinCallee()) {
+    default:
+      break;
+    case Builtin::BIaddressof:
+    case Builtin::BI__addressof:
+    case Builtin::BI__builtin_addressof: {
+      LValue LV = EmitLValue(Call->getArg(0));
+      if (BaseInfo) *BaseInfo = LV.getBaseInfo();
+      if (TBAAInfo) *TBAAInfo = LV.getTBAAInfo();
+      return LV.getAddress(*this);
+    }
+    }
+  }
+
   // TODO: conditional operators, comma.
 
   // Otherwise, use the alignment of the type.
   CharUnits Align =
       CGM.getNaturalPointeeTypeAlignment(E->getType(), BaseInfo, TBAAInfo);
   llvm::Type *ElemTy = ConvertTypeForMem(E->getType()->getPointeeType());
   return Address(EmitScalarExpr(E), ElemTy, Align);
 }

clang/test/CodeGenCXX/atomic-align.cpp

-// RUN: %clang_cc1 %s -std=c++11 -emit-llvm -o - -triple=x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 %s -std=c++14 -emit-llvm -o - -triple=x86_64-linux-gnu | FileCheck %s
 
 struct AM {
   int f1, f2;
 };
 alignas(8) AM m;
 AM load1() {
   AM am;
   // m is declared to align to 8bytes, so generate load atomic instead
AM load2() {
   AM am;
   // BM::f2 is declared to align to 8bytes, so generate load atomic instead
   // of libcall.
   // CHECK-LABEL: @_Z5load2v
   // CHECK: load atomic {{.*}} monotonic, align 8
   __atomic_load(&bm.f2, &am, 0);
   return am;
 }
+
+namespace std {
+  template <class _Tp>
+  inline constexpr
+  __attribute__ ((__visibility__("hidden"), __internal_linkage__))
+  _Tp* __addressof(_Tp& __x) noexcept
+  {
+      return __builtin_addressof(__x);
+  }
+}
+
+AM load3() {
+  AM am;
+  // m is declared to align to 8bytes, so generate load atomic instead
+  // of libcall.
+  // CHECK-LABEL: @_Z5load3v
+  // CHECK: load atomic {{.*}} monotonic, align 8
+  __atomic_load(std::__addressof(m), &am, 0);
+  return am;
+}