include/compiler.h

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2007-2018 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * compiler.h
  36  *
  37  * Compiler-specific macros for NASM.  Feel free to add support for
  38  * other compilers in here.
  39  *
  40  * This header file should be included before any other header.
  41  */
  42
  43 #ifndef NASM_COMPILER_H
  44 #define NASM_COMPILER_H 1
  45
  46 /*
  47  * At least DJGPP and Cygwin have broken header files if __STRICT_ANSI__
  48  * is defined.
  49  */
  50 #ifdef __GNUC__
  51 # undef __STRICT_ANSI__
  52 #endif
  53
  54 /* On Microsoft platforms we support multibyte character sets in filenames */
  55 #define _MBCS 1
  56
  57 #ifdef HAVE_CONFIG_H
  58 # include "config/config.h"
  59 #else
  60 # if defined(_MSC_VER) && (_MSC_VER >= 1310)
  61 #  include "config/msvc.h"
  62 # elif defined(__WATCOMC__)
  63 #  include "config/watcom.h"
  64 # else
  65 #  include "config/unknown.h"
  66 # endif
  67 /* This unconditionally defines some macros we really want */
  68 # include "config/unconfig.h"
  69 #endif /* Configuration file */
  70
  71 /* This is required to get the standard <inttypes.h> macros when compiling
  72    with a C++ compiler.  This must be defined *before* <inttypes.h> is
  73    included, directly or indirectly. */
  74 #define __STDC_CONSTANT_MACROS  1
  75 #define __STDC_LIMIT_MACROS     1
  76 #define __STDC_FORMAT_MACROS    1
  77
  78 #ifdef HAVE_INTTYPES_H
  79 # include <inttypes.h>
  80 #else
  81 # include "nasmint.h"
  82 #endif
  83
  84 #include <assert.h>
  85 #include <stddef.h>
  86 #include <stdarg.h>
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <string.h>
  90 #include <limits.h>
  91 #include <errno.h>
  92
  93 #ifdef HAVE_STRINGS_H
  94 # include <strings.h>
  95 #endif
  96 #ifdef HAVE_SYS_TYPES_H
  97 # include <sys/types.h>
  98 #endif
  99
 100 #ifdef HAVE_ENDIAN_H
 101 # include <endian.h>
 102 #elif defined(HAVE_SYS_ENDIAN_H)
 103 # include <sys/endian.h>
 104 #elif defined(HAVE_MACHINE_ENDIAN_H)
 105 # include <machine/endian.h>
 106 #endif
 107
 108 /*
 109  * If we have BYTE_ORDER defined, or the compiler provides
 110  * __BIG_ENDIAN__ or __LITTLE_ENDIAN__, trust it over what autoconf
 111  * came up with, especially since autoconf obviously can't figure
 112  * things out for a universal compiler.
 113  */
 114 #if defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 115 # undef WORDS_LITTLEENDIAN
 116 # undef WORDS_BIGENDIAN
 117 # define WORDS_BIGENDIAN 1
 118 #elif defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
 119 # undef WORDS_LITTLEENDIAN
 120 # undef WORDS_BIGENDIAN
 121 # define WORDS_LITTLEENDIAN 1
 122 #elif defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
 123 # undef WORDS_LITTLEENDIAN
 124 # undef WORDS_BIGENDIAN
 125 # if BYTE_ORDER == LITTLE_ENDIAN
 126 #  define WORDS_LITTLEENDIAN 1
 127 # elif BYTE_ORDER == BIG_ENDIAN
 128 #  define WORDS_BIGENDIAN 1
 129 # endif
 130 #endif
 131
 132 /*
 133  * Define this to 1 for faster performance if this is a littleendian
 134  * platform *and* it can do arbitrary unaligned memory references.  It
 135  * is safe to leave it defined to 0 even if that is true.
 136  */
 137 #if defined(__386__) || defined(__i386__) || defined(__x86_64__) \
 138     || defined(_M_IX86) || defined(_M_X64)
 139 # define X86_MEMORY 1
 140 # undef WORDS_BIGENDIAN
 141 # undef WORDS_LITTLEENDIAN
 142 # define WORDS_LITTLEENDIAN 1
 143 #else
 144 # define X86_MEMORY 0
 145 #endif
 146
 147 /* Some versions of MSVC have these only with underscores in front */
 148 #ifndef HAVE_SNPRINTF
 149 # ifdef HAVE__SNPRINTF
 150 #  define snprintf _snprintf
 151 # else
 152 int snprintf(char *, size_t, const char *, ...);
 153 # endif
 154 #endif
 155
 156 #ifndef HAVE_VSNPRINTF
 157 # ifdef HAVE__VSNPRINTF
 158 #  define vsnprintf _vsnprintf
 159 # else
 160 int vsnprintf(char *, size_t, const char *, va_list);
 161 # endif
 162 #endif
 163
 164 #if !defined(HAVE_STRLCPY) || !HAVE_DECL_STRLCPY
 165 size_t strlcpy(char *, const char *, size_t);
 166 #endif
 167
 168 #if !defined(HAVE_STRCHRNUL) || !HAVE_DECL_STRCHRNUL
 169 char *strrchrnul(const char *, int);
 170 #endif
 171
 172 #ifndef __cplusplus             /* C++ has false, true, bool as keywords */
 173 # ifdef HAVE_STDBOOL_H
 174 #  include <stdbool.h>
 175 # elif defined(HAVE__BOOL)
 176    typedef _Bool bool;
 177 #  define false 0
 178 #  define true 1
 179 # else
 180 /* This is sort of dangerous, since casts will behave different than
 181    casting to the standard boolean type.  Always use !!, not (bool). */
 182 typedef enum bool { false, true } bool;
 183 # endif
 184 #endif
 185
 186 /* Provide a substitute for offsetof() if we don't have one.  This
 187    variant works on most (but not *all*) systems... */
 188 #ifndef offsetof
 189 # define offsetof(t,m) ((size_t)&(((t *)0)->m))
 190 #endif
 191
 192 /* This is like offsetof(), but takes an object rather than a type.
 193    Ironically enough this is actually guaranteed to be portable,
 194    as far as I know... */
 195 #ifndef offsetin
 196 # define offsetin(p,m)  ((const char *)&((p).m) - (const char *)&(p))
 197 #endif
 198
 199 /* The container_of construct: if p is a pointer to member m of
 200    container class c, then return a pointer to the container of which
 201    *p is a member. */
 202 #ifndef container_of
 203 # define container_of(p, c, m) ((c *)((char *)(p) - offsetof(c,m)))
 204 #endif
 205
 206 /* Some misguided platforms hide the defs for these */
 207 #if defined(HAVE_STRCASECMP) && !HAVE_DECL_STRCASECMP
 208 int strcasecmp(const char *, const char *);
 209 #endif
 210
 211 #if defined(HAVE_STRICMP) && !HAVE_DECL_STRICMP
 212 int stricmp(const char *, const char *);
 213 #endif
 214
 215 #if defined(HAVE_STRNCASECMP) && !HAVE_DECL_STRNCASECMP
 216 int strncasecmp(const char *, const char *, size_t);
 217 #endif
 218
 219 #if defined(HAVE_STRNICMP) && !HAVE_DECL_STRNICMP
 220 int strnicmp(const char *, const char *, size_t);
 221 #endif
 222
 223 #if defined(HAVE_STRSEP) && !HAVE_DECL_STRSEP
 224 char *strsep(char **, const char *);
 225 #endif
 226
 227 #if !HAVE_DECL_STRNLEN
 228 size_t strnlen(const char *s, size_t maxlen);
 229 #endif
 230
 231 #ifndef HAVE_MEMPCPY
 232 static inline void *mempcpy(void *dst, const void *src, size_t n)
 233 {
 234     return (char *)memcpy(dst, src, n) + n;
 235 }
 236 #endif
 237
 238 /*
 239  * Hack to support external-linkage inline functions
 240  */
 241 #ifndef HAVE_STDC_INLINE
 242 # ifdef __GNUC__
 243 #  ifdef __GNUC_STDC_INLINE__
 244 #   define HAVE_STDC_INLINE
 245 #  else
 246 #   define HAVE_GNU_INLINE
 247 #  endif
 248 # elif defined(__GNUC_GNU_INLINE__)
 249 /* Some other compiler implementing only GNU inline semantics? */
 250 #   define HAVE_GNU_INLINE
 251 # elif defined(__STDC_VERSION__)
 252 #  if __STDC_VERSION__ >= 199901L
 253 #   define HAVE_STDC_INLINE
 254 #  endif
 255 # endif
 256 #endif
 257
 258 #ifdef HAVE_STDC_INLINE
 259 # define extern_inline inline
 260 #elif defined(HAVE_GNU_INLINE)
 261 # define extern_inline extern inline
 262 # define inline_prototypes
 263 #else
 264 # define inline_prototypes
 265 #endif
 266
 267 /*
 268  * Hints to the compiler that a particular branch of code is more or
 269  * less likely to be taken.
 270  */
 271 #if HAVE___BUILTIN_EXPECT
 272 # define likely(x)      __builtin_expect(!!(x), 1)
 273 # define unlikely(x)    __builtin_expect(!!(x), 0)
 274 #else
 275 # define likely(x)      (!!(x))
 276 # define unlikely(x)    (!!(x))
 277 #endif
 278
 279 #define safe_alloc     never_null     malloc_func
 280 #define safe_alloc_ptr never_null_ptr malloc_func_ptr
 281
 282 #define safe_malloc(s)          safe_alloc     alloc_size_func1(s)
 283 #define safe_malloc2(s1,s2)     safe_alloc     alloc_size_func2(s1,s2)
 284 #define safe_realloc(s)         never_null     alloc_size_func1(s)
 285 #define safe_malloc_ptr(s)      safe_alloc_ptr alloc_size_func1_ptr(s)
 286 #define safe_malloc2_ptr(s1,s2) safe_alloc_ptr alloc_size_func2_ptr(s1,s2)
 287 #define safe_realloc_ptr(s)     never_null_ptr alloc_size_func1_ptr(s)
 288
 289 /*
 290  * How to tell the compiler that a function doesn't return
 291  */
 292 #ifdef HAVE_STDNORETURN_H
 293 # include <stdnoreturn.h>
 294 # define no_return noreturn void
 295 #elif defined(_MSC_VER)
 296 # define no_return __declspec(noreturn) void
 297 #else
 298 # define no_return void noreturn_func
 299 #endif
 300
 301 /*
 302  * A fatal function is both unlikely and no_return
 303  */
 304 #define fatal_func     no_return unlikely_func
 305 #define fatal_func_ptr no_return unlikely_func_ptr
 306
 307 /*
 308  * How to tell the compiler that a function takes a printf-like string
 309  */
 310 #define printf_func(fmt, list)     format_func3(printf,fmt,list)
 311 #define printf_func_ptr(fmt, list) format_func3_ptr(printf,fmt,list)
 312
 313 /*
 314  * A static [inline] function which either is currently unused but
 315  * likely to be used in the future, or used only under some #if
 316  * combinations.  Mark with this option to suppress compiler
 317  * warnings.
 318  *
 319  * This is better than #if(def) because it still lets the compiler
 320  * analyze the function for validity, and it works even for the
 321  * conditional use case.
 322  *
 323  * The macro UNUSED is set to 1 if the unused macro is meaningful,
 324  * otherwise 0; this may be useful in some #if statements.
 325  */
 326 #ifdef HAVE_FUNC_ATTRIBUTE_UNUSED
 327 # define unused __attribute__((unused))
 328 # define UNUSED 1
 329 #else
 330 # define unused
 331 # define UNUSED 0
 332 #endif
 333
 334 /* Determine probabilistically if something is a compile-time constant */
 335 #ifdef HAVE___BUILTIN_CONSTANT_P
 336 # if defined(__GNUC__) && (__GNUC__ >= 5)
 337 #  define is_constant(x) __builtin_constant_p((x))
 338 # else
 339 #  define is_constant(x) false
 340 # endif
 341 #else
 342 # define is_constant(x) false
 343 #endif
 344
 345 /*
 346  * If we can guarantee that a particular expression is constant, use it,
 347  * otherwise use a different version.
 348  */
 349 #if defined(__GNUC__) && (__GNUC__ >= 3)
 350 # define not_pedantic_start                             \
 351     _Pragma("GCC diagnostic push")                      \
 352     _Pragma("GCC diagnostic ignored \"-Wpedantic\"")
 353 # define not_pedantic_end                       \
 354     _Pragma("GCC diagnostic pop")
 355 #else
 356 # define not_pedantic_start
 357 # define not_pedantic_end
 358 #endif
 359
 360 #ifdef HAVE___BUILTIN_CHOOSE_EXPR
 361 # define if_constant(x,y) __builtin_choose_expr(is_constant(x),(x),(y))
 362 #else
 363 # define if_constant(x,y) (y)
 364 #endif
 365
 366 /*
 367  * The autoconf documentation states:
 368  *
 369  * `va_copy'
 370  *    The C99 standard provides `va_copy' for copying `va_list'
 371  *    variables.  It may be available in older environments too, though
 372  *    possibly as `__va_copy' (e.g., `gcc' in strict pre-C99 mode).
 373  *    These can be tested with `#ifdef'.  A fallback to `memcpy (&dst,
 374  *    &src, sizeof (va_list))' gives maximum portability.
 375  */
 376 #ifndef va_copy
 377 # ifdef __va_copy
 378 #  define va_copy(dst,src) __va_copy(dst,src)
 379 # else
 380 #  define va_copy(dst,src) memcpy(&(dst),&(src),sizeof(va_list))
 381 # endif
 382 #endif
 383
 384 /*
 385  * If SIZE_MAX is not defined, rely on size_t being unsigned
 386  */
 387 #ifndef SIZE_MAX
 388 # define SIZE_MAX (((size_t)0) - 1)
 389 #endif
 390
 391 /* Watcom doesn't handle switch statements with 64-bit types, hack around it */
 392 #ifdef __WATCOMC__
 393 # define BOGUS_CASE 0x76543210
 394
 395 static inline unsigned int watcom_switch_hack(uint64_t x)
 396 {
 397     if (x > (uint64_t)UINT_MAX)
 398         return BOGUS_CASE;
 399     else
 400         return (unsigned int)x;
 401 }
 402
 403 # define switch(x) switch(sizeof(x) > sizeof(unsigned int) \
 404                           ? watcom_switch_hack(x) : (unsigned int)(x))
 405
 406 /* This is to make sure BOGUS_CASE doesn't conflict with anything real... */
 407 # define default case BOGUS_CASE: default
 408 #endif
 409
 410 #endif  /* NASM_COMPILER_H */