cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

compiler.h (6197B)

      1/* compiler.h: macros to abstract away compiler specifics
      2 *
      3 * This work is licensed under the terms of the GNU GPL, version 2 or later.
      4 * See the COPYING file in the top-level directory.
      5 */
      6
      7#ifndef COMPILER_H
      8#define COMPILER_H
      9
     10#if defined __clang_analyzer__ || defined __COVERITY__
     11#define QEMU_STATIC_ANALYSIS 1
     12#endif
     13
     14#ifdef __cplusplus
     15#define QEMU_EXTERN_C extern "C"
     16#else
     17#define QEMU_EXTERN_C extern
     18#endif
     19
     20#define QEMU_NORETURN __attribute__ ((__noreturn__))
     21
     22#define QEMU_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
     23
     24#define QEMU_SENTINEL __attribute__((sentinel))
     25
     26#if defined(_WIN32) && (defined(__x86_64__) || defined(__i386__))
     27# define QEMU_PACKED __attribute__((gcc_struct, packed))
     28#else
     29# define QEMU_PACKED __attribute__((packed))
     30#endif
     31
     32#define QEMU_ALIGNED(X) __attribute__((aligned(X)))
     33
     34#ifndef glue
     35#define xglue(x, y) x ## y
     36#define glue(x, y) xglue(x, y)
     37#define stringify(s)	tostring(s)
     38#define tostring(s)	#s
     39#endif
     40
     41#ifndef likely
     42#define likely(x)   __builtin_expect(!!(x), 1)
     43#define unlikely(x)   __builtin_expect(!!(x), 0)
     44#endif
     45
     46#ifndef container_of
     47#define container_of(ptr, type, member) ({                      \
     48        const typeof(((type *) 0)->member) *__mptr = (ptr);     \
     49        (type *) ((char *) __mptr - offsetof(type, member));})
     50#endif
     51
     52#define sizeof_field(type, field) sizeof(((type *)0)->field)
     53
     54/*
     55 * Calculate the number of bytes up to and including the given 'field' of
     56 * 'container'.
     57 */
     58#define endof(container, field) \
     59    (offsetof(container, field) + sizeof_field(container, field))
     60
     61/* Convert from a base type to a parent type, with compile time checking.  */
     62#define DO_UPCAST(type, field, dev) ( __extension__ ( { \
     63    char __attribute__((unused)) offset_must_be_zero[ \
     64        -offsetof(type, field)]; \
     65    container_of(dev, type, field);}))
     66
     67#define typeof_field(type, field) typeof(((type *)0)->field)
     68#define type_check(t1,t2) ((t1*)0 - (t2*)0)
     69
     70#define QEMU_BUILD_BUG_ON_STRUCT(x) \
     71    struct { \
     72        int:(x) ? -1 : 1; \
     73    }
     74
     75#define QEMU_BUILD_BUG_MSG(x, msg) _Static_assert(!(x), msg)
     76
     77#define QEMU_BUILD_BUG_ON(x) QEMU_BUILD_BUG_MSG(x, "not expecting: " #x)
     78
     79#define QEMU_BUILD_BUG_ON_ZERO(x) (sizeof(QEMU_BUILD_BUG_ON_STRUCT(x)) - \
     80                                   sizeof(QEMU_BUILD_BUG_ON_STRUCT(x)))
     81
     82#if defined(__clang__)
     83/* clang doesn't support gnu_printf, so use printf. */
     84# define GCC_FMT_ATTR(n, m) __attribute__((format(printf, n, m)))
     85#else
     86/* Use gnu_printf (qemu uses standard format strings). */
     87# define GCC_FMT_ATTR(n, m) __attribute__((format(gnu_printf, n, m)))
     88# if defined(_WIN32)
     89/*
     90 * Map __printf__ to __gnu_printf__ because we want standard format strings even
     91 * when MinGW or GLib include files use __printf__.
     92 */
     93#  define __printf__ __gnu_printf__
     94# endif
     95#endif
     96
     97#ifndef __has_warning
     98#define __has_warning(x) 0 /* compatibility with non-clang compilers */
     99#endif
    100
    101#ifndef __has_feature
    102#define __has_feature(x) 0 /* compatibility with non-clang compilers */
    103#endif
    104
    105#ifndef __has_builtin
    106#define __has_builtin(x) 0 /* compatibility with non-clang compilers */
    107#endif
    108
    109#if __has_builtin(__builtin_assume_aligned) || !defined(__clang__)
    110#define HAS_ASSUME_ALIGNED
    111#endif
    112
    113#ifndef __has_attribute
    114#define __has_attribute(x) 0 /* compatibility with older GCC */
    115#endif
    116
    117/*
    118 * GCC doesn't provide __has_attribute() until GCC 5, but we know all the GCC
    119 * versions we support have the "flatten" attribute. Clang may not have the
    120 * "flatten" attribute but always has __has_attribute() to check for it.
    121 */
    122#if __has_attribute(flatten) || !defined(__clang__)
    123# define QEMU_FLATTEN __attribute__((flatten))
    124#else
    125# define QEMU_FLATTEN
    126#endif
    127
    128/*
    129 * If __attribute__((error)) is present, use it to produce an error at
    130 * compile time.  Otherwise, one must wait for the linker to diagnose
    131 * the missing symbol.
    132 */
    133#if __has_attribute(error)
    134# define QEMU_ERROR(X) __attribute__((error(X)))
    135#else
    136# define QEMU_ERROR(X)
    137#endif
    138
    139/*
    140 * The nonstring variable attribute specifies that an object or member
    141 * declaration with type array of char or pointer to char is intended
    142 * to store character arrays that do not necessarily contain a terminating
    143 * NUL character. This is useful in detecting uses of such arrays or pointers
    144 * with functions that expect NUL-terminated strings, and to avoid warnings
    145 * when such an array or pointer is used as an argument to a bounded string
    146 * manipulation function such as strncpy.
    147 */
    148#if __has_attribute(nonstring)
    149# define QEMU_NONSTRING __attribute__((nonstring))
    150#else
    151# define QEMU_NONSTRING
    152#endif
    153
    154/*
    155 * Forced inlining may be desired to encourage constant propagation
    156 * of function parameters.  However, it can also make debugging harder,
    157 * so disable it for a non-optimizing build.
    158 */
    159#if defined(__OPTIMIZE__)
    160#define QEMU_ALWAYS_INLINE  __attribute__((always_inline))
    161#else
    162#define QEMU_ALWAYS_INLINE
    163#endif
    164
    165/**
    166 * qemu_build_not_reached()
    167 *
    168 * The compiler, during optimization, is expected to prove that a call
    169 * to this function cannot be reached and remove it.  If the compiler
    170 * supports QEMU_ERROR, this will be reported at compile time; otherwise
    171 * this will be reported at link time due to the missing symbol.
    172 */
    173extern void QEMU_NORETURN QEMU_ERROR("code path is reachable")
    174    qemu_build_not_reached_always(void);
    175#if defined(__OPTIMIZE__) && !defined(__NO_INLINE__)
    176#define qemu_build_not_reached()  qemu_build_not_reached_always()
    177#else
    178#define qemu_build_not_reached()  g_assert_not_reached()
    179#endif
    180
    181/**
    182 * In most cases, normal "fallthrough" comments are good enough for
    183 * switch-case statements, but sometimes the compiler has problems
    184 * with those. In that case you can use QEMU_FALLTHROUGH instead.
    185 */
    186#if __has_attribute(fallthrough)
    187# define QEMU_FALLTHROUGH __attribute__((fallthrough))
    188#else
    189# define QEMU_FALLTHROUGH do {} while (0) /* fallthrough */
    190#endif
    191
    192#ifdef CONFIG_CFI
    193/*
    194 * If CFI is enabled, use an attribute to disable cfi-icall on the following
    195 * function
    196 */
    197#define QEMU_DISABLE_CFI __attribute__((no_sanitize("cfi-icall")))
    198#else
    199/* If CFI is not enabled, use an empty define to not change the behavior */
    200#define QEMU_DISABLE_CFI
    201#endif
    202
    203#endif /* COMPILER_H */