sys/lib/libkern/libkern.h

   1 /*      $NetBSD: libkern.h,v 1.108 2013/08/28 16:20:38 riastradh Exp $  */
   2
   3 /*-
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)libkern.h   8.2 (Berkeley) 8/5/94
  32  */
  33
  34 #ifndef _LIB_LIBKERN_LIBKERN_H_
  35 #define _LIB_LIBKERN_LIBKERN_H_
  36
  37 #include <sys/types.h>
  38 #include <sys/inttypes.h>
  39 #include <sys/null.h>
  40
  41 #ifndef LIBKERN_INLINE
  42 #define LIBKERN_INLINE  static __inline
  43 #define LIBKERN_BODY
  44 #endif
  45
  46 LIBKERN_INLINE int imax(int, int) __unused;
  47 LIBKERN_INLINE int imin(int, int) __unused;
  48 LIBKERN_INLINE u_int max(u_int, u_int) __unused;
  49 LIBKERN_INLINE u_int min(u_int, u_int) __unused;
  50 LIBKERN_INLINE long lmax(long, long) __unused;
  51 LIBKERN_INLINE long lmin(long, long) __unused;
  52 LIBKERN_INLINE u_long ulmax(u_long, u_long) __unused;
  53 LIBKERN_INLINE u_long ulmin(u_long, u_long) __unused;
  54 LIBKERN_INLINE int abs(int) __unused;
  55
  56 LIBKERN_INLINE int isspace(int) __unused;
  57 LIBKERN_INLINE int isascii(int) __unused;
  58 LIBKERN_INLINE int isupper(int) __unused;
  59 LIBKERN_INLINE int islower(int) __unused;
  60 LIBKERN_INLINE int isalpha(int) __unused;
  61 LIBKERN_INLINE int isdigit(int) __unused;
  62 LIBKERN_INLINE int isxdigit(int) __unused;
  63 LIBKERN_INLINE int toupper(int) __unused;
  64 LIBKERN_INLINE int tolower(int) __unused;
  65
  66 #ifdef LIBKERN_BODY
  67 LIBKERN_INLINE int
  68 imax(int a, int b)
  69 {
  70         return (a > b ? a : b);
  71 }
  72 LIBKERN_INLINE int
  73 imin(int a, int b)
  74 {
  75         return (a < b ? a : b);
  76 }
  77 LIBKERN_INLINE long
  78 lmax(long a, long b)
  79 {
  80         return (a > b ? a : b);
  81 }
  82 LIBKERN_INLINE long
  83 lmin(long a, long b)
  84 {
  85         return (a < b ? a : b);
  86 }
  87 LIBKERN_INLINE u_int
  88 max(u_int a, u_int b)
  89 {
  90         return (a > b ? a : b);
  91 }
  92 LIBKERN_INLINE u_int
  93 min(u_int a, u_int b)
  94 {
  95         return (a < b ? a : b);
  96 }
  97 LIBKERN_INLINE u_long
  98 ulmax(u_long a, u_long b)
  99 {
 100         return (a > b ? a : b);
 101 }
 102 LIBKERN_INLINE u_long
 103 ulmin(u_long a, u_long b)
 104 {
 105         return (a < b ? a : b);
 106 }
 107
 108 LIBKERN_INLINE int
 109 abs(int j)
 110 {
 111         return(j < 0 ? -j : j);
 112 }
 113
 114 LIBKERN_INLINE int
 115 isspace(int ch)
 116 {
 117         return (ch == ' ' || (ch >= '\t' && ch <= '\r'));
 118 }
 119
 120 LIBKERN_INLINE int
 121 isascii(int ch)
 122 {
 123         return ((ch & ~0x7f) == 0);
 124 }
 125
 126 LIBKERN_INLINE int
 127 isupper(int ch)
 128 {
 129         return (ch >= 'A' && ch <= 'Z');
 130 }
 131
 132 LIBKERN_INLINE int
 133 islower(int ch)
 134 {
 135         return (ch >= 'a' && ch <= 'z');
 136 }
 137
 138 LIBKERN_INLINE int
 139 isalpha(int ch)
 140 {
 141         return (isupper(ch) || islower(ch));
 142 }
 143
 144 LIBKERN_INLINE int
 145 isdigit(int ch)
 146 {
 147         return (ch >= '0' && ch <= '9');
 148 }
 149
 150 LIBKERN_INLINE int
 151 isxdigit(int ch)
 152 {
 153         return (isdigit(ch) ||
 154             (ch >= 'A' && ch <= 'F') ||
 155             (ch >= 'a' && ch <= 'f'));
 156 }
 157
 158 LIBKERN_INLINE int
 159 toupper(int ch)
 160 {
 161         if (islower(ch))
 162                 return (ch - 0x20);
 163         return (ch);
 164 }
 165
 166 LIBKERN_INLINE int
 167 tolower(int ch)
 168 {
 169         if (isupper(ch))
 170                 return (ch + 0x20);
 171         return (ch);
 172 }
 173 #endif
 174
 175 #define __NULL_STMT             do { } while (/* CONSTCOND */ 0)
 176
 177 #define __KASSERTSTR  "kernel %sassertion \"%s\" failed: file \"%s\", line %d "
 178
 179 #ifdef NDEBUG                                           /* tradition! */
 180 #define assert(e)       ((void)0)
 181 #else
 182 #define assert(e)       (__predict_true((e)) ? (void)0 :                    \
 183                             kern_assert(__KASSERTSTR, "", #e, __FILE__, __LINE__))
 184 #endif
 185
 186 #ifdef __COVERITY__
 187 #ifndef DIAGNOSTIC
 188 #define DIAGNOSTIC
 189 #endif
 190 #endif
 191
 192 #define CTASSERT(x)             __CTASSERT(x)
 193 #define CTASSERT_SIGNED(x)      __CTASSERT(((typeof(x))-1) < 0)
 194 #define CTASSERT_UNSIGNED(x)    __CTASSERT(((typeof(x))-1) >= 0)
 195
 196 #ifndef DIAGNOSTIC
 197 #define _DIAGASSERT(a)  (void)0
 198 #ifdef lint
 199 #define KASSERTMSG(e, msg, ...) /* NOTHING */
 200 #define KASSERT(e)              /* NOTHING */
 201 #else /* !lint */
 202 #define KASSERTMSG(e, msg, ...) ((void)0)
 203 #define KASSERT(e)              ((void)0)
 204 #endif /* !lint */
 205 #else /* DIAGNOSTIC */
 206 #define _DIAGASSERT(a)  assert(a)
 207 #define KASSERTMSG(e, msg, ...)         \
 208                         (__predict_true((e)) ? (void)0 :                    \
 209                             kern_assert(__KASSERTSTR msg, "diagnostic ", #e,        \
 210                                 __FILE__, __LINE__, ## __VA_ARGS__))
 211
 212 #define KASSERT(e)      (__predict_true((e)) ? (void)0 :                    \
 213                             kern_assert(__KASSERTSTR, "diagnostic ", #e,            \
 214                                 __FILE__, __LINE__))
 215 #endif
 216
 217 #ifndef DEBUG
 218 #ifdef lint
 219 #define KDASSERTMSG(e,msg, ...) /* NOTHING */
 220 #define KDASSERT(e)             /* NOTHING */
 221 #else /* lint */
 222 #define KDASSERTMSG(e,msg, ...) ((void)0)
 223 #define KDASSERT(e)             ((void)0)
 224 #endif /* lint */
 225 #else
 226 #define KDASSERTMSG(e, msg, ...)        \
 227                         (__predict_true((e)) ? (void)0 :                    \
 228                             kern_assert(__KASSERTSTR msg, "debugging ", #e,         \
 229                                 __FILE__, __LINE__, ## __VA_ARGS__))
 230
 231 #define KDASSERT(e)     (__predict_true((e)) ? (void)0 :                    \
 232                             kern_assert(__KASSERTSTR, "debugging ", #e,     \
 233                                 __FILE__, __LINE__))
 234 #endif
 235
 236 /*
 237  * XXX: For compatibility we use SMALL_RANDOM by default.
 238  */
 239 #define SMALL_RANDOM
 240
 241 #ifndef offsetof
 242 #if __GNUC_PREREQ__(4, 0)
 243 #define offsetof(type, member)  __builtin_offsetof(type, member)
 244 #else
 245 #define offsetof(type, member) \
 246     ((size_t)(unsigned long)(&(((type *)0)->member)))
 247 #endif
 248 #endif
 249
 250 #define MTPRNG_RLEN             624
 251 struct mtprng_state {
 252         unsigned int mt_idx;
 253         uint32_t mt_elem[MTPRNG_RLEN];
 254         uint32_t mt_count;
 255         uint32_t mt_sparse[3];
 256 };
 257
 258 /* Prototypes for which GCC built-ins exist. */
 259 void    *memcpy(void *, const void *, size_t);
 260 int      memcmp(const void *, const void *, size_t);
 261 void    *memset(void *, int, size_t);
 262 #if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
 263 #define memcpy(d, s, l)         __builtin_memcpy(d, s, l)
 264 #define memcmp(a, b, l)         __builtin_memcmp(a, b, l)
 265 #endif
 266 #if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
 267 #define memset(d, v, l)         __builtin_memset(d, v, l)
 268 #endif
 269
 270 char    *strcpy(char *, const char *);
 271 int      strcmp(const char *, const char *);
 272 size_t   strlen(const char *);
 273 size_t   strnlen(const char *, size_t);
 274 char    *strsep(char **, const char *);
 275 #if __GNUC_PREREQ__(2, 95) && !defined(_STANDALONE)
 276 #define strcpy(d, s)            __builtin_strcpy(d, s)
 277 #define strcmp(a, b)            __builtin_strcmp(a, b)
 278 #define strlen(a)               __builtin_strlen(a)
 279 #endif
 280
 281 /* Functions for which we always use built-ins. */
 282 #ifdef __GNUC__
 283 #define alloca(s)               __builtin_alloca(s)
 284 #endif
 285
 286 /* These exist in GCC 3.x, but we don't bother. */
 287 char    *strcat(char *, const char *);
 288 char    *strncpy(char *, const char *, size_t);
 289 int      strncmp(const char *, const char *, size_t);
 290 char    *strchr(const char *, int);
 291 char    *strrchr(const char *, int);
 292
 293 char    *strstr(const char *, const char *);
 294
 295 /*
 296  * ffs is an instruction on vax.
 297  */
 298 int      ffs(int);
 299 #if __GNUC_PREREQ__(2, 95) && (!defined(__vax__) || __GNUC_PREREQ__(4,1))
 300 #define ffs(x)          __builtin_ffs(x)
 301 #endif
 302
 303 void     kern_assert(const char *, ...)
 304     __attribute__((__format__(__printf__, 1, 2)));
 305 unsigned int
 306         bcdtobin(unsigned int);
 307 unsigned int
 308         bintobcd(unsigned int);
 309 u_int32_t
 310         inet_addr(const char *);
 311 struct in_addr;
 312 int     inet_aton(const char *, struct in_addr *);
 313 char    *intoa(u_int32_t);
 314 #define inet_ntoa(a) intoa((a).s_addr)
 315 void    *memchr(const void *, int, size_t);
 316 void    *memmove(void *, const void *, size_t);
 317 int      pmatch(const char *, const char *, const char **);
 318 #ifndef SMALL_RANDOM
 319 void     srandom(unsigned long);
 320 char    *initstate(unsigned long, char *, size_t);
 321 char    *setstate(char *);
 322 #endif /* SMALL_RANDOM */
 323 long     random(void);
 324 void     mtprng_init32(struct mtprng_state *, uint32_t);
 325 void     mtprng_initarray(struct mtprng_state *, const uint32_t *, size_t);
 326 uint32_t mtprng_rawrandom(struct mtprng_state *);
 327 uint32_t mtprng_random(struct mtprng_state *);
 328 int      scanc(u_int, const u_char *, const u_char *, int);
 329 int      skpc(int, size_t, u_char *);
 330 int      strcasecmp(const char *, const char *);
 331 size_t   strlcpy(char *, const char *, size_t);
 332 size_t   strlcat(char *, const char *, size_t);
 333 int      strncasecmp(const char *, const char *, size_t);
 334 u_long   strtoul(const char *, char **, int);
 335 long long strtoll(const char *, char **, int);
 336 unsigned long long strtoull(const char *, char **, int);
 337 uintmax_t strtoumax(const char *, char **, int);
 338 int      snprintb(char *, size_t, const char *, uint64_t);
 339 int      snprintb_m(char *, size_t, const char *, uint64_t, size_t);
 340 int      kheapsort(void *, size_t, size_t, int (*)(const void *, const void *),
 341                    void *);
 342 uint32_t crc32(uint32_t, const uint8_t *, size_t);
 343 unsigned int    popcount(unsigned int) __constfunc;
 344 unsigned int    popcountl(unsigned long) __constfunc;
 345 unsigned int    popcountll(unsigned long long) __constfunc;
 346 unsigned int    popcount32(uint32_t) __constfunc;
 347 unsigned int    popcount64(uint64_t) __constfunc;
 348
 349 void    *explicit_memset(void *, int, size_t);
 350 int     consttime_memequal(const void *, const void *, size_t);
 351 #endif /* !_LIB_LIBKERN_LIBKERN_H_ */