BaseLib.h

Go to the documentation of this file.

 
#ifndef __BASE_LIB__
#define __BASE_LIB__
 
//
// Definitions for architecture-specific types
//
#if   defined (MDE_CPU_IA32)
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)
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];                         
  UINT64    Ssp;
} BASE_LIBRARY_JUMP_BUFFER;
 
#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT  8
 
#endif // defined (MDE_CPU_X64)
 
#if defined (MDE_CPU_EBC)
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_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
 
UINT64
EFIAPI
ArmReadCntPctReg (
  VOID
  );
 
//
// Bit shifts for the ID_AA64ISAR0_EL1 register.
//
#define ARM_ID_AA64ISAR0_EL1_AES_SHIFT     (4U)
#define ARM_ID_AA64ISAR0_EL1_SHA1_SHIFT    (8U)
#define ARM_ID_AA64ISAR0_EL1_SHA2_SHIFT    (12U)
#define ARM_ID_AA64ISAR0_EL1_CRC32_SHIFT   (16U)
#define ARM_ID_AA64ISAR0_EL1_ATOMIC_SHIFT  (20U)
#define ARM_ID_AA64ISAR0_EL1_RDM_SHIFT     (28U)
#define ARM_ID_AA64ISAR0_EL1_SHA3_SHIFT    (32U)
#define ARM_ID_AA64ISAR0_EL1_SM3_SHIFT     (36U)
#define ARM_ID_AA64ISAR0_EL1_SM4_SHIFT     (40U)
#define ARM_ID_AA64ISAR0_EL1_DP_SHIFT      (44U)
#define ARM_ID_AA64ISAR0_EL1_FHM_SHIFT     (48U)
#define ARM_ID_AA64ISAR0_EL1_TS_SHIFT      (52U)
#define ARM_ID_AA64ISAR0_EL1_TLB_SHIFT     (56U)
#define ARM_ID_AA64ISAR0_EL1_RNDR_SHIFT    (60U)
 
//
// Bit masks for the ID_AA64ISAR0_EL1 fields.
//
#define ARM_ID_AA64ISAR0_EL1_AES_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_SHA1_MASK    (0xFU)
#define ARM_ID_AA64ISAR0_EL1_SHA2_MASK    (0xFU)
#define ARM_ID_AA64ISAR0_EL1_CRC32_MASK   (0xFU)
#define ARM_ID_AA64ISAR0_EL1_ATOMIC_MASK  (0xFU)
#define ARM_ID_AA64ISAR0_EL1_RDM_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_SHA3_MASK    (0xFU)
#define ARM_ID_AA64ISAR0_EL1_SM3_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_SM4_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_DP_MASK      (0xFU)
#define ARM_ID_AA64ISAR0_EL1_FHM_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_TS_MASK      (0xFU)
#define ARM_ID_AA64ISAR0_EL1_TLB_MASK     (0xFU)
#define ARM_ID_AA64ISAR0_EL1_RNDR_MASK    (0xFU)
 
//
// Bit masks for the ID_AA64ISAR0_EL1 field values.
//
#define ARM_ID_AA64ISAR0_EL1_AES_FEAT_AES_MASK        (0x1U)
#define ARM_ID_AA64ISAR0_EL1_AES_FEAT_PMULL_MASK      (0x2U)
#define ARM_ID_AA64ISAR0_EL1_SHA1_FEAT_SHA1_MASK      (0x1U)
#define ARM_ID_AA64ISAR0_EL1_SHA2_FEAT_SHA256_MASK    (0x1U)
#define ARM_ID_AA64ISAR0_EL1_SHA2_FEAT_SHA512_MASK    (0x2U)
#define ARM_ID_AA64ISAR0_EL1_CRC32_HAVE_CRC32_MASK    (0x1U)
#define ARM_ID_AA64ISAR0_EL1_ATOMIC_FEAT_LSE_MASK     (0x2U)
#define ARM_ID_AA64ISAR0_EL1_RDM_FEAT_RDM_MASK        (0x1U)
#define ARM_ID_AA64ISAR0_EL1_SHA3_FEAT_SHA3_MASK      (0x1U)
#define ARM_ID_AA64ISAR0_EL1_SM3_FEAT_SM3_MASK        (0x1U)
#define ARM_ID_AA64ISAR0_EL1_SM4_FEAT_SM4_MASK        (0x1U)
#define ARM_ID_AA64ISAR0_EL1_DP_FEAT_DOTPROD_MASK     (0x1U)
#define ARM_ID_AA64ISAR0_EL1_FHM_FEAT_FHM_MASK        (0x1U)
#define ARM_ID_AA64ISAR0_EL1_TS_FEAT_FLAGM_MASK       (0x1U)
#define ARM_ID_AA64ISAR0_EL1_TS_FEAT_FLAGM2_MASK      (0x2U)
#define ARM_ID_AA64ISAR0_EL1_TLB_FEAT_TLBIOS_MASK     (0x1U)
#define ARM_ID_AA64ISAR0_EL1_TLB_FEAT_TLBIRANGE_MASK  (0x2U)
#define ARM_ID_AA64ISAR0_EL1_RNDR_FEAT_RNG_MASK       (0x1U)
 
UINT64
EFIAPI
ArmReadIdAA64Isar0Reg (
  VOID
  );
 
#endif // defined (MDE_CPU_AARCH64)
 
#if defined (MDE_CPU_RISCV64)
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
 
VOID
RiscVSetSupervisorScratch (
  IN UINT64
  );
 
UINT64
RiscVGetSupervisorScratch (
  VOID
  );
 
VOID
RiscVSetSupervisorStvec (
  IN UINT64
  );
 
UINT64
RiscVGetSupervisorStvec (
  VOID
  );
 
UINT64
RiscVGetSupervisorTrapCause (
  VOID
  );
 
VOID
RiscVSetSupervisorAddressTranslationRegister (
  IN UINT64
  );
 
UINT64
RiscVGetSupervisorAddressTranslationRegister (
  VOID
  );
 
UINT64
RiscVReadTimer (
  VOID
  );
 
VOID
RiscVSetSupervisorTimeCompareRegister (
  IN UINT64
  );
 
VOID
RiscVEnableTimerInterrupt (
  VOID
  );
 
VOID
RiscVDisableTimerInterrupt (
  VOID
  );
 
VOID
RiscVClearPendingTimerInterrupt (
  VOID
  );
 
VOID
EFIAPI
RiscVInvalidateInstCacheFenceAsm (
  VOID
  );
 
VOID
EFIAPI
RiscVInvalidateDataCacheFenceAsm (
  VOID
  );
 
VOID
EFIAPI
RiscVCpuCacheFlushCmoAsm (
  IN UINTN
  );
 
VOID
EFIAPI
RiscVCpuCacheCleanCmoAsm (
  IN UINTN
  );
 
VOID
EFIAPI
RiscVCpuCacheInvalCmoAsm (
  IN UINTN
  );
 
#endif // defined (MDE_CPU_RISCV64)
 
#if defined (MDE_CPU_LOONGARCH64)
typedef struct {
  UINT64    S0;
  UINT64    S1;
  UINT64    S2;
  UINT64    S3;
  UINT64    S4;
  UINT64    S5;
  UINT64    S6;
  UINT64    S7;
  UINT64    S8;
  UINT64    SP;
  UINT64    FP;
  UINT64    RA;
} BASE_LIBRARY_JUMP_BUFFER;
 
#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT  8
 
/*
 * Set the exception base address for LoongArch.
 *
 * @param  ExceptionBaseAddress   The exception base address, must be aligned greater than or qeual to 4K .
 */
VOID
SetExceptionBaseAddress (
  IN UINT64
  );
 
/*
 * Set the TlbRebase address for LoongArch.
 *
 * @param  TlbRebaseAddress   The TlbRebase address, must be aligned greater than or qeual to 4K .
 */
VOID
SetTlbRebaseAddress (
  IN UINT64
  );
 
VOID
EnableLocalInterrupts (
  IN UINT16
  );
 
VOID
DisableLocalInterrupts (
  IN UINT16
  );
 
VOID
AsmCpucfg (
  IN  UINT32  Index,
  OUT UINT32  *Data
  );
 
UINTN
AsmReadStableCounter (
  VOID
  );
 
UINTN
CsrRead (
  IN UINT16  Select
  );
 
UINTN
CsrWrite (
  IN UINT16  Select,
  IN UINTN   Value
  );
 
UINTN
CsrXChg (
  IN UINT16  Select,
  IN UINTN   Value,
  IN UINTN   Mask
  );
 
UINT8
IoCsrRead8 (
  IN UINTN  Select
  );
 
UINT16
IoCsrRead16 (
  IN UINTN  Select
  );
 
UINT32
IoCsrRead32 (
  IN UINTN  Select
  );
 
UINT64
IoCsrRead64 (
  IN UINTN  Select
  );
 
VOID
IoCsrWrite8 (
  IN UINTN  Select,
  IN UINT8  Value
  );
 
VOID
IoCsrWrite16 (
  IN UINTN   Select,
  IN UINT16  Value
  );
 
VOID
IoCsrWrite32 (
  IN UINTN   Select,
  IN UINT32  Value
  );
 
VOID
IoCsrWrite64 (
  IN UINTN   Select,
  IN UINT64  Value
  );
 
#endif // defined (MDE_CPU_LOONGARCH64)
 
//
// String Services
//
 
UINTN
EFIAPI
StrnLenS (
  IN CONST CHAR16  *String,
  IN UINTN         MaxSize
  );
 
UINTN
EFIAPI
StrnSizeS (
  IN CONST CHAR16  *String,
  IN UINTN         MaxSize
  );
 
RETURN_STATUS
EFIAPI
StrCpyS (
  OUT CHAR16        *Destination,
  IN  UINTN         DestMax,
  IN  CONST CHAR16  *Source
  );
 
RETURN_STATUS
EFIAPI
StrnCpyS (
  OUT CHAR16        *Destination,
  IN  UINTN         DestMax,
  IN  CONST CHAR16  *Source,
  IN  UINTN         Length
  );
 
RETURN_STATUS
EFIAPI
StrCatS (
  IN OUT CHAR16        *Destination,
  IN     UINTN         DestMax,
  IN     CONST CHAR16  *Source
  );
 
RETURN_STATUS
EFIAPI
StrnCatS (
  IN OUT CHAR16        *Destination,
  IN     UINTN         DestMax,
  IN     CONST CHAR16  *Source,
  IN     UINTN         Length
  );
 
RETURN_STATUS
EFIAPI
StrDecimalToUintnS (
  IN  CONST CHAR16  *String,
  OUT       CHAR16  **EndPointer   OPTIONAL,
  OUT       UINTN   *Data
  );
 
RETURN_STATUS
EFIAPI
StrDecimalToUint64S (
  IN  CONST CHAR16  *String,
  OUT       CHAR16  **EndPointer   OPTIONAL,
  OUT       UINT64  *Data
  );
 
RETURN_STATUS
EFIAPI
StrHexToUintnS (
  IN  CONST CHAR16  *String,
  OUT       CHAR16  **EndPointer   OPTIONAL,
  OUT       UINTN   *Data
  );
 
RETURN_STATUS
EFIAPI
StrHexToUint64S (
  IN  CONST CHAR16  *String,
  OUT       CHAR16  **EndPointer   OPTIONAL,
  OUT       UINT64  *Data
  );
 
UINTN
EFIAPI
AsciiStrnLenS (
  IN CONST CHAR8  *String,
  IN UINTN        MaxSize
  );
 
UINTN
EFIAPI
AsciiStrnSizeS (
  IN CONST CHAR8  *String,
  IN UINTN        MaxSize
  );
 
RETURN_STATUS
EFIAPI
AsciiStrCpyS (
  OUT CHAR8        *Destination,
  IN  UINTN        DestMax,
  IN  CONST CHAR8  *Source
  );
 
RETURN_STATUS
EFIAPI
AsciiStrnCpyS (
  OUT CHAR8        *Destination,
  IN  UINTN        DestMax,
  IN  CONST CHAR8  *Source,
  IN  UINTN        Length
  );
 
RETURN_STATUS
EFIAPI
AsciiStrCatS (
  IN OUT CHAR8        *Destination,
  IN     UINTN        DestMax,
  IN     CONST CHAR8  *Source
  );
 
RETURN_STATUS
EFIAPI
AsciiStrnCatS (
  IN OUT CHAR8        *Destination,
  IN     UINTN        DestMax,
  IN     CONST CHAR8  *Source,
  IN     UINTN        Length
  );
 
RETURN_STATUS
EFIAPI
AsciiStrDecimalToUintnS (
  IN  CONST CHAR8  *String,
  OUT       CHAR8  **EndPointer   OPTIONAL,
  OUT       UINTN  *Data
  );
 
RETURN_STATUS
EFIAPI
AsciiStrDecimalToUint64S (
  IN  CONST CHAR8   *String,
  OUT       CHAR8   **EndPointer   OPTIONAL,
  OUT       UINT64  *Data
  );
 
RETURN_STATUS
EFIAPI
AsciiStrHexToUintnS (
  IN  CONST CHAR8  *String,
  OUT       CHAR8  **EndPointer   OPTIONAL,
  OUT       UINTN  *Data
  );
 
RETURN_STATUS
EFIAPI
AsciiStrHexToUint64S (
  IN  CONST CHAR8   *String,
  OUT       CHAR8   **EndPointer   OPTIONAL,
  OUT       UINT64  *Data
  );
 
UINTN
EFIAPI
StrLen (
  IN      CONST CHAR16  *String
  );
 
UINTN
EFIAPI
StrSize (
  IN      CONST CHAR16  *String
  );
 
INTN
EFIAPI
StrCmp (
  IN      CONST CHAR16  *FirstString,
  IN      CONST CHAR16  *SecondString
  );
 
INTN
EFIAPI
StrnCmp (
  IN      CONST CHAR16  *FirstString,
  IN      CONST CHAR16  *SecondString,
  IN      UINTN         Length
  );
 
CHAR16 *
EFIAPI
StrStr (
  IN      CONST CHAR16  *String,
  IN      CONST CHAR16  *SearchString
  );
 
UINTN
EFIAPI
StrDecimalToUintn (
  IN      CONST CHAR16  *String
  );
 
UINT64
EFIAPI
StrDecimalToUint64 (
  IN      CONST CHAR16  *String
  );
 
UINTN
EFIAPI
StrHexToUintn (
  IN      CONST CHAR16  *String
  );
 
UINT64
EFIAPI
StrHexToUint64 (
  IN      CONST CHAR16  *String
  );
 
RETURN_STATUS
EFIAPI
StrToIpv6Address (
  IN  CONST CHAR16  *String,
  OUT CHAR16        **EndPointer  OPTIONAL,
  OUT IPv6_ADDRESS  *Address,
  OUT UINT8         *PrefixLength OPTIONAL
  );
 
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
 
RETURN_STATUS
EFIAPI
StrToGuid (
  IN  CONST CHAR16  *String,
  OUT GUID          *Guid
  );
 
RETURN_STATUS
EFIAPI
StrHexToBytes (
  IN  CONST CHAR16  *String,
  IN  UINTN         Length,
  OUT UINT8         *Buffer,
  IN  UINTN         MaxBufferSize
  );
 
RETURN_STATUS
EFIAPI
UnicodeStrToAsciiStrS (
  IN      CONST CHAR16  *Source,
  OUT     CHAR8         *Destination,
  IN      UINTN         DestMax
  );
 
RETURN_STATUS
EFIAPI
UnicodeStrnToAsciiStrS (
  IN      CONST CHAR16  *Source,
  IN      UINTN         Length,
  OUT     CHAR8         *Destination,
  IN      UINTN         DestMax,
  OUT     UINTN         *DestinationLength
  );
 
UINTN
EFIAPI
AsciiStrLen (
  IN      CONST CHAR8  *String
  );
 
UINTN
EFIAPI
AsciiStrSize (
  IN      CONST CHAR8  *String
  );
 
INTN
EFIAPI
AsciiStrCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString
  );
 
INTN
EFIAPI
AsciiStriCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString
  );
 
INTN
EFIAPI
AsciiStrnCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString,
  IN      UINTN        Length
  );
 
CHAR8 *
EFIAPI
AsciiStrStr (
  IN      CONST CHAR8  *String,
  IN      CONST CHAR8  *SearchString
  );
 
UINTN
EFIAPI
AsciiStrDecimalToUintn (
  IN      CONST CHAR8  *String
  );
 
UINT64
EFIAPI
AsciiStrDecimalToUint64 (
  IN      CONST CHAR8  *String
  );
 
UINTN
EFIAPI
AsciiStrHexToUintn (
  IN      CONST CHAR8  *String
  );
 
UINT64
EFIAPI
AsciiStrHexToUint64 (
  IN      CONST CHAR8  *String
  );
 
RETURN_STATUS
EFIAPI
AsciiStrToIpv6Address (
  IN  CONST CHAR8   *String,
  OUT CHAR8         **EndPointer  OPTIONAL,
  OUT IPv6_ADDRESS  *Address,
  OUT UINT8         *PrefixLength OPTIONAL
  );
 
RETURN_STATUS
EFIAPI
AsciiStrToIpv4Address (
  IN  CONST CHAR8   *String,
  OUT CHAR8         **EndPointer  OPTIONAL,
  OUT IPv4_ADDRESS  *Address,
  OUT UINT8         *PrefixLength OPTIONAL
  );
 
RETURN_STATUS
EFIAPI
AsciiStrToGuid (
  IN  CONST CHAR8  *String,
  OUT GUID         *Guid
  );
 
RETURN_STATUS
EFIAPI
AsciiStrHexToBytes (
  IN  CONST CHAR8  *String,
  IN  UINTN        Length,
  OUT UINT8        *Buffer,
  IN  UINTN        MaxBufferSize
  );
 
RETURN_STATUS
EFIAPI
AsciiStrToUnicodeStrS (
  IN      CONST CHAR8  *Source,
  OUT     CHAR16       *Destination,
  IN      UINTN        DestMax
  );
 
RETURN_STATUS
EFIAPI
AsciiStrnToUnicodeStrS (
  IN      CONST CHAR8  *Source,
  IN      UINTN        Length,
  OUT     CHAR16       *Destination,
  IN      UINTN        DestMax,
  OUT     UINTN        *DestinationLength
  );
 
CHAR16
EFIAPI
CharToUpper (
  IN      CHAR16  Char
  );
 
CHAR8
EFIAPI
AsciiCharToUpper (
  IN      CHAR8  Chr
  );
 
RETURN_STATUS
EFIAPI
Base64Encode (
  IN  CONST UINT8  *Source,
  IN        UINTN  SourceLength,
  OUT       CHAR8  *Destination  OPTIONAL,
  IN OUT    UINTN  *DestinationSize
  );
 
RETURN_STATUS
EFIAPI
Base64Decode (
  IN     CONST CHAR8  *Source          OPTIONAL,
  IN     UINTN        SourceSize,
  OUT    UINT8        *Destination     OPTIONAL,
  IN OUT UINTN        *DestinationSize
  );
 
UINT8
EFIAPI
DecimalToBcd8 (
  IN      UINT8  Value
  );
 
UINT8
EFIAPI
BcdToDecimal8 (
  IN      UINT8  Value
  );
 
//
//  File Path Manipulation Functions
//
 
BOOLEAN
EFIAPI
PathRemoveLastItem (
  IN OUT CHAR16  *Path
  );
 
CHAR16 *
EFIAPI
PathCleanUpDirectories (
  IN CHAR16  *Path
  );
 
//
// Linked List Functions and Macros
//
 
#define INITIALIZE_LIST_HEAD_VARIABLE(ListHead)  {&(ListHead), &(ListHead)}
 
#define BASE_LIST_FOR_EACH(Entry, ListHead)    \
  for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)
 
#define BASE_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead)            \
  for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink;\
      Entry != (ListHead); Entry = NextEntry, NextEntry = Entry->ForwardLink)
 
BOOLEAN
EFIAPI
IsNodeInList (
  IN      CONST LIST_ENTRY  *FirstEntry,
  IN      CONST LIST_ENTRY  *SecondEntry
  );
 
LIST_ENTRY *
EFIAPI
InitializeListHead (
  IN OUT  LIST_ENTRY  *ListHead
  );
 
LIST_ENTRY *
EFIAPI
InsertHeadList (
  IN OUT  LIST_ENTRY  *ListHead,
  IN OUT  LIST_ENTRY  *Entry
  );
 
LIST_ENTRY *
EFIAPI
InsertTailList (
  IN OUT  LIST_ENTRY  *ListHead,
  IN OUT  LIST_ENTRY  *Entry
  );
 
LIST_ENTRY *
EFIAPI
GetFirstNode (
  IN      CONST LIST_ENTRY  *List
  );
 
LIST_ENTRY *
EFIAPI
GetNextNode (
  IN      CONST LIST_ENTRY  *List,
  IN      CONST LIST_ENTRY  *Node
  );
 
LIST_ENTRY *
EFIAPI
GetPreviousNode (
  IN      CONST LIST_ENTRY  *List,
  IN      CONST LIST_ENTRY  *Node
  );
 
BOOLEAN
EFIAPI
IsListEmpty (
  IN      CONST LIST_ENTRY  *ListHead
  );
 
BOOLEAN
EFIAPI
IsNull (
  IN      CONST LIST_ENTRY  *List,
  IN      CONST LIST_ENTRY  *Node
  );
 
BOOLEAN
EFIAPI
IsNodeAtEnd (
  IN      CONST LIST_ENTRY  *List,
  IN      CONST LIST_ENTRY  *Node
  );
 
LIST_ENTRY *
EFIAPI
SwapListEntries (
  IN OUT  LIST_ENTRY  *FirstEntry,
  IN OUT  LIST_ENTRY  *SecondEntry
  );
 
LIST_ENTRY *
EFIAPI
RemoveEntryList (
  IN      CONST LIST_ENTRY  *Entry
  );
 
//
// Math Services
//
 
typedef
INTN
(EFIAPI *BASE_SORT_COMPARE)(
  IN CONST VOID                 *Buffer1,
  IN CONST VOID                 *Buffer2
  );
 
VOID
EFIAPI
QuickSort (
  IN OUT VOID                 *BufferToSort,
  IN CONST UINTN              Count,
  IN CONST UINTN              ElementSize,
  IN       BASE_SORT_COMPARE  CompareFunction,
  OUT VOID                    *BufferOneElement
  );
 
UINT64
EFIAPI
LShiftU64 (
  IN      UINT64  Operand,
  IN      UINTN   Count
  );
 
UINT64
EFIAPI
RShiftU64 (
  IN      UINT64  Operand,
  IN      UINTN   Count
  );
 
UINT64
EFIAPI
ARShiftU64 (
  IN      UINT64  Operand,
  IN      UINTN   Count
  );
 
UINT32
EFIAPI
LRotU32 (
  IN      UINT32  Operand,
  IN      UINTN   Count
  );
 
UINT32
EFIAPI
RRotU32 (
  IN      UINT32  Operand,
  IN      UINTN   Count
  );
 
UINT64
EFIAPI
LRotU64 (
  IN      UINT64  Operand,
  IN      UINTN   Count
  );
 
UINT64
EFIAPI
RRotU64 (
  IN      UINT64  Operand,
  IN      UINTN   Count
  );
 
INTN
EFIAPI
LowBitSet32 (
  IN      UINT32  Operand
  );
 
INTN
EFIAPI
LowBitSet64 (
  IN      UINT64  Operand
  );
 
INTN
EFIAPI
HighBitSet32 (
  IN      UINT32  Operand
  );
 
INTN
EFIAPI
HighBitSet64 (
  IN      UINT64  Operand
  );
 
UINT32
EFIAPI
GetPowerOfTwo32 (
  IN      UINT32  Operand
  );
 
UINT64
EFIAPI
GetPowerOfTwo64 (
  IN      UINT64  Operand
  );
 
UINT16
EFIAPI
SwapBytes16 (
  IN      UINT16  Value
  );
 
UINT32
EFIAPI
SwapBytes32 (
  IN      UINT32  Value
  );
 
UINT64
EFIAPI
SwapBytes64 (
  IN      UINT64  Value
  );
 
UINT64
EFIAPI
MultU64x32 (
  IN      UINT64  Multiplicand,
  IN      UINT32  Multiplier
  );
 
UINT64
EFIAPI
MultU64x64 (
  IN      UINT64  Multiplicand,
  IN      UINT64  Multiplier
  );
 
INT64
EFIAPI
MultS64x64 (
  IN      INT64  Multiplicand,
  IN      INT64  Multiplier
  );
 
UINT64
EFIAPI
DivU64x32 (
  IN      UINT64  Dividend,
  IN      UINT32  Divisor
  );
 
UINT32
EFIAPI
ModU64x32 (
  IN      UINT64  Dividend,
  IN      UINT32  Divisor
  );
 
UINT64
EFIAPI
DivU64x32Remainder (
  IN      UINT64  Dividend,
  IN      UINT32  Divisor,
  OUT     UINT32  *Remainder  OPTIONAL
  );
 
UINT64
EFIAPI
DivU64x64Remainder (
  IN      UINT64  Dividend,
  IN      UINT64  Divisor,
  OUT     UINT64  *Remainder  OPTIONAL
  );
 
INT64
EFIAPI
DivS64x64Remainder (
  IN      INT64  Dividend,
  IN      INT64  Divisor,
  OUT     INT64  *Remainder  OPTIONAL
  );
 
UINT16
EFIAPI
ReadUnaligned16 (
  IN CONST VOID  *Buffer
  );
 
UINT16
EFIAPI
WriteUnaligned16 (
  OUT VOID    *Buffer,
  IN  UINT16  Value
  );
 
UINT32
EFIAPI
ReadUnaligned24 (
  IN CONST VOID  *Buffer
  );
 
UINT32
EFIAPI
WriteUnaligned24 (
  OUT VOID    *Buffer,
  IN  UINT32  Value
  );
 
UINT32
EFIAPI
ReadUnaligned32 (
  IN CONST VOID  *Buffer
  );
 
UINT32
EFIAPI
WriteUnaligned32 (
  OUT VOID    *Buffer,
  IN  UINT32  Value
  );
 
UINT64
EFIAPI
ReadUnaligned64 (
  IN CONST VOID  *Buffer
  );
 
UINT64
EFIAPI
WriteUnaligned64 (
  OUT VOID    *Buffer,
  IN  UINT64  Value
  );
 
//
// Bit Field Functions
//
 
UINT8
EFIAPI
BitFieldRead8 (
  IN      UINT8  Operand,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  );
 
UINT8
EFIAPI
BitFieldWrite8 (
  IN      UINT8  Operand,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  Value
  );
 
UINT8
EFIAPI
BitFieldOr8 (
  IN      UINT8  Operand,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  OrData
  );
 
UINT8
EFIAPI
BitFieldAnd8 (
  IN      UINT8  Operand,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData
  );
 
UINT8
EFIAPI
BitFieldAndThenOr8 (
  IN      UINT8  Operand,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData,
  IN      UINT8  OrData
  );
 
UINT16
EFIAPI
BitFieldRead16 (
  IN      UINT16  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit
  );
 
UINT16
EFIAPI
BitFieldWrite16 (
  IN      UINT16  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  Value
  );
 
UINT16
EFIAPI
BitFieldOr16 (
  IN      UINT16  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  OrData
  );
 
UINT16
EFIAPI
BitFieldAnd16 (
  IN      UINT16  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData
  );
 
UINT16
EFIAPI
BitFieldAndThenOr16 (
  IN      UINT16  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData,
  IN      UINT16  OrData
  );
 
UINT32
EFIAPI
BitFieldRead32 (
  IN      UINT32  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit
  );
 
UINT32
EFIAPI
BitFieldWrite32 (
  IN      UINT32  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  Value
  );
 
UINT32
EFIAPI
BitFieldOr32 (
  IN      UINT32  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  OrData
  );
 
UINT32
EFIAPI
BitFieldAnd32 (
  IN      UINT32  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData
  );
 
UINT32
EFIAPI
BitFieldAndThenOr32 (
  IN      UINT32  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  );
 
UINT64
EFIAPI
BitFieldRead64 (
  IN      UINT64  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit
  );
 
UINT64
EFIAPI
BitFieldWrite64 (
  IN      UINT64  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  Value
  );
 
UINT64
EFIAPI
BitFieldOr64 (
  IN      UINT64  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  OrData
  );
 
UINT64
EFIAPI
BitFieldAnd64 (
  IN      UINT64  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  AndData
  );
 
UINT64
EFIAPI
BitFieldAndThenOr64 (
  IN      UINT64  Operand,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  AndData,
  IN      UINT64  OrData
  );
 
UINT8
EFIAPI
BitFieldCountOnes32 (
  IN       UINT32  Operand,
  IN       UINTN   StartBit,
  IN       UINTN   EndBit
  );
 
UINT8
EFIAPI
BitFieldCountOnes64 (
  IN       UINT64  Operand,
  IN       UINTN   StartBit,
  IN       UINTN   EndBit
  );
 
/*******************************************************************************
 
  UUID (Universally Unique IDentifier), as defined in RFC4122
  (https://datatracker.ietf.org/doc/html/rfc4122#section-4.1), is a 128-bit number
  used to uniquely identify information in computer systems.
 
  UUIDs contains 5 fields:
  - time_low: 32 bits
  - time_mid: 16 bits
  - time_hi_and_version: 16 bits
  - clock_seq_hi_and_reserved: 8 bits
  - clock_seq_low: 8 bits
  - node: 8 bits * 6
 
  Each field encoded with the Most Significant Byte first (known as network byte
  order, or big-endian).
 
  GUID (Globally Unique Identifier), on the other hand, is a 128-bit number used
  in UEFI environments, which is similar to UUID but has a different byte order
  in memory. See https://uefi.org/specs/UEFI/2.11/Apx_A_GUID_and_Time_Formats.html
 
  GUID also contains 5 fields:
  - TimeLow: 32 bits
  - TimeMid: 16 bits
  - TimeHiAndVersion: 16 bits
  - ClockSeqHighAndReserved: 16 bits
  - ClockSeqLow: 8 bits
  - Node: 8 bits * 6
 
  TimeLow, TimeMid, TimeHighAndVersion fields in the EFI are encoded with the Least
  Significant Byte first (also known as little-endian).
 
  Example:
  Consider the same string representation/registry format for MM communication v2:
  "378daedc-f06b-4446-8314-40ab933c87a3"
 
  In UUID format, it is represented as:
  - Data fields:
    - time_low: 0x37 0x8d 0xae 0xdc (0x378daedc in big-endian)
    - time_mid: 0xf0 0x6b (0xf06b in big-endian)
    - time_hi_and_version: 0x44 0x46 (0x4446 in big-endian)
    - clock_seq_hi_and_reserved: 0x83
    - clock_seq_low: 0x14
    - node: 0x00, 0xab, 0x93, 0x3c, 0x87, 0xa3
  - Byte representation in memory:
    - 37 8d ae dc f0 6b 44 46 83 14 40 ab 93 3c 87 a3
 
  However, in GUID format, it is represented as:
  - Data fields:
    - TimeLow: 0xdc 0xae 0x8d 0x37 (0x378daedc in little-endian)
    - TimeMid: 0x6b 0xf0 (0xf06b in little-endian)
    - TimeHiAndVersion: 0x46 0x44 (0x4446 in little-endian)
    - ClockSeqHighAndReserved: 0x83
    - ClockSeqLow: 0x14
    - Node: 0x00, 0xab, 0x93, 0x3c, 0x87, 0xa3
  - Byte representation in memory:
    - dc ae 8d 37 6b f0 46 44 83 14 40 ab 93 3c 87 a3
 
*******************************************************************************/
 
VOID
EFIAPI
ConvertGuidToUuid (
  IN   GUID  *FromGuid,
  OUT  GUID  *ToUuid
  );
 
VOID
EFIAPI
ConvertUuidToGuid (
  IN   GUID  *FromUuid,
  OUT  GUID  *ToGuid
  );
 
//
// Base Library Checksum Functions
//
 
UINT8
EFIAPI
CalculateSum8 (
  IN      CONST UINT8  *Buffer,
  IN      UINTN        Length
  );
 
UINT8
EFIAPI
CalculateCheckSum8 (
  IN      CONST UINT8  *Buffer,
  IN      UINTN        Length
  );
 
UINT16
EFIAPI
CalculateSum16 (
  IN      CONST UINT16  *Buffer,
  IN      UINTN         Length
  );
 
UINT16
EFIAPI
CalculateCheckSum16 (
  IN      CONST UINT16  *Buffer,
  IN      UINTN         Length
  );
 
UINT32
EFIAPI
CalculateSum32 (
  IN      CONST UINT32  *Buffer,
  IN      UINTN         Length
  );
 
UINT32
EFIAPI
CalculateCheckSum32 (
  IN      CONST UINT32  *Buffer,
  IN      UINTN         Length
  );
 
UINT64
EFIAPI
CalculateSum64 (
  IN      CONST UINT64  *Buffer,
  IN      UINTN         Length
  );
 
UINT64
EFIAPI
CalculateCheckSum64 (
  IN      CONST UINT64  *Buffer,
  IN      UINTN         Length
  );
 
UINT32
EFIAPI
CalculateCrc32 (
  IN  VOID   *Buffer,
  IN  UINTN  Length
  );
 
UINT16
EFIAPI
CalculateCrc16Ansi (
  IN  CONST VOID  *Buffer,
  IN  UINTN       Length,
  IN  UINT16      InitialValue
  );
 
//
// Initial value for the CRC16-ANSI algorithm, when no prior checksum has been calculated.
//
#define CRC16ANSI_INIT  0xffff
 
UINT32
EFIAPI
CalculateCrc32c (
  IN CONST VOID  *Buffer,
  IN UINTN       Length,
  IN UINT32      InitialValue
  );
 
UINT16
EFIAPI
CalculateCrc16CcittF (
  IN CONST VOID  *Buffer,
  IN UINTN       Length,
  IN UINT16      InitialValue
  );
 
//
// Base Library CPU Functions
//
 
typedef
VOID
(EFIAPI *SWITCH_STACK_ENTRY_POINT)(
  IN      VOID                      *Context1   OPTIONAL,
  IN      VOID                      *Context2   OPTIONAL
  );
 
VOID
EFIAPI
MemoryFence (
  VOID
  );
 
RETURNS_TWICE
UINTN
EFIAPI
SetJump (
  OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
  );
 
VOID
EFIAPI
LongJump (
  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
  IN      UINTN                     Value
  );
 
VOID
EFIAPI
EnableInterrupts (
  VOID
  );
 
VOID
EFIAPI
DisableInterrupts (
  VOID
  );
 
BOOLEAN
EFIAPI
SaveAndDisableInterrupts (
  VOID
  );
 
VOID
EFIAPI
EnableDisableInterrupts (
  VOID
  );
 
BOOLEAN
EFIAPI
GetInterruptState (
  VOID
  );
 
BOOLEAN
EFIAPI
SetInterruptState (
  IN      BOOLEAN  InterruptState
  );
 
VOID
EFIAPI
CpuPause (
  VOID
  );
 
VOID
EFIAPI
SwitchStack (
  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
  IN      VOID                      *Context1   OPTIONAL,
  IN      VOID                      *Context2   OPTIONAL,
  IN      VOID                      *NewStack,
  ...
  );
 
VOID
EFIAPI
CpuBreakpoint (
  VOID
  );
 
VOID
EFIAPI
CpuDeadLoop (
  VOID
  );
 
VOID
EFIAPI
SpeculationBarrier (
  VOID
  );
 
UINTN
EFIAPI
TdCall (
  IN UINT64    Leaf,
  IN UINT64    Arg1,
  IN UINT64    Arg2,
  IN UINT64    Arg3,
  IN OUT VOID  *Results
  );
 
UINTN
EFIAPI
TdVmCall (
  IN UINT64    Leaf,
  IN UINT64    Arg1,
  IN UINT64    Arg2,
  IN UINT64    Arg3,
  IN UINT64    Arg4,
  IN OUT VOID  *Results
  );
 
BOOLEAN
EFIAPI
TdIsEnabled (
  VOID
  );
 
BOOLEAN
EFIAPI
SevGuestIsEnabled (
  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
 
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
 
UINT32
EFIAPI
AsmRmpAdjust (
  IN      UINT64  Rax,
  IN      UINT64  Rcx,
  IN      UINT64  Rdx
  );
 
#endif
 
#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
typedef union {
  struct {
    UINT32    CF         : 1; 
    UINT32    Reserved_0 : 1; 
    UINT32    PF         : 1; 
    UINT32    Reserved_1 : 1; 
    UINT32    AF         : 1; 
    UINT32    Reserved_2 : 1; 
    UINT32    ZF         : 1; 
    UINT32    SF         : 1; 
    UINT32    TF         : 1; 
    UINT32    IF         : 1; 
    UINT32    DF         : 1; 
    UINT32    OF         : 1; 
    UINT32    IOPL       : 2; 
    UINT32    NT         : 1; 
    UINT32    Reserved_3 : 1; 
  } Bits;
  UINT16    Uint16;
} IA32_FLAGS16;
 
typedef union {
  struct {
    UINT32    CF         : 1;  
    UINT32    Reserved_0 : 1;  
    UINT32    PF         : 1;  
    UINT32    Reserved_1 : 1;  
    UINT32    AF         : 1;  
    UINT32    Reserved_2 : 1;  
    UINT32    ZF         : 1;  
    UINT32    SF         : 1;  
    UINT32    TF         : 1;  
    UINT32    IF         : 1;  
    UINT32    DF         : 1;  
    UINT32    OF         : 1;  
    UINT32    IOPL       : 2;  
    UINT32    NT         : 1;  
    UINT32    Reserved_3 : 1;  
    UINT32    RF         : 1;  
    UINT32    VM         : 1;  
    UINT32    AC         : 1;  
    UINT32    VIF        : 1;  
    UINT32    VIP        : 1;  
    UINT32    ID         : 1;  
    UINT32    Reserved_4 : 10; 
  } Bits;
  UINTN    UintN;
} IA32_EFLAGS32;
 
typedef union {
  struct {
    UINT32    PE         : 1;  
    UINT32    MP         : 1;  
    UINT32    EM         : 1;  
    UINT32    TS         : 1;  
    UINT32    ET         : 1;  
    UINT32    NE         : 1;  
    UINT32    Reserved_0 : 10; 
    UINT32    WP         : 1;  
    UINT32    Reserved_1 : 1;  
    UINT32    AM         : 1;  
    UINT32    Reserved_2 : 10; 
    UINT32    NW         : 1;  
    UINT32    CD         : 1;  
    UINT32    PG         : 1;  
  } Bits;
  UINTN    UintN;
} IA32_CR0;
 
typedef union {
  struct {
    UINT32    VME        : 1; 
    UINT32    PVI        : 1; 
    UINT32    TSD        : 1; 
    UINT32    DE         : 1; 
    UINT32    PSE        : 1; 
    UINT32    PAE        : 1; 
    UINT32    MCE        : 1; 
    UINT32    PGE        : 1; 
    UINT32    PCE        : 1; 
    UINT32    OSFXSR     : 1; 
    UINT32    OSXMMEXCPT : 1; 
    UINT32    UMIP       : 1; 
    UINT32    LA57       : 1; 
    UINT32    VMXE       : 1; 
    UINT32    SMXE       : 1; 
    UINT32    Reserved_3 : 1; 
    UINT32    FSGSBASE   : 1; 
    UINT32    PCIDE      : 1; 
    UINT32    OSXSAVE    : 1; 
    UINT32    Reserved_4 : 1; 
    UINT32    SMEP       : 1; 
    UINT32    SMAP       : 1; 
    UINT32    PKE        : 1; 
    UINT32    Reserved_5 : 9; 
  } Bits;
  UINTN    UintN;
} IA32_CR4;
 
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;
 
  #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)
typedef union {
  struct {
    UINT32    OffsetLow  : 16; 
    UINT32    Selector   : 16; 
    UINT32    Reserved_0 : 8;  
    UINT32    GateType   : 8;  
    UINT32    OffsetHigh : 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; 
    UINT32    BaseLow     : 16; 
    UINT32    BaseMid     : 8;  
    UINT32    Type        : 4;  
    UINT32    Reserved_43 : 1;  
    UINT32    DPL         : 2;  
    UINT32    P           : 1;  
    UINT32    LimitHigh   : 4;  
    UINT32    AVL         : 1;  
    UINT32    Reserved_52 : 2;  
    UINT32    G           : 1;  
    UINT32    BaseHigh    : 8;  
  } Bits;
  UINT64    Uint64;
} IA32_TSS_DESCRIPTOR;
    #pragma pack ()
 
  #endif // defined (MDE_CPU_IA32)
 
  #if defined (MDE_CPU_X64)
typedef union {
  struct {
    UINT32    OffsetLow   : 16; 
    UINT32    Selector    : 16; 
    UINT32    Reserved_0  : 8;  
    UINT32    GateType    : 8;  
    UINT32    OffsetHigh  : 16; 
    UINT32    OffsetUpper : 32; 
    UINT32    Reserved_1  : 32; 
  } 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; 
    UINT32    BaseLow     : 16; 
    UINT32    BaseMidl    : 8;  
    UINT32    Type        : 4;  
    UINT32    Reserved_43 : 1;  
    UINT32    DPL         : 2;  
    UINT32    P           : 1;  
    UINT32    LimitHigh   : 4;  
    UINT32    AVL         : 1;  
    UINT32    Reserved_52 : 2;  
    UINT32    G           : 1;  
    UINT32    BaseMidh    : 8;  
    UINT32    BaseHigh    : 32; 
    UINT32    Reserved_96 : 32; 
  } Bits;
  struct {
    UINT64    Uint64;
    UINT64    Uint64_1;
  } Uint128;
} IA32_TSS_DESCRIPTOR;
    #pragma pack ()
 
  #endif // defined (MDE_CPU_X64)
 
typedef struct {
  UINT8    Buffer[512];
} IA32_FX_BUFFER;
 
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;
 
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
 
typedef VOID (X86_ASSEMBLY_PATCH_LABEL) (
  VOID
  );
 
UINT32
EFIAPI
AsmCpuid (
  IN      UINT32  Index,
  OUT     UINT32  *Eax   OPTIONAL,
  OUT     UINT32  *Ebx   OPTIONAL,
  OUT     UINT32  *Ecx   OPTIONAL,
  OUT     UINT32  *Edx   OPTIONAL
  );
 
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
  );
 
VOID
EFIAPI
AsmDisableCache (
  VOID
  );
 
VOID
EFIAPI
AsmEnableCache (
  VOID
  );
 
UINT32
EFIAPI
AsmReadMsr32 (
  IN      UINT32  Index
  );
 
UINT32
EFIAPI
AsmWriteMsr32 (
  IN      UINT32  Index,
  IN      UINT32  Value
  );
 
UINT32
EFIAPI
AsmMsrOr32 (
  IN      UINT32  Index,
  IN      UINT32  OrData
  );
 
UINT32
EFIAPI
AsmMsrAnd32 (
  IN      UINT32  Index,
  IN      UINT32  AndData
  );
 
UINT32
EFIAPI
AsmMsrAndThenOr32 (
  IN      UINT32  Index,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  );
 
UINT32
EFIAPI
AsmMsrBitFieldRead32 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit
  );
 
UINT32
EFIAPI
AsmMsrBitFieldWrite32 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  Value
  );
 
UINT32
EFIAPI
AsmMsrBitFieldOr32 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  OrData
  );
 
UINT32
EFIAPI
AsmMsrBitFieldAnd32 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData
  );
 
UINT32
EFIAPI
AsmMsrBitFieldAndThenOr32 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  );
 
UINT64
EFIAPI
AsmReadMsr64 (
  IN      UINT32  Index
  );
 
UINT64
EFIAPI
AsmWriteMsr64 (
  IN      UINT32  Index,
  IN      UINT64  Value
  );
 
UINT64
EFIAPI
AsmMsrOr64 (
  IN      UINT32  Index,
  IN      UINT64  OrData
  );
 
UINT64
EFIAPI
AsmMsrAnd64 (
  IN      UINT32  Index,
  IN      UINT64  AndData
  );
 
UINT64
EFIAPI
AsmMsrAndThenOr64 (
  IN      UINT32  Index,
  IN      UINT64  AndData,
  IN      UINT64  OrData
  );
 
UINT64
EFIAPI
AsmMsrBitFieldRead64 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit
  );
 
UINT64
EFIAPI
AsmMsrBitFieldWrite64 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  Value
  );
 
UINT64
EFIAPI
AsmMsrBitFieldOr64 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  OrData
  );
 
UINT64
EFIAPI
AsmMsrBitFieldAnd64 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  AndData
  );
 
UINT64
EFIAPI
AsmMsrBitFieldAndThenOr64 (
  IN      UINT32  Index,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT64  AndData,
  IN      UINT64  OrData
  );
 
UINTN
EFIAPI
AsmReadEflags (
  VOID
  );
 
UINTN
EFIAPI
AsmReadCr0 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadCr2 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadCr3 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadCr4 (
  VOID
  );
 
UINTN
EFIAPI
AsmWriteCr0 (
  UINTN  Cr0
  );
 
UINTN
EFIAPI
AsmWriteCr2 (
  UINTN  Cr2
  );
 
UINTN
EFIAPI
AsmWriteCr3 (
  UINTN  Cr3
  );
 
UINTN
EFIAPI
AsmWriteCr4 (
  UINTN  Cr4
  );
 
UINTN
EFIAPI
AsmReadDr0 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr1 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr2 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr3 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr4 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr5 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr6 (
  VOID
  );
 
UINTN
EFIAPI
AsmReadDr7 (
  VOID
  );
 
UINTN
EFIAPI
AsmWriteDr0 (
  UINTN  Dr0
  );
 
UINTN
EFIAPI
AsmWriteDr1 (
  UINTN  Dr1
  );
 
UINTN
EFIAPI
AsmWriteDr2 (
  UINTN  Dr2
  );
 
UINTN
EFIAPI
AsmWriteDr3 (
  UINTN  Dr3
  );
 
UINTN
EFIAPI
AsmWriteDr4 (
  UINTN  Dr4
  );
 
UINTN
EFIAPI
AsmWriteDr5 (
  UINTN  Dr5
  );
 
UINTN
EFIAPI
AsmWriteDr6 (
  UINTN  Dr6
  );
 
UINTN
EFIAPI
AsmWriteDr7 (
  UINTN  Dr7
  );
 
UINT16
EFIAPI
AsmReadCs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadDs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadEs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadFs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadGs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadSs (
  VOID
  );
 
UINT16
EFIAPI
AsmReadTr (
  VOID
  );
 
VOID
EFIAPI
AsmReadGdtr (
  OUT     IA32_DESCRIPTOR  *Gdtr
  );
 
VOID
EFIAPI
AsmWriteGdtr (
  IN      CONST IA32_DESCRIPTOR  *Gdtr
  );
 
VOID
EFIAPI
AsmReadIdtr (
  OUT     IA32_DESCRIPTOR  *Idtr
  );
 
VOID
EFIAPI
AsmWriteIdtr (
  IN      CONST IA32_DESCRIPTOR  *Idtr
  );
 
UINT16
EFIAPI
AsmReadLdtr (
  VOID
  );
 
VOID
EFIAPI
AsmWriteLdtr (
  IN      UINT16  Ldtr
  );
 
VOID
EFIAPI
AsmFxSave (
  OUT     IA32_FX_BUFFER  *Buffer
  );
 
VOID
EFIAPI
AsmFxRestore (
  IN      CONST IA32_FX_BUFFER  *Buffer
  );
 
UINT64
EFIAPI
AsmReadMm0 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm1 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm2 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm3 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm4 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm5 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm6 (
  VOID
  );
 
UINT64
EFIAPI
AsmReadMm7 (
  VOID
  );
 
VOID
EFIAPI
AsmWriteMm0 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm1 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm2 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm3 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm4 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm5 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm6 (
  IN      UINT64  Value
  );
 
VOID
EFIAPI
AsmWriteMm7 (
  IN      UINT64  Value
  );
 
UINT64
EFIAPI
AsmReadTsc (
  VOID
  );
 
UINT64
EFIAPI
AsmReadPmc (
  IN      UINT32  Index
  );
 
UINTN
EFIAPI
AsmMonitor (
  IN      UINTN  Eax,
  IN      UINTN  Ecx,
  IN      UINTN  Edx
  );
 
UINTN
EFIAPI
AsmMwait (
  IN      UINTN  Eax,
  IN      UINTN  Ecx
  );
 
VOID
EFIAPI
AsmWbinvd (
  VOID
  );
 
VOID
EFIAPI
AsmInvd (
  VOID
  );
 
VOID *
EFIAPI
AsmFlushCacheLine (
  IN      VOID  *LinearAddress
  );
 
VOID
EFIAPI
AsmEnablePaging32 (
  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
  IN      VOID                      *Context1   OPTIONAL,
  IN      VOID                      *Context2   OPTIONAL,
  IN      VOID                      *NewStack
  );
 
VOID
EFIAPI
AsmDisablePaging32 (
  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
  IN      VOID                      *Context1   OPTIONAL,
  IN      VOID                      *Context2   OPTIONAL,
  IN      VOID                      *NewStack
  );
 
VOID
EFIAPI
AsmEnablePaging64 (
  IN      UINT16  Cs,
  IN      UINT64  EntryPoint,
  IN      UINT64  Context1   OPTIONAL,
  IN      UINT64  Context2   OPTIONAL,
  IN      UINT64  NewStack
  );
 
VOID
EFIAPI
AsmDisablePaging64 (
  IN      UINT16  Cs,
  IN      UINT32  EntryPoint,
  IN      UINT32  Context1   OPTIONAL,
  IN      UINT32  Context2   OPTIONAL,
  IN      UINT32  NewStack
  );
 
//
// 16-bit thunking services
//
 
VOID
EFIAPI
AsmGetThunk16Properties (
  OUT     UINT32  *RealModeBufferSize,
  OUT     UINT32  *ExtraStackSize
  );
 
VOID
EFIAPI
AsmPrepareThunk16 (
  IN OUT  THUNK_CONTEXT  *ThunkContext
  );
 
VOID
EFIAPI
AsmThunk16 (
  IN OUT  THUNK_CONTEXT  *ThunkContext
  );
 
VOID
EFIAPI
AsmPrepareAndThunk16 (
  IN OUT  THUNK_CONTEXT  *ThunkContext
  );
 
BOOLEAN
EFIAPI
AsmRdRand16 (
  OUT     UINT16  *Rand
  );
 
BOOLEAN
EFIAPI
AsmRdRand32 (
  OUT     UINT32  *Rand
  );
 
BOOLEAN
EFIAPI
AsmRdRand64  (
  OUT     UINT64  *Rand
  );
 
VOID
EFIAPI
AsmWriteTr (
  IN UINT16  Selector
  );
 
VOID
EFIAPI
AsmLfence (
  VOID
  );
 
UINT64
EFIAPI
AsmXGetBv (
  IN UINT32  Index
  );
 
UINT64
EFIAPI
AsmXSetBv (
  IN UINT32  Index,
  IN UINT64  Value
  );
 
VOID
EFIAPI
AsmVmgExit (
  VOID
  );
 
typedef struct {
  VOID      *Caa;
  UINT64    RaxIn;
  UINT64    RcxIn;
  UINT64    RdxIn;
  UINT64    R8In;
  UINT64    R9In;
  UINT64    RaxOut;
  UINT64    RcxOut;
  UINT64    RdxOut;
  UINT64    R8Out;
  UINT64    R9Out;
  UINT8     *CallPending;
} SVSM_CALL_DATA;
 
UINT32
EFIAPI
AsmVmgExitSvsm (
  IN OUT SVSM_CALL_DATA  *SvsmCallData
  );
 
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__)