/** @file
 * IPRT - Types.
 */

/*
 * Copyright (C) 2006-2025 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */

#ifndef IPRT_INCLUDED_types_h
#define IPRT_INCLUDED_types_h
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include <iprt/cdefs.h>
#include <iprt/stdint.h>
#include <iprt/stdarg.h>

/*
 * Include standard C types.
 */
#if !defined(IPRT_NO_CRT) && !defined(DOXYGEN_RUNNING)

# if defined(IN_XF86_MODULE) && !defined(NO_ANSIC)
    /*
     * Kludge for xfree86 modules: size_t and other types are redefined.
     */
RT_C_DECLS_BEGIN
#  include "xf86_ansic.h"
#  undef NULL
RT_C_DECLS_END

# elif defined(RT_OS_DARWIN) && defined(KERNEL)
    /*
     * Kludge for the darwin kernel:
     *  stddef.h is missing IIRC.
     */
#  ifndef _PTRDIFF_T
#  define _PTRDIFF_T
    typedef __darwin_ptrdiff_t ptrdiff_t;
#  endif
#  include <sys/types.h>

# elif defined(RT_OS_FREEBSD) && defined(_KERNEL)
#  include <sys/param.h>
#  undef PVM
#  if __FreeBSD_version < 1200000
    /*
     * Kludge for the FreeBSD kernel:
     *  stddef.h and sys/types.h have slightly different offsetof definitions
     *  when compiling in kernel mode. This is just to make GCC shut up.
     */
#   ifndef _STDDEF_H_
#    undef offsetof
#   endif
#   include <sys/stddef.h>
#   ifndef _SYS_TYPES_H_
#    undef offsetof
#   endif
#   include <sys/types.h>
#   ifndef offsetof
#    error "offsetof is not defined!"
#   endif
#  else
#   include <sys/stddef.h>
#   include <sys/types.h>
#  endif

# elif defined(RT_OS_FREEBSD) && HC_ARCH_BITS == 64 && defined(RT_ARCH_X86)
    /*
     * Kludge for compiling 32-bit code on a 64-bit FreeBSD:
     *  FreeBSD declares uint64_t and int64_t wrong (long unsigned and long int
     *  though they need to be long long unsigned and long long int). These
     *  defines conflict with our declaration in stdint.h. Adding the defines
     *  below omits the definitions in the system header.
     */
#  include <stddef.h>
#  define _UINT64_T_DECLARED
#  define _INT64_T_DECLARED
#  define _UINTPTR_T_DECLARED
#  define _INTPTR_T_DECLARED
#  include <sys/types.h>

# elif defined(RT_OS_NETBSD) && defined(_KERNEL)

#  include <sys/types.h>

   /*
    * Kludge for NetBSD-6.x where the definition of bool in
    * <sys/types.h> does not check for C++.
    */
#  if defined(__cplusplus) && defined(bool)
#   undef bool
#   undef true
#   undef false
#  endif

   /*
    * Kludge for NetBSD-6.x where <sys/types.h> does not define
    * ptrdiff_t for the kernel code.  Note that we don't worry about
    * redefinition in <stddef.h> since that header doesn't exist for
    * _KERNEL code.
    */
#  ifdef _BSD_PTRDIFF_T_
    typedef _BSD_PTRDIFF_T_ ptrdiff_t;
#  endif

# elif defined(RT_OS_LINUX) && defined(__KERNEL__)
    /*
     * Kludge for the linux kernel:
     *   1. sys/types.h doesn't mix with the kernel.
     *   2. Starting with 2.6.19, linux/types.h typedefs bool and linux/stddef.h
     *      declares false and true as enum values.
     *   3. Starting with 2.6.24, linux/types.h typedefs uintptr_t.
     * We work around these issues here and nowhere else.
     */
#  if defined(__cplusplus)
    typedef bool _Bool;
#  endif
#  define bool linux_bool
#  define true linux_true
#  define false linux_false
#  define uintptr_t linux_uintptr_t
#  include <linux/version.h>
#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)
#   include <generated/autoconf.h>
#  else
#   ifndef AUTOCONF_INCLUDED
#    include <linux/autoconf.h>
#   endif
#  endif
#  include <linux/compiler.h>
#  if defined(__cplusplus)
    /*
     * Starting with 3.3, <linux/compiler-gcc.h> appends 'notrace' (which
     * expands to __attribute__((no_instrument_function))) to inline,
     * __inline and __inline__. Revert that.
     */
#   undef inline
#   define inline inline
#   undef __inline__
#   define __inline__ __inline__
#   undef __inline
#   define __inline __inline
#  endif
#  include <linux/types.h>
#  include <linux/stddef.h>
    /*
     * Starting with 3.4, <linux/stddef.h> defines NULL as '((void*)0)' which
     * does not work for C++ code.
     */
#  undef NULL
#  undef uintptr_t
#  ifdef __GNUC__
#   if !RT_GNUC_PREREQ(4, 1)
     /*
      * <linux/compiler-gcc{3,4}.h> does
      *   #define __inline__  __inline__ __attribute__((always_inline))
      * in some older Linux kernels. Forcing inlining will fail for some RTStrA*
      * functions with gcc <= 4.0 due to passing variable argument lists.
      */
#    undef __inline__
#    define __inline__ __inline__
#   endif
#  endif
#  undef false
#  undef true
#  undef bool

# elif !defined(DOXYGEN_RUNNING) && RT_MSC_PREREQ(RT_MSC_VER_VC140) && defined(RT_OS_AGNOSTIC)
    /* Try avoid needing the UCRT just for stddef.h and sys/types.h. */
    /** @todo refine the RT_OS_AGNOSTIC test? */
#  include <vcruntime.h>

# else
#  include <stddef.h>
#  if defined(RT_OS_SOLARIS) && defined(VBOX_WITH_PARFAIT) && defined(_KERNEL) && defined(__INT_FAST16_MAX__)
    /* HACK ALERT: Workaround for duplicate [u]int_fast16_t conflicting due to 'incorrect'
                   __INT_FAST16_TYPE__ and __UINT_FAST16_TYPE__ definitions in pairfait.
                   The types are usually 'int' and 'unsigned int', which the system headers
                   assume, thus we get a conflict when the pairfait compiler redefines to
                   a narrow variant.  Workaround, try ignore the system types and use the
                   compiler ones... */
#   if (__INT_FAST16_MAX__) == 32767
#    define int_fast16_t  hacked_int_fast16_t
#    define uint_fast16_t hacked_uint_fast16_t
#    include <sys/int_types.h>
#    undef  int_fast16_t
#    undef  uint_fast16_t
#   endif
#  endif
#  include <sys/types.h>
# endif


/* Define any types missing from sys/types.h on Windows and OS/2. */
# ifdef _MSC_VER
#  undef ssize_t
typedef intptr_t ssize_t;
# endif
# if defined(RT_OS_OS2) && (defined(__IBMC__) || defined(__IBMCPP__))
typedef signed long ssize_t;
# endif

#else  /* no crt */
# include <iprt/nocrt/compiler/compiler.h>
#endif /* no crt */



/** @def NULL
 * NULL pointer.
 */
#ifndef NULL
# ifdef __cplusplus
#  define NULL 0
# else
#  define NULL ((void*)0)
# endif
#endif



/** @defgroup grp_rt_types  IPRT Base Types
 * @{
 */

/* define wchar_t, we don't wanna include all the wcsstuff to get this. */
#ifdef _MSC_VER
# ifndef _WCHAR_T_DEFINED
  typedef unsigned short wchar_t;
# define _WCHAR_T_DEFINED
# endif
#endif
#ifdef __GNUC__
/** @todo wchar_t on GNUC */
#endif

/*
 * C doesn't have bool, nor does VisualAge for C++ v3.08.
 * Starting with c23, bool, true and false are keywords.
 */
#if (!defined(__cplusplus) || (defined(__IBMCPP__) && defined(RT_OS_OS2))) && !RT_STDC_VERSION_PREREQ(202311L)
# if defined(__GNUC__)
#  if defined(RT_OS_LINUX) && __GNUC__ < 3
typedef uint8_t bool;
#  elif defined(RT_OS_FREEBSD)
#   ifndef __bool_true_false_are_defined
typedef _Bool bool;
#   endif
#  elif defined(RT_OS_NETBSD)
#   if !defined(_KERNEL)
     /*
      * For the kernel code <stdbool.h> is not available, but bool is
      * provided by <sys/types.h> included above.
      */
#    include <stdbool.h>

     /*
      * ... but the story doesn't end here.  The C standard says that
      * <stdbool.h> defines preprocessor macro "bool" that expands to
      * "_Bool", but adds that a program may undefine/redefine it
      * (this is 7.16 in C99 and 7.18 in C11).  We have to play this
      * game here because X11 code uses "bool" as a struct member name
      * - so undefine "bool" and provide it as a typedef instead.  We
      * still keep #include <stdbool.h> so that any code that might
      * include it later doesn't mess things up.
      */
#    undef bool
     typedef _Bool bool;
#   endif
#  else
#   undef bool /* see above netbsd explanation */
typedef _Bool bool;
#  endif
# else
#  if RT_MSC_PREREQ(RT_MSC_VER_VC120)
#   include <stdbool.h>
#  else
typedef unsigned char bool;
#  endif
# endif
# ifndef true
#  define true  (1)
# endif
# ifndef false
#  define false (0)
# endif
#endif


/**
 * 128-bit unsigned integer.
 */
#ifdef RT_COMPILER_WITH_128BIT_INT_TYPES
typedef __uint128_t uint128_t;
#else
typedef struct uint128_s
{
# ifdef RT_BIG_ENDIAN
    uint64_t    Hi;
    uint64_t    Lo;
# else
    uint64_t    Lo;
    uint64_t    Hi;
# endif
} uint128_t;
#endif


/**
 * 128-bit signed integer.
 */
#ifdef RT_COMPILER_WITH_128BIT_INT_TYPES
typedef __int128_t int128_t;
#else
typedef struct int128_s
{
# ifdef RT_BIG_ENDIAN
    int64_t     Hi;
    uint64_t    Lo;
# else
    uint64_t    Lo;
    int64_t     Hi;
# endif
} int128_t;
#endif


/**
 * 16-bit unsigned integer union.
 */
typedef union RTUINT16U
{
    /** natural view. */
    uint16_t    u;

    /** 16-bit hi/lo view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint8_t    Hi;
        uint8_t    Lo;
#else
        uint8_t    Lo;
        uint8_t    Hi;
#endif
    } s;

    /** Unsigned 16-bit view. */
    uint16_t    au16[1];
    /** Unsigned 8-bit view. */
    uint8_t     au8[2];

    /** Signed 16-bit view. */
    int16_t     ai16[1];
    /** Signed 8-bit view. */
    int8_t      ai8[2];
} RTUINT16U;
/** Pointer to a 16-bit unsigned integer union. */
typedef RTUINT16U RT_FAR *PRTUINT16U;
/** Pointer to a const 32-bit unsigned integer union. */
typedef const RTUINT16U RT_FAR *PCRTUINT16U;


/**
 * 32-bit unsigned integer union.
 */
typedef union RTUINT32U
{
    /** natural view. */
    uint32_t    u;
    /** Hi/Low view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    Hi;
        uint16_t    Lo;
#else
        uint16_t    Lo;
        uint16_t    Hi;
#endif
    } s;
    /** Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    w1;
        uint16_t    w0;
#else
        uint16_t    w0;
        uint16_t    w1;
#endif
    } Words;

    /** Unsigned 32-bit view. */
    uint32_t    au32[1];
    /** Unsigned 16-bit view. */
    uint16_t    au16[2];
    /** Unsigned 8-bit view. */
    uint8_t     au8[4];

    /** Signed 32-bit view. */
    int32_t     ai32[1];
    /** Signed 16-bit view. */
    int16_t     ai16[2];
    /** Signed 8-bit view. */
    int8_t      ai8[4];
} RTUINT32U;
/** Pointer to a 32-bit unsigned integer union. */
typedef RTUINT32U RT_FAR *PRTUINT32U;
/** Pointer to a const 32-bit unsigned integer union. */
typedef const RTUINT32U RT_FAR *PCRTUINT32U;


/**
 * 64-bit unsigned integer union.
 */
typedef union RTUINT64U
{
    /** Natural view. */
    uint64_t    u;
    /** Hi/Low view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint32_t    Hi;
        uint32_t    Lo;
#else
        uint32_t    Lo;
        uint32_t    Hi;
#endif
    } s;
    /** Double-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint32_t    dw1;
        uint32_t    dw0;
#else
        uint32_t    dw0;
        uint32_t    dw1;
#endif
    } DWords;
    /** Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    w3;
        uint16_t    w2;
        uint16_t    w1;
        uint16_t    w0;
#else
        uint16_t    w0;
        uint16_t    w1;
        uint16_t    w2;
        uint16_t    w3;
#endif
    } Words;

    /** Unsigned 64-bit view. */
    uint64_t    au64[1];
    /** Unsigned 32-bit view. */
    uint32_t    au32[2];
    /** Unsigned 16-bit view. */
    uint16_t    au16[4];
    /** Unsigned 8-bit view. */
    uint8_t     au8[8];

    /** Signed 64-bit view. */
    int64_t     ai64[1];
    /** Signed 32-bit view. */
    int32_t     ai32[2];
    /** Signed 16-bit view. */
    int16_t     ai16[4];
    /** Signed 8-bit view. */
    int8_t      ai8[8];
} RTUINT64U;
/** Pointer to a 64-bit unsigned integer union. */
typedef RTUINT64U RT_FAR *PRTUINT64U;
/** Pointer to a const 64-bit unsigned integer union. */
typedef const RTUINT64U RT_FAR *PCRTUINT64U;


/**
 * 128-bit unsigned integer union.
 *
 * @note This is not necessarily automatically 16 byte aligned. Sorry.
 */
#pragma pack(1)
typedef union RTUINT128U
{
    /** Hi/Low view.
     * @remarks We put this first so we can have portable initializers
     *          (RTUINT128_INIT) */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint64_t    Hi;
        uint64_t    Lo;
#else
        uint64_t    Lo;
        uint64_t    Hi;
#endif
    } s;

    /** Natural view.
     * WARNING! This member depends on the compiler supporting 128-bit stuff. */
    uint128_t   u;

    /** Quad-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint64_t    qw1;
        uint64_t    qw0;
#else
        uint64_t    qw0;
        uint64_t    qw1;
#endif
    } QWords;
    /** Double-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint32_t    dw3;
        uint32_t    dw2;
        uint32_t    dw1;
        uint32_t    dw0;
#else
        uint32_t    dw0;
        uint32_t    dw1;
        uint32_t    dw2;
        uint32_t    dw3;
#endif
    } DWords;
    /** Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    w7;
        uint16_t    w6;
        uint16_t    w5;
        uint16_t    w4;
        uint16_t    w3;
        uint16_t    w2;
        uint16_t    w1;
        uint16_t    w0;
#else
        uint16_t    w0;
        uint16_t    w1;
        uint16_t    w2;
        uint16_t    w3;
        uint16_t    w4;
        uint16_t    w5;
        uint16_t    w6;
        uint16_t    w7;
#endif
    } Words;

    /** Unsigned 64-bit view. */
    uint64_t    au64[2];
    /** Unsigned 32-bit view. */
    uint32_t    au32[4];
    /** Unsigned 16-bit view. */
    uint16_t    au16[8];
    /** Unsigned 8-bit view. */
    uint8_t     au8[16];

    /** Signed 64-bit view. */
    int64_t     ai64[2];
    /** Signed 32-bit view. */
    int32_t     ai32[4];
    /** Signed 16-bit view. */
    int16_t     ai16[8];
    /** Signed 8-bit view. */
    int8_t      ai8[16];
} RTUINT128U;
#pragma pack()
/** Pointer to a 128-bit unsigned integer union. */
typedef RTUINT128U RT_FAR *PRTUINT128U;
/** Pointer to a const 128-bit unsigned integer union. */
typedef const RTUINT128U RT_FAR *PCRTUINT128U;

/** @def RTUINT128_INIT
 * Portable RTUINT128U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTUINT128_INIT(a_Hi, a_Lo) { { a_Hi, a_Lo } }
#else
# define RTUINT128_INIT(a_Hi, a_Lo) { { a_Lo, a_Hi } }
#endif

/** @def RTUINT128_INIT_C
 * Portable RTUINT128U initializer for 64-bit constants. */
#ifdef RT_BIG_ENDIAN
# define RTUINT128_INIT_C(a_Hi, a_Lo) { { UINT64_C(a_Hi), UINT64_C(a_Lo) } }
#else
# define RTUINT128_INIT_C(a_Hi, a_Lo) { { UINT64_C(a_Lo), UINT64_C(a_Hi) } }
#endif


/**
 * 256-bit unsigned integer union.
 */
#pragma pack(1)
typedef union RTUINT256U
{
    /** Quad-Word view (first as it's used by RTUINT256_INIT). */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint64_t    qw3;
        uint64_t    qw2;
        uint64_t    qw1;
        uint64_t    qw0;
#else
        uint64_t    qw0;
        uint64_t    qw1;
        uint64_t    qw2;
        uint64_t    qw3;
#endif
    } QWords;
    /** Double-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint32_t    dw7;
        uint32_t    dw6;
        uint32_t    dw5;
        uint32_t    dw4;
        uint32_t    dw3;
        uint32_t    dw2;
        uint32_t    dw1;
        uint32_t    dw0;
#else
        uint32_t    dw0;
        uint32_t    dw1;
        uint32_t    dw2;
        uint32_t    dw3;
        uint32_t    dw4;
        uint32_t    dw5;
        uint32_t    dw6;
        uint32_t    dw7;
#endif
    } DWords;
    /** Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    w15;
        uint16_t    w14;
        uint16_t    w13;
        uint16_t    w12;
        uint16_t    w11;
        uint16_t    w10;
        uint16_t    w9;
        uint16_t    w8;
        uint16_t    w7;
        uint16_t    w6;
        uint16_t    w5;
        uint16_t    w4;
        uint16_t    w3;
        uint16_t    w2;
        uint16_t    w1;
        uint16_t    w0;
#else
        uint16_t    w0;
        uint16_t    w1;
        uint16_t    w2;
        uint16_t    w3;
        uint16_t    w4;
        uint16_t    w5;
        uint16_t    w6;
        uint16_t    w7;
        uint16_t    w8;
        uint16_t    w9;
        uint16_t    w10;
        uint16_t    w11;
        uint16_t    w12;
        uint16_t    w13;
        uint16_t    w14;
        uint16_t    w15;
#endif
    } Words;

    /** Double-Quad-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        RTUINT128U  dqw1;
        RTUINT128U  dqw0;
#else
        RTUINT128U  dqw0;
        RTUINT128U  dqw1;
#endif
    } DQWords;

    /** Unsigned 128-bit view. */
    RTUINT128U  au128[2];
    /** Unsigned 64-bit view. */
    uint64_t    au64[4];
    /** Unsigned 32-bit view. */
    uint32_t    au32[8];
    /** Unsigned 16-bit view. */
    uint16_t    au16[16];
    /** Unsigned 8-bit view. */
    uint8_t     au8[32];

    /** Signed 64-bit view. */
    int64_t     ai64[4];
    /** Signed 32-bit view. */
    int32_t     ai32[8];
    /** Signed 16-bit view. */
    int16_t     ai16[16];
    /** Signed 8-bit view. */
    int8_t      ai8[32];
} RTUINT256U;
#pragma pack()
/** Pointer to a 256-bit unsigned integer union. */
typedef RTUINT256U RT_FAR *PRTUINT256U;
/** Pointer to a const 256-bit unsigned integer union. */
typedef const RTUINT256U RT_FAR *PCRTUINT256U;

/** @def RTUINT256_INIT
 * Portable RTUINT256U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTUINT256_INIT(a_Qw3, a_Qw2, a_Qw1, a_Qw0)   { { a_Qw3, a_Qw2, a_Qw1, a_Qw0 } }
#else
# define RTUINT256_INIT(a_Qw3, a_Qw2, a_Qw1, a_Qw0)   { { a_Qw0, a_Qw1, a_Qw2, a_Qw3 } }
#endif

/** @def RTUINT256_INIT_C
 * Portable RTUINT256U initializer for 64-bit constants. */
#define RTUINT256_INIT_C(a_Qw3, a_Qw2, a_Qw1, a_Qw0)  \
    RTUINT256_INIT(UINT64_C(a_Qw3), UINT64_C(a_Qw2), UINT64_C(a_Qw1), UINT64_C(a_Qw0))


/**
 * 512-bit unsigned integer union.
 */
#pragma pack(1)
typedef union RTUINT512U
{
    /** Quad-Word view (first as it's used by RTUINT512_INIT). */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint64_t    qw7;
        uint64_t    qw6;
        uint64_t    qw5;
        uint64_t    qw4;
        uint64_t    qw3;
        uint64_t    qw2;
        uint64_t    qw1;
        uint64_t    qw0;
#else
        uint64_t    qw0;
        uint64_t    qw1;
        uint64_t    qw2;
        uint64_t    qw3;
        uint64_t    qw4;
        uint64_t    qw5;
        uint64_t    qw6;
        uint64_t    qw7;
#endif
    } QWords;
    /** Double-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint32_t    dw15;
        uint32_t    dw14;
        uint32_t    dw13;
        uint32_t    dw12;
        uint32_t    dw11;
        uint32_t    dw10;
        uint32_t    dw9;
        uint32_t    dw8;
        uint32_t    dw7;
        uint32_t    dw6;
        uint32_t    dw5;
        uint32_t    dw4;
        uint32_t    dw3;
        uint32_t    dw2;
        uint32_t    dw1;
        uint32_t    dw0;
#else
        uint32_t    dw0;
        uint32_t    dw1;
        uint32_t    dw2;
        uint32_t    dw3;
        uint32_t    dw4;
        uint32_t    dw5;
        uint32_t    dw6;
        uint32_t    dw7;
        uint32_t    dw8;
        uint32_t    dw9;
        uint32_t    dw10;
        uint32_t    dw11;
        uint32_t    dw12;
        uint32_t    dw13;
        uint32_t    dw14;
        uint32_t    dw15;
#endif
    } DWords;
    /** Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        uint16_t    w31;
        uint16_t    w30;
        uint16_t    w29;
        uint16_t    w28;
        uint16_t    w27;
        uint16_t    w26;
        uint16_t    w25;
        uint16_t    w24;
        uint16_t    w23;
        uint16_t    w22;
        uint16_t    w21;
        uint16_t    w20;
        uint16_t    w19;
        uint16_t    w18;
        uint16_t    w17;
        uint16_t    w16;
        uint16_t    w15;
        uint16_t    w14;
        uint16_t    w13;
        uint16_t    w12;
        uint16_t    w11;
        uint16_t    w10;
        uint16_t    w9;
        uint16_t    w8;
        uint16_t    w7;
        uint16_t    w6;
        uint16_t    w5;
        uint16_t    w4;
        uint16_t    w3;
        uint16_t    w2;
        uint16_t    w1;
        uint16_t    w0;
#else
        uint16_t    w0;
        uint16_t    w1;
        uint16_t    w2;
        uint16_t    w3;
        uint16_t    w4;
        uint16_t    w5;
        uint16_t    w6;
        uint16_t    w7;
        uint16_t    w8;
        uint16_t    w9;
        uint16_t    w10;
        uint16_t    w11;
        uint16_t    w12;
        uint16_t    w13;
        uint16_t    w14;
        uint16_t    w15;
        uint16_t    w16;
        uint16_t    w17;
        uint16_t    w18;
        uint16_t    w19;
        uint16_t    w20;
        uint16_t    w21;
        uint16_t    w22;
        uint16_t    w23;
        uint16_t    w24;
        uint16_t    w25;
        uint16_t    w26;
        uint16_t    w27;
        uint16_t    w28;
        uint16_t    w29;
        uint16_t    w30;
        uint16_t    w31;
#endif
    } Words;

    /** Double-Quad-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        RTUINT128U  dqw3;
        RTUINT128U  dqw2;
        RTUINT128U  dqw1;
        RTUINT128U  dqw0;
#else
        RTUINT128U  dqw0;
        RTUINT128U  dqw1;
        RTUINT128U  dqw2;
        RTUINT128U  dqw3;
#endif
    } DQWords;

    /** Octo-Word view. */
    struct
    {
#ifdef RT_BIG_ENDIAN
        RTUINT256U  ow3;
        RTUINT256U  ow2;
        RTUINT256U  ow1;
        RTUINT256U  ow0;
#else
        RTUINT256U  ow0;
        RTUINT256U  ow1;
        RTUINT256U  ow2;
        RTUINT256U  ow3;
#endif
    } OWords;

    /** 256-bit view. */
    RTUINT256U  au256[2];
    /** 128-bit view. */
    RTUINT128U  au128[4];
    /** 64-bit view. */
    uint64_t    au64[8];
    /** 32-bit view. */
    uint32_t    au32[16];
    /** 16-bit view. */
    uint16_t    au16[32];
    /** 8-bit view. */
    uint8_t     au8[64];
} RTUINT512U;
#pragma pack()
/** Pointer to a 512-bit unsigned integer union. */
typedef RTUINT512U RT_FAR *PRTUINT512U;
/** Pointer to a const 512-bit unsigned integer union. */
typedef const RTUINT512U RT_FAR *PCRTUINT512U;

/** @def RTUINT512_INIT
 * Portable RTUINT512U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTUINT512_INIT(a_Qw7, a_Qw6, a_Qw5, a_Qw4, a_Qw3, a_Qw2, a_Qw1, a_Qw0) \
    { { a_Qw7, a_Qw6, a_Qw5, a_Qw4, a_Qw3, a_Qw2, a_Qw1, a_Qw0 } }
#else
# define RTUINT512_INIT(a_Qw7, a_Qw6, a_Qw5, a_Qw4, a_Qw3, a_Qw2, a_Qw1, a_Qw0) \
    { { a_Qw0, a_Qw1, a_Qw2, a_Qw3, a_Qw4, a_Qw5, a_Qw6, a_Qw7 } }
#endif

/** @def RTUINT512_INIT_C
 * Portable RTUINT512U initializer for 64-bit constants. */
#define RTUINT512_INIT_C(a_Qw7, a_Qw6, a_Qw5, a_Qw4, a_Qw3, a_Qw2, a_Qw1, a_Qw0) \
    RTUINT512_INIT(UINT64_C(a_Qw7), UINT64_C(a_Qw6), UINT64_C(a_Qw5), UINT64_C(a_Qw4), \
                   UINT64_C(a_Qw3), UINT64_C(a_Qw2), UINT64_C(a_Qw1), UINT64_C(a_Qw0))


/**
 * Single precision floating point format (32-bit).
 */
typedef union RTFLOAT32U
{
    /** Format using regular bitfields.  */
    struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign indicator. */
        uint32_t    fSign : 1;
        /** The exponent (offsetted by 127). */
        uint32_t    uExponent : 8;
        /** The fraction. */
        uint32_t    uFraction : 23;
# else
        /** The fraction. */
        uint32_t    uFraction : 23;
        /** The exponent (offsetted by 127). */
        uint32_t    uExponent : 8;
        /** The sign indicator. */
        uint32_t    fSign : 1;
# endif
    } s;

#if 1 /** @todo exclude targets which doesn't have a 64-bit double type. (currently none) */
    /** Double view. */
    float       r;
#endif
    /** Unsigned integer view. */
    uint32_t    u;
    /** 32-bit view. */
    uint32_t    au32[1];
    /** 16-bit view. */
    uint16_t    au16[2];
    /** 8-bit view. */
    uint8_t     au8[4];
} RTFLOAT32U;
/** Pointer to a single precision floating point format union. */
typedef RTFLOAT32U RT_FAR *PRTFLOAT32U;
/** Pointer to a const single precision floating point format union. */
typedef const RTFLOAT32U RT_FAR *PCRTFLOAT32U;
/** RTFLOAT32U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTFLOAT32U_INIT(a_fSign, a_uFraction, a_uExponent)     { { (a_fSign), (a_uExponent), (a_uFraction) } }
#else
# define RTFLOAT32U_INIT(a_fSign, a_uFraction, a_uExponent)     { { (a_uFraction), (a_uExponent), (a_fSign) } }
#endif
#define RTFLOAT32U_INIT_C(a_fSign, a_uFraction, a_uExponent)    RTFLOAT32U_INIT((a_fSign), UINT32_C(a_uFraction), (a_uExponent))
#define RTFLOAT32U_INIT_ZERO(a_fSign)               RTFLOAT32U_INIT((a_fSign), 0, 0)
#define RTFLOAT32U_INIT_INF(a_fSign)                RTFLOAT32U_INIT((a_fSign), 0, RTFLOAT32U_EXP_MAX)
#define RTFLOAT32U_INIT_SNAN(a_fSign)               RTFLOAT32U_INIT((a_fSign), 1, RTFLOAT32U_EXP_MAX)
#define RTFLOAT32U_INIT_SNAN_EX(a_fSign, a_uVal)    RTFLOAT32U_INIT((a_fSign), (a_uVal) ? (a_uVal) : 1, RTFLOAT32U_EXP_MAX)
#define RTFLOAT32U_INIT_SIGNALLING_NAN(a_fSign)     RTFLOAT32U_INIT_SNAN(a_fSign)
#define RTFLOAT32U_INIT_QNAN(a_fSign)               RTFLOAT32U_INIT((a_fSign), RT_BIT_32(RTFLOAT32U_FRACTION_BITS - 1), RTFLOAT32U_EXP_MAX)
#define RTFLOAT32U_INIT_QNAN_EX(a_fSign, a_uVal)    RTFLOAT32U_INIT((a_fSign), RT_BIT_32(RTFLOAT32U_FRACTION_BITS - 1) | (a_uVal), RTFLOAT32U_EXP_MAX)
#define RTFLOAT32U_INIT_QUIET_NAN(a_fSign)          RTFLOAT32U_INIT_QNAN(a_fSign)
#define RTFLOAT32U_INIT_NAN_EX(a_fQuiet, a_fSign, a_uVal) \
    RTFLOAT32U_INIT((a_fSign), \
                    ((a_uVal) || (a_fQuiet) ? (a_uVal) : 1) | ((a_fQuiet) ? RT_BIT_32(RTFLOAT32U_FRACTION_BITS - 1) : 0), \
                    RTFLOAT32U_EXP_MAX)

/** The exponent bias for the RTFLOAT32U format. */
#define RTFLOAT32U_EXP_BIAS                     (127)
/** The max exponent value for the RTFLOAT32U format. */
#define RTFLOAT32U_EXP_MAX                      (255)
/** The exponent bias overflow/underflow adjust for the RTFLOAT32U format.
 * @note 754-1985 sec 7.3 & 7.4, not mentioned in later standard versions. */
#define RTFLOAT32U_EXP_BIAS_ADJUST              (192)
/** Fraction width (in bits) for the RTFLOAT32U format. */
#define RTFLOAT32U_FRACTION_BITS                (23)
/** Check if two 32-bit floating values are identical (memcmp, not
 *  numerically). */
#define RTFLOAT32U_ARE_IDENTICAL(a_pLeft, a_pRight)             ((a_pLeft)->u == (a_pRight)->u)
/** @name RTFLOAT32U classification macros
 * @{ */
#define RTFLOAT32U_IS_ZERO(a_pr32)              (((a_pr32)->u & (RT_BIT_32(31) - 1)) == 0)
#define RTFLOAT32U_IS_SUBNORMAL(a_pr32)         ((a_pr32)->s.uExponent == 0    && (a_pr32)->s.uFraction != 0)
#define RTFLOAT32U_IS_INF(a_pr32)               ((a_pr32)->s.uExponent == 0xff && (a_pr32)->s.uFraction == 0)
#define RTFLOAT32U_IS_SIGNALLING_NAN(a_pr32)    ((a_pr32)->s.uExponent == 0xff && !((a_pr32)->s.uFraction & RT_BIT_32(22)) \
                                                 && (a_pr32)->s.uFraction != 0)
#define RTFLOAT32U_IS_QUIET_NAN(a_pr32)         ((a_pr32)->s.uExponent == 0xff && ((a_pr32)->s.uFraction & RT_BIT_32(22)))
#define RTFLOAT32U_IS_NAN(a_pr32)               ((a_pr32)->s.uExponent == 0xff && (a_pr32)->s.uFraction != 0)
#define RTFLOAT32U_IS_NORMAL(a_pr32)            ((a_pr32)->s.uExponent > 0 && (a_pr32)->s.uExponent < 0xff)
/** @} */


/**
 * Double precision floating point format (64-bit).
 */
typedef union RTFLOAT64U
{
    /** Format using regular bitfields.  */
    struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign indicator. */
        uint32_t    fSign : 1;
        /** The exponent (offsetted by 1023). */
        uint32_t    uExponent : 11;
        /** The fraction, bits 32 thru 51. */
        uint32_t    uFractionHigh : 20;
        /** The fraction, bits 0 thru 31. */
        uint32_t    uFractionLow;
# else
        /** The fraction, bits 0 thru 31. */
        uint32_t    uFractionLow;
        /** The fraction, bits 32 thru 51. */
        uint32_t    uFractionHigh : 20;
        /** The exponent (offsetted by 1023). */
        uint32_t    uExponent : 11;
        /** The sign indicator. */
        uint32_t    fSign : 1;
# endif
    } s;

#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    /** Format using 64-bit bitfields.  */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign indicator. */
        RT_GCC_EXTENSION uint64_t    fSign : 1;
        /** The exponent (offsetted by 1023). */
        RT_GCC_EXTENSION uint64_t    uExponent : 11;
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t    uFraction : 52;
# else
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t    uFraction : 52;
        /** The exponent (offsetted by 1023). */
        RT_GCC_EXTENSION uint64_t    uExponent : 11;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint64_t    fSign : 1;
# endif
    } s64;
#endif

#if 1 /** @todo exclude targets which doesn't have a 64-bit double type. (currently none) */
    /** Double view. */
    double      rd, r;
#endif
#ifdef RT_COMPILER_WITH_64BIT_LONG_DOUBLE
    /** Long double view. */
    long double lrd;
#endif
    /** Unsigned integer view. */
    uint64_t    u;
    /** 64-bit view. */
    uint64_t    au64[1];
    /** 32-bit view. */
    uint32_t    au32[2];
    /** 16-bit view. */
    uint16_t    au16[4];
    /** 8-bit view. */
    uint8_t     au8[8];
} RTFLOAT64U;
/** Pointer to a double precision floating point format union. */
typedef RTFLOAT64U RT_FAR *PRTFLOAT64U;
/** Pointer to a const double precision floating point format union. */
typedef const RTFLOAT64U RT_FAR *PCRTFLOAT64U;
/** RTFLOAT64U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTFLOAT64U_INIT(a_fSign, a_uFraction, a_uExponent)     \
    { { (a_fSign), (a_uExponent), (uint32_t)((a_uFraction) >> 32), (uint32_t)((a_uFraction) & UINT32_MAX) } }
#else
# define RTFLOAT64U_INIT(a_fSign, a_uFraction, a_uExponent)     \
    { { (uint32_t)((a_uFraction) & UINT32_MAX), (uint32_t)((a_uFraction) >> 32), (a_uExponent), (a_fSign) } }
#endif
#define RTFLOAT64U_INIT_C(a_fSign, a_uFraction, a_uExponent)    RTFLOAT64U_INIT((a_fSign), UINT64_C(a_uFraction), (a_uExponent))
#define RTFLOAT64U_INIT_ZERO(a_fSign)               RTFLOAT64U_INIT((a_fSign), UINT64_C(0), 0)
#define RTFLOAT64U_INIT_INF(a_fSign)                RTFLOAT64U_INIT((a_fSign), UINT64_C(0), RTFLOAT64U_EXP_MAX)
#define RTFLOAT64U_INIT_SNAN(a_fSign)               RTFLOAT64U_INIT((a_fSign), UINT64_C(1), RTFLOAT64U_EXP_MAX)
#define RTFLOAT64U_INIT_SNAN_EX(a_fSign, a_uVal)    RTFLOAT64U_INIT((a_fSign), (a_uVal) ? (a_uVal) : UINT64_C(1), RTFLOAT64U_EXP_MAX)
#define RTFLOAT64U_INIT_SIGNALLING_NAN(a_fSign)     RTFLOAT64U_INIT_SNAN(a_fSign)
#define RTFLOAT64U_INIT_QNAN(a_fSign)               RTFLOAT64U_INIT((a_fSign), RT_BIT_64(RTFLOAT64U_FRACTION_BITS - 1), RTFLOAT64U_EXP_MAX)
#define RTFLOAT64U_INIT_QNAN_EX(a_fSign, a_uVal)    RTFLOAT64U_INIT((a_fSign), RT_BIT_64(RTFLOAT64U_FRACTION_BITS - 1) | (a_uVal), RTFLOAT64U_EXP_MAX)
#define RTFLOAT64U_INIT_QUIET_NAN(a_fSign)          RTFLOAT64U_INIT_QNAN(a_fSign)
#define RTFLOAT64U_INIT_NAN_EX(a_fQuiet, a_fSign, a_uVal) \
    RTFLOAT64U_INIT((a_fSign), \
                    ((a_uVal) || (a_fQuiet) ? (a_uVal) : UINT64_C(1)) | ((a_fQuiet) ? RT_BIT_64(RTFLOAT64U_FRACTION_BITS - 1) : UINT64_C(0)), \
                    RTFLOAT64U_EXP_MAX)

/** The exponent bias for the RTFLOAT64U format. */
#define RTFLOAT64U_EXP_BIAS                     (1023)
/** The max exponent value for the RTFLOAT64U format. */
#define RTFLOAT64U_EXP_MAX                      (2047)
/** The exponent bias overflow/underflow adjust for the RTFLOAT64U format.
 * @note 754-1985 sec 7.3 & 7.4, not mentioned in later standard versions. */
#define RTFLOAT64U_EXP_BIAS_ADJUST              (1536)
/** Fraction width (in bits) for the RTFLOAT64U format. */
#define RTFLOAT64U_FRACTION_BITS                (52)
/** Check if two 64-bit floating values are identical (memcmp, not
 *  numerically). */
#define RTFLOAT64U_ARE_IDENTICAL(a_pLeft, a_pRight)             ((a_pLeft)->u == (a_pRight)->u)
/** @name RTFLOAT64U classification macros
 * @{ */
#define RTFLOAT64U_IS_ZERO(a_pr64)              (((a_pr64)->u & (RT_BIT_64(63) - 1)) == 0)
#define RTFLOAT64U_IS_SUBNORMAL(a_pr64)         (   (a_pr64)->s.uExponent == 0 \
                                                 && ((a_pr64)->s.uFractionLow != 0 || (a_pr64)->s.uFractionHigh != 0) )
#define RTFLOAT64U_IS_INF(a_pr64)               (   (a_pr64)->s.uExponent == 0x7ff \
                                                 && (a_pr64)->s.uFractionLow == 0 && (a_pr64)->s.uFractionHigh == 0)
#define RTFLOAT64U_IS_SIGNALLING_NAN(a_pr64)    (   (a_pr64)->s.uExponent == 0x7ff \
                                                 && !((a_pr64)->s.uFractionHigh & RT_BIT_32(19)) \
                                                 && ((a_pr64)->s.uFractionHigh != 0 || (a_pr64)->s.uFractionLow != 0) )
#define RTFLOAT64U_IS_QUIET_NAN(a_pr64)         ((a_pr64)->s.uExponent == 0x7ff && ((a_pr64)->s.uFractionHigh & RT_BIT_32(19)))
#define RTFLOAT64U_IS_NAN(a_pr64)               (   (a_pr64)->s.uExponent == 0x7ff \
                                                 && ((a_pr64)->s.uFractionHigh != 0 || (a_pr64)->s.uFractionLow != 0) )
#define RTFLOAT64U_IS_NORMAL(a_pr64)            ((a_pr64)->s.uExponent > 0 && (a_pr64)->s.uExponent < 0x7ff)
/** @} */



#if !defined(__IBMCPP__) && !defined(__IBMC__)

/**
 * Extended Double precision floating point format (80-bit).
 */
# pragma pack(1)
typedef union RTFLOAT80U
{
    /** Format using bitfields.  */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The mantissa. */
        uint64_t                    uMantissa;
# else
        /** The mantissa. */
        uint64_t                    uMantissa;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
# endif
    } s;

    /** Format for accessing it as two separate components. */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign bit and exponent. */
        uint16_t                    uSignAndExponent;
        /** The mantissa. */
        uint64_t                    uMantissa;
# else
        /** The mantissa. */
        uint64_t                    uMantissa;
        /** The sign bit and exponent. */
        uint16_t                    uSignAndExponent;
# endif
    } s2;

# ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    /** 64-bit bitfields exposing the J bit and the fraction.  */
    RT_GCC_EXTENSION struct
    {
#  ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The J bit, aka the integer bit. */
        RT_GCC_EXTENSION uint64_t   fInteger : 1;
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t   uFraction : 63;
#  else
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t   uFraction : 63;
        /** The J bit, aka the integer bit. */
        RT_GCC_EXTENSION uint64_t   fInteger : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
#  endif
    } sj64;
# endif

    /** 64-bit view. */
    uint64_t    au64[1];
    /** 32-bit view. */
    uint32_t    au32[2];
    /** 16-bit view. */
    uint16_t    au16[5];
    /** 8-bit view. */
    uint8_t     au8[10];
} RTFLOAT80U;
# pragma pack()
/** Pointer to a extended precision floating point format union. */
typedef RTFLOAT80U RT_FAR *PRTFLOAT80U;
/** Pointer to a const extended precision floating point format union. */
typedef const RTFLOAT80U RT_FAR *PCRTFLOAT80U;
/** RTFLOAT80U initializer. */
# ifdef RT_BIG_ENDIAN
#  define RTFLOAT80U_INIT(a_fSign, a_uMantissa, a_uExponent)  { { (a_fSign), (a_uExponent), (a_uMantissa) } }
# else
#  define RTFLOAT80U_INIT(a_fSign, a_uMantissa, a_uExponent)  { { (a_uMantissa), (a_uExponent), (a_fSign) } }
# endif
# define RTFLOAT80U_INIT_C(a_fSign, a_uMantissa, a_uExponent) RTFLOAT80U_INIT((a_fSign), UINT64_C(a_uMantissa), (a_uExponent))
# define RTFLOAT80U_INIT_ZERO(a_fSign)              RTFLOAT80U_INIT((a_fSign), 0, 0)
# define RTFLOAT80U_INIT_INF(a_fSign)               RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63), RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_SIGNALLING_NAN(a_fSign)    RTFLOAT80U_INIT_SNAN((a_fSign))
# define RTFLOAT80U_INIT_SNAN(a_fSign)              RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63) | 1, RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_SNAN_EX(a_fSign, a_uVal)   RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63) | (a_uVal), RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_QUIET_NAN(a_fSign)         RTFLOAT80U_INIT_QNAN((a_fSign))
# define RTFLOAT80U_INIT_QNAN(a_fSign)              RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63) | RT_BIT_64(62), RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_QNAN_EX(a_fSign, a_uVal)   RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63) | RT_BIT_64(62) | (a_uVal), RTFLOAT80U_EXP_MAX)
#define RTFLOAT80U_INIT_NAN_EX(a_fQuiet, a_fSign, a_uVal) \
    RTFLOAT80U_INIT((a_fSign), \
                    ((a_uVal) || (a_fQuiet) ? (a_uVal) : UINT64_C(1)) | ((a_fQuiet) ? RT_BIT_64(63) | RT_BIT_64(62) : RT_BIT_64(63)), \
                    RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_INDEFINITE(a_fSign)        RTFLOAT80U_INIT((a_fSign), RT_BIT_64(63) | RT_BIT_64(62), RTFLOAT80U_EXP_MAX)
# define RTFLOAT80U_INIT_IND(a_fSign)               RTFLOAT80U_INIT_INDEFINITE(a_fSign)
/** The exponent bias for the RTFLOAT80U format. */
# define RTFLOAT80U_EXP_BIAS                    (16383)
/** The max exponent value for the RTFLOAT80U format. */
# define RTFLOAT80U_EXP_MAX                     (32767)
/** The exponent bias overflow/underflow adjust for the RTFLOAT80U format.
 * @note 754-1985 sec 7.3 & 7.4, not mentioned in later standard versions. */
# define RTFLOAT80U_EXP_BIAS_ADJUST             (24576)
/** Fraction width (in bits) for the RTFLOAT80U format. */
# define RTFLOAT80U_FRACTION_BITS               (63)
/** Check if two 80-bit floating values are identical (memcmp, not
 *  numberically). */
# define RTFLOAT80U_ARE_IDENTICAL(a_pLeft, a_pRight) \
    (   (a_pLeft)->au64[0] == (a_pRight)->au64[0] \
     && (a_pLeft)->au16[4] == (a_pRight)->au16[4] )
/** @name RTFLOAT80U classification macros
 * @{ */
/** Is @a a_pr80 +0 or -0. */
# define RTFLOAT80U_IS_ZERO(a_pr80)                 RTFLOAT80U_IS_ZERO_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_ZERO_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0 && (a_uMantissa) == 0)
/** Is @a a_pr80 a denormal (does not match psuedo-denormal). */
# define RTFLOAT80U_IS_DENORMAL(a_pr80)             RTFLOAT80U_IS_DENORMAL_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_DENORMAL_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0 && (a_uMantissa) <  RT_BIT_64(63) && (a_uMantissa) != 0)
/** Is @a a_pr80 a pseudo-denormal. */
# define RTFLOAT80U_IS_PSEUDO_DENORMAL(a_pr80)      RTFLOAT80U_IS_PSEUDO_DENORMAL_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_PSEUDO_DENORMAL_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0 && (a_uMantissa) >= RT_BIT_64(63))
/** Is @a a_pr80 denormal or pseudo-denormal. */
# define RTFLOAT80U_IS_DENORMAL_OR_PSEUDO_DENORMAL(a_pr80) \
    RTFLOAT80U_IS_DENORMAL_OR_PSEUDO_DENORMAL_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_DENORMAL_OR_PSEUDO_DENORMAL_EX(a_uMantissa, a_uExponent)     ((a_uExponent) == 0 && (a_uMantissa) != 0)
/** Is @a a_pr80 +/-pseudo-infinity. */
# define RTFLOAT80U_IS_PSEUDO_INF(a_pr80)           RTFLOAT80U_IS_PSEUDO_INF_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_PSEUDO_INF_EX(a_uMantissa, a_uExponent)  ((a_uExponent) == 0x7fff && (a_uMantissa) == 0)
/** Is @a a_pr80 pseudo-not-a-number. */
# define RTFLOAT80U_IS_PSEUDO_NAN(a_pr80)           RTFLOAT80U_IS_PSEUDO_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_PSEUDO_NAN_EX(a_uMantissa, a_uExponent)  ((a_uExponent) == 0x7fff && !((a_uMantissa) & RT_BIT_64(63)))
/** Is @a a_pr80 infinity (does not match pseudo-infinity). */
# define RTFLOAT80U_IS_INF(a_pr80)                  RTFLOAT80U_IS_INF_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_INF_EX(a_uMantissa, a_uExponent)         ((a_uExponent) == 0x7fff && (a_uMantissa) == RT_BIT_64(63))
/** Is @a a_pr80 a signalling not-a-number value. */
# define RTFLOAT80U_IS_SIGNALLING_NAN(a_pr80)       RTFLOAT80U_IS_SIGNALLING_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_SIGNALLING_NAN_EX(a_uMantissa, a_uExponent) \
    (   (a_uExponent) == 0x7fff \
     && ((a_uMantissa) & (RT_BIT_64(63) | RT_BIT_64(62))) == RT_BIT_64(63) \
     && ((a_uMantissa) & (RT_BIT_64(62) - 1)) != 0)
/** Is @a a_pr80 a quiet not-a-number value. */
# define RTFLOAT80U_IS_QUIET_NAN(a_pr80)            RTFLOAT80U_IS_QUIET_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_QUIET_NAN_EX(a_uMantissa, a_uExponent) \
    (   (a_uExponent) == 0x7fff \
     && ((a_uMantissa) & (RT_BIT_64(63) | RT_BIT_64(62))) == (RT_BIT_64(63) | RT_BIT_64(62)) \
     && ((a_uMantissa) & (RT_BIT_64(62) - 1)) != 0)
/** Is @a a_pr80 Signalling-, Quiet- or Pseudo-NaN. */
# define RTFLOAT80U_IS_NAN(a_pr80)                  RTFLOAT80U_IS_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_NAN_EX(a_uMantissa, a_uExponent) ((a_uExponent) == 0x7fff && ((a_uMantissa) & (RT_BIT_64(63) - 1)) != 0)
/** Is @a a_pr80 Signalling- or Quiet-Nan, but not Pseudo-NaN. */
# define RTFLOAT80U_IS_QUIET_OR_SIGNALLING_NAN(a_pr80) \
     RTFLOAT80U_IS_QUIET_OR_SIGNALLING_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_QUIET_OR_SIGNALLING_NAN_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0x7fff && ((a_uMantissa) > RT_BIT_64(63)))
/** Is @a a_pr80 indefinite (ignoring sign). */
# define RTFLOAT80U_IS_INDEFINITE(a_pr80)           RTFLOAT80U_IS_INDEFINITE_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_INDEFINITE_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0x7fff && (a_uMantissa) == (RT_BIT_64(63) | RT_BIT_64(62)))
/** Is @a a_pr80 Indefinite, Signalling- or Quiet-Nan, but not Pseudo-NaN (nor Infinity). */
# define RTFLOAT80U_IS_INDEFINITE_OR_QUIET_OR_SIGNALLING_NAN(a_pr80) \
    RTFLOAT80U_IS_INDEFINITE_OR_QUIET_OR_SIGNALLING_NAN_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_INDEFINITE_OR_QUIET_OR_SIGNALLING_NAN_EX(a_uMantissa, a_uExponent) \
    ((a_uExponent) == 0x7fff && (a_uMantissa) > RT_BIT_64(63))
/** Is @a a_pr80 an unnormal value (invalid operand on 387+). */
# define RTFLOAT80U_IS_UNNORMAL(a_pr80)             RTFLOAT80U_IS_UNNORMAL_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_UNNORMAL_EX(a_uMantissa, a_uExponent) \
    (!((a_uMantissa) & RT_BIT_64(63)) && (a_uExponent) > 0 && (a_uExponent) < 0x7fff) /* a_uExponent can be signed and up to 64-bit wide */
/** Is @a a_pr80 a normal value (excludes zero). */
# define RTFLOAT80U_IS_NORMAL(a_pr80)               RTFLOAT80U_IS_NORMAL_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
# define RTFLOAT80U_IS_NORMAL_EX(a_uMantissa, a_uExponent) \
    (((a_uMantissa) & RT_BIT_64(63))  && (a_uExponent) > 0 && (a_uExponent) < 0x7fff) /* a_uExponent can be signed and up to 64-bit wide */
/** Invalid 387 (and later) operands: Pseudo-Infinity, Psuedo-NaN, Unnormals. */
#define RTFLOAT80U_IS_387_INVALID(a_pr80)           RTFLOAT80U_IS_387_INVALID_EX((a_pr80)->s.uMantissa, (a_pr80)->s.uExponent)
#define RTFLOAT80U_IS_387_INVALID_EX(a_uMantissa, a_uExponent) \
    (!((a_uMantissa) & RT_BIT_64(63)) && (a_uExponent) > 0)
/** @} */


/**
 * A variant of RTFLOAT80U that may be larger than 80-bits depending on how the
 * compiler implements long double.
 *
 * @note On AMD64 systems implementing the System V ABI, this will be 16 bytes!
 *       The last 6 bytes are unused padding taken up by the long double view.
 */
# pragma pack(1)
typedef union RTFLOAT80U2
{
    /** Format using bitfields.  */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The mantissa. */
        uint64_t                    uMantissa;
# else
        /** The mantissa. */
        uint64_t                    uMantissa;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
# endif
    } s;

    /** Format for accessing it as two separate components. */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign bit and exponent. */
        uint16_t                    uSignAndExponent;
        /** The mantissa. */
        uint64_t                    uMantissa;
# else
        /** The mantissa. */
        uint64_t                    uMantissa;
        /** The sign bit and exponent. */
        uint16_t                    uSignAndExponent;
# endif
    } s2;

    /** Bitfield exposing the J bit and the fraction.  */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The J bit, aka the integer bit. */
        uint32_t                    fInteger : 1;
        /** The fraction, bits 32 thru 62. */
        uint32_t                    uFractionHigh : 31;
        /** The fraction, bits 0 thru 31. */
        uint32_t                    uFractionLow : 32;
# else
        /** The fraction, bits 0 thru 31. */
        uint32_t                    uFractionLow : 32;
        /** The fraction, bits 32 thru 62. */
        uint32_t                    uFractionHigh : 31;
        /** The J bit, aka the integer bit. */
        uint32_t                    fInteger : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
# endif
    } sj;

# ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    /** 64-bit bitfields exposing the J bit and the fraction.  */
    RT_GCC_EXTENSION struct
    {
#  ifdef RT_BIG_ENDIAN /** @todo big endian mapping is wrong. */
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The J bit, aka the integer bit. */
        RT_GCC_EXTENSION uint64_t   fInteger : 1;
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t   uFraction : 63;
#  else
        /** The fraction. */
        RT_GCC_EXTENSION uint64_t   uFraction : 63;
        /** The J bit, aka the integer bit. */
        RT_GCC_EXTENSION uint64_t   fInteger : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint16_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint16_t   fSign : 1;
#  endif
    } sj64;
# endif

# ifdef RT_COMPILER_WITH_80BIT_LONG_DOUBLE
    /** Long double view. */
    long double lrd, r;
# endif
    /** 64-bit view. */
    uint64_t    au64[1];
    /** 32-bit view. */
    uint32_t    au32[2];
    /** 16-bit view. */
    uint16_t    au16[5];
    /** 8-bit view. */
    uint8_t     au8[10];
} RTFLOAT80U2;
# pragma pack()
/** Pointer to a extended precision floating point format union, 2nd
 * variant. */
typedef RTFLOAT80U2 RT_FAR *PRTFLOAT80U2;
/** Pointer to a const extended precision floating point format union, 2nd
 * variant. */
typedef const RTFLOAT80U2 RT_FAR *PCRTFLOAT80U2;

#endif /* uint16_t bitfields doesn't work */


/**
 * Quadruple precision floating point format (128-bit).
 */
typedef union RTFLOAT128U
{
    /** Format using regular bitfields.  */
    struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign indicator. */
        uint32_t    fSign : 1;
        /** The exponent (offsetted by 16383). */
        uint32_t    uExponent : 15;
        /** The fraction, bits 96 thru 111. */
        uint32_t    uFractionHigh : 16;
        /** The fraction, bits 64 thru 95. */
        uint32_t    uFractionMid;
        /** The fraction, bits 0 thru 63. */
        uint64_t    uFractionLow;
# else
        /** The fraction, bits 0 thru 63. */
        uint64_t    uFractionLow;
        /** The fraction, bits 64 thru 95. */
        uint32_t    uFractionMid;
        /** The fraction, bits 96 thru 111. */
        uint32_t    uFractionHigh : 16;
        /** The exponent (offsetted by 16383). */
        uint32_t    uExponent : 15;
        /** The sign indicator. */
        uint32_t    fSign : 1;
# endif
    } s;

    /** Format for accessing it as two separate components.  */
    struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign bit and exponent. */
        uint16_t    uSignAndExponent;
        /** The fraction, bits 96 thru 111. */
        uint16_t    uFractionHigh;
        /** The fraction, bits 64 thru 95. */
        uint32_t    uFractionMid;
        /** The fraction, bits 0 thru 63. */
        uint64_t    uFractionLow;
# else
        /** The fraction, bits 0 thru 63. */
        uint64_t    uFractionLow;
        /** The fraction, bits 64 thru 95. */
        uint32_t    uFractionMid;
        /** The fraction, bits 96 thru 111. */
        uint16_t    uFractionHigh;
        /** The sign bit and exponent. */
        uint16_t    uSignAndExponent;
# endif
    } s2;

#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    /** Format using 64-bit bitfields.  */
    RT_GCC_EXTENSION struct
    {
# ifdef RT_BIG_ENDIAN
        /** The sign indicator. */
        RT_GCC_EXTENSION uint64_t   fSign : 1;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint64_t   uExponent : 15;
        /** The fraction, bits 64 thru 111. */
        RT_GCC_EXTENSION uint64_t   uFractionHi : 48;
        /** The fraction, bits 0 thru 63. */
        uint64_t                    uFractionLo;
# else
        /** The fraction, bits 0 thru 63. */
        uint64_t                    uFractionLo;
        /** The fraction, bits 64 thru 111. */
        RT_GCC_EXTENSION uint64_t   uFractionHi : 48;
        /** The exponent (offsetted by 16383). */
        RT_GCC_EXTENSION uint64_t   uExponent : 15;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint64_t   fSign : 1;
# endif
    } s64;
#endif

#ifdef RT_COMPILER_WITH_128BIT_LONG_DOUBLE
    /** Long double view. */
    long double lrd, r;
#endif
    /** 128-bit view. */
    RTUINT128U  u128;
    /** 64-bit view. */
    uint64_t    au64[2];
    /** 32-bit view. */
    uint32_t    au32[4];
    /** 16-bit view. */
    uint16_t    au16[8];
    /** 8-bit view. */
    uint8_t     au8[16];
} RTFLOAT128U;
/** Pointer to a quadruple precision floating point format union. */
typedef RTFLOAT128U RT_FAR *PRTFLOAT128U;
/** Pointer to a const quadruple precision floating point format union. */
typedef const RTFLOAT128U RT_FAR *PCRTFLOAT128U;
/** RTFLOAT128U initializer. */
#ifdef RT_BIG_ENDIAN
# define RTFLOAT128U_INIT(a_fSign, a_uFractionHi, a_uFractionLo, a_uExponent)     \
    { { (a_fSign), (a_uExponent), (uint32_t)((a_uFractionHi) >> 32), (uint32_t)((a_uFractionHi) & UINT32_MAX), (a_uFractionLo) } }
#else
# define RTFLOAT128U_INIT(a_fSign, a_uFractionHi, a_uFractionLo, a_uExponent)     \
    { { (a_uFractionLo), (uint32_t)((a_uFractionHi) & UINT32_MAX), (uint32_t)((a_uFractionHi) >> 32), (a_uExponent), (a_fSign) } }
#endif
#define RTFLOAT128U_INIT_C(a_fSign, a_uFractionHi, a_uFractionLo, a_uExponent) \
    RTFLOAT128U_INIT((a_fSign), UINT64_C(a_uFractionHi), UINT64_C(a_uFractionLo), (a_uExponent))

#define RTFLOAT128U_INIT_ZERO(a_fSign)               RTFLOAT128U_INIT((a_fSign), UINT64_C(0), UINT64_C(0), 0)
#define RTFLOAT128U_INIT_INF(a_fSign)                RTFLOAT128U_INIT((a_fSign), UINT64_C(0), UINT64_C(0), RTFLOAT128U_EXP_MAX)
#define RTFLOAT128U_INIT_SNAN(a_fSign)               RTFLOAT128U_INIT((a_fSign), UINT64_C(0), UINT64_C(1), RTFLOAT128U_EXP_MAX)
#define RTFLOAT128U_INIT_SNAN_EX(a_fSign, a_uValHi, a_uValLo) \
    RTFLOAT128U_INIT((a_fSign), (a_uValHi), (a_uValHi) || (a_uValLo) ? (a_uValLo) : UINT64_C(1), RTFLOAT128U_EXP_MAX)
#define RTFLOAT128U_INIT_SIGNALLING_NAN(a_fSign)     RTFLOAT128U_INIT_SNAN(a_fSign)
#define RTFLOAT128U_INIT_QNAN(a_fSign) \
    RTFLOAT128U_INIT((a_fSign), RT_BIT_64(RTFLOAT128U_FRACTION_BITS - 1 - 64), UINT64_C(0), RTFLOAT128U_EXP_MAX)
#define RTFLOAT128U_INIT_QNAN_EX(a_fSign, a_uValHi, a_uValLo) \
    RTFLOAT128U_INIT((a_fSign), RT_BIT_64(RTFLOAT128U_FRACTION_BITS - 1 - 64) | (a_uValHi), (a_uValLo), RTFLOAT128U_EXP_MAX)
#define RTFLOAT128U_INIT_QUIET_NAN(a_fSign)          RTFLOAT128U_INIT_QNAN(a_fSign)
#define RTFLOAT128U_INIT_NAN_EX(a_fQuiet, a_fSign, a_uValHi, a_uValLo) \
    RTFLOAT128U_INIT((a_fSign), \
                     ((a_fQuiet) ? RT_BIT_64(RTFLOAT128U_FRACTION_BITS - 1 - 64) : 0) | (a_uValHi), \
                     (a_uValLo) || (a_uValHi) || (a_fQuiet) ? (a_uValLo) : UINT64_C(1), \
                     RTFLOAT128U_EXP_MAX)

/** The exponent bias for the RTFLOAT128U format. */
#define RTFLOAT128U_EXP_BIAS                    (16383)
/** The max exponent value for the RTFLOAT128U format. */
#define RTFLOAT128U_EXP_MAX                     (32767)
/** The exponent bias overflow/underflow adjust for the RTFLOAT128U format.
 * @note This is stipulated based on RTFLOAT80U, it doesn't appear in any
 *       standard text as far as we know. */
#define RTFLOAT128U_EXP_BIAS_ADJUST             (24576)
/** Fraction width (in bits) for the RTFLOAT128U format. */
#define RTFLOAT128U_FRACTION_BITS               (112)
/** Check if two 128-bit floating values are identical (memcmp, not
 *  numerically). */
#define RTFLOAT128U_ARE_IDENTICAL(a_pLeft, a_pRight) \
    ( (a_pLeft)->au64[0] == (a_pRight)->au64[0] && (a_pLeft)->au64[1] == (a_pRight)->au64[1] )
/** @name RTFLOAT128U classification macros
 * @{ */
#define RTFLOAT128U_IS_ZERO(a_pr128)            (   (a_pr128)->u128.s.Lo == 0 \
                                                 && ((a_pr128)->u128.s.Hi & (RT_BIT_64(63) - 1)) == 0)
#define RTFLOAT128U_IS_SUBNORMAL(a_pr128)       (   (a_pr128)->s.uExponent == 0 \
                                                 && (   (a_pr128)->s.uFractionLow  != 0 \
                                                     || (a_pr128)->s.uFractionMid  != 0 \
                                                     || (a_pr128)->s.uFractionHigh != 0 ) )
#define RTFLOAT128U_IS_INF(a_pr128)             (   (a_pr128)->s.uExponent     == RTFLOAT128U_EXP_MAX \
                                                 && (a_pr128)->s.uFractionHigh == 0 \
                                                 && (a_pr128)->s.uFractionMid  == 0 \
                                                 && (a_pr128)->s.uFractionLow  == 0 )
#define RTFLOAT128U_IS_SIGNALLING_NAN(a_pr128)  (   (a_pr128)->s.uExponent == RTFLOAT128U_EXP_MAX \
                                                 && !((a_pr128)->s.uFractionHigh & RT_BIT_32(15)) \
                                                 && (   (a_pr128)->s.uFractionHigh != 0 \
                                                     || (a_pr128)->s.uFractionMid  != 0 \
                                                     || (a_pr128)->s.uFractionLow  != 0) )
#define RTFLOAT128U_IS_QUIET_NAN(a_pr128)       (   (a_pr128)->s.uExponent == RTFLOAT128U_EXP_MAX \
                                                 && ((a_pr128)->s.uFractionHigh & RT_BIT_32(15)))
#define RTFLOAT128U_IS_NAN(a_pr128)             (   (a_pr128)->s.uExponent == RTFLOAT128U_EXP_MAX \
                                                 && (   (a_pr128)->s.uFractionLow  != 0 \
                                                     || (a_pr128)->s.uFractionMid  != 0 \
                                                     || (a_pr128)->s.uFractionHigh != 0) )
#define RTFLOAT128U_IS_NORMAL(a_pr128)          ((a_pr128)->s.uExponent > 0 && (a_pr128)->s.uExponent < RTFLOAT128U_EXP_MAX)
/** @} */


/**
 * Packed BCD 18-digit signed integer format (80-bit).
 */
#pragma pack(1)
typedef union RTPBCD80U
{
    /** Format using bitfields.  */
    RT_GCC_EXTENSION struct
    {
        /** 18 packed BCD digits, two to a byte. */
        uint8_t                     abPairs[9];
        /** Padding, non-zero if indefinite. */
        RT_GCC_EXTENSION uint8_t    uPad : 7;
        /** The sign indicator. */
        RT_GCC_EXTENSION uint8_t    fSign : 1;
    } s;

    /** 64-bit view. */
    uint64_t    au64[1];
    /** 32-bit view. */
    uint32_t    au32[2];
    /** 16-bit view. */
    uint16_t    au16[5];
    /** 8-bit view. */
    uint8_t     au8[10];
} RTPBCD80U;
#pragma pack()
/** Pointer to a packed BCD integer format union. */
typedef RTPBCD80U RT_FAR *PRTPBCD80U;
/** Pointer to a const packed BCD integer format union. */
typedef const RTPBCD80U RT_FAR *PCRTPBCD80U;
/** RTPBCD80U initializer. */
#define RTPBCD80U_INIT_C(a_fSign, a_D17, a_D16, a_D15, a_D14, a_D13, a_D12, a_D11, a_D10, \
                         a_D9, a_D8, a_D7, a_D6, a_D5, a_D4, a_D3, a_D2, a_D1, a_D0) \
    RTPBCD80U_INIT_EX_C(0, a_fSign, a_D17, a_D16, a_D15, a_D14, a_D13, a_D12, a_D11, a_D10, \
                        a_D9, a_D8, a_D7, a_D6, a_D5, a_D4, a_D3, a_D2, a_D1, a_D0)
/** Extended RTPBCD80U initializer. */
#define RTPBCD80U_INIT_EX_C(a_uPad, a_fSign, a_D17, a_D16, a_D15, a_D14, a_D13, a_D12, a_D11, a_D10, \
                            a_D9, a_D8, a_D7, a_D6, a_D5, a_D4, a_D3, a_D2, a_D1, a_D0) \
    { { { RTPBCD80U_MAKE_PAIR(a_D1, a_D0), \
          RTPBCD80U_MAKE_PAIR(a_D3, a_D2), \
          RTPBCD80U_MAKE_PAIR(a_D5, a_D4), \
          RTPBCD80U_MAKE_PAIR(a_D7, a_D6), \
          RTPBCD80U_MAKE_PAIR(a_D9, a_D8), \
          RTPBCD80U_MAKE_PAIR(a_D11, a_D10), \
          RTPBCD80U_MAKE_PAIR(a_D13, a_D12), \
          RTPBCD80U_MAKE_PAIR(a_D15, a_D14), \
          RTPBCD80U_MAKE_PAIR(a_D17, a_D16), }, (a_uPad), (a_fSign) } }
/** RTPBCD80U initializer for the zero value. */
#define RTPBCD80U_INIT_ZERO(a_fSign)    RTPBCD80U_INIT_C(a_fSign, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0)
/** RTPBCD80U initializer for the indefinite value. */
#define RTPBCD80U_INIT_INDEFINITE()     RTPBCD80U_INIT_EX_C(0x7f,1, 0xf,0xf, 0xc,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0)
/** RTPBCD80U initializer for the minimum value. */
#define RTPBCD80U_INIT_MIN()            RTPBCD80U_INIT_C(1, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9)
/** RTPBCD80U initializer for the maximum value. */
#define RTPBCD80U_INIT_MAX()            RTPBCD80U_INIT_C(0, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9, 9,9)
/** RTPBCD80U minimum value. */
#define RTPBCD80U_MIN                   INT64_C(-999999999999999999)
/** RTPBCD80U maximum value. */
#define RTPBCD80U_MAX                   INT64_C(999999999999999999)
/** Makes a packs a pair of BCD digits. */
#define RTPBCD80U_MAKE_PAIR(a_D1, a_D0) ((a_D0) | ((a_D1) << 4))
/** Retrieves the lower digit of a BCD digit pair. */
#define RTPBCD80U_LO_DIGIT(a_bPair)     ((a_bPair) & 0xf)
/** Retrieves the higher digit of a BCD digit pair. */
#define RTPBCD80U_HI_DIGIT(a_bPair)     ((a_bPair) >> 4)
/** Checks if the packaged BCD number is representing indefinite. */
#define RTPBCD80U_IS_INDEFINITE(a_pd80) \
    (   (a_pd80)->s.uPad       == 0x7f \
     && (a_pd80)->s.fSign      == 1 \
     && (a_pd80)->s.abPairs[8] == 0xff \
     && (a_pd80)->s.abPairs[7] == RTPBCD80U_MAKE_PAIR(0xc, 0) \
     && (a_pd80)->s.abPairs[6] == 0 \
     && (a_pd80)->s.abPairs[5] == 0 \
     && (a_pd80)->s.abPairs[4] == 0 \
     && (a_pd80)->s.abPairs[3] == 0 \
     && (a_pd80)->s.abPairs[2] == 0 \
     && (a_pd80)->s.abPairs[1] == 0 \
     && (a_pd80)->s.abPairs[0] == 0)
/** Check if @a a_pd80Left and @a a_pd80Right are exactly the same. */
#define RTPBCD80U_ARE_IDENTICAL(a_pd80Left, a_pd80Right) \
    ( (a_pd80Left)->au64[0] == (a_pd80Right)->au64[0] && (a_pd80Left)->au16[4] == (a_pd80Right)->au16[4] )


/** Generic function type.
 * @see PFNRT
 */
typedef DECLCALLBACKTYPE(void, FNRT,(void));

/** Generic function pointer.
 * With -pedantic, gcc-4 complains when casting a function to a data object, for
 * example:
 *
 * @code
 *    void foo(void)
 *    {
 *    }
 *
 *    void *bar = (void *)foo;
 * @endcode
 *
 * The compiler would warn with "ISO C++ forbids casting between
 * pointer-to-function and pointer-to-object".  The purpose of this warning is
 * not to bother the programmer but to point out that he is probably doing
 * something dangerous, assigning a pointer to executable code to a data object.
 */
typedef FNRT *PFNRT;

/** Variant on PFNRT that takes one pointer argument. */
typedef DECLCALLBACKTYPE(void, FNRT1,(void *pvArg));
/** Pointer to FNRT1. */
typedef FNRT1 *PFNRT1;

/** Millisecond interval. */
typedef uint32_t                        RTMSINTERVAL;
/** Pointer to a millisecond interval. */
typedef RTMSINTERVAL            RT_FAR *PRTMSINTERVAL;
/** Pointer to a const millisecond interval. */
typedef const RTMSINTERVAL      RT_FAR *PCRTMSINTERVAL;

/** Pointer to a time spec structure. */
typedef struct RTTIMESPEC       RT_FAR *PRTTIMESPEC;
/** Pointer to a const time spec structure. */
typedef const struct RTTIMESPEC RT_FAR *PCRTTIMESPEC;



/** @defgroup grp_rt_types_both  Common Guest and Host Context Basic Types
 * @{
 */

/** Signed integer which can contain both GC and HC pointers. */
#if HC_ARCH_BITS == 16
typedef int32_t                 RTINTPTR;
#else
typedef int64_t                 RTINTPTR;
#endif
/** Pointer to signed integer which can contain both GC and HC pointers. */
typedef RTINTPTR        RT_FAR *PRTINTPTR;
/** Pointer const to signed integer which can contain both GC and HC pointers. */
typedef const RTINTPTR  RT_FAR *PCRTINTPTR;
/** The maximum value the RTINTPTR type can hold. */
#if HC_ARCH_BITS == 16
# define RTINTPTR_MAX           INT32_MAX
#else
# define RTINTPTR_MAX           INT64_MAX
#endif
/** The minimum value the RTINTPTR type can hold. */
#if HC_ARCH_BITS == 16
# define RTINTPTR_MIN           INT32_MIN
#else
# define RTINTPTR_MIN           INT64_MIN
#endif

/** Unsigned integer which can contain both GC and HC pointers. */
#if HC_ARCH_BITS == 16
typedef uint32_t                RTUINTPTR;
#else
typedef uint64_t                RTUINTPTR;
#endif
/** Pointer to unsigned integer which can contain both GC and HC pointers. */
typedef RTUINTPTR       RT_FAR *PRTUINTPTR;
/** Pointer const to unsigned integer which can contain both GC and HC pointers. */
typedef const RTUINTPTR RT_FAR *PCRTUINTPTR;
/** The maximum value the RTUINTPTR type can hold. */
#if HC_ARCH_BITS == 16
# define RTUINTPTR_MAX          UINT32_MAX
#else
# define RTUINTPTR_MAX          UINT64_MAX
#endif

/** Signed integer. */
typedef int32_t                 RTINT;
/** Pointer to signed integer. */
typedef RTINT           RT_FAR *PRTINT;
/** Pointer to const signed integer. */
typedef const RTINT     RT_FAR *PCRTINT;

/** Unsigned integer. */
typedef uint32_t                RTUINT;
/** Pointer to unsigned integer. */
typedef RTUINT          RT_FAR *PRTUINT;
/** Pointer to const unsigned integer. */
typedef const RTUINT    RT_FAR *PCRTUINT;

/** A file offset / size (off_t). */
typedef int64_t                 RTFOFF;
/** Pointer to a file offset / size. */
typedef RTFOFF          RT_FAR *PRTFOFF;
/** The max value for RTFOFF. */
#define RTFOFF_MAX              INT64_MAX
/** The min value for RTFOFF. */
#define RTFOFF_MIN              INT64_MIN

/** File mode (see iprt/fs.h). */
typedef uint32_t                RTFMODE;
/** Pointer to file mode. */
typedef RTFMODE         RT_FAR *PRTFMODE;

/** Device unix number. */
typedef uint32_t                RTDEV;
/** Pointer to a device unix number. */
typedef RTDEV           RT_FAR *PRTDEV;

/** @name RTDEV Macros
 * @{  */
/**
 * Our makedev macro.
 * @returns RTDEV
 * @param   uMajor          The major device number.
 * @param   uMinor          The minor device number.
 */
#define RTDEV_MAKE(uMajor, uMinor)      ((RTDEV)( ((RTDEV)(uMajor) << 24) | (uMinor & UINT32_C(0x00ffffff)) ))
/**
 * Get the major device node number from an RTDEV type.
 * @returns The major device number of @a uDev
 * @param   uDev            The device number.
 */
#define RTDEV_MAJOR(uDev)               ((uDev) >> 24)
/**
 * Get the minor device node number from an RTDEV type.
 * @returns The minor device number of @a uDev
 * @param   uDev            The device number.
 */
#define RTDEV_MINOR(uDev)               ((uDev) & UINT32_C(0x00ffffff))
/** @}  */

/** i-node number. */
typedef uint64_t                RTINODE;
/** Pointer to a i-node number. */
typedef RTINODE         RT_FAR *PRTINODE;

/** User id. */
typedef uint32_t                RTUID;
/** Pointer to a user id. */
typedef RTUID           RT_FAR *PRTUID;
/** NIL user id.
 * @todo check this for portability! */
#define NIL_RTUID               (~(RTUID)0)

/** Group id. */
typedef uint32_t                RTGID;
/** Pointer to a group id. */
typedef RTGID           RT_FAR *PRTGID;
/** NIL group id.
 * @todo check this for portability! */
#define NIL_RTGID               (~(RTGID)0)

/** I/O Port. */
typedef uint16_t                RTIOPORT;
/** Pointer to I/O Port. */
typedef RTIOPORT        RT_FAR *PRTIOPORT;
/** Pointer to const I/O Port. */
typedef const RTIOPORT  RT_FAR *PCRTIOPORT;

/** Selector. */
typedef uint16_t                RTSEL;
/** Pointer to selector. */
typedef RTSEL           RT_FAR *PRTSEL;
/** Pointer to const selector. */
typedef const RTSEL     RT_FAR *PCRTSEL;
/** Max selector value. */
#define RTSEL_MAX               UINT16_MAX

/** Far 16-bit pointer. */
#pragma pack(1)
typedef struct RTFAR16
{
    uint16_t        off;
    RTSEL           sel;
} RTFAR16;
#pragma pack()
/** Pointer to Far 16-bit pointer. */
typedef RTFAR16 RT_FAR *PRTFAR16;
/** Pointer to const Far 16-bit pointer. */
typedef const RTFAR16 RT_FAR *PCRTFAR16;

/** Far 32-bit pointer. */
#pragma pack(1)
typedef struct RTFAR32
{
    uint32_t        off;
    RTSEL           sel;
} RTFAR32;
#pragma pack()
/** Pointer to Far 32-bit pointer. */
typedef RTFAR32 RT_FAR *PRTFAR32;
/** Pointer to const Far 32-bit pointer. */
typedef const RTFAR32 RT_FAR *PCRTFAR32;

/** Far 64-bit pointer. */
#pragma pack(1)
typedef struct RTFAR64
{
    uint64_t        off;
    RTSEL           sel;
} RTFAR64;
#pragma pack()
/** Pointer to Far 64-bit pointer. */
typedef RTFAR64 RT_FAR *PRTFAR64;
/** Pointer to const Far 64-bit pointer. */
typedef const RTFAR64 RT_FAR *PCRTFAR64;

/** @} */


/** @defgroup grp_rt_types_hc  Host Context Basic Types
 * @{
 */

/** HC Natural signed integer.
 * @deprecated silly type. */
typedef int32_t                 RTHCINT;
/** Pointer to HC Natural signed integer.
 * @deprecated silly type. */
typedef RTHCINT         RT_FAR *PRTHCINT;
/** Pointer to const HC Natural signed integer.
 * @deprecated silly type. */
typedef const RTHCINT   RT_FAR *PCRTHCINT;

/** HC Natural unsigned integer.
 * @deprecated silly type. */
typedef uint32_t                RTHCUINT;
/** Pointer to HC Natural unsigned integer.
 * @deprecated silly type. */
typedef RTHCUINT        RT_FAR *PRTHCUINT;
/** Pointer to const HC Natural unsigned integer.
 * @deprecated silly type. */
typedef const RTHCUINT  RT_FAR *PCRTHCUINT;


/** Signed integer which can contain a HC pointer. */
#if HC_ARCH_BITS == 32 || HC_ARCH_BITS == 16
typedef int32_t                 RTHCINTPTR;
#elif HC_ARCH_BITS == 64
typedef int64_t                 RTHCINTPTR;
#else
# error Unsupported HC_ARCH_BITS value.
#endif
/** Pointer to signed integer which can contain a HC pointer. */
typedef RTHCINTPTR      RT_FAR *PRTHCINTPTR;
/** Pointer to const signed integer which can contain a HC pointer. */
typedef const RTHCINTPTR RT_FAR *PCRTHCINTPTR;
/** Max RTHCINTPTR value. */
#if HC_ARCH_BITS == 32
# define RTHCINTPTR_MAX         INT32_MAX
#elif HC_ARCH_BITS == 64
# define RTHCINTPTR_MAX         INT64_MAX
#else
# define RTHCINTPTR_MAX         INT16_MAX
#endif
/** Min RTHCINTPTR value. */
#if HC_ARCH_BITS == 32
# define RTHCINTPTR_MIN         INT32_MIN
#elif HC_ARCH_BITS == 64
# define RTHCINTPTR_MIN         INT64_MIN
#else
# define RTHCINTPTR_MIN         INT16_MIN
#endif

/** Signed integer which can contain a HC ring-3 pointer. */
#if R3_ARCH_BITS == 32 || R3_ARCH_BITS == 16
typedef int32_t                 RTR3INTPTR;
#elif R3_ARCH_BITS == 64
typedef int64_t                 RTR3INTPTR;
#else
#  error Unsupported R3_ARCH_BITS value.
#endif
/** Pointer to signed integer which can contain a HC ring-3 pointer. */
typedef RTR3INTPTR      RT_FAR *PRTR3INTPTR;
/** Pointer to const signed integer which can contain a HC ring-3 pointer. */
typedef const RTR3INTPTR RT_FAR *PCRTR3INTPTR;
/** Max RTR3INTPTR value. */
#if R3_ARCH_BITS == 32 || R3_ARCH_BITS == 16
# define RTR3INTPTR_MAX         INT32_MAX
#else
# define RTR3INTPTR_MAX         INT64_MAX
#endif
/** Min RTR3INTPTR value. */
#if R3_ARCH_BITS == 32 || R3_ARCH_BITS == 16
# define RTR3INTPTR_MIN         INT32_MIN
#else
# define RTR3INTPTR_MIN         INT64_MIN
#endif

/** Signed integer which can contain a HC ring-0 pointer. */
#if R0_ARCH_BITS == 32 || R0_ARCH_BITS == 16
typedef int32_t                 RTR0INTPTR;
#elif R0_ARCH_BITS == 64
typedef int64_t                 RTR0INTPTR;
#else
# error Unsupported R0_ARCH_BITS value.
#endif
/** Pointer to signed integer which can contain a HC ring-0 pointer. */
typedef RTR0INTPTR      RT_FAR *PRTR0INTPTR;
/** Pointer to const signed integer which can contain a HC ring-0 pointer. */
typedef const RTR0INTPTR RT_FAR *PCRTR0INTPTR;
/** Max RTR0INTPTR value. */
#if R0_ARCH_BITS == 32 || R0_ARCH_BITS == 16
# define RTR0INTPTR_MAX         INT32_MAX
#else
# define RTR0INTPTR_MAX         INT64_MAX
#endif
/** Min RTHCINTPTR value. */
#if R0_ARCH_BITS == 32 || R0_ARCH_BITS == 16
# define RTR0INTPTR_MIN         INT32_MIN
#else
# define RTR0INTPTR_MIN         INT64_MIN
#endif


/** Unsigned integer which can contain a HC pointer. */
#if HC_ARCH_BITS == 32 || HC_ARCH_BITS == 16
typedef uint32_t                RTHCUINTPTR;
#elif HC_ARCH_BITS == 64
typedef uint64_t                RTHCUINTPTR;
#else
# error Unsupported HC_ARCH_BITS value.
#endif
/** Pointer to unsigned integer which can contain a HC pointer. */
typedef RTHCUINTPTR     RT_FAR *PRTHCUINTPTR;
/** Pointer to unsigned integer which can contain a HC pointer. */
typedef const RTHCUINTPTR RT_FAR *PCRTHCUINTPTR;
/** Max RTHCUINTTPR value. */
#if HC_ARCH_BITS == 32 || HC_ARCH_BITS == 16
# define RTHCUINTPTR_MAX        UINT32_MAX
#else
# define RTHCUINTPTR_MAX        UINT64_MAX
#endif

/** Unsigned integer which can contain a HC ring-3 pointer. */
#if R3_ARCH_BITS == 32 || R3_ARCH_BITS == 16
typedef uint32_t                RTR3UINTPTR;
#elif R3_ARCH_BITS == 64
typedef uint64_t                RTR3UINTPTR;
#else
# error Unsupported R3_ARCH_BITS value.
#endif
/** Pointer to unsigned integer which can contain a HC ring-3 pointer. */
typedef RTR3UINTPTR     RT_FAR *PRTR3UINTPTR;
/** Pointer to unsigned integer which can contain a HC ring-3 pointer. */
typedef const RTR3UINTPTR RT_FAR *PCRTR3UINTPTR;
/** Max RTHCUINTTPR value. */
#if R3_ARCH_BITS == 32 || R3_ARCH_BITS == 16
# define RTR3UINTPTR_MAX        UINT32_MAX
#else
# define RTR3UINTPTR_MAX        UINT64_MAX
#endif

/** Unsigned integer which can contain a HC ring-0 pointer. */
#if R0_ARCH_BITS == 32 || R0_ARCH_BITS == 16
typedef uint32_t                RTR0UINTPTR;
#elif R0_ARCH_BITS == 64
typedef uint64_t                RTR0UINTPTR;
#else
# error Unsupported R0_ARCH_BITS value.
#endif
/** Pointer to unsigned integer which can contain a HC ring-0 pointer. */
typedef RTR0UINTPTR     RT_FAR *PRTR0UINTPTR;
/** Pointer to unsigned integer which can contain a HC ring-0 pointer. */
typedef const RTR0UINTPTR RT_FAR *PCRTR0UINTPTR;
/** Max RTR0UINTTPR value. */
#if R0_ARCH_BITS == 32 || R0_ARCH_BITS == 16
# define RTR0UINTPTR_MAX        UINT32_MAX
#else
# define RTR0UINTPTR_MAX        UINT64_MAX
#endif


/** Host Physical Memory Address. */
typedef uint64_t                RTHCPHYS;
/** Pointer to Host Physical Memory Address. */
typedef RTHCPHYS        RT_FAR *PRTHCPHYS;
/** Pointer to const Host Physical Memory Address. */
typedef const RTHCPHYS  RT_FAR *PCRTHCPHYS;
/** @def NIL_RTHCPHYS
 * NIL HC Physical Address.
 * NIL_RTHCPHYS is used to signal an invalid physical address, similar
 * to the NULL pointer.
 */
#define NIL_RTHCPHYS            (~(RTHCPHYS)0)
/** Max RTHCPHYS value. */
#define RTHCPHYS_MAX            UINT64_MAX


/** HC pointer. */
#if !defined(IN_RC) || defined(DOXYGEN_RUNNING)
typedef void            RT_FAR *RTHCPTR;
#else
typedef RTHCUINTPTR             RTHCPTR;
#endif
/** Pointer to HC pointer. */
typedef RTHCPTR         RT_FAR *PRTHCPTR;
/** Pointer to const HC pointer. */
typedef const RTHCPTR          *PCRTHCPTR;
/** @def NIL_RTHCPTR
 * NIL HC pointer.
 */
#define NIL_RTHCPTR             ((RTHCPTR)0)
/** Max RTHCPTR value. */
#define RTHCPTR_MAX             ((RTHCPTR)RTHCUINTPTR_MAX)


/** HC ring-3 pointer. */
#ifdef IN_RING3
typedef void            RT_FAR *RTR3PTR;
#else
typedef RTR3UINTPTR             RTR3PTR;
#endif
/** Pointer to HC ring-3 pointer. */
typedef RTR3PTR         RT_FAR *PRTR3PTR;
/** Pointer to const HC ring-3 pointer. */
typedef const RTR3PTR          *PCRTR3PTR;
/** @def NIL_RTR3PTR
 * NIL HC ring-3 pointer.
 */
#ifndef IN_RING3
# define NIL_RTR3PTR            ((RTR3PTR)0)
#else
# define NIL_RTR3PTR            (NULL)
#endif
/** Max RTR3PTR value. */
#define RTR3PTR_MAX             ((RTR3PTR)RTR3UINTPTR_MAX)

/** HC ring-0 pointer. */
#ifdef  IN_RING0
typedef void            RT_FAR *RTR0PTR;
#else
typedef RTR0UINTPTR             RTR0PTR;
#endif
/** Pointer to HC ring-0 pointer. */
typedef RTR0PTR         RT_FAR *PRTR0PTR;
/** Pointer to const HC ring-0 pointer. */
typedef const RTR0PTR          *PCRTR0PTR;
/** @def NIL_RTR0PTR
 * NIL HC ring-0 pointer.
 */
#ifndef IN_RING0
# define NIL_RTR0PTR            ((RTR0PTR)0)
#else
# define NIL_RTR0PTR            (NULL)
#endif
/** Max RTR3PTR value. */
#define RTR0PTR_MAX             ((RTR0PTR)RTR0UINTPTR_MAX)


/** Unsigned integer register in the host context. */
#if HC_ARCH_BITS == 32
typedef uint32_t                RTHCUINTREG;
#elif HC_ARCH_BITS == 64
typedef uint64_t                RTHCUINTREG;
#elif HC_ARCH_BITS == 16
typedef uint16_t                RTHCUINTREG;
#else
# error "Unsupported HC_ARCH_BITS!"
#endif
/** Pointer to an unsigned integer register in the host context. */
typedef RTHCUINTREG     RT_FAR *PRTHCUINTREG;
/** Pointer to a const unsigned integer register in the host context. */
typedef const RTHCUINTREG RT_FAR *PCRTHCUINTREG;

/** Unsigned integer register in the host ring-3 context. */
#if R3_ARCH_BITS == 32
typedef uint32_t                RTR3UINTREG;
#elif R3_ARCH_BITS == 64
typedef uint64_t                RTR3UINTREG;
#elif R3_ARCH_BITS == 16
typedef uint16_t                RTR3UINTREG;
#else
# error "Unsupported R3_ARCH_BITS!"
#endif
/** Pointer to an unsigned integer register in the host ring-3 context. */
typedef RTR3UINTREG     RT_FAR *PRTR3UINTREG;
/** Pointer to a const unsigned integer register in the host ring-3 context. */
typedef const RTR3UINTREG RT_FAR *PCRTR3UINTREG;

/** Unsigned integer register in the host ring-3 context. */
#if R0_ARCH_BITS == 32
typedef uint32_t                RTR0UINTREG;
#elif R0_ARCH_BITS == 64
typedef uint64_t                RTR0UINTREG;
#elif R0_ARCH_BITS == 16
typedef uint16_t                RTR0UINTREG;
#else
# error "Unsupported R3_ARCH_BITS!"
#endif
/** Pointer to an unsigned integer register in the host ring-3 context. */
typedef RTR0UINTREG     RT_FAR *PRTR0UINTREG;
/** Pointer to a const unsigned integer register in the host ring-3 context. */
typedef const RTR0UINTREG RT_FAR *PCRTR0UINTREG;

/** @} */


/** @defgroup grp_rt_types_gc  Guest Context Basic Types
 * @{
 */

/** Natural signed integer in the GC.
 * @deprecated silly type. */
/** @todo this isn't right, natural int is 32-bit, see RTHCINT. */
typedef int64_t                 RTGCINT;
/** Pointer to natural signed integer in GC.
 * @deprecated silly type. */
typedef RTGCINT RT_FAR         *PRTGCINT;
/** Pointer to const natural signed integer in GC.
 * @deprecated silly type. */
typedef const RTGCINT   RT_FAR *PCRTGCINT;

/** Natural unsigned integer in the GC.
 * @deprecated silly type. */
/** @todo this isn't right, natural int is 32-bit, see RTHCUINT. */
typedef uint64_t                RTGCUINT;
/** Pointer to natural unsigned integer in GC.
 * @deprecated silly type. */
typedef RTGCUINT        RT_FAR *PRTGCUINT;
/** Pointer to const natural unsigned integer in GC.
 * @deprecated silly type. */
typedef const RTGCUINT  RT_FAR *PCRTGCUINT;

/** Signed integer which can contain a GC pointer. */
typedef int64_t                 RTGCINTPTR;
/** Pointer to signed integer which can contain a GC pointer. */
typedef RTGCINTPTR      RT_FAR *PRTGCINTPTR;
/** Pointer to const signed integer which can contain a GC pointer. */
typedef const RTGCINTPTR RT_FAR *PCRTGCINTPTR;

/** Unsigned integer which can contain a GC pointer. */
typedef uint64_t                RTGCUINTPTR;
/** Pointer to unsigned integer which can contain a GC pointer. */
typedef RTGCUINTPTR     RT_FAR *PRTGCUINTPTR;
/** Pointer to unsigned integer which can contain a GC pointer. */
typedef const RTGCUINTPTR RT_FAR *PCRTGCUINTPTR;

/** Unsigned integer which can contain a 32 bits GC pointer. */
typedef uint32_t                RTGCUINTPTR32;
/** Pointer to unsigned integer which can contain a 32 bits GC pointer. */
typedef RTGCUINTPTR32   RT_FAR *PRTGCUINTPTR32;
/** Pointer to unsigned integer which can contain a 32 bits GC pointer. */
typedef const RTGCUINTPTR32 RT_FAR *PCRTGCUINTPTR32;

/** Unsigned integer which can contain a 64 bits GC pointer. */
typedef uint64_t                RTGCUINTPTR64;
/** Pointer to unsigned integer which can contain a 32 bits GC pointer. */
typedef RTGCUINTPTR64   RT_FAR *PRTGCUINTPTR64;
/** Pointer to unsigned integer which can contain a 32 bits GC pointer. */
typedef const RTGCUINTPTR64 RT_FAR *PCRTGCUINTPTR64;

/** Guest Physical Memory Address.*/
typedef uint64_t                RTGCPHYS;
/** Pointer to Guest Physical Memory Address. */
typedef RTGCPHYS        RT_FAR *PRTGCPHYS;
/** Pointer to const Guest Physical Memory Address. */
typedef const RTGCPHYS  RT_FAR *PCRTGCPHYS;
/** @def NIL_RTGCPHYS
 * NIL GC Physical Address.
 * NIL_RTGCPHYS is used to signal an invalid physical address, similar
 * to the NULL pointer. Note that this value may actually be valid in
 * some contexts.
 */
#define NIL_RTGCPHYS            (~(RTGCPHYS)0U)
/** Max guest physical memory address value. */
#define RTGCPHYS_MAX            UINT64_MAX


/** Guest Physical Memory Address; limited to 32 bits.*/
typedef uint32_t                RTGCPHYS32;
/** Pointer to Guest Physical Memory Address. */
typedef RTGCPHYS32      RT_FAR *PRTGCPHYS32;
/** Pointer to const Guest Physical Memory Address. */
typedef const RTGCPHYS32 RT_FAR *PCRTGCPHYS32;
/** @def NIL_RTGCPHYS32
 * NIL GC Physical Address.
 * NIL_RTGCPHYS32 is used to signal an invalid physical address, similar
 * to the NULL pointer. Note that this value may actually be valid in
 * some contexts.
 */
#define NIL_RTGCPHYS32          (~(RTGCPHYS32)0)


/** Guest Physical Memory Address; limited to 64 bits.*/
typedef uint64_t                RTGCPHYS64;
/** Pointer to Guest Physical Memory Address. */
typedef RTGCPHYS64      RT_FAR *PRTGCPHYS64;
/** Pointer to const Guest Physical Memory Address. */
typedef const RTGCPHYS64 RT_FAR *PCRTGCPHYS64;
/** @def NIL_RTGCPHYS64
 * NIL GC Physical Address.
 * NIL_RTGCPHYS64 is used to signal an invalid physical address, similar
 * to the NULL pointer. Note that this value may actually be valid in
 * some contexts.
 */
#define NIL_RTGCPHYS64          (~(RTGCPHYS64)0)

/** Guest context pointer, 32 bits.
 * Keep in mind that this type is an unsigned integer in
 * HC and void pointer in GC.
 */
typedef RTGCUINTPTR32           RTGCPTR32;
/** Pointer to a guest context pointer. */
typedef RTGCPTR32       RT_FAR *PRTGCPTR32;
/** Pointer to a const guest context pointer. */
typedef const RTGCPTR32 RT_FAR *PCRTGCPTR32;
/** @def NIL_RTGCPTR32
 * NIL GC pointer.
 */
#define NIL_RTGCPTR32           ((RTGCPTR32)0)

/** Guest context pointer, 64 bits.
 */
typedef RTGCUINTPTR64           RTGCPTR64;
/** Pointer to a guest context pointer. */
typedef RTGCPTR64       RT_FAR *PRTGCPTR64;
/** Pointer to a const guest context pointer. */
typedef const RTGCPTR64 RT_FAR *PCRTGCPTR64;
/** @def NIL_RTGCPTR64
 * NIL GC pointer.
 */
#define NIL_RTGCPTR64           ((RTGCPTR64)0)

/** @typedef RTGCPTR
 * Guest context pointer.
 * Keep in mind that this type is an unsigned integer in HC and void pointer in GC. */
/** @typedef PRTGCPTR
 * Pointer to a guest context pointer. */
/** @typedef PCRTGCPTR
 * Pointer to a const guest context pointer. */
/** @def NIL_RTGCPTR
 * NIL GC pointer.  */
/** @def RTGCPTR_MAX
 * Max RTGCPTR value. */
typedef RTGCPTR64               RTGCPTR;
typedef PRTGCPTR64              PRTGCPTR;
typedef PCRTGCPTR64             PCRTGCPTR;
# define NIL_RTGCPTR            NIL_RTGCPTR64
# define RTGCPTR_MAX            UINT64_MAX

/** Unsigned integer register in the guest context. */
typedef uint32_t                RTGCUINTREG32;
/** Pointer to an unsigned integer register in the guest context. */
typedef RTGCUINTREG32   RT_FAR *PRTGCUINTREG32;
/** Pointer to a const unsigned integer register in the guest context. */
typedef const RTGCUINTREG32 RT_FAR *PCRTGCUINTREG32;

typedef uint64_t                RTGCUINTREG64;
/** Pointer to an unsigned integer register in the guest context. */
typedef RTGCUINTREG64   RT_FAR *PRTGCUINTREG64;
/** Pointer to a const unsigned integer register in the guest context. */
typedef const RTGCUINTREG64 RT_FAR *PCRTGCUINTREG64;

typedef RTGCUINTREG64           RTGCUINTREG;
/** Pointer to an unsigned integer register in the guest context. */
typedef RTGCUINTREG     RT_FAR *PRTGCUINTREG;
/** Pointer to a const unsigned integer register in the guest context. */
typedef const RTGCUINTREG RT_FAR *PCRTGCUINTREG;

/** @} */

/** @defgroup grp_rt_types_rc  Raw mode Context Basic Types
 * @{
 */

/** Raw mode context pointer; a 32 bits guest context pointer.
 * Keep in mind that this type is an unsigned integer in
 * HC and void pointer in RC.
 */
#ifdef IN_RC
typedef void            RT_FAR *RTRCPTR;
#else
typedef uint32_t                RTRCPTR;
#endif
/** Pointer to a raw mode context pointer. */
typedef RTRCPTR         RT_FAR *PRTRCPTR;
/** Pointer to a const raw mode context pointer. */
typedef const RTRCPTR   RT_FAR *PCRTRCPTR;
/** @def NIL_RTRCPTR
 * NIL RC pointer.  */
#ifdef IN_RC
# define NIL_RTRCPTR            (NULL)
#else
# define NIL_RTRCPTR            ((RTRCPTR)0)
#endif
/** @def RTRCPTR_MAX
 * The maximum value a RTRCPTR can have. Mostly used as INVALID value.
 */
#define RTRCPTR_MAX             ((RTRCPTR)UINT32_MAX)

/** Raw mode context pointer, unsigned integer variant. */
typedef int32_t                 RTRCINTPTR;
/** @def RTRCUINTPTR_MAX
 * The maximum value a RTRCUINPTR can have.
 */
#define RTRCUINTPTR_MAX         ((RTRCUINTPTR)UINT32_MAX)

/** Raw mode context pointer, signed integer variant. */
typedef uint32_t                RTRCUINTPTR;
/** @def RTRCINTPTR_MIN
 * The minimum value a RTRCINPTR can have.
 */
#define RTRCINTPTR_MIN          ((RTRCINTPTR)INT32_MIN)
/** @def RTRCINTPTR_MAX
 * The maximum value a RTRCINPTR can have.
 */
#define RTRCINTPTR_MAX          ((RTRCINTPTR)INT32_MAX)

/* The following are only temporarily while we clean up RTRCPTR usage: */
#ifdef IN_RC
typedef void            RT_FAR *RTRGPTR;
#else
typedef uint64_t                RTRGPTR;
#endif
typedef RTRGPTR         RT_FAR *PRTRGPTR;
typedef const RTRGPTR   RT_FAR *PCRTRGPTR;
#ifdef IN_RC
# define NIL_RTRGPTR            (NULL)
#else
# define NIL_RTRGPTR            ((RTRGPTR)0)
#endif

/** @} */


/** @defgroup grp_rt_types_cc  Current Context Basic Types
 * @{
 */

/** Current Context Physical Memory Address.*/
#ifdef IN_RC
typedef RTGCPHYS RTCCPHYS;
#else
typedef RTHCPHYS RTCCPHYS;
#endif
/** Pointer to Current Context Physical Memory Address. */
typedef RTCCPHYS        RT_FAR *PRTCCPHYS;
/** Pointer to const Current Context Physical Memory Address. */
typedef const RTCCPHYS  RT_FAR *PCRTCCPHYS;
/** @def NIL_RTCCPHYS
 * NIL CC Physical Address.
 * NIL_RTCCPHYS is used to signal an invalid physical address, similar
 * to the NULL pointer.
 */
#ifdef IN_RC
# define NIL_RTCCPHYS           NIL_RTGCPHYS
#else
# define NIL_RTCCPHYS           NIL_RTHCPHYS
#endif

/** Unsigned integer register in the current context. */
#if ARCH_BITS == 32
typedef uint32_t                RTCCUINTREG;
#elif ARCH_BITS == 64
typedef uint64_t                RTCCUINTREG;
#elif ARCH_BITS == 16
typedef uint16_t                RTCCUINTREG;
#else
# error "Unsupported ARCH_BITS!"
#endif
/** Pointer to an unsigned integer register in the current context. */
typedef RTCCUINTREG     RT_FAR *PRTCCUINTREG;
/** Pointer to a const unsigned integer register in the current context. */
typedef RTCCUINTREG const RT_FAR *PCRTCCUINTREG;

/** Signed integer register in the current context. */
#if ARCH_BITS == 32
typedef int32_t                 RTCCINTREG;
#elif ARCH_BITS == 64
typedef int64_t                 RTCCINTREG;
#elif ARCH_BITS == 16
typedef int16_t                 RTCCINTREG;
#endif
/** Pointer to a signed integer register in the current context. */
typedef RTCCINTREG      RT_FAR *PRTCCINTREG;
/** Pointer to a const signed integer register in the current context. */
typedef RTCCINTREG const RT_FAR *PCRTCCINTREG;

/** Unsigned integer register in the current context.
 * @remarks This is for dealing with EAX in 16-bit mode. */
#if ARCH_BITS == 16 && defined(RT_ARCH_X86)
typedef uint32_t                RTCCUINTXREG;
#else
typedef RTCCUINTREG             RTCCUINTXREG;
#endif
/** Pointer to an unsigned integer register in the current context. */
typedef RTCCUINTREG     RT_FAR *PRTCCUINTXREG;
/** Pointer to a const unsigned integer register in the current context. */
typedef RTCCUINTREG const RT_FAR *PCRTCCUINTXREG;

/** Signed integer extended register in the current context.
 * @remarks This is for dealing with EAX in 16-bit mode. */
#if ARCH_BITS == 16 && defined(RT_ARCH_X86)
typedef int32_t                 RTCCINTXREG;
#else
typedef RTCCINTREG              RTCCINTXREG;
#endif
/** Pointer to a signed integer extended register in the current context. */
typedef RTCCINTXREG     RT_FAR *PRTCCINTXREG;
/** Pointer to a const signed integer extended register in the current
 * context. */
typedef RTCCINTXREG const RT_FAR *PCRTCCINTXREG;

/** @def RTCCUINTREG_C
 * Defines a constant of RTCCUINTREG type.
 * @param a_Value   Constant value  */
/** @def RTCCUINTREG_MAX
 * Max value that RTCCUINTREG can hold. */
/** @def RTCCUINTREG_FMT
 * Generic IPRT format specifier for RTCCUINTREG. */
/** @def RTCCUINTREG_XFMT
 * Generic IPRT format specifier for RTCCUINTREG, hexadecimal. */
/** @def RTCCINTREG_C
 * Defines a constant of RTCCINTREG type.
 * @param a_Value   Constant value  */
/** @def RTCCINTREG_MAX
 * Max value that RTCCINTREG can hold. */
/** @def RTCCINTREG_MIN
 * Min value that RTCCINTREG can hold. */
/** @def RTCCINTREG_XFMT
 * Generic IPRT format specifier for RTCCINTREG, hexadecimal. */
#if ARCH_BITS == 32
# define RTCCUINTREG_C(a_Value)     UINT32_C(a_Value)
# define RTCCUINTREG_MAX            UINT32_MAX
# define RTCCUINTREG_FMT            "RU32"
# define RTCCUINTREG_XFMT           "RX32"
# define RTCCINTREG_C(a_Value)      INT32_C(a_Value)
# define RTCCINTREG_MAX             INT32_MAX
# define RTCCINTREG_MIN             INT32_MIN
# define RTCCINTREG_FMT             "RI32"
# define RTCCINTREG_XFMT            "RX32"
#elif ARCH_BITS == 64
# define RTCCUINTREG_C(a_Value)     UINT64_C(a_Value)
# define RTCCUINTREG_MAX            UINT64_MAX
# define RTCCUINTREG_FMT            "RU64"
# define RTCCUINTREG_XFMT           "RX64"
# define RTCCINTREG_C(a_Value)      INT64_C(a_Value)
# define RTCCINTREG_MAX             INT64_MAX
# define RTCCINTREG_MIN             INT64_MIN
# define RTCCINTREG_FMT             "RI64"
# define RTCCINTREG_XFMT            "RX64"
#elif ARCH_BITS == 16
# define RTCCUINTREG_C(a_Value)     UINT16_C(a_Value)
# define RTCCUINTREG_MAX            UINT16_MAX
# define RTCCUINTREG_FMT            "RU16"
# define RTCCUINTREG_XFMT           "RX16"
# define RTCCINTREG_C(a_Value)      INT16_C(a_Value)
# define RTCCINTREG_MAX             INT16_MAX
# define RTCCINTREG_MIN             INT16_MIN
# define RTCCINTREG_FMT             "RI16"
# define RTCCINTREG_XFMT            "RX16"
#else
# error "Unsupported ARCH_BITS!"
#endif
/** @def RTCCUINTXREG_C
 * Defines a constant of RTCCUINTXREG type.
 * @param a_Value   Constant value  */
/** @def RTCCUINTXREG_MAX
 * Max value that RTCCUINTXREG can hold. */
/** @def RTCCUINTXREG_FMT
 * Generic IPRT format specifier for RTCCUINTXREG. */
/** @def RTCCUINTXREG_XFMT
 * Generic IPRT format specifier for RTCCUINTXREG, hexadecimal. */
/** @def RTCCINTXREG_C
 * Defines a constant of RTCCINTXREG type.
 * @param a_Value   Constant value  */
/** @def RTCCINTXREG_MAX
 * Max value that RTCCINTXREG can hold. */
/** @def RTCCINTXREG_MIN
 * Min value that RTCCINTXREG can hold. */
/** @def RTCCINTXREG_FMT
 * Generic IPRT format specifier for RTCCINTXREG. */
/** @def RTCCINTXREG_XFMT
 * Generic IPRT format specifier for RTCCINTXREG, hexadecimal. */
/** @def RTCCINTXREG_BITS
 * The width of RTCCINTXREG in bits (32 or 64). */
#if ARCH_BITS == 16 && defined(RT_ARCH_X86)
# define RTCCUINTXREG_C(a_Value)    UINT32_C(a_Value)
# define RTCCUINTXREG_MAX           UINT32_MAX
# define RTCCUINTXREG_FMT           "RU32"
# define RTCCUINTXREG_XFMT          "RX32"
# define RTCCINTXREG_C(a_Value)     INT32_C(a_Value)
# define RTCCINTXREG_MAX            INT32_MAX
# define RTCCINTXREG_MIN            INT32_MIN
# define RTCCINTXREG_FMT            "RI32"
# define RTCCINTXREG_XFMT           "RX32"
# define RTCCINTXREG_BITS           32
#else
# define RTCCUINTXREG_C(a_Value)    RTCCUINTREG_C(a_Value)
# define RTCCUINTXREG_MAX           RTCCUINTREG_MAX
# define RTCCUINTXREG_FMT           RTCCUINTREG_FMT
# define RTCCUINTXREG_XFMT          RTCCUINTREG_XFMT
# define RTCCINTXREG_C(a_Value)     RTCCINTREG_C(a_Value)
# define RTCCINTXREG_MAX            RTCCINTREG_MAX
# define RTCCINTXREG_MIN            RTCCINTREG_MIN
# define RTCCINTXREG_FMT            RTCCINTREG_FMT
# define RTCCINTXREG_XFMT           RTCCINTREG_XFMT
# define RTCCINTXREG_BITS           ARCH_BITS
#endif
/** @} */



/** Pointer to a big integer number. */
typedef struct RTBIGNUM                     RT_FAR *PRTBIGNUM;
/** Pointer to a const big integer number. */
typedef struct RTBIGNUM const               RT_FAR *PCRTBIGNUM;


/** Pointer to a critical section. */
typedef struct RTCRITSECT                   RT_FAR *PRTCRITSECT;
/** Pointer to a const critical section. */
typedef const struct RTCRITSECT             RT_FAR *PCRTCRITSECT;

/** Pointer to a read/write critical section. */
typedef struct RTCRITSECTRW                 RT_FAR *PRTCRITSECTRW;
/** Pointer to a const read/write critical section. */
typedef const struct RTCRITSECTRW           RT_FAR *PCRTCRITSECTRW;


/** Condition variable handle. */
typedef R3PTRTYPE(struct RTCONDVARINTERNAL RT_FAR *) RTCONDVAR;
/** Pointer to a condition variable handle. */
typedef RTCONDVAR                           RT_FAR *PRTCONDVAR;
/** Nil condition variable handle. */
#define NIL_RTCONDVAR                               0

/** Cryptographic (certificate) store handle. */
typedef R3R0PTRTYPE(struct RTCRSTOREINT RT_FAR *)   RTCRSTORE;
/** Pointer to a Cryptographic (certificate) store handle. */
typedef RTCRSTORE                           RT_FAR *PRTCRSTORE;
/** Nil Cryptographic (certificate) store handle. */
#define NIL_RTCRSTORE                               0

/** Pointer to a const (store) certificate context. */
typedef struct RTCRCERTCTX const            RT_FAR *PCRTCRCERTCTX;

/** Cryptographic message digest handle. */
typedef R3R0PTRTYPE(struct RTCRDIGESTINT RT_FAR *) RTCRDIGEST;
/** Pointer to a cryptographic message digest handle. */
typedef RTCRDIGEST                          RT_FAR *PRTCRDIGEST;
/** NIL cryptographic message digest handle. */
#define NIL_RTCRDIGEST                              (0)

/** Cryptographic key handle. */
typedef R3R0PTRTYPE(struct RTCRKEYINT RT_FAR *)     RTCRKEY;
/** Pointer to a cryptographic key handle. */
typedef RTCRKEY                             RT_FAR *PRTCRKEY;
/** Cryptographic key handle nil value. */
#define NIL_RTCRKEY                                 (0)

/** Public key encryption schema handle. */
typedef R3R0PTRTYPE(struct RTCRPKIXENCRYPTIONINT RT_FAR *) RTCRPKIXENCRYPTION;
/** Pointer to a public key encryption schema handle. */
typedef RTCRPKIXENCRYPTION                  RT_FAR *PRTCRPKIXENCRYPTION;
/** NIL public key encryption schema handle */
#define NIL_RTCRPKIXENCRYPTION                      (0)

/** Public key signature schema handle. */
typedef R3R0PTRTYPE(struct RTCRPKIXSIGNATUREINT RT_FAR *) RTCRPKIXSIGNATURE;
/** Pointer to a public key signature schema handle. */
typedef RTCRPKIXSIGNATURE                   RT_FAR *PRTCRPKIXSIGNATURE;
/** NIL public key signature schema handle */
#define NIL_RTCRPKIXSIGNATURE                       (0)

/** X.509 certificate paths builder & validator handle. */
typedef R3R0PTRTYPE(struct RTCRX509CERTPATHSINT RT_FAR *) RTCRX509CERTPATHS;
/** Pointer to a certificate paths builder & validator handle. */
typedef RTCRX509CERTPATHS                   RT_FAR *PRTCRX509CERTPATHS;
/** Nil certificate paths builder & validator handle. */
#define NIL_RTCRX509CERTPATHS                       0

/** Directory handle. */
typedef struct RTDIRINTERNAL                       *RTDIR;
/** Pointer to directory handle. */
typedef RTDIR                                      *PRTDIR;
/** NIL directory handle. */
#define NIL_RTDIR                                   ((RTDIR)0)

/** File handle. */
typedef R3R0PTRTYPE(struct RTFILEINT RT_FAR *)      RTFILE;
/** Pointer to file handle. */
typedef RTFILE                              RT_FAR *PRTFILE;
/** Nil file handle. */
#define NIL_RTFILE                                  ((RTFILE)~(RTHCINTPTR)0)

/** Async I/O request handle. */
typedef R3PTRTYPE(struct RTFILEAIOREQINTERNAL RT_FAR *) RTFILEAIOREQ;
/** Pointer to an async I/O request handle. */
typedef RTFILEAIOREQ                        RT_FAR *PRTFILEAIOREQ;
/** Nil request handle. */
#define NIL_RTFILEAIOREQ                            0

/** Async I/O completion context handle. */
typedef R3PTRTYPE(struct RTFILEAIOCTXINTERNAL RT_FAR *) RTFILEAIOCTX;
/** Pointer to an async I/O completion context handle. */
typedef RTFILEAIOCTX                        RT_FAR *PRTFILEAIOCTX;
/** Nil context handle. */
#define NIL_RTFILEAIOCTX                            0

/** ISO image maker handle. */
typedef struct RTFSISOMAKERINT              RT_FAR *RTFSISOMAKER;
/** Pointer to an ISO image maker handle. */
typedef RTFSISOMAKER                        RT_FAR *PRTFSISOMAKER;
/** NIL ISO maker handle. */
#define NIL_RTFSISOMAKER                           ((RTFSISOMAKER)0)

/** INI-file handle. */
typedef struct RTINIFILEINT                 RT_FAR *RTINIFILE;
/** Pointer to an INI-file handle. */
typedef RTINIFILE                           RT_FAR *PRTINIFILE;
/** NIL INI-file handle. */
#define NIL_RTINIFILE                              ((RTINIFILE)0)

/** Loader module handle. */
typedef R3R0PTRTYPE(struct RTLDRMODINTERNAL RT_FAR *) RTLDRMOD;
/** Pointer to a loader module handle. */
typedef RTLDRMOD                            RT_FAR *PRTLDRMOD;
/** Nil loader module handle. */
#define NIL_RTLDRMOD                                0

/** Lock validator class handle. */
typedef R3R0PTRTYPE(struct RTLOCKVALCLASSINT RT_FAR *) RTLOCKVALCLASS;
/** Pointer to a lock validator class handle. */
typedef RTLOCKVALCLASS                      RT_FAR *PRTLOCKVALCLASS;
/** Nil lock validator class handle. */
#define NIL_RTLOCKVALCLASS                         ((RTLOCKVALCLASS)0)

/** Ring-0 memory object handle. */
typedef R0PTRTYPE(struct RTR0MEMOBJINTERNAL RT_FAR *) RTR0MEMOBJ;
/** Pointer to a Ring-0 memory object handle. */
typedef RTR0MEMOBJ                          RT_FAR *PRTR0MEMOBJ;
/** Nil ring-0 memory object handle. */
#define NIL_RTR0MEMOBJ                              0

/** Native thread handle. */
typedef RTHCUINTPTR                                 RTNATIVETHREAD;
/** Pointer to an native thread handle. */
typedef RTNATIVETHREAD                      RT_FAR *PRTNATIVETHREAD;
/** Nil native thread handle. */
#define NIL_RTNATIVETHREAD                          (~(RTNATIVETHREAD)0)

/** Pipe handle. */
typedef R3R0PTRTYPE(struct RTPIPEINTERNAL RT_FAR *) RTPIPE;
/** Pointer to a pipe handle. */
typedef RTPIPE                              RT_FAR *PRTPIPE;
/** Nil pipe handle.
 * @remarks This is not 0 because of UNIX and OS/2 handle values. Take care! */
#define NIL_RTPIPE                                 ((RTPIPE)RTHCUINTPTR_MAX)

/** @typedef RTPOLLSET
 * Poll set handle. */
typedef R3R0PTRTYPE(struct RTPOLLSETINTERNAL RT_FAR *) RTPOLLSET;
/** Pointer to a poll set handle. */
typedef RTPOLLSET                           RT_FAR *PRTPOLLSET;
/** Nil poll set handle handle. */
#define NIL_RTPOLLSET                               ((RTPOLLSET)0)

/** Process identifier. */
typedef uint32_t                                    RTPROCESS;
/** Pointer to a process identifier. */
typedef RTPROCESS                           RT_FAR *PRTPROCESS;
/** Nil process identifier. */
#define NIL_RTPROCESS                               (~(RTPROCESS)0)

/** Process ring-0 handle. */
typedef RTR0UINTPTR                                 RTR0PROCESS;
/** Pointer to a ring-0 process handle. */
typedef RTR0PROCESS                         RT_FAR *PRTR0PROCESS;
/** Nil ring-0 process handle. */
#define NIL_RTR0PROCESS                             (~(RTR0PROCESS)0)

/** @typedef RTSEMEVENT
 * Event Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMEVENTINTERNAL RT_FAR *) RTSEMEVENT;
/** Pointer to an event semaphore handle. */
typedef RTSEMEVENT                          RT_FAR *PRTSEMEVENT;
/** Nil event semaphore handle. */
#define NIL_RTSEMEVENT                              0

/** @typedef RTSEMEVENTMULTI
 * Event Multiple Release Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMEVENTMULTIINTERNAL RT_FAR *) RTSEMEVENTMULTI;
/** Pointer to an event multiple release semaphore handle. */
typedef RTSEMEVENTMULTI                     RT_FAR *PRTSEMEVENTMULTI;
/** Nil multiple release event semaphore handle. */
#define NIL_RTSEMEVENTMULTI                         0

/** @typedef RTSEMFASTMUTEX
 * Fast mutex Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMFASTMUTEXINTERNAL RT_FAR *) RTSEMFASTMUTEX;
/** Pointer to a fast mutex semaphore handle. */
typedef RTSEMFASTMUTEX                      RT_FAR *PRTSEMFASTMUTEX;
/** Nil fast mutex semaphore handle. */
#define NIL_RTSEMFASTMUTEX                          0

/** @typedef RTSEMMUTEX
 * Mutex Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMMUTEXINTERNAL RT_FAR *) RTSEMMUTEX;
/** Pointer to a mutex semaphore handle. */
typedef RTSEMMUTEX                          RT_FAR *PRTSEMMUTEX;
/** Nil mutex semaphore handle. */
#define NIL_RTSEMMUTEX                              0

/** @typedef RTSEMSPINMUTEX
 * Spinning mutex Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMSPINMUTEXINTERNAL RT_FAR *) RTSEMSPINMUTEX;
/** Pointer to a spinning mutex semaphore handle. */
typedef RTSEMSPINMUTEX                      RT_FAR *PRTSEMSPINMUTEX;
/** Nil spinning mutex semaphore handle. */
#define NIL_RTSEMSPINMUTEX                          0

/** @typedef RTSEMRW
 * Read/Write Semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMRWINTERNAL RT_FAR *) RTSEMRW;
/** Pointer to a read/write semaphore handle. */
typedef RTSEMRW                             RT_FAR *PRTSEMRW;
/** Nil read/write semaphore handle. */
#define NIL_RTSEMRW                                 0

/** @typedef RTSEMXROADS
 * Crossroads semaphore handle. */
typedef R3R0PTRTYPE(struct RTSEMXROADSINTERNAL RT_FAR *) RTSEMXROADS;
/** Pointer to a crossroads semaphore handle. */
typedef RTSEMXROADS                         RT_FAR *PRTSEMXROADS;
/** Nil crossroads semaphore handle. */
#define NIL_RTSEMXROADS                             ((RTSEMXROADS)0)

/** Spinlock handle. */
typedef R3R0PTRTYPE(struct RTSPINLOCKINTERNAL RT_FAR *) RTSPINLOCK;
/** Pointer to a spinlock handle. */
typedef RTSPINLOCK                          RT_FAR *PRTSPINLOCK;
/** Nil spinlock handle. */
#define NIL_RTSPINLOCK                              0

/** Socket handle. */
typedef R3R0PTRTYPE(struct RTSOCKETINT RT_FAR *)    RTSOCKET;
/** Pointer to socket handle. */
typedef RTSOCKET                            RT_FAR *PRTSOCKET;
/** Nil socket handle. */
#define NIL_RTSOCKET                                ((RTSOCKET)0)

/** Pointer to a RTTCPSERVER handle. */
typedef struct RTTCPSERVER                  RT_FAR *PRTTCPSERVER;
/** Pointer to a RTTCPSERVER handle. */
typedef PRTTCPSERVER                        RT_FAR *PPRTTCPSERVER;
/** Nil RTTCPSERVER handle. */
#define NIL_RTTCPSERVER                            ((PRTTCPSERVER)0)

/** Pointer to a RTUDPSERVER handle. */
typedef struct RTUDPSERVER                  RT_FAR *PRTUDPSERVER;
/** Pointer to a RTUDPSERVER handle. */
typedef PRTUDPSERVER                        RT_FAR *PPRTUDPSERVER;
/** Nil RTUDPSERVER handle. */
#define NIL_RTUDPSERVER                            ((PRTUDPSERVER)0)

/** Thread handle.*/
typedef R3R0PTRTYPE(struct RTTHREADINT RT_FAR *)    RTTHREAD;
/** Pointer to thread handle. */
typedef RTTHREAD                            RT_FAR *PRTTHREAD;
/** Nil thread handle. */
#define NIL_RTTHREAD                                0

/** Thread context switching hook handle.   */
typedef R0PTRTYPE(struct RTTHREADCTXHOOKINT RT_FAR *) RTTHREADCTXHOOK;
/** Pointer to Thread context switching hook handle. */
typedef RTTHREADCTXHOOK                     RT_FAR *PRTTHREADCTXHOOK;
/** Nil Thread context switching hook handle. */
#define NIL_RTTHREADCTXHOOK                         ((RTTHREADCTXHOOK)0)

/** A TLS index. */
typedef RTHCINTPTR                                  RTTLS;
/** Pointer to a TLS index. */
typedef RTTLS                               RT_FAR *PRTTLS;
/** Pointer to a const TLS index. */
typedef RTTLS const                         RT_FAR *PCRTTLS;
/** NIL TLS index value. */
#define NIL_RTTLS                                   ((RTTLS)-1)

/** Trace buffer handle.
 * @remarks This is not a R3/R0 type like most other handles!
 */
typedef struct RTTRACEBUFINT                 RT_FAR *RTTRACEBUF;
/** Pointer to a trace buffer handle. */
typedef RTTRACEBUF                           RT_FAR *PRTTRACEBUF;
/** Nil trace buffer handle. */
#define NIL_RTTRACEBUF                              ((RTTRACEBUF)0)
/** The handle of the default trace buffer.
 * This can be used with any of the RTTraceBufAdd APIs. */
#define RTTRACEBUF_DEFAULT                          ((RTTRACEBUF)-2)

/** Handle to a simple heap. */
typedef R3R0PTRTYPE(struct RTHEAPSIMPLEINTERNAL RT_FAR *) RTHEAPSIMPLE;
/** Pointer to a handle to a simple heap. */
typedef RTHEAPSIMPLE                        RT_FAR *PRTHEAPSIMPLE;
/** NIL simple heap handle. */
#define NIL_RTHEAPSIMPLE                            ((RTHEAPSIMPLE)0)

/** Handle to an offset based heap. */
typedef R3R0PTRTYPE(struct RTHEAPOFFSETINTERNAL RT_FAR *) RTHEAPOFFSET;
/** Pointer to a handle to an offset based heap. */
typedef RTHEAPOFFSET                        RT_FAR *PRTHEAPOFFSET;
/** NIL offset based heap handle. */
#define NIL_RTHEAPOFFSET                            ((RTHEAPOFFSET)0)

/** Handle to an environment block. */
typedef R3PTRTYPE(struct RTENVINTERNAL RT_FAR *)    RTENV;
/** Pointer to a handle to an environment block. */
typedef RTENV                               RT_FAR *PRTENV;
/** NIL simple heap handle. */
#define NIL_RTENV                                   ((RTENV)0)

/** A CPU identifier.
 * @remarks This doesn't have to correspond to the APIC ID (intel/amd). Nor
 *          does it have to correspond to the bits in the affinity mask, at
 *          least not until we've sorted out Windows NT. */
typedef uint32_t                                    RTCPUID;
/** Pointer to a CPU identifier. */
typedef RTCPUID                             RT_FAR *PRTCPUID;
/** Pointer to a const CPU identifier. */
typedef RTCPUID const                       RT_FAR *PCRTCPUID;
/** Nil CPU Id. */
#define NIL_RTCPUID                                 ((RTCPUID)~0)

/** The maximum number of CPUs a set can contain and IPRT is able
 * to reference. (Should be max of support arch/platforms.)
 * @remarks Must be a power of two and multiple of 64 (see RTCPUSET).  */
#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
# if defined(RT_OS_OS2)
#  define RTCPUSET_MAX_CPUS     64
# elif defined(RT_OS_DARWIN) || defined(RT_ARCH_X86)
#  define RTCPUSET_MAX_CPUS     256
# else
#  define RTCPUSET_MAX_CPUS     1024
# endif
#elif defined(RT_ARCH_SPARC) || defined(RT_ARCH_SPARC64)
# define RTCPUSET_MAX_CPUS      1024
#else
# define RTCPUSET_MAX_CPUS      64
#endif
/** A CPU set.
 * @note    Treat this as an opaque type and always use RTCpuSet* for
 *          manipulating it. */
typedef struct RTCPUSET
{
    /** The bitmap.  */
    uint64_t bmSet[RTCPUSET_MAX_CPUS / 64];
} RTCPUSET;
/** Pointer to a CPU set. */
typedef RTCPUSET                            RT_FAR *PRTCPUSET;
/** Pointer to a const CPU set. */
typedef RTCPUSET const                      RT_FAR *PCRTCPUSET;

/** A handle table handle. */
typedef R3R0PTRTYPE(struct RTHANDLETABLEINT RT_FAR *) RTHANDLETABLE;
/** A pointer to a handle table handle. */
typedef RTHANDLETABLE                       RT_FAR *PRTHANDLETABLE;
/** @def NIL_RTHANDLETABLE
 * NIL handle table handle. */
#define NIL_RTHANDLETABLE                           ((RTHANDLETABLE)0)

/** A handle to a low resolution timer. */
typedef R3R0PTRTYPE(struct RTTIMERLRINT RT_FAR *)   RTTIMERLR;
/** A pointer to a low resolution timer handle. */
typedef RTTIMERLR                           RT_FAR *PRTTIMERLR;
/** @def NIL_RTTIMERLR
 * NIL low resolution timer handle value. */
#define NIL_RTTIMERLR                               ((RTTIMERLR)0)

/** Handle to a random number generator. */
typedef R3R0PTRTYPE(struct RTRANDINT RT_FAR *)      RTRAND;
/** Pointer to a random number generator handle. */
typedef RTRAND                              RT_FAR *PRTRAND;
/** NIL random number generator handle value. */
#define NIL_RTRAND                                  ((RTRAND)0)

/** Debug address space handle. */
typedef R3R0PTRTYPE(struct RTDBGASINT RT_FAR *)     RTDBGAS;
/** Pointer to a debug address space handle. */
typedef RTDBGAS                             RT_FAR *PRTDBGAS;
/** NIL debug address space handle. */
#define NIL_RTDBGAS                                 ((RTDBGAS)0)

/** Debug module handle. */
typedef R3R0PTRTYPE(struct RTDBGMODINT RT_FAR *)    RTDBGMOD;
/** Pointer to a debug module handle. */
typedef RTDBGMOD                            RT_FAR *PRTDBGMOD;
/** NIL debug module handle. */
#define NIL_RTDBGMOD                                ((RTDBGMOD)0)

/** Pointer to an unwind machine state. */
typedef struct RTDBGUNWINDSTATE RT_FAR              *PRTDBGUNWINDSTATE;
/** Pointer to a const unwind machine state. */
typedef struct RTDBGUNWINDSTATE const RT_FAR        *PCRTDBGUNWINDSTATE;

/** Manifest handle. */
typedef struct RTMANIFESTINT                RT_FAR *RTMANIFEST;
/** Pointer to a manifest handle. */
typedef RTMANIFEST                          RT_FAR *PRTMANIFEST;
/** NIL manifest handle. */
#define NIL_RTMANIFEST                              ((RTMANIFEST)~(uintptr_t)0)

/** Memory pool handle. */
typedef R3R0PTRTYPE(struct RTMEMPOOLINT RT_FAR *)   RTMEMPOOL;
/** Pointer to a memory pool handle. */
typedef RTMEMPOOL                           RT_FAR *PRTMEMPOOL;
/** NIL memory pool handle. */
#define NIL_RTMEMPOOL                               ((RTMEMPOOL)0)
/** The default memory pool handle. */
#define RTMEMPOOL_DEFAULT                           ((RTMEMPOOL)-2)

/** String cache handle. */
typedef R3R0PTRTYPE(struct RTSTRCACHEINT RT_FAR *)  RTSTRCACHE;
/** Pointer to a string cache handle. */
typedef RTSTRCACHE                          RT_FAR *PRTSTRCACHE;
/** NIL string cache handle. */
#define NIL_RTSTRCACHE                              ((RTSTRCACHE)0)
/** The default string cache handle. */
#define RTSTRCACHE_DEFAULT                          ((RTSTRCACHE)-2)


/** Virtual Filesystem handle. */
typedef struct RTVFSINTERNAL                RT_FAR *RTVFS;
/** Pointer to a VFS handle. */
typedef RTVFS                               RT_FAR *PRTVFS;
/** A NIL VFS handle. */
#define NIL_RTVFS                                   ((RTVFS)~(uintptr_t)0)

/** Virtual Filesystem base object handle. */
typedef struct RTVFSOBJINTERNAL             RT_FAR *RTVFSOBJ;
/** Pointer to a VFS base object handle. */
typedef RTVFSOBJ                            RT_FAR *PRTVFSOBJ;
/** A NIL VFS base object handle. */
#define NIL_RTVFSOBJ                                ((RTVFSOBJ)~(uintptr_t)0)

/** Virtual Filesystem directory handle. */
typedef struct RTVFSDIRINTERNAL             RT_FAR *RTVFSDIR;
/** Pointer to a VFS directory handle. */
typedef RTVFSDIR                            RT_FAR *PRTVFSDIR;
/** A NIL VFS directory handle. */
#define NIL_RTVFSDIR                                ((RTVFSDIR)~(uintptr_t)0)

/** Virtual Filesystem filesystem stream handle. */
typedef struct RTVFSFSSTREAMINTERNAL        RT_FAR *RTVFSFSSTREAM;
/** Pointer to a VFS filesystem stream handle. */
typedef RTVFSFSSTREAM                       RT_FAR *PRTVFSFSSTREAM;
/** A NIL VFS filesystem stream handle. */
#define NIL_RTVFSFSSTREAM                           ((RTVFSFSSTREAM)~(uintptr_t)0)

/** Virtual Filesystem I/O stream handle. */
typedef struct RTVFSIOSTREAMINTERNAL        RT_FAR *RTVFSIOSTREAM;
/** Pointer to a VFS I/O stream handle. */
typedef RTVFSIOSTREAM                       RT_FAR *PRTVFSIOSTREAM;
/** A NIL VFS I/O stream handle. */
#define NIL_RTVFSIOSTREAM                           ((RTVFSIOSTREAM)~(uintptr_t)0)

/** Virtual Filesystem file handle. */
typedef struct RTVFSFILEINTERNAL            RT_FAR *RTVFSFILE;
/** Pointer to a VFS file handle. */
typedef RTVFSFILE                           RT_FAR *PRTVFSFILE;
/** A NIL VFS file handle. */
#define NIL_RTVFSFILE                               ((RTVFSFILE)~(uintptr_t)0)

/** Virtual Filesystem symbolic link handle. */
typedef struct RTVFSSYMLINKINTERNAL         RT_FAR *RTVFSSYMLINK;
/** Pointer to a VFS symbolic link handle. */
typedef RTVFSSYMLINK                        RT_FAR *PRTVFSSYMLINK;
/** A NIL VFS symbolic link handle. */
#define NIL_RTVFSSYMLINK                            ((RTVFSSYMLINK)~(uintptr_t)0)

/** Async I/O manager handle. */
typedef struct RTAIOMGRINT                  RT_FAR *RTAIOMGR;
/** Pointer to a async I/O manager handle. */
typedef RTAIOMGR                            RT_FAR *PRTAIOMGR;
/** A NIL async I/O manager handle. */
#define NIL_RTAIOMGR                                ((RTAIOMGR)~(uintptr_t)0)

/** Async I/O manager file handle. */
typedef struct RTAIOMGRFILEINT              RT_FAR *RTAIOMGRFILE;
/** Pointer to a async I/O manager file handle. */
typedef RTAIOMGRFILE                        RT_FAR *PRTAIOMGRFILE;
/** A NIL async I/O manager file handle. */
#define NIL_RTAIOMGRFILE                            ((RTAIOMGRFILE)~(uintptr_t)0)

/** Kernel module information record handle. */
typedef struct RTKRNLMODINFOINT             RT_FAR *RTKRNLMODINFO;
/** Pointer to a kernel information record handle. */
typedef RTKRNLMODINFO                       RT_FAR *PRTKRNLMODINFO;
/** A NIL kernel module information record handle. */
#define NIL_RTKRNLMODINFO                          ((RTKRNLMODINFO)~(uintptr_t)0);

/** Shared memory object handle. */
typedef struct RTSHMEMINT                   RT_FAR *RTSHMEM;
/** Pointer to a shared memory object handle. */
typedef RTSHMEM                             RT_FAR *PRTSHMEM;
/** A NIL shared memory object handle. */
#define NIL_RTSHMEM                                ((RTSHMEM)~(uintptr_t)0)

/** EFI signature database handle. */
typedef struct RTEFISIGDBINT                RT_FAR *RTEFISIGDB;
/** Pointer to a EFI signature database handle. */
typedef RTEFISIGDB                          RT_FAR *PRTEFISIGDB;
/** A NIL EFI signature database handle. */
#define NIL_RTEFISIGDB                             ((RTEFISIGDB)~(uintptr_t)0)

/** Flattened Devicetree handle. */
typedef struct RTFDTINT                     RT_FAR *RTFDT;
/** Pointer to a Flattened Devicetree handle. */
typedef RTFDT                               RT_FAR *PRTFDT;
/** A NIL Flattened Devicetree handle. */
#define NIL_RTFDT                                  ((RTFDT)~(uintptr_t)0)

/** ACPI table handle. */
typedef struct RTACPITBLINT                 RT_FAR *RTACPITBL;
/** Pointer to an ACPI table handle. */
typedef RTACPITBL                           RT_FAR *PRTACPITBL;
/** A NIL ACPI table handle. */
#define NIL_RTACPITBL                              ((RTACPITBL)~(uintptr_t)0)

/** ACPI resource handle. */
typedef struct RTACPIRESINT                 RT_FAR *RTACPIRES;
/** Pointer to an ACPI resource handle. */
typedef RTACPIRES                           RT_FAR *PRTACPIRES;
/** A NIL ACPI resource handle. */
#define NIL_RTACPIRES                              ((RTACPIRES)~(uintptr_t)0)


/**
 * Handle type.
 *
 * This is usually used together with RTHANDLEUNION.
 */
typedef enum RTHANDLETYPE
{
    /** The invalid zero value. */
    RTHANDLETYPE_INVALID = 0,
    /** File handle. */
    RTHANDLETYPE_FILE,
    /** Pipe handle */
    RTHANDLETYPE_PIPE,
    /** Socket handle. */
    RTHANDLETYPE_SOCKET,
    /** Thread handle. */
    RTHANDLETYPE_THREAD,
    /** The end of the valid values. */
    RTHANDLETYPE_END,
    /** The 32-bit type blow up. */
    RTHANDLETYPE_32BIT_HACK = 0x7fffffff
} RTHANDLETYPE;
/** Pointer to a handle type. */
typedef RTHANDLETYPE RT_FAR *PRTHANDLETYPE;

/**
 * Handle union.
 *
 * This is usually used together with RTHANDLETYPE or as RTHANDLE.
 */
typedef union RTHANDLEUNION
{
    RTFILE          hFile;              /**< File handle. */
    RTPIPE          hPipe;              /**< Pipe handle. */
    RTSOCKET        hSocket;            /**< Socket handle. */
    RTTHREAD        hThread;            /**< Thread handle. */
    /** Generic integer handle value.
     * Note that RTFILE is not yet pointer sized, so accessing it via this member
     * isn't necessarily safe or fully portable. */
    RTHCUINTPTR     uInt;
} RTHANDLEUNION;
/** Pointer to a handle union. */
typedef RTHANDLEUNION RT_FAR *PRTHANDLEUNION;
/** Pointer to a const handle union. */
typedef RTHANDLEUNION const RT_FAR *PCRTHANDLEUNION;

/**
 * Generic handle.
 */
typedef struct RTHANDLE
{
    /** The handle type. */
    RTHANDLETYPE    enmType;
    /** The handle value. */
    RTHANDLEUNION   u;
} RTHANDLE;
/** Pointer to a generic handle. */
typedef RTHANDLE RT_FAR *PRTHANDLE;
/** Pointer to a const generic handle. */
typedef RTHANDLE const RT_FAR *PCRTHANDLE;


/**
 * Standard handles.
 *
 * @remarks These have the correct file descriptor values for unixy systems and
 *          can be used directly in code specific to those platforms.
 */
typedef enum RTHANDLESTD
{
    /** Invalid standard handle. */
    RTHANDLESTD_INVALID = -1,
    /** The standard input handle. */
    RTHANDLESTD_INPUT = 0,
    /** The standard output handle. */
    RTHANDLESTD_OUTPUT,
    /** The standard error handle. */
    RTHANDLESTD_ERROR,
    /** The typical 32-bit type hack. */
    RTHANDLESTD_32BIT_HACK = 0x7fffffff
} RTHANDLESTD;


/**
 * Error info.
 *
 * See RTErrInfo*.
 */
typedef struct RTERRINFO
{
    /** Flags, see RTERRINFO_FLAGS_XXX. */
    uint32_t    fFlags;
    /** The status code. */
    int32_t     rc;
    /** The size of the message buffer pointed to by pszMsg. */
    size_t      cbMsg;
    /** The error buffer. */
    char       *pszMsg;
    /** Reserved for future use. */
    void       *apvReserved[2];
} RTERRINFO;
/** Pointer to an error info structure. */
typedef RTERRINFO RT_FAR *PRTERRINFO;
/** Pointer to a const error info structure. */
typedef RTERRINFO const RT_FAR *PCRTERRINFO;

/**
 * Static error info structure, see RTErrInfoInitStatic.
 */
typedef struct RTERRINFOSTATIC
{
    /** The core error info. */
    RTERRINFO   Core;
    /** The static message buffer. */
    char        szMsg[3072];
} RTERRINFOSTATIC;
/** Pointer to a error info buffer. */
typedef RTERRINFOSTATIC RT_FAR *PRTERRINFOSTATIC;
/** Pointer to a const static error info buffer. */
typedef RTERRINFOSTATIC const RT_FAR *PCRTERRINFOSTATIC;


/**
 * UUID data type.
 *
 * See RTUuid*.
 *
 * @remarks IPRT defines that the first three integers in the @c Gen struct
 *          interpretation are in little endian representation.  This is
 *          different to many other UUID implementation, and requires
 *          conversion if you need to achieve consistent results.
 */
typedef union RTUUID
{
    /** 8-bit view. */
    uint8_t     au8[16];
    /** 16-bit view. */
    uint16_t    au16[8];
    /** 32-bit view. */
    uint32_t    au32[4];
    /** 64-bit view. */
    uint64_t    au64[2];
    /** The way the UUID is declared by the DCE specification. */
    struct
    {
        uint32_t    u32TimeLow;
        uint16_t    u16TimeMid;
        uint16_t    u16TimeHiAndVersion;
        uint8_t     u8ClockSeqHiAndReserved;
        uint8_t     u8ClockSeqLow;
        uint8_t     au8Node[6];
    } Gen;
} RTUUID;
/** Pointer to UUID data. */
typedef RTUUID RT_FAR *PRTUUID;
/** Pointer to readonly UUID data. */
typedef const RTUUID RT_FAR *PCRTUUID;

/** Initializes a RTUUID structure with all zeros (RTUuidIsNull() true). */
#define RTUUID_INITIALIZE_NULL  { { 0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0 } }

/** UUID string maximum length. */
#define RTUUID_STR_LENGTH       37


/** Compression handle. */
typedef struct RTZIPCOMP   RT_FAR *PRTZIPCOMP;
/** Decompressor handle. */
typedef struct RTZIPDECOMP RT_FAR *PRTZIPDECOMP;


/**
 * Unicode Code Point.
 */
typedef uint32_t                RTUNICP;
/** Pointer to an Unicode Code Point. */
typedef RTUNICP         RT_FAR *PRTUNICP;
/** Pointer to an Unicode Code Point. */
typedef const RTUNICP   RT_FAR *PCRTUNICP;
/** Max value a RTUNICP type can hold. */
#define RTUNICP_MAX             ( ~(RTUNICP)0 )
/** Invalid code point.
 * This is returned when encountered invalid encodings or invalid
 * unicode code points. */
#define RTUNICP_INVALID         ( UINT32_C(0xfffffffe) )


/**
 * UTF-16 character.
 *
 * @remark  wchar_t is not usable since it's compiler defined and can be 8 thru
 *          64 bit wide.  On Windows it is 16-bit, though, and for various
 *          reasons of convenience we need to use the native compiler type when
 *          compling without the /Zc:wchar_t- option (only relevant for C++ and
 *          _NATIVE_WCHAR_T_DEFINED indicates the absense of /Zc:wchar_t-).
 *
 * @remark  When we use the term character we're not talking about unicode code point, but
 *          the basic unit of the string encoding. Thus cwc - count of wide chars - means
 *          count of RTUTF16; cuc - count of unicode chars - means count of RTUNICP;
 *          and cch means count of the typedef 'char', which is assumed to be an octet.
 */
#if defined(_MSC_VER) && defined(__cplusplus) && defined(_NATIVE_WCHAR_T_DEFINED)
typedef __wchar_t               RTUTF16;
#else
typedef uint16_t                RTUTF16;
#endif
/** Pointer to a UTF-16 character. */
typedef RTUTF16         RT_FAR *PRTUTF16;
/** Pointer to a const UTF-16 character. */
typedef const RTUTF16   RT_FAR *PCRTUTF16;


/**
 * String tuple to go with the RT_STR_TUPLE macro.
 */
typedef struct RTSTRTUPLE
{
    /** The string. */
    const char *psz;
    /** The string length. */
    size_t      cch;
} RTSTRTUPLE;
/** Pointer to a string tuple. */
typedef RTSTRTUPLE RT_FAR *PRTSTRTUPLE;
/** Pointer to a const string tuple. */
typedef RTSTRTUPLE const RT_FAR *PCRTSTRTUPLE;

/**
 * Wait for ever if we have to.
 */
#define RT_INDEFINITE_WAIT      (~0U)


/**
 * Generic process callback.
 *
 * @returns VBox status code. Failure will cancel the operation.
 * @param   uPercentage     The percentage of the operation which has been completed.
 * @param   pvUser          The user specified argument.
 */
typedef DECLCALLBACKTYPE(int, FNRTPROGRESS,(unsigned uPercentage, void *pvUser));
/** Pointer to a generic progress callback function, FNRTPROCESS(). */
typedef FNRTPROGRESS *PFNRTPROGRESS;

/**
 * Generic vprintf-like callback function for dumpers.
 *
 * @param   pvUser          User argument.
 * @param   pszFormat       The format string.
 * @param   va              Arguments for the format string.
 */
typedef DECLCALLBACKTYPE(void, FNRTDUMPPRINTFV,(void *pvUser, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(2, 0));
/** Pointer to a generic printf-like function for dumping. */
typedef FNRTDUMPPRINTFV *PFNRTDUMPPRINTFV;


/**
 * A point in a two dimentional coordinate system.
 */
typedef struct RTPOINT
{
    /** X coordinate. */
    int32_t     x;
    /** Y coordinate. */
    int32_t     y;
} RTPOINT;
/** Pointer to a point. */
typedef RTPOINT RT_FAR *PRTPOINT;
/** Pointer to a const point. */
typedef const RTPOINT RT_FAR *PCRTPOINT;


/**
 * Rectangle data type, double point.
 */
typedef struct RTRECT
{
    /** left X coordinate. */
    int32_t     xLeft;
    /** top Y coordinate. */
    int32_t     yTop;
    /** right X coordinate. (exclusive) */
    int32_t     xRight;
    /** bottom Y coordinate. (exclusive) */
    int32_t     yBottom;
} RTRECT;
/** Pointer to a double point rectangle. */
typedef RTRECT RT_FAR *PRTRECT;
/** Pointer to a const double point rectangle. */
typedef const RTRECT RT_FAR *PCRTRECT;


/**
 * Rectangle data type, point + size.
 */
typedef struct RTRECT2
{
    /** X coordinate.
     * Unless stated otherwise, this is the top left corner. */
    int32_t     x;
    /** Y coordinate.
     * Unless stated otherwise, this is the top left corner.  */
    int32_t     y;
    /** The width.
     * Unless stated otherwise, this is to the right of (x,y) and will not
     * be a negative number. */
    int32_t     cx;
    /** The height.
     * Unless stated otherwise, this is down from (x,y) and will not be a
     * negative number. */
    int32_t     cy;
} RTRECT2;
/** Pointer to a point + size rectangle. */
typedef RTRECT2 RT_FAR *PRTRECT2;
/** Pointer to a const point + size rectangle. */
typedef const RTRECT2 RT_FAR *PCRTRECT2;


/**
 * The size of a rectangle.
 */
typedef struct RTRECTSIZE
{
    /** The width (along the x-axis). */
    uint32_t    cx;
    /** The height (along the y-axis). */
    uint32_t    cy;
} RTRECTSIZE;
/** Pointer to a rectangle size. */
typedef RTRECTSIZE RT_FAR *PRTRECTSIZE;
/** Pointer to a const rectangle size. */
typedef const RTRECTSIZE RT_FAR *PCRTRECTSIZE;


/**
 * Ethernet MAC address.
 *
 * The first 24 bits make up the Organisationally Unique Identifier (OUI),
 * where the first bit (little endian) indicates multicast (set) / unicast,
 * and the second bit indicates locally (set) / global administered. If all
 * bits are set, it's a broadcast.
 */
typedef union RTMAC
{
    /** @todo add a bitfield view of this stuff. */
    /** 8-bit view. */
    uint8_t     au8[6];
    /** 16-bit view. */
    uint16_t    au16[3];
} RTMAC;
/** Pointer to a MAC address. */
typedef RTMAC RT_FAR *PRTMAC;
/** Pointer to a readonly MAC address. */
typedef const RTMAC RT_FAR *PCRTMAC;


/** Pointer to a lock validator record.
 * The structure definition is found in iprt/lockvalidator.h.  */
typedef struct RTLOCKVALRECEXCL RT_FAR *PRTLOCKVALRECEXCL;
/** Pointer to a record of one ownership share.
 * The structure definition is found in iprt/lockvalidator.h.  */
typedef struct RTLOCKVALRECSHRD RT_FAR *PRTLOCKVALRECSHRD;
/** Pointer to a lock validator source position.
 * The structure definition is found in iprt/lockvalidator.h.  */
typedef struct RTLOCKVALSRCPOS  RT_FAR *PRTLOCKVALSRCPOS;
/** Pointer to a const lock validator source position.
 * The structure definition is found in iprt/lockvalidator.h.  */
typedef struct RTLOCKVALSRCPOS const RT_FAR *PCRTLOCKVALSRCPOS;

/** @name   Special sub-class values.
 * The range 16..UINT32_MAX is available to the user, the range 0..15 is
 * reserved for the lock validator.  In the user range the locks can only be
 * taking in ascending order.
 * @{ */
/** Invalid value.  */
#define RTLOCKVAL_SUB_CLASS_INVALID     UINT32_C(0)
/** Not allowed to be taken with any other locks in the same class.
  * This is the recommended value.  */
#define RTLOCKVAL_SUB_CLASS_NONE        UINT32_C(1)
/** Any order is allowed within the class. */
#define RTLOCKVAL_SUB_CLASS_ANY         UINT32_C(2)
/** The first user value. */
#define RTLOCKVAL_SUB_CLASS_USER        UINT32_C(16)
/** @} */


/**
 * Digest types.
 */
typedef enum RTDIGESTTYPE
{
    /** Invalid digest value.  */
    RTDIGESTTYPE_INVALID = 0,
    /** Unknown digest type. */
    RTDIGESTTYPE_UNKNOWN,
    /** CRC32 checksum. */
    RTDIGESTTYPE_CRC32,
    /** CRC64 checksum. */
    RTDIGESTTYPE_CRC64,
    /** MD2 checksum (unsafe!). */
    RTDIGESTTYPE_MD2,
    /** MD4 checksum (unsafe!!). */
    RTDIGESTTYPE_MD4,
    /** MD5 checksum (unsafe!). */
    RTDIGESTTYPE_MD5,
    /** SHA-1 checksum (unsafe!). */
    RTDIGESTTYPE_SHA1,
    /** SHA-224 checksum. */
    RTDIGESTTYPE_SHA224,
    /** SHA-256 checksum. */
    RTDIGESTTYPE_SHA256,
    /** SHA-384 checksum. */
    RTDIGESTTYPE_SHA384,
    /** SHA-512 checksum. */
    RTDIGESTTYPE_SHA512,
    /** SHA-512/224 checksum. */
    RTDIGESTTYPE_SHA512T224,
    /** SHA-512/256 checksum. */
    RTDIGESTTYPE_SHA512T256,
    /** SHA3-224 checksum. */
    RTDIGESTTYPE_SHA3_224,
    /** SHA3-256 checksum. */
    RTDIGESTTYPE_SHA3_256,
    /** SHA3-384 checksum. */
    RTDIGESTTYPE_SHA3_384,
    /** SHA3-512 checksum. */
    RTDIGESTTYPE_SHA3_512,
#if 0
    /** SHAKE128 checksum. */
    RTDIGESTTYPE_SHAKE128,
    /** SHAKE256 checksum. */
    RTDIGESTTYPE_SHAKE256,
#endif
    /** End of valid types. */
    RTDIGESTTYPE_END,
    /** Usual 32-bit type blowup. */
    RTDIGESTTYPE_32BIT_HACK = 0x7fffffff
} RTDIGESTTYPE;

/**
 * Process exit codes.
 */
typedef enum RTEXITCODE
{
    /** Success. */
    RTEXITCODE_SUCCESS = 0,
    /** General failure. */
    RTEXITCODE_FAILURE = 1,
    /** Invalid arguments.  */
    RTEXITCODE_SYNTAX = 2,
    /** Initialization failure (usually IPRT, but could be used for other
     *  components as well). */
    RTEXITCODE_INIT = 3,
    /** Test skipped. */
    RTEXITCODE_SKIPPED = 4,
    /** The end of valid exit codes. */
    RTEXITCODE_END,
    /** The usual 32-bit type hack. */
    RTEXITCODE_32BIT_HACK = 0x7fffffff
} RTEXITCODE;

/**
 * Range descriptor.
 */
typedef struct RTRANGE
{
    /** Start offset. */
    uint64_t    offStart;
    /** Range size. */
    size_t      cbRange;
} RTRANGE;
/** Pointer to a range descriptor. */
typedef RTRANGE RT_FAR *PRTRANGE;
/** Pointer to a readonly range descriptor. */
typedef const RTRANGE RT_FAR *PCRTRANGE;


/**
 * Generic pointer union.
 */
typedef union RTPTRUNION
{
    /** Pointer into the void. */
    void            RT_FAR *pv;
    /** As a signed integer. */
    intptr_t                i;
    /** As an unsigned integer. */
    uintptr_t               u;
    /** Pointer to char value. */
    char            RT_FAR *pch;
    /** Pointer to char value. */
    unsigned char   RT_FAR *puch;
    /** Pointer to a int value. */
    int             RT_FAR *pi;
    /** Pointer to a unsigned int value. */
    unsigned int    RT_FAR *pu;
    /** Pointer to a long value. */
    long            RT_FAR *pl;
    /** Pointer to a long value. */
    unsigned long   RT_FAR *pul;
    /** Pointer to a byte value. */
    uint8_t         RT_FAR *pb;
    /** Pointer to a 8-bit unsigned value. */
    uint8_t         RT_FAR *pu8;
    /** Pointer to a 16-bit unsigned value. */
    uint16_t        RT_FAR *pu16;
    /** Pointer to a 32-bit unsigned value. */
    uint32_t        RT_FAR *pu32;
    /** Pointer to a 64-bit unsigned value. */
    uint64_t        RT_FAR *pu64;
    /** Pointer to a 8-bit signed value. */
    int8_t          RT_FAR *pi8;
    /** Pointer to a 16-bit signed value. */
    int16_t         RT_FAR *pi16;
    /** Pointer to a 32-bit signed value. */
    int32_t         RT_FAR *pi32;
    /** Pointer to a 64-bit signed value. */
    int64_t         RT_FAR *pi64;
    /** Pointer to a UTF-16 character. */
    PRTUTF16                pwc;
    /** Pointer to a UUID character. */
    PRTUUID                 pUuid;
} RTPTRUNION;
/** Pointer to a pointer union. */
typedef RTPTRUNION RT_FAR *PRTPTRUNION;

/**
 * Generic const pointer union.
 */
typedef union RTCPTRUNION
{
    /** Pointer into the void. */
    void const      RT_FAR *pv;
    /** As a signed integer. */
    intptr_t                i;
    /** As an unsigned integer. */
    uintptr_t               u;
    /** Pointer to char value. */
    char const      RT_FAR *pch;
    /** Pointer to char value. */
    unsigned char const RT_FAR *puch;
    /** Pointer to a int value. */
    int const       RT_FAR *pi;
    /** Pointer to a unsigned int value. */
    unsigned int const RT_FAR *pu;
    /** Pointer to a long value. */
    long const      RT_FAR *pl;
    /** Pointer to a long value. */
    unsigned long const RT_FAR *pul;
    /** Pointer to a byte  value. */
    uint8_t const   RT_FAR *pb;
    /** Pointer to a 8-bit unsigned value. */
    uint8_t const   RT_FAR *pu8;
    /** Pointer to a 16-bit unsigned value. */
    uint16_t const  RT_FAR *pu16;
    /** Pointer to a 32-bit unsigned value. */
    uint32_t const  RT_FAR *pu32;
    /** Pointer to a 64-bit unsigned value. */
    uint64_t const  RT_FAR *pu64;
    /** Pointer to a 8-bit signed value. */
    int8_t const    RT_FAR *pi8;
    /** Pointer to a 16-bit signed value. */
    int16_t const   RT_FAR *pi16;
    /** Pointer to a 32-bit signed value. */
    int32_t const   RT_FAR *pi32;
    /** Pointer to a 64-bit signed value. */
    int64_t const   RT_FAR *pi64;
    /** Pointer to a UTF-16 character. */
    PCRTUTF16               pwc;
    /** Pointer to a UUID character. */
    PCRTUUID                pUuid;
} RTCPTRUNION;
/** Pointer to a const pointer union. */
typedef RTCPTRUNION RT_FAR *PRTCPTRUNION;

/**
 * Generic volatile pointer union.
 */
typedef union RTVPTRUNION
{
    /** Pointer into the void. */
    void volatile  RT_FAR *pv;
    /** As a signed integer. */
    intptr_t                i;
    /** As an unsigned integer. */
    uintptr_t               u;
    /** Pointer to char value. */
    char volatile  RT_FAR *pch;
    /** Pointer to char value. */
    unsigned char volatile RT_FAR *puch;
    /** Pointer to a int value. */
    int volatile   RT_FAR *pi;
    /** Pointer to a unsigned int value. */
    unsigned int volatile RT_FAR *pu;
    /** Pointer to a long value. */
    long volatile  RT_FAR *pl;
    /** Pointer to a long value. */
    unsigned long volatile RT_FAR *pul;
    /** Pointer to a byte value. */
    uint8_t volatile RT_FAR  *pb;
    /** Pointer to a 8-bit unsigned value. */
    uint8_t volatile RT_FAR  *pu8;
    /** Pointer to a 16-bit unsigned value. */
    uint16_t volatile RT_FAR *pu16;
    /** Pointer to a 32-bit unsigned value. */
    uint32_t volatile RT_FAR *pu32;
    /** Pointer to a 64-bit unsigned value. */
    uint64_t volatile RT_FAR *pu64;
    /** Pointer to a 8-bit signed value. */
    int8_t volatile RT_FAR   *pi8;
    /** Pointer to a 16-bit signed value. */
    int16_t volatile RT_FAR  *pi16;
    /** Pointer to a 32-bit signed value. */
    int32_t volatile RT_FAR  *pi32;
    /** Pointer to a 64-bit signed value. */
    int64_t volatile RT_FAR  *pi64;
    /** Pointer to a UTF-16 character. */
    RTUTF16 volatile RT_FAR *pwc;
    /** Pointer to a UUID character. */
    RTUUID volatile  RT_FAR *pUuid;
} RTVPTRUNION;
/** Pointer to a const pointer union. */
typedef RTVPTRUNION RT_FAR *PRTVPTRUNION;

/**
 * Generic const volatile pointer union.
 */
typedef union RTCVPTRUNION
{
    /** Pointer into the void. */
    void const volatile             RT_FAR *pv;
    /** As a signed integer. */
    intptr_t                                i;
    /** As an unsigned integer. */
    uintptr_t                               u;
    /** Pointer to char value. */
    char const volatile             RT_FAR *pch;
    /** Pointer to char value. */
    unsigned char const volatile    RT_FAR *puch;
    /** Pointer to a int value. */
    int const volatile              RT_FAR *pi;
    /** Pointer to a unsigned int value. */
    unsigned int const volatile     RT_FAR *pu;
    /** Pointer to a long value. */
    long const volatile             RT_FAR *pl;
    /** Pointer to a long value. */
    unsigned long const volatile    RT_FAR *pul;
    /** Pointer to a byte value. */
    uint8_t const volatile          RT_FAR *pb;
    /** Pointer to a 8-bit unsigned value. */
    uint8_t const volatile          RT_FAR *pu8;
    /** Pointer to a 16-bit unsigned value. */
    uint16_t const volatile         RT_FAR *pu16;
    /** Pointer to a 32-bit unsigned value. */
    uint32_t const volatile         RT_FAR *pu32;
    /** Pointer to a 64-bit unsigned value. */
    uint64_t const volatile         RT_FAR *pu64;
    /** Pointer to a 8-bit signed value. */
    int8_t const volatile           RT_FAR *pi8;
    /** Pointer to a 16-bit signed value. */
    int16_t const volatile          RT_FAR *pi16;
    /** Pointer to a 32-bit signed value. */
    int32_t const volatile          RT_FAR *pi32;
    /** Pointer to a 64-bit signed value. */
    int64_t const volatile          RT_FAR *pi64;
    /** Pointer to a UTF-16 character. */
    RTUTF16 const volatile          RT_FAR *pwc;
    /** Pointer to a UUID character. */
    RTUUID const volatile           RT_FAR *pUuid;
} RTCVPTRUNION;
/** Pointer to a const pointer union. */
typedef RTCVPTRUNION RT_FAR *PRTCVPTRUNION;



#ifdef __cplusplus
/**
 * Strict type validation helper class.
 *
 * See RTErrStrictType and RT_SUCCESS_NP.
 */
class RTErrStrictType2
{
protected:
    /** The status code.  */
    int32_t m_rc;

public:
    /**
     * Constructor.
     * @param   rc      IPRT style status code.
     */
    RTErrStrictType2(int32_t rc) : m_rc(rc)
    {
    }

    /**
     * Get the status code.
     * @returns IPRT style status code.
     */
    int32_t getValue() const
    {
        return m_rc;
    }
};
#endif /* __cplusplus */
/** @} */

#define IPRT_COMPLETED_types_h /* hack for watcom and nocrt headers depending on this one. */
#endif /* !IPRT_INCLUDED_types_h */

