koffi 2.5.0 → 2.5.2

package/src/koffi/src/ffi.cc

@@ -1186,7 +1186,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 
     bool temporary = (instance->memories.len > instance->config.resident_async_pools);
 
-    if (RG_UNLIKELY(temporary && instance->temporaries >= instance->config.max_temporaries))
+    if (temporary && instance->temporaries >= instance->config.max_temporaries) [[unlikely]]
         return nullptr;
 
     InstanceMemory *mem = new InstanceMemory();
@@ -1243,7 +1243,7 @@ static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (RG_UNLIKELY(info.Length() < (uint32_t)func->required_parameters)) {
+    if (info.Length() < (uint32_t)func->required_parameters) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
         return env.Null();
     }
@@ -1251,7 +1251,7 @@ static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem);
 
-    if (!RG_UNLIKELY(call.Prepare(func, info)))
+    if (!call.Prepare(func, info)) [[unlikely]]
         return env.Null();
 
     if (instance->debug) {
@@ -1291,11 +1291,11 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
         copy.parameters.Leak();
     };
 
-    if (RG_UNLIKELY(info.Length() < (uint32_t)copy.required_parameters)) {
+    if (info.Length() < (uint32_t)copy.required_parameters) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", copy.parameters.len, info.Length());
         return env.Null();
     }
-    if (RG_UNLIKELY((info.Length() - copy.required_parameters) % 2)) {
+    if ((info.Length() - copy.required_parameters) % 2) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
     }
@@ -1305,17 +1305,17 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
 
         param.type = ResolveType(info[(uint32_t)i], &param.directions);
 
-        if (RG_UNLIKELY(!param.type))
+        if (!param.type) [[unlikely]]
             return env.Null();
-        if (RG_UNLIKELY(!CanPassType(param.type, param.directions))) {
+        if (!CanPassType(param.type, param.directions)) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return env.Null();
         }
-        if (RG_UNLIKELY(copy.parameters.len >= MaxParameters)) {
+        if (copy.parameters.len >= MaxParameters) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if (RG_UNLIKELY((param.directions & 2) && ++copy.out_parameters >= MaxOutParameters)) {
+        if ((param.directions & 2) && ++copy.out_parameters >= MaxOutParameters) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
             return env.Null();
         }
@@ -1326,13 +1326,13 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
         copy.parameters.Append(param);
     }
 
-    if (RG_UNLIKELY(!AnalyseFunction(env, instance, &copy)))
+    if (!AnalyseFunction(env, instance, &copy)) [[unlikely]]
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem);
 
-    if (!RG_UNLIKELY(call.Prepare(&copy, info)))
+    if (!call.Prepare(&copy, info)) [[unlikely]]
         return env.Null();
 
     if (instance->debug) {
@@ -1434,7 +1434,7 @@ static Napi::Value TranslateAsyncCall(const FunctionInfo *func, void *native,
     }
 
     InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
-    if (RG_UNLIKELY(!mem)) {
+    if (!mem) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
         return env.Null();
     }
@@ -1456,7 +1456,7 @@ Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
 
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
-    if (RG_LIKELY(exec_call)) {
+    if (exec_call) [[likely]] {
         exec_call->RelaySafe(idx, own_sp, caller_sp, false, out_reg);
     } else {
         // This happens if the callback pointer is called from a different thread
@@ -1468,7 +1468,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
         InstanceData *instance = env.GetInstanceData<InstanceData>();
 
         InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
-        if (RG_UNLIKELY(!mem)) {
+        if (!mem) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
             return;
         }
@@ -1680,7 +1680,7 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
     {
         std::lock_guard<std::mutex> lock(shared.mutex);
 
-        if (RG_UNLIKELY(!shared.available.len)) {
+        if (!shared.available.len) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
             return env.Null();
         }
@@ -1732,7 +1732,7 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
     {
         int16_t *it = instance->trampolines_map.Find(ptr);
 
-        if (RG_UNLIKELY(!it)) {
+        if (!it) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Could not find matching registered callback");
             return env.Null();
         }
@@ -1762,7 +1762,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (RG_UNLIKELY(info.Length() < 2)) {
+    if (info.Length() < 2) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
         return env.Null();
     }
@@ -1770,7 +1770,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     Napi::Value value = info[0];
 
     const TypeInfo *type = ResolveType(info[1]);
-    if (RG_UNLIKELY(!type))
+    if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Pointer &&
             type->primitive != PrimitiveKind::String &&
@@ -1797,13 +1797,13 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
     bool has_len = (info.Length() >= 3u + has_offset && info[2u + has_offset].IsNumber());
 
-    if (RG_UNLIKELY(info.Length() < 2u + has_offset)) {
+    if (info.Length() < 2u + has_offset) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 to 4 arguments, got %2", 2 + has_offset, info.Length());
         return env.Null();
     }
 
     const TypeInfo *type = ResolveType(info[1u + has_offset]);
-    if (RG_UNLIKELY(!type))
+    if (!type) [[unlikely]]
         return env.Null();
 
     Napi::Value value = info[0];
@@ -1844,19 +1844,19 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (RG_UNLIKELY(info.Length() < 2)) {
+    if (info.Length() < 2) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 2 or more arguments, got %1", info.Length());
         return env.Null();
     }
 
     void *ptr = nullptr;
-    if (RG_UNLIKELY(!GetExternalPointer(env, info[0], &ptr)))
+    if (!GetExternalPointer(env, info[0], &ptr)) [[unlikely]]
         return env.Null();
 
     const TypeInfo *type = ResolveType(info[1]);
-    if (RG_UNLIKELY(!type))
+    if (!type) [[unlikely]]
         return env.Null();
-    if (RG_UNLIKELY(type->primitive != PrimitiveKind::Prototype)) {
+    if (type->primitive != PrimitiveKind::Prototype) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for type, expected function type", GetValueType(instance, info[1]));
         return env.Null();
     }

package/src/koffi/src/ffi.hh

@@ -305,9 +305,9 @@ struct InstanceData {
         int64_t disposed = 0;
     } stats;
 };
-RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(InstanceData::memories.data) - 1);
-RG_STATIC_ASSERT(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
-RG_STATIC_ASSERT(MaxAsyncCalls >= DefaultMaxAsyncCalls);
+static_assert(DefaultResidentAsyncPools <= RG_LEN(InstanceData::memories.data) - 1);
+static_assert(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
+static_assert(MaxAsyncCalls >= DefaultMaxAsyncCalls);
 
 struct TrampolineInfo {
     InstanceData *instance;
@@ -334,7 +334,7 @@ struct SharedData {
         }
     }
 };
-RG_STATIC_ASSERT(MaxTrampolines <= INT16_MAX);
+static_assert(MaxTrampolines <= INT16_MAX);
 
 extern SharedData shared;
 

package/src/koffi/src/parser.cc

@@ -172,7 +172,7 @@ const TypeInfo *PrototypeParser::ParseType()
             offset++;
             return type;
         }
-        if (RG_UNLIKELY(env.IsExceptionPending()))
+        if (env.IsExceptionPending()) [[unlikely]]
             return instance->void_type;
 
         offset--;

package/src/koffi/src/trampolines/prototypes.inc

@@ -16406,4 +16406,4 @@ static void *const Trampolines[][2] = {
     { &Trampoline8190, &TrampolineX8190 },
     { &Trampoline8191, &TrampolineX8191 }
 };
-RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines);
+static_assert(RG_LEN(Trampolines) == MaxTrampolines);

package/src/koffi/src/util.cc

@@ -85,7 +85,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
     } else {
         Napi::Env env = info.Env();
 
-        if (RG_UNLIKELY(!raw.len)) {
+        if (!raw.len) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Cannont convert %1 union value", active_idx < 0 ? "empty" : "assigned");
             return env.Null();
         }
@@ -190,7 +190,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
             remain = remain.Take(1, remain.len - 1);
             indirect++;
 
-            if (RG_UNLIKELY(indirect) >= RG_SIZE(disposables) * 8) {
+            if (indirect >= RG_SIZE(disposables) * 8) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Too many pointer indirections");
                 return nullptr;
             }
@@ -233,9 +233,9 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
 
     for (int i = 0;; i++) {
         if (disposables & (1u << i)) {
-            if (RG_UNLIKELY(type->primitive != PrimitiveKind::Pointer &&
-                            type->primitive != PrimitiveKind::String &&
-                            type->primitive != PrimitiveKind::String16)) {
+            if (type->primitive != PrimitiveKind::Pointer &&
+                    type->primitive != PrimitiveKind::String &&
+                    type->primitive != PrimitiveKind::String16) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Cannot create disposable type for non-pointer");
                 return nullptr;
             }
@@ -1035,7 +1035,7 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
     } else if (IsRawBuffer(value)) {
         Span<uint8_t> buffer = GetRawBuffer(value);
 
-        if (RG_UNLIKELY(buffer.len - offset < type->size)) {
+        if (buffer.len - offset < type->size) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
             return env.Null();
@@ -1065,7 +1065,7 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
         if (*len >= 0) {
             type = MakeArrayType(instance, type, *len);
         } else {
-            if (RG_UNLIKELY(!(type->flags & (int)TypeFlag::IsCharLike))) {
+            if (!(type->flags & (int)TypeFlag::IsCharLike)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Only char-like types can find their length automatically", type->name);
                 return env.Null();
             }

package/src/koffi/src/util.hh

@@ -147,7 +147,7 @@ T GetNumber(Napi::Value value)
 {
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
-    if (RG_LIKELY(value.IsNumber())) {
+    if (value.IsNumber()) [[likely]] {
         return (T)value.As<Napi::Number>().DoubleValue();
     } else if (value.IsBigInt()) {
         Napi::BigInt bigint = value.As<Napi::BigInt>();

package/src/koffi/src/win32.hh

@@ -38,8 +38,8 @@ struct TEB {
     char _pad2[712];
     uint32_t GuaranteedStackBytes;
 };
-RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0x1478);
-RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, GuaranteedStackBytes) == 0x1748);
+static_assert(RG_OFFSET_OF(TEB, DeallocationStack) == 0x1478);
+static_assert(RG_OFFSET_OF(TEB, GuaranteedStackBytes) == 0x1748);
 
 #else
 
@@ -52,8 +52,8 @@ struct TEB {
     char _pad2[360];
     uint32_t GuaranteedStackBytes;
 };
-RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, DeallocationStack) == 0xE0C);
-RG_STATIC_ASSERT(RG_OFFSET_OF(TEB, GuaranteedStackBytes) == 0x0F78);
+static_assert(RG_OFFSET_OF(TEB, DeallocationStack) == 0xE0C);
+static_assert(RG_OFFSET_OF(TEB, GuaranteedStackBytes) == 0x0F78);
 
 #endif