[compiler-rt][xray] Fix alignment of XRayFileHeader

[luporl]

Summary

XRayFileHeader storage was obtained from std::aligned_storage
using its default alignment and not the struct's alignment
requirement. This was causing a bus error on AArch32, on armv8
machines, where vld1.64/vst1.64 instructions with 128-bit
alignment requirement were being used to copy XRayFileHeader.

There is still another issue with fdr-single-thread.cpp test on
armv7. Now it runs until completion and produces a valid log file,
but for some reason the function name appears as _end in it,
instead of the expected mangled fn name.

[MaskRay]

Thank you for the patch!

If it's not too much work, consider migrating away from C++23 deprecated std::aligned_storage while you are modifying these lines:
https://stackoverflow.com/questions/71828288/why-is-stdaligned-storage-to-be-deprecated-in-c23-and-what-to-use-instead

[luporl]

Migrate away from C++23 deprecated std::aligned_storage

[fmayer]

compiler-rt/lib/xray/xray_fdr_logging.cpp

18–19

Random driveby: why do we mix <cfoo> and <foo.h>?

[luporl]

compiler-rt/lib/xray/xray_fdr_logging.cpp

18–19

I don't know why, but to my knowledge it's better to use <cfoo> in C++, when possible, to avoid polluting the global namespace.

[MaskRay]

compiler-rt/lib/xray/xray_fdr_logging.cpp

18–19

Yes, but in practice <cfoo> and <foo.h> can be mixed: https://maskray.me/blog/2022-05-15-c-standard-library-headers-in-c++

compiler-rt/lib/xray/xray_fdr_logging.cpp

 //
 // Here we implement the Flight Data Recorder mode for XRay, where we use
 // compact structures to store records in memory as well as when writing out the
 // data to files.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_fdr_logging.h"
 #include <cassert>
+#include <cstddef>
 #include <errno.h>
 #include <limits>
 #include <memory>
 #include <pthread.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "sanitizer_common/sanitizer_allocator_internal.h"
if (pthread_getspecific(Key) == NULL) {
     new (reinterpret_cast<ThreadLocalData *>(&TLDStorage)) ThreadLocalData{};
     pthread_setspecific(Key, &TLDStorage);
   }
 
   return *reinterpret_cast<ThreadLocalData *>(&TLDStorage);
 }
 
 static XRayFileHeader &fdrCommonHeaderInfo() {
-  static std::aligned_storage<sizeof(XRayFileHeader)>::type HStorage;
+  alignas(XRayFileHeader) static std::byte HStorage[sizeof(XRayFileHeader)];
   static pthread_once_t OnceInit = PTHREAD_ONCE_INIT;
   static bool TSCSupported = true;
   static uint64_t CycleFrequency = NanosecondsPerSecond;
   pthread_once(
       &OnceInit, +[] {
         XRayFileHeader &H = reinterpret_cast<XRayFileHeader &>(HStorage);
         // Version 2 of the log writes the extents of the buffer, instead of
         // relying on an end-of-buffer record.
if (Verbosity())
           "XRay FDR: Failed global buffer queue is null or not finalizing!\n");
     return {nullptr, 0};
   }
 
   // We use a global scratch-pad for the header information, which only gets
   // initialized the first time this function is called. We'll update one part
   // of this information with some relevant data (in particular the number of
   // buffers to expect).
-  static std::aligned_storage<sizeof(XRayFileHeader)>::type HeaderStorage;
+  alignas(
+      XRayFileHeader) static std::byte HeaderStorage[sizeof(XRayFileHeader)];
   static pthread_once_t HeaderOnce = PTHREAD_ONCE_INIT;
   pthread_once(
       &HeaderOnce, +[] {
         reinterpret_cast<XRayFileHeader &>(HeaderStorage) =
             fdrCommonHeaderInfo();
       });
 
   // We use a convenience alias for code referring to Header from here on out.