Apply suggestions from code review

Remove `glibc` guards for new functions to support all libc
implementations.

Updates tests to skip if compilation fails on a specific platform.

Signed-off-by: Nana Adjei Manu <[email protected]>

Author: claeusdev

src/memray/_memray/hooks.cpp

@@ -196,7 +196,6 @@ free(void* ptr) noexcept
     }
 }
 
-#if defined(__GLIBC__)
 void
 free_sized(void* ptr, size_t size) noexcept
 {
@@ -208,7 +207,6 @@ free_aligned_sized(void* ptr, size_t alignment, size_t size) noexcept
 {
     memray::intercept::free(ptr);
 }
-#endif
 
 void*
 realloc(void* ptr, size_t size) noexcept

src/memray/_memray/hooks.h

@@ -30,15 +30,21 @@
         FOR_EACH_HOOKED_FUNCTION(memalign)                                                              \
         FOR_EACH_HOOKED_FUNCTION(prctl)                                                                 \
         FOR_EACH_HOOKED_FUNCTION(pvalloc)                                                               \
-        FOR_EACH_HOOKED_FUNCTION(mmap64)
-        FOR_EACH_HOOKED_FUNCTION(free_sized)                                                            \
-        FOR_EACH_HOOKED_FUNCTION(free_aligned_sized)
+        FOR_EACH_HOOKED_FUNCTION(mmap64)                                                                \
 #else
 #    define MEMRAY_PLATFORM_HOOKED_FUNCTIONS                                                            \
         FOR_EACH_HOOKED_FUNCTION(memalign)                                                              \
         FOR_EACH_HOOKED_FUNCTION(prctl)
 #endif
 
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#    define MEMRAY_C23_HOOKED_FUNCTIONS                                                                 \
+        FOR_EACH_HOOKED_FUNCTION(free_sized)                                                            \
+        FOR_EACH_HOOKED_FUNCTION(free_aligned_sized)
+#else
+#    define MEMRAY_C23_HOOKED_FUNCTIONS
+#endif
+
 #define MEMRAY_HOOKED_FUNCTIONS                                                                         \
     FOR_EACH_HOOKED_FUNCTION(malloc)                                                                    \
     FOR_EACH_HOOKED_FUNCTION(free)                                                                      \
@@ -52,6 +58,7 @@
     FOR_EACH_HOOKED_FUNCTION(dlopen)                                                                    \
     FOR_EACH_HOOKED_FUNCTION(dlclose)                                                                   \
     FOR_EACH_HOOKED_FUNCTION(PyGILState_Ensure)                                                         \
+    MEMRAY_C23_HOOKED_FUNCTIONS                                                                         \
     MEMRAY_PLATFORM_HOOKED_FUNCTIONS
 
 namespace memray::hooks {
@@ -201,13 +208,13 @@ mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset) noexc
 #if defined(__GLIBC__)
 void*
 mmap64(void* addr, size_t length, int prot, int flags, int fd, off64_t offset) noexcept;
+#endif
 
 void
 free_sized(void* ptr, size_t size) noexcept;
 
 void
 free_aligned_sized(void* ptr, size_t alignment, size_t size) noexcept;
-#endif
 
 int
 munmap(void* addr, size_t length) noexcept;

tests/integration/free_sized_extension/free_sized_test.c

@@ -0,0 +1,150 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+
+__attribute__((weak)) void free_sized(void* ptr, size_t size);
+__attribute__((weak)) void free_aligned_sized(void* ptr, size_t alignment, size_t size);
+
+// Check if C23 functions are available
+static int functions_available = -1;
+
+static void check_functions_available(void) {
+    if (functions_available == -1) {
+        functions_available = (free_sized != NULL && free_aligned_sized != NULL);
+    }
+}
+
+// Structure to hold allocation info
+void*
+test_free_sized(void)
+{
+    void* address;
+    
+    check_functions_available();
+    if (!functions_available) {
+        return address;
+    }
+    
+    void* ptr = malloc(1024);
+    assert(ptr != NULL);
+    
+    address = ptr;
+
+    free_sized(ptr, 1024);
+    return address;
+}
+
+void*
+test_free_aligned_sized(void)
+{
+    void* address;
+    
+    check_functions_available();
+    if (!functions_available) {
+        return address;
+    }
+    
+    void* ptr = aligned_alloc(64, 1024);
+    assert(ptr != NULL);
+    
+    address = ptr;
+    
+    free_aligned_sized(ptr, 64, 1024);
+    return address;
+}
+
+void*
+test_both_free_functions(void)
+{
+    void* address;
+    
+    check_functions_available();
+    if (!functions_available) {
+        return NULL;
+    }
+    
+    void* ptr1 = malloc(512);
+    assert(ptr1 != NULL);
+    free_sized(ptr1, 512);
+    
+    void* ptr2 = aligned_alloc(32, 256);
+    assert(ptr2 != NULL);
+    free_aligned_sized(ptr2, 32, 256);
+    
+    address = ptr2;
+    
+    return address;
+}
+
+PyObject*
+run_free_sized_test(PyObject* self, PyObject* args)
+{
+    check_functions_available();
+    if (!functions_available) {
+        Py_RETURN_NONE; 
+    }
+    
+    void* address = test_free_sized();
+    
+    // Return address for verification
+    PyObject* result = Py_BuildValue("(KII)", address);
+    return result;
+}
+
+PyObject*
+run_free_aligned_sized_test(PyObject* self, PyObject* args)
+{
+    check_functions_available();
+    if (!functions_available) {
+        Py_RETURN_NONE; 
+    }
+    
+    void* address = test_free_aligned_sized();
+    
+    PyObject* result = Py_BuildValue("(KII)", address);
+    return result;
+}
+
+PyObject*
+run_both_tests(PyObject* self, PyObject* args)
+{
+    check_functions_available();
+    if (!functions_available) {
+        Py_RETURN_NONE; // Skip test if functions not available
+    }
+    
+    void* address = test_both_free_functions();
+    
+    PyObject* result = Py_BuildValue("(KII)", address);
+    return result;
+}
+
+static PyMethodDef
+free_sized_methods[] = {
+    {"run_free_sized_test", run_free_sized_test, METH_NOARGS, "Test free_sized function"},
+    {"run_free_aligned_sized_test", run_free_aligned_sized_test, METH_NOARGS, "Test free_aligned_sized function"},
+    {"run_both_tests", run_both_tests, METH_NOARGS, "Test both free functions"},
+    {NULL, NULL, 0, NULL}
+};
+
+static PyModuleDef
+free_sized_module = {
+    PyModuleDef_HEAD_INIT,
+    "free_sized_test",
+    "Test module for free_sized and free_aligned_sized functions",
+    -1,
+    free_sized_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC
+PyInit_free_sized_test(void)
+{
+    return PyModule_Create(&free_sized_module);
+}

tests/integration/free_sized_extension/free_sized_test.cpp

@@ -5,8 +5,9 @@
     ext_modules=[
         Extension(
             "free_sized_test",
-            sources=["free_sized_test.cpp"],
-            language="c++",
+            sources=["free_sized_test.c"],
+            language="c",
+            extra_compile_args=["-std=c23"]
         )
     ],
 )