Base.h

Go to the documentation of this file.

 
#ifndef __BASE_H__
#define __BASE_H__
 
//
// Include processor specific binding
//
#include <ProcessorBind.h>
 
#define VERIFY_SIZE_OF(TYPE, Size) extern UINT8 _VerifySizeof##TYPE[(sizeof(TYPE) == (Size)) / (sizeof(TYPE) == (Size))]
 
//
// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
// Section 2.3.1 of the UEFI 2.3 Specification.
//
VERIFY_SIZE_OF(BOOLEAN, 1);
VERIFY_SIZE_OF(INT8, 1);
VERIFY_SIZE_OF(UINT8, 1);
VERIFY_SIZE_OF(INT16, 2);
VERIFY_SIZE_OF(UINT16, 2);
VERIFY_SIZE_OF(INT32, 4);
VERIFY_SIZE_OF(UINT32, 4);
VERIFY_SIZE_OF(INT64, 8);
VERIFY_SIZE_OF(UINT64, 8);
VERIFY_SIZE_OF(CHAR8, 1);
VERIFY_SIZE_OF(CHAR16, 2);
 
//
// 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_EXTENSIONS) && !defined (MDE_CPU_EBC)
#define GLOBAL_REMOVE_IF_UNREFERENCED __declspec(selectany)
#else
#define GLOBAL_REMOVE_IF_UNREFERENCED
#endif
 
//
// For symbol name in GNU assembly code, an extra "_" is necessary
//
#if defined(__GNUC__)
#define _CONCATENATE(a, b)  __CONCATENATE(a, b)
#define __CONCATENATE(a, b) a ## b
 
#define ASM_PFX(name) _CONCATENATE (__USER_LABEL_PREFIX__, name)
#endif
 
#if __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
 
#ifdef __CC_ARM
//
// Older RVCT ARM compilers don't fully support #pragma pack and require __packed
// as a prefix for the structure.
//
#define PACKED  __packed
#else
#define PACKED
#endif
 
#if 0
typedef struct {
    UINT32  Data1;
    UINT16  Data2;
    UINT16  Data3;
    UINT8   Data4[8];
} GUID;
 
//
// 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
//  complier portability so we did it this way.
//
 
#define TRUE  ((BOOLEAN)(1==1))
 
#define FALSE ((BOOLEAN)(0==1))
 
#define NULL  ((VOID *) 0)
#endif
 
#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 length argument lists using the ANSI standard.
//
//  Since we are using the ANSI standard we used the standard naming and
//  did not follow the coding convention
//
//  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 size) - Use Marker to get an argument from
//    the ... list. You must know the size and pass it in this macro.
//  VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
//
//  example:
//
//  UINTN
//  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 average them up.
//      //
//      Result += VA_ARG (Marker, UINTN);
//    }
//
//    VA_END (Marker);
//    return Result
//  }
//
 
#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
 
#if defined(__CC_ARM)
//
// RVCT ARM variable argument list support.
//
 
#ifdef __APCS_ADSABI
typedef int         *va_list[1];
#define VA_LIST     va_list
#else
typedef struct __va_list { void *__ap; } va_list;
#define VA_LIST                          va_list
#endif
 
#define VA_START(Marker, Parameter)   __va_start(Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)          __va_arg(Marker, TYPE)
 
#define VA_END(Marker)                ((void)0)
 
#define VA_COPY(Dest, Start)          __va_copy (Dest, Start)
 
#elif defined(__GNUC__) && !defined(NO_BUILTIN_VA_FUNCS)
//
// 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)
 
#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)))
 
#ifdef __GNUC__
#if __GNUC__ >= 4
#define OFFSET_OF(TYPE, Field) ((UINTN) __builtin_offsetof(TYPE, Field))
#endif
#endif
 
#ifndef OFFSET_OF
#define OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field))
#endif
 
#define BASE_CR(Record, TYPE, Field)  ((TYPE *) ((CHAR8 *) (Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))
 
#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
 
#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               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_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 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))
 
#endif