Base.h

Go to the documentation of this file.

 
#ifndef __BASE_H__
#define __BASE_H__
 
//
// Include processor specific binding
//
#include <ProcessorBind.h>
 
#if defined (_MSC_EXTENSIONS)
//
// Disable warning when last field of data structure is a zero sized array.
//
  #pragma warning ( disable : 4200 )
#endif
 
//
// The Microsoft* C compiler can removed references to unreferenced data items
//  if the /OPT:REF linker option is used. We defined a macro as this is a
//  a non standard extension
//
#if defined (_MSC_VER) && _MSC_VER < 1800 && !defined (MDE_CPU_EBC)
#define GLOBAL_REMOVE_IF_UNREFERENCED  __declspec(selectany)
#else
#define GLOBAL_REMOVE_IF_UNREFERENCED
#endif
 
//
// Should be used in combination with NORETURN to avoid 'noreturn' returns
// warnings.
//
#ifndef UNREACHABLE
  #ifdef __GNUC__
#define UNREACHABLE()  __builtin_unreachable ()
  #elif defined (__has_feature)
    #if __has_builtin (__builtin_unreachable)
#define UNREACHABLE()  __builtin_unreachable ()
    #endif
  #endif
 
  #ifndef UNREACHABLE
#define UNREACHABLE()
  #endif
#endif
 
//
// Signaling compilers and analyzers that a certain function cannot return may
// remove all following code and thus lead to better optimization and less
// false positives.
//
#ifndef NORETURN
  #if defined (__GNUC__) || defined (__clang__)
#define NORETURN  __attribute__((noreturn))
  #elif defined (_MSC_EXTENSIONS) && !defined (MDE_CPU_EBC)
#define NORETURN  __declspec(noreturn)
  #else
#define NORETURN
  #endif
#endif
 
//
// Should be used in combination with ANALYZER_NORETURN to avoid 'noreturn'
// returns warnings.
//
#ifndef ANALYZER_UNREACHABLE
  #ifdef __clang_analyzer__
    #if __has_builtin (__builtin_unreachable)
#define ANALYZER_UNREACHABLE()  __builtin_unreachable ()
    #endif
  #endif
 
  #ifndef ANALYZER_UNREACHABLE
#define ANALYZER_UNREACHABLE()
  #endif
#endif
 
//
// Static Analyzers may issue errors about potential NULL-dereferences when
// dereferencing a pointer, that has been checked before, outside of a
// NULL-check.  This may lead to false positives, such as when using ASSERT()
// for verification.
//
#ifndef ANALYZER_NORETURN
  #ifdef __has_feature
    #if __has_feature (attribute_analyzer_noreturn)
#define ANALYZER_NORETURN  __attribute__((analyzer_noreturn))
    #endif
  #endif
 
  #ifndef ANALYZER_NORETURN
#define ANALYZER_NORETURN
  #endif
#endif
 
#ifndef RETURNS_TWICE
  #if defined (__GNUC__) || defined (__clang__)
#define RETURNS_TWICE  __attribute__((returns_twice))
  #else
#define RETURNS_TWICE
  #endif
#endif
 
//
// For symbol name in assembly code, an extra "_" is sometimes necessary
//
 
#define _CONCATENATE(a, b)   __CONCATENATE(a, b)
#define __CONCATENATE(a, b)  a ## b
 
#define ASM_PFX(name)  _CONCATENATE (__USER_LABEL_PREFIX__, name)
 
#ifdef __APPLE__
//
// Apple extension that is used by the linker to optimize code size
// with assembly functions. Put at the end of your .S files
//
#define ASM_FUNCTION_REMOVE_IF_UNREFERENCED  .subsections_via_symbols
#else
#define ASM_FUNCTION_REMOVE_IF_UNREFERENCED
#endif
 
#define PACKED
 
typedef struct {
  UINT32    Data1;
  UINT16    Data2;
  UINT16    Data3;
  UINT8     Data4[8];
} GUID;
 
typedef struct {
  UINT8    Addr[4];
} IPv4_ADDRESS;
 
typedef struct {
  UINT8    Addr[16];
} IPv6_ADDRESS;
 
//
// 8-bytes unsigned value that represents a physical system address.
//
typedef UINT64 PHYSICAL_ADDRESS;
 
typedef struct _LIST_ENTRY LIST_ENTRY;
 
struct _LIST_ENTRY {
  LIST_ENTRY    *ForwardLink;
  LIST_ENTRY    *BackLink;
};
 
//
// Modifiers to abstract standard types to aid in debug of problems
//
 
#define CONST  const
 
#define STATIC  static
 
#define VOID  void
 
//
// Modifiers for Data Types used to self document code.
// This concept is borrowed for UEFI specification.
//
 
#define IN
 
#define OUT
 
#define OPTIONAL
 
//
//  UEFI specification claims 1 and 0. We are concerned about the
//  compiler portability so we did it this way.
//
 
#define TRUE  ((BOOLEAN)(1==1))
 
#define FALSE  ((BOOLEAN)(0==1))
 
#if defined (__cplusplus)
  #if defined (_MSC_EXTENSIONS)
#define NULL  nullptr
  #else
#define NULL  __null
  #endif
#else
#define NULL  ((VOID *) 0)
#endif
 
//
// Null character
//
#define CHAR_NULL  0x0000
 
#define MAX_INT8    ((INT8)0x7F)
#define MAX_UINT8   ((UINT8)0xFF)
#define MAX_INT16   ((INT16)0x7FFF)
#define MAX_UINT16  ((UINT16)0xFFFF)
#define MAX_INT32   ((INT32)0x7FFFFFFF)
#define MAX_UINT32  ((UINT32)0xFFFFFFFF)
#define MAX_INT64   ((INT64)0x7FFFFFFFFFFFFFFFULL)
#define MAX_UINT64  ((UINT64)0xFFFFFFFFFFFFFFFFULL)
 
#define MIN_INT8   (((INT8)  -127) - 1)
#define MIN_INT16  (((INT16) -32767) - 1)
#define MIN_INT32  (((INT32) -2147483647) - 1)
#define MIN_INT64  (((INT64) -9223372036854775807LL) - 1)
 
#define  BIT0   0x00000001
#define  BIT1   0x00000002
#define  BIT2   0x00000004
#define  BIT3   0x00000008
#define  BIT4   0x00000010
#define  BIT5   0x00000020
#define  BIT6   0x00000040
#define  BIT7   0x00000080
#define  BIT8   0x00000100
#define  BIT9   0x00000200
#define  BIT10  0x00000400
#define  BIT11  0x00000800
#define  BIT12  0x00001000
#define  BIT13  0x00002000
#define  BIT14  0x00004000
#define  BIT15  0x00008000
#define  BIT16  0x00010000
#define  BIT17  0x00020000
#define  BIT18  0x00040000
#define  BIT19  0x00080000
#define  BIT20  0x00100000
#define  BIT21  0x00200000
#define  BIT22  0x00400000
#define  BIT23  0x00800000
#define  BIT24  0x01000000
#define  BIT25  0x02000000
#define  BIT26  0x04000000
#define  BIT27  0x08000000
#define  BIT28  0x10000000
#define  BIT29  0x20000000
#define  BIT30  0x40000000
#define  BIT31  0x80000000
#define  BIT32  0x0000000100000000ULL
#define  BIT33  0x0000000200000000ULL
#define  BIT34  0x0000000400000000ULL
#define  BIT35  0x0000000800000000ULL
#define  BIT36  0x0000001000000000ULL
#define  BIT37  0x0000002000000000ULL
#define  BIT38  0x0000004000000000ULL
#define  BIT39  0x0000008000000000ULL
#define  BIT40  0x0000010000000000ULL
#define  BIT41  0x0000020000000000ULL
#define  BIT42  0x0000040000000000ULL
#define  BIT43  0x0000080000000000ULL
#define  BIT44  0x0000100000000000ULL
#define  BIT45  0x0000200000000000ULL
#define  BIT46  0x0000400000000000ULL
#define  BIT47  0x0000800000000000ULL
#define  BIT48  0x0001000000000000ULL
#define  BIT49  0x0002000000000000ULL
#define  BIT50  0x0004000000000000ULL
#define  BIT51  0x0008000000000000ULL
#define  BIT52  0x0010000000000000ULL
#define  BIT53  0x0020000000000000ULL
#define  BIT54  0x0040000000000000ULL
#define  BIT55  0x0080000000000000ULL
#define  BIT56  0x0100000000000000ULL
#define  BIT57  0x0200000000000000ULL
#define  BIT58  0x0400000000000000ULL
#define  BIT59  0x0800000000000000ULL
#define  BIT60  0x1000000000000000ULL
#define  BIT61  0x2000000000000000ULL
#define  BIT62  0x4000000000000000ULL
#define  BIT63  0x8000000000000000ULL
 
#define  SIZE_1KB    0x00000400
#define  SIZE_2KB    0x00000800
#define  SIZE_4KB    0x00001000
#define  SIZE_8KB    0x00002000
#define  SIZE_16KB   0x00004000
#define  SIZE_32KB   0x00008000
#define  SIZE_64KB   0x00010000
#define  SIZE_128KB  0x00020000
#define  SIZE_256KB  0x00040000
#define  SIZE_512KB  0x00080000
#define  SIZE_1MB    0x00100000
#define  SIZE_2MB    0x00200000
#define  SIZE_4MB    0x00400000
#define  SIZE_8MB    0x00800000
#define  SIZE_16MB   0x01000000
#define  SIZE_32MB   0x02000000
#define  SIZE_64MB   0x04000000
#define  SIZE_128MB  0x08000000
#define  SIZE_256MB  0x10000000
#define  SIZE_512MB  0x20000000
#define  SIZE_1GB    0x40000000
#define  SIZE_2GB    0x80000000
#define  SIZE_4GB    0x0000000100000000ULL
#define  SIZE_8GB    0x0000000200000000ULL
#define  SIZE_16GB   0x0000000400000000ULL
#define  SIZE_32GB   0x0000000800000000ULL
#define  SIZE_64GB   0x0000001000000000ULL
#define  SIZE_128GB  0x0000002000000000ULL
#define  SIZE_256GB  0x0000004000000000ULL
#define  SIZE_512GB  0x0000008000000000ULL
#define  SIZE_1TB    0x0000010000000000ULL
#define  SIZE_2TB    0x0000020000000000ULL
#define  SIZE_4TB    0x0000040000000000ULL
#define  SIZE_8TB    0x0000080000000000ULL
#define  SIZE_16TB   0x0000100000000000ULL
#define  SIZE_32TB   0x0000200000000000ULL
#define  SIZE_64TB   0x0000400000000000ULL
#define  SIZE_128TB  0x0000800000000000ULL
#define  SIZE_256TB  0x0001000000000000ULL
#define  SIZE_512TB  0x0002000000000000ULL
#define  SIZE_1PB    0x0004000000000000ULL
#define  SIZE_2PB    0x0008000000000000ULL
#define  SIZE_4PB    0x0010000000000000ULL
#define  SIZE_8PB    0x0020000000000000ULL
#define  SIZE_16PB   0x0040000000000000ULL
#define  SIZE_32PB   0x0080000000000000ULL
#define  SIZE_64PB   0x0100000000000000ULL
#define  SIZE_128PB  0x0200000000000000ULL
#define  SIZE_256PB  0x0400000000000000ULL
#define  SIZE_512PB  0x0800000000000000ULL
#define  SIZE_1EB    0x1000000000000000ULL
#define  SIZE_2EB    0x2000000000000000ULL
#define  SIZE_4EB    0x4000000000000000ULL
#define  SIZE_8EB    0x8000000000000000ULL
 
#define  BASE_1KB    0x00000400
#define  BASE_2KB    0x00000800
#define  BASE_4KB    0x00001000
#define  BASE_8KB    0x00002000
#define  BASE_16KB   0x00004000
#define  BASE_32KB   0x00008000
#define  BASE_64KB   0x00010000
#define  BASE_128KB  0x00020000
#define  BASE_256KB  0x00040000
#define  BASE_512KB  0x00080000
#define  BASE_1MB    0x00100000
#define  BASE_2MB    0x00200000
#define  BASE_4MB    0x00400000
#define  BASE_8MB    0x00800000
#define  BASE_16MB   0x01000000
#define  BASE_32MB   0x02000000
#define  BASE_64MB   0x04000000
#define  BASE_128MB  0x08000000
#define  BASE_256MB  0x10000000
#define  BASE_512MB  0x20000000
#define  BASE_1GB    0x40000000
#define  BASE_2GB    0x80000000
#define  BASE_4GB    0x0000000100000000ULL
#define  BASE_8GB    0x0000000200000000ULL
#define  BASE_16GB   0x0000000400000000ULL
#define  BASE_32GB   0x0000000800000000ULL
#define  BASE_64GB   0x0000001000000000ULL
#define  BASE_128GB  0x0000002000000000ULL
#define  BASE_256GB  0x0000004000000000ULL
#define  BASE_512GB  0x0000008000000000ULL
#define  BASE_1TB    0x0000010000000000ULL
#define  BASE_2TB    0x0000020000000000ULL
#define  BASE_4TB    0x0000040000000000ULL
#define  BASE_8TB    0x0000080000000000ULL
#define  BASE_16TB   0x0000100000000000ULL
#define  BASE_32TB   0x0000200000000000ULL
#define  BASE_64TB   0x0000400000000000ULL
#define  BASE_128TB  0x0000800000000000ULL
#define  BASE_256TB  0x0001000000000000ULL
#define  BASE_512TB  0x0002000000000000ULL
#define  BASE_1PB    0x0004000000000000ULL
#define  BASE_2PB    0x0008000000000000ULL
#define  BASE_4PB    0x0010000000000000ULL
#define  BASE_8PB    0x0020000000000000ULL
#define  BASE_16PB   0x0040000000000000ULL
#define  BASE_32PB   0x0080000000000000ULL
#define  BASE_64PB   0x0100000000000000ULL
#define  BASE_128PB  0x0200000000000000ULL
#define  BASE_256PB  0x0400000000000000ULL
#define  BASE_512PB  0x0800000000000000ULL
#define  BASE_1EB    0x1000000000000000ULL
#define  BASE_2EB    0x2000000000000000ULL
#define  BASE_4EB    0x4000000000000000ULL
#define  BASE_8EB    0x8000000000000000ULL
 
//
//  Support for variable argument lists in freestanding edk2 modules.
//
//  For modules that use the ISO C library interfaces for variable
//  argument lists, refer to "StdLib/Include/stdarg.h".
//
//  VA_LIST  - typedef for argument list.
//  VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.
//  VA_END (VA_LIST Marker) - Clear Marker
//  VA_ARG (VA_LIST Marker, var arg type) - Use Marker to get an argument from
//    the ... list. You must know the type and pass it in this macro.  Type
//    must be compatible with the type of the actual next argument (as promoted
//    according to the default argument promotions.)
//  VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
//
//  Example:
//
//  UINTN
//  EFIAPI
//  ExampleVarArg (
//    IN UINTN  NumberOfArgs,
//    ...
//    )
//  {
//    VA_LIST Marker;
//    UINTN   Index;
//    UINTN   Result;
//
//    //
//    // Initialize the Marker
//    //
//    VA_START (Marker, NumberOfArgs);
//    for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {
//      //
//      // The ... list is a series of UINTN values, so sum them up.
//      //
//      Result += VA_ARG (Marker, UINTN);
//    }
//
//    VA_END (Marker);
//    return Result;
//  }
//
//  Notes:
//  - Functions that call VA_START() / VA_END() must have a variable
//    argument list and must be declared EFIAPI.
//  - Functions that call VA_COPY() / VA_END() must be declared EFIAPI.
//  - Functions that only use VA_LIST and VA_ARG() need not be EFIAPI.
//
 
#define _INT_SIZE_OF(n)  ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
 
#if defined (_M_ARM) || defined (_M_ARM64)
//
// MSFT ARM variable argument list support.
//
 
typedef char *VA_LIST;
 
#define VA_START(Marker, Parameter)  __va_start (&Marker, &Parameter, _INT_SIZE_OF (Parameter), __alignof(Parameter), &Parameter)
#define VA_ARG(Marker, TYPE)         (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE) + ((-(INTN)Marker) & (sizeof(TYPE) - 1))) - _INT_SIZE_OF (TYPE)))
#define VA_END(Marker)               (Marker = (VA_LIST) 0)
#define VA_COPY(Dest, Start)         ((void)((Dest) = (Start)))
 
#elif defined (__GNUC__) || defined (__clang__)
 
  #if defined (MDE_CPU_X64) && !defined (NO_MSABI_VA_FUNCS)
//
// X64 only. Use MS ABI version of GCC built-in macros for variable argument lists.
//
 
typedef __builtin_ms_va_list VA_LIST;
 
#define VA_START(Marker, Parameter)  __builtin_ms_va_start (Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)  ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
 
#define VA_END(Marker)  __builtin_ms_va_end (Marker)
 
#define VA_COPY(Dest, Start)  __builtin_ms_va_copy (Dest, Start)
 
  #else
//
// Use GCC built-in macros for variable argument lists.
//
 
typedef __builtin_va_list VA_LIST;
 
#define VA_START(Marker, Parameter)  __builtin_va_start (Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)  ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
 
#define VA_END(Marker)  __builtin_va_end (Marker)
 
#define VA_COPY(Dest, Start)  __builtin_va_copy (Dest, Start)
 
  #endif
 
#else
typedef CHAR8 *VA_LIST;
 
#define VA_START(Marker, Parameter)  (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))
 
#define VA_ARG(Marker, TYPE)  (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))
 
#define VA_END(Marker)  (Marker = (VA_LIST) 0)
 
#define VA_COPY(Dest, Start)  ((void)((Dest) = (Start)))
 
#endif
 
typedef UINTN *BASE_LIST;
 
#define _BASE_INT_SIZE_OF(TYPE)  ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))
 
#define BASE_ARG(Marker, TYPE)  (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))
 
#if (defined (__GNUC__) && __GNUC__ >= 4) || defined (__clang__)
#define OFFSET_OF(TYPE, Field)  ((UINTN) __builtin_offsetof(TYPE, Field))
#endif
 
#ifndef OFFSET_OF
#define OFFSET_OF(TYPE, Field)  ((UINTN) &(((TYPE *)0)->Field))
#endif
 
#if defined (__cplusplus)
//
// Standard C++ operator.
//
#define ALIGNOF(TYPE)  alignof (TYPE)
#elif defined (__GNUC__) || defined (__clang__) || (defined (_MSC_VER) && _MSC_VER >= 1900)
//
// All supported versions of GCC and Clang, as well as MSVC 2015 and later,
// support the standard operator _Alignof.
//
#define ALIGNOF(TYPE)  _Alignof (TYPE)
#elif defined (_MSC_EXTENSIONS)
//
// Earlier versions of MSVC, at least MSVC 2008 and later, support the vendor
// extension __alignof.
//
#define ALIGNOF(TYPE)  __alignof (TYPE)
#else
//
// For compilers that do not support inbuilt alignof operators, use OFFSET_OF.
// CHAR8 is known to have both a size and an alignment requirement of 1 Byte.
// As such, A must be located exactly at the offset equal to its alignment
// requirement.
//
#define ALIGNOF(TYPE)  OFFSET_OF (struct { CHAR8 C; TYPE A; }, A)
#endif
 
#ifdef MDE_CPU_EBC
#define STATIC_ASSERT(Expression, Message)
#elif defined (_MSC_EXTENSIONS) || defined (__cplusplus)
#define STATIC_ASSERT  static_assert
#else
#define STATIC_ASSERT  _Static_assert
#endif
 
//
// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
// Section 2.3.1 of the UEFI 2.3 Specification.
//
 
STATIC_ASSERT (sizeof (BOOLEAN) == 1, "sizeof (BOOLEAN) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (INT8)    == 1, "sizeof (INT8) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (UINT8)   == 1, "sizeof (UINT8) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (INT16)   == 2, "sizeof (INT16) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (UINT16)  == 2, "sizeof (UINT16) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (INT32)   == 4, "sizeof (INT32) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (UINT32)  == 4, "sizeof (UINT32) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (INT64)   == 8, "sizeof (INT64) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (UINT64)  == 8, "sizeof (UINT64) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (CHAR8)   == 1, "sizeof (CHAR8) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (CHAR16)  == 2, "sizeof (CHAR16) does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (L'A')    == 2, "sizeof (L'A') does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (L"A")    == 4, "sizeof (L\"A\") does not meet UEFI Specification Data Type requirements");
 
STATIC_ASSERT (ALIGNOF (BOOLEAN) == sizeof (BOOLEAN), "Alignment of BOOLEAN does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (INT8)    == sizeof (INT8), "Alignment of INT8 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (UINT8)   == sizeof (UINT8), "Alignment of INT16 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (INT16)   == sizeof (INT16), "Alignment of INT16 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (UINT16)  == sizeof (UINT16), "Alignment of UINT16 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (INT32)   == sizeof (INT32), "Alignment of INT32 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (UINT32)  == sizeof (UINT32), "Alignment of UINT32 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (INT64)   == sizeof (INT64), "Alignment of INT64 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (UINT64)  == sizeof (UINT64), "Alignment of UINT64 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (CHAR8)   == sizeof (CHAR8), "Alignment of CHAR8 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (CHAR16)  == sizeof (CHAR16), "Alignment of CHAR16 does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (INTN)    == sizeof (INTN), "Alignment of INTN does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (UINTN)   == sizeof (UINTN), "Alignment of UINTN does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (VOID *)  == sizeof (VOID *), "Alignment of VOID * does not meet UEFI Specification Data Type requirements");
 
//
// The following three enum types are used to verify that the compiler
// configuration for enum types is compliant with Section 2.3.1 of the
// UEFI 2.3.1 Errata C Specification. These enum types and enum values
// are not intended to be used. A prefix of '__' is used avoid
// conflicts with other types.
//
typedef enum {
  __VerifyUint8EnumValue = 0xff
} __VERIFY_UINT8_ENUM_SIZE;
 
typedef enum {
  __VerifyUint16EnumValue = 0xffff
} __VERIFY_UINT16_ENUM_SIZE;
 
typedef enum {
  __VerifyInt32EnumValue = 0x7fffffff
} __VERIFY_INT32_ENUM_SIZE;
 
STATIC_ASSERT (sizeof (__VERIFY_UINT8_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (__VERIFY_UINT16_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (sizeof (__VERIFY_INT32_ENUM_SIZE) == 4, "Size of enum does not meet UEFI Specification Data Type requirements");
 
STATIC_ASSERT (ALIGNOF (__VERIFY_UINT8_ENUM_SIZE)  == sizeof (__VERIFY_UINT8_ENUM_SIZE), "Alignment of enum does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (__VERIFY_UINT16_ENUM_SIZE) == sizeof (__VERIFY_UINT16_ENUM_SIZE), "Alignment of enum does not meet UEFI Specification Data Type requirements");
STATIC_ASSERT (ALIGNOF (__VERIFY_INT32_ENUM_SIZE) == sizeof (__VERIFY_INT32_ENUM_SIZE), "Alignment of enum does not meet UEFI Specification Data Type requirements");
 
#define BASE_CR(Record, TYPE, Field)  ((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, Field)))
 
#define IS_POW2(Value)  ((Value) != 0U && ((Value) & ((Value) - 1U)) == 0U)
 
#define IS_ALIGNED(Value, Alignment)  (((Value) & ((Alignment) - 1U)) == 0U)
 
#define ADDRESS_IS_ALIGNED(Address, Alignment)  IS_ALIGNED ((UINTN) (Address), Alignment)
 
#define ALIGN_VALUE_ADDEND(Value, Alignment)  (((Alignment) - (Value)) & ((Alignment) - 1U))
 
#define ALIGN_VALUE(Value, Alignment)  ((Value) + ALIGN_VALUE_ADDEND (Value, Alignment))
 
#define ALIGN_POINTER(Pointer, Alignment)  ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))
 
#define ALIGN_VARIABLE(Value)  ALIGN_VALUE ((Value), sizeof (UINTN))
 
#define MAX(a, b)                       \
  (((a) > (b)) ? (a) : (b))
 
#define MIN(a, b)                       \
  (((a) < (b)) ? (a) : (b))
 
#define ABS(a)                          \
  (((a) < 0) ? (-(a)) : (a))
 
//
// Status codes common to all execution phases
//
typedef UINTN RETURN_STATUS;
 
#define ENCODE_ERROR(StatusCode)  ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
 
#define ENCODE_WARNING(StatusCode)  ((RETURN_STATUS)(StatusCode))
 
#define RETURN_ERROR(StatusCode)  (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
 
#define RETURN_SUCCESS  (RETURN_STATUS)(0)
 
#define RETURN_LOAD_ERROR  ENCODE_ERROR (1)
 
#define RETURN_INVALID_PARAMETER  ENCODE_ERROR (2)
 
#define RETURN_UNSUPPORTED  ENCODE_ERROR (3)
 
#define RETURN_BAD_BUFFER_SIZE  ENCODE_ERROR (4)
 
#define RETURN_BUFFER_TOO_SMALL  ENCODE_ERROR (5)
 
#define RETURN_NOT_READY  ENCODE_ERROR (6)
 
#define RETURN_DEVICE_ERROR  ENCODE_ERROR (7)
 
#define RETURN_WRITE_PROTECTED  ENCODE_ERROR (8)
 
#define RETURN_OUT_OF_RESOURCES  ENCODE_ERROR (9)
 
#define RETURN_VOLUME_CORRUPTED  ENCODE_ERROR (10)
 
#define RETURN_VOLUME_FULL  ENCODE_ERROR (11)
 
#define RETURN_NO_MEDIA  ENCODE_ERROR (12)
 
#define RETURN_MEDIA_CHANGED  ENCODE_ERROR (13)
 
#define RETURN_NOT_FOUND  ENCODE_ERROR (14)
 
#define RETURN_ACCESS_DENIED  ENCODE_ERROR (15)
 
#define RETURN_NO_RESPONSE  ENCODE_ERROR (16)
 
#define RETURN_NO_MAPPING  ENCODE_ERROR (17)
 
#define RETURN_TIMEOUT  ENCODE_ERROR (18)
 
#define RETURN_NOT_STARTED  ENCODE_ERROR (19)
 
#define RETURN_ALREADY_STARTED  ENCODE_ERROR (20)
 
#define RETURN_ABORTED  ENCODE_ERROR (21)
 
#define RETURN_ICMP_ERROR  ENCODE_ERROR (22)
 
#define RETURN_TFTP_ERROR  ENCODE_ERROR (23)
 
#define RETURN_PROTOCOL_ERROR  ENCODE_ERROR (24)
 
#define RETURN_INCOMPATIBLE_VERSION  ENCODE_ERROR (25)
 
#define RETURN_SECURITY_VIOLATION  ENCODE_ERROR (26)
 
#define RETURN_CRC_ERROR  ENCODE_ERROR (27)
 
#define RETURN_END_OF_MEDIA  ENCODE_ERROR (28)
 
#define RETURN_END_OF_FILE  ENCODE_ERROR (31)
 
#define RETURN_INVALID_LANGUAGE  ENCODE_ERROR (32)
 
#define RETURN_COMPROMISED_DATA  ENCODE_ERROR (33)
 
#define RETURN_IP_ADDRESS_CONFLICT  ENCODE_ERROR (34)
 
#define RETURN_HTTP_ERROR  ENCODE_ERROR (35)
 
#define RETURN_WARN_UNKNOWN_GLYPH  ENCODE_WARNING (1)
 
#define RETURN_WARN_DELETE_FAILURE  ENCODE_WARNING (2)
 
#define RETURN_WARN_WRITE_FAILURE  ENCODE_WARNING (3)
 
#define RETURN_WARN_BUFFER_TOO_SMALL  ENCODE_WARNING (4)
 
#define RETURN_WARN_STALE_DATA  ENCODE_WARNING (5)
 
#define RETURN_WARN_FILE_SYSTEM  ENCODE_WARNING (6)
 
#define RETURN_WARN_RESET_REQUIRED  ENCODE_WARNING (7)
 
#define SIGNATURE_16(A, B)  ((A) | (B << 8))
 
#define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
 
#define SIGNATURE_64(A, B, C, D, E, F, G, H) \
    (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
 
#if defined (_MSC_EXTENSIONS) && !defined (__INTEL_COMPILER) && !defined (MDE_CPU_EBC)
void *
_ReturnAddress (
  void
  );
 
  #pragma intrinsic(_ReturnAddress)
 
#define RETURN_ADDRESS(L)  ((L == 0) ? _ReturnAddress() : (VOID *) 0)
#elif defined (__GNUC__) || defined (__clang__)
 
#define RETURN_ADDRESS(L)  __builtin_return_address (L)
#else
 
#define RETURN_ADDRESS(L)  ((VOID *) 0)
#endif
 
#define ARRAY_SIZE(Array)  (sizeof (Array) / sizeof ((Array)[0]))
 
#endif