scudo: Replace ALIGNED macro with standard alignas specifier.

[pcc]

Summary

alignas was introduced in C++11 and is already being used throughout LLVM.

[cryptoad]

Did you verify this works on Fuchsia by chance?

[pcc]

In D77823#1972883, @cryptoad wrote:

Did you verify this works on Fuchsia by chance?

No, and I deleted my Fuchsia checkout so I can't verify it easily. If the command line for compiling scudo (ninja -t commands | grep wrappers_c) contains -std={c,gnu}++11 or later it should work.

[cryptoad]

In D77823#1972938, @pcc wrote:

No, and I deleted my Fuchsia checkout so I can't verify it easily. If the command line for compiling scudo (ninja -t commands | grep wrappers_c) contains -std={c,gnu}++11 or later it should work.

No worries, I'll check it out shortly, shouldn't be a problem.

compiler-rt/lib/scudo/standalone/atomic_helpers.h

 struct atomic_u32 {
   typedef u32 Type;
   volatile Type ValDoNotUse;
 };
 
 struct atomic_u64 {
   typedef u64 Type;
   // On 32-bit platforms u64 is not necessarily aligned on 8 bytes.
-  ALIGNED(8) volatile Type ValDoNotUse;
+  alignas(8) volatile Type ValDoNotUse;
 };
 
 struct atomic_uptr {
   typedef uptr Type;
   volatile Type ValDoNotUse;
 };
 
 template <typename T>

compiler-rt/lib/scudo/standalone/internal_defs.h

 
 // Attributes & builtins related macros.
 
 #define INTERFACE __attribute__((visibility("default")))
 #define HIDDEN __attribute__((visibility("hidden")))
 #define WEAK __attribute__((weak))
 #define ALWAYS_INLINE inline __attribute__((always_inline))
 #define ALIAS(X) __attribute__((alias(X)))
-// Please only use the ALIGNED macro before the type. Using ALIGNED after the
-// variable declaration is not portable.
-#define ALIGNED(X) __attribute__((aligned(X)))
 #define FORMAT(F, A) __attribute__((format(printf, F, A)))
 #define NOINLINE __attribute__((noinline))
 #define NORETURN __attribute__((noreturn))
 #define THREADLOCAL __thread
 #define LIKELY(X) __builtin_expect(!!(X), 1)
 #define UNLIKELY(X) __builtin_expect(!!(X), 0)
 #if defined(__i386__) || defined(__x86_64__)
 // __builtin_prefetch(X) generates prefetchnt0 on x86

compiler-rt/lib/scudo/standalone/primary32.h

private:
 
   struct ReleaseToOsInfo {
     uptr PushedBlocksAtLastRelease;
     uptr RangesReleased;
     uptr LastReleasedBytes;
     u64 LastReleaseAtNs;
   };
 
-  struct ALIGNED(SCUDO_CACHE_LINE_SIZE) SizeClassInfo {
+  struct alignas(SCUDO_CACHE_LINE_SIZE) SizeClassInfo {
     HybridMutex Mutex;
     SinglyLinkedList<TransferBatch> FreeList;
     uptr CurrentRegion;
     uptr CurrentRegionAllocated;
     SizeClassStats Stats;
     bool CanRelease;
     u32 RandState;
     uptr AllocatedUser;

compiler-rt/lib/scudo/standalone/primary64.h

private:
 
   struct ReleaseToOsInfo {
     uptr PushedBlocksAtLastRelease;
     uptr RangesReleased;
     uptr LastReleasedBytes;
     u64 LastReleaseAtNs;
   };
 
-  struct ALIGNED(SCUDO_CACHE_LINE_SIZE) RegionInfo {
+  struct alignas(SCUDO_CACHE_LINE_SIZE) RegionInfo {
     HybridMutex Mutex;
     SinglyLinkedList<TransferBatch> FreeList;
     RegionStats Stats;
     bool CanRelease;
     bool Exhausted;
     u32 RandState;
     uptr RegionBeg;
     uptr MappedUser;    // Bytes mapped for user memory.

compiler-rt/lib/scudo/standalone/tests/mutex_test.cpp

for (scudo::u32 I = 0; I < Size; I++) {
       EXPECT_EQ(LocalData[I], 1U);
     }
   }
 
 private:
   static const scudo::u32 Size = 64U;
   typedef scudo::u64 T;
   scudo::HybridMutex &Mutex;
-  ALIGNED(SCUDO_CACHE_LINE_SIZE) T Data[Size];
+  alignas(SCUDO_CACHE_LINE_SIZE) T Data[Size];
 };
 
 const scudo::u32 NumberOfThreads = 8;
 #if SCUDO_DEBUG
 const scudo::u32 NumberOfIterations = 4 * 1024;
 #else
 const scudo::u32 NumberOfIterations = 16 * 1024;
 #endif

compiler-rt/lib/scudo/standalone/tsd.h

 
 // With some build setups, this might still not be defined.
 #ifndef PTHREAD_DESTRUCTOR_ITERATIONS
 #define PTHREAD_DESTRUCTOR_ITERATIONS 4
 #endif
 
 namespace scudo {
 
-template <class Allocator> struct ALIGNED(SCUDO_CACHE_LINE_SIZE) TSD {
+template <class Allocator> struct alignas(SCUDO_CACHE_LINE_SIZE) TSD {
   typename Allocator::CacheT Cache;
   typename Allocator::QuarantineCacheT QuarantineCache;
   u8 DestructorIterations;
 
   void initLinkerInitialized(Allocator *Instance) {
     Instance->initCache(&Cache);
     DestructorIterations = PTHREAD_DESTRUCTOR_ITERATIONS;
   }