contrib/elftoolchain/common/_elftc.h

   1 /*-
   2  * Copyright (c) 2009 Joseph Koshy
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $Id: _elftc.h 3446 2016-05-03 01:31:17Z emaste $
  27  */
  28
  29 /**
  30  ** Miscellaneous definitions needed by multiple components.
  31  **/
  32
  33 #ifndef _ELFTC_H
  34 #define _ELFTC_H
  35
  36 #ifndef NULL
  37 #define NULL    ((void *) 0)
  38 #endif
  39
  40 #ifndef offsetof
  41 #define offsetof(T, M)          ((int) &((T*) 0) -> M)
  42 #endif
  43
  44 /* --QUEUE-MACROS-- [[ */
  45
  46 /*
  47  * Supply macros missing from <sys/queue.h>
  48  */
  49
  50 /*
  51  * Copyright (c) 1991, 1993
  52  *      The Regents of the University of California.  All rights reserved.
  53  *
  54  * Redistribution and use in source and binary forms, with or without
  55  * modification, are permitted provided that the following conditions
  56  * are met:
  57  * 1. Redistributions of source code must retain the above copyright
  58  *    notice, this list of conditions and the following disclaimer.
  59  * 2. Redistributions in binary form must reproduce the above copyright
  60  *    notice, this list of conditions and the following disclaimer in the
  61  *    documentation and/or other materials provided with the distribution.
  62  * 3. Neither the name of the University nor the names of its contributors
  63  *    may be used to endorse or promote products derived from this software
  64  *    without specific prior written permission.
  65  *
  66  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  67  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  69  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  70  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  71  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  72  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  73  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  74  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  75  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  76  * SUCH DAMAGE.
  77  */
  78
  79 #ifndef LIST_FOREACH_SAFE
  80 #define LIST_FOREACH_SAFE(var, head, field, tvar)               \
  81         for ((var) = LIST_FIRST((head));                        \
  82             (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
  83             (var) = (tvar))
  84 #endif
  85
  86 #ifndef SLIST_FOREACH_SAFE
  87 #define SLIST_FOREACH_SAFE(var, head, field, tvar)              \
  88         for ((var) = SLIST_FIRST((head));                       \
  89             (var) && ((tvar) = SLIST_NEXT((var), field), 1);    \
  90             (var) = (tvar))
  91 #endif
  92
  93 #ifndef STAILQ_CONCAT
  94 #define STAILQ_CONCAT(head1, head2) do {                        \
  95         if (!STAILQ_EMPTY((head2))) {                           \
  96                 *(head1)->stqh_last = (head2)->stqh_first;      \
  97                 (head1)->stqh_last = (head2)->stqh_last;        \
  98                 STAILQ_INIT((head2));                           \
  99         }                                                       \
 100 } while (/*CONSTCOND*/0)
 101 #endif
 102
 103 #ifndef STAILQ_EMPTY
 104 #define STAILQ_EMPTY(head)      ((head)->stqh_first == NULL)
 105 #endif
 106
 107 #ifndef STAILQ_ENTRY
 108 #define STAILQ_ENTRY(type)                                      \
 109 struct {                                                        \
 110         struct type *stqe_next; /* next element */              \
 111 }
 112 #endif
 113
 114 #ifndef STAILQ_FIRST
 115 #define STAILQ_FIRST(head)      ((head)->stqh_first)
 116 #endif
 117
 118 #ifndef STAILQ_HEAD
 119 #define STAILQ_HEAD(name, type)                                 \
 120 struct name {                                                   \
 121         struct type *stqh_first; /* first element */            \
 122         struct type **stqh_last; /* addr of last next element */ \
 123 }
 124 #endif
 125
 126 #ifndef STAILQ_HEAD_INITIALIZER
 127 #define STAILQ_HEAD_INITIALIZER(head)                           \
 128         { NULL, &(head).stqh_first }
 129 #endif
 130
 131 #ifndef STAILQ_FOREACH
 132 #define STAILQ_FOREACH(var, head, field)                        \
 133         for ((var) = ((head)->stqh_first);                      \
 134                 (var);                                          \
 135                 (var) = ((var)->field.stqe_next))
 136 #endif
 137
 138 #ifndef STAILQ_FOREACH_SAFE
 139 #define STAILQ_FOREACH_SAFE(var, head, field, tvar)             \
 140        for ((var) = STAILQ_FIRST((head));                       \
 141             (var) && ((tvar) = STAILQ_NEXT((var), field), 1);   \
 142             (var) = (tvar))
 143 #endif
 144
 145 #ifndef STAILQ_INIT
 146 #define STAILQ_INIT(head) do {                                  \
 147         (head)->stqh_first = NULL;                              \
 148         (head)->stqh_last = &(head)->stqh_first;                \
 149 } while (/*CONSTCOND*/0)
 150 #endif
 151
 152 #ifndef STAILQ_INSERT_HEAD
 153 #define STAILQ_INSERT_HEAD(head, elm, field) do {                       \
 154         if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)      \
 155                 (head)->stqh_last = &(elm)->field.stqe_next;            \
 156         (head)->stqh_first = (elm);                                     \
 157 } while (/*CONSTCOND*/0)
 158 #endif
 159
 160 #ifndef STAILQ_INSERT_TAIL
 161 #define STAILQ_INSERT_TAIL(head, elm, field) do {                       \
 162         (elm)->field.stqe_next = NULL;                                  \
 163         *(head)->stqh_last = (elm);                                     \
 164         (head)->stqh_last = &(elm)->field.stqe_next;                    \
 165 } while (/*CONSTCOND*/0)
 166 #endif
 167
 168 #ifndef STAILQ_INSERT_AFTER
 169 #define STAILQ_INSERT_AFTER(head, listelm, elm, field) do {             \
 170         if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
 171                 (head)->stqh_last = &(elm)->field.stqe_next;            \
 172         (listelm)->field.stqe_next = (elm);                             \
 173 } while (/*CONSTCOND*/0)
 174 #endif
 175
 176 #ifndef STAILQ_LAST
 177 #define STAILQ_LAST(head, type, field)                                  \
 178         (STAILQ_EMPTY((head)) ?                                 \
 179             NULL : ((struct type *)(void *)                             \
 180             ((char *)((head)->stqh_last) - offsetof(struct type, field))))
 181 #endif
 182
 183 #ifndef STAILQ_NEXT
 184 #define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
 185 #endif
 186
 187 #ifndef STAILQ_REMOVE
 188 #define STAILQ_REMOVE(head, elm, type, field) do {                      \
 189         if ((head)->stqh_first == (elm)) {                              \
 190                 STAILQ_REMOVE_HEAD((head), field);                      \
 191         } else {                                                        \
 192                 struct type *curelm = (head)->stqh_first;               \
 193                 while (curelm->field.stqe_next != (elm))                \
 194                         curelm = curelm->field.stqe_next;               \
 195                 if ((curelm->field.stqe_next =                          \
 196                         curelm->field.stqe_next->field.stqe_next) == NULL) \
 197                             (head)->stqh_last = &(curelm)->field.stqe_next; \
 198         }                                                               \
 199 } while (/*CONSTCOND*/0)
 200 #endif
 201
 202 #ifndef STAILQ_REMOVE_HEAD
 203 #define STAILQ_REMOVE_HEAD(head, field) do {                            \
 204         if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \
 205             NULL)                                                       \
 206                 (head)->stqh_last = &(head)->stqh_first;                \
 207 } while (/*CONSTCOND*/0)
 208 #endif
 209
 210 /*
 211  * The STAILQ_SORT macro is adapted from Simon Tatham's O(n*log(n))
 212  * mergesort algorithm.
 213  */
 214 #ifndef STAILQ_SORT
 215 #define STAILQ_SORT(head, type, field, cmp) do {                        \
 216         STAILQ_HEAD(, type) _la, _lb;                                   \
 217         struct type *_p, *_q, *_e;                                      \
 218         int _i, _sz, _nmerges, _psz, _qsz;                              \
 219                                                                         \
 220         _sz = 1;                                                        \
 221         do {                                                            \
 222                 _nmerges = 0;                                           \
 223                 STAILQ_INIT(&_lb);                                      \
 224                 while (!STAILQ_EMPTY((head))) {                         \
 225                         _nmerges++;                                     \
 226                         STAILQ_INIT(&_la);                              \
 227                         _psz = 0;                                       \
 228                         for (_i = 0; _i < _sz && !STAILQ_EMPTY((head)); \
 229                              _i++) {                                    \
 230                                 _e = STAILQ_FIRST((head));              \
 231                                 if (_e == NULL)                         \
 232                                         break;                          \
 233                                 _psz++;                                 \
 234                                 STAILQ_REMOVE_HEAD((head), field);      \
 235                                 STAILQ_INSERT_TAIL(&_la, _e, field);    \
 236                         }                                               \
 237                         _p = STAILQ_FIRST(&_la);                        \
 238                         _qsz = _sz;                                     \
 239                         _q = STAILQ_FIRST((head));                      \
 240                         while (_psz > 0 || (_qsz > 0 && _q != NULL)) {  \
 241                                 if (_psz == 0) {                        \
 242                                         _e = _q;                        \
 243                                         _q = STAILQ_NEXT(_q, field);    \
 244                                         STAILQ_REMOVE_HEAD((head),      \
 245                                             field);                     \
 246                                         _qsz--;                         \
 247                                 } else if (_qsz == 0 || _q == NULL) {   \
 248                                         _e = _p;                        \
 249                                         _p = STAILQ_NEXT(_p, field);    \
 250                                         STAILQ_REMOVE_HEAD(&_la, field);\
 251                                         _psz--;                         \
 252                                 } else if (cmp(_p, _q) <= 0) {          \
 253                                         _e = _p;                        \
 254                                         _p = STAILQ_NEXT(_p, field);    \
 255                                         STAILQ_REMOVE_HEAD(&_la, field);\
 256                                         _psz--;                         \
 257                                 } else {                                \
 258                                         _e = _q;                        \
 259                                         _q = STAILQ_NEXT(_q, field);    \
 260                                         STAILQ_REMOVE_HEAD((head),      \
 261                                             field);                     \
 262                                         _qsz--;                         \
 263                                 }                                       \
 264                                 STAILQ_INSERT_TAIL(&_lb, _e, field);    \
 265                         }                                               \
 266                 }                                                       \
 267                 (head)->stqh_first = _lb.stqh_first;                    \
 268                 (head)->stqh_last = _lb.stqh_last;                      \
 269                 _sz *= 2;                                               \
 270         } while (_nmerges > 1);                                         \
 271 } while (/*CONSTCOND*/0)
 272 #endif
 273
 274 #ifndef TAILQ_FOREACH_SAFE
 275 #define TAILQ_FOREACH_SAFE(var, head, field, tvar)                      \
 276         for ((var) = TAILQ_FIRST((head));                               \
 277             (var) && ((tvar) = TAILQ_NEXT((var), field), 1);            \
 278             (var) = (tvar))
 279 #endif
 280
 281 /* ]] --QUEUE-MACROS-- */
 282
 283 /*
 284  * VCS Ids.
 285  */
 286
 287 #ifndef ELFTC_VCSID
 288
 289 #if defined(__DragonFly__)
 290 #define ELFTC_VCSID(ID)         __RCSID(ID)
 291 #endif
 292
 293 #if defined(__FreeBSD__)
 294 #define ELFTC_VCSID(ID)         __FBSDID(ID)
 295 #endif
 296
 297 #if defined(__APPLE__) || defined(__GLIBC__) || defined(__GNU__) || \
 298     defined(__linux__)
 299 #if defined(__GNUC__)
 300 #define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
 301 #else
 302 #define ELFTC_VCSID(ID)         /**/
 303 #endif
 304 #endif
 305
 306 #if defined(__minix)
 307 #if defined(__GNUC__)
 308 #define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
 309 #else
 310 #define ELFTC_VCSID(ID)         /**/
 311 #endif  /* __GNU__ */
 312 #endif
 313
 314 #if defined(__NetBSD__)
 315 #define ELFTC_VCSID(ID)         __RCSID(ID)
 316 #endif
 317
 318 #if defined(__OpenBSD__)
 319 #if defined(__GNUC__)
 320 #define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
 321 #else
 322 #define ELFTC_VCSID(ID)         /**/
 323 #endif  /* __GNUC__ */
 324 #endif
 325
 326 #endif  /* ELFTC_VCSID */
 327
 328 /*
 329  * Provide an equivalent for getprogname(3).
 330  */
 331
 332 #ifndef ELFTC_GETPROGNAME
 333
 334 #if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \
 335     defined(__minix) || defined(__NetBSD__)
 336
 337 #include <stdlib.h>
 338
 339 #define ELFTC_GETPROGNAME()     getprogname()
 340
 341 #endif  /* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */
 342
 343
 344 #if defined(__GLIBC__) || defined(__linux__)
 345 #ifndef _GNU_SOURCE
 346 /*
 347  * GLIBC based systems have a global 'char *' pointer referencing
 348  * the executable's name.
 349  */
 350 extern const char *program_invocation_short_name;
 351 #endif  /* !_GNU_SOURCE */
 352
 353 #define ELFTC_GETPROGNAME()     program_invocation_short_name
 354
 355 #endif  /* __GLIBC__ || __linux__ */
 356
 357
 358 #if defined(__OpenBSD__)
 359
 360 extern const char *__progname;
 361
 362 #define ELFTC_GETPROGNAME()     __progname
 363
 364 #endif  /* __OpenBSD__ */
 365
 366 #endif  /* ELFTC_GETPROGNAME */
 367
 368
 369 /**
 370  ** Per-OS configuration.
 371  **/
 372
 373 #if defined(__APPLE__)
 374
 375 #include <libkern/OSByteOrder.h>
 376 #define htobe32(x)      OSSwapHostToBigInt32(x)
 377 #define htole32(x)      OSSwapHostToLittleInt32(x)
 378 #ifndef roundup2
 379 #define roundup2        roundup
 380 #endif
 381
 382 #define ELFTC_BYTE_ORDER                        __DARWIN_BYTE_ORDER
 383 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          __DARWIN_LITTLE_ENDIAN
 384 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             __DARWIN_BIG_ENDIAN
 385
 386 #define ELFTC_HAVE_MMAP                         1
 387 #define ELFTC_HAVE_STRMODE                      1
 388
 389 #define ELFTC_NEED_BYTEORDER_EXTENSIONS         1
 390 #endif /* __APPLE__ */
 391
 392
 393 #if defined(__DragonFly__)
 394
 395 #include <osreldate.h>
 396 #include <sys/endian.h>
 397
 398 #define ELFTC_BYTE_ORDER                        _BYTE_ORDER
 399 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
 400 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
 401
 402 #define ELFTC_HAVE_MMAP                         1
 403
 404 #endif
 405
 406 #if defined(__GLIBC__) || defined(__linux__)
 407
 408 #include <endian.h>
 409
 410 #define ELFTC_BYTE_ORDER                        __BYTE_ORDER
 411 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          __LITTLE_ENDIAN
 412 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             __BIG_ENDIAN
 413
 414 #define ELFTC_HAVE_MMAP                         1
 415
 416 /*
 417  * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3).
 418  */
 419 #define ELFTC_HAVE_STRMODE                      0
 420
 421 /* Whether we need to supply {be,le}32dec. */
 422 #define ELFTC_NEED_BYTEORDER_EXTENSIONS         1
 423
 424 #ifndef roundup2
 425 #define roundup2        roundup
 426 #endif
 427
 428 #endif  /* __GLIBC__ || __linux__ */
 429
 430
 431 #if defined(__FreeBSD__)
 432
 433 #include <osreldate.h>
 434 #include <sys/endian.h>
 435
 436 #define ELFTC_BYTE_ORDER                        _BYTE_ORDER
 437 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
 438 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
 439
 440 #define ELFTC_HAVE_MMAP                         1
 441 #define ELFTC_HAVE_STRMODE                      1
 442 #if __FreeBSD_version <= 900000
 443 #define ELFTC_BROKEN_YY_NO_INPUT                1
 444 #endif
 445 #endif  /* __FreeBSD__ */
 446
 447
 448 #if defined(__minix)
 449 #define ELFTC_HAVE_MMAP                         0
 450 #endif  /* __minix */
 451
 452
 453 #if defined(__NetBSD__)
 454
 455 #include <sys/param.h>
 456 #include <sys/endian.h>
 457
 458 #define ELFTC_BYTE_ORDER                        _BYTE_ORDER
 459 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
 460 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
 461
 462 #define ELFTC_HAVE_MMAP                         1
 463 #define ELFTC_HAVE_STRMODE                      1
 464 #if __NetBSD_Version__ <= 599002100
 465 /* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */
 466 /* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */
 467 #  define ELFTC_BROKEN_YY_NO_INPUT              1
 468 #endif
 469 #endif  /* __NetBSD __ */
 470
 471
 472 #if defined(__OpenBSD__)
 473
 474 #include <sys/param.h>
 475 #include <sys/endian.h>
 476
 477 #define ELFTC_BYTE_ORDER                        _BYTE_ORDER
 478 #define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
 479 #define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
 480
 481 #define ELFTC_HAVE_MMAP                         1
 482 #define ELFTC_HAVE_STRMODE                      1
 483
 484 #define ELFTC_NEED_BYTEORDER_EXTENSIONS         1
 485 #define roundup2        roundup
 486
 487 #endif  /* __OpenBSD__ */
 488
 489 #endif  /* _ELFTC_H */