Cppcheck report - GATE C/C++ Framework: gate/functions.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/
#include "gate/functions.h"
#include "gate/results.h"
#include "gate/memalloc.h"
#include "gate/callstacks.h"
#include "gate/debugging.h"

#if defined(GATE_COMPILER_MSVC)
#	if defined(GATE_SYS_EFI)
#		define GATE_FUNCTION_GUARD_NOGUARD	1
#	else
#		define GATE_FUNCTION_GUARD_WINSEH	1
#	endif
#else
#	define GATE_FUNCTION_GUARD_SIGNALS	1
#endif

#define GATE_FUNCTIONS_GENERIC_IMPL	1

#if defined(GATE_FUNCTIONS_GENERIC_IMPL)

#if defined(GATE_COMPILER_WATCOM)
typedef short fparam_t;
#else
typedef void* fparam_t;
#endif

typedef gate_uint64_t(*gate_function_generic_t)(
    fparam_t a000, fparam_t a001, fparam_t a002, fparam_t a003, fparam_t a004, fparam_t a005, fparam_t a006, fparam_t a007, fparam_t a008, fparam_t a009,
    fparam_t a010, fparam_t a011, fparam_t a012, fparam_t a013, fparam_t a014, fparam_t a015, fparam_t a016, fparam_t a017, fparam_t a018, fparam_t a019,
    fparam_t a020, fparam_t a021, fparam_t a022, fparam_t a023, fparam_t a024, fparam_t a025, fparam_t a026, fparam_t a027, fparam_t a028, fparam_t a029,
    fparam_t a030, fparam_t a031, fparam_t a032, fparam_t a033, fparam_t a034, fparam_t a035, fparam_t a036, fparam_t a037, fparam_t a038, fparam_t a039,
    fparam_t a040, fparam_t a041, fparam_t a042, fparam_t a043, fparam_t a044, fparam_t a045, fparam_t a046, fparam_t a047, fparam_t a048, fparam_t a049,
    fparam_t a050, fparam_t a051, fparam_t a052, fparam_t a053, fparam_t a054, fparam_t a055, fparam_t a056, fparam_t a057, fparam_t a058, fparam_t a059,
    fparam_t a060, fparam_t a061, fparam_t a062, fparam_t a063
    );

#define REGISTER_TYPE_CONVERTER(type, arg_type_name) \
typedef union { \
	type native_value; \
	fparam_t generic_value[(sizeof(fparam_t) + sizeof(type) - 1) / sizeof(fparam_t)]; \
} arg_type_name ## _converter_t

REGISTER_TYPE_CONVERTER(unsigned char, unsigned_char);
REGISTER_TYPE_CONVERTER(signed char, signed_char);
REGISTER_TYPE_CONVERTER(unsigned short, unsigned_short);
REGISTER_TYPE_CONVERTER(signed short, signed_short);
REGISTER_TYPE_CONVERTER(unsigned int, unsigned_int);
REGISTER_TYPE_CONVERTER(signed int, signed_int);
REGISTER_TYPE_CONVERTER(unsigned long, unsigned_long);
REGISTER_TYPE_CONVERTER(signed long, signed_long);
REGISTER_TYPE_CONVERTER(gate_uint64_t, unsigned_longlong);
REGISTER_TYPE_CONVERTER(gate_int64_t, signed_longlong);
REGISTER_TYPE_CONVERTER(float, float);
REGISTER_TYPE_CONVERTER(double, double);
REGISTER_TYPE_CONVERTER(long double, longdouble);
REGISTER_TYPE_CONVERTER(void*, pointer);

#define CONVERT_TYPE_TO_GENERIC(arg_type_name, input_value, output_ptr, output_count, output_max) do { \
	arg_type_name ## _converter_t converter = GATE_INIT_EMPTY; \
	if(sizeof(input_value) > (sizeof(fparam_t) * output_max)) \
	{ \
		*output_count = 0; \
	} \
	else \
	{ \
		converter.native_value = input_value; \
		*output_count = sizeof(converter.generic_value) / sizeof(fparam_t); \
		gate_mem_copy(output_ptr, &converter.generic_value[0], sizeof(converter.generic_value)); \
	} \
} while(0)

#if defined(GATE_SYS_WIN)
#else	
#	define GATE_FUNCTION_ARGS_MAX_ALIGNMENT
#endif

static unsigned gate_function_load_argument(gate_function_argument_t* arg, fparam_t* target, unsigned target_count)
{
    unsigned target_used = 0;

    if (!arg || !target || (target_count == 0))
    {
        return 0;
    }

    switch (arg->arg_type)
    {
    case GATE_FUNCTION_ARG_UCHAR:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_char, arg->arg_value.u_chr, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_SCHAR:
    {
        CONVERT_TYPE_TO_GENERIC(signed_char, arg->arg_value.s_chr, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_USHORT:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_short, arg->arg_value.u_short, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_SSHORT:
    {
        CONVERT_TYPE_TO_GENERIC(signed_short, arg->arg_value.s_short, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_UINT:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_int, arg->arg_value.u_int, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_SINT:
    {
        CONVERT_TYPE_TO_GENERIC(signed_int, arg->arg_value.s_int, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_ULONG:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_long, arg->arg_value.u_long, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_SLONG:
    {
        CONVERT_TYPE_TO_GENERIC(signed_long, arg->arg_value.s_long, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_ULONGLONG:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_longlong, arg->arg_value.u_long_long, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_SLONGLONG:
    {
        CONVERT_TYPE_TO_GENERIC(signed_longlong, arg->arg_value.s_long_long, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_FLOAT:
    {
        CONVERT_TYPE_TO_GENERIC(float, arg->arg_value.flt, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_DOUBLE:
    {
        CONVERT_TYPE_TO_GENERIC(double, arg->arg_value.dbl, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_LONGDOUBLE:
    {
        CONVERT_TYPE_TO_GENERIC(longdouble, arg->arg_value.ldbl, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_POINTER:
    {
        CONVERT_TYPE_TO_GENERIC(pointer, arg->arg_value.ptr, target, &target_used, target_count);
        break;
    }
    case GATE_FUNCTION_ARG_BLOB:
    {
        CONVERT_TYPE_TO_GENERIC(unsigned_char, arg->arg_value.u_chr, target, &target_used, target_count);
        break;
    }
    }
    return target_used;
}

gate_result_t gate_function_invoke_generic(gate_funcptr_t func_ptr, gate_enumint_t flags,
    gate_function_argument_t* args, gate_size_t arg_count,
    gate_function_argument_t* retval)
{
    fparam_t v[64] = GATE_INIT_EMPTY;
    gate_uint64_t r = 0;
    gate_function_generic_t func = (gate_function_generic_t)func_ptr;
    unsigned count = sizeof(v) / sizeof(v[0]);
    unsigned used, n;
<--- The scope of the variable 'used' can be reduced. [+]
The scope of the variable 'used' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    fparam_t tmp[16];
    fparam_t* ptr_v = &v[0];

    GATE_UNUSED_ARG(flags);

    while (arg_count-- != 0)
    {
        gate_mem_clear(tmp, sizeof(tmp));
        used = gate_function_load_argument(args, tmp, sizeof(tmp) / sizeof(tmp[0]));
        if (used > count)
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
#if defined(GATE_FUNCTION_ARGS_MAX_ALIGNMENT)
        /* type was greater than pointer, add padding words to extend alignment */
        if (used > 1)
        {
            unsigned mod, padd;
<--- The scope of the variable 'padd' can be reduced. [+]
The scope of the variable 'padd' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
            mod = count % used;
            if (mod > 0)
            {
                padd = used - mod;
                if (padd > count)
                {
                    return GATE_RESULT_OUTOFMEMORY;
                }
                for (n = 0; n != padd; ++n)
                {
                    ptr_v[n] = ((fparam_t)0);
                }
                ptr_v += padd;
                count -= padd;
            }
        }
#else
        /* we are pointer-aligned -> nothing to do */
#endif
        for (n = 0; n != used; ++n)
        {
            ptr_v[n] = tmp[n];
        }
        ptr_v += used;
        count -= used;
        ++args;
    }

    r = func(
        v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9],
        v[10], v[11], v[12], v[13], v[14], v[15], v[16], v[17], v[18], v[19],
        v[20], v[21], v[22], v[23], v[24], v[25], v[26], v[27], v[28], v[29],
        v[30], v[31], v[32], v[33], v[34], v[35], v[36], v[37], v[38], v[39],
        v[40], v[41], v[42], v[43], v[44], v[45], v[46], v[47], v[48], v[49],
        v[50], v[51], v[52], v[53], v[54], v[55], v[56], v[57], v[58], v[59],
        v[60], v[61], v[62], v[63]
    );

    if (retval)
    {
        retval->arg_value.u_long_long = r;
        retval->arg_type = GATE_FUNCTION_ARG_ULONGLONG;
    }

    return GATE_RESULT_OK;
}

#endif


#if defined(GATE_FUNCTIONS_X86_IMPL)

typedef struct gate_function_context
{
    void* function_ptr;<--- struct member 'gate_function_context::function_ptr' is never used.
    int		eax;<--- struct member 'gate_function_context::eax' is never used.
    int		ebx;<--- struct member 'gate_function_context::ebx' is never used.
    int		ecx;<--- struct member 'gate_function_context::ecx' is never used.
    int		edx;<--- struct member 'gate_function_context::edx' is never used.
    int		esi;<--- struct member 'gate_function_context::esi' is never used.
    int		edi;<--- struct member 'gate_function_context::edi' is never used.

    gate_function_argument_t	arguments[32];
    gate_size_t					argumentcount;

} gate_function_context_t;

typedef union x86_arguments
{
    void* function_ptr;<--- union member 'x86_arguments::function_ptr' is never used.
    unsigned char	buffer[1024];
} x86_arguments_t;

typedef gate_uint64_t(*x86_c_func_t)(x86_arguments_t args);

gate_result_t gate_function_invoke_generic(void* func_ptr, gate_enumint_t flags,
    gate_function_argument_t* args, gate_size_t arg_count, gate_function_argument_t* retval)
{
    gate_result_t ret = GATE_RESULT_OK;
    x86_c_func_t func = (x86_c_func_t)func_ptr;
    gate_uint64_t x86_ret = NULL;
    x86_arguments_t x86_args = GATE_INIT_EMPTY;
    gate_size_t n;

    for (n = 0; n != sizeof(x86_args.buffer); ++n)
    {
        x86_args.buffer[n] = (unsigned char)(n % 256);
    }

    x86_ret = func(x86_args);
    if (retval)
    {
        retval->arg_value.u_long_long = x86_ret;
        retval->arg_type = GATE_FUNCTION_ARG_ULONGLONG;
    }
    return ret;
}


#endif	/* GATE_FUNCTIONS_X86_IMPL */

#if defined(GATE_FUNCTIONS_X86X64_IMPL)


typedef union x64_arguments
{
    void* function_ptr[1024 / sizeof(void*)];<--- union member 'x64_arguments::function_ptr' is never used.
    unsigned char	buffer[1024];<--- union member 'x64_arguments::buffer' is never used.
} x64_arguments_t;

typedef void* (*x64_c_func_t)(
    void* a1, void* a2, void* a3, void* a4, void* a5, void* a6, void* a7, void* a8,
    void* b1, void* b2, void* b3, void* b4, void* b5, void* b6, void* b7, void* b8,
    void* c1, void* c2, void* c3, void* c4, void* c5, void* c6, void* c7, void* c8,
    void* d1, void* d2, void* d3, void* d4, void* d5, void* d6, void* d7, void* d8,
    void* e1, void* e2, void* e3, void* e4, void* e5, void* e6, void* e7, void* e8,
    void* f1, void* f2, void* f3, void* f4, void* f5, void* f6, void* f7, void* f8
    );

gate_result_t gate_function_invoke_generic(void* func_ptr, gate_enumint_t flags,
    gate_function_argument_t* args, gate_size_t arg_count, gate_function_argument_t* retval)
{
    gate_result_t ret = GATE_RESULT_OK;
    x64_c_func_t func = (x64_c_func_t)func_ptr;
    void* x64_ret = NULL;
    x64_arguments_t x64_args = GATE_INIT_EMPTY;<--- Variable 'x64_args' is assigned a value that is never used.
    gate_size_t n, i;
    void* a[8];
    void* b[8];
    void* c[8];
    void* d[8];
    void* e[8];
    void* f[8];

    i = 0;
    for (n = 0; n != 8; ++n) a[n] = (unsigned char)(i++ % 256);
    for (n = 0; n != 8; ++n) b[n] = (unsigned char)(i++ % 256);
    for (n = 0; n != 8; ++n) c[n] = (unsigned char)(i++ % 256);
    for (n = 0; n != 8; ++n) d[n] = (unsigned char)(i++ % 256);
    for (n = 0; n != 8; ++n) e[n] = (unsigned char)(i++ % 256);
    for (n = 0; n != 8; ++n) f[n] = (unsigned char)(i++ % 256);

    x64_ret = func(
        a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
        b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
        c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7],
        d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
        e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7],
        f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7]
    );
    if (retval)
    {
        retval->arg_value.u_long_long = x64_ret;
        retval->arg_type = GATE_FUNCTION_ARG_ULONGLONG;
    }

    return ret;
}

#endif	/* GATE_FUNCTIONS_X86X64_IMPL */



#if defined(GATE_FUNCTION_GUARD_WINSEH)

#include "gate/platforms.h"

static int gate_win32_seh_filter(unsigned int seh_code,
    struct _EXCEPTION_POINTERS* xcpt_ptrs,
    gate_function_fault_handler_t handler, void* param)
{
    unsigned fault_code;
    gate_result_t result;

    GATE_UNUSED_ARG(xcpt_ptrs);

    switch (seh_code)
    {
    case EXCEPTION_FLT_DENORMAL_OPERAND:
    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
    case EXCEPTION_FLT_INEXACT_RESULT:
    case EXCEPTION_FLT_INVALID_OPERATION:
    case EXCEPTION_FLT_OVERFLOW:
    case EXCEPTION_FLT_STACK_CHECK:
    case EXCEPTION_FLT_UNDERFLOW:
        fault_code = GATE_FUNCTION_FAULT_FLOAT;
        break;
    case EXCEPTION_ACCESS_VIOLATION:
    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
    case EXCEPTION_GUARD_PAGE:
    case EXCEPTION_IN_PAGE_ERROR:
        fault_code = GATE_FUNCTION_FAULT_ADDRESS;
        break;
    case EXCEPTION_ILLEGAL_INSTRUCTION:
        fault_code = GATE_FUNCTION_FAULT_INSTRUCTION;
        break;
    case EXCEPTION_SINGLE_STEP:
    case EXCEPTION_BREAKPOINT:
        fault_code = GATE_FUNCTION_FAULT_BREAKPOINT;
        break;
    case EXCEPTION_DATATYPE_MISALIGNMENT:
        fault_code = GATE_FUNCTION_FAULT_ALIGNMENT;
        break;
    case EXCEPTION_INT_DIVIDE_BY_ZERO:
        fault_code = GATE_FUNCTION_FAULT_ARITHMETIC;
        break;
    case EXCEPTION_INT_OVERFLOW:
        fault_code = GATE_FUNCTION_FAULT_OVERFLOW;
        break;
    case EXCEPTION_INVALID_HANDLE:
        fault_code = GATE_FUNCTION_FAULT_SYSTEM;
        break;
    case EXCEPTION_PRIV_INSTRUCTION:
        fault_code = GATE_FUNCTION_FAULT_PRIVILEGE;
        break;
    case EXCEPTION_STACK_OVERFLOW:
        fault_code = GATE_FUNCTION_FAULT_STACK;
        break;
    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
    case EXCEPTION_INVALID_DISPOSITION:
    default:
        fault_code = GATE_FUNCTION_FAULT_UNKNOWN;
        break;
    }

    if (handler)
    {
        result = handler(fault_code, param);
        if (GATE_FAILED(result))
        {
            return EXCEPTION_CONTINUE_SEARCH;
        }
    }
    return EXCEPTION_EXECUTE_HANDLER;
}


gate_result_t gate_function_invoke_guarded(gate_entrypoint_t entry_point, void* entry_param,
    gate_function_fault_handler_t fault_handler, void* fault_param)
{
    gate_result_t result = GATE_RESULT_OK;
    __try
    {
        if (entry_point)
        {
            result = entry_point(entry_param);
        }
    }
    __except (gate_win32_seh_filter(GetExceptionCode(), GetExceptionInformation(), fault_handler, fault_param))
    {
        result = GATE_RESULT_BADINSTRUCTION;
    }
    return result;
}

#endif /* GATE_FUNCTION_GUARD_WINSEH */



#if defined(GATE_FUNCTION_GUARD_SIGNALS)

#include "gate/atomics.h"
#include "gate/platforms.h"
#include "gate/callstacks.h"
#include "gate/threading.h"
#include <setjmp.h>
#include <signal.h>


static gate_thread_storage_t global_function_guard_registry;
static gate_atomic_flag_t global_function_guard_registry_initialized = GATE_ATOMIC_FLAG_INIT;

typedef struct gate_function_anchor_class
{
    gate_callstack_jmpbuf_t			context;
    gate_function_fault_handler_t	fault_handler;
    void* fault_param;
} gate_function_anchor_t;


static void gate_function_guard_signal_handler(int signum);

static gate_result_t gate_function_guard_init()
{
    gate_result_t ret = GATE_RESULT_OK;

    if (false == gate_atomic_flag_set(&global_function_guard_registry_initialized))
    {
        ret = gate_thread_storage_alloc(&global_function_guard_registry);
        if (GATE_FAILED(ret))
        {
            gate_atomic_flag_clear(&global_function_guard_registry_initialized);
            return ret;
        }
    }

    gate_platform_set_signal_handler(SIGABRT, &gate_function_guard_signal_handler, NULL);
#ifdef SIGBUS
    gate_platform_set_signal_handler(SIGBUS, &gate_function_guard_signal_handler, NULL);<--- Skipping configuration 'SIGBUS' since the value of 'SIGBUS' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
    gate_platform_set_signal_handler(SIGFPE, &gate_function_guard_signal_handler, NULL);
    gate_platform_set_signal_handler(SIGILL, &gate_function_guard_signal_handler, NULL);
    gate_platform_set_signal_handler(SIGSEGV, &gate_function_guard_signal_handler, NULL);
#ifdef SIGSYS
    gate_platform_set_signal_handler(SIGSYS, &gate_function_guard_signal_handler, NULL);<--- Skipping configuration 'SIGSYS' since the value of 'SIGSYS' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
#ifdef SIGTRAP
    gate_platform_set_signal_handler(SIGTRAP, &gate_function_guard_signal_handler, NULL);<--- Skipping configuration 'SIGTRAP' since the value of 'SIGTRAP' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
    return ret;
}

static unsigned translate_signal(int sig)
{
    switch (sig)
    {
    case SIGSEGV:	return GATE_FUNCTION_FAULT_ADDRESS;
#ifdef SIGBUS
    case SIGBUS:	return GATE_FUNCTION_FAULT_ADDRESS;<--- Skipping configuration 'SIGBUS' since the value of 'SIGBUS' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
    case SIGABRT:	return GATE_FUNCTION_FAULT_ADDRESS;

    case SIGILL:	return GATE_FUNCTION_FAULT_INSTRUCTION;
    case SIGFPE:	return GATE_FUNCTION_FAULT_ARITHMETIC;

#ifdef SIGSYS
    case SIGSYS:	return GATE_FUNCTION_FAULT_SYSTEM;<--- Skipping configuration 'SIGSYS' since the value of 'SIGSYS' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
#ifdef SIGTRAP
    case SIGTRAP:	return GATE_FUNCTION_FAULT_BREAKPOINT;<--- Skipping configuration 'SIGTRAP' since the value of 'SIGTRAP' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
#endif
    }
    return GATE_FUNCTION_FAULT_UNKNOWN;
}

static void gate_function_guard_signal_handler(int signum)
{
    gate_result_t result;
    gate_function_anchor_t* ptr_anchor = NULL;
    unsigned fault_code;
<--- The scope of the variable 'fault_code' can be reduced. [+]
The scope of the variable 'fault_code' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    result = gate_thread_storage_get(&global_function_guard_registry, (void**)&ptr_anchor);
    if (GATE_SUCCEEDED(result) && (ptr_anchor != NULL))
    {
        fault_code = translate_signal(signum);
        result = ptr_anchor->fault_handler(fault_code, ptr_anchor->fault_param);
        if (GATE_SUCCEEDED(result))
        {
            gate_callstack_jump(&ptr_anchor->context);
        }
    }
}

static gate_result_t gate_function_guard_error_branch(void* param)
{
    (void)param;
    return GATE_RESULT_BADINSTRUCTION;
}

gate_result_t gate_function_invoke_guarded(gate_entrypoint_t entry_point, void* entry_param,
    gate_function_fault_handler_t fault_handler, void* fault_param)
{
    volatile gate_result_t ret = GATE_RESULT_FAILED;
    gate_function_anchor_t new_anchor;
    gate_function_anchor_t* ptr_old_anchor = NULL;

    ret = gate_function_guard_init();
    if (GATE_FAILED(ret))
    {
        return ret;
    }

    gate_thread_storage_get(&global_function_guard_registry, (void**)&ptr_old_anchor);
    new_anchor.fault_handler = fault_handler;
    new_anchor.fault_param = fault_param;

    ret = gate_thread_storage_set(&global_function_guard_registry, &new_anchor);
    if (GATE_FAILED(ret))
    {
        return ret;
    }

    ret = gate_callstack_fork(&new_anchor.context, entry_point, entry_param, &gate_function_guard_error_branch, NULL);

    gate_thread_storage_set(&global_function_guard_registry, ptr_old_anchor);
    return ret;
}

#endif /* GATE_FUNCTION_GUARD_SIGNALS */

#if defined(GATE_FUNCTION_GUARD_NOGUARD)

gate_result_t gate_function_invoke_guarded(gate_entrypoint_t entry_point, void* entry_param,
    gate_function_fault_handler_t fault_handler, void* fault_param)
{
    gate_result_t ret;

    ret = entry_point(entry_param);
    return ret;
}

#endif	/* GATE_FUNCTION_GUARD_NOGUARD */