koffi 2.5.0-beta.2 → 2.5.1

package/src/core/libcc/libcc.hh

@@ -162,8 +162,6 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
     #else
         #define RG_THREAD_LOCAL __thread
     #endif
-    #define RG_LIKELY(Cond) __builtin_expect(!!(Cond), 1)
-    #define RG_UNLIKELY(Cond) __builtin_expect(!!(Cond), 0)
 
     #ifndef SCNd8
         #define SCNd8 "hhd"
@@ -179,8 +177,6 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
     #define RG_POP_NO_WARNINGS __pragma(warning(pop))
 
     #define RG_THREAD_LOCAL thread_local
-    #define RG_LIKELY(Cond) (Cond)
-    #define RG_UNLIKELY(Cond) (Cond)
 #else
     #error Compiler not supported
 #endif
@@ -217,7 +213,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
 
 #define RG_CRITICAL(Cond, ...) \
     do { \
-        if (RG_UNLIKELY(!(Cond))) { \
+        if (!(Cond)) [[unlikely]] { \
             PrintLn(stderr, __VA_ARGS__); \
             abort(); \
         } \
@@ -225,7 +221,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
 #ifdef RG_DEBUG
     #define RG_ASSERT(Cond) \
         do { \
-            if (RG_UNLIKELY(!(Cond))) { \
+            if (!(Cond)) [[unlikely]] { \
                 RG::AssertMessage(__FILE__, __LINE__, RG_STRINGIFY(Cond)); \
                 RG_DEBUG_BREAK(); \
                 abort(); \
@@ -237,8 +233,6 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
             (void)sizeof(Cond); \
         } while (false)
 #endif
-#define RG_STATIC_ASSERT(Cond) \
-    static_assert((Cond), RG_STRINGIFY(Cond))
 
 #if defined(RG_DEBUG)
     #define RG_UNREACHABLE() \
@@ -2104,7 +2098,7 @@ public:
 
     void RemoveAll()
     {
-        RG_STATIC_ASSERT(!std::is_pointer<ValueType>::value);
+        static_assert(!std::is_pointer<ValueType>::value);
 
         for (Size i = 0; i < capacity; i++) {
             if (!IsEmpty(i)) {
@@ -3436,6 +3430,53 @@ static inline Span<const char> SplitStr(Span<const char> str, char split_char, S
 static inline Span<const char> SplitStr(const char *str, char split_char, const char **out_remainder = nullptr)
     { return SplitStr((char *)str, split_char, (char **)out_remainder); }
 
+static inline Span<char> SplitStr(Span<char> str, const char *split_str, Span<char> *out_remainder = nullptr)
+{
+    RG_ASSERT(split_str[0]);
+
+    Size part_len = 0;
+    while (part_len < str.len) {
+        if (StartsWith(str.Take(part_len, str.len - part_len), split_str)) {
+            if (out_remainder) {
+                Size split_len = strlen(split_str);
+                *out_remainder = str.Take(part_len + split_len, str.len - part_len - split_len);
+            }
+            return str.Take(0, part_len);
+        }
+        part_len++;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str.Take(str.len, 0);
+    }
+    return str;
+}
+static inline Span<char> SplitStr(char *str, const char *split_str, char **out_remainder = nullptr)
+{
+    RG_ASSERT(split_str[0]);
+
+    Size part_len = 0;
+    while (str[part_len]) {
+        if (StartsWith(str + part_len, split_str)) {
+            if (out_remainder) {
+                Size split_len = strlen(split_str);
+                *out_remainder = str + part_len + split_len;
+            }
+            return MakeSpan(str, part_len);
+        }
+        part_len++;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str + part_len;
+    }
+    return MakeSpan(str, part_len);
+}
+static inline Span<const char> SplitStr(Span<const char> str, const char *split_str, Span<const char> *out_remainder = nullptr)
+    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split_str, (Span<char> *)out_remainder); }
+static inline Span<const char> SplitStr(const char *str, const char *split_str, const char **out_remainder = nullptr)
+    { return SplitStr((char *)str, split_str, (char **)out_remainder); }
+
 static inline Span<char> SplitStrLine(Span<char> str, Span<char> *out_remainder = nullptr)
 {
     Span<char> part = SplitStr(str, '\n', out_remainder);
@@ -3603,7 +3644,7 @@ template <typename T>
 bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
               Span<const char> *out_remaining = nullptr)
 {
-    if (RG_UNLIKELY(!str.len)) {
+    if (!str.len) [[unlikely]] {
         if (flags & (int)ParseFlag::Log) {
             LogError("Cannot convert empty string to integer");
         }
@@ -3625,7 +3666,7 @@ bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAUL
 
     for (; pos < str.len; pos++) {
         unsigned int digit = (unsigned int)(str[pos] - '0');
-        if (RG_UNLIKELY(digit > 9)) {
+        if (digit > 9) [[unlikely]] {
             if (!pos || flags & (int)ParseFlag::End) {
                 if (flags & (int)ParseFlag::Log) {
                     LogError("Malformed integer number '%1'", str);
@@ -3637,11 +3678,11 @@ bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAUL
         }
 
         uint64_t new_value = (value * 10) + digit;
-        if (RG_UNLIKELY(new_value < value))
+        if (new_value < value) [[unlikely]]
             goto overflow;
         value = new_value;
     }
-    if (RG_UNLIKELY(value > (uint64_t)std::numeric_limits<T>::max()))
+    if (value > (uint64_t)std::numeric_limits<T>::max()) [[unlikely]]
         goto overflow;
     value = ((value ^ neg) - neg);
 
@@ -3704,18 +3745,18 @@ static inline Size DecodeUtf8(const char *str, int32_t *out_c)
     if (ptr[0] < 0x80) {
         *out_c = ptr[0];
         return 1;
-    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+    } else if (ptr[0] - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
         return 0;
-    } else if (RG_LIKELY(ptr[1])) {
+    } else if (ptr[1]) [[likely]] {
         if (ptr[0] < 0xE0 && (ptr[1] & 0xC0) == 0x80) {
             *out_c = ((ptr[0] & 0x1F) << 6) | (ptr[1] & 0x3F);
             return 2;
-        } else if (RG_LIKELY(ptr[2])) {
+        } else if (ptr[2]) [[likely]] {
             if (ptr[0] < 0xF0 && (ptr[1] & 0xC0) == 0x80 &&
                                  (ptr[2] & 0xC0) == 0x80) {
                 *out_c = ((ptr[0] & 0xF) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
                 return 3;
-            } else if (RG_LIKELY(ptr[3])) {
+            } else if (ptr[3]) [[likely]] {
                 if ((ptr[1] & 0xC0) == 0x80 &&
                         (ptr[2] & 0xC0) == 0x80 &&
                         (ptr[3] & 0xC0) == 0x80) {
@@ -3739,20 +3780,18 @@ static inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
     if (ptr[0] < 0x80) {
         *out_c = ptr[0];
         return 1;
-    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+    } else if (ptr[0] - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
         return 0;
-    } else if (ptr[0] < 0xE0 &&
-               RG_LIKELY(available >= 2 && (ptr[1] & 0xC0) == 0x80)) {
+    } else if (ptr[0] < 0xE0 && available >= 2 && (ptr[1] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0x1F) << 6) | (ptr[1] & 0x3F);
         return 2;
-    } else if (ptr[0] < 0xF0 &&
-               RG_LIKELY(available >= 3 && (ptr[1] & 0xC0) == 0x80 &&
-                                           (ptr[2] & 0xC0) == 0x80)) {
+    } else if (ptr[0] < 0xF0 && available >= 3 && (ptr[1] & 0xC0) == 0x80 &&
+                                                  (ptr[2] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0xF) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
         return 3;
-    } else if (RG_LIKELY(available >= 4 && (ptr[1] & 0xC0) == 0x80 &&
-                                           (ptr[2] & 0xC0) == 0x80 &&
-                                           (ptr[3] & 0xC0) == 0x80)) {
+    } else if (available >= 4 && (ptr[1] & 0xC0) == 0x80 &&
+                                 (ptr[2] & 0xC0) == 0x80 &&
+                                 (ptr[3] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0x7) << 18) | ((ptr[1] & 0x3F) << 12) | ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
         return 4;
     } else {
@@ -4092,8 +4131,8 @@ private:
 
 template <int Min = 0, int Max = INT_MAX>
 class FastRandomInt {
-    RG_STATIC_ASSERT(Min >= 0);
-    RG_STATIC_ASSERT(Max > Min);
+    static_assert(Min >= 0);
+    static_assert(Max > Min);
 
     FastRandom rng;
 

package/src/core/libcc/miniz.cc

@@ -54,7 +54,7 @@ public:
 
 bool MinizDecompressor::Init(CompressionType type)
 {
-    RG_STATIC_ASSERT(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
+    static_assert(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
 
     tinfl_init(&inflator);
     is_gzip = (type == CompressionType::Gzip);
@@ -177,7 +177,7 @@ Size MinizDecompressor::Read(Size max_len, void *user_buf)
                     // Gzip footer (CRC and size check)
                     if (is_gzip) {
                         uint32_t footer[2];
-                        RG_STATIC_ASSERT(RG_SIZE(footer) == 8);
+                        static_assert(RG_SIZE(footer) == 8);
 
                         if (in_len < RG_SIZE(footer)) {
                             memcpy_safe(footer, in_ptr, (size_t)in_len);

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();