cast.h

 
#pragma once
 
#include <stdint.h>
 
#include <winpr/platform.h>
#include <winpr/assert-api.h>
 
#ifdef __cplusplus
#define WINPR_CXX_COMPAT_CAST(t, val) static_cast<t>(val)
#else
#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val))
#endif
 
#if defined(DISABLE_SUPPORTED_ARCH_CHECKS)
#elif defined(_M_ARM) || defined(_M_ARM64)
/* MSVC is not defining the same guards as everyone else, so lets hope they always support it and
 * not only sometimes. */
#if !defined(__ARM_FEATURE_UNALIGNED) && !defined(_MSC_VER)
#warning \
    "-munaligned-access is required on arm. Use -DDISABLE_SUPPORTED_ARCH_CHECKS=ON to ignore, but there will be dragons ahead!"
#else
#define WINPR_ARCH_SUPPORTED 1
#endif
#elif defined(_M_IX86) || defined(_M_AMD64) || defined(_M_PPC) || defined(_M_S390X)
#define WINPR_ARCH_SUPPORTED 1
#elif defined(_M_RISCV32) || defined(_M_RISCV64)
#if !defined(__riscv_misaligned_fast)
#warning \
    "RISCV must support __riscv_misaligned_fast. Use -DDISABLE_SUPPORTED_ARCH_CHECKS=ON to ignore, but there will be dragons ahead!"
#else
#define WINPR_ARCH_SUPPORTED 1
#endif
#endif
 
#if !defined(WINPR_ARCH_SUPPORTED)
#if defined(__GNUC__) || defined(__clang__) ||                      \
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L)) || \
    (defined(__cplusplus) && (__cplusplus >= 202302L))
#warning "unaligned pointer access not verified on platform, SIGBUS may happen!"
#endif
#endif
 
#if defined(_WIN32)
#define WINPR_PACKED_ALIGN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val)
#elif defined(WINPR_ARCH_SUPPORTED)
#define WINPR_PACKED_ALIGN_CAST(t, val)                     \
  __extension__({                                         \
    WINPR_PRAGMA_DIAG_PUSH;                             \
    WINPR_PRAGMA_DIAG_IGNORED_CAST_ALIGN;               \
    typeof(t) aligntmp = WINPR_CXX_COMPAT_CAST(t, val); \
    WINPR_PRAGMA_DIAG_POP;                              \
    aligntmp;                                           \
  })
#else
#define WINPR_PACKED_ALIGN_CAST(t, val)                          \
  __extension__({                                              \
    typeof(t) aligntmp = WINPR_CXX_COMPAT_CAST(t, val);      \
    if (aligntmp)                                            \
    {                                                        \
      const size_t fromtype = _Alignof(typeof(*aligntmp)); \
      const size_t actual = ((uintptr_t)(val)) % fromtype; \
      WINPR_ASSERT(actual == 0);                           \
    }                                                        \
    aligntmp;                                                \
  })
#endif
 
#if defined(__GNUC__) || defined(__clang__)
#define WINPR_REINTERPRET_CAST(ptr, srcType, dstType)            \
  __extension__({                                              \
    union                                                    \
    {                                                        \
      srcType src;                                         \
      dstType dst;                                         \
    } cnv;                                                   \
    WINPR_STATIC_ASSERT(sizeof(srcType) == sizeof(dstType)); \
    cnv.src = ptr;                                           \
    cnv.dst;                                                 \
  })
 
#define WINPR_CAST_CONST_PTR_AWAY(ptr, dstType) \
  __extension__({                             \
    union                                   \
    {                                       \
      __typeof(ptr) src;                  \
      dstType dst;                        \
    } cnv;                                  \
    cnv.src = ptr;                          \
    cnv.dst;                                \
  })
 
#define WINPR_FUNC_PTR_CAST(ptr, dstType)                              \
  __extension__({                                                    \
    union                                                          \
    {                                                              \
      __typeof(ptr) src;                                         \
      dstType dst;                                               \
    } cnv;                                                         \
    WINPR_STATIC_ASSERT(sizeof(dstType) == sizeof(__typeof(ptr))); \
    cnv.src = ptr;                                                 \
    cnv.dst;                                                       \
  })
 
#else
#define WINPR_REINTERPRET_CAST(ptr, srcType, dstType) (dstType) ptr
#define WINPR_CAST_CONST_PTR_AWAY(ptr, dstType) (dstType) ptr
#define WINPR_FUNC_PTR_CAST(ptr, dstType) (dstType)(uintptr_t) ptr
#endif
 
#if defined(__GNUC__) || defined(__clang__)
 
#define WINPR_ASSERTING_INT_CAST(type, ivar)                                                    \
  __extension__({                                                                             \
    __typeof(ivar) var = ivar;                                                              \
    WINPR_ASSERT((var) ==                                                                   \
                 WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \
    WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) ||               \
                 (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0));                \
    WINPR_CXX_COMPAT_CAST(type, (var));                                                     \
  })
 
#else
#define WINPR_ASSERTING_INT_CAST(type, var) WINPR_CXX_COMPAT_CAST(type, var)
#endif