Replace SLANG_ALIGN_OF with C++11 alignof (#7523)

* Replace SLANG_ALIGN_OF with C++11 alignof

* Fix formatting (again)

7 files changed, 31 insertions, 52 deletions

diff --git a/source/core/slang-memory-arena.h b/source/core/slang-memory-arena.h
index 714918b9a..f08541ddb 100644
--- a/source/core/slang-memory-arena.h
+++ b/source/core/slang-memory-arena.h
@@ -382,9 +382,8 @@ inline const char* MemoryArena::allocateString(const char* chars, size_t numChar
 template<typename T>
 SLANG_FORCE_INLINE T* MemoryArena::allocate()
 {
-    void* mem = (SLANG_ALIGN_OF(T) <= kMinAlignment)
-                    ? allocate(sizeof(T))
-                    : allocateAligned(sizeof(T), SLANG_ALIGN_OF(T));
+    void* mem = (alignof(T) <= kMinAlignment) ? allocate(sizeof(T))
+                                              : allocateAligned(sizeof(T), alignof(T));
     return reinterpret_cast<T*>(mem);
 }
 
@@ -392,9 +391,8 @@ SLANG_FORCE_INLINE T* MemoryArena::allocate()
 template<typename T>
 SLANG_FORCE_INLINE T* MemoryArena::allocateArray(size_t numElems)
 {
-    return (numElems > 0)
-               ? reinterpret_cast<T*>(allocateAligned(sizeof(T) * numElems, SLANG_ALIGN_OF(T)))
-               : nullptr;
+    return (numElems > 0) ? reinterpret_cast<T*>(allocateAligned(sizeof(T) * numElems, alignof(T)))
+                          : nullptr;
 }
 
 // --------------------------------------------------------------------------
@@ -405,7 +403,7 @@ SLANG_FORCE_INLINE T* MemoryArena::allocateAndCopyArray(const T* arr, size_t num
     if (numElems > 0)
     {
         const size_t totalSize = sizeof(T) * numElems;
-        void* ptr = allocateAligned(totalSize, SLANG_ALIGN_OF(T));
+        void* ptr = allocateAligned(totalSize, alignof(T));
         ::memcpy(ptr, arr, totalSize);
         return reinterpret_cast<T*>(ptr);
     }
@@ -419,7 +417,7 @@ SLANG_FORCE_INLINE T* MemoryArena::allocateAndZeroArray(size_t numElems)
     if (numElems > 0)
     {
         const size_t totalSize = sizeof(T) * numElems;
-        void* ptr = allocateAligned(totalSize, SLANG_ALIGN_OF(T));
+        void* ptr = allocateAligned(totalSize, alignof(T));
         ::memset(ptr, 0, totalSize);
         return reinterpret_cast<T*>(ptr);
     }
diff --git a/source/core/slang-offset-container.h b/source/core/slang-offset-container.h
index 4e6920bed..7398c3a8d 100644
--- a/source/core/slang-offset-container.h
+++ b/source/core/slang-offset-container.h
@@ -445,7 +445,7 @@ public:
     template<typename T>
     Offset32Ptr<T> newObject()
     {
-        void* data = allocate(sizeof(T), SLANG_ALIGN_OF(T));
+        void* data = allocate(sizeof(T), alignof(T));
         new (data) T();
         return Offset32Ptr<T>(getOffset(data));
     }
@@ -457,7 +457,7 @@ public:
         {
             return Offset32Array<T>();
         }
-        T* data = (T*)allocate(sizeof(T) * size, SLANG_ALIGN_OF(T));
+        T* data = (T*)allocate(sizeof(T) * size, alignof(T));
         for (size_t i = 0; i < size; ++i)
         {
             new (data + i) T();
diff --git a/source/core/slang-rtti-info.cpp b/source/core/slang-rtti-info.cpp
index 070b9c204..b30b5ac75 100644
--- a/source/core/slang-rtti-info.cpp
+++ b/source/core/slang-rtti-info.cpp
@@ -13,11 +13,11 @@ namespace Slang
     {                                 \
         RttiInfo::Kind::Invalid, 0, 0 \
     }
-#define SLANG_RTTI_INFO_BASIC(name, type)                                    \
-    RttiInfo                                                                 \
-    {                                                                        \
-        RttiInfo::Kind::name, RttiInfo::AlignmentType(SLANG_ALIGN_OF(type)), \
-            RttiInfo::SizeType(sizeof(type))                                 \
+#define SLANG_RTTI_INFO_BASIC(name, type)                             \
+    RttiInfo                                                          \
+    {                                                                 \
+        RttiInfo::Kind::name, RttiInfo::AlignmentType(alignof(type)), \
+            RttiInfo::SizeType(sizeof(type))                          \
     }
 
 /* static */ const RttiInfo RttiInfo::g_basicTypes[Index(Kind::CountOf)] = {
diff --git a/source/core/slang-rtti-info.h b/source/core/slang-rtti-info.h
index 58e557dd0..9d4967cfe 100644
--- a/source/core/slang-rtti-info.h
+++ b/source/core/slang-rtti-info.h
@@ -199,7 +199,7 @@ struct RttiInfo
     template<typename T>
     void init(Kind kind)
     {
-        init(kind, SLANG_ALIGN_OF(T), sizeof(T));
+        init(kind, alignof(T), sizeof(T));
     }
 
     /// Allocate memory for RttiInfo types.
@@ -475,7 +475,7 @@ struct GetRttiInfo<T[COUNT]>
     {
         FixedArrayRttiInfo info;
         info.m_kind = RttiInfo::Kind::FixedArray;
-        info.m_alignment = RttiInfo::AlignmentType(SLANG_ALIGN_OF(T));
+        info.m_alignment = RttiInfo::AlignmentType(alignof(T));
         info.m_size = RttiInfo::SizeType(sizeof(T) * COUNT);
         info.m_elementType = GetRttiInfo<T>::get();
         info.m_elementCount = COUNT;
diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 1aecfae95..b257ff49c 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -3066,7 +3066,7 @@ int __alignOf()
     {
     case cuda :
     case cpp :
-        __intrinsic_asm "SLANG_ALIGN_OF($[0])", T;
+        __intrinsic_asm "alignof($[0])", T;
     }
 }
 
@@ -3077,8 +3077,8 @@ int __alignOf(T v)
 {
     __target_switch
     {
-    case cpp: __intrinsic_asm "SLANG_ALIGN_OF($T0)";
-    case cuda: __intrinsic_asm "SLANG_ALIGN_OF($T0)";
+    case cpp: __intrinsic_asm "alignof($T0)";
+    case cuda: __intrinsic_asm "alignof($T0)";
     }
 }
 
diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp
index 61a453f37..3982b579d 100644
--- a/source/slang/slang-type-layout.cpp
+++ b/source/slang/slang-type-layout.cpp
@@ -463,7 +463,7 @@ struct CPULayoutRulesImpl : DefaultLayoutRulesImpl
         // the compilation.
         // If we are emitting C++, then there is no way in general to know how that C++ will be
         // compiled it could be 32 or 64 (or other) sizes. For now we just assume they are the same.
-        return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), SLANG_ALIGN_OF(void*));
+        return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*));
     }
 
     SimpleArrayLayoutInfo GetArrayLayout(SimpleLayoutInfo elementInfo, LayoutSize elementCount)
@@ -476,7 +476,7 @@ struct CPULayoutRulesImpl : DefaultLayoutRulesImpl
 
             // So it is actually a Array<T> on CPU which is a pointer and a size
             info.size = sizeof(void*) * 2;
-            info.alignment = SLANG_ALIGN_OF(void*);
+            info.alignment = alignof(void*);
 
             return info;
         }
@@ -539,7 +539,7 @@ struct CUDALayoutRulesImpl : DefaultLayoutRulesImpl
                 return SimpleLayoutInfo(
                     LayoutResourceKind::Uniform,
                     sizeof(uint8_t),
-                    SLANG_ALIGN_OF(uint8_t));
+                    alignof(uint8_t));
             }
 
         default:
@@ -1195,60 +1195,41 @@ struct CPUObjectLayoutRulesImpl : ObjectLayoutRulesImpl
         case ShaderParameterKind::ConstantBuffer:
         case ShaderParameterKind::ParameterBlock:
             // It's a pointer to the actual uniform data
-            return SimpleLayoutInfo(
-                LayoutResourceKind::Uniform,
-                sizeof(void*),
-                SLANG_ALIGN_OF(void*));
+            return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*));
 
         case ShaderParameterKind::MutableTexture:
         case ShaderParameterKind::TextureUniformBuffer:
         case ShaderParameterKind::Texture:
             // It's a pointer to a texture interface
-            return SimpleLayoutInfo(
-                LayoutResourceKind::Uniform,
-                sizeof(void*),
-                SLANG_ALIGN_OF(void*));
+            return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*));
 
         case ShaderParameterKind::StructuredBuffer:
         case ShaderParameterKind::MutableStructuredBuffer:
         case ShaderParameterKind::AppendConsumeStructuredBuffer:
             // It's a ptr and a size of the amount of elements
-            return SimpleLayoutInfo(
-                LayoutResourceKind::Uniform,
-                sizeof(void*) * 2,
-                SLANG_ALIGN_OF(void*));
+            return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*) * 2, alignof(void*));
 
         case ShaderParameterKind::RawBuffer:
         case ShaderParameterKind::Buffer:
         case ShaderParameterKind::MutableRawBuffer:
         case ShaderParameterKind::MutableBuffer:
             // It's a pointer and a size in bytes
-            return SimpleLayoutInfo(
-                LayoutResourceKind::Uniform,
-                sizeof(void*) * 2,
-                SLANG_ALIGN_OF(void*));
+            return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*) * 2, alignof(void*));
 
         case ShaderParameterKind::ShaderStorageBuffer:
         case ShaderParameterKind::AccelerationStructure:
         case ShaderParameterKind::SamplerState:
             // It's a pointer
-            return SimpleLayoutInfo(
-                LayoutResourceKind::Uniform,
-                sizeof(void*),
-                SLANG_ALIGN_OF(void*));
+            return SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*));
 
         case ShaderParameterKind::TextureSampler:
         case ShaderParameterKind::MutableTextureSampler:
             {
                 ObjectLayoutInfo info;
-                info.layoutInfos.add(SimpleLayoutInfo(
-                    LayoutResourceKind::Uniform,
-                    sizeof(void*),
-                    SLANG_ALIGN_OF(void*)));
-                info.layoutInfos.add(SimpleLayoutInfo(
-                    LayoutResourceKind::Uniform,
-                    sizeof(void*),
-                    SLANG_ALIGN_OF(void*)));
+                info.layoutInfos.add(
+                    SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*)));
+                info.layoutInfos.add(
+                    SimpleLayoutInfo(LayoutResourceKind::Uniform, sizeof(void*), alignof(void*)));
                 return info;
             }
         case ShaderParameterKind::InputRenderTarget:
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index e98187c85..297a3464f 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -835,7 +835,7 @@ static T makeFromSizeVersioned(const uint8_t* src)
     const size_t dstSize = sizeof(T);
 
     // If they are the same size, and appropriate alignment we can just cast and return
-    if (srcSize == dstSize && (size_t(src) & (SLANG_ALIGN_OF(T) - 1)) == 0)
+    if (srcSize == dstSize && (size_t(src) & (alignof(T) - 1)) == 0)
     {
         return *(const T*)src;
     }