include/sys/cdefs.h

   1 /*      $NetBSD: cdefs.h,v 1.78 2009/10/02 21:05:28 christos Exp $      */
   2
   3 /*
   4  * Copyright (c) 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Berkeley Software Design, Inc.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)cdefs.h     8.8 (Berkeley) 1/9/95
  35  */
  36
  37 #ifndef _SYS_CDEFS_H_
  38 #define _SYS_CDEFS_H_
  39
  40 /*
  41  * Macro to test if we're using a GNU C compiler of a specific vintage
  42  * or later, for e.g. features that appeared in a particular version
  43  * of GNU C.  Usage:
  44  *
  45  *      #if __GNUC_PREREQ__(major, minor)
  46  *      ...cool feature...
  47  *      #else
  48  *      ...delete feature...
  49  *      #endif
  50  */
  51 #ifdef __GNUC__
  52 #define __GNUC_PREREQ__(x, y)                                           \
  53         ((__GNUC__ == (x) && __GNUC_MINOR__ >= (y)) ||                  \
  54          (__GNUC__ > (x)))
  55 #else
  56 #define __GNUC_PREREQ__(x, y)   0
  57 #endif
  58
  59 #if 0
  60 #include <machine/cdefs.h>
  61 #ifdef __ELF__
  62 #include <sys/cdefs_elf.h>
  63 #else
  64 #include <sys/cdefs_aout.h>
  65 #endif
  66 #endif
  67
  68 #if defined(__cplusplus)
  69 #define __BEGIN_DECLS           extern "C" {
  70 #define __END_DECLS             }
  71 #define __static_cast(x,y)      static_cast<x>(y)
  72 #else
  73 #define __BEGIN_DECLS
  74 #define __END_DECLS
  75 #define __static_cast(x,y)      (x)y
  76 #endif
  77
  78 /*
  79  * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
  80  * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
  81  * The __CONCAT macro is a bit tricky -- make sure you don't put spaces
  82  * in between its arguments.  __CONCAT can also concatenate double-quoted
  83  * strings produced by the __STRING macro, but this only works with ANSI C.
  84  */
  85
  86 #define ___STRING(x)    __STRING(x)
  87 #define ___CONCAT(x,y)  __CONCAT(x,y)
  88
  89 #if __STDC__ || defined(__cplusplus)
  90 #define __P(protos)     protos          /* full-blown ANSI C */
  91 #define __CONCAT(x,y)   x ## y
  92 #define __STRING(x)     #x
  93
  94 #define __const         const           /* define reserved names to standard */
  95 #define __signed        signed
  96 #define __volatile      volatile
  97 #if defined(__cplusplus) || defined(__PCC__)
  98 #define __inline        inline          /* convert to C++/C99 keyword */
  99 #else
 100 #if !defined(__GNUC__) && !defined(__lint__)
 101 #define __inline                        /* delete GCC keyword */
 102 #endif /* !__GNUC__  && !__lint__ */
 103 #endif /* !__cplusplus */
 104
 105 #else   /* !(__STDC__ || __cplusplus) */
 106 #define __P(protos)     ()              /* traditional C preprocessor */
 107 #define __CONCAT(x,y)   x/**/y
 108 #define __STRING(x)     "x"
 109
 110 #ifndef __GNUC__
 111 #define __const                         /* delete pseudo-ANSI C keywords */
 112 #define __inline
 113 #define __signed
 114 #define __volatile
 115 #endif  /* !__GNUC__ */
 116
 117 /*
 118  * In non-ANSI C environments, new programs will want ANSI-only C keywords
 119  * deleted from the program and old programs will want them left alone.
 120  * Programs using the ANSI C keywords const, inline etc. as normal
 121  * identifiers should define -DNO_ANSI_KEYWORDS.
 122  */
 123 #ifndef NO_ANSI_KEYWORDS
 124 #define const           __const         /* convert ANSI C keywords */
 125 #define inline          __inline
 126 #define signed          __signed
 127 #define volatile        __volatile
 128 #endif /* !NO_ANSI_KEYWORDS */
 129 #endif  /* !(__STDC__ || __cplusplus) */
 130
 131 /*
 132  * Used for internal auditing of the NetBSD source tree.
 133  */
 134 #ifdef __AUDIT__
 135 #define __aconst        __const
 136 #else
 137 #define __aconst
 138 #endif
 139
 140 /*
 141  * The following macro is used to remove const cast-away warnings
 142  * from gcc -Wcast-qual; it should be used with caution because it
 143  * can hide valid errors; in particular most valid uses are in
 144  * situations where the API requires it, not to cast away string
 145  * constants. We don't use *intptr_t on purpose here and we are
 146  * explicit about unsigned long so that we don't have additional
 147  * dependencies.
 148  */
 149 #define __UNCONST(a)    ((void *)(unsigned long)(const void *)(a))
 150
 151 /*
 152  * The following macro is used to remove the volatile cast-away warnings
 153  * from gcc -Wcast-qual; as above it should be used with caution
 154  * because it can hide valid errors or warnings.  Valid uses include
 155  * making it possible to pass a volatile pointer to memset().
 156  * For the same reasons as above, we use unsigned long and not intptr_t.
 157  */
 158 #define __UNVOLATILE(a) ((void *)(unsigned long)(volatile void *)(a))
 159
 160 /*
 161  * GCC2 provides __extension__ to suppress warnings for various GNU C
 162  * language extensions under "-ansi -pedantic".
 163  */
 164 #if !__GNUC_PREREQ__(2, 0)
 165 #define __extension__           /* delete __extension__ if non-gcc or gcc1 */
 166 #endif
 167
 168 /*
 169  * GCC1 and some versions of GCC2 declare dead (non-returning) and
 170  * pure (no side effects) functions using "volatile" and "const";
 171  * unfortunately, these then cause warnings under "-ansi -pedantic".
 172  * GCC2 uses a new, peculiar __attribute__((attrs)) style.  All of
 173  * these work for GNU C++ (modulo a slight glitch in the C++ grammar
 174  * in the distribution version of 2.5.5).
 175  *
 176  * GCC defines a pure function as depending only on its arguments and
 177  * global variables.  Typical examples are strlen and sqrt.
 178  *
 179  * GCC defines a const function as depending only on its arguments.
 180  * Therefore calling a const function again with identical arguments
 181  * will always produce the same result.
 182  *
 183  * Rounding modes for floating point operations are considered global
 184  * variables and prevent sqrt from being a const function.
 185  *
 186  * Calls to const functions can be optimised away and moved around
 187  * without limitations.
 188  */
 189 #if !__GNUC_PREREQ__(2, 0)
 190 #define __attribute__(x)
 191 #endif
 192
 193 #if __GNUC_PREREQ__(2, 5)
 194 #define __dead          __attribute__((__noreturn__))
 195 #elif defined(__GNUC__)
 196 #define __dead          __volatile
 197 #else
 198 #define __dead
 199 #endif
 200
 201 #if __GNUC_PREREQ__(2, 96)
 202 #define __pure          __attribute__((__pure__))
 203 #elif defined(__GNUC__)
 204 #define __pure          __const
 205 #else
 206 #define __pure
 207 #endif
 208
 209 #if __GNUC_PREREQ__(2, 5)
 210 #define __constfunc     __attribute__((__const__))
 211 #else
 212 #define __constfunc
 213 #endif
 214
 215 #if __GNUC_PREREQ__(3, 0)
 216 #define __noinline      __attribute__((__noinline__))
 217 #else
 218 #define __noinline      /* nothing */
 219 #endif
 220
 221 #if __GNUC_PREREQ__(2, 7)
 222 #define __unused        __attribute__((__unused__))
 223 #else
 224 #define __unused        /* delete */
 225 #endif
 226
 227 #if __GNUC_PREREQ__(3, 1)
 228 #define __used          __attribute__((__used__))
 229 #else
 230 #define __used          __unused
 231 #endif
 232
 233 #if defined(__lint__)
 234 #define __packed        __packed
 235 #define __aligned(x)    /* delete */
 236 #define __section(x)    /* delete */
 237 #elif __GNUC_PREREQ__(2, 7)
 238 #define __packed        __attribute__((__packed__))
 239 #define __aligned(x)    __attribute__((__aligned__(x)))
 240 #define __section(x)    __attribute__((__section__(x)))
 241 #elif defined(__PCC__)
 242 #define __packed        _Pragma("packed 1")
 243 #define __aligned(x)    _Pragma("aligned " __STRING(x))
 244 #define __section(x)    _Pragma("section " ## x)
 245 #else
 246 #define __packed        error: no __packed for this compiler
 247 #define __aligned(x)    error: no __aligned for this compiler
 248 #define __section(x)    error: no __section for this compiler
 249 #endif
 250
 251 /*
 252  * C99 defines the restrict type qualifier keyword, which was made available
 253  * in GCC 2.92.
 254  */
 255 #if defined(__lint__)
 256 #define __restrict      /* delete __restrict when not supported */
 257 #elif __STDC_VERSION__ >= 199901L
 258 #define __restrict      restrict
 259 #elif !__GNUC_PREREQ__(2, 92)
 260 #define __restrict      /* delete __restrict when not supported */
 261 #endif
 262
 263 /*
 264  * C99 defines __func__ predefined identifier, which was made available
 265  * in GCC 2.95.
 266  */
 267 #if !(__STDC_VERSION__ >= 199901L)
 268 #if __GNUC_PREREQ__(2, 6)
 269 #define __func__        __PRETTY_FUNCTION__
 270 #elif __GNUC_PREREQ__(2, 4)
 271 #define __func__        __FUNCTION__
 272 #else
 273 #define __func__        ""
 274 #endif
 275 #endif /* !(__STDC_VERSION__ >= 199901L) */
 276
 277 #if defined(_KERNEL)
 278 #if defined(NO_KERNEL_RCSIDS)
 279 #undef __KERNEL_RCSID
 280 #define __KERNEL_RCSID(_n, _s)          /* nothing */
 281 #endif /* NO_KERNEL_RCSIDS */
 282 #endif /* _KERNEL */
 283
 284 #if 0
 285 #if !defined(_STANDALONE) && !defined(_KERNEL)
 286 #if defined(__GNUC__) || defined(__PCC__)
 287 #define __RENAME(x)     ___RENAME(x)
 288 #else
 289 #ifdef __lint__
 290 #define __RENAME(x)     __symbolrename(x)
 291 #else
 292 #error "No function renaming possible"
 293 #endif /* __lint__ */
 294 #endif /* __GNUC__ */
 295 #else /* _STANDALONE || _KERNEL */
 296 #define __RENAME(x)     no renaming in kernel or standalone environment
 297 #endif
 298 #endif
 299 /*
 300  * A barrier to stop the optimizer from moving code or assume live
 301  * register values. This is gcc specific, the version is more or less
 302  * arbitrary, might work with older compilers.
 303  */
 304 #if __GNUC_PREREQ__(2, 95)
 305 #define __insn_barrier()        __asm __volatile("":::"memory")
 306 #else
 307 #define __insn_barrier()        /* */
 308 #endif
 309
 310 /*
 311  * GNU C version 2.96 adds explicit branch prediction so that
 312  * the CPU back-end can hint the processor and also so that
 313  * code blocks can be reordered such that the predicted path
 314  * sees a more linear flow, thus improving cache behavior, etc.
 315  *
 316  * The following two macros provide us with a way to use this
 317  * compiler feature.  Use __predict_true() if you expect the expression
 318  * to evaluate to true, and __predict_false() if you expect the
 319  * expression to evaluate to false.
 320  *
 321  * A few notes about usage:
 322  *
 323  *      * Generally, __predict_false() error condition checks (unless
 324  *        you have some _strong_ reason to do otherwise, in which case
 325  *        document it), and/or __predict_true() `no-error' condition
 326  *        checks, assuming you want to optimize for the no-error case.
 327  *
 328  *      * Other than that, if you don't know the likelihood of a test
 329  *        succeeding from empirical or other `hard' evidence, don't
 330  *        make predictions.
 331  *
 332  *      * These are meant to be used in places that are run `a lot'.
 333  *        It is wasteful to make predictions in code that is run
 334  *        seldomly (e.g. at subsystem initialization time) as the
 335  *        basic block reordering that this affects can often generate
 336  *        larger code.
 337  */
 338 #if __GNUC_PREREQ__(2, 96)
 339 #define __predict_true(exp)     __builtin_expect((exp) != 0, 1)
 340 #define __predict_false(exp)    __builtin_expect((exp) != 0, 0)
 341 #else
 342 #define __predict_true(exp)     (exp)
 343 #define __predict_false(exp)    (exp)
 344 #endif
 345
 346 /*
 347  * Compiler-dependent macros to declare that functions take printf-like
 348  * or scanf-like arguments.  They are null except for versions of gcc
 349  * that are known to support the features properly (old versions of gcc-2
 350  * didn't permit keeping the keywords out of the application namespace).
 351  */
 352 #if __GNUC_PREREQ__(2, 7)
 353 #define __printflike(fmtarg, firstvararg)       \
 354             __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
 355 #define __scanflike(fmtarg, firstvararg)        \
 356             __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
 357 #define __format_arg(fmtarg)    __attribute__((__format_arg__ (fmtarg)))
 358 #else
 359 #define __printflike(fmtarg, firstvararg)       /* nothing */
 360 #define __scanflike(fmtarg, firstvararg)        /* nothing */
 361 #define __format_arg(fmtarg)                    /* nothing */
 362 #endif
 363
 364 /*
 365  * Macros for manipulating "link sets".  Link sets are arrays of pointers
 366  * to objects, which are gathered up by the linker.
 367  *
 368  * Object format-specific code has provided us with the following macros:
 369  *
 370  *      __link_set_add_text(set, sym)
 371  *              Add a reference to the .text symbol `sym' to `set'.
 372  *
 373  *      __link_set_add_rodata(set, sym)
 374  *              Add a reference to the .rodata symbol `sym' to `set'.
 375  *
 376  *      __link_set_add_data(set, sym)
 377  *              Add a reference to the .data symbol `sym' to `set'.
 378  *
 379  *      __link_set_add_bss(set, sym)
 380  *              Add a reference to the .bss symbol `sym' to `set'.
 381  *
 382  *      __link_set_decl(set, ptype)
 383  *              Provide an extern declaration of the set `set', which
 384  *              contains an array of the pointer type `ptype'.  This
 385  *              macro must be used by any code which wishes to reference
 386  *              the elements of a link set.
 387  *
 388  *      __link_set_start(set)
 389  *              This points to the first slot in the link set.
 390  *
 391  *      __link_set_end(set)
 392  *              This points to the (non-existent) slot after the last
 393  *              entry in the link set.
 394  *
 395  *      __link_set_count(set)
 396  *              Count the number of entries in link set `set'.
 397  *
 398  * In addition, we provide the following macros for accessing link sets:
 399  *
 400  *      __link_set_foreach(pvar, set)
 401  *              Iterate over the link set `set'.  Because a link set is
 402  *              an array of pointers, pvar must be declared as "type **pvar",
 403  *              and the actual entry accessed as "*pvar".
 404  *
 405  *      __link_set_entry(set, idx)
 406  *              Access the link set entry at index `idx' from set `set'.
 407  */
 408 #define __link_set_foreach(pvar, set)                                   \
 409         for (pvar = __link_set_start(set); pvar < __link_set_end(set); pvar++)
 410
 411 #define __link_set_entry(set, idx)      (__link_set_begin(set)[idx])
 412
 413 /*
 414  * Return the number of elements in a statically-allocated array,
 415  * __x.
 416  */
 417 #define __arraycount(__x)       (sizeof(__x) / sizeof(__x[0]))
 418
 419 /* __BIT(n): nth bit, where __BIT(0) == 0x1. */
 420 #define __BIT(__n)      \
 421     (((uintmax_t)(__n) >= NBBY * sizeof(uintmax_t)) ? 0 : ((uintmax_t)1 << (uintmax_t)(__n)))
 422
 423 /* __BITS(m, n): bits m through n, m < n. */
 424 #define __BITS(__m, __n)        \
 425         ((__BIT(MAX((__m), (__n)) + 1) - 1) ^ (__BIT(MIN((__m), (__n))) - 1))
 426
 427 /* find least significant bit that is set */
 428 #define __LOWEST_SET_BIT(__mask) ((((__mask) - 1) & (__mask)) ^ (__mask))
 429
 430 #define __PRIuBIT       PRIuMAX
 431 #define __PRIuBITS      __PRIuBIT
 432
 433 #define __PRIxBIT       PRIxMAX
 434 #define __PRIxBITS      __PRIxBIT
 435
 436 #define __SHIFTOUT(__x, __mask) (((__x) & (__mask)) / __LOWEST_SET_BIT(__mask))
 437 #define __SHIFTIN(__x, __mask) ((__x) * __LOWEST_SET_BIT(__mask))
 438 #define __SHIFTOUT_MASK(__mask) __SHIFTOUT((__mask), (__mask))
 439
 440 /*
 441  * Only to be used in other headers that are included from both c or c++
 442  * NOT to be used in code.
 443  */
 444 #ifdef __cplusplus
 445 #define __CAST(__dt, __st)      static_cast<__dt>(__st)
 446 #else
 447 #define __CAST(__dt, __st)      ((__dt)(__st))
 448 #endif
 449
 450 #endif /* !_SYS_CDEFS_H_ */