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)
#if !defined(__ARM_FEATURE_UNALIGNED)
#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)
#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)
#warning "unaligned pointer access not verified on platform, SIGBUS may happen!"
#endif
 
#if defined(WINPR_ARCH_SUPPORTED) && !defined(_WIN32)
#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
// Promote any -Wcast-align warnings to errors on platforms not supporting unaligned access
#if defined(DISABLE_SUPPORTED_ARCH_CHECKS)
#if defined(__clang__)
WINPR_DO_PRAGMA(clang diagnostic warning "-Wcast-align")
#elif defined(__GNUC__)
WINPR_DO_PRAGMA(GCC diagnostic warning "-Wcast-align")
#endif
#else
#if defined(__clang__)
WINPR_DO_PRAGMA(clang diagnostic error "-Wcast-align")
#elif defined(__GNUC__)
WINPR_DO_PRAGMA(GCC diagnostic error "-Wcast-align")
#endif
#endif
#define WINPR_PACKED_ALIGN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val)
#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