iPXE
|
Root include file for Mde Package Base type modules. More...
#include <ipxe/efi/ProcessorBind.h>
Go to the source code of this file.
Data Structures | |
struct | GUID |
128 bit buffer containing a unique identifier value. More... | |
struct | IPv4_ADDRESS |
4-byte buffer. More... | |
struct | IPv6_ADDRESS |
16-byte buffer. More... | |
struct | _LIST_ENTRY |
_LIST_ENTRY structure definition. More... | |
Macros | |
#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. More... | |
#define | UNREACHABLE() |
Signal compilers and analyzers that this call is not reachable. More... | |
#define | NORETURN |
Signal compilers and analyzers that the function cannot return. More... | |
#define | ANALYZER_UNREACHABLE() |
Signal the analyzer that this call is not reachable. More... | |
#define | ANALYZER_NORETURN |
Signal the analyzer that the function cannot return. More... | |
#define | RETURNS_TWICE |
Tell the code optimizer that the function will return twice. More... | |
#define | _CONCATENATE(a, b) __CONCATENATE(a, b) |
Private worker functions for ASM_PFX() More... | |
#define | __CONCATENATE(a, b) a ## b |
#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. More... | |
#define | ASM_FUNCTION_REMOVE_IF_UNREFERENCED |
#define | PACKED |
#define | CONST const |
Datum is read-only. More... | |
#define | STATIC static |
Datum is scoped to the current file or function. More... | |
#define | VOID void |
Undeclared type. More... | |
#define | IN |
Datum is passed to the function. More... | |
#define | OUT |
Datum is returned from the function. More... | |
#define | OPTIONAL |
Passing the datum to the function is optional, and a NULL is passed if the value is not supplied. More... | |
#define | TRUE ((BOOLEAN)(1==1)) |
Boolean true value. More... | |
#define | FALSE ((BOOLEAN)(0==1)) |
Boolean false value. More... | |
#define | NULL ((VOID *) 0) |
NULL pointer (VOID *) More... | |
#define | CHAR_NULL 0x0000 |
#define | MAX_INT8 ((INT8)0x7F) |
Maximum values for common UEFI Data Types. More... | |
#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) |
Minimum values for the signed UEFI Data Types. More... | |
#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)) |
Return the size of argument that has been aligned to sizeof (UINTN). More... | |
#define | VA_START(Marker, Parameter) (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter))) |
Retrieves a pointer to the beginning of a variable argument list, based on the name of the parameter that immediately precedes the variable argument list. More... | |
#define | VA_ARG(Marker, TYPE) (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _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. More... | |
#define | VA_END(Marker) (Marker = (VA_LIST) 0) |
Terminates the use of a variable argument list. More... | |
#define | VA_COPY(Dest, Start) ((void)((Dest) = (Start))) |
Initializes a VA_LIST as a copy of an existing VA_LIST. More... | |
#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. More... | |
#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. More... | |
#define | OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field)) |
The macro that returns the byte offset of a field in a data structure. More... | |
#define | ALIGNOF(TYPE) OFFSET_OF (struct { CHAR8 C; TYPE A; }, A) |
Returns the alignment requirement of a type. More... | |
#define | STATIC_ASSERT _Static_assert |
Portable definition for compile time assertions. More... | |
#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. More... | |
#define | IS_POW2(Value) ((Value) != 0U && ((Value) & ((Value) - 1U)) == 0U) |
Checks whether a value is a power of two. More... | |
#define | IS_ALIGNED(Value, Alignment) (((Value) & ((Alignment) - 1U)) == 0U) |
Checks whether a value is aligned by a specified alignment. More... | |
#define | ADDRESS_IS_ALIGNED(Address, Alignment) IS_ALIGNED ((UINTN) (Address), Alignment) |
Checks whether a pointer or address is aligned by a specified alignment. More... | |
#define | ALIGN_VALUE_ADDEND(Value, Alignment) (((Alignment) - (Value)) & ((Alignment) - 1U)) |
Determines the addend to add to a value to round it up to the next boundary of a specified alignment. More... | |
#define | ALIGN_VALUE(Value, Alignment) ((Value) + ALIGN_VALUE_ADDEND (Value, Alignment)) |
Rounds a value up to the next boundary using a specified alignment. More... | |
#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. More... | |
#define | ALIGN_VARIABLE(Value) ALIGN_VALUE ((Value), sizeof (UINTN)) |
Rounds a value up to the next natural boundary for the current CPU. More... | |
#define | MAX(a, b) (((a) > (b)) ? (a) : (b)) |
Return the maximum of two operands. More... | |
#define | MIN(a, b) (((a) < (b)) ? (a) : (b)) |
Return the minimum of two operands. More... | |
#define | ABS(a) (((a) < 0) ? (-(a)) : (a)) |
Return the absolute value of a signed operand. More... | |
#define | ENCODE_ERROR(StatusCode) ((RETURN_STATUS)(MAX_BIT | (StatusCode))) |
Produces a RETURN_STATUS code with the highest bit set. More... | |
#define | ENCODE_WARNING(StatusCode) ((RETURN_STATUS)(StatusCode)) |
Produces a RETURN_STATUS code with the highest bit clear. More... | |
#define | RETURN_ERROR(StatusCode) (((INTN)(RETURN_STATUS)(StatusCode)) < 0) |
Returns TRUE if a specified RETURN_STATUS code is an error code. More... | |
#define | RETURN_SUCCESS (RETURN_STATUS)(0) |
The operation completed successfully. More... | |
#define | RETURN_LOAD_ERROR ENCODE_ERROR (1) |
The image failed to load. More... | |
#define | RETURN_INVALID_PARAMETER ENCODE_ERROR (2) |
The parameter was incorrect. More... | |
#define | RETURN_UNSUPPORTED ENCODE_ERROR (3) |
The operation is not supported. More... | |
#define | RETURN_BAD_BUFFER_SIZE ENCODE_ERROR (4) |
The buffer was not the proper size for the request. More... | |
#define | RETURN_BUFFER_TOO_SMALL ENCODE_ERROR (5) |
The buffer was not large enough to hold the requested data. More... | |
#define | RETURN_NOT_READY ENCODE_ERROR (6) |
There is no data pending upon return. More... | |
#define | RETURN_DEVICE_ERROR ENCODE_ERROR (7) |
The physical device reported an error while attempting the operation. More... | |
#define | RETURN_WRITE_PROTECTED ENCODE_ERROR (8) |
The device can not be written to. More... | |
#define | RETURN_OUT_OF_RESOURCES ENCODE_ERROR (9) |
The resource has run out. More... | |
#define | RETURN_VOLUME_CORRUPTED ENCODE_ERROR (10) |
An inconsistency was detected on the file system causing the operation to fail. More... | |
#define | RETURN_VOLUME_FULL ENCODE_ERROR (11) |
There is no more space on the file system. More... | |
#define | RETURN_NO_MEDIA ENCODE_ERROR (12) |
The device does not contain any medium to perform the operation. More... | |
#define | RETURN_MEDIA_CHANGED ENCODE_ERROR (13) |
The medium in the device has changed since the last access. More... | |
#define | RETURN_NOT_FOUND ENCODE_ERROR (14) |
The item was not found. More... | |
#define | RETURN_ACCESS_DENIED ENCODE_ERROR (15) |
Access was denied. More... | |
#define | RETURN_NO_RESPONSE ENCODE_ERROR (16) |
The server was not found or did not respond to the request. More... | |
#define | RETURN_NO_MAPPING ENCODE_ERROR (17) |
A mapping to the device does not exist. More... | |
#define | RETURN_TIMEOUT ENCODE_ERROR (18) |
A timeout time expired. More... | |
#define | RETURN_NOT_STARTED ENCODE_ERROR (19) |
The protocol has not been started. More... | |
#define | RETURN_ALREADY_STARTED ENCODE_ERROR (20) |
The protocol has already been started. More... | |
#define | RETURN_ABORTED ENCODE_ERROR (21) |
The operation was aborted. More... | |
#define | RETURN_ICMP_ERROR ENCODE_ERROR (22) |
An ICMP error occurred during the network operation. More... | |
#define | RETURN_TFTP_ERROR ENCODE_ERROR (23) |
A TFTP error occurred during the network operation. More... | |
#define | RETURN_PROTOCOL_ERROR ENCODE_ERROR (24) |
A protocol error occurred during the network operation. More... | |
#define | RETURN_INCOMPATIBLE_VERSION ENCODE_ERROR (25) |
A function encountered an internal version that was incompatible with a version requested by the caller. More... | |
#define | RETURN_SECURITY_VIOLATION ENCODE_ERROR (26) |
The function was not performed due to a security violation. More... | |
#define | RETURN_CRC_ERROR ENCODE_ERROR (27) |
A CRC error was detected. More... | |
#define | RETURN_END_OF_MEDIA ENCODE_ERROR (28) |
The beginning or end of media was reached. More... | |
#define | RETURN_END_OF_FILE ENCODE_ERROR (31) |
The end of the file was reached. More... | |
#define | RETURN_INVALID_LANGUAGE ENCODE_ERROR (32) |
The language specified was invalid. More... | |
#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. More... | |
#define | RETURN_IP_ADDRESS_CONFLICT ENCODE_ERROR (34) |
There is an address conflict address allocation. More... | |
#define | RETURN_HTTP_ERROR ENCODE_ERROR (35) |
A HTTP error occurred during the network operation. More... | |
#define | RETURN_WARN_UNKNOWN_GLYPH ENCODE_WARNING (1) |
The string contained one or more characters that the device could not render and were skipped. More... | |
#define | RETURN_WARN_DELETE_FAILURE ENCODE_WARNING (2) |
The handle was closed, but the file was not deleted. More... | |
#define | RETURN_WARN_WRITE_FAILURE ENCODE_WARNING (3) |
The handle was closed, but the data to the file was not flushed properly. More... | |
#define | RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4) |
The resulting buffer was too small, and the data was truncated to the buffer size. More... | |
#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. More... | |
#define | RETURN_WARN_FILE_SYSTEM ENCODE_WARNING (6) |
The resulting buffer contains UEFI-compliant file system. More... | |
#define | RETURN_WARN_RESET_REQUIRED ENCODE_WARNING (7) |
The operation will be processed across a system reset. More... | |
#define | SIGNATURE_16(A, B) ((A) | (B << 8)) |
Returns a 16-bit signature built from 2 ASCII characters. More... | |
#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. More... | |
#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. More... | |
#define | RETURN_ADDRESS(L) ((VOID *) 0) |
Get the return address of the calling function. More... | |
#define | ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0])) |
Return the number of elements in an array. More... | |
Typedefs | |
typedef UINT64 | PHYSICAL_ADDRESS |
typedef struct _LIST_ENTRY | LIST_ENTRY |
LIST_ENTRY structure definition. More... | |
typedef CHAR8 * | VA_LIST |
Variable used to traverse the list of arguments. More... | |
typedef UINTN * | BASE_LIST |
Pointer to the start of a variable argument list stored in a memory buffer. More... | |
typedef UINTN | RETURN_STATUS |
Enumerations | |
enum | __VERIFY_UINT8_ENUM_SIZE { __VerifyUint8EnumValue = 0xff } |
enum | __VERIFY_UINT16_ENUM_SIZE { __VerifyUint16EnumValue = 0xffff } |
enum | __VERIFY_INT32_ENUM_SIZE { __VerifyInt32EnumValue = 0x7fffffff } |
Functions | |
FILE_LICENCE (BSD2_PATENT) | |
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 (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(VOID *)==sizeof(VOID *), "Alignment of VOID * 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_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") | |
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
Definition in file Base.h.
#define GLOBAL_REMOVE_IF_UNREFERENCED |
#define UNREACHABLE | ( | ) |
#define NORETURN |
#define ANALYZER_UNREACHABLE | ( | ) |
#define ANALYZER_NORETURN |
#define RETURNS_TWICE |
#define _CONCATENATE | ( | a, | |
b | |||
) | __CONCATENATE(a, b) |
#define ASM_PFX | ( | name | ) | _CONCATENATE (__USER_LABEL_PREFIX__, name) |
#define STATIC static |
#define OPTIONAL |
#define TRUE ((BOOLEAN)(1==1)) |
#define FALSE ((BOOLEAN)(0==1)) |
#define MAX_INT8 ((INT8)0x7F) |
#define MIN_INT8 (((INT8) -127) - 1) |
#define VA_START | ( | Marker, | |
Parameter | |||
) | (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter))) |
Retrieves a pointer to the beginning of a variable argument list, based on the name of the parameter that immediately precedes the variable argument list.
This function initializes Marker to point to the beginning of the variable argument list that immediately follows Parameter. The method for computing the pointer to the next argument in the argument list is CPU-specific following the EFIAPI ABI.
Marker | The VA_LIST used to traverse the list of arguments. |
Parameter | The name of the parameter that immediately precedes the variable argument list. |
#define VA_ARG | ( | Marker, | |
TYPE | |||
) | (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _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.
Marker | VA_LIST used to traverse the list of arguments. |
TYPE | The type of argument to retrieve from the beginning of the variable argument list. |
#define VA_END | ( | Marker | ) | (Marker = (VA_LIST) 0) |
Terminates the use of a variable argument list.
This function initializes Marker so it can no longer be used with VA_ARG(). After this macro is used, the only way to access the variable argument list is by using VA_START() again.
Marker | VA_LIST used to traverse the list of arguments. |
#define VA_COPY | ( | Dest, | |
Start | |||
) | ((void)((Dest) = (Start))) |
Initializes a VA_LIST as a copy of an existing VA_LIST.
This macro initializes Dest as a copy of Start, as if the VA_START macro had been applied to Dest followed by the same sequence of uses of the VA_ARG macro as had previously been used to reach the present state of Start.
Dest | VA_LIST used to traverse the list of arguments. |
Start | VA_LIST used to traverse the list of arguments. |
#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.
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. |
#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.
TYPE | The name of the data structure that contains the field specified by Field. |
Field | The name of the field in the data structure. |
#define STATIC_ASSERT _Static_assert |
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.
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. |
#define IS_POW2 | ( | Value | ) | ((Value) != 0U && ((Value) & ((Value) - 1U)) == 0U) |
Checks whether a pointer or address is aligned by a specified alignment.
Address | The pointer or address to check. |
Alignment | The alignment boundary used to check against. |
TRUE | Address is aligned by Alignment. |
FALSE | Address is not aligned by Alignment. |
Determines the addend to add to a value to round it up to the next boundary of a specified alignment.
Value | The value to round up. |
Alignment | The alignment boundary used to return the addend. |
#define ALIGN_VALUE | ( | Value, | |
Alignment | |||
) | ((Value) + ALIGN_VALUE_ADDEND (Value, Alignment)) |
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.
Value | The value to round up. |
Alignment | The alignment boundary used to return the aligned value. |
#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.
Pointer | The pointer to round up. |
Alignment | The alignment boundary to use to return an aligned pointer. |
#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.
Value | The value to round up. |
#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.
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. |
#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.
a | The first operand with any numerical type. |
b | The second operand. It should be the same any numerical type with a. |
#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) |
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.
StatusCode | The status code value to evaluate. |
TRUE | The high bit of StatusCode is set. |
FALSE | The high bit of StatusCode is clear. |
#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)) |
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.
A | The first ASCII character. |
B | The second ASCII character. |
#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.
A | The first ASCII character. |
B | The second ASCII character. |
C | The third ASCII character. |
D | The fourth ASCII character. |
#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.
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. |
#define RETURN_ADDRESS | ( | L | ) | ((VOID *) 0) |
#define ARRAY_SIZE | ( | Array | ) | (sizeof (Array) / sizeof ((Array)[0])) |
Return the number of elements in an array.
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. |
typedef UINT64 PHYSICAL_ADDRESS |
typedef struct _LIST_ENTRY LIST_ENTRY |
typedef UINTN RETURN_STATUS |
FILE_LICENCE | ( | BSD2_PATENT | ) |
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 | ( | 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(VOID *) | = =sizeof(VOID *) , |
"Alignment of VOID * 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_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" | |||
) |