Base.h File Reference

Data Structures
struct	GUID
struct	IPv4_ADDRESS
struct	IPv6_ADDRESS
struct	_LIST_ENTRY

Macros
#define	GLOBAL_REMOVE_IF_UNREFERENCED
#define	UNREACHABLE()   __builtin_unreachable ()
#define	NORETURN   __attribute__((noreturn))
#define	ANALYZER_UNREACHABLE()
#define	ANALYZER_NORETURN
#define	RETURNS_TWICE   __attribute__((returns_twice))
#define	_CONCATENATE(a, b)   __CONCATENATE(a, b)
#define	__CONCATENATE(a, b)   a ## b
#define	ASM_PFX(name)   _CONCATENATE (__USER_LABEL_PREFIX__, name)
#define	ASM_FUNCTION_REMOVE_IF_UNREFERENCED
#define	PACKED
#define	CONST   const
#define	STATIC   static
#define	VOID   void
#define	IN
#define	OUT
#define	OPTIONAL
#define	TRUE   ((BOOLEAN)(1==1))
#define	FALSE   ((BOOLEAN)(0==1))
#define	NULL   ((VOID *) 0)
#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
#define	_INT_SIZE_OF(n)   ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
#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)
#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)))
#define	OFFSET_OF(TYPE, Field)   ((UINTN) &(((TYPE *)0)->Field))
#define	STATIC_ASSERT(Expression, Message)
#define	BASE_CR(Record, TYPE, Field)   ((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, 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))
#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_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	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))
#define	RETURN_ADDRESS(L)   __builtin_return_address (L)
#define	ARRAY_SIZE(Array)   (sizeof (Array) / sizeof ((Array)[0]))

Typedefs
typedef UINT64	PHYSICAL_ADDRESS
typedef struct _LIST_ENTRY	LIST_ENTRY
typedef __builtin_ms_va_list	VA_LIST
typedef UINTN *	BASE_LIST
typedef UINTN	RETURN_STATUS

Enumerations
enum	__VERIFY_UINT8_ENUM_SIZE { __VerifyUint8EnumValue = 0xff }
enum	__VERIFY_UINT16_ENUM_SIZE { __VerifyUint16EnumValue = 0xffff }
enum	__VERIFY_UINT32_ENUM_SIZE { __VerifyUint32EnumValue = 0xffffffff }

Functions
	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(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(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 (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_UINT32_ENUM_SIZE)==4,"Size of enum does not meet UEFI Specification Data Type requirements")

Detailed Description

Root include file for Mde Package Base type modules

This is the include file for any module of type base. Base modules only use types defined via this include file and can be ported easily to any environment. There are a set of base libraries in the Mde Package that can be used to implement base modules.

Copyright (c) 2006 - 2021, Intel Corporation. All rights reserved.
Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent

Macro Definition Documentation

#define __CONCATENATE	(		a,
			b
	)		a ## b

#define _BASE_INT_SIZE_OF

(

TYPE

)

((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))

Returns the size of a data type in sizeof(UINTN) units rounded up to the nearest UINTN boundary.

Parameters

TYPE	The date type to determine the size of.

Returns

The size of TYPE in sizeof (UINTN) units rounded up to the nearest UINTN boundary.

#define _CONCATENATE	(		a,
			b
	)		__CONCATENATE(a, b)

Private worker functions for ASM_PFX()

#define _INT_SIZE_OF

(

n

)

((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))

Return the size of argument that has been aligned to sizeof (UINTN).

Parameters

n	The parameter size to be aligned.

Returns

The aligned size.

#define ABS

(

a

)

(((a) < 0) ? (-(a)) : (a))

Return the absolute value of a signed operand.

This macro returns the absolute value of the signed operand specified by a.

Parameters

a	The signed operand.

Returns

The absolute value of the signed operand.

#define ALIGN_POINTER	(		Pointer,
			Alignment
	)		((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))

Adjust a pointer by adding the minimum offset required for it to be aligned on a specified alignment boundary.

This function rounds the pointer specified by Pointer to the next alignment boundary specified by Alignment. The pointer to the aligned address is returned.

Parameters

Pointer	The pointer to round up.
Alignment	The alignment boundary to use to return an aligned pointer.

Returns

Pointer to the aligned address.

#define ALIGN_VALUE	(		Value,
			Alignment
	)		((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))

Rounds a value up to the next boundary using a specified alignment.

This function rounds Value up to the next boundary using the specified Alignment. This aligned value is returned.

Parameters

Value	The value to round up.
Alignment	The alignment boundary used to return the aligned value.

Returns

A value up to the next boundary.

#define ALIGN_VARIABLE

(

Value

)

ALIGN_VALUE ((Value), sizeof (UINTN))

Rounds a value up to the next natural boundary for the current CPU. This is 4-bytes for 32-bit CPUs and 8-bytes for 64-bit CPUs.

This function rounds the value specified by Value up to the next natural boundary for the current CPU. This rounded value is returned.

Parameters

Value

The value to round up.

Returns

Rounded value specified by Value.

#define ANALYZER_NORETURN

Signal the analyzer that the function cannot return. This excludes compilers.

#define ANALYZER_UNREACHABLE

(

)

Signal the analyzer that this call is not reachable. This excludes compilers.

#define ARRAY_SIZE

(

Array

)

(sizeof (Array) / sizeof ((Array)[0]))

Return the number of elements in an array.

Parameters

Array

An object of array type. Array is only used as an argument to the sizeof operator, therefore Array is never evaluated. The caller is responsible for ensuring that Array's type is not incomplete; that is, Array must have known constant size.

Returns

The number of elements in Array. The result has type UINTN.

#define ASM_FUNCTION_REMOVE_IF_UNREFERENCED

#define ASM_PFX

(

name

)

_CONCATENATE (__USER_LABEL_PREFIX__, name)

The USER_LABEL_PREFIX macro predefined by GNUC represents the prefix on symbols in assembly language.

#define BASE_128GB   0x0000002000000000ULL

#define BASE_128KB   0x00020000

#define BASE_128MB   0x08000000

#define BASE_128PB   0x0200000000000000ULL

#define BASE_128TB   0x0000800000000000ULL

#define BASE_16GB   0x0000000400000000ULL

#define BASE_16KB   0x00004000

#define BASE_16MB   0x01000000

#define BASE_16PB   0x0040000000000000ULL

#define BASE_16TB   0x0000100000000000ULL

#define BASE_1EB   0x1000000000000000ULL

#define BASE_1GB   0x40000000

#define BASE_1KB   0x00000400

#define BASE_1MB   0x00100000

#define BASE_1PB   0x0004000000000000ULL

#define BASE_1TB   0x0000010000000000ULL

#define BASE_256GB   0x0000004000000000ULL

#define BASE_256KB   0x00040000

#define BASE_256MB   0x10000000

#define BASE_256PB   0x0400000000000000ULL

#define BASE_256TB   0x0001000000000000ULL

#define BASE_2EB   0x2000000000000000ULL

#define BASE_2GB   0x80000000

#define BASE_2KB   0x00000800

#define BASE_2MB   0x00200000

#define BASE_2PB   0x0008000000000000ULL

#define BASE_2TB   0x0000020000000000ULL

#define BASE_32GB   0x0000000800000000ULL

#define BASE_32KB   0x00008000

#define BASE_32MB   0x02000000

#define BASE_32PB   0x0080000000000000ULL

#define BASE_32TB   0x0000200000000000ULL

#define BASE_4EB   0x4000000000000000ULL

#define BASE_4GB   0x0000000100000000ULL

#define BASE_4KB   0x00001000

#define BASE_4MB   0x00400000

#define BASE_4PB   0x0010000000000000ULL

#define BASE_4TB   0x0000040000000000ULL

#define BASE_512GB   0x0000008000000000ULL

#define BASE_512KB   0x00080000

#define BASE_512MB   0x20000000

#define BASE_512PB   0x0800000000000000ULL

#define BASE_512TB   0x0002000000000000ULL

#define BASE_64GB   0x0000001000000000ULL

#define BASE_64KB   0x00010000

#define BASE_64MB   0x04000000

#define BASE_64PB   0x0100000000000000ULL

#define BASE_64TB   0x0000400000000000ULL

#define BASE_8EB   0x8000000000000000ULL

#define BASE_8GB   0x0000000200000000ULL

#define BASE_8KB   0x00002000

#define BASE_8MB   0x00800000

#define BASE_8PB   0x0020000000000000ULL

#define BASE_8TB   0x0000080000000000ULL

#define BASE_ARG	(		Marker,
			TYPE
	)		(*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))

Returns an argument of a specified type from a variable argument list and updates the pointer to the variable argument list to point to the next argument.

This function returns an argument of the type specified by TYPE from the beginning of the variable argument list specified by Marker. Marker is then updated to point to the next argument in the variable argument list. The method for computing the pointer to the next argument in the argument list is CPU specific following the EFIAPI ABI.

Parameters

Marker	The pointer to the beginning of a variable argument list.
TYPE	The type of argument to retrieve from the beginning of the variable argument list.

Returns

An argument of the type specified by TYPE.

#define BASE_CR	(		Record,
			TYPE,
			Field
	)		((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, Field)))

Macro that returns a pointer to the data structure that contains a specified field of that data structure. This is a lightweight method to hide information by placing a public data structure inside a larger private data structure and using a pointer to the public data structure to retrieve a pointer to the private data structure.

This function computes the offset, in bytes, of field specified by Field from the beginning of the data structure specified by TYPE. This offset is subtracted from Record, and is used to return a pointer to a data structure of the type specified by TYPE. If the data type specified by TYPE does not contain the field specified by Field, then the module will not compile.

Parameters

Record	Pointer to the field specified by Field within a data structure of type TYPE.
TYPE	The name of the data structure type to return. This data structure must contain the field specified by Field.
Field	The name of the field in the data structure specified by TYPE to which Record points.

Returns

A pointer to the structure from one of it's elements.

#define BIT0   0x00000001

#define BIT1   0x00000002

#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 BIT2   0x00000004

#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 BIT3   0x00000008

#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 BIT4   0x00000010

#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 BIT5   0x00000020

#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 BIT6   0x00000040

#define BIT60   0x1000000000000000ULL

#define BIT61   0x2000000000000000ULL

#define BIT62   0x4000000000000000ULL

#define BIT63   0x8000000000000000ULL

#define BIT7   0x00000080

#define BIT8   0x00000100

#define BIT9   0x00000200

#define CHAR_NULL   0x0000

#define CONST   const

Datum is read-only.

#define ENCODE_ERROR

(

StatusCode

)

((RETURN_STATUS)(MAX_BIT | (StatusCode)))

Produces a RETURN_STATUS code with the highest bit set.

Parameters

StatusCode

The status code value to convert into a warning code. StatusCode must be in the range 0x00000000..0x7FFFFFFF.

Returns

The value specified by StatusCode with the highest bit set.

#define ENCODE_WARNING

(

StatusCode

)

((RETURN_STATUS)(StatusCode))

Produces a RETURN_STATUS code with the highest bit clear.

Parameters

StatusCode

The status code value to convert into a warning code. StatusCode must be in the range 0x00000000..0x7FFFFFFF.

Returns

The value specified by StatusCode with the highest bit clear.

#define FALSE   ((BOOLEAN)(0==1))

Boolean false value. UEFI Specification defines this value to be 0, but this form is more portable.

#define GLOBAL_REMOVE_IF_UNREFERENCED

Remove the global variable from the linked image if there are no references to it after all compiler and linker optimizations have been performed.

#define IN

Datum is passed to the function.

#define MAX	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Return the maximum of two operands.

This macro returns the maximum of two operand specified by a and b. Both a and b must be the same numerical types, signed or unsigned.

Parameters

a	The first operand with any numerical type.
b	The second operand. Can be any numerical type as long as is the same type as a.

Returns

Maximum of two operands.

#define MAX_INT16   ((INT16)0x7FFF)

#define MAX_INT32   ((INT32)0x7FFFFFFF)

#define MAX_INT64   ((INT64)0x7FFFFFFFFFFFFFFFULL)

#define MAX_INT8   ((INT8)0x7F)

Maximum values for common UEFI Data Types

#define MAX_UINT16   ((UINT16)0xFFFF)

#define MAX_UINT32   ((UINT32)0xFFFFFFFF)

#define MAX_UINT64   ((UINT64)0xFFFFFFFFFFFFFFFFULL)

#define MAX_UINT8   ((UINT8)0xFF)

#define MIN	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Return the minimum of two operands.

This macro returns the minimal of two operand specified by a and b. Both a and b must be the same numerical types, signed or unsigned.

Parameters

a	The first operand with any numerical type.
b	The second operand. It should be the same any numerical type with a.

Returns

Minimum of two operands.

#define MIN_INT16   (((INT16) -32767) - 1)

#define MIN_INT32   (((INT32) -2147483647) - 1)

#define MIN_INT64   (((INT64) -9223372036854775807LL) - 1)

#define MIN_INT8   (((INT8) -127) - 1)

Minimum values for the signed UEFI Data Types

#define NORETURN   __attribute__((noreturn))

Signal compilers and analyzers that the function cannot return. It is up to the compiler to remove any code past a call to functions flagged with this attribute.

#define NULL   ((VOID *) 0)

NULL pointer (VOID *)

#define OFFSET_OF	(		TYPE,
			Field
	)		((UINTN) &(((TYPE *)0)->Field))

The macro that returns the byte offset of a field in a data structure.

This function returns the offset, in bytes, of field specified by Field from the beginning of the data structure specified by TYPE. If TYPE does not contain Field, the module will not compile.

Parameters

TYPE	The name of the data structure that contains the field specified by Field.
Field	The name of the field in the data structure.

Returns

Offset, in bytes, of field.

#define OPTIONAL

Passing the datum to the function is optional, and a NULL is passed if the value is not supplied.

#define OUT

Datum is returned from the function.

#define PACKED

#define RETURN_ABORTED   ENCODE_ERROR (21)

The operation was aborted.

#define RETURN_ACCESS_DENIED   ENCODE_ERROR (15)

Access was denied.

#define RETURN_ADDRESS

(

L

)

__builtin_return_address (L)

Get the return address of the calling function.

Based on built-in Function __builtin_return_address that returns the return address of the current function, or of one of its callers.

Parameters

L	Return Level.

Returns

The return address of the calling function.

#define RETURN_ALREADY_STARTED   ENCODE_ERROR (20)

The protocol has already been started.

#define RETURN_BAD_BUFFER_SIZE   ENCODE_ERROR (4)

The buffer was not the proper size for the request.

#define RETURN_BUFFER_TOO_SMALL   ENCODE_ERROR (5)

The buffer was not large enough to hold the requested data. The required buffer size is returned in the appropriate parameter when this error occurs.

#define RETURN_COMPROMISED_DATA   ENCODE_ERROR (33)

The security status of the data is unknown or compromised and the data must be updated or replaced to restore a valid security status.

#define RETURN_CRC_ERROR   ENCODE_ERROR (27)

A CRC error was detected.

#define RETURN_DEVICE_ERROR   ENCODE_ERROR (7)

The physical device reported an error while attempting the operation.

#define RETURN_END_OF_FILE   ENCODE_ERROR (31)

The end of the file was reached.

#define RETURN_END_OF_MEDIA   ENCODE_ERROR (28)

The beginning or end of media was reached.

#define RETURN_ERROR

(

StatusCode

)

(((INTN)(RETURN_STATUS)(StatusCode)) < 0)

Returns TRUE if a specified RETURN_STATUS code is an error code.

This function returns TRUE if StatusCode has the high bit set. Otherwise, FALSE is returned.

Parameters

StatusCode

The status code value to evaluate.

Return values

TRUE	The high bit of StatusCode is set.
FALSE	The high bit of StatusCode is clear.

#define RETURN_HTTP_ERROR   ENCODE_ERROR (35)

A HTTP error occurred during the network operation.

#define RETURN_ICMP_ERROR   ENCODE_ERROR (22)

An ICMP error occurred during the network operation.

#define RETURN_INCOMPATIBLE_VERSION   ENCODE_ERROR (25)

A function encountered an internal version that was incompatible with a version requested by the caller.

#define RETURN_INVALID_LANGUAGE   ENCODE_ERROR (32)

The language specified was invalid.

#define RETURN_INVALID_PARAMETER   ENCODE_ERROR (2)

The parameter was incorrect.

#define RETURN_LOAD_ERROR   ENCODE_ERROR (1)

The image failed to load.

#define RETURN_MEDIA_CHANGED   ENCODE_ERROR (13)

The medium in the device has changed since the last access.

#define RETURN_NO_MAPPING   ENCODE_ERROR (17)

A mapping to the device does not exist.

#define RETURN_NO_MEDIA   ENCODE_ERROR (12)

The device does not contain any medium to perform the operation.

#define RETURN_NO_RESPONSE   ENCODE_ERROR (16)

The server was not found or did not respond to the request.

#define RETURN_NOT_FOUND   ENCODE_ERROR (14)

The item was not found.

#define RETURN_NOT_READY   ENCODE_ERROR (6)

There is no data pending upon return.

#define RETURN_NOT_STARTED   ENCODE_ERROR (19)

The protocol has not been started.

#define RETURN_OUT_OF_RESOURCES   ENCODE_ERROR (9)

The resource has run out.

#define RETURN_PROTOCOL_ERROR   ENCODE_ERROR (24)

A protocol error occurred during the network operation.

#define RETURN_SECURITY_VIOLATION   ENCODE_ERROR (26)

The function was not performed due to a security violation.

#define RETURN_SUCCESS   0

The operation completed successfully.

#define RETURN_TFTP_ERROR   ENCODE_ERROR (23)

A TFTP error occurred during the network operation.

#define RETURN_TIMEOUT   ENCODE_ERROR (18)

A timeout time expired.

#define RETURN_UNSUPPORTED   ENCODE_ERROR (3)

The operation is not supported.

#define RETURN_VOLUME_CORRUPTED   ENCODE_ERROR (10)

An inconsistency was detected on the file system causing the operation to fail.

#define RETURN_VOLUME_FULL   ENCODE_ERROR (11)

There is no more space on the file system.

#define RETURN_WARN_BUFFER_TOO_SMALL   ENCODE_WARNING (4)

The resulting buffer was too small, and the data was truncated to the buffer size.

#define RETURN_WARN_DELETE_FAILURE   ENCODE_WARNING (2)

The handle was closed, but the file was not deleted.

#define RETURN_WARN_FILE_SYSTEM   ENCODE_WARNING (6)

The resulting buffer contains UEFI-compliant file system.

#define RETURN_WARN_STALE_DATA   ENCODE_WARNING (5)

The data has not been updated within the timeframe set by local policy for this type of data.

#define RETURN_WARN_UNKNOWN_GLYPH   ENCODE_WARNING (1)

The string contained one or more characters that the device could not render and were skipped.

#define RETURN_WARN_WRITE_FAILURE   ENCODE_WARNING (3)

The handle was closed, but the data to the file was not flushed properly.

#define RETURN_WRITE_PROTECTED   ENCODE_ERROR (8)

The device can not be written to.

#define RETURNS_TWICE   __attribute__((returns_twice))

Tell the code optimizer that the function will return twice. This prevents wrong optimizations which can cause bugs. Tell the code optimizer that the function will return twice. This prevents wrong optimizations which can cause bugs.

#define SIGNATURE_16	(		A,
			B
	)		((A) | (B << 8))

Returns a 16-bit signature built from 2 ASCII characters.

This macro returns a 16-bit value built from the two ASCII characters specified by A and B.

Parameters

A	The first ASCII character.
B	The second ASCII character.

Returns

A 16-bit value built from the two ASCII characters specified by A and B.

#define SIGNATURE_32	(		A,
			B,
			C,
			D
	)		(SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))

Returns a 32-bit signature built from 4 ASCII characters.

This macro returns a 32-bit value built from the four ASCII characters specified by A, B, C, and D.

Parameters

A	The first ASCII character.
B	The second ASCII character.
C	The third ASCII character.
D	The fourth ASCII character.

Returns

A 32-bit value built from the two ASCII characters specified by A, B, C and D.

#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))

Returns a 64-bit signature built from 8 ASCII characters.

This macro returns a 64-bit value built from the eight ASCII characters specified by A, B, C, D, E, F, G,and H.

Parameters

A	The first ASCII character.
B	The second ASCII character.
C	The third ASCII character.
D	The fourth ASCII character.
E	The fifth ASCII character.
F	The sixth ASCII character.
G	The seventh ASCII character.
H	The eighth ASCII character.

Returns

A 64-bit value built from the two ASCII characters specified by A, B, C, D, E, F, G and H.

#define SIZE_128GB   0x0000002000000000ULL

#define SIZE_128KB   0x00020000

#define SIZE_128MB   0x08000000

#define SIZE_128PB   0x0200000000000000ULL

#define SIZE_128TB   0x0000800000000000ULL

#define SIZE_16GB   0x0000000400000000ULL

#define SIZE_16KB   0x00004000

#define SIZE_16MB   0x01000000

#define SIZE_16PB   0x0040000000000000ULL

#define SIZE_16TB   0x0000100000000000ULL

#define SIZE_1EB   0x1000000000000000ULL

#define SIZE_1GB   0x40000000

#define SIZE_1KB   0x00000400

#define SIZE_1MB   0x00100000

#define SIZE_1PB   0x0004000000000000ULL

#define SIZE_1TB   0x0000010000000000ULL

#define SIZE_256GB   0x0000004000000000ULL

#define SIZE_256KB   0x00040000

#define SIZE_256MB   0x10000000

#define SIZE_256PB   0x0400000000000000ULL

#define SIZE_256TB   0x0001000000000000ULL

#define SIZE_2EB   0x2000000000000000ULL

#define SIZE_2GB   0x80000000

#define SIZE_2KB   0x00000800

#define SIZE_2MB   0x00200000

#define SIZE_2PB   0x0008000000000000ULL

#define SIZE_2TB   0x0000020000000000ULL

#define SIZE_32GB   0x0000000800000000ULL

#define SIZE_32KB   0x00008000

#define SIZE_32MB   0x02000000

#define SIZE_32PB   0x0080000000000000ULL

#define SIZE_32TB   0x0000200000000000ULL

#define SIZE_4EB   0x4000000000000000ULL

#define SIZE_4GB   0x0000000100000000ULL

#define SIZE_4KB   0x00001000

#define SIZE_4MB   0x00400000

#define SIZE_4PB   0x0010000000000000ULL

#define SIZE_4TB   0x0000040000000000ULL

#define SIZE_512GB   0x0000008000000000ULL

#define SIZE_512KB   0x00080000

#define SIZE_512MB   0x20000000

#define SIZE_512PB   0x0800000000000000ULL

#define SIZE_512TB   0x0002000000000000ULL

#define SIZE_64GB   0x0000001000000000ULL

#define SIZE_64KB   0x00010000

#define SIZE_64MB   0x04000000

#define SIZE_64PB   0x0100000000000000ULL

#define SIZE_64TB   0x0000400000000000ULL

#define SIZE_8EB   0x8000000000000000ULL

#define SIZE_8GB   0x0000000200000000ULL

#define SIZE_8KB   0x00002000

#define SIZE_8MB   0x00800000

#define SIZE_8PB   0x0020000000000000ULL

#define SIZE_8TB   0x0000080000000000ULL

#define STATIC   static

Datum is scoped to the current file or function.

#define STATIC_ASSERT	(		Expression,
			Message
	)

Portable definition for compile time assertions. Equivalent to C11 static_assert macro from assert.h.

Parameters

Expression	Boolean expression.
Message	Raised compiler diagnostic message when expression is false.

#define TRUE   ((BOOLEAN)(1==1))

Boolean true value. UEFI Specification defines this value to be 1, but this form is more portable.

#define UNREACHABLE

(

)

__builtin_unreachable ()

Signal compilers and analyzers that this call is not reachable. It is up to the compiler to remove any code past that point.

#define VA_ARG	(		Marker,
			TYPE
	)		((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))

#define VA_COPY	(		Dest,
			Start
	)		__builtin_ms_va_copy (Dest, Start)

#define VA_END

(

Marker

)

__builtin_ms_va_end (Marker)

#define VA_START	(		Marker,
			Parameter
	)		__builtin_ms_va_start (Marker, Parameter)

#define VOID   void

Undeclared type.

Typedef Documentation

typedef UINTN* BASE_LIST

Pointer to the start of a variable argument list stored in a memory buffer. Same as UINT8 *.

typedef struct _LIST_ENTRY LIST_ENTRY

LIST_ENTRY structure definition.

typedef UINT64 PHYSICAL_ADDRESS

typedef UINTN RETURN_STATUS

typedef __builtin_ms_va_list VA_LIST

Both GCC and LLVM 3.8 for X64 support new variable argument intrinsics for Microsoft ABI Variable used to traverse the list of arguments. This type can vary by implementation and could be an array or structure.

Enumeration Type Documentation

enum __VERIFY_UINT16_ENUM_SIZE

Enumerator
__VerifyUint16EnumValue

enum __VERIFY_UINT32_ENUM_SIZE

Enumerator
__VerifyUint32EnumValue

enum __VERIFY_UINT8_ENUM_SIZE

Enumerator
__VerifyUint8EnumValue

Function Documentation

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(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(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	(	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_UINT32_ENUM_SIZE)	= =4,
		"Size of enum does not meet UEFI Specification Data Type requirements"
	)