| /** @file |
| Provides string functions, linked list functions, math functions, synchronization |
| functions, file path functions, and CPU architecture-specific functions. |
| |
| Copyright (c) 2006 - 2021, Intel Corporation. All rights reserved.<BR> |
| Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR> |
| Copyright (c) Microsoft Corporation.<BR> |
| Portions Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR> |
| |
| SPDX-License-Identifier: BSD-2-Clause-Patent |
| |
| **/ |
| |
| #ifndef __BASE_LIB__ |
| #define __BASE_LIB__ |
| |
| // |
| // Definitions for architecture-specific types |
| // |
| #if defined (MDE_CPU_IA32) |
| /// |
| /// The IA-32 architecture context buffer used by SetJump() and LongJump(). |
| /// |
| typedef struct { |
| UINT32 Ebx; |
| UINT32 Esi; |
| UINT32 Edi; |
| UINT32 Ebp; |
| UINT32 Esp; |
| UINT32 Eip; |
| UINT32 Ssp; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 4 |
| |
| #endif // defined (MDE_CPU_IA32) |
| |
| #if defined (MDE_CPU_X64) |
| /// |
| /// The x64 architecture context buffer used by SetJump() and LongJump(). |
| /// |
| typedef struct { |
| UINT64 Rbx; |
| UINT64 Rsp; |
| UINT64 Rbp; |
| UINT64 Rdi; |
| UINT64 Rsi; |
| UINT64 R12; |
| UINT64 R13; |
| UINT64 R14; |
| UINT64 R15; |
| UINT64 Rip; |
| UINT64 MxCsr; |
| UINT8 XmmBuffer[160]; ///< XMM6-XMM15. |
| UINT64 Ssp; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8 |
| |
| #endif // defined (MDE_CPU_X64) |
| |
| #if defined (MDE_CPU_EBC) |
| /// |
| /// The EBC context buffer used by SetJump() and LongJump(). |
| /// |
| typedef struct { |
| UINT64 R0; |
| UINT64 R1; |
| UINT64 R2; |
| UINT64 R3; |
| UINT64 IP; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8 |
| |
| #endif // defined (MDE_CPU_EBC) |
| |
| #if defined (MDE_CPU_ARM) |
| |
| typedef struct { |
| UINT32 R3; ///< A copy of R13. |
| UINT32 R4; |
| UINT32 R5; |
| UINT32 R6; |
| UINT32 R7; |
| UINT32 R8; |
| UINT32 R9; |
| UINT32 R10; |
| UINT32 R11; |
| UINT32 R12; |
| UINT32 R14; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 4 |
| |
| #endif // defined (MDE_CPU_ARM) |
| |
| #if defined (MDE_CPU_AARCH64) |
| typedef struct { |
| // GP regs |
| UINT64 X19; |
| UINT64 X20; |
| UINT64 X21; |
| UINT64 X22; |
| UINT64 X23; |
| UINT64 X24; |
| UINT64 X25; |
| UINT64 X26; |
| UINT64 X27; |
| UINT64 X28; |
| UINT64 FP; |
| UINT64 LR; |
| UINT64 IP0; |
| |
| // FP regs |
| UINT64 D8; |
| UINT64 D9; |
| UINT64 D10; |
| UINT64 D11; |
| UINT64 D12; |
| UINT64 D13; |
| UINT64 D14; |
| UINT64 D15; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8 |
| |
| #endif // defined (MDE_CPU_AARCH64) |
| |
| #if defined (MDE_CPU_RISCV64) |
| /// |
| /// The RISC-V architecture context buffer used by SetJump() and LongJump(). |
| /// |
| typedef struct { |
| UINT64 RA; |
| UINT64 S0; |
| UINT64 S1; |
| UINT64 S2; |
| UINT64 S3; |
| UINT64 S4; |
| UINT64 S5; |
| UINT64 S6; |
| UINT64 S7; |
| UINT64 S8; |
| UINT64 S9; |
| UINT64 S10; |
| UINT64 S11; |
| UINT64 SP; |
| } BASE_LIBRARY_JUMP_BUFFER; |
| |
| #define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8 |
| |
| #endif // defined (MDE_CPU_RISCV64) |
| |
| // |
| // String Services |
| // |
| |
| |
| /** |
| Returns the length of a Null-terminated Unicode string. |
| |
| This function is similar as strlen_s defined in C11. |
| |
| If String is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| @param String A pointer to a Null-terminated Unicode string. |
| @param MaxSize The maximum number of Destination Unicode |
| char, including terminating null char. |
| |
| @retval 0 If String is NULL. |
| @retval MaxSize If there is no null character in the first MaxSize characters of String. |
| @return The number of characters that percede the terminating null character. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrnLenS ( |
| IN CONST CHAR16 *String, |
| IN UINTN MaxSize |
| ); |
| |
| /** |
| Returns the size of a Null-terminated Unicode string in bytes, including the |
| Null terminator. |
| |
| This function returns the size of the Null-terminated Unicode string |
| specified by String in bytes, including the Null terminator. |
| |
| If String is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| @param String A pointer to a Null-terminated Unicode string. |
| @param MaxSize The maximum number of Destination Unicode |
| char, including the Null terminator. |
| |
| @retval 0 If String is NULL. |
| @retval (sizeof (CHAR16) * (MaxSize + 1)) |
| If there is no Null terminator in the first MaxSize characters of |
| String. |
| @return The size of the Null-terminated Unicode string in bytes, including |
| the Null terminator. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrnSizeS ( |
| IN CONST CHAR16 *String, |
| IN UINTN MaxSize |
| ); |
| |
| /** |
| Copies the string pointed to by Source (including the terminating null char) |
| to the array pointed to by Destination. |
| |
| This function is similar as strcpy_s defined in C11. |
| |
| If Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| If Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Unicode string. |
| |
| @retval RETURN_SUCCESS String is copied. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrCpyS ( |
| OUT CHAR16 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR16 *Source |
| ); |
| |
| /** |
| Copies not more than Length successive char from the string pointed to by |
| Source to the array pointed to by Destination. If no null char is copied from |
| Source, then Destination[Length] is always set to null. |
| |
| This function is similar as strncpy_s defined in C11. |
| |
| If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Unicode string. |
| @param Length The maximum number of Unicode characters to copy. |
| |
| @retval RETURN_SUCCESS String is copied. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than |
| MIN(StrLen(Source), Length). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrnCpyS ( |
| OUT CHAR16 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR16 *Source, |
| IN UINTN Length |
| ); |
| |
| /** |
| Appends a copy of the string pointed to by Source (including the terminating |
| null char) to the end of the string pointed to by Destination. |
| |
| This function is similar as strcat_s defined in C11. |
| |
| If Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| If Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Unicode string. |
| |
| @retval RETURN_SUCCESS String is appended. |
| @retval RETURN_BAD_BUFFER_SIZE If DestMax is NOT greater than |
| StrLen(Destination). |
| @retval RETURN_BUFFER_TOO_SMALL If (DestMax - StrLen(Destination)) is NOT |
| greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrCatS ( |
| IN OUT CHAR16 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR16 *Source |
| ); |
| |
| /** |
| Appends not more than Length successive char from the string pointed to by |
| Source to the end of the string pointed to by Destination. If no null char is |
| copied from Source, then Destination[StrLen(Destination) + Length] is always |
| set to null. |
| |
| This function is similar as strncat_s defined in C11. |
| |
| If Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| If Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Unicode string. |
| @param Length The maximum number of Unicode characters to copy. |
| |
| @retval RETURN_SUCCESS String is appended. |
| @retval RETURN_BAD_BUFFER_SIZE If DestMax is NOT greater than |
| StrLen(Destination). |
| @retval RETURN_BUFFER_TOO_SMALL If (DestMax - StrLen(Destination)) is NOT |
| greater than MIN(StrLen(Source), Length). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrnCatS ( |
| IN OUT CHAR16 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR16 *Source, |
| IN UINTN Length |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode decimal string to a value of type UINTN. |
| |
| This function outputs a value of type UINTN by interpreting the contents of |
| the Unicode string specified by String as a decimal number. The format of the |
| input Unicode string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before |
| [decimal digits]. The running zero in the beginning of [decimal digits] will |
| be ignored. Then, the function stops at the first character that is a not a |
| valid decimal character or a Null-terminator, whichever one comes first. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If String has no valid decimal digits in the above format, then 0 is stored |
| at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINTN, then |
| MAX_UINTN is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| decimal digits right after the optional pad spaces, the value of String is |
| stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINTN. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrDecimalToUintnS ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT UINTN *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode decimal string to a value of type UINT64. |
| |
| This function outputs a value of type UINT64 by interpreting the contents of |
| the Unicode string specified by String as a decimal number. The format of the |
| input Unicode string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before |
| [decimal digits]. The running zero in the beginning of [decimal digits] will |
| be ignored. Then, the function stops at the first character that is a not a |
| valid decimal character or a Null-terminator, whichever one comes first. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If String has no valid decimal digits in the above format, then 0 is stored |
| at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINT64, then |
| MAX_UINT64 is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| decimal digits right after the optional pad spaces, the value of String is |
| stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINT64. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrDecimalToUint64S ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT UINT64 *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode hexadecimal string to a value of type |
| UINTN. |
| |
| This function outputs a value of type UINTN by interpreting the contents of |
| the Unicode string specified by String as a hexadecimal number. The format of |
| the input Unicode string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. |
| If "x" appears in the input string, it must be prefixed with at least one 0. |
| The function will ignore the pad space, which includes spaces or tab |
| characters, before [zeros], [x] or [hexadecimal digit]. The running zero |
| before [x] or [hexadecimal digit] will be ignored. Then, the decoding starts |
| after [x] or the first valid hexadecimal digit. Then, the function stops at |
| the first character that is a not a valid hexadecimal character or NULL, |
| whichever one comes first. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If String has no valid hexadecimal digits in the above format, then 0 is |
| stored at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINTN, then |
| MAX_UINTN is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| hexadecimal digits right after the optional pad spaces, the value of String |
| is stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINTN. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrHexToUintnS ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT UINTN *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode hexadecimal string to a value of type |
| UINT64. |
| |
| This function outputs a value of type UINT64 by interpreting the contents of |
| the Unicode string specified by String as a hexadecimal number. The format of |
| the input Unicode string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. |
| If "x" appears in the input string, it must be prefixed with at least one 0. |
| The function will ignore the pad space, which includes spaces or tab |
| characters, before [zeros], [x] or [hexadecimal digit]. The running zero |
| before [x] or [hexadecimal digit] will be ignored. Then, the decoding starts |
| after [x] or the first valid hexadecimal digit. Then, the function stops at |
| the first character that is a not a valid hexadecimal character or NULL, |
| whichever one comes first. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If String has no valid hexadecimal digits in the above format, then 0 is |
| stored at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINT64, then |
| MAX_UINT64 is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| hexadecimal digits right after the optional pad spaces, the value of String |
| is stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINT64. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrHexToUint64S ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT UINT64 *Data |
| ); |
| |
| /** |
| Returns the length of a Null-terminated Ascii string. |
| |
| This function is similar as strlen_s defined in C11. |
| |
| @param String A pointer to a Null-terminated Ascii string. |
| @param MaxSize The maximum number of Destination Ascii |
| char, including terminating null char. |
| |
| @retval 0 If String is NULL. |
| @retval MaxSize If there is no null character in the first MaxSize characters of String. |
| @return The number of characters that percede the terminating null character. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrnLenS ( |
| IN CONST CHAR8 *String, |
| IN UINTN MaxSize |
| ); |
| |
| /** |
| Returns the size of a Null-terminated Ascii string in bytes, including the |
| Null terminator. |
| |
| This function returns the size of the Null-terminated Ascii string specified |
| by String in bytes, including the Null terminator. |
| |
| @param String A pointer to a Null-terminated Ascii string. |
| @param MaxSize The maximum number of Destination Ascii |
| char, including the Null terminator. |
| |
| @retval 0 If String is NULL. |
| @retval (sizeof (CHAR8) * (MaxSize + 1)) |
| If there is no Null terminator in the first MaxSize characters of |
| String. |
| @return The size of the Null-terminated Ascii string in bytes, including the |
| Null terminator. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrnSizeS ( |
| IN CONST CHAR8 *String, |
| IN UINTN MaxSize |
| ); |
| |
| /** |
| Copies the string pointed to by Source (including the terminating null char) |
| to the array pointed to by Destination. |
| |
| This function is similar as strcpy_s defined in C11. |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Ascii string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Ascii string. |
| |
| @retval RETURN_SUCCESS String is copied. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrCpyS ( |
| OUT CHAR8 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR8 *Source |
| ); |
| |
| /** |
| Copies not more than Length successive char from the string pointed to by |
| Source to the array pointed to by Destination. If no null char is copied from |
| Source, then Destination[Length] is always set to null. |
| |
| This function is similar as strncpy_s defined in C11. |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Ascii string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Ascii string. |
| @param Length The maximum number of Ascii characters to copy. |
| |
| @retval RETURN_SUCCESS String is copied. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than |
| MIN(StrLen(Source), Length). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrnCpyS ( |
| OUT CHAR8 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR8 *Source, |
| IN UINTN Length |
| ); |
| |
| /** |
| Appends a copy of the string pointed to by Source (including the terminating |
| null char) to the end of the string pointed to by Destination. |
| |
| This function is similar as strcat_s defined in C11. |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Ascii string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Ascii string. |
| |
| @retval RETURN_SUCCESS String is appended. |
| @retval RETURN_BAD_BUFFER_SIZE If DestMax is NOT greater than |
| StrLen(Destination). |
| @retval RETURN_BUFFER_TOO_SMALL If (DestMax - StrLen(Destination)) is NOT |
| greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrCatS ( |
| IN OUT CHAR8 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR8 *Source |
| ); |
| |
| /** |
| Appends not more than Length successive char from the string pointed to by |
| Source to the end of the string pointed to by Destination. If no null char is |
| copied from Source, then Destination[StrLen(Destination) + Length] is always |
| set to null. |
| |
| This function is similar as strncat_s defined in C11. |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Destination A pointer to a Null-terminated Ascii string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| @param Source A pointer to a Null-terminated Ascii string. |
| @param Length The maximum number of Ascii characters to copy. |
| |
| @retval RETURN_SUCCESS String is appended. |
| @retval RETURN_BAD_BUFFER_SIZE If DestMax is NOT greater than |
| StrLen(Destination). |
| @retval RETURN_BUFFER_TOO_SMALL If (DestMax - StrLen(Destination)) is NOT |
| greater than MIN(StrLen(Source), Length). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrnCatS ( |
| IN OUT CHAR8 *Destination, |
| IN UINTN DestMax, |
| IN CONST CHAR8 *Source, |
| IN UINTN Length |
| ); |
| |
| /** |
| Convert a Null-terminated Ascii decimal string to a value of type UINTN. |
| |
| This function outputs a value of type UINTN by interpreting the contents of |
| the Ascii string specified by String as a decimal number. The format of the |
| input Ascii string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before |
| [decimal digits]. The running zero in the beginning of [decimal digits] will |
| be ignored. Then, the function stops at the first character that is a not a |
| valid decimal character or a Null-terminator, whichever one comes first. |
| |
| If String has no valid decimal digits in the above format, then 0 is stored |
| at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINTN, then |
| MAX_UINTN is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| decimal digits right after the optional pad spaces, the value of String is |
| stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Ascii string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than |
| PcdMaximumAsciiStringLength Ascii |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINTN. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrDecimalToUintnS ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT UINTN *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Ascii decimal string to a value of type UINT64. |
| |
| This function outputs a value of type UINT64 by interpreting the contents of |
| the Ascii string specified by String as a decimal number. The format of the |
| input Ascii string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before |
| [decimal digits]. The running zero in the beginning of [decimal digits] will |
| be ignored. Then, the function stops at the first character that is a not a |
| valid decimal character or a Null-terminator, whichever one comes first. |
| |
| If String has no valid decimal digits in the above format, then 0 is stored |
| at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINT64, then |
| MAX_UINT64 is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| decimal digits right after the optional pad spaces, the value of String is |
| stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Ascii string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than |
| PcdMaximumAsciiStringLength Ascii |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINT64. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrDecimalToUint64S ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT UINT64 *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Ascii hexadecimal string to a value of type UINTN. |
| |
| This function outputs a value of type UINTN by interpreting the contents of |
| the Ascii string specified by String as a hexadecimal number. The format of |
| the input Ascii string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If |
| "x" appears in the input string, it must be prefixed with at least one 0. The |
| function will ignore the pad space, which includes spaces or tab characters, |
| before [zeros], [x] or [hexadecimal digits]. The running zero before [x] or |
| [hexadecimal digits] will be ignored. Then, the decoding starts after [x] or |
| the first valid hexadecimal digit. Then, the function stops at the first |
| character that is a not a valid hexadecimal character or Null-terminator, |
| whichever on comes first. |
| |
| If String has no valid hexadecimal digits in the above format, then 0 is |
| stored at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINTN, then |
| MAX_UINTN is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| hexadecimal digits right after the optional pad spaces, the value of String |
| is stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Ascii string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than |
| PcdMaximumAsciiStringLength Ascii |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINTN. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrHexToUintnS ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT UINTN *Data |
| ); |
| |
| /** |
| Convert a Null-terminated Ascii hexadecimal string to a value of type UINT64. |
| |
| This function outputs a value of type UINT64 by interpreting the contents of |
| the Ascii string specified by String as a hexadecimal number. The format of |
| the input Ascii string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If |
| "x" appears in the input string, it must be prefixed with at least one 0. The |
| function will ignore the pad space, which includes spaces or tab characters, |
| before [zeros], [x] or [hexadecimal digits]. The running zero before [x] or |
| [hexadecimal digits] will be ignored. Then, the decoding starts after [x] or |
| the first valid hexadecimal digit. Then, the function stops at the first |
| character that is a not a valid hexadecimal character or Null-terminator, |
| whichever on comes first. |
| |
| If String has no valid hexadecimal digits in the above format, then 0 is |
| stored at the location pointed to by Data. |
| If the number represented by String exceeds the range defined by UINT64, then |
| MAX_UINT64 is stored at the location pointed to by Data. |
| |
| If EndPointer is not NULL, a pointer to the character that stopped the scan |
| is stored at the location pointed to by EndPointer. If String has no valid |
| hexadecimal digits right after the optional pad spaces, the value of String |
| is stored at the location pointed to by EndPointer. |
| |
| @param String Pointer to a Null-terminated Ascii string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Data Pointer to the converted value. |
| |
| @retval RETURN_SUCCESS Value is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than |
| PcdMaximumAsciiStringLength Ascii |
| characters, not including the |
| Null-terminator. |
| @retval RETURN_UNSUPPORTED If the number represented by String exceeds |
| the range defined by UINT64. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrHexToUint64S ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT UINT64 *Data |
| ); |
| |
| |
| /** |
| Returns the length of a Null-terminated Unicode string. |
| |
| This function returns the number of Unicode characters in the Null-terminated |
| Unicode string specified by String. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned on a 16-bit boundary, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode characters not including the |
| Null-terminator, then ASSERT(). |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| |
| @return The length of String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrLen ( |
| IN CONST CHAR16 *String |
| ); |
| |
| |
| /** |
| Returns the size of a Null-terminated Unicode string in bytes, including the |
| Null terminator. |
| |
| This function returns the size, in bytes, of the Null-terminated Unicode string |
| specified by String. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned on a 16-bit boundary, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode characters not including the |
| Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| |
| @return The size of String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrSize ( |
| IN CONST CHAR16 *String |
| ); |
| |
| |
| /** |
| Compares two Null-terminated Unicode strings, and returns the difference |
| between the first mismatched Unicode characters. |
| |
| This function compares the Null-terminated Unicode string FirstString to the |
| Null-terminated Unicode string SecondString. If FirstString is identical to |
| SecondString, then 0 is returned. Otherwise, the value returned is the first |
| mismatched Unicode character in SecondString subtracted from the first |
| mismatched Unicode character in FirstString. |
| |
| If FirstString is NULL, then ASSERT(). |
| If FirstString is not aligned on a 16-bit boundary, then ASSERT(). |
| If SecondString is NULL, then ASSERT(). |
| If SecondString is not aligned on a 16-bit boundary, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more |
| than PcdMaximumUnicodeStringLength Unicode characters not including the |
| Null-terminator, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more |
| than PcdMaximumUnicodeStringLength Unicode characters, not including the |
| Null-terminator, then ASSERT(). |
| |
| @param FirstString The pointer to a Null-terminated Unicode string. |
| @param SecondString The pointer to a Null-terminated Unicode string. |
| |
| @retval 0 FirstString is identical to SecondString. |
| @return others FirstString is not identical to SecondString. |
| |
| **/ |
| INTN |
| EFIAPI |
| StrCmp ( |
| IN CONST CHAR16 *FirstString, |
| IN CONST CHAR16 *SecondString |
| ); |
| |
| |
| /** |
| Compares up to a specified length the contents of two Null-terminated Unicode strings, |
| and returns the difference between the first mismatched Unicode characters. |
| |
| This function compares the Null-terminated Unicode string FirstString to the |
| Null-terminated Unicode string SecondString. At most, Length Unicode |
| characters will be compared. If Length is 0, then 0 is returned. If |
| FirstString is identical to SecondString, then 0 is returned. Otherwise, the |
| value returned is the first mismatched Unicode character in SecondString |
| subtracted from the first mismatched Unicode character in FirstString. |
| |
| If Length > 0 and FirstString is NULL, then ASSERT(). |
| If Length > 0 and FirstString is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length > 0 and SecondString is NULL, then ASSERT(). |
| If Length > 0 and SecondString is not aligned on a 16-bit boundary, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and Length is greater than |
| PcdMaximumUnicodeStringLength, then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more than |
| PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator, |
| then ASSERT(). |
| If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more than |
| PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator, |
| then ASSERT(). |
| |
| @param FirstString The pointer to a Null-terminated Unicode string. |
| @param SecondString The pointer to a Null-terminated Unicode string. |
| @param Length The maximum number of Unicode characters to compare. |
| |
| @retval 0 FirstString is identical to SecondString. |
| @return others FirstString is not identical to SecondString. |
| |
| **/ |
| INTN |
| EFIAPI |
| StrnCmp ( |
| IN CONST CHAR16 *FirstString, |
| IN CONST CHAR16 *SecondString, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the first occurrence of a Null-terminated Unicode sub-string |
| in a Null-terminated Unicode string. |
| |
| This function scans the contents of the Null-terminated Unicode string |
| specified by String and returns the first occurrence of SearchString. |
| If SearchString is not found in String, then NULL is returned. If |
| the length of SearchString is zero, then String is returned. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned on a 16-bit boundary, then ASSERT(). |
| If SearchString is NULL, then ASSERT(). |
| If SearchString is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If PcdMaximumUnicodeStringLength is not zero, and SearchString |
| or String contains more than PcdMaximumUnicodeStringLength Unicode |
| characters, not including the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| @param SearchString The pointer to a Null-terminated Unicode string to search for. |
| |
| @retval NULL If the SearchString does not appear in String. |
| @return others If there is a match. |
| |
| **/ |
| CHAR16 * |
| EFIAPI |
| StrStr ( |
| IN CONST CHAR16 *String, |
| IN CONST CHAR16 *SearchString |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode decimal string to a value of |
| type UINTN. |
| |
| This function returns a value of type UINTN by interpreting the contents |
| of the Unicode string specified by String as a decimal number. The format |
| of the input Unicode string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The |
| function will ignore the pad space, which includes spaces or |
| tab characters, before [decimal digits]. The running zero in the |
| beginning of [decimal digits] will be ignored. Then, the function |
| stops at the first character that is a not a valid decimal character |
| or a Null-terminator, whichever one comes first. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| If String has only pad spaces, then 0 is returned. |
| If String has no pad spaces or valid decimal digits, |
| then 0 is returned. |
| If the number represented by String overflows according |
| to the range defined by UINTN, then MAX_UINTN is returned. |
| |
| If PcdMaximumUnicodeStringLength is not zero, and String contains |
| more than PcdMaximumUnicodeStringLength Unicode characters not including |
| the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrDecimalToUintn ( |
| IN CONST CHAR16 *String |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode decimal string to a value of |
| type UINT64. |
| |
| This function returns a value of type UINT64 by interpreting the contents |
| of the Unicode string specified by String as a decimal number. The format |
| of the input Unicode string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The |
| function will ignore the pad space, which includes spaces or |
| tab characters, before [decimal digits]. The running zero in the |
| beginning of [decimal digits] will be ignored. Then, the function |
| stops at the first character that is a not a valid decimal character |
| or a Null-terminator, whichever one comes first. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| If String has only pad spaces, then 0 is returned. |
| If String has no pad spaces or valid decimal digits, |
| then 0 is returned. |
| If the number represented by String overflows according |
| to the range defined by UINT64, then MAX_UINT64 is returned. |
| |
| If PcdMaximumUnicodeStringLength is not zero, and String contains |
| more than PcdMaximumUnicodeStringLength Unicode characters not including |
| the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| StrDecimalToUint64 ( |
| IN CONST CHAR16 *String |
| ); |
| |
| |
| /** |
| Convert a Null-terminated Unicode hexadecimal string to a value of type UINTN. |
| |
| This function returns a value of type UINTN by interpreting the contents |
| of the Unicode string specified by String as a hexadecimal number. |
| The format of the input Unicode string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. |
| If "x" appears in the input string, it must be prefixed with at least one 0. |
| The function will ignore the pad space, which includes spaces or tab characters, |
| before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or |
| [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the |
| first valid hexadecimal digit. Then, the function stops at the first character |
| that is a not a valid hexadecimal character or NULL, whichever one comes first. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| If String has only pad spaces, then zero is returned. |
| If String has no leading pad spaces, leading zeros or valid hexadecimal digits, |
| then zero is returned. |
| If the number represented by String overflows according to the range defined by |
| UINTN, then MAX_UINTN is returned. |
| |
| If PcdMaximumUnicodeStringLength is not zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| StrHexToUintn ( |
| IN CONST CHAR16 *String |
| ); |
| |
| |
| /** |
| Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64. |
| |
| This function returns a value of type UINT64 by interpreting the contents |
| of the Unicode string specified by String as a hexadecimal number. |
| The format of the input Unicode string String is |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. |
| If "x" appears in the input string, it must be prefixed with at least one 0. |
| The function will ignore the pad space, which includes spaces or tab characters, |
| before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or |
| [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the |
| first valid hexadecimal digit. Then, the function stops at the first character that is |
| a not a valid hexadecimal character or NULL, whichever one comes first. |
| |
| If String is NULL, then ASSERT(). |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| If String has only pad spaces, then zero is returned. |
| If String has no leading pad spaces, leading zeros or valid hexadecimal digits, |
| then zero is returned. |
| If the number represented by String overflows according to the range defined by |
| UINT64, then MAX_UINT64 is returned. |
| |
| If PcdMaximumUnicodeStringLength is not zero, and String contains more than |
| PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated Unicode string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| StrHexToUint64 ( |
| IN CONST CHAR16 *String |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode string to IPv6 address and prefix length. |
| |
| This function outputs a value of type IPv6_ADDRESS and may output a value |
| of type UINT8 by interpreting the contents of the Unicode string specified |
| by String. The format of the input Unicode string String is as follows: |
| |
| X:X:X:X:X:X:X:X[/P] |
| |
| X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and |
| [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low |
| memory address and high byte is stored in high memory address. P contains decimal |
| digit characters in the range [0-9]. The running zero in the beginning of P will |
| be ignored. /P is optional. |
| |
| When /P is not in the String, the function stops at the first character that is |
| not a valid hexadecimal digit character after eight X's are converted. |
| |
| When /P is in the String, the function stops at the first character that is not |
| a valid decimal digit character after P is converted. |
| |
| "::" can be used to compress one or more groups of X when X contains only 0. |
| The "::" can only appear once in the String. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If EndPointer is not NULL and Address is translated from String, a pointer |
| to the character that stopped the scan is stored at the location pointed to |
| by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Address Pointer to the converted IPv6 address. |
| @param PrefixLength Pointer to the converted IPv6 address prefix |
| length. MAX_UINT8 is returned when /P is |
| not in the String. |
| |
| @retval RETURN_SUCCESS Address is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If X contains more than four hexadecimal |
| digit characters. |
| If String contains "::" and number of X |
| is not less than 8. |
| If P starts with character that is not a |
| valid decimal digit character. |
| If the decimal number converted from P |
| exceeds 128. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrToIpv6Address ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT IPv6_ADDRESS *Address, |
| OUT UINT8 *PrefixLength OPTIONAL |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode string to IPv4 address and prefix length. |
| |
| This function outputs a value of type IPv4_ADDRESS and may output a value |
| of type UINT8 by interpreting the contents of the Unicode string specified |
| by String. The format of the input Unicode string String is as follows: |
| |
| D.D.D.D[/P] |
| |
| D and P are decimal digit characters in the range [0-9]. The running zero in |
| the beginning of D and P will be ignored. /P is optional. |
| |
| When /P is not in the String, the function stops at the first character that is |
| not a valid decimal digit character after four D's are converted. |
| |
| When /P is in the String, the function stops at the first character that is not |
| a valid decimal digit character after P is converted. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| If EndPointer is not NULL and Address is translated from String, a pointer |
| to the character that stopped the scan is stored at the location pointed to |
| by EndPointer. |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Address Pointer to the converted IPv4 address. |
| @param PrefixLength Pointer to the converted IPv4 address prefix |
| length. MAX_UINT8 is returned when /P is |
| not in the String. |
| |
| @retval RETURN_SUCCESS Address is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If String is not in the correct format. |
| If any decimal number converted from D |
| exceeds 255. |
| If the decimal number converted from P |
| exceeds 32. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrToIpv4Address ( |
| IN CONST CHAR16 *String, |
| OUT CHAR16 **EndPointer, OPTIONAL |
| OUT IPv4_ADDRESS *Address, |
| OUT UINT8 *PrefixLength OPTIONAL |
| ); |
| |
| #define GUID_STRING_LENGTH 36 |
| |
| /** |
| Convert a Null-terminated Unicode GUID string to a value of type |
| EFI_GUID. |
| |
| This function outputs a GUID value by interpreting the contents of |
| the Unicode string specified by String. The format of the input |
| Unicode string String consists of 36 characters, as follows: |
| |
| aabbccdd-eeff-gghh-iijj-kkllmmnnoopp |
| |
| The pairs aa - pp are two characters in the range [0-9], [a-f] and |
| [A-F], with each pair representing a single byte hexadecimal value. |
| |
| The mapping between String and the EFI_GUID structure is as follows: |
| aa Data1[24:31] |
| bb Data1[16:23] |
| cc Data1[8:15] |
| dd Data1[0:7] |
| ee Data2[8:15] |
| ff Data2[0:7] |
| gg Data3[8:15] |
| hh Data3[0:7] |
| ii Data4[0:7] |
| jj Data4[8:15] |
| kk Data4[16:23] |
| ll Data4[24:31] |
| mm Data4[32:39] |
| nn Data4[40:47] |
| oo Data4[48:55] |
| pp Data4[56:63] |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param Guid Pointer to the converted GUID. |
| |
| @retval RETURN_SUCCESS Guid is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If String is not as the above format. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrToGuid ( |
| IN CONST CHAR16 *String, |
| OUT GUID *Guid |
| ); |
| |
| /** |
| Convert a Null-terminated Unicode hexadecimal string to a byte array. |
| |
| This function outputs a byte array by interpreting the contents of |
| the Unicode string specified by String in hexadecimal format. The format of |
| the input Unicode string String is: |
| |
| [XX]* |
| |
| X is a hexadecimal digit character in the range [0-9], [a-f] and [A-F]. |
| The function decodes every two hexadecimal digit characters as one byte. The |
| decoding stops after Length of characters and outputs Buffer containing |
| (Length / 2) bytes. |
| |
| If String is not aligned in a 16-bit boundary, then ASSERT(). |
| |
| @param String Pointer to a Null-terminated Unicode string. |
| @param Length The number of Unicode characters to decode. |
| @param Buffer Pointer to the converted bytes array. |
| @param MaxBufferSize The maximum size of Buffer. |
| |
| @retval RETURN_SUCCESS Buffer is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If Length is not multiple of 2. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and Length is greater than |
| PcdMaximumUnicodeStringLength. |
| @retval RETURN_UNSUPPORTED If Length of characters from String contain |
| a character that is not valid hexadecimal |
| digit characters, or a Null-terminator. |
| @retval RETURN_BUFFER_TOO_SMALL If MaxBufferSize is less than (Length / 2). |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| StrHexToBytes ( |
| IN CONST CHAR16 *String, |
| IN UINTN Length, |
| OUT UINT8 *Buffer, |
| IN UINTN MaxBufferSize |
| ); |
| |
| |
| /** |
| Convert a Null-terminated Unicode string to a Null-terminated |
| ASCII string. |
| |
| This function is similar to AsciiStrCpyS. |
| |
| This function converts the content of the Unicode string Source |
| to the ASCII string Destination by copying the lower 8 bits of |
| each Unicode character. The function terminates the ASCII string |
| Destination by appending a Null-terminator character at the end. |
| |
| The caller is responsible to make sure Destination points to a buffer with size |
| equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes. |
| |
| If any Unicode characters in Source contain non-zero value in |
| the upper 8 bits, then ASSERT(). |
| |
| If Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Source The pointer to a Null-terminated Unicode string. |
| @param Destination The pointer to a Null-terminated ASCII string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| |
| @retval RETURN_SUCCESS String is converted. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| UnicodeStrToAsciiStrS ( |
| IN CONST CHAR16 *Source, |
| OUT CHAR8 *Destination, |
| IN UINTN DestMax |
| ); |
| |
| /** |
| Convert not more than Length successive characters from a Null-terminated |
| Unicode string to a Null-terminated Ascii string. If no null char is copied |
| from Source, then Destination[Length] is always set to null. |
| |
| This function converts not more than Length successive characters from the |
| Unicode string Source to the Ascii string Destination by copying the lower 8 |
| bits of each Unicode character. The function terminates the Ascii string |
| Destination by appending a Null-terminator character at the end. |
| |
| The caller is responsible to make sure Destination points to a buffer with size |
| equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes. |
| |
| If any Unicode characters in Source contain non-zero value in the upper 8 |
| bits, then ASSERT(). |
| If Source is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Source The pointer to a Null-terminated Unicode string. |
| @param Length The maximum number of Unicode characters to |
| convert. |
| @param Destination The pointer to a Null-terminated Ascii string. |
| @param DestMax The maximum number of Destination Ascii |
| char, including terminating null char. |
| @param DestinationLength The number of Unicode characters converted. |
| |
| @retval RETURN_SUCCESS String is converted. |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If DestinationLength is NULL. |
| If PcdMaximumAsciiStringLength is not zero, |
| and Length or DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and Length or DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If DestMax is 0. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than |
| MIN(StrLen(Source), Length). |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| UnicodeStrnToAsciiStrS ( |
| IN CONST CHAR16 *Source, |
| IN UINTN Length, |
| OUT CHAR8 *Destination, |
| IN UINTN DestMax, |
| OUT UINTN *DestinationLength |
| ); |
| |
| |
| /** |
| Returns the length of a Null-terminated ASCII string. |
| |
| This function returns the number of ASCII characters in the Null-terminated |
| ASCII string specified by String. |
| |
| If Length > 0 and Destination is NULL, then ASSERT(). |
| If Length > 0 and Source is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and String contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @return The length of String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrLen ( |
| IN CONST CHAR8 *String |
| ); |
| |
| |
| /** |
| Returns the size of a Null-terminated ASCII string in bytes, including the |
| Null terminator. |
| |
| This function returns the size, in bytes, of the Null-terminated ASCII string |
| specified by String. |
| |
| If String is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and String contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @return The size of String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrSize ( |
| IN CONST CHAR8 *String |
| ); |
| |
| |
| /** |
| Compares two Null-terminated ASCII strings, and returns the difference |
| between the first mismatched ASCII characters. |
| |
| This function compares the Null-terminated ASCII string FirstString to the |
| Null-terminated ASCII string SecondString. If FirstString is identical to |
| SecondString, then 0 is returned. Otherwise, the value returned is the first |
| mismatched ASCII character in SecondString subtracted from the first |
| mismatched ASCII character in FirstString. |
| |
| If FirstString is NULL, then ASSERT(). |
| If SecondString is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and FirstString contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and SecondString contains more |
| than PcdMaximumAsciiStringLength ASCII characters not including the |
| Null-terminator, then ASSERT(). |
| |
| @param FirstString The pointer to a Null-terminated ASCII string. |
| @param SecondString The pointer to a Null-terminated ASCII string. |
| |
| @retval ==0 FirstString is identical to SecondString. |
| @retval !=0 FirstString is not identical to SecondString. |
| |
| **/ |
| INTN |
| EFIAPI |
| AsciiStrCmp ( |
| IN CONST CHAR8 *FirstString, |
| IN CONST CHAR8 *SecondString |
| ); |
| |
| |
| /** |
| Performs a case insensitive comparison of two Null-terminated ASCII strings, |
| and returns the difference between the first mismatched ASCII characters. |
| |
| This function performs a case insensitive comparison of the Null-terminated |
| ASCII string FirstString to the Null-terminated ASCII string SecondString. If |
| FirstString is identical to SecondString, then 0 is returned. Otherwise, the |
| value returned is the first mismatched lower case ASCII character in |
| SecondString subtracted from the first mismatched lower case ASCII character |
| in FirstString. |
| |
| If FirstString is NULL, then ASSERT(). |
| If SecondString is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and FirstString contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero and SecondString contains more |
| than PcdMaximumAsciiStringLength ASCII characters not including the |
| Null-terminator, then ASSERT(). |
| |
| @param FirstString The pointer to a Null-terminated ASCII string. |
| @param SecondString The pointer to a Null-terminated ASCII string. |
| |
| @retval ==0 FirstString is identical to SecondString using case insensitive |
| comparisons. |
| @retval !=0 FirstString is not identical to SecondString using case |
| insensitive comparisons. |
| |
| **/ |
| INTN |
| EFIAPI |
| AsciiStriCmp ( |
| IN CONST CHAR8 *FirstString, |
| IN CONST CHAR8 *SecondString |
| ); |
| |
| |
| /** |
| Compares two Null-terminated ASCII strings with maximum lengths, and returns |
| the difference between the first mismatched ASCII characters. |
| |
| This function compares the Null-terminated ASCII string FirstString to the |
| Null-terminated ASCII string SecondString. At most, Length ASCII characters |
| will be compared. If Length is 0, then 0 is returned. If FirstString is |
| identical to SecondString, then 0 is returned. Otherwise, the value returned |
| is the first mismatched ASCII character in SecondString subtracted from the |
| first mismatched ASCII character in FirstString. |
| |
| If Length > 0 and FirstString is NULL, then ASSERT(). |
| If Length > 0 and SecondString is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, and Length is greater than |
| PcdMaximumAsciiStringLength, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, and FirstString contains more than |
| PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator, |
| then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, and SecondString contains more than |
| PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator, |
| then ASSERT(). |
| |
| @param FirstString The pointer to a Null-terminated ASCII string. |
| @param SecondString The pointer to a Null-terminated ASCII string. |
| @param Length The maximum number of ASCII characters for compare. |
| |
| @retval ==0 FirstString is identical to SecondString. |
| @retval !=0 FirstString is not identical to SecondString. |
| |
| **/ |
| INTN |
| EFIAPI |
| AsciiStrnCmp ( |
| IN CONST CHAR8 *FirstString, |
| IN CONST CHAR8 *SecondString, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the first occurrence of a Null-terminated ASCII sub-string |
| in a Null-terminated ASCII string. |
| |
| This function scans the contents of the ASCII string specified by String |
| and returns the first occurrence of SearchString. If SearchString is not |
| found in String, then NULL is returned. If the length of SearchString is zero, |
| then String is returned. |
| |
| If String is NULL, then ASSERT(). |
| If SearchString is NULL, then ASSERT(). |
| |
| If PcdMaximumAsciiStringLength is not zero, and SearchString or |
| String contains more than PcdMaximumAsciiStringLength Unicode characters |
| not including the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| @param SearchString The pointer to a Null-terminated ASCII string to search for. |
| |
| @retval NULL If the SearchString does not appear in String. |
| @retval others If there is a match return the first occurrence of SearchingString. |
| If the length of SearchString is zero,return String. |
| |
| **/ |
| CHAR8 * |
| EFIAPI |
| AsciiStrStr ( |
| IN CONST CHAR8 *String, |
| IN CONST CHAR8 *SearchString |
| ); |
| |
| |
| /** |
| Convert a Null-terminated ASCII decimal string to a value of type |
| UINTN. |
| |
| This function returns a value of type UINTN by interpreting the contents |
| of the ASCII string String as a decimal number. The format of the input |
| ASCII string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before the digits. |
| The running zero in the beginning of [decimal digits] will be ignored. Then, the |
| function stops at the first character that is a not a valid decimal character or |
| Null-terminator, whichever on comes first. |
| |
| If String has only pad spaces, then 0 is returned. |
| If String has no pad spaces or valid decimal digits, then 0 is returned. |
| If the number represented by String overflows according to the range defined by |
| UINTN, then MAX_UINTN is returned. |
| If String is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, and String contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @retval The value translated from String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrDecimalToUintn ( |
| IN CONST CHAR8 *String |
| ); |
| |
| |
| /** |
| Convert a Null-terminated ASCII decimal string to a value of type |
| UINT64. |
| |
| This function returns a value of type UINT64 by interpreting the contents |
| of the ASCII string String as a decimal number. The format of the input |
| ASCII string String is: |
| |
| [spaces] [decimal digits]. |
| |
| The valid decimal digit character is in the range [0-9]. The function will |
| ignore the pad space, which includes spaces or tab characters, before the digits. |
| The running zero in the beginning of [decimal digits] will be ignored. Then, the |
| function stops at the first character that is a not a valid decimal character or |
| Null-terminator, whichever on comes first. |
| |
| If String has only pad spaces, then 0 is returned. |
| If String has no pad spaces or valid decimal digits, then 0 is returned. |
| If the number represented by String overflows according to the range defined by |
| UINT64, then MAX_UINT64 is returned. |
| If String is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, and String contains more than |
| PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator, |
| then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsciiStrDecimalToUint64 ( |
| IN CONST CHAR8 *String |
| ); |
| |
| |
| /** |
| Convert a Null-terminated ASCII hexadecimal string to a value of type UINTN. |
| |
| This function returns a value of type UINTN by interpreting the contents of |
| the ASCII string String as a hexadecimal number. The format of the input ASCII |
| string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If "x" |
| appears in the input string, it must be prefixed with at least one 0. The function |
| will ignore the pad space, which includes spaces or tab characters, before [zeros], |
| [x] or [hexadecimal digits]. The running zero before [x] or [hexadecimal digits] |
| will be ignored. Then, the decoding starts after [x] or the first valid hexadecimal |
| digit. Then, the function stops at the first character that is a not a valid |
| hexadecimal character or Null-terminator, whichever on comes first. |
| |
| If String has only pad spaces, then 0 is returned. |
| If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then |
| 0 is returned. |
| |
| If the number represented by String overflows according to the range defined by UINTN, |
| then MAX_UINTN is returned. |
| If String is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than PcdMaximumAsciiStringLength ASCII characters not including |
| the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsciiStrHexToUintn ( |
| IN CONST CHAR8 *String |
| ); |
| |
| |
| /** |
| Convert a Null-terminated ASCII hexadecimal string to a value of type UINT64. |
| |
| This function returns a value of type UINT64 by interpreting the contents of |
| the ASCII string String as a hexadecimal number. The format of the input ASCII |
| string String is: |
| |
| [spaces][zeros][x][hexadecimal digits]. |
| |
| The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F]. |
| The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If "x" |
| appears in the input string, it must be prefixed with at least one 0. The function |
| will ignore the pad space, which includes spaces or tab characters, before [zeros], |
| [x] or [hexadecimal digits]. The running zero before [x] or [hexadecimal digits] |
| will be ignored. Then, the decoding starts after [x] or the first valid hexadecimal |
| digit. Then, the function stops at the first character that is a not a valid |
| hexadecimal character or Null-terminator, whichever on comes first. |
| |
| If String has only pad spaces, then 0 is returned. |
| If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then |
| 0 is returned. |
| |
| If the number represented by String overflows according to the range defined by UINT64, |
| then MAX_UINT64 is returned. |
| If String is NULL, then ASSERT(). |
| If PcdMaximumAsciiStringLength is not zero, |
| and String contains more than PcdMaximumAsciiStringLength ASCII characters not including |
| the Null-terminator, then ASSERT(). |
| |
| @param String The pointer to a Null-terminated ASCII string. |
| |
| @retval Value translated from String. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsciiStrHexToUint64 ( |
| IN CONST CHAR8 *String |
| ); |
| |
| /** |
| Convert a Null-terminated ASCII string to IPv6 address and prefix length. |
| |
| This function outputs a value of type IPv6_ADDRESS and may output a value |
| of type UINT8 by interpreting the contents of the ASCII string specified |
| by String. The format of the input ASCII string String is as follows: |
| |
| X:X:X:X:X:X:X:X[/P] |
| |
| X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and |
| [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low |
| memory address and high byte is stored in high memory address. P contains decimal |
| digit characters in the range [0-9]. The running zero in the beginning of P will |
| be ignored. /P is optional. |
| |
| When /P is not in the String, the function stops at the first character that is |
| not a valid hexadecimal digit character after eight X's are converted. |
| |
| When /P is in the String, the function stops at the first character that is not |
| a valid decimal digit character after P is converted. |
| |
| "::" can be used to compress one or more groups of X when X contains only 0. |
| The "::" can only appear once in the String. |
| |
| If EndPointer is not NULL and Address is translated from String, a pointer |
| to the character that stopped the scan is stored at the location pointed to |
| by EndPointer. |
| |
| @param String Pointer to a Null-terminated ASCII string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Address Pointer to the converted IPv6 address. |
| @param PrefixLength Pointer to the converted IPv6 address prefix |
| length. MAX_UINT8 is returned when /P is |
| not in the String. |
| |
| @retval RETURN_SUCCESS Address is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If X contains more than four hexadecimal |
| digit characters. |
| If String contains "::" and number of X |
| is not less than 8. |
| If P starts with character that is not a |
| valid decimal digit character. |
| If the decimal number converted from P |
| exceeds 128. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrToIpv6Address ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT IPv6_ADDRESS *Address, |
| OUT UINT8 *PrefixLength OPTIONAL |
| ); |
| |
| /** |
| Convert a Null-terminated ASCII string to IPv4 address and prefix length. |
| |
| This function outputs a value of type IPv4_ADDRESS and may output a value |
| of type UINT8 by interpreting the contents of the ASCII string specified |
| by String. The format of the input ASCII string String is as follows: |
| |
| D.D.D.D[/P] |
| |
| D and P are decimal digit characters in the range [0-9]. The running zero in |
| the beginning of D and P will be ignored. /P is optional. |
| |
| When /P is not in the String, the function stops at the first character that is |
| not a valid decimal digit character after four D's are converted. |
| |
| When /P is in the String, the function stops at the first character that is not |
| a valid decimal digit character after P is converted. |
| |
| If EndPointer is not NULL and Address is translated from String, a pointer |
| to the character that stopped the scan is stored at the location pointed to |
| by EndPointer. |
| |
| @param String Pointer to a Null-terminated ASCII string. |
| @param EndPointer Pointer to character that stops scan. |
| @param Address Pointer to the converted IPv4 address. |
| @param PrefixLength Pointer to the converted IPv4 address prefix |
| length. MAX_UINT8 is returned when /P is |
| not in the String. |
| |
| @retval RETURN_SUCCESS Address is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If String is not in the correct format. |
| If any decimal number converted from D |
| exceeds 255. |
| If the decimal number converted from P |
| exceeds 32. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrToIpv4Address ( |
| IN CONST CHAR8 *String, |
| OUT CHAR8 **EndPointer, OPTIONAL |
| OUT IPv4_ADDRESS *Address, |
| OUT UINT8 *PrefixLength OPTIONAL |
| ); |
| |
| /** |
| Convert a Null-terminated ASCII GUID string to a value of type |
| EFI_GUID. |
| |
| This function outputs a GUID value by interpreting the contents of |
| the ASCII string specified by String. The format of the input |
| ASCII string String consists of 36 characters, as follows: |
| |
| aabbccdd-eeff-gghh-iijj-kkllmmnnoopp |
| |
| The pairs aa - pp are two characters in the range [0-9], [a-f] and |
| [A-F], with each pair representing a single byte hexadecimal value. |
| |
| The mapping between String and the EFI_GUID structure is as follows: |
| aa Data1[24:31] |
| bb Data1[16:23] |
| cc Data1[8:15] |
| dd Data1[0:7] |
| ee Data2[8:15] |
| ff Data2[0:7] |
| gg Data3[8:15] |
| hh Data3[0:7] |
| ii Data4[0:7] |
| jj Data4[8:15] |
| kk Data4[16:23] |
| ll Data4[24:31] |
| mm Data4[32:39] |
| nn Data4[40:47] |
| oo Data4[48:55] |
| pp Data4[56:63] |
| |
| @param String Pointer to a Null-terminated ASCII string. |
| @param Guid Pointer to the converted GUID. |
| |
| @retval RETURN_SUCCESS Guid is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| @retval RETURN_UNSUPPORTED If String is not as the above format. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrToGuid ( |
| IN CONST CHAR8 *String, |
| OUT GUID *Guid |
| ); |
| |
| /** |
| Convert a Null-terminated ASCII hexadecimal string to a byte array. |
| |
| This function outputs a byte array by interpreting the contents of |
| the ASCII string specified by String in hexadecimal format. The format of |
| the input ASCII string String is: |
| |
| [XX]* |
| |
| X is a hexadecimal digit character in the range [0-9], [a-f] and [A-F]. |
| The function decodes every two hexadecimal digit characters as one byte. The |
| decoding stops after Length of characters and outputs Buffer containing |
| (Length / 2) bytes. |
| |
| @param String Pointer to a Null-terminated ASCII string. |
| @param Length The number of ASCII characters to decode. |
| @param Buffer Pointer to the converted bytes array. |
| @param MaxBufferSize The maximum size of Buffer. |
| |
| @retval RETURN_SUCCESS Buffer is translated from String. |
| @retval RETURN_INVALID_PARAMETER If String is NULL. |
| If Data is NULL. |
| If Length is not multiple of 2. |
| If PcdMaximumAsciiStringLength is not zero, |
| and Length is greater than |
| PcdMaximumAsciiStringLength. |
| @retval RETURN_UNSUPPORTED If Length of characters from String contain |
| a character that is not valid hexadecimal |
| digit characters, or a Null-terminator. |
| @retval RETURN_BUFFER_TOO_SMALL If MaxBufferSize is less than (Length / 2). |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrHexToBytes ( |
| IN CONST CHAR8 *String, |
| IN UINTN Length, |
| OUT UINT8 *Buffer, |
| IN UINTN MaxBufferSize |
| ); |
| |
| |
| /** |
| Convert one Null-terminated ASCII string to a Null-terminated |
| Unicode string. |
| |
| This function is similar to StrCpyS. |
| |
| This function converts the contents of the ASCII string Source to the Unicode |
| string Destination. The function terminates the Unicode string Destination by |
| appending a Null-terminator character at the end. |
| |
| The caller is responsible to make sure Destination points to a buffer with size |
| equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes. |
| |
| If Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then the Destination is unmodified. |
| |
| @param Source The pointer to a Null-terminated ASCII string. |
| @param Destination The pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode |
| char, including terminating null char. |
| |
| @retval RETURN_SUCCESS String is converted. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than StrLen(Source). |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If PcdMaximumUnicodeStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If PcdMaximumAsciiStringLength is not zero, |
| and DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrToUnicodeStrS ( |
| IN CONST CHAR8 *Source, |
| OUT CHAR16 *Destination, |
| IN UINTN DestMax |
| ); |
| |
| /** |
| Convert not more than Length successive characters from a Null-terminated |
| Ascii string to a Null-terminated Unicode string. If no null char is copied |
| from Source, then Destination[Length] is always set to null. |
| |
| This function converts not more than Length successive characters from the |
| Ascii string Source to the Unicode string Destination. The function |
| terminates the Unicode string Destination by appending a Null-terminator |
| character at the end. |
| |
| The caller is responsible to make sure Destination points to a buffer with |
| size not smaller than |
| ((MIN(AsciiStrLen(Source), Length) + 1) * sizeof (CHAR8)) in bytes. |
| |
| If Destination is not aligned on a 16-bit boundary, then ASSERT(). |
| |
| If an error is returned, then Destination and DestinationLength are |
| unmodified. |
| |
| @param Source The pointer to a Null-terminated Ascii string. |
| @param Length The maximum number of Ascii characters to convert. |
| @param Destination The pointer to a Null-terminated Unicode string. |
| @param DestMax The maximum number of Destination Unicode char, |
| including terminating null char. |
| @param DestinationLength The number of Ascii characters converted. |
| |
| @retval RETURN_SUCCESS String is converted. |
| @retval RETURN_INVALID_PARAMETER If Destination is NULL. |
| If Source is NULL. |
| If DestinationLength is NULL. |
| If PcdMaximumUnicodeStringLength is not |
| zero, and Length or DestMax is greater than |
| PcdMaximumUnicodeStringLength. |
| If PcdMaximumAsciiStringLength is not zero, |
| and Length or DestMax is greater than |
| PcdMaximumAsciiStringLength. |
| If DestMax is 0. |
| @retval RETURN_BUFFER_TOO_SMALL If DestMax is NOT greater than |
| MIN(AsciiStrLen(Source), Length). |
| @retval RETURN_ACCESS_DENIED If Source and Destination overlap. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| AsciiStrnToUnicodeStrS ( |
| IN CONST CHAR8 *Source, |
| IN UINTN Length, |
| OUT CHAR16 *Destination, |
| IN UINTN DestMax, |
| OUT UINTN *DestinationLength |
| ); |
| |
| /** |
| Convert a Unicode character to upper case only if |
| it maps to a valid small-case ASCII character. |
| |
| This internal function only deal with Unicode character |
| which maps to a valid small-case ASCII character, i.e. |
| L'a' to L'z'. For other Unicode character, the input character |
| is returned directly. |
| |
| @param Char The character to convert. |
| |
| @retval LowerCharacter If the Char is with range L'a' to L'z'. |
| @retval Unchanged Otherwise. |
| |
| **/ |
| CHAR16 |
| EFIAPI |
| CharToUpper ( |
| IN CHAR16 Char |
| ); |
| |
| /** |
| Converts a lowercase Ascii character to upper one. |
| |
| If Chr is lowercase Ascii character, then converts it to upper one. |
| |
| If Value >= 0xA0, then ASSERT(). |
| If (Value & 0x0F) >= 0x0A, then ASSERT(). |
| |
| @param Chr one Ascii character |
| |
| @return The uppercase value of Ascii character |
| |
| **/ |
| CHAR8 |
| EFIAPI |
| AsciiCharToUpper ( |
| IN CHAR8 Chr |
| ); |
| |
| /** |
| Convert binary data to a Base64 encoded ascii string based on RFC4648. |
| |
| Produce a Null-terminated Ascii string in the output buffer specified by Destination and DestinationSize. |
| The Ascii string is produced by converting the data string specified by Source and SourceLength. |
| |
| @param Source Input UINT8 data |
| @param SourceLength Number of UINT8 bytes of data |
| @param Destination Pointer to output string buffer |
| @param DestinationSize Size of ascii buffer. Set to 0 to get the size needed. |
| Caller is responsible for passing in buffer of DestinationSize |
| |
| @retval RETURN_SUCCESS When ascii buffer is filled in. |
| @retval RETURN_INVALID_PARAMETER If Source is NULL or DestinationSize is NULL. |
| @retval RETURN_INVALID_PARAMETER If SourceLength or DestinationSize is bigger than (MAX_ADDRESS - (UINTN)Destination). |
| @retval RETURN_BUFFER_TOO_SMALL If SourceLength is 0 and DestinationSize is <1. |
| @retval RETURN_BUFFER_TOO_SMALL If Destination is NULL or DestinationSize is smaller than required buffersize. |
| |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| Base64Encode ( |
| IN CONST UINT8 *Source, |
| IN UINTN SourceLength, |
| OUT CHAR8 *Destination OPTIONAL, |
| IN OUT UINTN *DestinationSize |
| ); |
| |
| /** |
| Decode Base64 ASCII encoded data to 8-bit binary representation, based on |
| RFC4648. |
| |
| Decoding occurs according to "Table 1: The Base 64 Alphabet" in RFC4648. |
| |
| Whitespace is ignored at all positions: |
| - 0x09 ('\t') horizontal tab |
| - 0x0A ('\n') new line |
| - 0x0B ('\v') vertical tab |
| - 0x0C ('\f') form feed |
| - 0x0D ('\r') carriage return |
| - 0x20 (' ') space |
| |
| The minimum amount of required padding (with ASCII 0x3D, '=') is tolerated |
| and enforced at the end of the Base64 ASCII encoded data, and only there. |
| |
| Other characters outside of the encoding alphabet cause the function to |
| reject the Base64 ASCII encoded data. |
| |
| @param[in] Source Array of CHAR8 elements containing the Base64 |
| ASCII encoding. May be NULL if SourceSize is |
| zero. |
| |
| @param[in] SourceSize Number of CHAR8 elements in Source. |
| |
| @param[out] Destination Array of UINT8 elements receiving the decoded |
| 8-bit binary representation. Allocated by the |
| caller. May be NULL if DestinationSize is |
| zero on input. If NULL, decoding is |
| performed, but the 8-bit binary |
| representation is not stored. If non-NULL and |
| the function returns an error, the contents |
| of Destination are indeterminate. |
| |
| @param[in,out] DestinationSize On input, the number of UINT8 elements that |
| the caller allocated for Destination. On |
| output, if the function returns |
| RETURN_SUCCESS or RETURN_BUFFER_TOO_SMALL, |
| the number of UINT8 elements that are |
| required for decoding the Base64 ASCII |
| representation. If the function returns a |
| value different from both RETURN_SUCCESS and |
| RETURN_BUFFER_TOO_SMALL, then DestinationSize |
| is indeterminate on output. |
| |
| @retval RETURN_SUCCESS SourceSize CHAR8 elements at Source have |
| been decoded to on-output DestinationSize |
| UINT8 elements at Destination. Note that |
| RETURN_SUCCESS covers the case when |
| DestinationSize is zero on input, and |
| Source decodes to zero bytes (due to |
| containing at most ignored whitespace). |
| |
| @retval RETURN_BUFFER_TOO_SMALL The input value of DestinationSize is not |
| large enough for decoding SourceSize CHAR8 |
| elements at Source. The required number of |
| UINT8 elements has been stored to |
| DestinationSize. |
| |
| @retval RETURN_INVALID_PARAMETER DestinationSize is NULL. |
| |
| @retval RETURN_INVALID_PARAMETER Source is NULL, but SourceSize is not zero. |
| |
| @retval RETURN_INVALID_PARAMETER Destination is NULL, but DestinationSize is |
| not zero on input. |
| |
| @retval RETURN_INVALID_PARAMETER Source is non-NULL, and (Source + |
| SourceSize) would wrap around MAX_ADDRESS. |
| |
| @retval RETURN_INVALID_PARAMETER Destination is non-NULL, and (Destination + |
| DestinationSize) would wrap around |
| MAX_ADDRESS, as specified on input. |
| |
| @retval RETURN_INVALID_PARAMETER None of Source and Destination are NULL, |
| and CHAR8[SourceSize] at Source overlaps |
| UINT8[DestinationSize] at Destination, as |
| specified on input. |
| |
| @retval RETURN_INVALID_PARAMETER Invalid CHAR8 element encountered in |
| Source. |
| **/ |
| RETURN_STATUS |
| EFIAPI |
| Base64Decode ( |
| IN CONST CHAR8 *Source OPTIONAL, |
| IN UINTN SourceSize, |
| OUT UINT8 *Destination OPTIONAL, |
| IN OUT UINTN *DestinationSize |
| ); |
| |
| /** |
| Converts an 8-bit value to an 8-bit BCD value. |
| |
| Converts the 8-bit value specified by Value to BCD. The BCD value is |
| returned. |
| |
| If Value >= 100, then ASSERT(). |
| |
| @param Value The 8-bit value to convert to BCD. Range 0..99. |
| |
| @return The BCD value. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| DecimalToBcd8 ( |
| IN UINT8 Value |
| ); |
| |
| |
| /** |
| Converts an 8-bit BCD value to an 8-bit value. |
| |
| Converts the 8-bit BCD value specified by Value to an 8-bit value. The 8-bit |
| value is returned. |
| |
| If Value >= 0xA0, then ASSERT(). |
| If (Value & 0x0F) >= 0x0A, then ASSERT(). |
| |
| @param Value The 8-bit BCD value to convert to an 8-bit value. |
| |
| @return The 8-bit value is returned. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BcdToDecimal8 ( |
| IN UINT8 Value |
| ); |
| |
| // |
| // File Path Manipulation Functions |
| // |
| |
| /** |
| Removes the last directory or file entry in a path. |
| |
| @param[in, out] Path The pointer to the path to modify. |
| |
| @retval FALSE Nothing was found to remove. |
| @retval TRUE A directory or file was removed. |
| **/ |
| BOOLEAN |
| EFIAPI |
| PathRemoveLastItem( |
| IN OUT CHAR16 *Path |
| ); |
| |
| /** |
| Function to clean up paths. |
| - Single periods in the path are removed. |
| - Double periods in the path are removed along with a single parent directory. |
| - Forward slashes L'/' are converted to backward slashes L'\'. |
| |
| This will be done inline and the existing buffer may be larger than required |
| upon completion. |
| |
| @param[in] Path The pointer to the string containing the path. |
| |
| @return Returns Path, otherwise returns NULL to indicate that an error has occurred. |
| **/ |
| CHAR16* |
| EFIAPI |
| PathCleanUpDirectories( |
| IN CHAR16 *Path |
| ); |
| |
| // |
| // Linked List Functions and Macros |
| // |
| |
| /** |
| Initializes the head node of a doubly linked list that is declared as a |
| global variable in a module. |
| |
| Initializes the forward and backward links of a new linked list. After |
| initializing a linked list with this macro, the other linked list functions |
| may be used to add and remove nodes from the linked list. This macro results |
| in smaller executables by initializing the linked list in the data section, |
| instead if calling the InitializeListHead() function to perform the |
| equivalent operation. |
| |
| @param ListHead The head note of a list to initialize. |
| |
| **/ |
| #define INITIALIZE_LIST_HEAD_VARIABLE(ListHead) {&(ListHead), &(ListHead)} |
| |
| /** |
| Iterates over each node in a doubly linked list using each node's forward link. |
| |
| @param Entry A pointer to a list node used as a loop cursor during iteration |
| @param ListHead The head node of the doubly linked list |
| |
| **/ |
| #define BASE_LIST_FOR_EACH(Entry, ListHead) \ |
| for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink) |
| |
| /** |
| Iterates over each node in a doubly linked list using each node's forward link |
| with safety against node removal. |
| |
| This macro uses NextEntry to temporarily store the next list node so the node |
| pointed to by Entry may be deleted in the current loop iteration step and |
| iteration can continue from the node pointed to by NextEntry. |
| |
| @param Entry A pointer to a list node used as a loop cursor during iteration |
| @param NextEntry A pointer to a list node used to temporarily store the next node |
| @param ListHead The head node of the doubly linked list |
| |
| **/ |
| #define BASE_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \ |
| for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink;\ |
| Entry != (ListHead); Entry = NextEntry, NextEntry = Entry->ForwardLink) |
| |
| /** |
| Checks whether FirstEntry and SecondEntry are part of the same doubly-linked |
| list. |
| |
| If FirstEntry is NULL, then ASSERT(). |
| If FirstEntry->ForwardLink is NULL, then ASSERT(). |
| If FirstEntry->BackLink is NULL, then ASSERT(). |
| If SecondEntry is NULL, then ASSERT(); |
| If PcdMaximumLinkedListLength is not zero, and List contains more than |
| PcdMaximumLinkedListLength nodes, then ASSERT(). |
| |
| @param FirstEntry A pointer to a node in a linked list. |
| @param SecondEntry A pointer to the node to locate. |
| |
| @retval TRUE SecondEntry is in the same doubly-linked list as FirstEntry. |
| @retval FALSE SecondEntry isn't in the same doubly-linked list as FirstEntry, |
| or FirstEntry is invalid. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| IsNodeInList ( |
| IN CONST LIST_ENTRY *FirstEntry, |
| IN CONST LIST_ENTRY *SecondEntry |
| ); |
| |
| |
| /** |
| Initializes the head node of a doubly linked list, and returns the pointer to |
| the head node of the doubly linked list. |
| |
| Initializes the forward and backward links of a new linked list. After |
| initializing a linked list with this function, the other linked list |
| functions may be used to add and remove nodes from the linked list. It is up |
| to the caller of this function to allocate the memory for ListHead. |
| |
| If ListHead is NULL, then ASSERT(). |
| |
| @param ListHead A pointer to the head node of a new doubly linked list. |
| |
| @return ListHead |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| InitializeListHead ( |
| IN OUT LIST_ENTRY *ListHead |
| ); |
| |
| |
| /** |
| Adds a node to the beginning of a doubly linked list, and returns the pointer |
| to the head node of the doubly linked list. |
| |
| Adds the node Entry at the beginning of the doubly linked list denoted by |
| ListHead, and returns ListHead. |
| |
| If ListHead is NULL, then ASSERT(). |
| If Entry is NULL, then ASSERT(). |
| If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and prior to insertion the number |
| of nodes in ListHead, including the ListHead node, is greater than or |
| equal to PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param ListHead A pointer to the head node of a doubly linked list. |
| @param Entry A pointer to a node that is to be inserted at the beginning |
| of a doubly linked list. |
| |
| @return ListHead |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| InsertHeadList ( |
| IN OUT LIST_ENTRY *ListHead, |
| IN OUT LIST_ENTRY *Entry |
| ); |
| |
| |
| /** |
| Adds a node to the end of a doubly linked list, and returns the pointer to |
| the head node of the doubly linked list. |
| |
| Adds the node Entry to the end of the doubly linked list denoted by ListHead, |
| and returns ListHead. |
| |
| If ListHead is NULL, then ASSERT(). |
| If Entry is NULL, then ASSERT(). |
| If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and prior to insertion the number |
| of nodes in ListHead, including the ListHead node, is greater than or |
| equal to PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param ListHead A pointer to the head node of a doubly linked list. |
| @param Entry A pointer to a node that is to be added at the end of the |
| doubly linked list. |
| |
| @return ListHead |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| InsertTailList ( |
| IN OUT LIST_ENTRY *ListHead, |
| IN OUT LIST_ENTRY *Entry |
| ); |
| |
| |
| /** |
| Retrieves the first node of a doubly linked list. |
| |
| Returns the first node of a doubly linked list. List must have been |
| initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). |
| If List is empty, then List is returned. |
| |
| If List is NULL, then ASSERT(). |
| If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes |
| in List, including the List node, is greater than or equal to |
| PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param List A pointer to the head node of a doubly linked list. |
| |
| @return The first node of a doubly linked list. |
| @retval List The list is empty. |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| GetFirstNode ( |
| IN CONST LIST_ENTRY *List |
| ); |
| |
| |
| /** |
| Retrieves the next node of a doubly linked list. |
| |
| Returns the node of a doubly linked list that follows Node. |
| List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE() |
| or InitializeListHead(). If List is empty, then List is returned. |
| |
| If List is NULL, then ASSERT(). |
| If Node is NULL, then ASSERT(). |
| If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and List contains more than |
| PcdMaximumLinkedListLength nodes, then ASSERT(). |
| If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT(). |
| |
| @param List A pointer to the head node of a doubly linked list. |
| @param Node A pointer to a node in the doubly linked list. |
| |
| @return The pointer to the next node if one exists. Otherwise List is returned. |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| GetNextNode ( |
| IN CONST LIST_ENTRY *List, |
| IN CONST LIST_ENTRY *Node |
| ); |
| |
| |
| /** |
| Retrieves the previous node of a doubly linked list. |
| |
| Returns the node of a doubly linked list that precedes Node. |
| List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE() |
| or InitializeListHead(). If List is empty, then List is returned. |
| |
| If List is NULL, then ASSERT(). |
| If Node is NULL, then ASSERT(). |
| If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and List contains more than |
| PcdMaximumLinkedListLength nodes, then ASSERT(). |
| If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT(). |
| |
| @param List A pointer to the head node of a doubly linked list. |
| @param Node A pointer to a node in the doubly linked list. |
| |
| @return The pointer to the previous node if one exists. Otherwise List is returned. |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| GetPreviousNode ( |
| IN CONST LIST_ENTRY *List, |
| IN CONST LIST_ENTRY *Node |
| ); |
| |
| |
| /** |
| Checks to see if a doubly linked list is empty or not. |
| |
| Checks to see if the doubly linked list is empty. If the linked list contains |
| zero nodes, this function returns TRUE. Otherwise, it returns FALSE. |
| |
| If ListHead is NULL, then ASSERT(). |
| If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes |
| in List, including the List node, is greater than or equal to |
| PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param ListHead A pointer to the head node of a doubly linked list. |
| |
| @retval TRUE The linked list is empty. |
| @retval FALSE The linked list is not empty. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| IsListEmpty ( |
| IN CONST LIST_ENTRY *ListHead |
| ); |
| |
| |
| /** |
| Determines if a node in a doubly linked list is the head node of a the same |
| doubly linked list. This function is typically used to terminate a loop that |
| traverses all the nodes in a doubly linked list starting with the head node. |
| |
| Returns TRUE if Node is equal to List. Returns FALSE if Node is one of the |
| nodes in the doubly linked list specified by List. List must have been |
| initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). |
| |
| If List is NULL, then ASSERT(). |
| If Node is NULL, then ASSERT(). |
| If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(), |
| then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes |
| in List, including the List node, is greater than or equal to |
| PcdMaximumLinkedListLength, then ASSERT(). |
| If PcdVerifyNodeInList is TRUE and Node is not a node in List the and Node is not equal |
| to List, then ASSERT(). |
| |
| @param List A pointer to the head node of a doubly linked list. |
| @param Node A pointer to a node in the doubly linked list. |
| |
| @retval TRUE Node is the head of the doubly-linked list pointed by List. |
| @retval FALSE Node is not the head of the doubly-linked list pointed by List. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| IsNull ( |
| IN CONST LIST_ENTRY *List, |
| IN CONST LIST_ENTRY *Node |
| ); |
| |
| |
| /** |
| Determines if a node the last node in a doubly linked list. |
| |
| Returns TRUE if Node is the last node in the doubly linked list specified by |
| List. Otherwise, FALSE is returned. List must have been initialized with |
| INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). |
| |
| If List is NULL, then ASSERT(). |
| If Node is NULL, then ASSERT(). |
| If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or |
| InitializeListHead(), then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes |
| in List, including the List node, is greater than or equal to |
| PcdMaximumLinkedListLength, then ASSERT(). |
| If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT(). |
| |
| @param List A pointer to the head node of a doubly linked list. |
| @param Node A pointer to a node in the doubly linked list. |
| |
| @retval TRUE Node is the last node in the linked list. |
| @retval FALSE Node is not the last node in the linked list. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| IsNodeAtEnd ( |
| IN CONST LIST_ENTRY *List, |
| IN CONST LIST_ENTRY *Node |
| ); |
| |
| |
| /** |
| Swaps the location of two nodes in a doubly linked list, and returns the |
| first node after the swap. |
| |
| If FirstEntry is identical to SecondEntry, then SecondEntry is returned. |
| Otherwise, the location of the FirstEntry node is swapped with the location |
| of the SecondEntry node in a doubly linked list. SecondEntry must be in the |
| same double linked list as FirstEntry and that double linked list must have |
| been initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). |
| SecondEntry is returned after the nodes are swapped. |
| |
| If FirstEntry is NULL, then ASSERT(). |
| If SecondEntry is NULL, then ASSERT(). |
| If PcdVerifyNodeInList is TRUE and SecondEntry and FirstEntry are not in the |
| same linked list, then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes in the |
| linked list containing the FirstEntry and SecondEntry nodes, including |
| the FirstEntry and SecondEntry nodes, is greater than or equal to |
| PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param FirstEntry A pointer to a node in a linked list. |
| @param SecondEntry A pointer to another node in the same linked list. |
| |
| @return SecondEntry. |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| SwapListEntries ( |
| IN OUT LIST_ENTRY *FirstEntry, |
| IN OUT LIST_ENTRY *SecondEntry |
| ); |
| |
| |
| /** |
| Removes a node from a doubly linked list, and returns the node that follows |
| the removed node. |
| |
| Removes the node Entry from a doubly linked list. It is up to the caller of |
| this function to release the memory used by this node if that is required. On |
| exit, the node following Entry in the doubly linked list is returned. If |
| Entry is the only node in the linked list, then the head node of the linked |
| list is returned. |
| |
| If Entry is NULL, then ASSERT(). |
| If Entry is the head node of an empty list, then ASSERT(). |
| If PcdMaximumLinkedListLength is not zero, and the number of nodes in the |
| linked list containing Entry, including the Entry node, is greater than |
| or equal to PcdMaximumLinkedListLength, then ASSERT(). |
| |
| @param Entry A pointer to a node in a linked list. |
| |
| @return Entry. |
| |
| **/ |
| LIST_ENTRY * |
| EFIAPI |
| RemoveEntryList ( |
| IN CONST LIST_ENTRY *Entry |
| ); |
| |
| // |
| // Math Services |
| // |
| /** |
| Prototype for comparison function for any two element types. |
| |
| @param[in] Buffer1 The pointer to first buffer. |
| @param[in] Buffer2 The pointer to second buffer. |
| |
| @retval 0 Buffer1 equal to Buffer2. |
| @return <0 Buffer1 is less than Buffer2. |
| @return >0 Buffer1 is greater than Buffer2. |
| **/ |
| typedef |
| INTN |
| (EFIAPI *BASE_SORT_COMPARE)( |
| IN CONST VOID *Buffer1, |
| IN CONST VOID *Buffer2 |
| ); |
| |
| /** |
| This function is identical to perform QuickSort, |
| except that is uses the pre-allocated buffer so the in place sorting does not need to |
| allocate and free buffers constantly. |
| |
| Each element must be equal sized. |
| |
| if BufferToSort is NULL, then ASSERT. |
| if CompareFunction is NULL, then ASSERT. |
| if BufferOneElement is NULL, then ASSERT. |
| if ElementSize is < 1, then ASSERT. |
| |
| if Count is < 2 then perform no action. |
| |
| @param[in, out] BufferToSort on call a Buffer of (possibly sorted) elements |
| on return a buffer of sorted elements |
| @param[in] Count the number of elements in the buffer to sort |
| @param[in] ElementSize Size of an element in bytes |
| @param[in] CompareFunction The function to call to perform the comparison |
| of any 2 elements |
| @param[out] BufferOneElement Caller provided buffer whose size equals to ElementSize. |
| It's used by QuickSort() for swapping in sorting. |
| **/ |
| VOID |
| EFIAPI |
| QuickSort ( |
| IN OUT VOID *BufferToSort, |
| IN CONST UINTN Count, |
| IN CONST UINTN ElementSize, |
| IN BASE_SORT_COMPARE CompareFunction, |
| OUT VOID *BufferOneElement |
| ); |
| |
| /** |
| Shifts a 64-bit integer left between 0 and 63 bits. The low bits are filled |
| with zeros. The shifted value is returned. |
| |
| This function shifts the 64-bit value Operand to the left by Count bits. The |
| low Count bits are set to zero. The shifted value is returned. |
| |
| If Count is greater than 63, then ASSERT(). |
| |
| @param Operand The 64-bit operand to shift left. |
| @param Count The number of bits to shift left. |
| |
| @return Operand << Count. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| LShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Shifts a 64-bit integer right between 0 and 63 bits. This high bits are |
| filled with zeros. The shifted value is returned. |
| |
| This function shifts the 64-bit value Operand to the right by Count bits. The |
| high Count bits are set to zero. The shifted value is returned. |
| |
| If Count is greater than 63, then ASSERT(). |
| |
| @param Operand The 64-bit operand to shift right. |
| @param Count The number of bits to shift right. |
| |
| @return Operand >> Count |
| |
| **/ |
| UINT64 |
| EFIAPI |
| RShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Shifts a 64-bit integer right between 0 and 63 bits. The high bits are filled |
| with original integer's bit 63. The shifted value is returned. |
| |
| This function shifts the 64-bit value Operand to the right by Count bits. The |
| high Count bits are set to bit 63 of Operand. The shifted value is returned. |
| |
| If Count is greater than 63, then ASSERT(). |
| |
| @param Operand The 64-bit operand to shift right. |
| @param Count The number of bits to shift right. |
| |
| @return Operand >> Count |
| |
| **/ |
| UINT64 |
| EFIAPI |
| ARShiftU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Rotates a 32-bit integer left between 0 and 31 bits, filling the low bits |
| with the high bits that were rotated. |
| |
| This function rotates the 32-bit value Operand to the left by Count bits. The |
| low Count bits are fill with the high Count bits of Operand. The rotated |
| value is returned. |
| |
| If Count is greater than 31, then ASSERT(). |
| |
| @param Operand The 32-bit operand to rotate left. |
| @param Count The number of bits to rotate left. |
| |
| @return Operand << Count |
| |
| **/ |
| UINT32 |
| EFIAPI |
| LRotU32 ( |
| IN UINT32 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Rotates a 32-bit integer right between 0 and 31 bits, filling the high bits |
| with the low bits that were rotated. |
| |
| This function rotates the 32-bit value Operand to the right by Count bits. |
| The high Count bits are fill with the low Count bits of Operand. The rotated |
| value is returned. |
| |
| If Count is greater than 31, then ASSERT(). |
| |
| @param Operand The 32-bit operand to rotate right. |
| @param Count The number of bits to rotate right. |
| |
| @return Operand >> Count |
| |
| **/ |
| UINT32 |
| EFIAPI |
| RRotU32 ( |
| IN UINT32 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Rotates a 64-bit integer left between 0 and 63 bits, filling the low bits |
| with the high bits that were rotated. |
| |
| This function rotates the 64-bit value Operand to the left by Count bits. The |
| low Count bits are fill with the high Count bits of Operand. The rotated |
| value is returned. |
| |
| If Count is greater than 63, then ASSERT(). |
| |
| @param Operand The 64-bit operand to rotate left. |
| @param Count The number of bits to rotate left. |
| |
| @return Operand << Count |
| |
| **/ |
| UINT64 |
| EFIAPI |
| LRotU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Rotates a 64-bit integer right between 0 and 63 bits, filling the high bits |
| with the high low bits that were rotated. |
| |
| This function rotates the 64-bit value Operand to the right by Count bits. |
| The high Count bits are fill with the low Count bits of Operand. The rotated |
| value is returned. |
| |
| If Count is greater than 63, then ASSERT(). |
| |
| @param Operand The 64-bit operand to rotate right. |
| @param Count The number of bits to rotate right. |
| |
| @return Operand >> Count |
| |
| **/ |
| UINT64 |
| EFIAPI |
| RRotU64 ( |
| IN UINT64 Operand, |
| IN UINTN Count |
| ); |
| |
| |
| /** |
| Returns the bit position of the lowest bit set in a 32-bit value. |
| |
| This function computes the bit position of the lowest bit set in the 32-bit |
| value specified by Operand. If Operand is zero, then -1 is returned. |
| Otherwise, a value between 0 and 31 is returned. |
| |
| @param Operand The 32-bit operand to evaluate. |
| |
| @retval 0..31 The lowest bit set in Operand was found. |
| @retval -1 Operand is zero. |
| |
| **/ |
| INTN |
| EFIAPI |
| LowBitSet32 ( |
| IN UINT32 Operand |
| ); |
| |
| |
| /** |
| Returns the bit position of the lowest bit set in a 64-bit value. |
| |
| This function computes the bit position of the lowest bit set in the 64-bit |
| value specified by Operand. If Operand is zero, then -1 is returned. |
| Otherwise, a value between 0 and 63 is returned. |
| |
| @param Operand The 64-bit operand to evaluate. |
| |
| @retval 0..63 The lowest bit set in Operand was found. |
| @retval -1 Operand is zero. |
| |
| |
| **/ |
| INTN |
| EFIAPI |
| LowBitSet64 ( |
| IN UINT64 Operand |
| ); |
| |
| |
| /** |
| Returns the bit position of the highest bit set in a 32-bit value. Equivalent |
| to log2(x). |
| |
| This function computes the bit position of the highest bit set in the 32-bit |
| value specified by Operand. If Operand is zero, then -1 is returned. |
| Otherwise, a value between 0 and 31 is returned. |
| |
| @param Operand The 32-bit operand to evaluate. |
| |
| @retval 0..31 Position of the highest bit set in Operand if found. |
| @retval -1 Operand is zero. |
| |
| **/ |
| INTN |
| EFIAPI |
| HighBitSet32 ( |
| IN UINT32 Operand |
| ); |
| |
| |
| /** |
| Returns the bit position of the highest bit set in a 64-bit value. Equivalent |
| to log2(x). |
| |
| This function computes the bit position of the highest bit set in the 64-bit |
| value specified by Operand. If Operand is zero, then -1 is returned. |
| Otherwise, a value between 0 and 63 is returned. |
| |
| @param Operand The 64-bit operand to evaluate. |
| |
| @retval 0..63 Position of the highest bit set in Operand if found. |
| @retval -1 Operand is zero. |
| |
| **/ |
| INTN |
| EFIAPI |
| HighBitSet64 ( |
| IN UINT64 Operand |
| ); |
| |
| |
| /** |
| Returns the value of the highest bit set in a 32-bit value. Equivalent to |
| 1 << log2(x). |
| |
| This function computes the value of the highest bit set in the 32-bit value |
| specified by Operand. If Operand is zero, then zero is returned. |
| |
| @param Operand The 32-bit operand to evaluate. |
| |
| @return 1 << HighBitSet32(Operand) |
| @retval 0 Operand is zero. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| GetPowerOfTwo32 ( |
| IN UINT32 Operand |
| ); |
| |
| |
| /** |
| Returns the value of the highest bit set in a 64-bit value. Equivalent to |
| 1 << log2(x). |
| |
| This function computes the value of the highest bit set in the 64-bit value |
| specified by Operand. If Operand is zero, then zero is returned. |
| |
| @param Operand The 64-bit operand to evaluate. |
| |
| @return 1 << HighBitSet64(Operand) |
| @retval 0 Operand is zero. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| GetPowerOfTwo64 ( |
| IN UINT64 Operand |
| ); |
| |
| |
| /** |
| Switches the endianness of a 16-bit integer. |
| |
| This function swaps the bytes in a 16-bit unsigned value to switch the value |
| from little endian to big endian or vice versa. The byte swapped value is |
| returned. |
| |
| @param Value A 16-bit unsigned value. |
| |
| @return The byte swapped Value. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| SwapBytes16 ( |
| IN UINT16 Value |
| ); |
| |
| |
| /** |
| Switches the endianness of a 32-bit integer. |
| |
| This function swaps the bytes in a 32-bit unsigned value to switch the value |
| from little endian to big endian or vice versa. The byte swapped value is |
| returned. |
| |
| @param Value A 32-bit unsigned value. |
| |
| @return The byte swapped Value. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| SwapBytes32 ( |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Switches the endianness of a 64-bit integer. |
| |
| This function swaps the bytes in a 64-bit unsigned value to switch the value |
| from little endian to big endian or vice versa. The byte swapped value is |
| returned. |
| |
| @param Value A 64-bit unsigned value. |
| |
| @return The byte swapped Value. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| SwapBytes64 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Multiples a 64-bit unsigned integer by a 32-bit unsigned integer and |
| generates a 64-bit unsigned result. |
| |
| This function multiples the 64-bit unsigned value Multiplicand by the 32-bit |
| unsigned value Multiplier and generates a 64-bit unsigned result. This 64- |
| bit unsigned result is returned. |
| |
| @param Multiplicand A 64-bit unsigned value. |
| @param Multiplier A 32-bit unsigned value. |
| |
| @return Multiplicand * Multiplier |
| |
| **/ |
| UINT64 |
| EFIAPI |
| MultU64x32 ( |
| IN UINT64 Multiplicand, |
| IN UINT32 Multiplier |
| ); |
| |
| |
| /** |
| Multiples a 64-bit unsigned integer by a 64-bit unsigned integer and |
| generates a 64-bit unsigned result. |
| |
| This function multiples the 64-bit unsigned value Multiplicand by the 64-bit |
| unsigned value Multiplier and generates a 64-bit unsigned result. This 64- |
| bit unsigned result is returned. |
| |
| @param Multiplicand A 64-bit unsigned value. |
| @param Multiplier A 64-bit unsigned value. |
| |
| @return Multiplicand * Multiplier. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| MultU64x64 ( |
| IN UINT64 Multiplicand, |
| IN UINT64 Multiplier |
| ); |
| |
| |
| /** |
| Multiples a 64-bit signed integer by a 64-bit signed integer and generates a |
| 64-bit signed result. |
| |
| This function multiples the 64-bit signed value Multiplicand by the 64-bit |
| signed value Multiplier and generates a 64-bit signed result. This 64-bit |
| signed result is returned. |
| |
| @param Multiplicand A 64-bit signed value. |
| @param Multiplier A 64-bit signed value. |
| |
| @return Multiplicand * Multiplier |
| |
| **/ |
| INT64 |
| EFIAPI |
| MultS64x64 ( |
| IN INT64 Multiplicand, |
| IN INT64 Multiplier |
| ); |
| |
| |
| /** |
| Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates |
| a 64-bit unsigned result. |
| |
| This function divides the 64-bit unsigned value Dividend by the 32-bit |
| unsigned value Divisor and generates a 64-bit unsigned quotient. This |
| function returns the 64-bit unsigned quotient. |
| |
| If Divisor is 0, then ASSERT(). |
| |
| @param Dividend A 64-bit unsigned value. |
| @param Divisor A 32-bit unsigned value. |
| |
| @return Dividend / Divisor. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| DivU64x32 ( |
| IN UINT64 Dividend, |
| IN UINT32 Divisor |
| ); |
| |
| |
| /** |
| Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates |
| a 32-bit unsigned remainder. |
| |
| This function divides the 64-bit unsigned value Dividend by the 32-bit |
| unsigned value Divisor and generates a 32-bit remainder. This function |
| returns the 32-bit unsigned remainder. |
| |
| If Divisor is 0, then ASSERT(). |
| |
| @param Dividend A 64-bit unsigned value. |
| @param Divisor A 32-bit unsigned value. |
| |
| @return Dividend % Divisor. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| ModU64x32 ( |
| IN UINT64 Dividend, |
| IN UINT32 Divisor |
| ); |
| |
| |
| /** |
| Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates |
| a 64-bit unsigned result and an optional 32-bit unsigned remainder. |
| |
| This function divides the 64-bit unsigned value Dividend by the 32-bit |
| unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder |
| is not NULL, then the 32-bit unsigned remainder is returned in Remainder. |
| This function returns the 64-bit unsigned quotient. |
| |
| If Divisor is 0, then ASSERT(). |
| |
| @param Dividend A 64-bit unsigned value. |
| @param Divisor A 32-bit unsigned value. |
| @param Remainder A pointer to a 32-bit unsigned value. This parameter is |
| optional and may be NULL. |
| |
| @return Dividend / Divisor. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| DivU64x32Remainder ( |
| IN UINT64 Dividend, |
| IN UINT32 Divisor, |
| OUT UINT32 *Remainder OPTIONAL |
| ); |
| |
| |
| /** |
| Divides a 64-bit unsigned integer by a 64-bit unsigned integer and generates |
| a 64-bit unsigned result and an optional 64-bit unsigned remainder. |
| |
| This function divides the 64-bit unsigned value Dividend by the 64-bit |
| unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder |
| is not NULL, then the 64-bit unsigned remainder is returned in Remainder. |
| This function returns the 64-bit unsigned quotient. |
| |
| If Divisor is 0, then ASSERT(). |
| |
| @param Dividend A 64-bit unsigned value. |
| @param Divisor A 64-bit unsigned value. |
| @param Remainder A pointer to a 64-bit unsigned value. This parameter is |
| optional and may be NULL. |
| |
| @return Dividend / Divisor. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| DivU64x64Remainder ( |
| IN UINT64 Dividend, |
| IN UINT64 Divisor, |
| OUT UINT64 *Remainder OPTIONAL |
| ); |
| |
| |
| /** |
| Divides a 64-bit signed integer by a 64-bit signed integer and generates a |
| 64-bit signed result and a optional 64-bit signed remainder. |
| |
| This function divides the 64-bit signed value Dividend by the 64-bit signed |
| value Divisor and generates a 64-bit signed quotient. If Remainder is not |
| NULL, then the 64-bit signed remainder is returned in Remainder. This |
| function returns the 64-bit signed quotient. |
| |
| It is the caller's responsibility to not call this function with a Divisor of 0. |
| If Divisor is 0, then the quotient and remainder should be assumed to be |
| the largest negative integer. |
| |
| If Divisor is 0, then ASSERT(). |
| |
| @param Dividend A 64-bit signed value. |
| @param Divisor A 64-bit signed value. |
| @param Remainder A pointer to a 64-bit signed value. This parameter is |
| optional and may be NULL. |
| |
| @return Dividend / Divisor. |
| |
| **/ |
| INT64 |
| EFIAPI |
| DivS64x64Remainder ( |
| IN INT64 Dividend, |
| IN INT64 Divisor, |
| OUT INT64 *Remainder OPTIONAL |
| ); |
| |
| |
| /** |
| Reads a 16-bit value from memory that may be unaligned. |
| |
| This function returns the 16-bit value pointed to by Buffer. The function |
| guarantees that the read operation does not produce an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 16-bit value that may be unaligned. |
| |
| @return The 16-bit value read from Buffer. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| ReadUnaligned16 ( |
| IN CONST UINT16 *Buffer |
| ); |
| |
| |
| /** |
| Writes a 16-bit value to memory that may be unaligned. |
| |
| This function writes the 16-bit value specified by Value to Buffer. Value is |
| returned. The function guarantees that the write operation does not produce |
| an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 16-bit value that may be unaligned. |
| @param Value 16-bit value to write to Buffer. |
| |
| @return The 16-bit value to write to Buffer. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| WriteUnaligned16 ( |
| OUT UINT16 *Buffer, |
| IN UINT16 Value |
| ); |
| |
| |
| /** |
| Reads a 24-bit value from memory that may be unaligned. |
| |
| This function returns the 24-bit value pointed to by Buffer. The function |
| guarantees that the read operation does not produce an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 24-bit value that may be unaligned. |
| |
| @return The 24-bit value read from Buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| ReadUnaligned24 ( |
| IN CONST UINT32 *Buffer |
| ); |
| |
| |
| /** |
| Writes a 24-bit value to memory that may be unaligned. |
| |
| This function writes the 24-bit value specified by Value to Buffer. Value is |
| returned. The function guarantees that the write operation does not produce |
| an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 24-bit value that may be unaligned. |
| @param Value 24-bit value to write to Buffer. |
| |
| @return The 24-bit value to write to Buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| WriteUnaligned24 ( |
| OUT UINT32 *Buffer, |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Reads a 32-bit value from memory that may be unaligned. |
| |
| This function returns the 32-bit value pointed to by Buffer. The function |
| guarantees that the read operation does not produce an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 32-bit value that may be unaligned. |
| |
| @return The 32-bit value read from Buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| ReadUnaligned32 ( |
| IN CONST UINT32 *Buffer |
| ); |
| |
| |
| /** |
| Writes a 32-bit value to memory that may be unaligned. |
| |
| This function writes the 32-bit value specified by Value to Buffer. Value is |
| returned. The function guarantees that the write operation does not produce |
| an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 32-bit value that may be unaligned. |
| @param Value 32-bit value to write to Buffer. |
| |
| @return The 32-bit value to write to Buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| WriteUnaligned32 ( |
| OUT UINT32 *Buffer, |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Reads a 64-bit value from memory that may be unaligned. |
| |
| This function returns the 64-bit value pointed to by Buffer. The function |
| guarantees that the read operation does not produce an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 64-bit value that may be unaligned. |
| |
| @return The 64-bit value read from Buffer. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| ReadUnaligned64 ( |
| IN CONST UINT64 *Buffer |
| ); |
| |
| |
| /** |
| Writes a 64-bit value to memory that may be unaligned. |
| |
| This function writes the 64-bit value specified by Value to Buffer. Value is |
| returned. The function guarantees that the write operation does not produce |
| an alignment fault. |
| |
| If the Buffer is NULL, then ASSERT(). |
| |
| @param Buffer The pointer to a 64-bit value that may be unaligned. |
| @param Value 64-bit value to write to Buffer. |
| |
| @return The 64-bit value to write to Buffer. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| WriteUnaligned64 ( |
| OUT UINT64 *Buffer, |
| IN UINT64 Value |
| ); |
| |
| |
| // |
| // Bit Field Functions |
| // |
| |
| /** |
| Returns a bit field from an 8-bit value. |
| |
| Returns the bitfield specified by the StartBit and the EndBit from Operand. |
| |
| If 8-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 7, then ASSERT(). |
| If EndBit is greater than 7, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..7. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..7. |
| |
| @return The bit field read. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldRead8 ( |
| IN UINT8 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to an 8-bit value, and returns the result. |
| |
| Writes Value to the bit field specified by the StartBit and the EndBit in |
| Operand. All other bits in Operand are preserved. The new 8-bit value is |
| returned. |
| |
| If 8-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 7, then ASSERT(). |
| If EndBit is greater than 7, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..7. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..7. |
| @param Value New value of the bit field. |
| |
| @return The new 8-bit value. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldWrite8 ( |
| IN UINT8 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT8 Value |
| ); |
| |
| |
| /** |
| Reads a bit field from an 8-bit value, performs a bitwise OR, and returns the |
| result. |
| |
| Performs a bitwise OR between the bit field specified by StartBit |
| and EndBit in Operand and the value specified by OrData. All other bits in |
| Operand are preserved. The new 8-bit value is returned. |
| |
| If 8-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 7, then ASSERT(). |
| If EndBit is greater than 7, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..7. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..7. |
| @param OrData The value to OR with the read value from the value |
| |
| @return The new 8-bit value. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldOr8 ( |
| IN UINT8 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT8 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field from an 8-bit value, performs a bitwise AND, and returns |
| the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData. All other bits in Operand are |
| preserved. The new 8-bit value is returned. |
| |
| If 8-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 7, then ASSERT(). |
| If EndBit is greater than 7, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..7. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..7. |
| @param AndData The value to AND with the read value from the value. |
| |
| @return The new 8-bit value. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldAnd8 ( |
| IN UINT8 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT8 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field from an 8-bit value, performs a bitwise AND followed by a |
| bitwise OR, and returns the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData, followed by a bitwise |
| OR with value specified by OrData. All other bits in Operand are |
| preserved. The new 8-bit value is returned. |
| |
| If 8-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 7, then ASSERT(). |
| If EndBit is greater than 7, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..7. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..7. |
| @param AndData The value to AND with the read value from the value. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The new 8-bit value. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldAndThenOr8 ( |
| IN UINT8 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT8 AndData, |
| IN UINT8 OrData |
| ); |
| |
| |
| /** |
| Returns a bit field from a 16-bit value. |
| |
| Returns the bitfield specified by the StartBit and the EndBit from Operand. |
| |
| If 16-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 15, then ASSERT(). |
| If EndBit is greater than 15, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..15. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..15. |
| |
| @return The bit field read. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| BitFieldRead16 ( |
| IN UINT16 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to a 16-bit value, and returns the result. |
| |
| Writes Value to the bit field specified by the StartBit and the EndBit in |
| Operand. All other bits in Operand are preserved. The new 16-bit value is |
| returned. |
| |
| If 16-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 15, then ASSERT(). |
| If EndBit is greater than 15, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..15. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..15. |
| @param Value New value of the bit field. |
| |
| @return The new 16-bit value. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| BitFieldWrite16 ( |
| IN UINT16 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT16 Value |
| ); |
| |
| |
| /** |
| Reads a bit field from a 16-bit value, performs a bitwise OR, and returns the |
| result. |
| |
| Performs a bitwise OR between the bit field specified by StartBit |
| and EndBit in Operand and the value specified by OrData. All other bits in |
| Operand are preserved. The new 16-bit value is returned. |
| |
| If 16-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 15, then ASSERT(). |
| If EndBit is greater than 15, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..15. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..15. |
| @param OrData The value to OR with the read value from the value |
| |
| @return The new 16-bit value. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| BitFieldOr16 ( |
| IN UINT16 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT16 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 16-bit value, performs a bitwise AND, and returns |
| the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData. All other bits in Operand are |
| preserved. The new 16-bit value is returned. |
| |
| If 16-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 15, then ASSERT(). |
| If EndBit is greater than 15, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..15. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..15. |
| @param AndData The value to AND with the read value from the value |
| |
| @return The new 16-bit value. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| BitFieldAnd16 ( |
| IN UINT16 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT16 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 16-bit value, performs a bitwise AND followed by a |
| bitwise OR, and returns the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData, followed by a bitwise |
| OR with value specified by OrData. All other bits in Operand are |
| preserved. The new 16-bit value is returned. |
| |
| If 16-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 15, then ASSERT(). |
| If EndBit is greater than 15, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..15. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..15. |
| @param AndData The value to AND with the read value from the value. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The new 16-bit value. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| BitFieldAndThenOr16 ( |
| IN UINT16 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT16 AndData, |
| IN UINT16 OrData |
| ); |
| |
| |
| /** |
| Returns a bit field from a 32-bit value. |
| |
| Returns the bitfield specified by the StartBit and the EndBit from Operand. |
| |
| If 32-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| |
| @return The bit field read. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| BitFieldRead32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to a 32-bit value, and returns the result. |
| |
| Writes Value to the bit field specified by the StartBit and the EndBit in |
| Operand. All other bits in Operand are preserved. The new 32-bit value is |
| returned. |
| |
| If 32-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param Value New value of the bit field. |
| |
| @return The new 32-bit value. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| BitFieldWrite32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Reads a bit field from a 32-bit value, performs a bitwise OR, and returns the |
| result. |
| |
| Performs a bitwise OR between the bit field specified by StartBit |
| and EndBit in Operand and the value specified by OrData. All other bits in |
| Operand are preserved. The new 32-bit value is returned. |
| |
| If 32-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param OrData The value to OR with the read value from the value. |
| |
| @return The new 32-bit value. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| BitFieldOr32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 32-bit value, performs a bitwise AND, and returns |
| the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData. All other bits in Operand are |
| preserved. The new 32-bit value is returned. |
| |
| If 32-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param AndData The value to AND with the read value from the value |
| |
| @return The new 32-bit value. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| BitFieldAnd32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 32-bit value, performs a bitwise AND followed by a |
| bitwise OR, and returns the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData, followed by a bitwise |
| OR with value specified by OrData. All other bits in Operand are |
| preserved. The new 32-bit value is returned. |
| |
| If 32-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param AndData The value to AND with the read value from the value. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The new 32-bit value. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| BitFieldAndThenOr32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 AndData, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Returns a bit field from a 64-bit value. |
| |
| Returns the bitfield specified by the StartBit and the EndBit from Operand. |
| |
| If 64-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| |
| @return The bit field read. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| BitFieldRead64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to a 64-bit value, and returns the result. |
| |
| Writes Value to the bit field specified by the StartBit and the EndBit in |
| Operand. All other bits in Operand are preserved. The new 64-bit value is |
| returned. |
| |
| If 64-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param Value New value of the bit field. |
| |
| @return The new 64-bit value. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| BitFieldWrite64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Reads a bit field from a 64-bit value, performs a bitwise OR, and returns the |
| result. |
| |
| Performs a bitwise OR between the bit field specified by StartBit |
| and EndBit in Operand and the value specified by OrData. All other bits in |
| Operand are preserved. The new 64-bit value is returned. |
| |
| If 64-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param OrData The value to OR with the read value from the value |
| |
| @return The new 64-bit value. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| BitFieldOr64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 64-bit value, performs a bitwise AND, and returns |
| the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData. All other bits in Operand are |
| preserved. The new 64-bit value is returned. |
| |
| If 64-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param AndData The value to AND with the read value from the value |
| |
| @return The new 64-bit value. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| BitFieldAnd64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field from a 64-bit value, performs a bitwise AND followed by a |
| bitwise OR, and returns the result. |
| |
| Performs a bitwise AND between the bit field specified by StartBit and EndBit |
| in Operand and the value specified by AndData, followed by a bitwise |
| OR with value specified by OrData. All other bits in Operand are |
| preserved. The new 64-bit value is returned. |
| |
| If 64-bit operations are not supported, then ASSERT(). |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param AndData The value to AND with the read value from the value. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The new 64-bit value. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| BitFieldAndThenOr64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 AndData, |
| IN UINT64 OrData |
| ); |
| |
| /** |
| Reads a bit field from a 32-bit value, counts and returns |
| the number of set bits. |
| |
| Counts the number of set bits in the bit field specified by |
| StartBit and EndBit in Operand. The count is returned. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| |
| @return The number of bits set between StartBit and EndBit. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldCountOnes32 ( |
| IN UINT32 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| /** |
| Reads a bit field from a 64-bit value, counts and returns |
| the number of set bits. |
| |
| Counts the number of set bits in the bit field specified by |
| StartBit and EndBit in Operand. The count is returned. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Operand Operand on which to perform the bitfield operation. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| |
| @return The number of bits set between StartBit and EndBit. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| BitFieldCountOnes64 ( |
| IN UINT64 Operand, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| // |
| // Base Library Checksum Functions |
| // |
| |
| /** |
| Returns the sum of all elements in a buffer in unit of UINT8. |
| During calculation, the carry bits are dropped. |
| |
| This function calculates the sum of all elements in a buffer |
| in unit of UINT8. The carry bits in result of addition are dropped. |
| The result is returned as UINT8. If Length is Zero, then Zero is |
| returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the sum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Sum The sum of Buffer with carry bits dropped during additions. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| CalculateSum8 ( |
| IN CONST UINT8 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the two's complement checksum of all elements in a buffer |
| of 8-bit values. |
| |
| This function first calculates the sum of the 8-bit values in the |
| buffer specified by Buffer and Length. The carry bits in the result |
| of addition are dropped. Then, the two's complement of the sum is |
| returned. If Length is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the checksum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Checksum The two's complement checksum of Buffer. |
| |
| **/ |
| UINT8 |
| EFIAPI |
| CalculateCheckSum8 ( |
| IN CONST UINT8 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the sum of all elements in a buffer of 16-bit values. During |
| calculation, the carry bits are dropped. |
| |
| This function calculates the sum of the 16-bit values in the buffer |
| specified by Buffer and Length. The carry bits in result of addition are dropped. |
| The 16-bit result is returned. If Length is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the sum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Sum The sum of Buffer with carry bits dropped during additions. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| CalculateSum16 ( |
| IN CONST UINT16 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the two's complement checksum of all elements in a buffer of |
| 16-bit values. |
| |
| This function first calculates the sum of the 16-bit values in the buffer |
| specified by Buffer and Length. The carry bits in the result of addition |
| are dropped. Then, the two's complement of the sum is returned. If Length |
| is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length is not aligned on a 16-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the checksum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Checksum The two's complement checksum of Buffer. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| CalculateCheckSum16 ( |
| IN CONST UINT16 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the sum of all elements in a buffer of 32-bit values. During |
| calculation, the carry bits are dropped. |
| |
| This function calculates the sum of the 32-bit values in the buffer |
| specified by Buffer and Length. The carry bits in result of addition are dropped. |
| The 32-bit result is returned. If Length is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 32-bit boundary, then ASSERT(). |
| If Length is not aligned on a 32-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the sum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Sum The sum of Buffer with carry bits dropped during additions. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| CalculateSum32 ( |
| IN CONST UINT32 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the two's complement checksum of all elements in a buffer of |
| 32-bit values. |
| |
| This function first calculates the sum of the 32-bit values in the buffer |
| specified by Buffer and Length. The carry bits in the result of addition |
| are dropped. Then, the two's complement of the sum is returned. If Length |
| is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 32-bit boundary, then ASSERT(). |
| If Length is not aligned on a 32-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the checksum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Checksum The two's complement checksum of Buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| CalculateCheckSum32 ( |
| IN CONST UINT32 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the sum of all elements in a buffer of 64-bit values. During |
| calculation, the carry bits are dropped. |
| |
| This function calculates the sum of the 64-bit values in the buffer |
| specified by Buffer and Length. The carry bits in result of addition are dropped. |
| The 64-bit result is returned. If Length is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 64-bit boundary, then ASSERT(). |
| If Length is not aligned on a 64-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the sum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Sum The sum of Buffer with carry bits dropped during additions. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| CalculateSum64 ( |
| IN CONST UINT64 *Buffer, |
| IN UINTN Length |
| ); |
| |
| |
| /** |
| Returns the two's complement checksum of all elements in a buffer of |
| 64-bit values. |
| |
| This function first calculates the sum of the 64-bit values in the buffer |
| specified by Buffer and Length. The carry bits in the result of addition |
| are dropped. Then, the two's complement of the sum is returned. If Length |
| is 0, then 0 is returned. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 64-bit boundary, then ASSERT(). |
| If Length is not aligned on a 64-bit boundary, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param Buffer The pointer to the buffer to carry out the checksum operation. |
| @param Length The size, in bytes, of Buffer. |
| |
| @return Checksum The two's complement checksum of Buffer. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| CalculateCheckSum64 ( |
| IN CONST UINT64 *Buffer, |
| IN UINTN Length |
| ); |
| |
| /** |
| Computes and returns a 32-bit CRC for a data buffer. |
| CRC32 value bases on ITU-T V.42. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). |
| |
| @param[in] Buffer A pointer to the buffer on which the 32-bit CRC is to be computed. |
| @param[in] Length The number of bytes in the buffer Data. |
| |
| @retval Crc32 The 32-bit CRC was computed for the data buffer. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| CalculateCrc32( |
| IN VOID *Buffer, |
| IN UINTN Length |
| ); |
| |
| // |
| // Base Library CPU Functions |
| // |
| |
| /** |
| Function entry point used when a stack switch is requested with SwitchStack() |
| |
| @param Context1 Context1 parameter passed into SwitchStack(). |
| @param Context2 Context2 parameter passed into SwitchStack(). |
| |
| **/ |
| typedef |
| VOID |
| (EFIAPI *SWITCH_STACK_ENTRY_POINT)( |
| IN VOID *Context1, OPTIONAL |
| IN VOID *Context2 OPTIONAL |
| ); |
| |
| |
| /** |
| Used to serialize load and store operations. |
| |
| All loads and stores that proceed calls to this function are guaranteed to be |
| globally visible when this function returns. |
| |
| **/ |
| VOID |
| EFIAPI |
| MemoryFence ( |
| VOID |
| ); |
| |
| |
| /** |
| Saves the current CPU context that can be restored with a call to LongJump() |
| and returns 0. |
| |
| Saves the current CPU context in the buffer specified by JumpBuffer and |
| returns 0. The initial call to SetJump() must always return 0. Subsequent |
| calls to LongJump() cause a non-zero value to be returned by SetJump(). |
| |
| If JumpBuffer is NULL, then ASSERT(). |
| For Itanium processors, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT(). |
| |
| NOTE: The structure BASE_LIBRARY_JUMP_BUFFER is CPU architecture specific. |
| The same structure must never be used for more than one CPU architecture context. |
| For example, a BASE_LIBRARY_JUMP_BUFFER allocated by an IA-32 module must never be used from an x64 module. |
| SetJump()/LongJump() is not currently supported for the EBC processor type. |
| |
| @param JumpBuffer A pointer to CPU context buffer. |
| |
| @retval 0 Indicates a return from SetJump(). |
| |
| **/ |
| RETURNS_TWICE |
| UINTN |
| EFIAPI |
| SetJump ( |
| OUT BASE_LIBRARY_JUMP_BUFFER *JumpBuffer |
| ); |
| |
| |
| /** |
| Restores the CPU context that was saved with SetJump(). |
| |
| Restores the CPU context from the buffer specified by JumpBuffer. This |
| function never returns to the caller. Instead is resumes execution based on |
| the state of JumpBuffer. |
| |
| If JumpBuffer is NULL, then ASSERT(). |
| For Itanium processors, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT(). |
| If Value is 0, then ASSERT(). |
| |
| @param JumpBuffer A pointer to CPU context buffer. |
| @param Value The value to return when the SetJump() context is |
| restored and must be non-zero. |
| |
| **/ |
| VOID |
| EFIAPI |
| LongJump ( |
| IN BASE_LIBRARY_JUMP_BUFFER *JumpBuffer, |
| IN UINTN Value |
| ); |
| |
| |
| /** |
| Enables CPU interrupts. |
| |
| **/ |
| VOID |
| EFIAPI |
| EnableInterrupts ( |
| VOID |
| ); |
| |
| |
| /** |
| Disables CPU interrupts. |
| |
| **/ |
| VOID |
| EFIAPI |
| DisableInterrupts ( |
| VOID |
| ); |
| |
| |
| /** |
| Disables CPU interrupts and returns the interrupt state prior to the disable |
| operation. |
| |
| @retval TRUE CPU interrupts were enabled on entry to this call. |
| @retval FALSE CPU interrupts were disabled on entry to this call. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| SaveAndDisableInterrupts ( |
| VOID |
| ); |
| |
| |
| /** |
| Enables CPU interrupts for the smallest window required to capture any |
| pending interrupts. |
| |
| **/ |
| VOID |
| EFIAPI |
| EnableDisableInterrupts ( |
| VOID |
| ); |
| |
| |
| /** |
| Retrieves the current CPU interrupt state. |
| |
| Returns TRUE if interrupts are currently enabled. Otherwise |
| returns FALSE. |
| |
| @retval TRUE CPU interrupts are enabled. |
| @retval FALSE CPU interrupts are disabled. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| GetInterruptState ( |
| VOID |
| ); |
| |
| |
| /** |
| Set the current CPU interrupt state. |
| |
| Sets the current CPU interrupt state to the state specified by |
| InterruptState. If InterruptState is TRUE, then interrupts are enabled. If |
| InterruptState is FALSE, then interrupts are disabled. InterruptState is |
| returned. |
| |
| @param InterruptState TRUE if interrupts should enabled. FALSE if |
| interrupts should be disabled. |
| |
| @return InterruptState |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| SetInterruptState ( |
| IN BOOLEAN InterruptState |
| ); |
| |
| |
| /** |
| Requests CPU to pause for a short period of time. |
| |
| Requests CPU to pause for a short period of time. Typically used in MP |
| systems to prevent memory starvation while waiting for a spin lock. |
| |
| **/ |
| VOID |
| EFIAPI |
| CpuPause ( |
| VOID |
| ); |
| |
| |
| /** |
| Transfers control to a function starting with a new stack. |
| |
| Transfers control to the function specified by EntryPoint using the |
| new stack specified by NewStack and passing in the parameters specified |
| by Context1 and Context2. Context1 and Context2 are optional and may |
| be NULL. The function EntryPoint must never return. This function |
| supports a variable number of arguments following the NewStack parameter. |
| These additional arguments are ignored on IA-32, x64, and EBC architectures. |
| Itanium processors expect one additional parameter of type VOID * that specifies |
| the new backing store pointer. |
| |
| If EntryPoint is NULL, then ASSERT(). |
| If NewStack is NULL, then ASSERT(). |
| |
| @param EntryPoint A pointer to function to call with the new stack. |
| @param Context1 A pointer to the context to pass into the EntryPoint |
| function. |
| @param Context2 A pointer to the context to pass into the EntryPoint |
| function. |
| @param NewStack A pointer to the new stack to use for the EntryPoint |
| function. |
| @param ... This variable argument list is ignored for IA-32, x64, and |
| EBC architectures. For Itanium processors, this variable |
| argument list is expected to contain a single parameter of |
| type VOID * that specifies the new backing store pointer. |
| |
| |
| **/ |
| VOID |
| EFIAPI |
| SwitchStack ( |
| IN SWITCH_STACK_ENTRY_POINT EntryPoint, |
| IN VOID *Context1, OPTIONAL |
| IN VOID *Context2, OPTIONAL |
| IN VOID *NewStack, |
| ... |
| ); |
| |
| |
| /** |
| Generates a breakpoint on the CPU. |
| |
| Generates a breakpoint on the CPU. The breakpoint must be implemented such |
| that code can resume normal execution after the breakpoint. |
| |
| **/ |
| VOID |
| EFIAPI |
| CpuBreakpoint ( |
| VOID |
| ); |
| |
| |
| /** |
| Executes an infinite loop. |
| |
| Forces the CPU to execute an infinite loop. A debugger may be used to skip |
| past the loop and the code that follows the loop must execute properly. This |
| implies that the infinite loop must not cause the code that follow it to be |
| optimized away. |
| |
| **/ |
| VOID |
| EFIAPI |
| CpuDeadLoop ( |
| VOID |
| ); |
| |
| |
| /** |
| Uses as a barrier to stop speculative execution. |
| |
| Ensures that no later instruction will execute speculatively, until all prior |
| instructions have completed. |
| |
| **/ |
| VOID |
| EFIAPI |
| SpeculationBarrier ( |
| VOID |
| ); |
| |
| #if defined (MDE_CPU_X64) |
| // |
| // The page size for the PVALIDATE instruction |
| // |
| typedef enum { |
| PvalidatePageSize4K = 0, |
| PvalidatePageSize2MB, |
| } PVALIDATE_PAGE_SIZE; |
| |
| // |
| // PVALIDATE Return Code. |
| // |
| #define PVALIDATE_RET_SUCCESS 0 |
| #define PVALIDATE_RET_FAIL_INPUT 1 |
| #define PVALIDATE_RET_SIZE_MISMATCH 6 |
| |
| // |
| // The PVALIDATE instruction did not make any changes to the RMP entry. |
| // |
| #define PVALIDATE_RET_NO_RMPUPDATE 255 |
| |
| /** |
| Execute a PVALIDATE instruction to validate or to rescinds validation of a guest |
| page's RMP entry. |
| |
| The instruction is available only when CPUID Fn8000_001F_EAX[SNP]=1. |
| |
| The function is available on X64. |
| |
| @param[in] PageSize The page size to use. |
| @param[in] Validate If TRUE, validate the guest virtual address |
| otherwise invalidate the guest virtual address. |
| @param[in] Address The guest virtual address. |
| |
| @retval PVALIDATE_RET_SUCCESS The PVALIDATE instruction succeeded, and |
| updated the RMP entry. |
| @retval PVALIDATE_RET_NO_RMPUPDATE The PVALIDATE instruction succeeded, but |
| did not update the RMP entry. |
| @return Failure code from the PVALIDATE |
| instruction. |
| **/ |
| UINT32 |
| EFIAPI |
| AsmPvalidate ( |
| IN PVALIDATE_PAGE_SIZE PageSize, |
| IN BOOLEAN Validate, |
| IN PHYSICAL_ADDRESS Address |
| ); |
| |
| // |
| // RDX settings for RMPADJUST |
| // |
| #define RMPADJUST_VMPL_MAX 3 |
| #define RMPADJUST_VMPL_MASK 0xFF |
| #define RMPADJUST_VMPL_SHIFT 0 |
| #define RMPADJUST_PERMISSION_MASK_MASK 0xFF |
| #define RMPADJUST_PERMISSION_MASK_SHIFT 8 |
| #define RMPADJUST_VMSA_PAGE_BIT BIT16 |
| |
| /** |
| Adjusts the permissions of an SEV-SNP guest page. |
| |
| Executes a RMPADJUST instruction with the register state specified by Rax, |
| Rcx, and Rdx. Returns Eax. This function is only available on X64. |
| |
| The instruction is available only when CPUID Fn8000_001F_EAX[SNP]=1. |
| |
| @param[in] Rax The value to load into RAX before executing the RMPADJUST |
| instruction. |
| @param[in] Rcx The value to load into RCX before executing the RMPADJUST |
| instruction. |
| @param[in] Rdx The value to load into RDX before executing the RMPADJUST |
| instruction. |
| |
| @return Eax |
| **/ |
| UINT32 |
| EFIAPI |
| AsmRmpAdjust ( |
| IN UINT64 Rax, |
| IN UINT64 Rcx, |
| IN UINT64 Rdx |
| ); |
| #endif |
| |
| |
| #if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) |
| /// |
| /// IA32 and x64 Specific Functions. |
| /// Byte packed structure for 16-bit Real Mode EFLAGS. |
| /// |
| typedef union { |
| struct { |
| UINT32 CF:1; ///< Carry Flag. |
| UINT32 Reserved_0:1; ///< Reserved. |
| UINT32 PF:1; ///< Parity Flag. |
| UINT32 Reserved_1:1; ///< Reserved. |
| UINT32 AF:1; ///< Auxiliary Carry Flag. |
| UINT32 Reserved_2:1; ///< Reserved. |
| UINT32 ZF:1; ///< Zero Flag. |
| UINT32 SF:1; ///< Sign Flag. |
| UINT32 TF:1; ///< Trap Flag. |
| UINT32 IF:1; ///< Interrupt Enable Flag. |
| UINT32 DF:1; ///< Direction Flag. |
| UINT32 OF:1; ///< Overflow Flag. |
| UINT32 IOPL:2; ///< I/O Privilege Level. |
| UINT32 NT:1; ///< Nested Task. |
| UINT32 Reserved_3:1; ///< Reserved. |
| } Bits; |
| UINT16 Uint16; |
| } IA32_FLAGS16; |
| |
| /// |
| /// Byte packed structure for EFLAGS/RFLAGS. |
| /// 32-bits on IA-32. |
| /// 64-bits on x64. The upper 32-bits on x64 are reserved. |
| /// |
| typedef union { |
| struct { |
| UINT32 CF:1; ///< Carry Flag. |
| UINT32 Reserved_0:1; ///< Reserved. |
| UINT32 PF:1; ///< Parity Flag. |
| UINT32 Reserved_1:1; ///< Reserved. |
| UINT32 AF:1; ///< Auxiliary Carry Flag. |
| UINT32 Reserved_2:1; ///< Reserved. |
| UINT32 ZF:1; ///< Zero Flag. |
| UINT32 SF:1; ///< Sign Flag. |
| UINT32 TF:1; ///< Trap Flag. |
| UINT32 IF:1; ///< Interrupt Enable Flag. |
| UINT32 DF:1; ///< Direction Flag. |
| UINT32 OF:1; ///< Overflow Flag. |
| UINT32 IOPL:2; ///< I/O Privilege Level. |
| UINT32 NT:1; ///< Nested Task. |
| UINT32 Reserved_3:1; ///< Reserved. |
| UINT32 RF:1; ///< Resume Flag. |
| UINT32 VM:1; ///< Virtual 8086 Mode. |
| UINT32 AC:1; ///< Alignment Check. |
| UINT32 VIF:1; ///< Virtual Interrupt Flag. |
| UINT32 VIP:1; ///< Virtual Interrupt Pending. |
| UINT32 ID:1; ///< ID Flag. |
| UINT32 Reserved_4:10; ///< Reserved. |
| } Bits; |
| UINTN UintN; |
| } IA32_EFLAGS32; |
| |
| /// |
| /// Byte packed structure for Control Register 0 (CR0). |
| /// 32-bits on IA-32. |
| /// 64-bits on x64. The upper 32-bits on x64 are reserved. |
| /// |
| typedef union { |
| struct { |
| UINT32 PE:1; ///< Protection Enable. |
| UINT32 MP:1; ///< Monitor Coprocessor. |
| UINT32 EM:1; ///< Emulation. |
| UINT32 TS:1; ///< Task Switched. |
| UINT32 ET:1; ///< Extension Type. |
| UINT32 NE:1; ///< Numeric Error. |
| UINT32 Reserved_0:10; ///< Reserved. |
| UINT32 WP:1; ///< Write Protect. |
| UINT32 Reserved_1:1; ///< Reserved. |
| UINT32 AM:1; ///< Alignment Mask. |
| UINT32 Reserved_2:10; ///< Reserved. |
| UINT32 NW:1; ///< Mot Write-through. |
| UINT32 CD:1; ///< Cache Disable. |
| UINT32 PG:1; ///< Paging. |
| } Bits; |
| UINTN UintN; |
| } IA32_CR0; |
| |
| /// |
| /// Byte packed structure for Control Register 4 (CR4). |
| /// 32-bits on IA-32. |
| /// 64-bits on x64. The upper 32-bits on x64 are reserved. |
| /// |
| typedef union { |
| struct { |
| UINT32 VME:1; ///< Virtual-8086 Mode Extensions. |
| UINT32 PVI:1; ///< Protected-Mode Virtual Interrupts. |
| UINT32 TSD:1; ///< Time Stamp Disable. |
| UINT32 DE:1; ///< Debugging Extensions. |
| UINT32 PSE:1; ///< Page Size Extensions. |
| UINT32 PAE:1; ///< Physical Address Extension. |
| UINT32 MCE:1; ///< Machine Check Enable. |
| UINT32 PGE:1; ///< Page Global Enable. |
| UINT32 PCE:1; ///< Performance Monitoring Counter |
| ///< Enable. |
| UINT32 OSFXSR:1; ///< Operating System Support for |
| ///< FXSAVE and FXRSTOR instructions |
| UINT32 OSXMMEXCPT:1; ///< Operating System Support for |
| ///< Unmasked SIMD Floating Point |
| ///< Exceptions. |
| UINT32 UMIP:1; ///< User-Mode Instruction Prevention. |
| UINT32 LA57:1; ///< Linear Address 57bit. |
| UINT32 VMXE:1; ///< VMX Enable. |
| UINT32 SMXE:1; ///< SMX Enable. |
| UINT32 Reserved_3:1; ///< Reserved. |
| UINT32 FSGSBASE:1; ///< FSGSBASE Enable. |
| UINT32 PCIDE:1; ///< PCID Enable. |
| UINT32 OSXSAVE:1; ///< XSAVE and Processor Extended States Enable. |
| UINT32 Reserved_4:1; ///< Reserved. |
| UINT32 SMEP:1; ///< SMEP Enable. |
| UINT32 SMAP:1; ///< SMAP Enable. |
| UINT32 PKE:1; ///< Protection-Key Enable. |
| UINT32 Reserved_5:9; ///< Reserved. |
| } Bits; |
| UINTN UintN; |
| } IA32_CR4; |
| |
| /// |
| /// Byte packed structure for a segment descriptor in a GDT/LDT. |
| /// |
| typedef union { |
| struct { |
| UINT32 LimitLow:16; |
| UINT32 BaseLow:16; |
| UINT32 BaseMid:8; |
| UINT32 Type:4; |
| UINT32 S:1; |
| UINT32 DPL:2; |
| UINT32 P:1; |
| UINT32 LimitHigh:4; |
| UINT32 AVL:1; |
| UINT32 L:1; |
| UINT32 DB:1; |
| UINT32 G:1; |
| UINT32 BaseHigh:8; |
| } Bits; |
| UINT64 Uint64; |
| } IA32_SEGMENT_DESCRIPTOR; |
| |
| /// |
| /// Byte packed structure for an IDTR, GDTR, LDTR descriptor. |
| /// |
| #pragma pack (1) |
| typedef struct { |
| UINT16 Limit; |
| UINTN Base; |
| } IA32_DESCRIPTOR; |
| #pragma pack () |
| |
| #define IA32_IDT_GATE_TYPE_TASK 0x85 |
| #define IA32_IDT_GATE_TYPE_INTERRUPT_16 0x86 |
| #define IA32_IDT_GATE_TYPE_TRAP_16 0x87 |
| #define IA32_IDT_GATE_TYPE_INTERRUPT_32 0x8E |
| #define IA32_IDT_GATE_TYPE_TRAP_32 0x8F |
| |
| #define IA32_GDT_TYPE_TSS 0x9 |
| #define IA32_GDT_ALIGNMENT 8 |
| |
| #if defined (MDE_CPU_IA32) |
| /// |
| /// Byte packed structure for an IA-32 Interrupt Gate Descriptor. |
| /// |
| typedef union { |
| struct { |
| UINT32 OffsetLow:16; ///< Offset bits 15..0. |
| UINT32 Selector:16; ///< Selector. |
| UINT32 Reserved_0:8; ///< Reserved. |
| UINT32 GateType:8; ///< Gate Type. See #defines above. |
| UINT32 OffsetHigh:16; ///< Offset bits 31..16. |
| } Bits; |
| UINT64 Uint64; |
| } IA32_IDT_GATE_DESCRIPTOR; |
| |
| #pragma pack (1) |
| // |
| // IA32 Task-State Segment Definition |
| // |
| typedef struct { |
| UINT16 PreviousTaskLink; |
| UINT16 Reserved_2; |
| UINT32 ESP0; |
| UINT16 SS0; |
| UINT16 Reserved_10; |
| UINT32 ESP1; |
| UINT16 SS1; |
| UINT16 Reserved_18; |
| UINT32 ESP2; |
| UINT16 SS2; |
| UINT16 Reserved_26; |
| UINT32 CR3; |
| UINT32 EIP; |
| UINT32 EFLAGS; |
| UINT32 EAX; |
| UINT32 ECX; |
| UINT32 EDX; |
| UINT32 EBX; |
| UINT32 ESP; |
| UINT32 EBP; |
| UINT32 ESI; |
| UINT32 EDI; |
| UINT16 ES; |
| UINT16 Reserved_74; |
| UINT16 CS; |
| UINT16 Reserved_78; |
| UINT16 SS; |
| UINT16 Reserved_82; |
| UINT16 DS; |
| UINT16 Reserved_86; |
| UINT16 FS; |
| UINT16 Reserved_90; |
| UINT16 GS; |
| UINT16 Reserved_94; |
| UINT16 LDTSegmentSelector; |
| UINT16 Reserved_98; |
| UINT16 T; |
| UINT16 IOMapBaseAddress; |
| } IA32_TASK_STATE_SEGMENT; |
| |
| typedef union { |
| struct { |
| UINT32 LimitLow:16; ///< Segment Limit 15..00 |
| UINT32 BaseLow:16; ///< Base Address 15..00 |
| UINT32 BaseMid:8; ///< Base Address 23..16 |
| UINT32 Type:4; ///< Type (1 0 B 1) |
| UINT32 Reserved_43:1; ///< 0 |
| UINT32 DPL:2; ///< Descriptor Privilege Level |
| UINT32 P:1; ///< Segment Present |
| UINT32 LimitHigh:4; ///< Segment Limit 19..16 |
| UINT32 AVL:1; ///< Available for use by system software |
| UINT32 Reserved_52:2; ///< 0 0 |
| UINT32 G:1; ///< Granularity |
| UINT32 BaseHigh:8; ///< Base Address 31..24 |
| } Bits; |
| UINT64 Uint64; |
| } IA32_TSS_DESCRIPTOR; |
| #pragma pack () |
| |
| #endif // defined (MDE_CPU_IA32) |
| |
| #if defined (MDE_CPU_X64) |
| /// |
| /// Byte packed structure for an x64 Interrupt Gate Descriptor. |
| /// |
| typedef union { |
| struct { |
| UINT32 OffsetLow:16; ///< Offset bits 15..0. |
| UINT32 Selector:16; ///< Selector. |
| UINT32 Reserved_0:8; ///< Reserved. |
| UINT32 GateType:8; ///< Gate Type. See #defines above. |
| UINT32 OffsetHigh:16; ///< Offset bits 31..16. |
| UINT32 OffsetUpper:32; ///< Offset bits 63..32. |
| UINT32 Reserved_1:32; ///< Reserved. |
| } Bits; |
| struct { |
| UINT64 Uint64; |
| UINT64 Uint64_1; |
| } Uint128; |
| } IA32_IDT_GATE_DESCRIPTOR; |
| |
| #pragma pack (1) |
| // |
| // IA32 Task-State Segment Definition |
| // |
| typedef struct { |
| UINT32 Reserved_0; |
| UINT64 RSP0; |
| UINT64 RSP1; |
| UINT64 RSP2; |
| UINT64 Reserved_28; |
| UINT64 IST[7]; |
| UINT64 Reserved_92; |
| UINT16 Reserved_100; |
| UINT16 IOMapBaseAddress; |
| } IA32_TASK_STATE_SEGMENT; |
| |
| typedef union { |
| struct { |
| UINT32 LimitLow:16; ///< Segment Limit 15..00 |
| UINT32 BaseLow:16; ///< Base Address 15..00 |
| UINT32 BaseMidl:8; ///< Base Address 23..16 |
| UINT32 Type:4; ///< Type (1 0 B 1) |
| UINT32 Reserved_43:1; ///< 0 |
| UINT32 DPL:2; ///< Descriptor Privilege Level |
| UINT32 P:1; ///< Segment Present |
| UINT32 LimitHigh:4; ///< Segment Limit 19..16 |
| UINT32 AVL:1; ///< Available for use by system software |
| UINT32 Reserved_52:2; ///< 0 0 |
| UINT32 G:1; ///< Granularity |
| UINT32 BaseMidh:8; ///< Base Address 31..24 |
| UINT32 BaseHigh:32; ///< Base Address 63..32 |
| UINT32 Reserved_96:32; ///< Reserved |
| } Bits; |
| struct { |
| UINT64 Uint64; |
| UINT64 Uint64_1; |
| } Uint128; |
| } IA32_TSS_DESCRIPTOR; |
| #pragma pack () |
| |
| #endif // defined (MDE_CPU_X64) |
| |
| /// |
| /// Byte packed structure for an FP/SSE/SSE2 context. |
| /// |
| typedef struct { |
| UINT8 Buffer[512]; |
| } IA32_FX_BUFFER; |
| |
| /// |
| /// Structures for the 16-bit real mode thunks. |
| /// |
| typedef struct { |
| UINT32 Reserved1; |
| UINT32 Reserved2; |
| UINT32 Reserved3; |
| UINT32 Reserved4; |
| UINT8 BL; |
| UINT8 BH; |
| UINT16 Reserved5; |
| UINT8 DL; |
| UINT8 DH; |
| UINT16 Reserved6; |
| UINT8 CL; |
| UINT8 CH; |
| UINT16 Reserved7; |
| UINT8 AL; |
| UINT8 AH; |
| UINT16 Reserved8; |
| } IA32_BYTE_REGS; |
| |
| typedef struct { |
| UINT16 DI; |
| UINT16 Reserved1; |
| UINT16 SI; |
| UINT16 Reserved2; |
| UINT16 BP; |
| UINT16 Reserved3; |
| UINT16 SP; |
| UINT16 Reserved4; |
| UINT16 BX; |
| UINT16 Reserved5; |
| UINT16 DX; |
| UINT16 Reserved6; |
| UINT16 CX; |
| UINT16 Reserved7; |
| UINT16 AX; |
| UINT16 Reserved8; |
| } IA32_WORD_REGS; |
| |
| typedef struct { |
| UINT32 EDI; |
| UINT32 ESI; |
| UINT32 EBP; |
| UINT32 ESP; |
| UINT32 EBX; |
| UINT32 EDX; |
| UINT32 ECX; |
| UINT32 EAX; |
| UINT16 DS; |
| UINT16 ES; |
| UINT16 FS; |
| UINT16 GS; |
| IA32_EFLAGS32 EFLAGS; |
| UINT32 Eip; |
| UINT16 CS; |
| UINT16 SS; |
| } IA32_DWORD_REGS; |
| |
| typedef union { |
| IA32_DWORD_REGS E; |
| IA32_WORD_REGS X; |
| IA32_BYTE_REGS H; |
| } IA32_REGISTER_SET; |
| |
| /// |
| /// Byte packed structure for an 16-bit real mode thunks. |
| /// |
| typedef struct { |
| IA32_REGISTER_SET *RealModeState; |
| VOID *RealModeBuffer; |
| UINT32 RealModeBufferSize; |
| UINT32 ThunkAttributes; |
| } THUNK_CONTEXT; |
| |
| #define THUNK_ATTRIBUTE_BIG_REAL_MODE 0x00000001 |
| #define THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 0x00000002 |
| #define THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL 0x00000004 |
| |
| /// |
| /// Type definition for representing labels in NASM source code that allow for |
| /// the patching of immediate operands of IA32 and X64 instructions. |
| /// |
| /// While the type is technically defined as a function type (note: not a |
| /// pointer-to-function type), such labels in NASM source code never stand for |
| /// actual functions, and identifiers declared with this function type should |
| /// never be called. This is also why the EFIAPI calling convention specifier |
| /// is missing from the typedef, and why the typedef does not follow the usual |
| /// edk2 coding style for function (or pointer-to-function) typedefs. The VOID |
| /// return type and the VOID argument list are merely artifacts. |
| /// |
| typedef VOID (X86_ASSEMBLY_PATCH_LABEL) (VOID); |
| |
| /** |
| Retrieves CPUID information. |
| |
| Executes the CPUID instruction with EAX set to the value specified by Index. |
| This function always returns Index. |
| If Eax is not NULL, then the value of EAX after CPUID is returned in Eax. |
| If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx. |
| If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx. |
| If Edx is not NULL, then the value of EDX after CPUID is returned in Edx. |
| This function is only available on IA-32 and x64. |
| |
| @param Index The 32-bit value to load into EAX prior to invoking the CPUID |
| instruction. |
| @param Eax The pointer to the 32-bit EAX value returned by the CPUID |
| instruction. This is an optional parameter that may be NULL. |
| @param Ebx The pointer to the 32-bit EBX value returned by the CPUID |
| instruction. This is an optional parameter that may be NULL. |
| @param Ecx The pointer to the 32-bit ECX value returned by the CPUID |
| instruction. This is an optional parameter that may be NULL. |
| @param Edx The pointer to the 32-bit EDX value returned by the CPUID |
| instruction. This is an optional parameter that may be NULL. |
| |
| @return Index. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmCpuid ( |
| IN UINT32 Index, |
| OUT UINT32 *Eax, OPTIONAL |
| OUT UINT32 *Ebx, OPTIONAL |
| OUT UINT32 *Ecx, OPTIONAL |
| OUT UINT32 *Edx OPTIONAL |
| ); |
| |
| |
| /** |
| Retrieves CPUID information using an extended leaf identifier. |
| |
| Executes the CPUID instruction with EAX set to the value specified by Index |
| and ECX set to the value specified by SubIndex. This function always returns |
| Index. This function is only available on IA-32 and x64. |
| |
| If Eax is not NULL, then the value of EAX after CPUID is returned in Eax. |
| If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx. |
| If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx. |
| If Edx is not NULL, then the value of EDX after CPUID is returned in Edx. |
| |
| @param Index The 32-bit value to load into EAX prior to invoking the |
| CPUID instruction. |
| @param SubIndex The 32-bit value to load into ECX prior to invoking the |
| CPUID instruction. |
| @param Eax The pointer to the 32-bit EAX value returned by the CPUID |
| instruction. This is an optional parameter that may be |
| NULL. |
| @param Ebx The pointer to the 32-bit EBX value returned by the CPUID |
| instruction. This is an optional parameter that may be |
| NULL. |
| @param Ecx The pointer to the 32-bit ECX value returned by the CPUID |
| instruction. This is an optional parameter that may be |
| NULL. |
| @param Edx The pointer to the 32-bit EDX value returned by the CPUID |
| instruction. This is an optional parameter that may be |
| NULL. |
| |
| @return Index. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmCpuidEx ( |
| IN UINT32 Index, |
| IN UINT32 SubIndex, |
| OUT UINT32 *Eax, OPTIONAL |
| OUT UINT32 *Ebx, OPTIONAL |
| OUT UINT32 *Ecx, OPTIONAL |
| OUT UINT32 *Edx OPTIONAL |
| ); |
| |
| |
| /** |
| Set CD bit and clear NW bit of CR0 followed by a WBINVD. |
| |
| Disables the caches by setting the CD bit of CR0 to 1, clearing the NW bit of CR0 to 0, |
| and executing a WBINVD instruction. This function is only available on IA-32 and x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmDisableCache ( |
| VOID |
| ); |
| |
| |
| /** |
| Perform a WBINVD and clear both the CD and NW bits of CR0. |
| |
| Enables the caches by executing a WBINVD instruction and then clear both the CD and NW |
| bits of CR0 to 0. This function is only available on IA-32 and x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmEnableCache ( |
| VOID |
| ); |
| |
| |
| /** |
| Returns the lower 32-bits of a Machine Specific Register(MSR). |
| |
| Reads and returns the lower 32-bits of the MSR specified by Index. |
| No parameter checking is performed on Index, and some Index values may cause |
| CPU exceptions. The caller must either guarantee that Index is valid, or the |
| caller must set up exception handlers to catch the exceptions. This function |
| is only available on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to read. |
| |
| @return The lower 32 bits of the MSR identified by Index. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmReadMsr32 ( |
| IN UINT32 Index |
| ); |
| |
| |
| /** |
| Writes a 32-bit value to a Machine Specific Register(MSR), and returns the value. |
| The upper 32-bits of the MSR are set to zero. |
| |
| Writes the 32-bit value specified by Value to the MSR specified by Index. The |
| upper 32-bits of the MSR write are set to zero. The 32-bit value written to |
| the MSR is returned. No parameter checking is performed on Index or Value, |
| and some of these may cause CPU exceptions. The caller must either guarantee |
| that Index and Value are valid, or the caller must establish proper exception |
| handlers. This function is only available on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param Value The 32-bit value to write to the MSR. |
| |
| @return Value |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmWriteMsr32 ( |
| IN UINT32 Index, |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise OR on the lower 32-bits, and |
| writes the result back to the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise OR |
| between the lower 32-bits of the read result and the value specified by |
| OrData, and writes the result to the 64-bit MSR specified by Index. The lower |
| 32-bits of the value written to the MSR is returned. No parameter checking is |
| performed on Index or OrData, and some of these may cause CPU exceptions. The |
| caller must either guarantee that Index and OrData are valid, or the caller |
| must establish proper exception handlers. This function is only available on |
| IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param OrData The value to OR with the read value from the MSR. |
| |
| @return The lower 32-bit value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrOr32 ( |
| IN UINT32 Index, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise AND on the lower 32-bits, and writes |
| the result back to the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between the |
| lower 32-bits of the read result and the value specified by AndData, and |
| writes the result to the 64-bit MSR specified by Index. The lower 32-bits of |
| the value written to the MSR is returned. No parameter checking is performed |
| on Index or AndData, and some of these may cause CPU exceptions. The caller |
| must either guarantee that Index and AndData are valid, or the caller must |
| establish proper exception handlers. This function is only available on IA-32 |
| and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param AndData The value to AND with the read value from the MSR. |
| |
| @return The lower 32-bit value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrAnd32 ( |
| IN UINT32 Index, |
| IN UINT32 AndData |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise OR |
| on the lower 32-bits, and writes the result back to the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between the |
| lower 32-bits of the read result and the value specified by AndData |
| preserving the upper 32-bits, performs a bitwise OR between the |
| result of the AND operation and the value specified by OrData, and writes the |
| result to the 64-bit MSR specified by Address. The lower 32-bits of the value |
| written to the MSR is returned. No parameter checking is performed on Index, |
| AndData, or OrData, and some of these may cause CPU exceptions. The caller |
| must either guarantee that Index, AndData, and OrData are valid, or the |
| caller must establish proper exception handlers. This function is only |
| available on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param AndData The value to AND with the read value from the MSR. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The lower 32-bit value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrAndThenOr32 ( |
| IN UINT32 Index, |
| IN UINT32 AndData, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field of an MSR. |
| |
| Reads the bit field in the lower 32-bits of a 64-bit MSR. The bit field is |
| specified by the StartBit and the EndBit. The value of the bit field is |
| returned. The caller must either guarantee that Index is valid, or the caller |
| must set up exception handlers to catch the exceptions. This function is only |
| available on IA-32 and x64. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to read. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| |
| @return The bit field read from the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrBitFieldRead32 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to an MSR. |
| |
| Writes Value to a bit field in the lower 32-bits of a 64-bit MSR. The bit |
| field is specified by the StartBit and the EndBit. All other bits in the |
| destination MSR are preserved. The lower 32-bits of the MSR written is |
| returned. The caller must either guarantee that Index and the data written |
| is valid, or the caller must set up exception handlers to catch the exceptions. |
| This function is only available on IA-32 and x64. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param Value New value of the bit field. |
| |
| @return The lower 32-bit of the value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrBitFieldWrite32 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 Value |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise OR, and writes the |
| result back to the bit field in the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise OR |
| between the read result and the value specified by OrData, and writes the |
| result to the 64-bit MSR specified by Index. The lower 32-bits of the value |
| written to the MSR are returned. Extra left bits in OrData are stripped. The |
| caller must either guarantee that Index and the data written is valid, or |
| the caller must set up exception handlers to catch the exceptions. This |
| function is only available on IA-32 and x64. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param OrData The value to OR with the read value from the MSR. |
| |
| @return The lower 32-bit of the value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrBitFieldOr32 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the |
| result back to the bit field in the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between the |
| read result and the value specified by AndData, and writes the result to the |
| 64-bit MSR specified by Index. The lower 32-bits of the value written to the |
| MSR are returned. Extra left bits in AndData are stripped. The caller must |
| either guarantee that Index and the data written is valid, or the caller must |
| set up exception handlers to catch the exceptions. This function is only |
| available on IA-32 and x64. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param AndData The value to AND with the read value from the MSR. |
| |
| @return The lower 32-bit of the value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrBitFieldAnd32 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a |
| bitwise OR, and writes the result back to the bit field in the |
| 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by a |
| bitwise OR between the read result and the value specified by |
| AndData, and writes the result to the 64-bit MSR specified by Index. The |
| lower 32-bits of the value written to the MSR are returned. Extra left bits |
| in both AndData and OrData are stripped. The caller must either guarantee |
| that Index and the data written is valid, or the caller must set up exception |
| handlers to catch the exceptions. This function is only available on IA-32 |
| and x64. |
| |
| If StartBit is greater than 31, then ASSERT(). |
| If EndBit is greater than 31, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..31. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..31. |
| @param AndData The value to AND with the read value from the MSR. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The lower 32-bit of the value written to the MSR. |
| |
| **/ |
| UINT32 |
| EFIAPI |
| AsmMsrBitFieldAndThenOr32 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT32 AndData, |
| IN UINT32 OrData |
| ); |
| |
| |
| /** |
| Returns a 64-bit Machine Specific Register(MSR). |
| |
| Reads and returns the 64-bit MSR specified by Index. No parameter checking is |
| performed on Index, and some Index values may cause CPU exceptions. The |
| caller must either guarantee that Index is valid, or the caller must set up |
| exception handlers to catch the exceptions. This function is only available |
| on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to read. |
| |
| @return The value of the MSR identified by Index. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMsr64 ( |
| IN UINT32 Index |
| ); |
| |
| |
| /** |
| Writes a 64-bit value to a Machine Specific Register(MSR), and returns the |
| value. |
| |
| Writes the 64-bit value specified by Value to the MSR specified by Index. The |
| 64-bit value written to the MSR is returned. No parameter checking is |
| performed on Index or Value, and some of these may cause CPU exceptions. The |
| caller must either guarantee that Index and Value are valid, or the caller |
| must establish proper exception handlers. This function is only available on |
| IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param Value The 64-bit value to write to the MSR. |
| |
| @return Value |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmWriteMsr64 ( |
| IN UINT32 Index, |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise OR, and writes the result |
| back to the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise OR |
| between the read result and the value specified by OrData, and writes the |
| result to the 64-bit MSR specified by Index. The value written to the MSR is |
| returned. No parameter checking is performed on Index or OrData, and some of |
| these may cause CPU exceptions. The caller must either guarantee that Index |
| and OrData are valid, or the caller must establish proper exception handlers. |
| This function is only available on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param OrData The value to OR with the read value from the MSR. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrOr64 ( |
| IN UINT32 Index, |
| IN UINT64 OrData |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise AND, and writes the result back to the |
| 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between the |
| read result and the value specified by OrData, and writes the result to the |
| 64-bit MSR specified by Index. The value written to the MSR is returned. No |
| parameter checking is performed on Index or OrData, and some of these may |
| cause CPU exceptions. The caller must either guarantee that Index and OrData |
| are valid, or the caller must establish proper exception handlers. This |
| function is only available on IA-32 and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param AndData The value to AND with the read value from the MSR. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrAnd64 ( |
| IN UINT32 Index, |
| IN UINT64 AndData |
| ); |
| |
| |
| /** |
| Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise |
| OR, and writes the result back to the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between read |
| result and the value specified by AndData, performs a bitwise OR |
| between the result of the AND operation and the value specified by OrData, |
| and writes the result to the 64-bit MSR specified by Index. The value written |
| to the MSR is returned. No parameter checking is performed on Index, AndData, |
| or OrData, and some of these may cause CPU exceptions. The caller must either |
| guarantee that Index, AndData, and OrData are valid, or the caller must |
| establish proper exception handlers. This function is only available on IA-32 |
| and x64. |
| |
| @param Index The 32-bit MSR index to write. |
| @param AndData The value to AND with the read value from the MSR. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrAndThenOr64 ( |
| IN UINT32 Index, |
| IN UINT64 AndData, |
| IN UINT64 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field of an MSR. |
| |
| Reads the bit field in the 64-bit MSR. The bit field is specified by the |
| StartBit and the EndBit. The value of the bit field is returned. The caller |
| must either guarantee that Index is valid, or the caller must set up |
| exception handlers to catch the exceptions. This function is only available |
| on IA-32 and x64. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to read. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| |
| @return The value read from the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrBitFieldRead64 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit |
| ); |
| |
| |
| /** |
| Writes a bit field to an MSR. |
| |
| Writes Value to a bit field in a 64-bit MSR. The bit field is specified by |
| the StartBit and the EndBit. All other bits in the destination MSR are |
| preserved. The MSR written is returned. The caller must either guarantee |
| that Index and the data written is valid, or the caller must set up exception |
| handlers to catch the exceptions. This function is only available on IA-32 and x64. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param Value New value of the bit field. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrBitFieldWrite64 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise OR, and |
| writes the result back to the bit field in the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise OR |
| between the read result and the value specified by OrData, and writes the |
| result to the 64-bit MSR specified by Index. The value written to the MSR is |
| returned. Extra left bits in OrData are stripped. The caller must either |
| guarantee that Index and the data written is valid, or the caller must set up |
| exception handlers to catch the exceptions. This function is only available |
| on IA-32 and x64. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param OrData The value to OR with the read value from the bit field. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrBitFieldOr64 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 OrData |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the |
| result back to the bit field in the 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND between the |
| read result and the value specified by AndData, and writes the result to the |
| 64-bit MSR specified by Index. The value written to the MSR is returned. |
| Extra left bits in AndData are stripped. The caller must either guarantee |
| that Index and the data written is valid, or the caller must set up exception |
| handlers to catch the exceptions. This function is only available on IA-32 |
| and x64. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param AndData The value to AND with the read value from the bit field. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrBitFieldAnd64 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 AndData |
| ); |
| |
| |
| /** |
| Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a |
| bitwise OR, and writes the result back to the bit field in the |
| 64-bit MSR. |
| |
| Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by |
| a bitwise OR between the read result and the value specified by |
| AndData, and writes the result to the 64-bit MSR specified by Index. The |
| value written to the MSR is returned. Extra left bits in both AndData and |
| OrData are stripped. The caller must either guarantee that Index and the data |
| written is valid, or the caller must set up exception handlers to catch the |
| exceptions. This function is only available on IA-32 and x64. |
| |
| If StartBit is greater than 63, then ASSERT(). |
| If EndBit is greater than 63, then ASSERT(). |
| If EndBit is less than StartBit, then ASSERT(). |
| If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT(). |
| |
| @param Index The 32-bit MSR index to write. |
| @param StartBit The ordinal of the least significant bit in the bit field. |
| Range 0..63. |
| @param EndBit The ordinal of the most significant bit in the bit field. |
| Range 0..63. |
| @param AndData The value to AND with the read value from the bit field. |
| @param OrData The value to OR with the result of the AND operation. |
| |
| @return The value written back to the MSR. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmMsrBitFieldAndThenOr64 ( |
| IN UINT32 Index, |
| IN UINTN StartBit, |
| IN UINTN EndBit, |
| IN UINT64 AndData, |
| IN UINT64 OrData |
| ); |
| |
| |
| /** |
| Reads the current value of the EFLAGS register. |
| |
| Reads and returns the current value of the EFLAGS register. This function is |
| only available on IA-32 and x64. This returns a 32-bit value on IA-32 and a |
| 64-bit value on x64. |
| |
| @return EFLAGS on IA-32 or RFLAGS on x64. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadEflags ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of the Control Register 0 (CR0). |
| |
| Reads and returns the current value of CR0. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of the Control Register 0 (CR0). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadCr0 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of the Control Register 2 (CR2). |
| |
| Reads and returns the current value of CR2. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of the Control Register 2 (CR2). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadCr2 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of the Control Register 3 (CR3). |
| |
| Reads and returns the current value of CR3. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of the Control Register 3 (CR3). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadCr3 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of the Control Register 4 (CR4). |
| |
| Reads and returns the current value of CR4. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of the Control Register 4 (CR4). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadCr4 ( |
| VOID |
| ); |
| |
| |
| /** |
| Writes a value to Control Register 0 (CR0). |
| |
| Writes and returns a new value to CR0. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Cr0 The value to write to CR0. |
| |
| @return The value written to CR0. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteCr0 ( |
| UINTN Cr0 |
| ); |
| |
| |
| /** |
| Writes a value to Control Register 2 (CR2). |
| |
| Writes and returns a new value to CR2. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Cr2 The value to write to CR2. |
| |
| @return The value written to CR2. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteCr2 ( |
| UINTN Cr2 |
| ); |
| |
| |
| /** |
| Writes a value to Control Register 3 (CR3). |
| |
| Writes and returns a new value to CR3. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Cr3 The value to write to CR3. |
| |
| @return The value written to CR3. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteCr3 ( |
| UINTN Cr3 |
| ); |
| |
| |
| /** |
| Writes a value to Control Register 4 (CR4). |
| |
| Writes and returns a new value to CR4. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Cr4 The value to write to CR4. |
| |
| @return The value written to CR4. |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteCr4 ( |
| UINTN Cr4 |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 0 (DR0). |
| |
| Reads and returns the current value of DR0. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 0 (DR0). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr0 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 1 (DR1). |
| |
| Reads and returns the current value of DR1. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 1 (DR1). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr1 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 2 (DR2). |
| |
| Reads and returns the current value of DR2. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 2 (DR2). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr2 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 3 (DR3). |
| |
| Reads and returns the current value of DR3. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 3 (DR3). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr3 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 4 (DR4). |
| |
| Reads and returns the current value of DR4. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 4 (DR4). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr4 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 5 (DR5). |
| |
| Reads and returns the current value of DR5. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 5 (DR5). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr5 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 6 (DR6). |
| |
| Reads and returns the current value of DR6. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 6 (DR6). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr6 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Debug Register 7 (DR7). |
| |
| Reads and returns the current value of DR7. This function is only available |
| on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on |
| x64. |
| |
| @return The value of Debug Register 7 (DR7). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmReadDr7 ( |
| VOID |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 0 (DR0). |
| |
| Writes and returns a new value to DR0. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr0 The value to write to Dr0. |
| |
| @return The value written to Debug Register 0 (DR0). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr0 ( |
| UINTN Dr0 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 1 (DR1). |
| |
| Writes and returns a new value to DR1. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr1 The value to write to Dr1. |
| |
| @return The value written to Debug Register 1 (DR1). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr1 ( |
| UINTN Dr1 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 2 (DR2). |
| |
| Writes and returns a new value to DR2. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr2 The value to write to Dr2. |
| |
| @return The value written to Debug Register 2 (DR2). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr2 ( |
| UINTN Dr2 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 3 (DR3). |
| |
| Writes and returns a new value to DR3. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr3 The value to write to Dr3. |
| |
| @return The value written to Debug Register 3 (DR3). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr3 ( |
| UINTN Dr3 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 4 (DR4). |
| |
| Writes and returns a new value to DR4. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr4 The value to write to Dr4. |
| |
| @return The value written to Debug Register 4 (DR4). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr4 ( |
| UINTN Dr4 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 5 (DR5). |
| |
| Writes and returns a new value to DR5. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr5 The value to write to Dr5. |
| |
| @return The value written to Debug Register 5 (DR5). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr5 ( |
| UINTN Dr5 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 6 (DR6). |
| |
| Writes and returns a new value to DR6. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr6 The value to write to Dr6. |
| |
| @return The value written to Debug Register 6 (DR6). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr6 ( |
| UINTN Dr6 |
| ); |
| |
| |
| /** |
| Writes a value to Debug Register 7 (DR7). |
| |
| Writes and returns a new value to DR7. This function is only available on |
| IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64. |
| |
| @param Dr7 The value to write to Dr7. |
| |
| @return The value written to Debug Register 7 (DR7). |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmWriteDr7 ( |
| UINTN Dr7 |
| ); |
| |
| |
| /** |
| Reads the current value of Code Segment Register (CS). |
| |
| Reads and returns the current value of CS. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of CS. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadCs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Data Segment Register (DS). |
| |
| Reads and returns the current value of DS. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of DS. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadDs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Extra Segment Register (ES). |
| |
| Reads and returns the current value of ES. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of ES. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadEs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of FS Data Segment Register (FS). |
| |
| Reads and returns the current value of FS. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of FS. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadFs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of GS Data Segment Register (GS). |
| |
| Reads and returns the current value of GS. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of GS. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadGs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Stack Segment Register (SS). |
| |
| Reads and returns the current value of SS. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of SS. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadSs ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of Task Register (TR). |
| |
| Reads and returns the current value of TR. This function is only available on |
| IA-32 and x64. |
| |
| @return The current value of TR. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadTr ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current Global Descriptor Table Register(GDTR) descriptor. |
| |
| Reads and returns the current GDTR descriptor and returns it in Gdtr. This |
| function is only available on IA-32 and x64. |
| |
| If Gdtr is NULL, then ASSERT(). |
| |
| @param Gdtr The pointer to a GDTR descriptor. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmReadGdtr ( |
| OUT IA32_DESCRIPTOR *Gdtr |
| ); |
| |
| |
| /** |
| Writes the current Global Descriptor Table Register (GDTR) descriptor. |
| |
| Writes and the current GDTR descriptor specified by Gdtr. This function is |
| only available on IA-32 and x64. |
| |
| If Gdtr is NULL, then ASSERT(). |
| |
| @param Gdtr The pointer to a GDTR descriptor. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteGdtr ( |
| IN CONST IA32_DESCRIPTOR *Gdtr |
| ); |
| |
| |
| /** |
| Reads the current Interrupt Descriptor Table Register(IDTR) descriptor. |
| |
| Reads and returns the current IDTR descriptor and returns it in Idtr. This |
| function is only available on IA-32 and x64. |
| |
| If Idtr is NULL, then ASSERT(). |
| |
| @param Idtr The pointer to a IDTR descriptor. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmReadIdtr ( |
| OUT IA32_DESCRIPTOR *Idtr |
| ); |
| |
| |
| /** |
| Writes the current Interrupt Descriptor Table Register(IDTR) descriptor. |
| |
| Writes the current IDTR descriptor and returns it in Idtr. This function is |
| only available on IA-32 and x64. |
| |
| If Idtr is NULL, then ASSERT(). |
| |
| @param Idtr The pointer to a IDTR descriptor. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteIdtr ( |
| IN CONST IA32_DESCRIPTOR *Idtr |
| ); |
| |
| |
| /** |
| Reads the current Local Descriptor Table Register(LDTR) selector. |
| |
| Reads and returns the current 16-bit LDTR descriptor value. This function is |
| only available on IA-32 and x64. |
| |
| @return The current selector of LDT. |
| |
| **/ |
| UINT16 |
| EFIAPI |
| AsmReadLdtr ( |
| VOID |
| ); |
| |
| |
| /** |
| Writes the current Local Descriptor Table Register (LDTR) selector. |
| |
| Writes and the current LDTR descriptor specified by Ldtr. This function is |
| only available on IA-32 and x64. |
| |
| @param Ldtr 16-bit LDTR selector value. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteLdtr ( |
| IN UINT16 Ldtr |
| ); |
| |
| |
| /** |
| Save the current floating point/SSE/SSE2 context to a buffer. |
| |
| Saves the current floating point/SSE/SSE2 state to the buffer specified by |
| Buffer. Buffer must be aligned on a 16-byte boundary. This function is only |
| available on IA-32 and x64. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 16-byte boundary, then ASSERT(). |
| |
| @param Buffer The pointer to a buffer to save the floating point/SSE/SSE2 context. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmFxSave ( |
| OUT IA32_FX_BUFFER *Buffer |
| ); |
| |
| |
| /** |
| Restores the current floating point/SSE/SSE2 context from a buffer. |
| |
| Restores the current floating point/SSE/SSE2 state from the buffer specified |
| by Buffer. Buffer must be aligned on a 16-byte boundary. This function is |
| only available on IA-32 and x64. |
| |
| If Buffer is NULL, then ASSERT(). |
| If Buffer is not aligned on a 16-byte boundary, then ASSERT(). |
| If Buffer was not saved with AsmFxSave(), then ASSERT(). |
| |
| @param Buffer The pointer to a buffer to save the floating point/SSE/SSE2 context. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmFxRestore ( |
| IN CONST IA32_FX_BUFFER *Buffer |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #0 (MM0). |
| |
| Reads and returns the current value of MM0. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM0. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm0 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #1 (MM1). |
| |
| Reads and returns the current value of MM1. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM1. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm1 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #2 (MM2). |
| |
| Reads and returns the current value of MM2. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM2. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm2 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #3 (MM3). |
| |
| Reads and returns the current value of MM3. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM3. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm3 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #4 (MM4). |
| |
| Reads and returns the current value of MM4. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM4. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm4 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #5 (MM5). |
| |
| Reads and returns the current value of MM5. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM5. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm5 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #6 (MM6). |
| |
| Reads and returns the current value of MM6. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM6. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm6 ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of 64-bit MMX Register #7 (MM7). |
| |
| Reads and returns the current value of MM7. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of MM7. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadMm7 ( |
| VOID |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #0 (MM0). |
| |
| Writes the current value of MM0. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM0. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm0 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #1 (MM1). |
| |
| Writes the current value of MM1. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM1. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm1 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #2 (MM2). |
| |
| Writes the current value of MM2. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM2. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm2 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #3 (MM3). |
| |
| Writes the current value of MM3. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM3. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm3 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #4 (MM4). |
| |
| Writes the current value of MM4. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM4. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm4 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #5 (MM5). |
| |
| Writes the current value of MM5. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM5. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm5 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #6 (MM6). |
| |
| Writes the current value of MM6. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM6. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm6 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Writes the current value of 64-bit MMX Register #7 (MM7). |
| |
| Writes the current value of MM7. This function is only available on IA32 and |
| x64. |
| |
| @param Value The 64-bit value to write to MM7. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteMm7 ( |
| IN UINT64 Value |
| ); |
| |
| |
| /** |
| Reads the current value of Time Stamp Counter (TSC). |
| |
| Reads and returns the current value of TSC. This function is only available |
| on IA-32 and x64. |
| |
| @return The current value of TSC |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadTsc ( |
| VOID |
| ); |
| |
| |
| /** |
| Reads the current value of a Performance Counter (PMC). |
| |
| Reads and returns the current value of performance counter specified by |
| Index. This function is only available on IA-32 and x64. |
| |
| @param Index The 32-bit Performance Counter index to read. |
| |
| @return The value of the PMC specified by Index. |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmReadPmc ( |
| IN UINT32 Index |
| ); |
| |
| |
| /** |
| Sets up a monitor buffer that is used by AsmMwait(). |
| |
| Executes a MONITOR instruction with the register state specified by Eax, Ecx |
| and Edx. Returns Eax. This function is only available on IA-32 and x64. |
| |
| @param Eax The value to load into EAX or RAX before executing the MONITOR |
| instruction. |
| @param Ecx The value to load into ECX or RCX before executing the MONITOR |
| instruction. |
| @param Edx The value to load into EDX or RDX before executing the MONITOR |
| instruction. |
| |
| @return Eax |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmMonitor ( |
| IN UINTN Eax, |
| IN UINTN Ecx, |
| IN UINTN Edx |
| ); |
| |
| |
| /** |
| Executes an MWAIT instruction. |
| |
| Executes an MWAIT instruction with the register state specified by Eax and |
| Ecx. Returns Eax. This function is only available on IA-32 and x64. |
| |
| @param Eax The value to load into EAX or RAX before executing the MONITOR |
| instruction. |
| @param Ecx The value to load into ECX or RCX before executing the MONITOR |
| instruction. |
| |
| @return Eax |
| |
| **/ |
| UINTN |
| EFIAPI |
| AsmMwait ( |
| IN UINTN Eax, |
| IN UINTN Ecx |
| ); |
| |
| |
| /** |
| Executes a WBINVD instruction. |
| |
| Executes a WBINVD instruction. This function is only available on IA-32 and |
| x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmWbinvd ( |
| VOID |
| ); |
| |
| |
| /** |
| Executes a INVD instruction. |
| |
| Executes a INVD instruction. This function is only available on IA-32 and |
| x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmInvd ( |
| VOID |
| ); |
| |
| |
| /** |
| Flushes a cache line from all the instruction and data caches within the |
| coherency domain of the CPU. |
| |
| Flushed the cache line specified by LinearAddress, and returns LinearAddress. |
| This function is only available on IA-32 and x64. |
| |
| @param LinearAddress The address of the cache line to flush. If the CPU is |
| in a physical addressing mode, then LinearAddress is a |
| physical address. If the CPU is in a virtual |
| addressing mode, then LinearAddress is a virtual |
| address. |
| |
| @return LinearAddress. |
| **/ |
| VOID * |
| EFIAPI |
| AsmFlushCacheLine ( |
| IN VOID *LinearAddress |
| ); |
| |
| |
| /** |
| Enables the 32-bit paging mode on the CPU. |
| |
| Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables |
| must be properly initialized prior to calling this service. This function |
| assumes the current execution mode is 32-bit protected mode. This function is |
| only available on IA-32. After the 32-bit paging mode is enabled, control is |
| transferred to the function specified by EntryPoint using the new stack |
| specified by NewStack and passing in the parameters specified by Context1 and |
| Context2. Context1 and Context2 are optional and may be NULL. The function |
| EntryPoint must never return. |
| |
| If the current execution mode is not 32-bit protected mode, then ASSERT(). |
| If EntryPoint is NULL, then ASSERT(). |
| If NewStack is NULL, then ASSERT(). |
| |
| There are a number of constraints that must be followed before calling this |
| function: |
| 1) Interrupts must be disabled. |
| 2) The caller must be in 32-bit protected mode with flat descriptors. This |
| means all descriptors must have a base of 0 and a limit of 4GB. |
| 3) CR0 and CR4 must be compatible with 32-bit protected mode with flat |
| descriptors. |
| 4) CR3 must point to valid page tables that will be used once the transition |
| is complete, and those page tables must guarantee that the pages for this |
| function and the stack are identity mapped. |
| |
| @param EntryPoint A pointer to function to call with the new stack after |
| paging is enabled. |
| @param Context1 A pointer to the context to pass into the EntryPoint |
| function as the first parameter after paging is enabled. |
| @param Context2 A pointer to the context to pass into the EntryPoint |
| function as the second parameter after paging is enabled. |
| @param NewStack A pointer to the new stack to use for the EntryPoint |
| function after paging is enabled. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmEnablePaging32 ( |
| IN SWITCH_STACK_ENTRY_POINT EntryPoint, |
| IN VOID *Context1, OPTIONAL |
| IN VOID *Context2, OPTIONAL |
| IN VOID *NewStack |
| ); |
| |
| |
| /** |
| Disables the 32-bit paging mode on the CPU. |
| |
| Disables the 32-bit paging mode on the CPU and returns to 32-bit protected |
| mode. This function assumes the current execution mode is 32-paged protected |
| mode. This function is only available on IA-32. After the 32-bit paging mode |
| is disabled, control is transferred to the function specified by EntryPoint |
| using the new stack specified by NewStack and passing in the parameters |
| specified by Context1 and Context2. Context1 and Context2 are optional and |
| may be NULL. The function EntryPoint must never return. |
| |
| If the current execution mode is not 32-bit paged mode, then ASSERT(). |
| If EntryPoint is NULL, then ASSERT(). |
| If NewStack is NULL, then ASSERT(). |
| |
| There are a number of constraints that must be followed before calling this |
| function: |
| 1) Interrupts must be disabled. |
| 2) The caller must be in 32-bit paged mode. |
| 3) CR0, CR3, and CR4 must be compatible with 32-bit paged mode. |
| 4) CR3 must point to valid page tables that guarantee that the pages for |
| this function and the stack are identity mapped. |
| |
| @param EntryPoint A pointer to function to call with the new stack after |
| paging is disabled. |
| @param Context1 A pointer to the context to pass into the EntryPoint |
| function as the first parameter after paging is disabled. |
| @param Context2 A pointer to the context to pass into the EntryPoint |
| function as the second parameter after paging is |
| disabled. |
| @param NewStack A pointer to the new stack to use for the EntryPoint |
| function after paging is disabled. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmDisablePaging32 ( |
| IN SWITCH_STACK_ENTRY_POINT EntryPoint, |
| IN VOID *Context1, OPTIONAL |
| IN VOID *Context2, OPTIONAL |
| IN VOID *NewStack |
| ); |
| |
| |
| /** |
| Enables the 64-bit paging mode on the CPU. |
| |
| Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables |
| must be properly initialized prior to calling this service. This function |
| assumes the current execution mode is 32-bit protected mode with flat |
| descriptors. This function is only available on IA-32. After the 64-bit |
| paging mode is enabled, control is transferred to the function specified by |
| EntryPoint using the new stack specified by NewStack and passing in the |
| parameters specified by Context1 and Context2. Context1 and Context2 are |
| optional and may be 0. The function EntryPoint must never return. |
| |
| If the current execution mode is not 32-bit protected mode with flat |
| descriptors, then ASSERT(). |
| If EntryPoint is 0, then ASSERT(). |
| If NewStack is 0, then ASSERT(). |
| |
| @param Cs The 16-bit selector to load in the CS before EntryPoint |
| is called. The descriptor in the GDT that this selector |
| references must be setup for long mode. |
| @param EntryPoint The 64-bit virtual address of the function to call with |
| the new stack after paging is enabled. |
| @param Context1 The 64-bit virtual address of the context to pass into |
| the EntryPoint function as the first parameter after |
| paging is enabled. |
| @param Context2 The 64-bit virtual address of the context to pass into |
| the EntryPoint function as the second parameter after |
| paging is enabled. |
| @param NewStack The 64-bit virtual address of the new stack to use for |
| the EntryPoint function after paging is enabled. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmEnablePaging64 ( |
| IN UINT16 Cs, |
| IN UINT64 EntryPoint, |
| IN UINT64 Context1, OPTIONAL |
| IN UINT64 Context2, OPTIONAL |
| IN UINT64 NewStack |
| ); |
| |
| |
| /** |
| Disables the 64-bit paging mode on the CPU. |
| |
| Disables the 64-bit paging mode on the CPU and returns to 32-bit protected |
| mode. This function assumes the current execution mode is 64-paging mode. |
| This function is only available on x64. After the 64-bit paging mode is |
| disabled, control is transferred to the function specified by EntryPoint |
| using the new stack specified by NewStack and passing in the parameters |
| specified by Context1 and Context2. Context1 and Context2 are optional and |
| may be 0. The function EntryPoint must never return. |
| |
| If the current execution mode is not 64-bit paged mode, then ASSERT(). |
| If EntryPoint is 0, then ASSERT(). |
| If NewStack is 0, then ASSERT(). |
| |
| @param Cs The 16-bit selector to load in the CS before EntryPoint |
| is called. The descriptor in the GDT that this selector |
| references must be setup for 32-bit protected mode. |
| @param EntryPoint The 64-bit virtual address of the function to call with |
| the new stack after paging is disabled. |
| @param Context1 The 64-bit virtual address of the context to pass into |
| the EntryPoint function as the first parameter after |
| paging is disabled. |
| @param Context2 The 64-bit virtual address of the context to pass into |
| the EntryPoint function as the second parameter after |
| paging is disabled. |
| @param NewStack The 64-bit virtual address of the new stack to use for |
| the EntryPoint function after paging is disabled. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmDisablePaging64 ( |
| IN UINT16 Cs, |
| IN UINT32 EntryPoint, |
| IN UINT32 Context1, OPTIONAL |
| IN UINT32 Context2, OPTIONAL |
| IN UINT32 NewStack |
| ); |
| |
| |
| // |
| // 16-bit thunking services |
| // |
| |
| /** |
| Retrieves the properties for 16-bit thunk functions. |
| |
| Computes the size of the buffer and stack below 1MB required to use the |
| AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This |
| buffer size is returned in RealModeBufferSize, and the stack size is returned |
| in ExtraStackSize. If parameters are passed to the 16-bit real mode code, |
| then the actual minimum stack size is ExtraStackSize plus the maximum number |
| of bytes that need to be passed to the 16-bit real mode code. |
| |
| If RealModeBufferSize is NULL, then ASSERT(). |
| If ExtraStackSize is NULL, then ASSERT(). |
| |
| @param RealModeBufferSize A pointer to the size of the buffer below 1MB |
| required to use the 16-bit thunk functions. |
| @param ExtraStackSize A pointer to the extra size of stack below 1MB |
| that the 16-bit thunk functions require for |
| temporary storage in the transition to and from |
| 16-bit real mode. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmGetThunk16Properties ( |
| OUT UINT32 *RealModeBufferSize, |
| OUT UINT32 *ExtraStackSize |
| ); |
| |
| |
| /** |
| Prepares all structures a code required to use AsmThunk16(). |
| |
| Prepares all structures and code required to use AsmThunk16(). |
| |
| This interface is limited to be used in either physical mode or virtual modes with paging enabled where the |
| virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1. |
| |
| If ThunkContext is NULL, then ASSERT(). |
| |
| @param ThunkContext A pointer to the context structure that describes the |
| 16-bit real mode code to call. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmPrepareThunk16 ( |
| IN OUT THUNK_CONTEXT *ThunkContext |
| ); |
| |
| |
| /** |
| Transfers control to a 16-bit real mode entry point and returns the results. |
| |
| Transfers control to a 16-bit real mode entry point and returns the results. |
| AsmPrepareThunk16() must be called with ThunkContext before this function is used. |
| This function must be called with interrupts disabled. |
| |
| The register state from the RealModeState field of ThunkContext is restored just prior |
| to calling the 16-bit real mode entry point. This includes the EFLAGS field of RealModeState, |
| which is used to set the interrupt state when a 16-bit real mode entry point is called. |
| Control is transferred to the 16-bit real mode entry point specified by the CS and Eip fields of RealModeState. |
| The stack is initialized to the SS and ESP fields of RealModeState. Any parameters passed to |
| the 16-bit real mode code must be populated by the caller at SS:ESP prior to calling this function. |
| The 16-bit real mode entry point is invoked with a 16-bit CALL FAR instruction, |
| so when accessing stack contents, the 16-bit real mode code must account for the 16-bit segment |
| and 16-bit offset of the return address that were pushed onto the stack. The 16-bit real mode entry |
| point must exit with a RETF instruction. The register state is captured into RealModeState immediately |
| after the RETF instruction is executed. |
| |
| If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, |
| or any of the 16-bit real mode code makes a SW interrupt, then the caller is responsible for making sure |
| the IDT at address 0 is initialized to handle any HW or SW interrupts that may occur while in 16-bit real mode. |
| |
| If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, |
| then the caller is responsible for making sure the 8259 PIC is in a state compatible with 16-bit real mode. |
| This includes the base vectors, the interrupt masks, and the edge/level trigger mode. |
| |
| If THUNK_ATTRIBUTE_BIG_REAL_MODE is set in the ThunkAttributes field of ThunkContext, then the user code |
| is invoked in big real mode. Otherwise, the user code is invoked in 16-bit real mode with 64KB segment limits. |
| |
| If neither THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 nor THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in |
| ThunkAttributes, then it is assumed that the user code did not enable the A20 mask, and no attempt is made to |
| disable the A20 mask. |
| |
| If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is set and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is clear in |
| ThunkAttributes, then attempt to use the INT 15 service to disable the A20 mask. If this INT 15 call fails, |
| then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports. |
| |
| If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is clear and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is set in |
| ThunkAttributes, then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports. |
| |
| If ThunkContext is NULL, then ASSERT(). |
| If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT(). |
| If both THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in |
| ThunkAttributes, then ASSERT(). |
| |
| This interface is limited to be used in either physical mode or virtual modes with paging enabled where the |
| virtual to physical mappings for ThunkContext.RealModeBuffer are mapped 1:1. |
| |
| @param ThunkContext A pointer to the context structure that describes the |
| 16-bit real mode code to call. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmThunk16 ( |
| IN OUT THUNK_CONTEXT *ThunkContext |
| ); |
| |
| |
| /** |
| Prepares all structures and code for a 16-bit real mode thunk, transfers |
| control to a 16-bit real mode entry point, and returns the results. |
| |
| Prepares all structures and code for a 16-bit real mode thunk, transfers |
| control to a 16-bit real mode entry point, and returns the results. If the |
| caller only need to perform a single 16-bit real mode thunk, then this |
| service should be used. If the caller intends to make more than one 16-bit |
| real mode thunk, then it is more efficient if AsmPrepareThunk16() is called |
| once and AsmThunk16() can be called for each 16-bit real mode thunk. |
| |
| This interface is limited to be used in either physical mode or virtual modes with paging enabled where the |
| virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1. |
| |
| See AsmPrepareThunk16() and AsmThunk16() for the detailed description and ASSERT() conditions. |
| |
| @param ThunkContext A pointer to the context structure that describes the |
| 16-bit real mode code to call. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmPrepareAndThunk16 ( |
| IN OUT THUNK_CONTEXT *ThunkContext |
| ); |
| |
| /** |
| Generates a 16-bit random number through RDRAND instruction. |
| |
| if Rand is NULL, then ASSERT(). |
| |
| @param[out] Rand Buffer pointer to store the random result. |
| |
| @retval TRUE RDRAND call was successful. |
| @retval FALSE Failed attempts to call RDRAND. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| AsmRdRand16 ( |
| OUT UINT16 *Rand |
| ); |
| |
| /** |
| Generates a 32-bit random number through RDRAND instruction. |
| |
| if Rand is NULL, then ASSERT(). |
| |
| @param[out] Rand Buffer pointer to store the random result. |
| |
| @retval TRUE RDRAND call was successful. |
| @retval FALSE Failed attempts to call RDRAND. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| AsmRdRand32 ( |
| OUT UINT32 *Rand |
| ); |
| |
| /** |
| Generates a 64-bit random number through RDRAND instruction. |
| |
| if Rand is NULL, then ASSERT(). |
| |
| @param[out] Rand Buffer pointer to store the random result. |
| |
| @retval TRUE RDRAND call was successful. |
| @retval FALSE Failed attempts to call RDRAND. |
| |
| **/ |
| BOOLEAN |
| EFIAPI |
| AsmRdRand64 ( |
| OUT UINT64 *Rand |
| ); |
| |
| /** |
| Load given selector into TR register. |
| |
| @param[in] Selector Task segment selector |
| **/ |
| VOID |
| EFIAPI |
| AsmWriteTr ( |
| IN UINT16 Selector |
| ); |
| |
| /** |
| Performs a serializing operation on all load-from-memory instructions that |
| were issued prior the AsmLfence function. |
| |
| Executes a LFENCE instruction. This function is only available on IA-32 and x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmLfence ( |
| VOID |
| ); |
| |
| /** |
| Executes a XGETBV instruction |
| |
| Executes a XGETBV instruction. This function is only available on IA-32 and |
| x64. |
| |
| @param[in] Index Extended control register index |
| |
| @return The current value of the extended control register |
| **/ |
| UINT64 |
| EFIAPI |
| AsmXGetBv ( |
| IN UINT32 Index |
| ); |
| |
| /** |
| Executes a XSETBV instruction to write a 64-bit value to a Extended Control |
| Register(XCR), and returns the value. |
| |
| Writes the 64-bit value specified by Value to the XCR specified by Index. The |
| 64-bit value written to the XCR is returned. No parameter checking is |
| performed on Index or Value, and some of these may cause CPU exceptions. The |
| caller must either guarantee that Index and Value are valid, or the caller |
| must establish proper exception handlers. This function is only available on |
| IA-32 and x64. |
| |
| @param Index The 32-bit XCR index to write. |
| @param Value The 64-bit value to write to the XCR. |
| |
| @return Value |
| |
| **/ |
| UINT64 |
| EFIAPI |
| AsmXSetBv ( |
| IN UINT32 Index, |
| IN UINT64 Value |
| ); |
| |
| /** |
| Executes a VMGEXIT instruction (VMMCALL with a REP prefix) |
| |
| Executes a VMGEXIT instruction. This function is only available on IA-32 and |
| x64. |
| |
| **/ |
| VOID |
| EFIAPI |
| AsmVmgExit ( |
| VOID |
| ); |
| |
| |
| /** |
| Patch the immediate operand of an IA32 or X64 instruction such that the byte, |
| word, dword or qword operand is encoded at the end of the instruction's |
| binary representation. |
| |
| This function should be used to update object code that was compiled with |
| NASM from assembly source code. Example: |
| |
| NASM source code: |
| |
| mov eax, strict dword 0 ; the imm32 zero operand will be patched |
| ASM_PFX(gPatchCr3): |
| mov cr3, eax |
| |
| C source code: |
| |
| X86_ASSEMBLY_PATCH_LABEL gPatchCr3; |
| PatchInstructionX86 (gPatchCr3, AsmReadCr3 (), 4); |
| |
| @param[out] InstructionEnd Pointer right past the instruction to patch. The |
| immediate operand to patch is expected to |
| comprise the trailing bytes of the instruction. |
| If InstructionEnd is closer to address 0 than |
| ValueSize permits, then ASSERT(). |
| |
| @param[in] PatchValue The constant to write to the immediate operand. |
| The caller is responsible for ensuring that |
| PatchValue can be represented in the byte, word, |
| dword or qword operand (as indicated through |
| ValueSize); otherwise ASSERT(). |
| |
| @param[in] ValueSize The size of the operand in bytes; must be 1, 2, |
| 4, or 8. ASSERT() otherwise. |
| **/ |
| VOID |
| EFIAPI |
| PatchInstructionX86 ( |
| OUT X86_ASSEMBLY_PATCH_LABEL *InstructionEnd, |
| IN UINT64 PatchValue, |
| IN UINTN ValueSize |
| ); |
| |
| #endif // defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) |
| #endif // !defined (__BASE_LIB__) |