/*
  This struct declaration is misleading (but accurate and necessary).
  It declares a "view" into memory allowing access to necessary
  fields at known offsets from a given base. See explanation below.
*/
struct malloc_chunk {
  INTERNAL_SIZE_T      mchunk_prev_size;  /* Size of previous chunk (if free).  */
  INTERNAL_SIZE_T      mchunk_size;       /* Size in bytes, including overhead. */
  struct malloc_chunk* fd;         /* double links -- used only if free. */
  struct malloc_chunk* bk;
  /* Only used for large blocks: pointer to next larger size.  */
  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
  struct malloc_chunk* bk_nextsize;
};
/*
   malloc_chunk details:
    (The following includes lightly edited explanations by Colin Plumb.)
    Chunks of memory are maintained using a `boundary tag' method as
    described in e.g., Knuth or Standish.  (See the paper by Paul
    Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
    survey of such techniques.)  Sizes of free chunks are stored both
    in the front of each chunk and at the end.  This makes
    consolidating fragmented chunks into bigger chunks very fast.  The
    size fields also hold bits representing whether chunks are free or
    in use.
    An allocated chunk looks like this:
    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Size of previous chunk, if unallocated (P clear)  |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Size of chunk, in bytes                     |A|M|P|
      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             User data starts here...                          .
            .                                                               .
            .             (malloc_usable_size() bytes)                      .
            .                                                               |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             (size of chunk, but used for application data)    |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Size of next chunk, in bytes                |A|0|1|
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    Where "chunk" is the front of the chunk for the purpose of most of
    the malloc code, but "mem" is the pointer that is returned to the
    user.  "Nextchunk" is the beginning of the next contiguous chunk.
    Chunks always begin on even word boundaries, so the mem portion
    (which is returned to the user) is also on an even word boundary, and
    thus at least double-word aligned.
    Free chunks are stored in circular doubly-linked lists, and look like this:
    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Size of previous chunk, if unallocated (P clear)  |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    `head:' |             Size of chunk, in bytes                     |A|0|P|
      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Forward pointer to next chunk in list             |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Back pointer to previous chunk in list            |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Unused space (may be 0 bytes long)                .
            .                                                               .
            .                                                               |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    `foot:' |             Size of chunk, in bytes                           |
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            |             Size of next chunk, in bytes                |A|0|0|
            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    The P (PREV_INUSE) bit, stored in the unused low-order bit of the
    chunk size (which is always a multiple of two words), is an in-use
    bit for the *previous* chunk.  If that bit is *clear*, then the
    word before the current chunk size contains the previous chunk
    size, and can be used to find the front of the previous chunk.
    The very first chunk allocated always has this bit set,
    preventing access to non-existent (or non-owned) memory. If
    prev_inuse is set for any given chunk, then you CANNOT determine
    the size of the previous chunk, and might even get a memory
    addressing fault when trying to do so.
    The A (NON_MAIN_ARENA) bit is cleared for chunks on the initial,
    main arena, described by the main_arena variable.  When additional
    threads are spawned, each thread receives its own arena (up to a
    configurable limit, after which arenas are reused for multiple
    threads), and the chunks in these arenas have the A bit set.  To
    find the arena for a chunk on such a non-main arena, heap_for_ptr
    performs a bit mask operation and indirection through the ar_ptr
    member of the per-heap header heap_info (see arena.c).
    Note that the `foot' of the current chunk is actually represented
    as the prev_size of the NEXT chunk. This makes it easier to
    deal with alignments etc but can be very confusing when trying
    to extend or adapt this code.
    The three exceptions to all this are:
     1. The special chunk `top' doesn't bother using the
        trailing size field since there is no next contiguous chunk
        that would have to index off it. After initialization, `top'
        is forced to always exist.  If it would become less than
        MINSIZE bytes long, it is replenished.
     2. Chunks allocated via mmap, which have the second-lowest-order
        bit M (IS_MMAPPED) set in their size fields.  Because they are
        allocated one-by-one, each must contain its own trailing size
        field.  If the M bit is set, the other bits are ignored
        (because mmapped chunks are neither in an arena, nor adjacent
        to a freed chunk).  The M bit is also used for chunks which
        originally came from a dumped heap via malloc_set_state in
        hooks.c.
     3. Chunks in fastbins are treated as allocated chunks from the
        point of view of the chunk allocator.  They are consolidated
        with their neighbors only in bulk, in malloc_consolidate.
*/

#define __SI_KILL        0
#define __SI_TIMER        0
#define __SI_POLL        0
#define __SI_FAULT        0
#define __SI_CHLD        0
#define __SI_RT                0
#define __SI_MESGQ        0
#define __SI_CODE(T,N)        (N)

/*
 * si_code values
 * Digital reserves positive values for kernel-generated signals.
 */
#define SI_USER                0                /* sent by kill, sigsend, raise */
#define SI_KERNEL        0x80                /* sent by the kernel from somewhere */
#define SI_QUEUE        -1                /* sent by sigqueue */
#define SI_TIMER __SI_CODE(__SI_TIMER,-2) /* sent by timer expiration */
#define SI_MESGQ __SI_CODE(__SI_MESGQ,-3) /* sent by real time mesq state change */
#define SI_ASYNCIO        -4                /* sent by AIO completion */
#define SI_SIGIO        -5                /* sent by queued SIGIO */
#define SI_TKILL        -6                /* sent by tkill system call */
#define SI_DETHREAD        -7                /* sent by execve() killing subsidiary threads */

#define SI_FROMUSER(siptr)        ((siptr)->si_code <= 0)
#define SI_FROMKERNEL(siptr)        ((siptr)->si_code > 0)

/*
 * SIGILL si_codes
 */
#define ILL_ILLOPC        (__SI_FAULT|1)        /* illegal opcode */
#define ILL_ILLOPN        (__SI_FAULT|2)        /* illegal operand */
#define ILL_ILLADR        (__SI_FAULT|3)        /* illegal addressing mode */
#define ILL_ILLTRP        (__SI_FAULT|4)        /* illegal trap */
#define ILL_PRVOPC        (__SI_FAULT|5)        /* privileged opcode */
#define ILL_PRVREG        (__SI_FAULT|6)        /* privileged register */
#define ILL_COPROC        (__SI_FAULT|7)        /* coprocessor error */
#define ILL_BADSTK        (__SI_FAULT|8)        /* internal stack error */
#define NSIGILL                8

/*
 * SIGFPE si_codes
 */
#define FPE_INTDIV        (__SI_FAULT|1)        /* integer divide by zero */
#define FPE_INTOVF        (__SI_FAULT|2)        /* integer overflow */
#define FPE_FLTDIV        (__SI_FAULT|3)        /* floating point divide by zero */
#define FPE_FLTOVF        (__SI_FAULT|4)        /* floating point overflow */
#define FPE_FLTUND        (__SI_FAULT|5)        /* floating point underflow */
#define FPE_FLTRES        (__SI_FAULT|6)        /* floating point inexact result */
#define FPE_FLTINV        (__SI_FAULT|7)        /* floating point invalid operation */
#define FPE_FLTSUB        (__SI_FAULT|8)        /* subscript out of range */
#define NSIGFPE                8

/*
 * SIGSEGV si_codes
 */
#define SEGV_MAPERR        (__SI_FAULT|1)        /* address not mapped to object */
#define SEGV_ACCERR        (__SI_FAULT|2)        /* invalid permissions for mapped object */
#define NSIGSEGV        2

/*
 * SIGBUS si_codes
 */
#define BUS_ADRALN        (__SI_FAULT|1)        /* invalid address alignment */
#define BUS_ADRERR        (__SI_FAULT|2)        /* non-existant physical address */
#define BUS_OBJERR        (__SI_FAULT|3)        /* object specific hardware error */
/* hardware memory error consumed on a machine check: action required */
#define BUS_MCEERR_AR        (__SI_FAULT|4)
/* hardware memory error detected in process but not consumed: action optional*/
#define BUS_MCEERR_AO        (__SI_FAULT|5)
#define NSIGBUS                5

/*
 * SIGTRAP si_codes
 */
#define TRAP_BRKPT        (__SI_FAULT|1)        /* process breakpoint */
#define TRAP_TRACE        (__SI_FAULT|2)        /* process trace trap */
#define TRAP_BRANCH     (__SI_FAULT|3)  /* process taken branch trap */
#define TRAP_HWBKPT     (__SI_FAULT|4)  /* hardware breakpoint/watchpoint */
#define NSIGTRAP        4

/*
 * SIGCHLD si_codes
 */
#define CLD_EXITED        (__SI_CHLD|1)        /* child has exited */
#define CLD_KILLED        (__SI_CHLD|2)        /* child was killed */
#define CLD_DUMPED        (__SI_CHLD|3)        /* child terminated abnormally */
#define CLD_TRAPPED        (__SI_CHLD|4)        /* traced child has trapped */
#define CLD_STOPPED        (__SI_CHLD|5)        /* child has stopped */
#define CLD_CONTINUED        (__SI_CHLD|6)        /* stopped child has continued */
#define NSIGCHLD        6

/*
 * SIGPOLL si_codes
 */
#define POLL_IN                (__SI_POLL|1)        /* data input available */
#define POLL_OUT        (__SI_POLL|2)        /* output buffers available */
#define POLL_MSG        (__SI_POLL|3)        /* input message available */
#define POLL_ERR        (__SI_POLL|4)        /* i/o error */
#define POLL_PRI        (__SI_POLL|5)        /* high priority input available */
#define POLL_HUP        (__SI_POLL|6)        /* device disconnected */
#define NSIGPOLL        6

/*
 * sigevent definitions
 * 
 * It seems likely that SIGEV_THREAD will have to be handled from 
 * userspace, libpthread transmuting it to SIGEV_SIGNAL, which the
 * thread manager then catches and does the appropriate nonsense.
 * However, everything is written out here so as to not get lost.
 */
#define SIGEV_SIGNAL        0        /* notify via signal */
#define SIGEV_NONE        1        /* other notification: meaningless */
#define SIGEV_THREAD        2        /* deliver via thread creation */
#define SIGEV_THREAD_ID 4        /* deliver to thread */