koffi 2.5.0 → 2.5.2

package/src/koffi/CMakeLists.txt

@@ -28,11 +28,7 @@ include(CheckCXXCompilerFlag)
 
 find_package(CNoke)
 
-if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.8.0")
-    set(CMAKE_CXX_STANDARD 17)
-else()
-    set(CMAKE_CXX_STANDARD 14)
-endif()
+set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
 

package/src/koffi/src/abi_arm32.cc

@@ -226,11 +226,11 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     // registers just before the stack (so behind the vector ones).
     // In the armv7hf calling convention, some arguments can end up
     // partially in GPR, partially in the stack.
-    if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
+    if (!AllocStack(func->args_size, 16, &args_ptr)) [[unlikely]]
         return false;
-    if (RG_UNLIKELY(!AllocStack(4 * 4, 8, &gpr_ptr)))
+    if (!AllocStack(4 * 4, 8, &gpr_ptr)) [[unlikely]]
         return false;
-    if (RG_UNLIKELY(!AllocStack(8 * 8, 8, &vec_ptr)))
+    if (!AllocStack(8 * 8, 8, &vec_ptr)) [[unlikely]]
         return false;
     if (func->ret.use_memory) {
         return_ptr = AllocHeap(func->ret.type->size, 16);
@@ -239,7 +239,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
 #define PUSH_INTEGER_32(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
@@ -249,7 +249,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
         } while (false)
 #define PUSH_INTEGER_32_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
@@ -259,14 +259,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
         } while (false)
 #define PUSH_INTEGER_64(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
              \
             CType v = GetNumber<CType>(value); \
              \
-            if (RG_LIKELY(param.gpr_count)) { \
+            if (param.gpr_count) [[likely]] { \
                 gpr_ptr = AlignUp(gpr_ptr, 8); \
                 *(uint64_t *)gpr_ptr = (uint64_t)v; \
                 gpr_ptr += param.gpr_count; \
@@ -278,14 +278,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
         } while (false)
 #define PUSH_INTEGER_64_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
              \
             CType v = GetNumber<CType>(value); \
              \
-            if (RG_LIKELY(param.gpr_count)) { \
+            if (param.gpr_count) [[likely]] { \
                 gpr_ptr = AlignUp(gpr_ptr, 8); \
                 *(uint64_t *)gpr_ptr = (uint64_t)ReverseBytes(v); \
                 gpr_ptr += param.gpr_count; \
@@ -307,7 +307,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                if (RG_UNLIKELY(!value.IsBoolean())) {
+                if (!value.IsBoolean()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                     return false;
                 }
@@ -331,28 +331,28 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S: { PUSH_INTEGER_64_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, param.directions, &str)))
+                if (!PushString(value, param.directions, &str)) [[unlikely]]
                     return false;
 
                 *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, param.directions, &str16)))
+                if (!PushString16(value, param.directions, &str16)) [[unlikely]]
                     return false;
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
-                if (RG_UNLIKELY(!PushPointer(value, param.type, param.directions, &ptr)))
+                if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
                     return false;
 
                 *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                if (RG_UNLIKELY(!IsObject(value))) {
+                if (!IsObject(value)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
                 }
@@ -385,14 +385,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
                 float f = GetNumber<float>(value);
 
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     *(float *)(vec_ptr++) = f;
                 } else if (param.gpr_count) {
                     *(float *)(gpr_ptr++) = f;
@@ -401,14 +401,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
                 double d = GetNumber<double>(value);
 
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     *(double *)vec_ptr = d;
                     vec_ptr += 2;
                 } else if (param.gpr_count) {
@@ -428,7 +428,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                     Napi::Function func = value.As<Napi::Function>();
 
                     ptr = ReserveTrampoline(param.type->ref.proto, func);
-                    if (RG_UNLIKELY(!ptr))
+                    if (!ptr) [[unlikely]]
                         return false;
                 } else if (CheckValueTag(instance, value, param.type->ref.marker)) {
                     ptr = value.As<Napi::External<void>>().Data();
@@ -566,7 +566,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
 
 void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
-    if (RG_UNLIKELY(env.IsExceptionPending()))
+    if (env.IsExceptionPending()) [[unlikely]]
         return;
 
     const TrampolineInfo &trampoline = shared.trampolines[idx];
@@ -583,7 +583,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     RG_DEFER_N(err_guard) { memset(out_reg, 0, RG_SIZE(*out_reg)); };
 
-    if (RG_UNLIKELY(trampoline.generation >= 0 && trampoline.generation != (int32_t)mem->generation)) {
+    if (trampoline.generation >= 0 && trampoline.generation != (int32_t)mem->generation) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Cannot use non-registered callback beyond FFI call");
         return;
     }
@@ -789,7 +789,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 float f;
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     f = *(float *)(vec_ptr++);
                 } else if (param.gpr_count) {
                     f = *(float *)(gpr_ptr++);
@@ -802,7 +802,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
             } break;
             case PrimitiveKind::Float64: {
                 double d;
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     d = *(double *)vec_ptr;
                     vec_ptr += 2;
                 } else if (param.gpr_count) {
@@ -835,12 +835,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     }
     Napi::Value value(env, ret);
 
-    if (RG_UNLIKELY(env.IsExceptionPending()))
+    if (env.IsExceptionPending()) [[unlikely]]
         return;
 
 #define RETURN_INTEGER_32(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value for return value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -850,7 +850,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } while (false)
 #define RETURN_INTEGER_32_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -860,7 +860,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } while (false)
 #define RETURN_INTEGER_64(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -872,7 +872,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } while (false)
 #define RETURN_INTEGER_64_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -887,7 +887,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     switch (type->primitive) {
         case PrimitiveKind::Void: {} break;
         case PrimitiveKind::Bool: {
-            if (RG_UNLIKELY(!value.IsBoolean())) {
+            if (!value.IsBoolean()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                 return;
             }
@@ -911,14 +911,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         case PrimitiveKind::UInt64S: { RETURN_INTEGER_64_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (RG_UNLIKELY(!PushString(value, 1, &str)))
+            if (!PushString(value, 1, &str)) [[unlikely]]
                 return;
 
             out_reg->r0 = (uint32_t)str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
+            if (!PushString16(value, 1, &str16)) [[unlikely]]
                 return;
 
             out_reg->r0 = (uint32_t)str16;
@@ -947,7 +947,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (RG_UNLIKELY(!IsObject(value))) {
+            if (!IsObject(value)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;
             }
@@ -966,7 +966,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: {
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return;
             }
@@ -979,7 +979,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 #endif
         } break;
         case PrimitiveKind::Float64: {
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return;
             }
@@ -998,7 +998,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                 Napi::Function func2 = value.As<Napi::Function>();
 
                 ptr = ReserveTrampoline(type->ref.proto, func2);
-                if (RG_UNLIKELY(!ptr))
+                if (!ptr) [[unlikely]]
                     return;
             } else if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<void>>().Data();

package/src/koffi/src/abi_arm64.cc

@@ -271,11 +271,11 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     uint64_t *vec_ptr = nullptr;
 
     // Return through registers unless it's too big
-    if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
+    if (!AllocStack(func->args_size, 16, &args_ptr)) [[unlikely]]
         return false;
-    if (RG_UNLIKELY(!AllocStack(8 * 8, 8, &vec_ptr)))
+    if (!AllocStack(8 * 8, 8, &vec_ptr)) [[unlikely]]
         return false;
-    if (RG_UNLIKELY(!AllocStack(9 * 8, 8, &gpr_ptr)))
+    if (!AllocStack(9 * 8, 8, &gpr_ptr)) [[unlikely]]
         return false;
     if (func->ret.use_memory) {
         return_ptr = AllocHeap(func->ret.type->size, 16);
@@ -297,14 +297,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 #ifdef __APPLE__
     #define PUSH_INTEGER(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
              \
             CType v = GetNumber<CType>(value); \
              \
-            if (RG_LIKELY(param.gpr_count)) { \
+            if (param.gpr_count) [[likely]] { \
                 *(gpr_ptr++) = (uint64_t)v; \
             } else { \
                 args_ptr = AlignUp(args_ptr, param.type->align); \
@@ -314,14 +314,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
         } while (false)
     #define PUSH_INTEGER_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
              \
             CType v = GetNumber<CType>(value); \
              \
-            if (RG_LIKELY(param.gpr_count)) { \
+            if (param.gpr_count) [[likely]] { \
                 *(gpr_ptr++) = (uint64_t)ReverseBytes(v); \
             } else { \
                 args_ptr = AlignUp(args_ptr, param.type->align); \
@@ -332,7 +332,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 #else
     #define PUSH_INTEGER(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
@@ -342,7 +342,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
         } while (false)
     #define PUSH_INTEGER_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return false; \
             } \
@@ -363,7 +363,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                if (RG_UNLIKELY(!value.IsBoolean())) {
+                if (!value.IsBoolean()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                     return false;
                 }
@@ -371,7 +371,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 bool b = value.As<Napi::Boolean>();
 
 #ifdef __APPLE__
-                if (RG_LIKELY(param.gpr_count)) {
+                if (param.gpr_count) [[likely]] {
                     *(gpr_ptr++) = (uint64_t)b;
                 } else {
                     *(uint8_t *)args_ptr = b;
@@ -397,7 +397,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, param.directions, &str)))
+                if (!PushString(value, param.directions, &str)) [[unlikely]]
                     return false;
 
 #ifdef __APPLE__
@@ -407,7 +407,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, param.directions, &str16)))
+                if (!PushString16(value, param.directions, &str16)) [[unlikely]]
                     return false;
 
 #ifdef __APPLE__
@@ -417,7 +417,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
-                if (RG_UNLIKELY(!PushPointer(value, param.type, param.directions, &ptr)))
+                if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
                     return false;
 
 #ifdef __APPLE__
@@ -427,7 +427,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                if (RG_UNLIKELY(!IsObject(value))) {
+                if (!IsObject(value)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
                 }
@@ -478,14 +478,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
                 float f = GetNumber<float>(value);
 
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     memset((uint8_t *)vec_ptr + 4, 0, 4);
                     *(float *)(vec_ptr++) = f;
 #ifdef _WIN32
@@ -505,14 +505,14 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                 }
             } break;
             case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
                 double d = GetNumber<double>(value);
 
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     *(double *)(vec_ptr++) = d;
 #ifdef _WIN32
                 } else if (param.gpr_count) {
@@ -532,7 +532,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
                     Napi::Function func = value.As<Napi::Function>();
 
                     ptr = ReserveTrampoline(param.type->ref.proto, func);
-                    if (RG_UNLIKELY(!ptr))
+                    if (!ptr) [[unlikely]]
                         return false;
                 } else if (CheckValueTag(instance, value, param.type->ref.marker)) {
                     ptr = value.As<Napi::External<void>>().Data();
@@ -707,7 +707,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
 
 void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
-    if (RG_UNLIKELY(env.IsExceptionPending()))
+    if (env.IsExceptionPending()) [[unlikely]]
         return;
 
 #ifdef _WIN32
@@ -741,7 +741,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     RG_DEFER_N(err_guard) { memset(out_reg, 0, RG_SIZE(*out_reg)); };
 
-    if (RG_UNLIKELY(trampoline.generation >= 0 && trampoline.generation != (int32_t)mem->generation)) {
+    if (trampoline.generation >= 0 && trampoline.generation != (int32_t)mem->generation) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Cannot use non-registered callback beyond FFI call");
         return;
     }
@@ -1092,7 +1092,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 float f;
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     f = *(float *)(vec_ptr++);
 #ifdef _WIN32
                 } else if (param.gpr_count) {
@@ -1113,7 +1113,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
             } break;
             case PrimitiveKind::Float64: {
                 double d;
-                if (RG_LIKELY(param.vec_count)) {
+                if (param.vec_count) [[likely]] {
                     d = *(double *)(vec_ptr++);
 #ifdef _WIN32
                 } else if (param.gpr_count) {
@@ -1147,12 +1147,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     }
     Napi::Value value(env, ret);
 
-    if (RG_UNLIKELY(env.IsExceptionPending()))
+    if (env.IsExceptionPending()) [[unlikely]]
         return;
 
 #define RETURN_INTEGER(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -1162,7 +1162,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } while (false)
 #define RETURN_INTEGER_SWAP(CType) \
         do { \
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
                 return; \
             } \
@@ -1175,7 +1175,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     switch (type->primitive) {
         case PrimitiveKind::Void: {} break;
         case PrimitiveKind::Bool: {
-            if (RG_UNLIKELY(!value.IsBoolean())) {
+            if (!value.IsBoolean()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                 return;
             }
@@ -1199,14 +1199,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         case PrimitiveKind::UInt64S: { RETURN_INTEGER_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             const char *str;
-            if (RG_UNLIKELY(!PushString(value, 1, &str)))
+            if (!PushString(value, 1, &str)) [[unlikely]]
                 return;
 
             out_reg->x0 = (uint64_t)str;
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16;
-            if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
+            if (!PushString16(value, 1, &str16)) [[unlikely]]
                 return;
 
             out_reg->x0 = (uint64_t)str16;
@@ -1235,7 +1235,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (RG_UNLIKELY(!IsObject(value))) {
+            if (!IsObject(value)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return;
             }
@@ -1257,7 +1257,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
         } break;
         case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: {
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return;
             }
@@ -1268,7 +1268,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
             memcpy(&out_reg->d0, &f, 4);
         } break;
         case PrimitiveKind::Float64: {
-            if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return;
             }
@@ -1283,7 +1283,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                 Napi::Function func2 = value.As<Napi::Function>();
 
                 ptr = ReserveTrampoline(type->ref.proto, func2);
-                if (RG_UNLIKELY(!ptr))
+                if (!ptr) [[unlikely]]
                     return;
             } else if (CheckValueTag(instance, value, type->ref.marker)) {
                 ptr = value.As<Napi::External<void>>().Data();