memalloc_utils.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024-2025 Rafael V. Volkmer
 * SPDX-FileCopyrightText: <rafael.v.volkmer@gmail.com>
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
/*< C++ Compatibility >*/
#ifdef __cplusplus
extern "C"
{
#endif
 
#ifndef __LIBMEMALLOC_HAS_ATTRIBUTE
  #if defined(__has_attribute)
    #define __LIBMEMALLOC_HAS_ATTRIBUTE(attr_) __has_attribute(attr_)
  #else
    #define __LIBMEMALLOC_HAS_ATTRIBUTE(attr_) 0
  #endif
#endif
 
#ifndef __LIBMEMALLOC_GNUC_PREREQ
  #if defined(__GNUC__) && !defined(__clang__)
    #define __LIBMEMALLOC_GNUC_PREREQ(maj_, min_) \
      ((__GNUC__ > (maj_)) || (__GNUC__ == (maj_) && __GNUC_MINOR__ >= (min_)))
  #else
    #define __LIBMEMALLOC_GNUC_PREREQ(maj_, min_) 0
  #endif
#endif
 
#ifndef __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS
  #if __LIBMEMALLOC_HAS_ATTRIBUTE(zero_call_used_regs) \
    || __LIBMEMALLOC_GNUC_PREREQ(11, 0)
    #define __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS , zero_call_used_regs("all")
  #else
    #define __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS
  #endif
#endif
 
#ifndef ARCH_ALIGNMENT
  /* x86_64 processor [64-bit] - Vendor: AMD/Intel */
  #if defined(__x86_64__) || defined(_M_X64) || defined(__amd64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* i386 processor [32-bit] - Vendor: Intel */
  #elif defined(__i386__) || defined(_M_IX86) || defined(__386__)
    #define ARCH_ALIGNMENT (4U)
 
  /* aarch64 processor [64-bit] - Vendor: ARM */
  #elif defined(__aarch64__) || defined(_M_ARM64) || defined(__arm64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* arm processor [32-bit] - Vendor: ARM (v7/v6) */
  #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_6__) || defined(__arm__) \
    || defined(_M_ARM)
    #define ARCH_ALIGNMENT (4U)
 
  /* riscv processor [64-bit] - Vendor: RISC-V */
  #elif defined(__riscv) && (__riscv_xlen == 64)
    #define ARCH_ALIGNMENT (8U)
  /* riscv processor [32-bit] - Vendor: RISC-V */
  #elif defined(__riscv) && (__riscv_xlen == 32)
    #define ARCH_ALIGNMENT (4U)
 
  /* powerpc processor [64-bit] - Vendor: IBM */
  #elif defined(__powerpc64__) || defined(__PPC64__)
    #define ARCH_ALIGNMENT (8U)
  /* powerpc processor [32-bit] - Vendor: IBM */
  #elif defined(__powerpc__) || defined(__PPC__)
    #define ARCH_ALIGNMENT (4U)
 
  /* s390x processor [64-bit] - Vendor: IBM */
  #elif defined(__s390x__) || defined(__s390__)
    #define ARCH_ALIGNMENT (8U)
 
  /* mips processor [64-bit] - Vendor: MIPS */
  #elif defined(__mips64) || defined(__mips64el__)
    #define ARCH_ALIGNMENT (8U)
  /* mips processor [32-bit] - Vendor: MIPS */
  #elif defined(__mips__)
    #define ARCH_ALIGNMENT (4U)
 
  /* loongarch processor [64-bit] - Vendor: Loongson */
  #elif defined(__loongarch__)
    #define ARCH_ALIGNMENT (8U)
 
  /* avr processor [8-bit] - Vendor: Microchip */
  #elif defined(__AVR__)
    #define ARCH_ALIGNMENT (2U)
  /* avr32 processor [32-bit] - Vendor: Microchip */
  #elif defined(__avr32__)
    #define ARCH_ALIGNMENT (4U)
 
  /* microblaze processor [32-bit] - Vendor: Xilinx */
  #elif defined(__MICROBLAZE__)
    #define ARCH_ALIGNMENT (4U)
 
  /* sh processor [32-bit] - Vendor: Renesas */
  #elif defined(__sh__)
    #define ARCH_ALIGNMENT (4U)
 
  /* arc processor [32-bit] - Vendor: Synopsys */
  #elif defined(__arc__)
    #define ARCH_ALIGNMENT (4U)
 
  /* bfin processor [32-bit] - Vendor: Analog Devices */
  #elif defined(__bfin__)
    #define ARCH_ALIGNMENT (4U)
 
  /* wasm processor [32-bit] - Vendor: WebAssembly/Emscripten */
  #elif defined(__EMSCRIPTEN__) || defined(__wasm__)
    #define ARCH_ALIGNMENT (4U)
 
  /* sparc processor [32-bit] - Vendor: Oracle */
  #elif defined(__sparc__) || defined(__sparc)
    #define ARCH_ALIGNMENT (4U)
  /* sparc processor [64-bit] - Vendor: Oracle (V9) */
  #elif defined(__sparcv9__)
    #define ARCH_ALIGNMENT (8U)
 
  /* ia64 processor [64-bit] - Vendor: Intel Itanium */
  #elif defined(__ia64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* alpha processor [64-bit] - Vendor: DEC */
  #elif defined(__alpha__)
    #define ARCH_ALIGNMENT (8U)
 
  /* pru processor [32-bit] - Vendor: TI */
  #elif defined(__TI_PRU__) || defined(__PRU__)
    #define ARCH_ALIGNMENT (4U)
  /* PA-RISC [32-bit] – Vendor: HP PA-RISC */
  #elif defined(__hppa__)
    #define ARCH_ALIGNMENT (4U)
 
  /* z/Arch [64-bit] – Vendor: IBM Z */
  #elif defined(__zarch__)
    #define ARCH_ALIGNMENT (8U)
 
  /* SPU [32-bit] – Vendor: Cell Broadband */
  #elif defined(__cell_spu__)
    #define ARCH_ALIGNMENT (16U) /* SPU natural aligns to 16 bytes */
 
  /* NVPTX [64-bit] – Vendor: NVIDIA PTX */
  #elif defined(__NVPTX__) || defined(__PTX__)
    #define ARCH_ALIGNMENT (8U)
 
  /* eBPF [64-bit] – in-kernel VM */
  #elif defined(__bpf__)
    #define ARCH_ALIGNMENT (8U)
 
  /* Elbrus E2K [64-bit] – Vendor: MCST */
  #elif defined(__e2k__)
    #define ARCH_ALIGNMENT (8U)
 
  /* CRIS [32-bit] – Vendor: Axis Communications */
  #elif defined(__CRIS__)
    #define ARCH_ALIGNMENT (4U)
 
  /* TILEGX [64-bit] – Vendor: Tilera */
  #elif defined(__tilegx__)
    #define ARCH_ALIGNMENT (8U)
 
  /* Generic fallback */
  #else
    #error "[ERROR] Unknown Architecture: check 'ARCH_ALIGNMENT'"
  #endif
#endif
 
#define ALIGN(val_)   (((val_) + (ARCH_ALIGNMENT - 1U)) & ~(ARCH_ALIGNMENT - 1U))
 
#define PTR_ERR(ptr_) ((void *)((intptr_t)(ptr_)))
 
#ifndef __LIBMEMALLOC_API
  #if defined(_WIN32)
    #ifdef BUILDING_LIBMEMALLOC
      #define __LIBMEMALLOC_API __declspec(dllexport)
    #else
      #define __LIBMEMALLOC_API __declspec(dllimport)
    #endif
  #else
    #if defined(__GNUC__) || defined(__clang__)
      #define __LIBMEMALLOC_API __attribute__((visibility("default")))
    #else
      #define __LIBMEMALLOC_API
    #endif
  #endif
#endif
 
#ifndef __ALIGN
  #if __LIBMEMALLOC_HAS_ATTRIBUTE(scalar_storage_order) \
    || __LIBMEMALLOC_GNUC_PREREQ(8, 0)
    #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
      #define __LIBMEMALLOC_ATTR_SSO \
        __attribute__((scalar_storage_order("big-endian")))
    #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
      #define __LIBMEMALLOC_ATTR_SSO \
        __attribute__((scalar_storage_order("little-endian")))
    #else
      #error "[ERROR] Unknown Endianness: check '__BYTE_ORDER__'"
    #endif
  #else
    #define __LIBMEMALLOC_ATTR_SSO
  #endif
 
  #if (defined(__GNUC__) || defined(__clang__) \
       || __LIBMEMALLOC_HAS_ATTRIBUTE(aligned))
    #define __LIBMEMALLOC_ATTR_ALIGNED __attribute__((aligned(ARCH_ALIGNMENT)))
  #else
    #define __LIBMEMALLOC_ATTR_ALIGNED
  #endif
 
  #define __ALIGN __LIBMEMALLOC_ATTR_SSO __LIBMEMALLOC_ATTR_ALIGNED
#endif
 
#ifndef __UNUSED
  #if defined(__GNUC__) || defined(__clang__)
    #define __UNUSED __attribute__((unused))
  #else
    #define __UNUSED
  #endif
#endif
 
#ifndef __GC_HOT
  #if defined(__GNUC__) || defined(__clang__)
    #define __GC_HOT __attribute__((hot))
  #else
    #define __GC_HOT
  #endif
#endif
 
#ifndef __GC_COLD
  #if defined(__GNUC__) || defined(__clang__)
    #define __GC_COLD __attribute__((cold))
  #else
    #define __GC_COLD
  #endif
#endif
 
#ifndef __LIBMEMALLOC_INTERNAL_MALLOC
  #if defined(__GNUC__) || defined(__clang__)
    #define __LIBMEMALLOC_INTERNAL_MALLOC \
      __attribute__((malloc,              \
                     alloc_size(2),       \
                     warn_unused_result,  \
                     returns_nonnull __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS))
  #else
    #define __LIBMEMALLOC_INTERNAL_MALLOC
  #endif
#endif
 
#ifndef __LIBMEMALLOC_MALLOC
  #if defined(__GNUC__) || defined(__clang__)
    #define __LIBMEMALLOC_MALLOC         \
      __attribute__((malloc,             \
                     alloc_size(1),      \
                     warn_unused_result, \
                     returns_nonnull __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS))
  #else
    #define __LIBMEMALLOC_MALLOC
  #endif
#endif
 
#ifndef __LIBMEMALLOC_REALLOC
  #if defined(__GNUC__) || defined(__clang__)
    #define __LIBMEMALLOC_REALLOC        \
      __attribute__((malloc,             \
                     alloc_size(2),      \
                     warn_unused_result, \
                     returns_nonnull __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS))
  #else
    #define __LIBMEMALLOC_REALLOC
  #endif
#endif
 
#ifndef __LIBMEMALLOC_INTERNAL_REALLOC
  #if defined(__GNUC__) || defined(__clang__)
    #define __LIBMEMALLOC_INTERNAL_REALLOC \
      __attribute__((malloc,               \
                     alloc_size(3),        \
                     warn_unused_result,   \
                     returns_nonnull __LIBMEMALLOC_ATTR_ZERO_CALL_USED_REGS))
  #else
    #define __LIBMEMALLOC_INTERNAL_REALLOC
  #endif
#endif
 
#ifndef LIKELY
  #if (defined(__has_builtin) && __has_builtin(__builtin_expect)) \
    || defined(__GNUC__) || defined(__clang__)
    #define LIKELY(cond_) (__builtin_expect(!!(cond_), 1))
  #else
    #define LIKELY(cond_) (!!(cond_))
  #endif
#endif
 
#ifndef UNLIKELY
  #if (defined(__has_builtin) && __has_builtin(__builtin_expect)) \
    || defined(__GNUC__) || defined(__clang__)
    #define UNLIKELY(cond_) (__builtin_expect(!!(cond_), 0))
  #else
    #define UNLIKELY(cond_) (!!(cond_))
  #endif
#endif
 
#ifndef PREFETCH_R
  #if (defined(__has_builtin) && __has_builtin(__builtin_prefetch)) \
    || defined(__GNUC__) || defined(__clang__)
    #define PREFETCH_R(addr_) __builtin_prefetch((addr_), 0, 1)
  #else
    #define PREFETCH_R(addr_) ((void)0)
  #endif
#endif
 
#ifndef PREFETCH_W
  #if (defined(__has_builtin) && __has_builtin(__builtin_prefetch)) \
    || defined(__GNUC__) || defined(__clang__)
    #define PREFETCH_W(addr_) __builtin_prefetch((addr_), 1, 1)
  #else
    #define PREFETCH_W(addr_) ((void)0)
  #endif
#endif
 
#ifndef ASSUME_ALIGNED
  #if (defined(__has_builtin) && __has_builtin(__builtin_assume_aligned)) \
    || defined(__GNUC__) || defined(__clang__)
    #define ASSUME_ALIGNED(ptr_, align_) \
      __builtin_assume_aligned((ptr_), (align_))
  #else
    #define ASSUME_ALIGNED(ptr_, align_) (align_)
  #endif
#endif
 
/*< C++ Compatibility >*/
#ifdef __cplusplus
}
#endif
 
/*< end of header file >*/