Renormalized end-of-lines from master@27b044605cd5f6b33a3d231576003850b3fe305btrunk

12 files changed, 2254 insertions, 2254 deletions

diff --git a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupport.c b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupport.c
index 349a932b06..c46a291ec7 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupport.c
+++ b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupport.c
@@ -1,127 +1,127 @@
-/** @file

-  Top level C file for debug support driver.  Contains initialization function.

-

-Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#include "PlDebugSupport.h"

-

-EFI_DEBUG_SUPPORT_PROTOCOL  mDebugSupportProtocolInterface = {

-  EFI_ISA,

-  GetMaximumProcessorIndex,

-  RegisterPeriodicCallback,

-  RegisterExceptionCallback,

-  InvalidateInstructionCache

-};

-

-/**

-  Debug Support Driver entry point.

-

-  Checks to see if there's not already a Debug Support protocol installed for

-  the selected processor before installing it.

-

-  @param[in] ImageHandle       The firmware allocated handle for the EFI image.

-  @param[in] SystemTable       A pointer to the EFI System Table.

-

-  @retval EFI_SUCCESS          The entry point is executed successfully.

-  @retval EFI_ALREADY_STARTED  Debug Support protocol is installed already.

-  @retval other                Some error occurs when executing this entry point.

-

-**/

-EFI_STATUS

-EFIAPI

-InitializeDebugSupportDriver (

-  IN EFI_HANDLE        ImageHandle,

-  IN EFI_SYSTEM_TABLE  *SystemTable

-  )

-{

-  EFI_LOADED_IMAGE_PROTOCOL   *LoadedImageProtocolPtr;

-  EFI_STATUS                  Status;

-  EFI_HANDLE                  Handle;

-  EFI_HANDLE                  *HandlePtr;

-  UINTN                       NumHandles;

-  EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupportProtocolPtr;

-

-  //

-  // First check to see that the debug support protocol for this processor

-  // type is not already installed

-  //

-  Status = gBS->LocateHandleBuffer (

-                  ByProtocol,

-                  &gEfiDebugSupportProtocolGuid,

-                  NULL,

-                  &NumHandles,

-                  &HandlePtr

-                  );

-

-  if (Status != EFI_NOT_FOUND) {

-    do {

-      NumHandles--;

-      Status = gBS->OpenProtocol (

-                      HandlePtr[NumHandles],

-                      &gEfiDebugSupportProtocolGuid,

-                      (VOID **)&DebugSupportProtocolPtr,

-                      ImageHandle,

-                      NULL,

-                      EFI_OPEN_PROTOCOL_GET_PROTOCOL

-                      );

-      if ((Status == EFI_SUCCESS) && (DebugSupportProtocolPtr->Isa == EFI_ISA)) {

-        //

-        // a Debug Support protocol has been installed for this processor

-        //

-        FreePool (HandlePtr);

-        Status = EFI_ALREADY_STARTED;

-        goto ErrExit;

-      }

-    } while (NumHandles > 0);

-

-    FreePool (HandlePtr);

-  }

-

-  //

-  // Get our image information and install platform specific unload handler

-  //

-  Status = gBS->OpenProtocol (

-                  ImageHandle,

-                  &gEfiLoadedImageProtocolGuid,

-                  (VOID **)&LoadedImageProtocolPtr,

-                  ImageHandle,

-                  NULL,

-                  EFI_OPEN_PROTOCOL_GET_PROTOCOL

-                  );

-  ASSERT (!EFI_ERROR (Status));

-  if (Status != EFI_SUCCESS) {

-    goto ErrExit;

-  }

-

-  LoadedImageProtocolPtr->Unload = PlUnloadDebugSupportDriver;

-

-  //

-  // Call hook for processor specific initialization

-  //

-  Status = PlInitializeDebugSupportDriver ();

-  ASSERT (!EFI_ERROR (Status));

-  if (Status != EFI_SUCCESS) {

-    goto ErrExit;

-  }

-

-  //

-  // Install Debug Support protocol to new handle

-  //

-  Handle = NULL;

-  Status = gBS->InstallProtocolInterface (

-                  &Handle,

-                  &gEfiDebugSupportProtocolGuid,

-                  EFI_NATIVE_INTERFACE,

-                  &mDebugSupportProtocolInterface

-                  );

-  ASSERT (!EFI_ERROR (Status));

-  if (Status != EFI_SUCCESS) {

-    goto ErrExit;

-  }

-

-ErrExit:

-  return Status;

-}

+/** @file
+  Top level C file for debug support driver.  Contains initialization function.
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "PlDebugSupport.h"
+
+EFI_DEBUG_SUPPORT_PROTOCOL  mDebugSupportProtocolInterface = {
+  EFI_ISA,
+  GetMaximumProcessorIndex,
+  RegisterPeriodicCallback,
+  RegisterExceptionCallback,
+  InvalidateInstructionCache
+};
+
+/**
+  Debug Support Driver entry point.
+
+  Checks to see if there's not already a Debug Support protocol installed for
+  the selected processor before installing it.
+
+  @param[in] ImageHandle       The firmware allocated handle for the EFI image.
+  @param[in] SystemTable       A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS          The entry point is executed successfully.
+  @retval EFI_ALREADY_STARTED  Debug Support protocol is installed already.
+  @retval other                Some error occurs when executing this entry point.
+
+**/
+EFI_STATUS
+EFIAPI
+InitializeDebugSupportDriver (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_LOADED_IMAGE_PROTOCOL   *LoadedImageProtocolPtr;
+  EFI_STATUS                  Status;
+  EFI_HANDLE                  Handle;
+  EFI_HANDLE                  *HandlePtr;
+  UINTN                       NumHandles;
+  EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupportProtocolPtr;
+
+  //
+  // First check to see that the debug support protocol for this processor
+  // type is not already installed
+  //
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiDebugSupportProtocolGuid,
+                  NULL,
+                  &NumHandles,
+                  &HandlePtr
+                  );
+
+  if (Status != EFI_NOT_FOUND) {
+    do {
+      NumHandles--;
+      Status = gBS->OpenProtocol (
+                      HandlePtr[NumHandles],
+                      &gEfiDebugSupportProtocolGuid,
+                      (VOID **)&DebugSupportProtocolPtr,
+                      ImageHandle,
+                      NULL,
+                      EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                      );
+      if ((Status == EFI_SUCCESS) && (DebugSupportProtocolPtr->Isa == EFI_ISA)) {
+        //
+        // a Debug Support protocol has been installed for this processor
+        //
+        FreePool (HandlePtr);
+        Status = EFI_ALREADY_STARTED;
+        goto ErrExit;
+      }
+    } while (NumHandles > 0);
+
+    FreePool (HandlePtr);
+  }
+
+  //
+  // Get our image information and install platform specific unload handler
+  //
+  Status = gBS->OpenProtocol (
+                  ImageHandle,
+                  &gEfiLoadedImageProtocolGuid,
+                  (VOID **)&LoadedImageProtocolPtr,
+                  ImageHandle,
+                  NULL,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  ASSERT (!EFI_ERROR (Status));
+  if (Status != EFI_SUCCESS) {
+    goto ErrExit;
+  }
+
+  LoadedImageProtocolPtr->Unload = PlUnloadDebugSupportDriver;
+
+  //
+  // Call hook for processor specific initialization
+  //
+  Status = PlInitializeDebugSupportDriver ();
+  ASSERT (!EFI_ERROR (Status));
+  if (Status != EFI_SUCCESS) {
+    goto ErrExit;
+  }
+
+  //
+  // Install Debug Support protocol to new handle
+  //
+  Handle = NULL;
+  Status = gBS->InstallProtocolInterface (
+                  &Handle,
+                  &gEfiDebugSupportProtocolGuid,
+                  EFI_NATIVE_INTERFACE,
+                  &mDebugSupportProtocolInterface
+                  );
+  ASSERT (!EFI_ERROR (Status));
+  if (Status != EFI_SUCCESS) {
+    goto ErrExit;
+  }
+
+ErrExit:
+  return Status;
+}
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.inf b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.inf
index 1bb8635bf7..b9c1d4b417 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.inf
+++ b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.inf
@@ -1,72 +1,72 @@
-## @file

-# This driver installs Debug Support protocol for the selected processor.

-#

-# This driver provides the capabilities for debug-agent to gain control of the machine

-# when certain types of events occur, i.e. breakpoint, processor execptions, etc. It also

-# provides debug-agent to periodically gain control during operation of the machine to

-# check for asynchronous commands form the host.

-#

-# Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-#

-#  SPDX-License-Identifier: BSD-2-Clause-Patent

-#

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = DebugSupportDxe

-  MODULE_UNI_FILE                = DebugSupportDxe.uni

-  FILE_GUID                      = 911D584C-35F7-4955-BEF9-B452769DDC3A

-  MODULE_TYPE                    = DXE_DRIVER

-  VERSION_STRING                 = 1.0

-  ENTRY_POINT                    = InitializeDebugSupportDriver

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64

-#

-

-[Sources]

-  DebugSupport.c

-

-[Sources.Ia32]

-  Ia32/DebugSupport.h

-  Ia32/PlDebugSupport.c

-  Ia32/PlDebugSupport.h

-  Ia32/PlDebugSupportIa32.c

-  Ia32/AsmFuncs.nasm

-

-[Sources.X64]

-  Ia32/DebugSupport.h

-  Ia32/PlDebugSupport.c

-  X64/PlDebugSupport.h

-  X64/PlDebugSupportX64.c

-  X64/AsmFuncs.nasm

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-

-[LibraryClasses]

-  UefiBootServicesTableLib

-  MemoryAllocationLib

-  BaseMemoryLib

-  UefiDriverEntryPoint

-  DebugLib

-

-[LibraryClasses.IA32, LibraryClasses.X64]

-  BaseLib

-

-[Protocols]

-  gEfiLoadedImageProtocolGuid                   ## CONSUMES

-  gEfiDebugSupportProtocolGuid                  ## PRODUCES

-

-

-[Depex]

-  TRUE

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  DebugSupportDxeExtra.uni

+## @file
+# This driver installs Debug Support protocol for the selected processor.
+#
+# This driver provides the capabilities for debug-agent to gain control of the machine
+# when certain types of events occur, i.e. breakpoint, processor execptions, etc. It also
+# provides debug-agent to periodically gain control during operation of the machine to
+# check for asynchronous commands form the host.
+#
+# Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DebugSupportDxe
+  MODULE_UNI_FILE                = DebugSupportDxe.uni
+  FILE_GUID                      = 911D584C-35F7-4955-BEF9-B452769DDC3A
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  ENTRY_POINT                    = InitializeDebugSupportDriver
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  DebugSupport.c
+
+[Sources.Ia32]
+  Ia32/DebugSupport.h
+  Ia32/PlDebugSupport.c
+  Ia32/PlDebugSupport.h
+  Ia32/PlDebugSupportIa32.c
+  Ia32/AsmFuncs.nasm
+
+[Sources.X64]
+  Ia32/DebugSupport.h
+  Ia32/PlDebugSupport.c
+  X64/PlDebugSupport.h
+  X64/PlDebugSupportX64.c
+  X64/AsmFuncs.nasm
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  BaseMemoryLib
+  UefiDriverEntryPoint
+  DebugLib
+
+[LibraryClasses.IA32, LibraryClasses.X64]
+  BaseLib
+
+[Protocols]
+  gEfiLoadedImageProtocolGuid                   ## CONSUMES
+  gEfiDebugSupportProtocolGuid                  ## PRODUCES
+
+
+[Depex]
+  TRUE
+
+[UserExtensions.TianoCore."ExtraFiles"]
+  DebugSupportDxeExtra.uni
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.uni b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.uni
index 1403d41efc..a6de2f3d23 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.uni
+++ b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxe.uni
@@ -1,19 +1,19 @@
-// /** @file

-// This driver installs Debug Support protocol for the selected processor.

-//

-// This driver provides the capabilities for debug-agent to gain control of the machine

-// when certain types of events occur, i.e. breakpoint, processor execptions, etc. It also

-// provides debug-agent to periodically gain control during operation of the machine to

-// check for asynchronous commands form the host.

-//

-// Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// SPDX-License-Identifier: BSD-2-Clause-Patent

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "Installs Debug Support protocol for the selected processor"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "This driver provides the capabilities for debug-agent to gain control of the machine when certain types of events occur, i.e. breakpoint, processor exceptions, etc. It also provides debug-agent to periodically gain control during operation of the machine to check for asynchronous commands from the host."

-

+// /** @file
+// This driver installs Debug Support protocol for the selected processor.
+//
+// This driver provides the capabilities for debug-agent to gain control of the machine
+// when certain types of events occur, i.e. breakpoint, processor execptions, etc. It also
+// provides debug-agent to periodically gain control during operation of the machine to
+// check for asynchronous commands form the host.
+//
+// Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Installs Debug Support protocol for the selected processor"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This driver provides the capabilities for debug-agent to gain control of the machine when certain types of events occur, i.e. breakpoint, processor exceptions, etc. It also provides debug-agent to periodically gain control during operation of the machine to check for asynchronous commands from the host."
+
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxeExtra.uni b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxeExtra.uni
index 7ceb95d3f2..383c47ad0d 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxeExtra.uni
+++ b/MdeModulePkg/Universal/DebugSupportDxe/DebugSupportDxeExtra.uni
@@ -1,14 +1,14 @@
-// /** @file

-// DebugSupportDxe Localized Strings and Content

-//

-// Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>

-//

-// SPDX-License-Identifier: BSD-2-Clause-Patent

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME

-#language en-US

-"Debug Support DXE Driver"

-

-

+// /** @file
+// DebugSupportDxe Localized Strings and Content
+//
+// Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+//
+// **/
+
+#string STR_PROPERTIES_MODULE_NAME
+#language en-US
+"Debug Support DXE Driver"
+
+
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/AsmFuncs.nasm b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/AsmFuncs.nasm
index 07fc912fe8..0adb9fb851 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/AsmFuncs.nasm
+++ b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/AsmFuncs.nasm
@@ -1,479 +1,479 @@
-;/** @file

-;  Low leve IA32 specific debug support functions.

-;

-;  Copyright (c) 2006 - 2022, Intel Corporation. All rights reserved.<BR>

-;  SPDX-License-Identifier: BSD-2-Clause-Patent

-;

-;**/

-

-%define EXCPT32_DIVIDE_ERROR 0

-%define EXCPT32_DEBUG 1

-%define EXCPT32_NMI 2

-%define EXCPT32_BREAKPOINT 3

-%define EXCPT32_OVERFLOW 4

-%define EXCPT32_BOUND 5

-%define EXCPT32_INVALID_OPCODE 6

-%define EXCPT32_DOUBLE_FAULT 8

-%define EXCPT32_INVALID_TSS 10

-%define EXCPT32_SEG_NOT_PRESENT 11

-%define EXCPT32_STACK_FAULT 12

-%define EXCPT32_GP_FAULT 13

-%define EXCPT32_PAGE_FAULT 14

-%define EXCPT32_FP_ERROR 16

-%define EXCPT32_ALIGNMENT_CHECK 17

-%define EXCPT32_MACHINE_CHECK 18

-%define EXCPT32_SIMD 19

-

-%define FXSTOR_FLAG 0x1000000         ; bit cpuid 24 of feature flags

-

-SECTION .data

-

-global ASM_PFX(OrigVector)

-global ASM_PFX(InterruptEntryStub)

-global ASM_PFX(StubSize)

-global ASM_PFX(CommonIdtEntry)

-global ASM_PFX(FxStorSupport)

-extern ASM_PFX(InterruptDistrubutionHub)

-

-ASM_PFX(StubSize): dd InterruptEntryStubEnd - ASM_PFX(InterruptEntryStub)

-AppEsp: dd 0x11111111 ; ?

-DebugEsp: dd 0x22222222 ; ?

-ExtraPush: dd 0x33333333 ; ?

-ExceptData: dd 0x44444444 ; ?

-Eflags: dd 0x55555555 ; ?

-ASM_PFX(OrigVector): dd 0x66666666 ; ?

-

-;; The declarations below define the memory region that will be used for the debug stack.

-;; The context record will be built by pushing register values onto this stack.

-;; It is imparitive that alignment be carefully managed, since the FXSTOR and

-;; FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.

-;;

-;; The stub will switch stacks from the application stack to the debuger stack

-;; and pushes the exception number.

-;;

-;; Then we building the context record on the stack. Since the stack grows down,

-;; we push the fields of the context record from the back to the front.  There

-;; are 132 bytes of stack used prior allocating the 512 bytes of stack to be

-;; used as the memory buffer for the fxstor instruction. Therefore address of

-;; the buffer used for the FXSTOR instruction is &Eax - 132 - 512, which

-;; must be 16 byte aligned.

-;;

-;; We carefully locate the stack to make this happen.

-;;

-;; For reference, the context structure looks like this:

-;;      struct {

-;;        UINT32             ExceptionData;

-;;        FX_SAVE_STATE_IA32 FxSaveState;    // 512 bytes, must be 16 byte aligned

-;;        UINT32             Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-;;        UINT32             Cr0, Cr1, Cr2, Cr3, Cr4;

-;;        UINT32             EFlags;

-;;        UINT32             Ldtr, Tr;

-;;        UINT32             Gdtr[2], Idtr[2];

-;;        UINT32             Eip;

-;;        UINT32             Gs, Fs, Es, Ds, Cs, Ss;

-;;        UINT32             Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

-;;      } SYSTEM_CONTEXT_IA32;  // 32 bit system context record

-

-align           16

-DebugStackEnd: db "DbgStkEnd >>>>>>"    ;; 16 byte long string - must be 16 bytes to preserve alignment

-                times 0x1ffc dd    0x0  ;; 32K should be enough stack

-                                        ;;   This allocation is coocked to insure

-                                        ;;   that the the buffer for the FXSTORE instruction

-                                        ;;   will be 16 byte aligned also.

-                                        ;;

-ExceptionNumber: dd 0                   ;; first entry will be the vector number pushed by the stub

-

-DebugStackBegin: db "<<<< DbgStkBegin"  ;; initial debug ESP == DebugStackBegin, set in stub

-

-SECTION .text

-

-;------------------------------------------------------------------------------

-; BOOLEAN

-; FxStorSupport (

-;   void

-;   )

-;

-; Abstract: Returns TRUE if FxStor instructions are supported

-;

-global ASM_PFX(FxStorSupport)

-ASM_PFX(FxStorSupport):

-

-;

-; cpuid corrupts ebx which must be preserved per the C calling convention

-;

-                push    ebx

-                mov     eax, 1

-                cpuid

-                mov     eax, edx

-                and     eax, FXSTOR_FLAG

-                shr     eax, 24

-                pop     ebx

-                ret

-

-;------------------------------------------------------------------------------

-; void

-; Vect2Desc (

-;   DESCRIPTOR * DestDesc,

-;   void (*Vector) (void)

-;   )

-;

-; Abstract: Encodes an IDT descriptor with the given physical address

-;

-global ASM_PFX(Vect2Desc)

-ASM_PFX(Vect2Desc):

-                push    ebp

-                mov     ebp, esp

-                mov     eax, [ebp + 0xC]

-                mov     ecx, [ebp + 0x8]

-                mov     word [ecx], ax                  ; write bits 15..0 of offset

-                mov     dx, cs

-                mov     word [ecx+2], dx                ; SYS_CODE_SEL from GDT

-                mov     word [ecx+4], 0xe00 | 0x8000    ; type = 386 interrupt gate, present

-                shr     eax, 16

-                mov     word [ecx+6], ax                ; write bits 31..16 of offset

-                leave

-                ret

-

-;------------------------------------------------------------------------------

-; InterruptEntryStub

-;

-; Abstract: This code is not a function, but is a small piece of code that is

-;               copied and fixed up once for each IDT entry that is hooked.

-;

-ASM_PFX(InterruptEntryStub):

-                mov     [AppEsp], esp                ; save stack top

-                mov     esp, DebugStackBegin         ; switch to debugger stack

-                push    0                            ; push vector number - will be modified before installed

-                db      0xe9                         ; jump rel32

-                dd      0                            ; fixed up to relative address of CommonIdtEntry

-InterruptEntryStubEnd:

-

-;------------------------------------------------------------------------------

-; CommonIdtEntry

-;

-; Abstract: This code is not a function, but is the common part for all IDT

-;               vectors.

-;

-ASM_PFX(CommonIdtEntry):

-;;

-;; At this point, the stub has saved the current application stack esp into AppEsp

-;; and switched stacks to the debug stack, where it pushed the vector number

-;;

-;; The application stack looks like this:

-;;

-;;              ...

-;;              (last application stack entry)

-;;              eflags from interrupted task

-;;              CS from interrupted task

-;;              EIP from interrupted task

-;;              Error code <-------------------- Only present for some exeption types

-;;

-;;

-

-;; The stub switched us to the debug stack and pushed the interrupt number.

-;;

-;; Next, construct the context record.  It will be build on the debug stack by

-;; pushing the registers in the correct order so as to create the context structure

-;; on the debug stack.  The context record must be built from the end back to the

-;; beginning because the stack grows down...

-;

-;; For reference, the context record looks like this:

-;;

-;; typedef

-;; struct {

-;;   UINT32             ExceptionData;

-;;   FX_SAVE_STATE_IA32 FxSaveState;

-;;   UINT32             Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-;;   UINT32             Cr0, Cr2, Cr3, Cr4;

-;;   UINT32             EFlags;

-;;   UINT32             Ldtr, Tr;

-;;   UINT32             Gdtr[2], Idtr[2];

-;;   UINT32             Eip;

-;;   UINT32             Gs, Fs, Es, Ds, Cs, Ss;

-;;   UINT32             Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

-;; } SYSTEM_CONTEXT_IA32;  // 32 bit system context record

-

-;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

-                pushad

-

-;; Save interrupt state eflags register...

-                pushfd

-                pop     eax

-                mov     [Eflags], eax

-

-;; We need to determine if any extra data was pushed by the exception, and if so, save it

-;; To do this, we check the exception number pushed by the stub, and cache the

-;; result in a variable since we'll need this again.

-                cmp     dword [ExceptionNumber], EXCPT32_DOUBLE_FAULT

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_INVALID_TSS

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_SEG_NOT_PRESENT

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_STACK_FAULT

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_GP_FAULT

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_PAGE_FAULT

-                jz      ExtraPushOne

-                cmp     dword [ExceptionNumber], EXCPT32_ALIGNMENT_CHECK

-                jz      ExtraPushOne

-                mov     dword [ExtraPush], 0

-                mov     dword [ExceptData], 0

-                jmp     ExtraPushDone

-

-ExtraPushOne:

-                mov     dword [ExtraPush], 1

-

-;; If there's some extra data, save it also, and modify the saved AppEsp to effectively

-;; pop this value off the application's stack.

-                mov     eax, [AppEsp]

-                mov     ebx, [eax]

-                mov     [ExceptData], ebx

-                add     eax, 4

-                mov     [AppEsp], eax

-

-ExtraPushDone:

-

-;; The "pushad" above pushed the debug stack esp.  Since what we're actually doing

-;; is building the context record on the debug stack, we need to save the pushed

-;; debug ESP, and replace it with the application's last stack entry...

-                mov     eax, [esp + 12]

-                mov     [DebugEsp], eax

-                mov     eax, [AppEsp]

-                add     eax, 12

-                ; application stack has eflags, cs, & eip, so

-                ; last actual application stack entry is

-                ; 12 bytes into the application stack.

-                mov     [esp + 12], eax

-

-;; continue building context record

-;; UINT32  Gs, Fs, Es, Ds, Cs, Ss;  insure high 16 bits of each is zero

-                mov     eax, ss

-                push    eax

-

-                ; CS from application is one entry back in application stack

-                mov     eax, [AppEsp]

-                movzx   eax, word [eax + 4]

-                push    eax

-

-                mov     eax, ds

-                push    eax

-                mov     eax, es

-                push    eax

-                mov     eax, fs

-                push    eax

-                mov     eax, gs

-                push    eax

-

-;; UINT32  Eip;

-                ; Eip from application is on top of application stack

-                mov     eax, [AppEsp]

-                push    dword [eax]

-

-;; UINT32  Gdtr[2], Idtr[2];

-                push    0

-                push    0

-                sidt    [esp]

-                push    0

-                push    0

-                sgdt    [esp]

-

-;; UINT32  Ldtr, Tr;

-                xor     eax, eax

-                str     ax

-                push    eax

-                sldt    ax

-                push    eax

-

-;; UINT32  EFlags;

-;; Eflags from application is two entries back in application stack

-                mov     eax, [AppEsp]

-                push    dword [eax + 8]

-

-;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;

-;; insure FXSAVE/FXRSTOR is enabled in CR4...

-;; ... while we're at it, make sure DE is also enabled...

-                mov     eax, cr4

-                or      eax, 0x208

-                mov     cr4, eax

-                push    eax

-                mov     eax, cr3

-                push    eax

-                mov     eax, cr2

-                push    eax

-                push    0

-                mov     eax, cr0

-                push    eax

-

-;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-                mov     eax, dr7

-                push    eax

-;; clear Dr7 while executing debugger itself

-                xor     eax, eax

-                mov     dr7, eax

-

-                mov     eax, dr6

-                push    eax

-;; insure all status bits in dr6 are clear...

-                xor     eax, eax

-                mov     dr6, eax

-

-                mov     eax, dr3

-                push    eax

-                mov     eax, dr2

-                push    eax

-                mov     eax, dr1

-                push    eax

-                mov     eax, dr0

-                push    eax

-

-;; FX_SAVE_STATE_IA32 FxSaveState;

-                sub     esp, 512

-                mov     edi, esp

-                ; IMPORTANT!! The debug stack has been carefully constructed to

-                ; insure that esp and edi are 16 byte aligned when we get here.

-                ; They MUST be.  If they are not, a GP fault will occur.

-                fxsave  [edi]

-

-;; UEFI calling convention for IA32 requires that Direction flag in EFLAGs is clear

-                cld

-

-;; UINT32  ExceptionData;

-                mov     eax, [ExceptData]

-                push    eax

-

-; call to C code which will in turn call registered handler

-; pass in the vector number

-                mov     eax, esp

-                push    eax

-                mov     eax, [ExceptionNumber]

-                push    eax

-                call    ASM_PFX(InterruptDistrubutionHub)

-                add     esp, 8

-

-; restore context...

-;; UINT32  ExceptionData;

-                add     esp, 4

-

-;; FX_SAVE_STATE_IA32 FxSaveState;

-                mov     esi, esp

-                fxrstor [esi]

-                add     esp, 512

-

-;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-                pop     eax

-                mov     dr0, eax

-                pop     eax

-                mov     dr1, eax

-                pop     eax

-                mov     dr2, eax

-                pop     eax

-                mov     dr3, eax

-;; skip restore of dr6.  We cleared dr6 during the context save.

-                add     esp, 4

-                pop     eax

-                mov     dr7, eax

-

-;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;

-                pop     eax

-                mov     cr0, eax

-                add     esp, 4

-                pop     eax

-                mov     cr2, eax

-                pop     eax

-                mov     cr3, eax

-                pop     eax

-                mov     cr4, eax

-

-;; UINT32  EFlags;

-                mov     eax, [AppEsp]

-                pop     dword [eax + 8]

-

-;; UINT32  Ldtr, Tr;

-;; UINT32  Gdtr[2], Idtr[2];

-;; Best not let anyone mess with these particular registers...

-                add     esp, 24

-

-;; UINT32  Eip;

-                pop     dword [eax]

-

-;; UINT32  SegGs, SegFs, SegEs, SegDs, SegCs, SegSs;

-;; NOTE - modified segment registers could hang the debugger...  We

-;;        could attempt to insulate ourselves against this possibility,

-;;        but that poses risks as well.

-;;

-

-                pop     gs

-                pop     fs

-                pop     es

-                pop     ds

-                pop     dword [eax + 4]

-                pop     ss

-

-;; The next stuff to restore is the general purpose registers that were pushed

-;; using the "pushad" instruction.

-;;

-;; The value of ESP as stored in the context record is the application ESP

-;; including the 3 entries on the application stack caused by the exception

-;; itself. It may have been modified by the debug agent, so we need to

-;; determine if we need to relocate the application stack.

-

-                mov     ebx, [esp + 12]  ; move the potentially modified AppEsp into ebx

-                mov     eax, [AppEsp]

-                add     eax, 12

-                cmp     ebx, eax

-                je      NoAppStackMove

-

-                mov     eax, [AppEsp]

-                mov     ecx, [eax]       ; EIP

-                mov     [ebx], ecx

-

-                mov     ecx, [eax + 4]   ; CS

-                mov     [ebx + 4], ecx

-

-                mov     ecx, [eax + 8]   ; EFLAGS

-                mov     [ebx + 8], ecx

-

-                mov     eax, ebx         ; modify the saved AppEsp to the new AppEsp

-                mov     [AppEsp], eax

-NoAppStackMove:

-                mov     eax, [DebugEsp]  ; restore the DebugEsp on the debug stack

-                                         ; so our "popad" will not cause a stack switch

-                mov     [esp + 12], eax

-

-                cmp     dword [ExceptionNumber], 0x68

-                jne     NoChain

-

-Chain:

-

-;; Restore eflags so when we chain, the flags will be exactly as if we were never here.

-;; We gin up the stack to do an iretd so we can get ALL the flags.

-                mov     eax, [AppEsp]

-                mov     ebx, [eax + 8]

-                and     ebx, ~ 0x300 ; special handling for IF and TF

-                push    ebx

-                push    cs

-                push    PhonyIretd

-                iretd

-PhonyIretd:

-

-;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

-                popad

-

-;; Switch back to application stack

-                mov     esp, [AppEsp]

-

-;; Jump to original handler

-                jmp     [ASM_PFX(OrigVector)]

-

-NoChain:

-;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

-                popad

-

-;; Switch back to application stack

-                mov     esp, [AppEsp]

-

-;; We're outa here...

-                iretd

-

+;/** @file
+;  Low leve IA32 specific debug support functions.
+;
+;  Copyright (c) 2006 - 2022, Intel Corporation. All rights reserved.<BR>
+;  SPDX-License-Identifier: BSD-2-Clause-Patent
+;
+;**/
+
+%define EXCPT32_DIVIDE_ERROR 0
+%define EXCPT32_DEBUG 1
+%define EXCPT32_NMI 2
+%define EXCPT32_BREAKPOINT 3
+%define EXCPT32_OVERFLOW 4
+%define EXCPT32_BOUND 5
+%define EXCPT32_INVALID_OPCODE 6
+%define EXCPT32_DOUBLE_FAULT 8
+%define EXCPT32_INVALID_TSS 10
+%define EXCPT32_SEG_NOT_PRESENT 11
+%define EXCPT32_STACK_FAULT 12
+%define EXCPT32_GP_FAULT 13
+%define EXCPT32_PAGE_FAULT 14
+%define EXCPT32_FP_ERROR 16
+%define EXCPT32_ALIGNMENT_CHECK 17
+%define EXCPT32_MACHINE_CHECK 18
+%define EXCPT32_SIMD 19
+
+%define FXSTOR_FLAG 0x1000000         ; bit cpuid 24 of feature flags
+
+SECTION .data
+
+global ASM_PFX(OrigVector)
+global ASM_PFX(InterruptEntryStub)
+global ASM_PFX(StubSize)
+global ASM_PFX(CommonIdtEntry)
+global ASM_PFX(FxStorSupport)
+extern ASM_PFX(InterruptDistrubutionHub)
+
+ASM_PFX(StubSize): dd InterruptEntryStubEnd - ASM_PFX(InterruptEntryStub)
+AppEsp: dd 0x11111111 ; ?
+DebugEsp: dd 0x22222222 ; ?
+ExtraPush: dd 0x33333333 ; ?
+ExceptData: dd 0x44444444 ; ?
+Eflags: dd 0x55555555 ; ?
+ASM_PFX(OrigVector): dd 0x66666666 ; ?
+
+;; The declarations below define the memory region that will be used for the debug stack.
+;; The context record will be built by pushing register values onto this stack.
+;; It is imparitive that alignment be carefully managed, since the FXSTOR and
+;; FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.
+;;
+;; The stub will switch stacks from the application stack to the debuger stack
+;; and pushes the exception number.
+;;
+;; Then we building the context record on the stack. Since the stack grows down,
+;; we push the fields of the context record from the back to the front.  There
+;; are 132 bytes of stack used prior allocating the 512 bytes of stack to be
+;; used as the memory buffer for the fxstor instruction. Therefore address of
+;; the buffer used for the FXSTOR instruction is &Eax - 132 - 512, which
+;; must be 16 byte aligned.
+;;
+;; We carefully locate the stack to make this happen.
+;;
+;; For reference, the context structure looks like this:
+;;      struct {
+;;        UINT32             ExceptionData;
+;;        FX_SAVE_STATE_IA32 FxSaveState;    // 512 bytes, must be 16 byte aligned
+;;        UINT32             Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+;;        UINT32             Cr0, Cr1, Cr2, Cr3, Cr4;
+;;        UINT32             EFlags;
+;;        UINT32             Ldtr, Tr;
+;;        UINT32             Gdtr[2], Idtr[2];
+;;        UINT32             Eip;
+;;        UINT32             Gs, Fs, Es, Ds, Cs, Ss;
+;;        UINT32             Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
+;;      } SYSTEM_CONTEXT_IA32;  // 32 bit system context record
+
+align           16
+DebugStackEnd: db "DbgStkEnd >>>>>>"    ;; 16 byte long string - must be 16 bytes to preserve alignment
+                times 0x1ffc dd    0x0  ;; 32K should be enough stack
+                                        ;;   This allocation is coocked to insure
+                                        ;;   that the the buffer for the FXSTORE instruction
+                                        ;;   will be 16 byte aligned also.
+                                        ;;
+ExceptionNumber: dd 0                   ;; first entry will be the vector number pushed by the stub
+
+DebugStackBegin: db "<<<< DbgStkBegin"  ;; initial debug ESP == DebugStackBegin, set in stub
+
+SECTION .text
+
+;------------------------------------------------------------------------------
+; BOOLEAN
+; FxStorSupport (
+;   void
+;   )
+;
+; Abstract: Returns TRUE if FxStor instructions are supported
+;
+global ASM_PFX(FxStorSupport)
+ASM_PFX(FxStorSupport):
+
+;
+; cpuid corrupts ebx which must be preserved per the C calling convention
+;
+                push    ebx
+                mov     eax, 1
+                cpuid
+                mov     eax, edx
+                and     eax, FXSTOR_FLAG
+                shr     eax, 24
+                pop     ebx
+                ret
+
+;------------------------------------------------------------------------------
+; void
+; Vect2Desc (
+;   DESCRIPTOR * DestDesc,
+;   void (*Vector) (void)
+;   )
+;
+; Abstract: Encodes an IDT descriptor with the given physical address
+;
+global ASM_PFX(Vect2Desc)
+ASM_PFX(Vect2Desc):
+                push    ebp
+                mov     ebp, esp
+                mov     eax, [ebp + 0xC]
+                mov     ecx, [ebp + 0x8]
+                mov     word [ecx], ax                  ; write bits 15..0 of offset
+                mov     dx, cs
+                mov     word [ecx+2], dx                ; SYS_CODE_SEL from GDT
+                mov     word [ecx+4], 0xe00 | 0x8000    ; type = 386 interrupt gate, present
+                shr     eax, 16
+                mov     word [ecx+6], ax                ; write bits 31..16 of offset
+                leave
+                ret
+
+;------------------------------------------------------------------------------
+; InterruptEntryStub
+;
+; Abstract: This code is not a function, but is a small piece of code that is
+;               copied and fixed up once for each IDT entry that is hooked.
+;
+ASM_PFX(InterruptEntryStub):
+                mov     [AppEsp], esp                ; save stack top
+                mov     esp, DebugStackBegin         ; switch to debugger stack
+                push    0                            ; push vector number - will be modified before installed
+                db      0xe9                         ; jump rel32
+                dd      0                            ; fixed up to relative address of CommonIdtEntry
+InterruptEntryStubEnd:
+
+;------------------------------------------------------------------------------
+; CommonIdtEntry
+;
+; Abstract: This code is not a function, but is the common part for all IDT
+;               vectors.
+;
+ASM_PFX(CommonIdtEntry):
+;;
+;; At this point, the stub has saved the current application stack esp into AppEsp
+;; and switched stacks to the debug stack, where it pushed the vector number
+;;
+;; The application stack looks like this:
+;;
+;;              ...
+;;              (last application stack entry)
+;;              eflags from interrupted task
+;;              CS from interrupted task
+;;              EIP from interrupted task
+;;              Error code <-------------------- Only present for some exeption types
+;;
+;;
+
+;; The stub switched us to the debug stack and pushed the interrupt number.
+;;
+;; Next, construct the context record.  It will be build on the debug stack by
+;; pushing the registers in the correct order so as to create the context structure
+;; on the debug stack.  The context record must be built from the end back to the
+;; beginning because the stack grows down...
+;
+;; For reference, the context record looks like this:
+;;
+;; typedef
+;; struct {
+;;   UINT32             ExceptionData;
+;;   FX_SAVE_STATE_IA32 FxSaveState;
+;;   UINT32             Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+;;   UINT32             Cr0, Cr2, Cr3, Cr4;
+;;   UINT32             EFlags;
+;;   UINT32             Ldtr, Tr;
+;;   UINT32             Gdtr[2], Idtr[2];
+;;   UINT32             Eip;
+;;   UINT32             Gs, Fs, Es, Ds, Cs, Ss;
+;;   UINT32             Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
+;; } SYSTEM_CONTEXT_IA32;  // 32 bit system context record
+
+;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
+                pushad
+
+;; Save interrupt state eflags register...
+                pushfd
+                pop     eax
+                mov     [Eflags], eax
+
+;; We need to determine if any extra data was pushed by the exception, and if so, save it
+;; To do this, we check the exception number pushed by the stub, and cache the
+;; result in a variable since we'll need this again.
+                cmp     dword [ExceptionNumber], EXCPT32_DOUBLE_FAULT
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_INVALID_TSS
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_SEG_NOT_PRESENT
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_STACK_FAULT
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_GP_FAULT
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_PAGE_FAULT
+                jz      ExtraPushOne
+                cmp     dword [ExceptionNumber], EXCPT32_ALIGNMENT_CHECK
+                jz      ExtraPushOne
+                mov     dword [ExtraPush], 0
+                mov     dword [ExceptData], 0
+                jmp     ExtraPushDone
+
+ExtraPushOne:
+                mov     dword [ExtraPush], 1
+
+;; If there's some extra data, save it also, and modify the saved AppEsp to effectively
+;; pop this value off the application's stack.
+                mov     eax, [AppEsp]
+                mov     ebx, [eax]
+                mov     [ExceptData], ebx
+                add     eax, 4
+                mov     [AppEsp], eax
+
+ExtraPushDone:
+
+;; The "pushad" above pushed the debug stack esp.  Since what we're actually doing
+;; is building the context record on the debug stack, we need to save the pushed
+;; debug ESP, and replace it with the application's last stack entry...
+                mov     eax, [esp + 12]
+                mov     [DebugEsp], eax
+                mov     eax, [AppEsp]
+                add     eax, 12
+                ; application stack has eflags, cs, & eip, so
+                ; last actual application stack entry is
+                ; 12 bytes into the application stack.
+                mov     [esp + 12], eax
+
+;; continue building context record
+;; UINT32  Gs, Fs, Es, Ds, Cs, Ss;  insure high 16 bits of each is zero
+                mov     eax, ss
+                push    eax
+
+                ; CS from application is one entry back in application stack
+                mov     eax, [AppEsp]
+                movzx   eax, word [eax + 4]
+                push    eax
+
+                mov     eax, ds
+                push    eax
+                mov     eax, es
+                push    eax
+                mov     eax, fs
+                push    eax
+                mov     eax, gs
+                push    eax
+
+;; UINT32  Eip;
+                ; Eip from application is on top of application stack
+                mov     eax, [AppEsp]
+                push    dword [eax]
+
+;; UINT32  Gdtr[2], Idtr[2];
+                push    0
+                push    0
+                sidt    [esp]
+                push    0
+                push    0
+                sgdt    [esp]
+
+;; UINT32  Ldtr, Tr;
+                xor     eax, eax
+                str     ax
+                push    eax
+                sldt    ax
+                push    eax
+
+;; UINT32  EFlags;
+;; Eflags from application is two entries back in application stack
+                mov     eax, [AppEsp]
+                push    dword [eax + 8]
+
+;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
+;; insure FXSAVE/FXRSTOR is enabled in CR4...
+;; ... while we're at it, make sure DE is also enabled...
+                mov     eax, cr4
+                or      eax, 0x208
+                mov     cr4, eax
+                push    eax
+                mov     eax, cr3
+                push    eax
+                mov     eax, cr2
+                push    eax
+                push    0
+                mov     eax, cr0
+                push    eax
+
+;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+                mov     eax, dr7
+                push    eax
+;; clear Dr7 while executing debugger itself
+                xor     eax, eax
+                mov     dr7, eax
+
+                mov     eax, dr6
+                push    eax
+;; insure all status bits in dr6 are clear...
+                xor     eax, eax
+                mov     dr6, eax
+
+                mov     eax, dr3
+                push    eax
+                mov     eax, dr2
+                push    eax
+                mov     eax, dr1
+                push    eax
+                mov     eax, dr0
+                push    eax
+
+;; FX_SAVE_STATE_IA32 FxSaveState;
+                sub     esp, 512
+                mov     edi, esp
+                ; IMPORTANT!! The debug stack has been carefully constructed to
+                ; insure that esp and edi are 16 byte aligned when we get here.
+                ; They MUST be.  If they are not, a GP fault will occur.
+                fxsave  [edi]
+
+;; UEFI calling convention for IA32 requires that Direction flag in EFLAGs is clear
+                cld
+
+;; UINT32  ExceptionData;
+                mov     eax, [ExceptData]
+                push    eax
+
+; call to C code which will in turn call registered handler
+; pass in the vector number
+                mov     eax, esp
+                push    eax
+                mov     eax, [ExceptionNumber]
+                push    eax
+                call    ASM_PFX(InterruptDistrubutionHub)
+                add     esp, 8
+
+; restore context...
+;; UINT32  ExceptionData;
+                add     esp, 4
+
+;; FX_SAVE_STATE_IA32 FxSaveState;
+                mov     esi, esp
+                fxrstor [esi]
+                add     esp, 512
+
+;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+                pop     eax
+                mov     dr0, eax
+                pop     eax
+                mov     dr1, eax
+                pop     eax
+                mov     dr2, eax
+                pop     eax
+                mov     dr3, eax
+;; skip restore of dr6.  We cleared dr6 during the context save.
+                add     esp, 4
+                pop     eax
+                mov     dr7, eax
+
+;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
+                pop     eax
+                mov     cr0, eax
+                add     esp, 4
+                pop     eax
+                mov     cr2, eax
+                pop     eax
+                mov     cr3, eax
+                pop     eax
+                mov     cr4, eax
+
+;; UINT32  EFlags;
+                mov     eax, [AppEsp]
+                pop     dword [eax + 8]
+
+;; UINT32  Ldtr, Tr;
+;; UINT32  Gdtr[2], Idtr[2];
+;; Best not let anyone mess with these particular registers...
+                add     esp, 24
+
+;; UINT32  Eip;
+                pop     dword [eax]
+
+;; UINT32  SegGs, SegFs, SegEs, SegDs, SegCs, SegSs;
+;; NOTE - modified segment registers could hang the debugger...  We
+;;        could attempt to insulate ourselves against this possibility,
+;;        but that poses risks as well.
+;;
+
+                pop     gs
+                pop     fs
+                pop     es
+                pop     ds
+                pop     dword [eax + 4]
+                pop     ss
+
+;; The next stuff to restore is the general purpose registers that were pushed
+;; using the "pushad" instruction.
+;;
+;; The value of ESP as stored in the context record is the application ESP
+;; including the 3 entries on the application stack caused by the exception
+;; itself. It may have been modified by the debug agent, so we need to
+;; determine if we need to relocate the application stack.
+
+                mov     ebx, [esp + 12]  ; move the potentially modified AppEsp into ebx
+                mov     eax, [AppEsp]
+                add     eax, 12
+                cmp     ebx, eax
+                je      NoAppStackMove
+
+                mov     eax, [AppEsp]
+                mov     ecx, [eax]       ; EIP
+                mov     [ebx], ecx
+
+                mov     ecx, [eax + 4]   ; CS
+                mov     [ebx + 4], ecx
+
+                mov     ecx, [eax + 8]   ; EFLAGS
+                mov     [ebx + 8], ecx
+
+                mov     eax, ebx         ; modify the saved AppEsp to the new AppEsp
+                mov     [AppEsp], eax
+NoAppStackMove:
+                mov     eax, [DebugEsp]  ; restore the DebugEsp on the debug stack
+                                         ; so our "popad" will not cause a stack switch
+                mov     [esp + 12], eax
+
+                cmp     dword [ExceptionNumber], 0x68
+                jne     NoChain
+
+Chain:
+
+;; Restore eflags so when we chain, the flags will be exactly as if we were never here.
+;; We gin up the stack to do an iretd so we can get ALL the flags.
+                mov     eax, [AppEsp]
+                mov     ebx, [eax + 8]
+                and     ebx, ~ 0x300 ; special handling for IF and TF
+                push    ebx
+                push    cs
+                push    PhonyIretd
+                iretd
+PhonyIretd:
+
+;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
+                popad
+
+;; Switch back to application stack
+                mov     esp, [AppEsp]
+
+;; Jump to original handler
+                jmp     [ASM_PFX(OrigVector)]
+
+NoChain:
+;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
+                popad
+
+;; Switch back to application stack
+                mov     esp, [AppEsp]
+
+;; We're outa here...
+                iretd
+
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/DebugSupport.h b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/DebugSupport.h
index cf12a2a6e8..77ee1690f2 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/DebugSupport.h
+++ b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/DebugSupport.h
@@ -1,294 +1,294 @@
-/** @file

-  Generic debug support macros, typedefs and prototypes for IA32/x64.

-

-Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#ifndef _DEBUG_SUPPORT_H_

-#define _DEBUG_SUPPORT_H_

-

-#include <Uefi.h>

-

-#include <Protocol/DebugSupport.h>

-#include <Protocol/LoadedImage.h>

-

-#include <Library/DebugLib.h>

-#include <Library/UefiDriverEntryPoint.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/BaseLib.h>

-

-#define NUM_IDT_ENTRIES      0x78

-#define SYSTEM_TIMER_VECTOR  0x68

-

-typedef

-VOID

-(*DEBUG_PROC) (

-  VOID

-  );

-

-typedef

-VOID

-(EFIAPI *CALLBACK_FUNC)(

-  );

-

-typedef struct {

-  IA32_IDT_GATE_DESCRIPTOR    OrigDesc;

-  DEBUG_PROC                  OrigVector;

-  IA32_IDT_GATE_DESCRIPTOR    NewDesc;

-  DEBUG_PROC                  StubEntry;

-  CALLBACK_FUNC               RegisteredCallback;

-} IDT_ENTRY;

-

-extern UINT8   InterruptEntryStub[];

-extern UINT32  StubSize;

-extern VOID    (*OrigVector) (

-  VOID

-  );

-extern IDT_ENTRY                 *IdtEntryTable;

-extern IA32_IDT_GATE_DESCRIPTOR  NullDesc;

-

-/**

-  Generic IDT entry.

-

-**/

-VOID

-CommonIdtEntry (

-  VOID

-  );

-

-/**

-  Check whether FXSTOR is supported

-

-  @retval TRUE   FXSTOR is supported.

-  @retval FALSE  FXSTOR is not supported.

-

-**/

-BOOLEAN

-FxStorSupport (

-  VOID

-  );

-

-/**

-  Encodes an IDT descriptor with the given physical address.

-

-  @param  DestDesc    The IDT descriptor address.

-  @param  Vecotr      The interrupt vector entry.

-

-**/

-VOID

-Vect2Desc (

-  IA32_IDT_GATE_DESCRIPTOR  *DestDesc,

-  VOID (                    *Vector )(VOID)

-  );

-

-/**

-  Initializes driver's handler registration database.

-

-  This code executes in boot services context

-  Must be public because it's referenced from DebugSupport.c

-

-  @retval  EFI_UNSUPPORTED      If IA32 processor does not support FXSTOR/FXRSTOR instructions,

-                                the context save will fail, so these processor's are not supported.

-  @retval  EFI_OUT_OF_RESOURCES Fails to allocate memory.

-  @retval  EFI_SUCCESS          Initializes successfully.

-

-**/

-EFI_STATUS

-PlInitializeDebugSupportDriver (

-  VOID

-  );

-

-/**

-  This is the callback that is written to the LoadedImage protocol instance

-  on the image handle. It uninstalls all registered handlers and frees all entry

-  stub memory.

-

-  @param  ImageHandle    The firmware allocated handle for the EFI image.

-

-  @retval EFI_SUCCESS    Always.

-

-**/

-EFI_STATUS

-EFIAPI

-PlUnloadDebugSupportDriver (

-  IN EFI_HANDLE  ImageHandle

-  );

-

-/**

-  Returns the maximum value that may be used for the ProcessorIndex parameter in

-  RegisterPeriodicCallback() and RegisterExceptionCallback().

-

-  Hard coded to support only 1 processor for now.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported

-                                processor index is returned. Always 0 returned.

-

-  @retval EFI_SUCCESS           Always returned with **MaxProcessorIndex set to 0.

-

-**/

-EFI_STATUS

-EFIAPI

-GetMaximumProcessorIndex (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  OUT UINTN                      *MaxProcessorIndex

-  );

-

-/**

-  Registers a function to be called back periodically in interrupt context.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor the callback function applies to.

-  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main

-                                periodic entry point of the debug agent.

-

-  @retval EFI_SUCCESS           The function completed successfully.

-  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback

-                                function was previously registered.

-  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback

-                                function.

-**/

-EFI_STATUS

-EFIAPI

-RegisterPeriodicCallback (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN EFI_PERIODIC_CALLBACK       PeriodicCallback

-  );

-

-/**

-  Registers a function to be called when a given processor exception occurs.

-

-  This code executes in boot services context.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor the callback function applies to.

-  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called

-                                when the processor exception specified by ExceptionType occurs.

-  @param  ExceptionType         Specifies which processor exception to hook.

-

-  @retval EFI_SUCCESS           The function completed successfully.

-  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback

-                                function was previously registered.

-  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback

-                                function.

-**/

-EFI_STATUS

-EFIAPI

-RegisterExceptionCallback (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,

-  IN EFI_EXCEPTION_TYPE          ExceptionType

-  );

-

-/**

-  Invalidates processor instruction cache for a memory range. Subsequent execution in this range

-  causes a fresh memory fetch to retrieve code to be executed.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.

-  @param  Start                 Specifies the physical base of the memory range to be invalidated.

-  @param  Length                Specifies the minimum number of bytes in the processor's instruction

-                                cache to invalidate.

-

-  @retval EFI_SUCCESS           Always returned.

-

-**/

-EFI_STATUS

-EFIAPI

-InvalidateInstructionCache (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN VOID                        *Start,

-  IN UINT64                      Length

-  );

-

-/**

-  Allocate pool for a new IDT entry stub.

-

-  Copy the generic stub into the new buffer and fixup the vector number

-  and jump target address.

-

-  @param  ExceptionType   This is the exception type that the new stub will be created

-                          for.

-  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.

-

-**/

-VOID

-CreateEntryStub (

-  IN EFI_EXCEPTION_TYPE  ExceptionType,

-  OUT VOID               **Stub

-  );

-

-/**

-  Get Interrupt Handle from IDT Gate Descriptor.

-

-  @param  IdtGateDecriptor  IDT Gate Descriptor.

-

-  @return Interrupt Handle stored in IDT Gate Descriptor.

-

-**/

-UINTN

-GetInterruptHandleFromIdt (

-  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDecriptor

-  );

-

-/**

-  This is the main worker function that manages the state of the interrupt

-  handlers.  It both installs and uninstalls interrupt handlers based on the

-  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.

-  If NewCallback is non-NULL, then install is indicated.

-

-  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.

-                        If NULL, specifies that the previously registered handler should

-                        be uninstalled.

-  @param  ExceptionType Indicates which entry to manage.

-

-  @retval EFI_SUCCESS            Process is ok.

-  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has

-                                 no handler registered for it

-  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.

-  @retval others                 Possible return values are passed through from UnHookEntry and HookEntry.

-

-**/

-EFI_STATUS

-ManageIdtEntryTable (

-  CALLBACK_FUNC       NewCallback,

-  EFI_EXCEPTION_TYPE  ExceptionType

-  );

-

-/**

-  Creates a nes entry stub.  Then saves the current IDT entry and replaces it

-  with an interrupt gate for the new entry point.  The IdtEntryTable is updated

-  with the new registered function.

-

-  This code executes in boot services context.  The stub entry executes in interrupt

-  context.

-

-  @param  ExceptionType      Specifies which vector to hook.

-  @param  NewCallback        A pointer to the new function to be registered.

-

-**/

-VOID

-HookEntry (

-  IN EFI_EXCEPTION_TYPE  ExceptionType,

-  IN CALLBACK_FUNC       NewCallback

-  );

-

-/**

-  Undoes HookEntry. This code executes in boot services context.

-

-  @param  ExceptionType   Specifies which entry to unhook

-

-**/

-VOID

-UnhookEntry (

-  IN EFI_EXCEPTION_TYPE  ExceptionType

-  );

-

-#endif

+/** @file
+  Generic debug support macros, typedefs and prototypes for IA32/x64.
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _DEBUG_SUPPORT_H_
+#define _DEBUG_SUPPORT_H_
+
+#include <Uefi.h>
+
+#include <Protocol/DebugSupport.h>
+#include <Protocol/LoadedImage.h>
+
+#include <Library/DebugLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseLib.h>
+
+#define NUM_IDT_ENTRIES      0x78
+#define SYSTEM_TIMER_VECTOR  0x68
+
+typedef
+VOID
+(*DEBUG_PROC) (
+  VOID
+  );
+
+typedef
+VOID
+(EFIAPI *CALLBACK_FUNC)(
+  );
+
+typedef struct {
+  IA32_IDT_GATE_DESCRIPTOR    OrigDesc;
+  DEBUG_PROC                  OrigVector;
+  IA32_IDT_GATE_DESCRIPTOR    NewDesc;
+  DEBUG_PROC                  StubEntry;
+  CALLBACK_FUNC               RegisteredCallback;
+} IDT_ENTRY;
+
+extern UINT8   InterruptEntryStub[];
+extern UINT32  StubSize;
+extern VOID    (*OrigVector) (
+  VOID
+  );
+extern IDT_ENTRY                 *IdtEntryTable;
+extern IA32_IDT_GATE_DESCRIPTOR  NullDesc;
+
+/**
+  Generic IDT entry.
+
+**/
+VOID
+CommonIdtEntry (
+  VOID
+  );
+
+/**
+  Check whether FXSTOR is supported
+
+  @retval TRUE   FXSTOR is supported.
+  @retval FALSE  FXSTOR is not supported.
+
+**/
+BOOLEAN
+FxStorSupport (
+  VOID
+  );
+
+/**
+  Encodes an IDT descriptor with the given physical address.
+
+  @param  DestDesc    The IDT descriptor address.
+  @param  Vecotr      The interrupt vector entry.
+
+**/
+VOID
+Vect2Desc (
+  IA32_IDT_GATE_DESCRIPTOR  *DestDesc,
+  VOID (                    *Vector )(VOID)
+  );
+
+/**
+  Initializes driver's handler registration database.
+
+  This code executes in boot services context
+  Must be public because it's referenced from DebugSupport.c
+
+  @retval  EFI_UNSUPPORTED      If IA32 processor does not support FXSTOR/FXRSTOR instructions,
+                                the context save will fail, so these processor's are not supported.
+  @retval  EFI_OUT_OF_RESOURCES Fails to allocate memory.
+  @retval  EFI_SUCCESS          Initializes successfully.
+
+**/
+EFI_STATUS
+PlInitializeDebugSupportDriver (
+  VOID
+  );
+
+/**
+  This is the callback that is written to the LoadedImage protocol instance
+  on the image handle. It uninstalls all registered handlers and frees all entry
+  stub memory.
+
+  @param  ImageHandle    The firmware allocated handle for the EFI image.
+
+  @retval EFI_SUCCESS    Always.
+
+**/
+EFI_STATUS
+EFIAPI
+PlUnloadDebugSupportDriver (
+  IN EFI_HANDLE  ImageHandle
+  );
+
+/**
+  Returns the maximum value that may be used for the ProcessorIndex parameter in
+  RegisterPeriodicCallback() and RegisterExceptionCallback().
+
+  Hard coded to support only 1 processor for now.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported
+                                processor index is returned. Always 0 returned.
+
+  @retval EFI_SUCCESS           Always returned with **MaxProcessorIndex set to 0.
+
+**/
+EFI_STATUS
+EFIAPI
+GetMaximumProcessorIndex (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  OUT UINTN                      *MaxProcessorIndex
+  );
+
+/**
+  Registers a function to be called back periodically in interrupt context.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main
+                                periodic entry point of the debug agent.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback
+                                function.
+**/
+EFI_STATUS
+EFIAPI
+RegisterPeriodicCallback (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN EFI_PERIODIC_CALLBACK       PeriodicCallback
+  );
+
+/**
+  Registers a function to be called when a given processor exception occurs.
+
+  This code executes in boot services context.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called
+                                when the processor exception specified by ExceptionType occurs.
+  @param  ExceptionType         Specifies which processor exception to hook.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback
+                                function.
+**/
+EFI_STATUS
+EFIAPI
+RegisterExceptionCallback (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,
+  IN EFI_EXCEPTION_TYPE          ExceptionType
+  );
+
+/**
+  Invalidates processor instruction cache for a memory range. Subsequent execution in this range
+  causes a fresh memory fetch to retrieve code to be executed.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.
+  @param  Start                 Specifies the physical base of the memory range to be invalidated.
+  @param  Length                Specifies the minimum number of bytes in the processor's instruction
+                                cache to invalidate.
+
+  @retval EFI_SUCCESS           Always returned.
+
+**/
+EFI_STATUS
+EFIAPI
+InvalidateInstructionCache (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN VOID                        *Start,
+  IN UINT64                      Length
+  );
+
+/**
+  Allocate pool for a new IDT entry stub.
+
+  Copy the generic stub into the new buffer and fixup the vector number
+  and jump target address.
+
+  @param  ExceptionType   This is the exception type that the new stub will be created
+                          for.
+  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.
+
+**/
+VOID
+CreateEntryStub (
+  IN EFI_EXCEPTION_TYPE  ExceptionType,
+  OUT VOID               **Stub
+  );
+
+/**
+  Get Interrupt Handle from IDT Gate Descriptor.
+
+  @param  IdtGateDecriptor  IDT Gate Descriptor.
+
+  @return Interrupt Handle stored in IDT Gate Descriptor.
+
+**/
+UINTN
+GetInterruptHandleFromIdt (
+  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDecriptor
+  );
+
+/**
+  This is the main worker function that manages the state of the interrupt
+  handlers.  It both installs and uninstalls interrupt handlers based on the
+  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.
+  If NewCallback is non-NULL, then install is indicated.
+
+  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.
+                        If NULL, specifies that the previously registered handler should
+                        be uninstalled.
+  @param  ExceptionType Indicates which entry to manage.
+
+  @retval EFI_SUCCESS            Process is ok.
+  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has
+                                 no handler registered for it
+  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.
+  @retval others                 Possible return values are passed through from UnHookEntry and HookEntry.
+
+**/
+EFI_STATUS
+ManageIdtEntryTable (
+  CALLBACK_FUNC       NewCallback,
+  EFI_EXCEPTION_TYPE  ExceptionType
+  );
+
+/**
+  Creates a nes entry stub.  Then saves the current IDT entry and replaces it
+  with an interrupt gate for the new entry point.  The IdtEntryTable is updated
+  with the new registered function.
+
+  This code executes in boot services context.  The stub entry executes in interrupt
+  context.
+
+  @param  ExceptionType      Specifies which vector to hook.
+  @param  NewCallback        A pointer to the new function to be registered.
+
+**/
+VOID
+HookEntry (
+  IN EFI_EXCEPTION_TYPE  ExceptionType,
+  IN CALLBACK_FUNC       NewCallback
+  );
+
+/**
+  Undoes HookEntry. This code executes in boot services context.
+
+  @param  ExceptionType   Specifies which entry to unhook
+
+**/
+VOID
+UnhookEntry (
+  IN EFI_EXCEPTION_TYPE  ExceptionType
+  );
+
+#endif
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.c b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.c
index 40fe74d8c2..86e4869bfe 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.c
+++ b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.c
@@ -1,368 +1,368 @@
-/** @file

-  IA32/x64 generic functions to support Debug Support protocol.

-

-Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#include "DebugSupport.h"

-

-//

-// This the global main table to keep track of the interrupts

-//

-IDT_ENTRY  *IdtEntryTable = NULL;

-

-/**

-  Read IDT Gate Descriptor from IDT Table.

-

-  @param  Vector            Specifies vector number.

-  @param  IdtGateDescriptor Pointer to IDT Gate Descriptor read from IDT Table.

-

-**/

-VOID

-ReadIdtGateDescriptor (

-  IN  EFI_EXCEPTION_TYPE        Vector,

-  OUT IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor

-  )

-{

-  IA32_DESCRIPTOR           IdtrValue;

-  IA32_IDT_GATE_DESCRIPTOR  *IdtTable;

-

-  AsmReadIdtr (&IdtrValue);

-  IdtTable = (IA32_IDT_GATE_DESCRIPTOR *)IdtrValue.Base;

-

-  CopyMem ((VOID *)IdtGateDescriptor, (VOID *)&(IdtTable)[Vector], sizeof (IA32_IDT_GATE_DESCRIPTOR));

-}

-

-/**

-  Write IDT Gate Descriptor into IDT Table.

-

-  @param  Vector            Specifies vector number.

-  @param  IdtGateDescriptor Pointer to IDT Gate Descriptor written into IDT Table.

-

-**/

-VOID

-WriteIdtGateDescriptor (

-  EFI_EXCEPTION_TYPE        Vector,

-  IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor

-  )

-{

-  IA32_DESCRIPTOR           IdtrValue;

-  IA32_IDT_GATE_DESCRIPTOR  *IdtTable;

-

-  AsmReadIdtr (&IdtrValue);

-  IdtTable = (IA32_IDT_GATE_DESCRIPTOR *)IdtrValue.Base;

-

-  CopyMem ((VOID *)&(IdtTable)[Vector], (VOID *)IdtGateDescriptor, sizeof (IA32_IDT_GATE_DESCRIPTOR));

-}

-

-/**

-  Creates a nes entry stub.  Then saves the current IDT entry and replaces it

-  with an interrupt gate for the new entry point.  The IdtEntryTable is updated

-  with the new registered function.

-

-  This code executes in boot services context.  The stub entry executes in interrupt

-  context.

-

-  @param  ExceptionType      Specifies which vector to hook.

-  @param  NewCallback        A pointer to the new function to be registered.

-

-**/

-VOID

-HookEntry (

-  IN EFI_EXCEPTION_TYPE  ExceptionType,

-  IN CALLBACK_FUNC       NewCallback

-  )

-{

-  BOOLEAN  OldIntFlagState;

-

-  CreateEntryStub (ExceptionType, (VOID **)&IdtEntryTable[ExceptionType].StubEntry);

-

-  //

-  // Disables CPU interrupts and returns the previous interrupt state

-  //

-  OldIntFlagState = SaveAndDisableInterrupts ();

-

-  //

-  // gets IDT Gate descriptor by index

-  //

-  ReadIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));

-  //

-  // stores orignal interrupt handle

-  //

-  IdtEntryTable[ExceptionType].OrigVector = (DEBUG_PROC)GetInterruptHandleFromIdt (&(IdtEntryTable[ExceptionType].OrigDesc));

-

-  //

-  // encodes new IDT Gate descriptor by stub entry

-  //

-  Vect2Desc (&IdtEntryTable[ExceptionType].NewDesc, IdtEntryTable[ExceptionType].StubEntry);

-  //

-  // stores NewCallback

-  //

-  IdtEntryTable[ExceptionType].RegisteredCallback = NewCallback;

-

-  //

-  // writes back new IDT Gate descriptor

-  //

-  WriteIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].NewDesc));

-

-  //

-  // restore interrupt state

-  //

-  SetInterruptState (OldIntFlagState);

-

-  return;

-}

-

-/**

-  Undoes HookEntry. This code executes in boot services context.

-

-  @param  ExceptionType   Specifies which entry to unhook

-

-**/

-VOID

-UnhookEntry (

-  IN EFI_EXCEPTION_TYPE  ExceptionType

-  )

-{

-  BOOLEAN  OldIntFlagState;

-

-  //

-  // Disables CPU interrupts and returns the previous interrupt state

-  //

-  OldIntFlagState = SaveAndDisableInterrupts ();

-

-  //

-  // restore the default IDT Date Descriptor

-  //

-  WriteIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));

-

-  //

-  // restore interrupt state

-  //

-  SetInterruptState (OldIntFlagState);

-

-  return;

-}

-

-/**

-  Returns the maximum value that may be used for the ProcessorIndex parameter in

-  RegisterPeriodicCallback() and RegisterExceptionCallback().

-

-  Hard coded to support only 1 processor for now.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported

-                                processor index is returned. Always 0 returned.

-

-  @retval EFI_SUCCESS           Always returned with **MaxProcessorIndex set to 0.

-

-**/

-EFI_STATUS

-EFIAPI

-GetMaximumProcessorIndex (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  OUT UINTN                      *MaxProcessorIndex

-  )

-{

-  *MaxProcessorIndex = 0;

-  return EFI_SUCCESS;

-}

-

-/**

-  Registers a function to be called back periodically in interrupt context.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor the callback function applies to.

-  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main

-                                periodic entry point of the debug agent.

-

-  @retval EFI_SUCCESS           The function completed successfully.

-  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback

-                                function was previously registered.

-  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback

-                                function.

-**/

-EFI_STATUS

-EFIAPI

-RegisterPeriodicCallback (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN EFI_PERIODIC_CALLBACK       PeriodicCallback

-  )

-{

-  return ManageIdtEntryTable (PeriodicCallback, SYSTEM_TIMER_VECTOR);

-}

-

-/**

-  Registers a function to be called when a given processor exception occurs.

-

-  This code executes in boot services context.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor the callback function applies to.

-  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called

-                                when the processor exception specified by ExceptionType occurs.

-  @param  ExceptionType         Specifies which processor exception to hook.

-

-  @retval EFI_SUCCESS           The function completed successfully.

-  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback

-                                function was previously registered.

-  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback

-                                function.

-**/

-EFI_STATUS

-EFIAPI

-RegisterExceptionCallback (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,

-  IN EFI_EXCEPTION_TYPE          ExceptionType

-  )

-{

-  return ManageIdtEntryTable (ExceptionCallback, ExceptionType);

-}

-

-/**

-  Invalidates processor instruction cache for a memory range. Subsequent execution in this range

-  causes a fresh memory fetch to retrieve code to be executed.

-

-  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.

-  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.

-  @param  Start                 Specifies the physical base of the memory range to be invalidated.

-  @param  Length                Specifies the minimum number of bytes in the processor's instruction

-                                cache to invalidate.

-

-  @retval EFI_SUCCESS           Always returned.

-

-**/

-EFI_STATUS

-EFIAPI

-InvalidateInstructionCache (

-  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,

-  IN UINTN                       ProcessorIndex,

-  IN VOID                        *Start,

-  IN UINT64                      Length

-  )

-{

-  AsmWbinvd ();

-  return EFI_SUCCESS;

-}

-

-/**

-  Common piece of code that invokes the registered handlers.

-

-  This code executes in exception context so no efi calls are allowed.

-  This code is called from assembly file.

-

-  @param  ExceptionType     Exception type

-  @param  ContextRecord     System context

-

-**/

-VOID

-InterruptDistrubutionHub (

-  EFI_EXCEPTION_TYPE       ExceptionType,

-  EFI_SYSTEM_CONTEXT_IA32  *ContextRecord

-  )

-{

-  if (IdtEntryTable[ExceptionType].RegisteredCallback != NULL) {

-    if (ExceptionType != SYSTEM_TIMER_VECTOR) {

-      IdtEntryTable[ExceptionType].RegisteredCallback (ExceptionType, ContextRecord);

-    } else {

-      OrigVector = IdtEntryTable[ExceptionType].OrigVector;

-      IdtEntryTable[ExceptionType].RegisteredCallback (ContextRecord);

-    }

-  }

-}

-

-/**

-  This is the callback that is written to the Loaded Image protocol instance

-  on the image handle. It uninstalls all registered handlers and frees all entry

-  stub memory.

-

-  @param  ImageHandle    The firmware allocated handle for the EFI image.

-

-  @retval EFI_SUCCESS    Always.

-

-**/

-EFI_STATUS

-EFIAPI

-PlUnloadDebugSupportDriver (

-  IN EFI_HANDLE  ImageHandle

-  )

-{

-  EFI_EXCEPTION_TYPE  ExceptionType;

-

-  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {

-    ManageIdtEntryTable (NULL, ExceptionType);

-    //

-    // Free space for each Interrupt Stub precedure.

-    //

-    if (IdtEntryTable[ExceptionType].StubEntry != NULL) {

-      FreePool ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry);

-    }

-  }

-

-  FreePool (IdtEntryTable);

-

-  return EFI_SUCCESS;

-}

-

-/**

-  Initializes driver's handler registration database.

-

-  This code executes in boot services context.

-  Must be public because it's referenced from DebugSupport.c

-

-  @retval  EFI_UNSUPPORTED      If IA32/x64 processor does not support FXSTOR/FXRSTOR instructions,

-                                the context save will fail, so these processors are not supported.

-  @retval  EFI_OUT_OF_RESOURCES Fails to allocate memory.

-  @retval  EFI_SUCCESS          Initializes successfully.

-

-**/

-EFI_STATUS

-PlInitializeDebugSupportDriver (

-  VOID

-  )

-{

-  EFI_EXCEPTION_TYPE  ExceptionType;

-

-  //

-  // Check whether FxStor instructions are supported.

-  //

-  if (!FxStorSupport ()) {

-    return EFI_UNSUPPORTED;

-  }

-

-  IdtEntryTable = AllocateZeroPool (sizeof (IDT_ENTRY) * NUM_IDT_ENTRIES);

-  if (IdtEntryTable == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {

-    IdtEntryTable[ExceptionType].StubEntry = (DEBUG_PROC)(UINTN)AllocatePool (StubSize);

-    if (IdtEntryTable[ExceptionType].StubEntry == NULL) {

-      goto ErrorCleanup;

-    }

-

-    //

-    // Copy Interrupt stub code.

-    //

-    CopyMem ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry, InterruptEntryStub, StubSize);

-  }

-

-  return EFI_SUCCESS;

-

-ErrorCleanup:

-

-  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {

-    if (IdtEntryTable[ExceptionType].StubEntry != NULL) {

-      FreePool ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry);

-    }

-  }

-

-  FreePool (IdtEntryTable);

-

-  return EFI_OUT_OF_RESOURCES;

-}

+/** @file
+  IA32/x64 generic functions to support Debug Support protocol.
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "DebugSupport.h"
+
+//
+// This the global main table to keep track of the interrupts
+//
+IDT_ENTRY  *IdtEntryTable = NULL;
+
+/**
+  Read IDT Gate Descriptor from IDT Table.
+
+  @param  Vector            Specifies vector number.
+  @param  IdtGateDescriptor Pointer to IDT Gate Descriptor read from IDT Table.
+
+**/
+VOID
+ReadIdtGateDescriptor (
+  IN  EFI_EXCEPTION_TYPE        Vector,
+  OUT IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor
+  )
+{
+  IA32_DESCRIPTOR           IdtrValue;
+  IA32_IDT_GATE_DESCRIPTOR  *IdtTable;
+
+  AsmReadIdtr (&IdtrValue);
+  IdtTable = (IA32_IDT_GATE_DESCRIPTOR *)IdtrValue.Base;
+
+  CopyMem ((VOID *)IdtGateDescriptor, (VOID *)&(IdtTable)[Vector], sizeof (IA32_IDT_GATE_DESCRIPTOR));
+}
+
+/**
+  Write IDT Gate Descriptor into IDT Table.
+
+  @param  Vector            Specifies vector number.
+  @param  IdtGateDescriptor Pointer to IDT Gate Descriptor written into IDT Table.
+
+**/
+VOID
+WriteIdtGateDescriptor (
+  EFI_EXCEPTION_TYPE        Vector,
+  IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor
+  )
+{
+  IA32_DESCRIPTOR           IdtrValue;
+  IA32_IDT_GATE_DESCRIPTOR  *IdtTable;
+
+  AsmReadIdtr (&IdtrValue);
+  IdtTable = (IA32_IDT_GATE_DESCRIPTOR *)IdtrValue.Base;
+
+  CopyMem ((VOID *)&(IdtTable)[Vector], (VOID *)IdtGateDescriptor, sizeof (IA32_IDT_GATE_DESCRIPTOR));
+}
+
+/**
+  Creates a nes entry stub.  Then saves the current IDT entry and replaces it
+  with an interrupt gate for the new entry point.  The IdtEntryTable is updated
+  with the new registered function.
+
+  This code executes in boot services context.  The stub entry executes in interrupt
+  context.
+
+  @param  ExceptionType      Specifies which vector to hook.
+  @param  NewCallback        A pointer to the new function to be registered.
+
+**/
+VOID
+HookEntry (
+  IN EFI_EXCEPTION_TYPE  ExceptionType,
+  IN CALLBACK_FUNC       NewCallback
+  )
+{
+  BOOLEAN  OldIntFlagState;
+
+  CreateEntryStub (ExceptionType, (VOID **)&IdtEntryTable[ExceptionType].StubEntry);
+
+  //
+  // Disables CPU interrupts and returns the previous interrupt state
+  //
+  OldIntFlagState = SaveAndDisableInterrupts ();
+
+  //
+  // gets IDT Gate descriptor by index
+  //
+  ReadIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));
+  //
+  // stores orignal interrupt handle
+  //
+  IdtEntryTable[ExceptionType].OrigVector = (DEBUG_PROC)GetInterruptHandleFromIdt (&(IdtEntryTable[ExceptionType].OrigDesc));
+
+  //
+  // encodes new IDT Gate descriptor by stub entry
+  //
+  Vect2Desc (&IdtEntryTable[ExceptionType].NewDesc, IdtEntryTable[ExceptionType].StubEntry);
+  //
+  // stores NewCallback
+  //
+  IdtEntryTable[ExceptionType].RegisteredCallback = NewCallback;
+
+  //
+  // writes back new IDT Gate descriptor
+  //
+  WriteIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].NewDesc));
+
+  //
+  // restore interrupt state
+  //
+  SetInterruptState (OldIntFlagState);
+
+  return;
+}
+
+/**
+  Undoes HookEntry. This code executes in boot services context.
+
+  @param  ExceptionType   Specifies which entry to unhook
+
+**/
+VOID
+UnhookEntry (
+  IN EFI_EXCEPTION_TYPE  ExceptionType
+  )
+{
+  BOOLEAN  OldIntFlagState;
+
+  //
+  // Disables CPU interrupts and returns the previous interrupt state
+  //
+  OldIntFlagState = SaveAndDisableInterrupts ();
+
+  //
+  // restore the default IDT Date Descriptor
+  //
+  WriteIdtGateDescriptor (ExceptionType, &(IdtEntryTable[ExceptionType].OrigDesc));
+
+  //
+  // restore interrupt state
+  //
+  SetInterruptState (OldIntFlagState);
+
+  return;
+}
+
+/**
+  Returns the maximum value that may be used for the ProcessorIndex parameter in
+  RegisterPeriodicCallback() and RegisterExceptionCallback().
+
+  Hard coded to support only 1 processor for now.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported
+                                processor index is returned. Always 0 returned.
+
+  @retval EFI_SUCCESS           Always returned with **MaxProcessorIndex set to 0.
+
+**/
+EFI_STATUS
+EFIAPI
+GetMaximumProcessorIndex (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  OUT UINTN                      *MaxProcessorIndex
+  )
+{
+  *MaxProcessorIndex = 0;
+  return EFI_SUCCESS;
+}
+
+/**
+  Registers a function to be called back periodically in interrupt context.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main
+                                periodic entry point of the debug agent.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback
+                                function.
+**/
+EFI_STATUS
+EFIAPI
+RegisterPeriodicCallback (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN EFI_PERIODIC_CALLBACK       PeriodicCallback
+  )
+{
+  return ManageIdtEntryTable (PeriodicCallback, SYSTEM_TIMER_VECTOR);
+}
+
+/**
+  Registers a function to be called when a given processor exception occurs.
+
+  This code executes in boot services context.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called
+                                when the processor exception specified by ExceptionType occurs.
+  @param  ExceptionType         Specifies which processor exception to hook.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback
+                                function.
+**/
+EFI_STATUS
+EFIAPI
+RegisterExceptionCallback (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,
+  IN EFI_EXCEPTION_TYPE          ExceptionType
+  )
+{
+  return ManageIdtEntryTable (ExceptionCallback, ExceptionType);
+}
+
+/**
+  Invalidates processor instruction cache for a memory range. Subsequent execution in this range
+  causes a fresh memory fetch to retrieve code to be executed.
+
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.
+  @param  Start                 Specifies the physical base of the memory range to be invalidated.
+  @param  Length                Specifies the minimum number of bytes in the processor's instruction
+                                cache to invalidate.
+
+  @retval EFI_SUCCESS           Always returned.
+
+**/
+EFI_STATUS
+EFIAPI
+InvalidateInstructionCache (
+  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+  IN UINTN                       ProcessorIndex,
+  IN VOID                        *Start,
+  IN UINT64                      Length
+  )
+{
+  AsmWbinvd ();
+  return EFI_SUCCESS;
+}
+
+/**
+  Common piece of code that invokes the registered handlers.
+
+  This code executes in exception context so no efi calls are allowed.
+  This code is called from assembly file.
+
+  @param  ExceptionType     Exception type
+  @param  ContextRecord     System context
+
+**/
+VOID
+InterruptDistrubutionHub (
+  EFI_EXCEPTION_TYPE       ExceptionType,
+  EFI_SYSTEM_CONTEXT_IA32  *ContextRecord
+  )
+{
+  if (IdtEntryTable[ExceptionType].RegisteredCallback != NULL) {
+    if (ExceptionType != SYSTEM_TIMER_VECTOR) {
+      IdtEntryTable[ExceptionType].RegisteredCallback (ExceptionType, ContextRecord);
+    } else {
+      OrigVector = IdtEntryTable[ExceptionType].OrigVector;
+      IdtEntryTable[ExceptionType].RegisteredCallback (ContextRecord);
+    }
+  }
+}
+
+/**
+  This is the callback that is written to the Loaded Image protocol instance
+  on the image handle. It uninstalls all registered handlers and frees all entry
+  stub memory.
+
+  @param  ImageHandle    The firmware allocated handle for the EFI image.
+
+  @retval EFI_SUCCESS    Always.
+
+**/
+EFI_STATUS
+EFIAPI
+PlUnloadDebugSupportDriver (
+  IN EFI_HANDLE  ImageHandle
+  )
+{
+  EFI_EXCEPTION_TYPE  ExceptionType;
+
+  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
+    ManageIdtEntryTable (NULL, ExceptionType);
+    //
+    // Free space for each Interrupt Stub precedure.
+    //
+    if (IdtEntryTable[ExceptionType].StubEntry != NULL) {
+      FreePool ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry);
+    }
+  }
+
+  FreePool (IdtEntryTable);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Initializes driver's handler registration database.
+
+  This code executes in boot services context.
+  Must be public because it's referenced from DebugSupport.c
+
+  @retval  EFI_UNSUPPORTED      If IA32/x64 processor does not support FXSTOR/FXRSTOR instructions,
+                                the context save will fail, so these processors are not supported.
+  @retval  EFI_OUT_OF_RESOURCES Fails to allocate memory.
+  @retval  EFI_SUCCESS          Initializes successfully.
+
+**/
+EFI_STATUS
+PlInitializeDebugSupportDriver (
+  VOID
+  )
+{
+  EFI_EXCEPTION_TYPE  ExceptionType;
+
+  //
+  // Check whether FxStor instructions are supported.
+  //
+  if (!FxStorSupport ()) {
+    return EFI_UNSUPPORTED;
+  }
+
+  IdtEntryTable = AllocateZeroPool (sizeof (IDT_ENTRY) * NUM_IDT_ENTRIES);
+  if (IdtEntryTable == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
+    IdtEntryTable[ExceptionType].StubEntry = (DEBUG_PROC)(UINTN)AllocatePool (StubSize);
+    if (IdtEntryTable[ExceptionType].StubEntry == NULL) {
+      goto ErrorCleanup;
+    }
+
+    //
+    // Copy Interrupt stub code.
+    //
+    CopyMem ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry, InterruptEntryStub, StubSize);
+  }
+
+  return EFI_SUCCESS;
+
+ErrorCleanup:
+
+  for (ExceptionType = 0; ExceptionType < NUM_IDT_ENTRIES; ExceptionType++) {
+    if (IdtEntryTable[ExceptionType].StubEntry != NULL) {
+      FreePool ((VOID *)(UINTN)IdtEntryTable[ExceptionType].StubEntry);
+    }
+  }
+
+  FreePool (IdtEntryTable);
+
+  return EFI_OUT_OF_RESOURCES;
+}
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.h b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.h
index c3f0d96d28..96963685ae 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.h
+++ b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupport.h
@@ -1,16 +1,16 @@
-/** @file

-  IA32 specific debug support macros, typedefs and prototypes.

-

-Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#ifndef _PLDEBUG_SUPPORT_H_

-#define _PLDEBUG_SUPPORT_H_

-

-#include "Ia32/DebugSupport.h"

-

-#define EFI_ISA  IsaIa32

-

-#endif

+/** @file
+  IA32 specific debug support macros, typedefs and prototypes.
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _PLDEBUG_SUPPORT_H_
+#define _PLDEBUG_SUPPORT_H_
+
+#include "Ia32/DebugSupport.h"
+
+#define EFI_ISA  IsaIa32
+
+#endif
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupportIa32.c b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupportIa32.c
index 0201427ade..f1386817a2 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupportIa32.c
+++ b/MdeModulePkg/Universal/DebugSupportDxe/Ia32/PlDebugSupportIa32.c
@@ -1,141 +1,141 @@
-/** @file

-  IA32 specific functions to support Debug Support protocol.

-

-Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#include "PlDebugSupport.h"

-

-IA32_IDT_GATE_DESCRIPTOR  NullDesc = {

-  { 0 }

-};

-

-/**

-  Get Interrupt Handle from IDT Gate Descriptor.

-

-  @param  IdtGateDescriptor  IDT Gate Descriptor.

-

-  @return Interrupt Handle stored in IDT Gate Descriptor.

-

-**/

-UINTN

-GetInterruptHandleFromIdt (

-  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor

-  )

-{

-  UINTN  InterruptHandle;

-

-  //

-  // InterruptHandle  0-15 : OffsetLow

-  // InterruptHandle 16-31 : OffsetHigh

-  //

-  ((UINT16 *)&InterruptHandle)[0] = (UINT16)IdtGateDescriptor->Bits.OffsetLow;

-  ((UINT16 *)&InterruptHandle)[1] = (UINT16)IdtGateDescriptor->Bits.OffsetHigh;

-

-  return InterruptHandle;

-}

-

-/**

-  Allocate pool for a new IDT entry stub.

-

-  Copy the generic stub into the new buffer and fixup the vector number

-  and jump target address.

-

-  @param  ExceptionType   This is the exception type that the new stub will be created

-                          for.

-  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.

-

-**/

-VOID

-CreateEntryStub (

-  IN EFI_EXCEPTION_TYPE  ExceptionType,

-  OUT VOID               **Stub

-  )

-{

-  UINT8  *StubCopy;

-

-  StubCopy = *Stub;

-

-  //

-  // Fixup the stub code for this vector

-  //

-

-  // The stub code looks like this:

-  //

-  //    00000000  89 25 00000004 R  mov     AppEsp, esp             ; save stack top

-  //    00000006  BC 00008014 R     mov     esp, offset DbgStkBot   ; switch to debugger stack

-  //    0000000B  6A 00             push    0                       ; push vector number - will be modified before installed

-  //    0000000D  E9                db      0e9h                    ; jump rel32

-  //    0000000E  00000000          dd      0                       ; fixed up to relative address of CommonIdtEntry

-  //

-

-  //

-  // poke in the exception type so the second push pushes the exception type

-  //

-  StubCopy[0x0c] = (UINT8)ExceptionType;

-

-  //

-  // fixup the jump target to point to the common entry

-  //

-  *(UINT32 *)&StubCopy[0x0e] = (UINT32)CommonIdtEntry - (UINT32)&StubCopy[StubSize];

-

-  return;

-}

-

-/**

-  This is the main worker function that manages the state of the interrupt

-  handlers.  It both installs and uninstalls interrupt handlers based on the

-  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.

-  If NewCallback is non-NULL, then install is indicated.

-

-  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.

-                        If NULL, specifies that the previously registered handler should

-                        be uninstalled.

-  @param  ExceptionType Indicates which entry to manage.

-

-  @retval EFI_SUCCESS            Installing or Uninstalling operation is ok.

-  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has

-                                 no handler registered for it

-  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.

-

-**/

-EFI_STATUS

-ManageIdtEntryTable (

-  CALLBACK_FUNC       NewCallback,

-  EFI_EXCEPTION_TYPE  ExceptionType

-  )

-{

-  EFI_STATUS  Status;

-

-  Status = EFI_SUCCESS;

-

-  if (CompareMem (&IdtEntryTable[ExceptionType].NewDesc, &NullDesc, sizeof (IA32_IDT_GATE_DESCRIPTOR)) != 0) {

-    //

-    // we've already installed to this vector

-    //

-    if (NewCallback != NULL) {

-      //

-      // if the input handler is non-null, error

-      //

-      Status = EFI_ALREADY_STARTED;

-    } else {

-      UnhookEntry (ExceptionType);

-    }

-  } else {

-    //

-    // no user handler installed on this vector

-    //

-    if (NewCallback == NULL) {

-      //

-      // if the input handler is null, error

-      //

-      Status = EFI_INVALID_PARAMETER;

-    } else {

-      HookEntry (ExceptionType, NewCallback);

-    }

-  }

-

-  return Status;

-}

+/** @file
+  IA32 specific functions to support Debug Support protocol.
+
+Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "PlDebugSupport.h"
+
+IA32_IDT_GATE_DESCRIPTOR  NullDesc = {
+  { 0 }
+};
+
+/**
+  Get Interrupt Handle from IDT Gate Descriptor.
+
+  @param  IdtGateDescriptor  IDT Gate Descriptor.
+
+  @return Interrupt Handle stored in IDT Gate Descriptor.
+
+**/
+UINTN
+GetInterruptHandleFromIdt (
+  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDescriptor
+  )
+{
+  UINTN  InterruptHandle;
+
+  //
+  // InterruptHandle  0-15 : OffsetLow
+  // InterruptHandle 16-31 : OffsetHigh
+  //
+  ((UINT16 *)&InterruptHandle)[0] = (UINT16)IdtGateDescriptor->Bits.OffsetLow;
+  ((UINT16 *)&InterruptHandle)[1] = (UINT16)IdtGateDescriptor->Bits.OffsetHigh;
+
+  return InterruptHandle;
+}
+
+/**
+  Allocate pool for a new IDT entry stub.
+
+  Copy the generic stub into the new buffer and fixup the vector number
+  and jump target address.
+
+  @param  ExceptionType   This is the exception type that the new stub will be created
+                          for.
+  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.
+
+**/
+VOID
+CreateEntryStub (
+  IN EFI_EXCEPTION_TYPE  ExceptionType,
+  OUT VOID               **Stub
+  )
+{
+  UINT8  *StubCopy;
+
+  StubCopy = *Stub;
+
+  //
+  // Fixup the stub code for this vector
+  //
+
+  // The stub code looks like this:
+  //
+  //    00000000  89 25 00000004 R  mov     AppEsp, esp             ; save stack top
+  //    00000006  BC 00008014 R     mov     esp, offset DbgStkBot   ; switch to debugger stack
+  //    0000000B  6A 00             push    0                       ; push vector number - will be modified before installed
+  //    0000000D  E9                db      0e9h                    ; jump rel32
+  //    0000000E  00000000          dd      0                       ; fixed up to relative address of CommonIdtEntry
+  //
+
+  //
+  // poke in the exception type so the second push pushes the exception type
+  //
+  StubCopy[0x0c] = (UINT8)ExceptionType;
+
+  //
+  // fixup the jump target to point to the common entry
+  //
+  *(UINT32 *)&StubCopy[0x0e] = (UINT32)CommonIdtEntry - (UINT32)&StubCopy[StubSize];
+
+  return;
+}
+
+/**
+  This is the main worker function that manages the state of the interrupt
+  handlers.  It both installs and uninstalls interrupt handlers based on the
+  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.
+  If NewCallback is non-NULL, then install is indicated.
+
+  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.
+                        If NULL, specifies that the previously registered handler should
+                        be uninstalled.
+  @param  ExceptionType Indicates which entry to manage.
+
+  @retval EFI_SUCCESS            Installing or Uninstalling operation is ok.
+  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has
+                                 no handler registered for it
+  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.
+
+**/
+EFI_STATUS
+ManageIdtEntryTable (
+  CALLBACK_FUNC       NewCallback,
+  EFI_EXCEPTION_TYPE  ExceptionType
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = EFI_SUCCESS;
+
+  if (CompareMem (&IdtEntryTable[ExceptionType].NewDesc, &NullDesc, sizeof (IA32_IDT_GATE_DESCRIPTOR)) != 0) {
+    //
+    // we've already installed to this vector
+    //
+    if (NewCallback != NULL) {
+      //
+      // if the input handler is non-null, error
+      //
+      Status = EFI_ALREADY_STARTED;
+    } else {
+      UnhookEntry (ExceptionType);
+    }
+  } else {
+    //
+    // no user handler installed on this vector
+    //
+    if (NewCallback == NULL) {
+      //
+      // if the input handler is null, error
+      //
+      Status = EFI_INVALID_PARAMETER;
+    } else {
+      HookEntry (ExceptionType, NewCallback);
+    }
+  }
+
+  return Status;
+}
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.nasm b/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.nasm
index c6c5e49189..bc25fbffae 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.nasm
+++ b/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.nasm
@@ -1,566 +1,566 @@
-;/** @file

-;  Low level x64 routines used by the debug support driver.

-;

-;  Copyright (c) 2007 - 2022, Intel Corporation. All rights reserved.<BR>

-;  SPDX-License-Identifier: BSD-2-Clause-Patent

-;

-;**/

-

-%define EXCPT64_DIVIDE_ERROR 0

-%define EXCPT64_DEBUG 1

-%define EXCPT64_NMI 2

-%define EXCPT64_BREAKPOINT 3

-%define EXCPT64_OVERFLOW 4

-%define EXCPT64_BOUND 5

-%define EXCPT64_INVALID_OPCODE 6

-%define EXCPT64_DOUBLE_FAULT 8

-%define EXCPT64_INVALID_TSS 10

-%define EXCPT64_SEG_NOT_PRESENT 11

-%define EXCPT64_STACK_FAULT 12

-%define EXCPT64_GP_FAULT 13

-%define EXCPT64_PAGE_FAULT 14

-%define EXCPT64_FP_ERROR 16

-%define EXCPT64_ALIGNMENT_CHECK 17

-%define EXCPT64_MACHINE_CHECK 18

-%define EXCPT64_SIMD 19

-

-%define FXSTOR_FLAG 0x1000000         ; bit cpuid 24 of feature flags

-

-SECTION .data

-

-global ASM_PFX(OrigVector)

-global ASM_PFX(InterruptEntryStub)

-global ASM_PFX(StubSize)

-global ASM_PFX(CommonIdtEntry)

-global ASM_PFX(FxStorSupport)

-extern ASM_PFX(InterruptDistrubutionHub)

-

-ASM_PFX(StubSize): dd InterruptEntryStubEnd - ASM_PFX(InterruptEntryStub)

-AppRsp: dq 0x1111111111111111 ; ?

-DebugRsp: dq 0x2222222222222222 ; ?

-ExtraPush: dq 0x3333333333333333 ; ?

-ExceptData: dq 0x4444444444444444 ; ?

-Rflags: dq 0x5555555555555555 ; ?

-ASM_PFX(OrigVector): dq 0x6666666666666666 ; ?

-

-;; The declarations below define the memory region that will be used for the debug stack.

-;; The context record will be built by pushing register values onto this stack.

-;; It is imparitive that alignment be carefully managed, since the FXSTOR and

-;; FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.

-;;

-;; The stub will switch stacks from the application stack to the debuger stack

-;; and pushes the exception number.

-;;

-;; Then we building the context record on the stack. Since the stack grows down,

-;; we push the fields of the context record from the back to the front.  There

-;; are 336 bytes of stack used prior allocating the 512 bytes of stack to be

-;; used as the memory buffer for the fxstor instruction. Therefore address of

-;; the buffer used for the FXSTOR instruction is &Eax - 336 - 512, which

-;; must be 16 byte aligned.

-;;

-;; We carefully locate the stack to make this happen.

-;;

-;; For reference, the context structure looks like this:

-;;      struct {

-;;        UINT64            ExceptionData;

-;;        FX_SAVE_STATE_X64 FxSaveState;    // 512 bytes, must be 16 byte aligned

-;;        UINT64            Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-;;        UINT64            Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;

-;;        UINT64            RFlags;

-;;        UINT64            Ldtr, Tr;

-;;        UINT64            Gdtr[2], Idtr[2];

-;;        UINT64            Rip;

-;;        UINT64            Gs, Fs, Es, Ds, Cs, Ss;

-;;        UINT64            Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

-;;        UINT64            R8, R9, R10, R11, R12, R13, R14, R15;

-;;      } SYSTEM_CONTEXT_X64;  // 64 bit system context record

-

-align           16

-DebugStackEnd: db "DbgStkEnd >>>>>>"    ;; 16 byte long string - must be 16 bytes to preserve alignment

-                times 0x1ffc dd    0x0  ;; 32K should be enough stack

-                                        ;;   This allocation is coocked to insure

-                                        ;;   that the the buffer for the FXSTORE instruction

-                                        ;;   will be 16 byte aligned also.

-                                        ;;

-ExceptionNumber: dq 0                   ;; first entry will be the vector number pushed by the stub

-

-DebugStackBegin: db "<<<< DbgStkBegin"  ;; initial debug ESP == DebugStackBegin, set in stub

-

-DEFAULT REL

-SECTION .text

-

-;------------------------------------------------------------------------------

-; BOOLEAN

-; FxStorSupport (

-;   void

-;   )

-;

-; Abstract: Returns TRUE if FxStor instructions are supported

-;

-global ASM_PFX(FxStorSupport)

-ASM_PFX(FxStorSupport):

-

-;

-; cpuid corrupts rbx which must be preserved per the C calling convention

-;

-                push    rbx

-                mov     rax, dword 1

-                cpuid

-                mov     eax, edx

-                and     rax, FXSTOR_FLAG

-                shr     rax, 24

-                pop     rbx

-                ret

-

-;------------------------------------------------------------------------------

-; void

-; Vect2Desc (

-;   IA32_IDT_GATE_DESCRIPTOR * DestDesc,  // rcx

-;   void (*Vector) (void)   // rdx

-;   )

-;

-; Abstract: Encodes an IDT descriptor with the given physical address

-;

-global ASM_PFX(Vect2Desc)

-ASM_PFX(Vect2Desc):

-

-                mov     rax, rdx

-                mov     word [rcx], ax                  ; write bits 15..0 of offset

-                mov     dx, cs

-                mov     word [rcx+2], dx                ; SYS_CODE_SEL from GDT

-                mov     word [rcx+4], 0xe00 | 0x8000    ; type = 386 interrupt gate, present

-                shr     rax, 16

-                mov     word [rcx+6], ax                ; write bits 31..16 of offset

-                shr     rax, 16

-                mov     dword [rcx+8], eax              ; write bits 63..32 of offset

-

-                ret

-

-;------------------------------------------------------------------------------

-; InterruptEntryStub

-;

-; Abstract: This code is not a function, but is a small piece of code that is

-;               copied and fixed up once for each IDT entry that is hooked.

-;

-ASM_PFX(InterruptEntryStub):

-                push    0                       ; push vector number - will be modified before installed

-                db      0xe9                    ; jump rel32

-                dd      0                       ; fixed up to relative address of CommonIdtEntry

-InterruptEntryStubEnd:

-

-;------------------------------------------------------------------------------

-; CommonIdtEntry

-;

-; Abstract: This code is not a function, but is the common part for all IDT

-;               vectors.

-;

-ASM_PFX(CommonIdtEntry):

-;;

-;; At this point, the stub has saved the current application stack esp into AppRsp

-;; and switched stacks to the debug stack, where it pushed the vector number

-;;

-;; The application stack looks like this:

-;;

-;;              ...

-;;              (last application stack entry)

-;;              [16 bytes alignment, do not care it]

-;;              SS from interrupted task

-;;              RSP from interrupted task

-;;              rflags from interrupted task

-;;              CS from interrupted task

-;;              RIP from interrupted task

-;;              Error code <-------------------- Only present for some exeption types

-;;

-;;              Vector Number <----------------- pushed in our IDT Entry

-;;

-

-;; The stub switched us to the debug stack and pushed the interrupt number.

-;;

-;; Next, construct the context record.  It will be build on the debug stack by

-;; pushing the registers in the correct order so as to create the context structure

-;; on the debug stack.  The context record must be built from the end back to the

-;; beginning because the stack grows down...

-;

-;; For reference, the context record looks like this:

-;;

-;; typedef

-;; struct {

-;;   UINT64            ExceptionData;

-;;   FX_SAVE_STATE_X64 FxSaveState;

-;;   UINT64            Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-;;   UINT64            Cr0, Cr2, Cr3, Cr4, Cr8;

-;;   UINT64            RFlags;

-;;   UINT64            Ldtr, Tr;

-;;   UINT64            Gdtr[2], Idtr[2];

-;;   UINT64            Rip;

-;;   UINT64            Gs, Fs, Es, Ds, Cs, Ss;

-;;   UINT64            Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

-;;   UINT64            R8, R9, R10, R11, R12, R13, R14, R15;

-;; } SYSTEM_CONTEXT_X64;  // 64 bit system context record

-

-;; NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp

-                push    rax

-                mov     rax, qword [rsp+8]               ; save vector number

-                mov     [ExceptionNumber], rax           ; save vector number

-                pop     rax

-                add     rsp, 8                           ; pop vector number

-                mov     [AppRsp], rsp                    ; save stack top

-                lea     rsp, [DebugStackBegin]           ; switch to debugger stack

-                sub     rsp, 8                           ; leave space for vector number

-

-;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

-;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;

-                push    r15

-                push    r14

-                push    r13

-                push    r12

-                push    r11

-                push    r10

-                push    r9

-                push    r8

-                push    rax

-                push    rcx

-                push    rdx

-                push    rbx

-                push    rsp

-                push    rbp

-                push    rsi

-                push    rdi

-

-;; Save interrupt state rflags register...

-                pushfq

-                pop     rax

-                mov     [Rflags], rax

-

-;; We need to determine if any extra data was pushed by the exception, and if so, save it

-;; To do this, we check the exception number pushed by the stub, and cache the

-;; result in a variable since we'll need this again.

-                cmp     qword [ExceptionNumber], EXCPT64_DOUBLE_FAULT

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_INVALID_TSS

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_SEG_NOT_PRESENT

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_STACK_FAULT

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_GP_FAULT

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_PAGE_FAULT

-                jz      ExtraPushOne

-                cmp     qword [ExceptionNumber], EXCPT64_ALIGNMENT_CHECK

-                jz      ExtraPushOne

-                mov     qword [ExtraPush], 0

-                mov     qword [ExceptData], 0

-                jmp     ExtraPushDone

-ExtraPushOne:

-                mov     qword [ExtraPush], 1

-

-;; If there's some extra data, save it also, and modify the saved AppRsp to effectively

-;; pop this value off the application's stack.

-                mov     rax, [AppRsp]

-                mov     rbx, [rax]

-                mov     qword [ExceptData], rbx

-                add     rax, 8

-                mov     [AppRsp], rax

-

-ExtraPushDone:

-

-;; The "push" above pushed the debug stack rsp.  Since what we're actually doing

-;; is building the context record on the debug stack, we need to save the pushed

-;; debug RSP, and replace it with the application's last stack entry...

-                mov     rax, [rsp + 24]

-                mov     [DebugRsp], rax

-                mov     rax, [AppRsp]

-                mov     rax, QWORD [rax + 24]

-                ; application stack has ss, rsp, rflags, cs, & rip, so

-                ; last actual application stack entry is saved at offset

-                ; 24 bytes from stack top.

-                mov     [rsp + 24], rax

-

-;; continue building context record

-;; UINT64  Gs, Fs, Es, Ds, Cs, Ss;  insure high 16 bits of each is zero

-                mov     rax, ss

-                push    rax

-

-                ; CS from application is one entry back in application stack

-                mov     rax, [AppRsp]

-                movzx   rax, word [rax + 8]

-                push    rax

-

-                mov     rax, ds

-                push    rax

-                mov     rax, es

-                push    rax

-                mov     rax, fs

-                push    rax

-                mov     rax, gs

-                push    rax

-

-;; UINT64  Rip;

-                ; Rip from application is on top of application stack

-                mov     rax, [AppRsp]

-                push    qword [rax]

-

-;; UINT64  Gdtr[2], Idtr[2];

-                push    0

-                push    0

-                sidt    [rsp]

-                push    0

-                push    0

-                sgdt    [rsp]

-

-;; UINT64  Ldtr, Tr;

-                xor     rax, rax

-                str     ax

-                push    rax

-                sldt    ax

-                push    rax

-

-;; UINT64  RFlags;

-;; Rflags from application is two entries back in application stack

-                mov     rax, [AppRsp]

-                push    qword [rax + 16]

-

-;; UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;

-;; insure FXSAVE/FXRSTOR is enabled in CR4...

-;; ... while we're at it, make sure DE is also enabled...

-                mov     rax, cr8

-                push    rax

-                mov     rax, cr4

-                or      rax, 0x208

-                mov     cr4, rax

-                push    rax

-                mov     rax, cr3

-                push    rax

-                mov     rax, cr2

-                push    rax

-                push    0

-                mov     rax, cr0

-                push    rax

-

-;; UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-                mov     rax, dr7

-                push    rax

-;; clear Dr7 while executing debugger itself

-                xor     rax, rax

-                mov     dr7, rax

-

-                mov     rax, dr6

-                push    rax

-;; insure all status bits in dr6 are clear...

-                xor     rax, rax

-                mov     dr6, rax

-

-                mov     rax, dr3

-                push    rax

-                mov     rax, dr2

-                push    rax

-                mov     rax, dr1

-                push    rax

-                mov     rax, dr0

-                push    rax

-

-;; FX_SAVE_STATE_X64 FxSaveState;

-                sub     rsp, 512

-                mov     rdi, rsp

-                ; IMPORTANT!! The debug stack has been carefully constructed to

-                ; insure that rsp and rdi are 16 byte aligned when we get here.

-                ; They MUST be.  If they are not, a GP fault will occur.

-                fxsave  [rdi]

-

-;; UEFI calling convention for x64 requires that Direction flag in EFLAGs is clear

-                cld

-

-;; UINT64  ExceptionData;

-                mov     rax, [ExceptData]

-                push    rax

-

-; call to C code which will in turn call registered handler

-; pass in the vector number

-                mov     rdx, rsp

-                mov     rcx, [ExceptionNumber]

-                sub     rsp, 40

-                call    ASM_PFX(InterruptDistrubutionHub)

-                add     rsp, 40

-

-; restore context...

-;; UINT64  ExceptionData;

-                add     rsp, 8

-

-;; FX_SAVE_STATE_X64 FxSaveState;

-                mov     rsi, rsp

-                fxrstor [rsi]

-                add     rsp, 512

-

-;; UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

-                pop     rax

-                mov     dr0, rax

-                pop     rax

-                mov     dr1, rax

-                pop     rax

-                mov     dr2, rax

-                pop     rax

-                mov     dr3, rax

-;; skip restore of dr6.  We cleared dr6 during the context save.

-                add     rsp, 8

-                pop     rax

-                mov     dr7, rax

-

-;; UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;

-                pop     rax

-                mov     cr0, rax

-                add     rsp, 8

-                pop     rax

-                mov     cr2, rax

-                pop     rax

-                mov     cr3, rax

-                pop     rax

-                mov     cr4, rax

-                pop     rax

-                mov     cr8, rax

-

-;; UINT64  RFlags;

-                mov     rax, [AppRsp]

-                pop     qword [rax + 16]

-

-;; UINT64  Ldtr, Tr;

-;; UINT64  Gdtr[2], Idtr[2];

-;; Best not let anyone mess with these particular registers...

-                add     rsp, 48

-

-;; UINT64  Rip;

-                pop     qword [rax]

-

-;; UINT64  Gs, Fs, Es, Ds, Cs, Ss;

-;; NOTE - modified segment registers could hang the debugger...  We

-;;        could attempt to insulate ourselves against this possibility,

-;;        but that poses risks as well.

-;;

-

-                pop     rax

-                ; mov     gs, rax

-                pop     rax

-                ; mov     fs, rax

-                pop     rax

-                mov     es, rax

-                pop     rax

-                mov     ds, rax

-                mov     rax, [AppRsp]

-                pop     qword [rax + 8]

-                pop     rax

-                mov     ss, rax

-

-;; The next stuff to restore is the general purpose registers that were pushed

-;; using the "push" instruction.

-;;

-;; The value of RSP as stored in the context record is the application RSP

-;; including the 5 entries on the application stack caused by the exception

-;; itself. It may have been modified by the debug agent, so we need to

-;; determine if we need to relocate the application stack.

-

-                mov     rbx, [rsp + 24]  ; move the potentially modified AppRsp into rbx

-                mov     rax, [AppRsp]

-                mov     rax, QWORD [rax + 24]

-                cmp     rbx, rax

-                je      NoAppStackMove

-

-                mov     rax, [AppRsp]

-                mov     rcx, [rax]       ; RIP

-                mov     [rbx], rcx

-

-                mov     rcx, [rax + 8]   ; CS

-                mov     [rbx + 8], rcx

-

-                mov     rcx, [rax + 16]  ; RFLAGS

-                mov     [rbx + 16], rcx

-

-                mov     rcx, [rax + 24]  ; RSP

-                mov     [rbx + 24], rcx

-

-                mov     rcx, [rax + 32]  ; SS

-                mov     [rbx + 32], rcx

-

-                mov     rax, rbx         ; modify the saved AppRsp to the new AppRsp

-                mov     [AppRsp], rax

-NoAppStackMove:

-                mov     rax, [DebugRsp]  ; restore the DebugRsp on the debug stack

-                                         ; so our "pop" will not cause a stack switch

-                mov     [rsp + 24], rax

-

-                cmp     qword [ExceptionNumber], 0x68

-                jne     NoChain

-

-Chain:

-

-;; Restore rflags so when we chain, the flags will be exactly as if we were never here.

-;; We gin up the stack to do an iretq so we can get ALL the flags.

-                mov     rax, [AppRsp]

-                mov     rbx, [rax + 40]

-                push    rbx

-                mov     rax, ss

-                push    rax

-                mov     rax, rsp

-                add     rax, 16

-                push    rax

-                mov     rax, [AppRsp]

-                mov     rbx, [rax + 16]

-                and     rbx, ~ 0x300 ; special handling for IF and TF

-                push    rbx

-                mov     rax, cs

-                push    rax

-                lea     rax, [PhonyIretq]

-                push    rax

-                iretq

-PhonyIretq:

-

-;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

-;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;

-                pop     rdi

-                pop     rsi

-                pop     rbp

-                pop     rsp

-                pop     rbx

-                pop     rdx

-                pop     rcx

-                pop     rax

-                pop     r8

-                pop     r9

-                pop     r10

-                pop     r11

-                pop     r12

-                pop     r13

-                pop     r14

-                pop     r15

-

-;; Switch back to application stack

-                mov     rsp, [AppRsp]

-

-;; Jump to original handler

-                jmp     [ASM_PFX(OrigVector)]

-

-NoChain:

-;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

-;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;

-                pop     rdi

-                pop     rsi

-                pop     rbp

-                pop     rsp

-                pop     rbx

-                pop     rdx

-                pop     rcx

-                pop     rax

-                pop     r8

-                pop     r9

-                pop     r10

-                pop     r11

-                pop     r12

-                pop     r13

-                pop     r14

-                pop     r15

-

-;; Switch back to application stack

-                mov     rsp, [AppRsp]

-

-;; We're outa here...

-                iretq

-

+;/** @file
+;  Low level x64 routines used by the debug support driver.
+;
+;  Copyright (c) 2007 - 2022, Intel Corporation. All rights reserved.<BR>
+;  SPDX-License-Identifier: BSD-2-Clause-Patent
+;
+;**/
+
+%define EXCPT64_DIVIDE_ERROR 0
+%define EXCPT64_DEBUG 1
+%define EXCPT64_NMI 2
+%define EXCPT64_BREAKPOINT 3
+%define EXCPT64_OVERFLOW 4
+%define EXCPT64_BOUND 5
+%define EXCPT64_INVALID_OPCODE 6
+%define EXCPT64_DOUBLE_FAULT 8
+%define EXCPT64_INVALID_TSS 10
+%define EXCPT64_SEG_NOT_PRESENT 11
+%define EXCPT64_STACK_FAULT 12
+%define EXCPT64_GP_FAULT 13
+%define EXCPT64_PAGE_FAULT 14
+%define EXCPT64_FP_ERROR 16
+%define EXCPT64_ALIGNMENT_CHECK 17
+%define EXCPT64_MACHINE_CHECK 18
+%define EXCPT64_SIMD 19
+
+%define FXSTOR_FLAG 0x1000000         ; bit cpuid 24 of feature flags
+
+SECTION .data
+
+global ASM_PFX(OrigVector)
+global ASM_PFX(InterruptEntryStub)
+global ASM_PFX(StubSize)
+global ASM_PFX(CommonIdtEntry)
+global ASM_PFX(FxStorSupport)
+extern ASM_PFX(InterruptDistrubutionHub)
+
+ASM_PFX(StubSize): dd InterruptEntryStubEnd - ASM_PFX(InterruptEntryStub)
+AppRsp: dq 0x1111111111111111 ; ?
+DebugRsp: dq 0x2222222222222222 ; ?
+ExtraPush: dq 0x3333333333333333 ; ?
+ExceptData: dq 0x4444444444444444 ; ?
+Rflags: dq 0x5555555555555555 ; ?
+ASM_PFX(OrigVector): dq 0x6666666666666666 ; ?
+
+;; The declarations below define the memory region that will be used for the debug stack.
+;; The context record will be built by pushing register values onto this stack.
+;; It is imparitive that alignment be carefully managed, since the FXSTOR and
+;; FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.
+;;
+;; The stub will switch stacks from the application stack to the debuger stack
+;; and pushes the exception number.
+;;
+;; Then we building the context record on the stack. Since the stack grows down,
+;; we push the fields of the context record from the back to the front.  There
+;; are 336 bytes of stack used prior allocating the 512 bytes of stack to be
+;; used as the memory buffer for the fxstor instruction. Therefore address of
+;; the buffer used for the FXSTOR instruction is &Eax - 336 - 512, which
+;; must be 16 byte aligned.
+;;
+;; We carefully locate the stack to make this happen.
+;;
+;; For reference, the context structure looks like this:
+;;      struct {
+;;        UINT64            ExceptionData;
+;;        FX_SAVE_STATE_X64 FxSaveState;    // 512 bytes, must be 16 byte aligned
+;;        UINT64            Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+;;        UINT64            Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
+;;        UINT64            RFlags;
+;;        UINT64            Ldtr, Tr;
+;;        UINT64            Gdtr[2], Idtr[2];
+;;        UINT64            Rip;
+;;        UINT64            Gs, Fs, Es, Ds, Cs, Ss;
+;;        UINT64            Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
+;;        UINT64            R8, R9, R10, R11, R12, R13, R14, R15;
+;;      } SYSTEM_CONTEXT_X64;  // 64 bit system context record
+
+align           16
+DebugStackEnd: db "DbgStkEnd >>>>>>"    ;; 16 byte long string - must be 16 bytes to preserve alignment
+                times 0x1ffc dd    0x0  ;; 32K should be enough stack
+                                        ;;   This allocation is coocked to insure
+                                        ;;   that the the buffer for the FXSTORE instruction
+                                        ;;   will be 16 byte aligned also.
+                                        ;;
+ExceptionNumber: dq 0                   ;; first entry will be the vector number pushed by the stub
+
+DebugStackBegin: db "<<<< DbgStkBegin"  ;; initial debug ESP == DebugStackBegin, set in stub
+
+DEFAULT REL
+SECTION .text
+
+;------------------------------------------------------------------------------
+; BOOLEAN
+; FxStorSupport (
+;   void
+;   )
+;
+; Abstract: Returns TRUE if FxStor instructions are supported
+;
+global ASM_PFX(FxStorSupport)
+ASM_PFX(FxStorSupport):
+
+;
+; cpuid corrupts rbx which must be preserved per the C calling convention
+;
+                push    rbx
+                mov     rax, dword 1
+                cpuid
+                mov     eax, edx
+                and     rax, FXSTOR_FLAG
+                shr     rax, 24
+                pop     rbx
+                ret
+
+;------------------------------------------------------------------------------
+; void
+; Vect2Desc (
+;   IA32_IDT_GATE_DESCRIPTOR * DestDesc,  // rcx
+;   void (*Vector) (void)   // rdx
+;   )
+;
+; Abstract: Encodes an IDT descriptor with the given physical address
+;
+global ASM_PFX(Vect2Desc)
+ASM_PFX(Vect2Desc):
+
+                mov     rax, rdx
+                mov     word [rcx], ax                  ; write bits 15..0 of offset
+                mov     dx, cs
+                mov     word [rcx+2], dx                ; SYS_CODE_SEL from GDT
+                mov     word [rcx+4], 0xe00 | 0x8000    ; type = 386 interrupt gate, present
+                shr     rax, 16
+                mov     word [rcx+6], ax                ; write bits 31..16 of offset
+                shr     rax, 16
+                mov     dword [rcx+8], eax              ; write bits 63..32 of offset
+
+                ret
+
+;------------------------------------------------------------------------------
+; InterruptEntryStub
+;
+; Abstract: This code is not a function, but is a small piece of code that is
+;               copied and fixed up once for each IDT entry that is hooked.
+;
+ASM_PFX(InterruptEntryStub):
+                push    0                       ; push vector number - will be modified before installed
+                db      0xe9                    ; jump rel32
+                dd      0                       ; fixed up to relative address of CommonIdtEntry
+InterruptEntryStubEnd:
+
+;------------------------------------------------------------------------------
+; CommonIdtEntry
+;
+; Abstract: This code is not a function, but is the common part for all IDT
+;               vectors.
+;
+ASM_PFX(CommonIdtEntry):
+;;
+;; At this point, the stub has saved the current application stack esp into AppRsp
+;; and switched stacks to the debug stack, where it pushed the vector number
+;;
+;; The application stack looks like this:
+;;
+;;              ...
+;;              (last application stack entry)
+;;              [16 bytes alignment, do not care it]
+;;              SS from interrupted task
+;;              RSP from interrupted task
+;;              rflags from interrupted task
+;;              CS from interrupted task
+;;              RIP from interrupted task
+;;              Error code <-------------------- Only present for some exeption types
+;;
+;;              Vector Number <----------------- pushed in our IDT Entry
+;;
+
+;; The stub switched us to the debug stack and pushed the interrupt number.
+;;
+;; Next, construct the context record.  It will be build on the debug stack by
+;; pushing the registers in the correct order so as to create the context structure
+;; on the debug stack.  The context record must be built from the end back to the
+;; beginning because the stack grows down...
+;
+;; For reference, the context record looks like this:
+;;
+;; typedef
+;; struct {
+;;   UINT64            ExceptionData;
+;;   FX_SAVE_STATE_X64 FxSaveState;
+;;   UINT64            Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+;;   UINT64            Cr0, Cr2, Cr3, Cr4, Cr8;
+;;   UINT64            RFlags;
+;;   UINT64            Ldtr, Tr;
+;;   UINT64            Gdtr[2], Idtr[2];
+;;   UINT64            Rip;
+;;   UINT64            Gs, Fs, Es, Ds, Cs, Ss;
+;;   UINT64            Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
+;;   UINT64            R8, R9, R10, R11, R12, R13, R14, R15;
+;; } SYSTEM_CONTEXT_X64;  // 64 bit system context record
+
+;; NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp
+                push    rax
+                mov     rax, qword [rsp+8]               ; save vector number
+                mov     [ExceptionNumber], rax           ; save vector number
+                pop     rax
+                add     rsp, 8                           ; pop vector number
+                mov     [AppRsp], rsp                    ; save stack top
+                lea     rsp, [DebugStackBegin]           ; switch to debugger stack
+                sub     rsp, 8                           ; leave space for vector number
+
+;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
+;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;
+                push    r15
+                push    r14
+                push    r13
+                push    r12
+                push    r11
+                push    r10
+                push    r9
+                push    r8
+                push    rax
+                push    rcx
+                push    rdx
+                push    rbx
+                push    rsp
+                push    rbp
+                push    rsi
+                push    rdi
+
+;; Save interrupt state rflags register...
+                pushfq
+                pop     rax
+                mov     [Rflags], rax
+
+;; We need to determine if any extra data was pushed by the exception, and if so, save it
+;; To do this, we check the exception number pushed by the stub, and cache the
+;; result in a variable since we'll need this again.
+                cmp     qword [ExceptionNumber], EXCPT64_DOUBLE_FAULT
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_INVALID_TSS
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_SEG_NOT_PRESENT
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_STACK_FAULT
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_GP_FAULT
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_PAGE_FAULT
+                jz      ExtraPushOne
+                cmp     qword [ExceptionNumber], EXCPT64_ALIGNMENT_CHECK
+                jz      ExtraPushOne
+                mov     qword [ExtraPush], 0
+                mov     qword [ExceptData], 0
+                jmp     ExtraPushDone
+ExtraPushOne:
+                mov     qword [ExtraPush], 1
+
+;; If there's some extra data, save it also, and modify the saved AppRsp to effectively
+;; pop this value off the application's stack.
+                mov     rax, [AppRsp]
+                mov     rbx, [rax]
+                mov     qword [ExceptData], rbx
+                add     rax, 8
+                mov     [AppRsp], rax
+
+ExtraPushDone:
+
+;; The "push" above pushed the debug stack rsp.  Since what we're actually doing
+;; is building the context record on the debug stack, we need to save the pushed
+;; debug RSP, and replace it with the application's last stack entry...
+                mov     rax, [rsp + 24]
+                mov     [DebugRsp], rax
+                mov     rax, [AppRsp]
+                mov     rax, QWORD [rax + 24]
+                ; application stack has ss, rsp, rflags, cs, & rip, so
+                ; last actual application stack entry is saved at offset
+                ; 24 bytes from stack top.
+                mov     [rsp + 24], rax
+
+;; continue building context record
+;; UINT64  Gs, Fs, Es, Ds, Cs, Ss;  insure high 16 bits of each is zero
+                mov     rax, ss
+                push    rax
+
+                ; CS from application is one entry back in application stack
+                mov     rax, [AppRsp]
+                movzx   rax, word [rax + 8]
+                push    rax
+
+                mov     rax, ds
+                push    rax
+                mov     rax, es
+                push    rax
+                mov     rax, fs
+                push    rax
+                mov     rax, gs
+                push    rax
+
+;; UINT64  Rip;
+                ; Rip from application is on top of application stack
+                mov     rax, [AppRsp]
+                push    qword [rax]
+
+;; UINT64  Gdtr[2], Idtr[2];
+                push    0
+                push    0
+                sidt    [rsp]
+                push    0
+                push    0
+                sgdt    [rsp]
+
+;; UINT64  Ldtr, Tr;
+                xor     rax, rax
+                str     ax
+                push    rax
+                sldt    ax
+                push    rax
+
+;; UINT64  RFlags;
+;; Rflags from application is two entries back in application stack
+                mov     rax, [AppRsp]
+                push    qword [rax + 16]
+
+;; UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
+;; insure FXSAVE/FXRSTOR is enabled in CR4...
+;; ... while we're at it, make sure DE is also enabled...
+                mov     rax, cr8
+                push    rax
+                mov     rax, cr4
+                or      rax, 0x208
+                mov     cr4, rax
+                push    rax
+                mov     rax, cr3
+                push    rax
+                mov     rax, cr2
+                push    rax
+                push    0
+                mov     rax, cr0
+                push    rax
+
+;; UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+                mov     rax, dr7
+                push    rax
+;; clear Dr7 while executing debugger itself
+                xor     rax, rax
+                mov     dr7, rax
+
+                mov     rax, dr6
+                push    rax
+;; insure all status bits in dr6 are clear...
+                xor     rax, rax
+                mov     dr6, rax
+
+                mov     rax, dr3
+                push    rax
+                mov     rax, dr2
+                push    rax
+                mov     rax, dr1
+                push    rax
+                mov     rax, dr0
+                push    rax
+
+;; FX_SAVE_STATE_X64 FxSaveState;
+                sub     rsp, 512
+                mov     rdi, rsp
+                ; IMPORTANT!! The debug stack has been carefully constructed to
+                ; insure that rsp and rdi are 16 byte aligned when we get here.
+                ; They MUST be.  If they are not, a GP fault will occur.
+                fxsave  [rdi]
+
+;; UEFI calling convention for x64 requires that Direction flag in EFLAGs is clear
+                cld
+
+;; UINT64  ExceptionData;
+                mov     rax, [ExceptData]
+                push    rax
+
+; call to C code which will in turn call registered handler
+; pass in the vector number
+                mov     rdx, rsp
+                mov     rcx, [ExceptionNumber]
+                sub     rsp, 40
+                call    ASM_PFX(InterruptDistrubutionHub)
+                add     rsp, 40
+
+; restore context...
+;; UINT64  ExceptionData;
+                add     rsp, 8
+
+;; FX_SAVE_STATE_X64 FxSaveState;
+                mov     rsi, rsp
+                fxrstor [rsi]
+                add     rsp, 512
+
+;; UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
+                pop     rax
+                mov     dr0, rax
+                pop     rax
+                mov     dr1, rax
+                pop     rax
+                mov     dr2, rax
+                pop     rax
+                mov     dr3, rax
+;; skip restore of dr6.  We cleared dr6 during the context save.
+                add     rsp, 8
+                pop     rax
+                mov     dr7, rax
+
+;; UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
+                pop     rax
+                mov     cr0, rax
+                add     rsp, 8
+                pop     rax
+                mov     cr2, rax
+                pop     rax
+                mov     cr3, rax
+                pop     rax
+                mov     cr4, rax
+                pop     rax
+                mov     cr8, rax
+
+;; UINT64  RFlags;
+                mov     rax, [AppRsp]
+                pop     qword [rax + 16]
+
+;; UINT64  Ldtr, Tr;
+;; UINT64  Gdtr[2], Idtr[2];
+;; Best not let anyone mess with these particular registers...
+                add     rsp, 48
+
+;; UINT64  Rip;
+                pop     qword [rax]
+
+;; UINT64  Gs, Fs, Es, Ds, Cs, Ss;
+;; NOTE - modified segment registers could hang the debugger...  We
+;;        could attempt to insulate ourselves against this possibility,
+;;        but that poses risks as well.
+;;
+
+                pop     rax
+                ; mov     gs, rax
+                pop     rax
+                ; mov     fs, rax
+                pop     rax
+                mov     es, rax
+                pop     rax
+                mov     ds, rax
+                mov     rax, [AppRsp]
+                pop     qword [rax + 8]
+                pop     rax
+                mov     ss, rax
+
+;; The next stuff to restore is the general purpose registers that were pushed
+;; using the "push" instruction.
+;;
+;; The value of RSP as stored in the context record is the application RSP
+;; including the 5 entries on the application stack caused by the exception
+;; itself. It may have been modified by the debug agent, so we need to
+;; determine if we need to relocate the application stack.
+
+                mov     rbx, [rsp + 24]  ; move the potentially modified AppRsp into rbx
+                mov     rax, [AppRsp]
+                mov     rax, QWORD [rax + 24]
+                cmp     rbx, rax
+                je      NoAppStackMove
+
+                mov     rax, [AppRsp]
+                mov     rcx, [rax]       ; RIP
+                mov     [rbx], rcx
+
+                mov     rcx, [rax + 8]   ; CS
+                mov     [rbx + 8], rcx
+
+                mov     rcx, [rax + 16]  ; RFLAGS
+                mov     [rbx + 16], rcx
+
+                mov     rcx, [rax + 24]  ; RSP
+                mov     [rbx + 24], rcx
+
+                mov     rcx, [rax + 32]  ; SS
+                mov     [rbx + 32], rcx
+
+                mov     rax, rbx         ; modify the saved AppRsp to the new AppRsp
+                mov     [AppRsp], rax
+NoAppStackMove:
+                mov     rax, [DebugRsp]  ; restore the DebugRsp on the debug stack
+                                         ; so our "pop" will not cause a stack switch
+                mov     [rsp + 24], rax
+
+                cmp     qword [ExceptionNumber], 0x68
+                jne     NoChain
+
+Chain:
+
+;; Restore rflags so when we chain, the flags will be exactly as if we were never here.
+;; We gin up the stack to do an iretq so we can get ALL the flags.
+                mov     rax, [AppRsp]
+                mov     rbx, [rax + 40]
+                push    rbx
+                mov     rax, ss
+                push    rax
+                mov     rax, rsp
+                add     rax, 16
+                push    rax
+                mov     rax, [AppRsp]
+                mov     rbx, [rax + 16]
+                and     rbx, ~ 0x300 ; special handling for IF and TF
+                push    rbx
+                mov     rax, cs
+                push    rax
+                lea     rax, [PhonyIretq]
+                push    rax
+                iretq
+PhonyIretq:
+
+;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
+;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;
+                pop     rdi
+                pop     rsi
+                pop     rbp
+                pop     rsp
+                pop     rbx
+                pop     rdx
+                pop     rcx
+                pop     rax
+                pop     r8
+                pop     r9
+                pop     r10
+                pop     r11
+                pop     r12
+                pop     r13
+                pop     r14
+                pop     r15
+
+;; Switch back to application stack
+                mov     rsp, [AppRsp]
+
+;; Jump to original handler
+                jmp     [ASM_PFX(OrigVector)]
+
+NoChain:
+;; UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
+;; UINT64  R8, R9, R10, R11, R12, R13, R14, R15;
+                pop     rdi
+                pop     rsi
+                pop     rbp
+                pop     rsp
+                pop     rbx
+                pop     rdx
+                pop     rcx
+                pop     rax
+                pop     r8
+                pop     r9
+                pop     r10
+                pop     r11
+                pop     r12
+                pop     r13
+                pop     r14
+                pop     r15
+
+;; Switch back to application stack
+                mov     rsp, [AppRsp]
+
+;; We're outa here...
+                iretq
+
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupport.h b/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupport.h
index 5ea09daaf6..999e917273 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupport.h
+++ b/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupport.h
@@ -1,16 +1,16 @@
-/** @file

-  X64 specific debug support macros.

-

-Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#ifndef _PLDEBUG_SUPPORT_H_

-#define _PLDEBUG_SUPPORT_H_

-

-#include "Ia32/DebugSupport.h"

-

-#define EFI_ISA  IsaX64

-

-#endif

+/** @file
+  X64 specific debug support macros.
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _PLDEBUG_SUPPORT_H_
+#define _PLDEBUG_SUPPORT_H_
+
+#include "Ia32/DebugSupport.h"
+
+#define EFI_ISA  IsaX64
+
+#endif
diff --git a/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupportX64.c b/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupportX64.c
index 8d7b63ac02..5de205fb61 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupportX64.c
+++ b/MdeModulePkg/Universal/DebugSupportDxe/X64/PlDebugSupportX64.c
@@ -1,142 +1,142 @@
-/** @file

-  X64 specific functions to support Debug Support protocol.

-

-Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>

-SPDX-License-Identifier: BSD-2-Clause-Patent

-

-**/

-

-#include "PlDebugSupport.h"

-

-IA32_IDT_GATE_DESCRIPTOR  NullDesc = {

-  { 0, 0 }

-};

-

-/**

-  Get Interrupt Handle from IDT Gate Descriptor.

-

-  @param  IdtGateDecriptor  IDT Gate Descriptor.

-

-  @return Interrupt Handle stored in IDT Gate Descriptor.

-

-**/

-UINTN

-GetInterruptHandleFromIdt (

-  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDecriptor

-  )

-{

-  UINTN  InterruptHandle;

-

-  //

-  // InterruptHandle  0-15 : OffsetLow

-  // InterruptHandle 16-31 : OffsetHigh

-  // InterruptHandle 32-63 : OffsetUpper

-  //

-  InterruptHandle = ((UINTN)IdtGateDecriptor->Bits.OffsetLow) |

-                    (((UINTN)IdtGateDecriptor->Bits.OffsetHigh)  << 16) |

-                    (((UINTN)IdtGateDecriptor->Bits.OffsetUpper) << 32);

-

-  return InterruptHandle;

-}

-

-/**

-  Allocate pool for a new IDT entry stub.

-

-  Copy the generic stub into the new buffer and fixup the vector number

-  and jump target address.

-

-  @param  ExceptionType   This is the exception type that the new stub will be created

-                          for.

-  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.

-

-**/

-VOID

-CreateEntryStub (

-  IN EFI_EXCEPTION_TYPE  ExceptionType,

-  OUT VOID               **Stub

-  )

-{

-  UINT8  *StubCopy;

-

-  StubCopy = *Stub;

-

-  //

-  // Fixup the stub code for this vector

-  //

-

-  // The stub code looks like this:

-  //

-  //    00000000  6A 00               push    0                       ; push vector number - will be modified before installed

-  //    00000002  E9                  db      0e9h                    ; jump rel32

-  //    00000003  00000000            dd      0                       ; fixed up to relative address of CommonIdtEntry

-  //

-

-  //

-  // poke in the exception type so the second push pushes the exception type

-  //

-  StubCopy[0x1] = (UINT8)ExceptionType;

-

-  //

-  // fixup the jump target to point to the common entry

-  //

-  *(UINT32 *)&StubCopy[0x3] = (UINT32)((UINTN)CommonIdtEntry - (UINTN)&StubCopy[StubSize]);

-

-  return;

-}

-

-/**

-  This is the main worker function that manages the state of the interrupt

-  handlers.  It both installs and uninstalls interrupt handlers based on the

-  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.

-  If NewCallback is non-NULL, then install is indicated.

-

-  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.

-                        If NULL, specifies that the previously registered handler should

-                        be uninstalled.

-  @param  ExceptionType Indicates which entry to manage.

-

-  @retval EFI_SUCCESS            Process is ok.

-  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has

-                                 no handler registered for it

-  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.

-  @retval others                 Possible return values are passed through from UnHookEntry and HookEntry.

-

-**/

-EFI_STATUS

-ManageIdtEntryTable (

-  CALLBACK_FUNC       NewCallback,

-  EFI_EXCEPTION_TYPE  ExceptionType

-  )

-{

-  EFI_STATUS  Status;

-

-  Status = EFI_SUCCESS;

-

-  if (CompareMem (&IdtEntryTable[ExceptionType].NewDesc, &NullDesc, sizeof (IA32_IDT_GATE_DESCRIPTOR)) != 0) {

-    //

-    // we've already installed to this vector

-    //

-    if (NewCallback != NULL) {

-      //

-      // if the input handler is non-null, error

-      //

-      Status = EFI_ALREADY_STARTED;

-    } else {

-      UnhookEntry (ExceptionType);

-    }

-  } else {

-    //

-    // no user handler installed on this vector

-    //

-    if (NewCallback == NULL) {

-      //

-      // if the input handler is null, error

-      //

-      Status = EFI_INVALID_PARAMETER;

-    } else {

-      HookEntry (ExceptionType, NewCallback);

-    }

-  }

-

-  return Status;

-}

+/** @file
+  X64 specific functions to support Debug Support protocol.
+
+Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "PlDebugSupport.h"
+
+IA32_IDT_GATE_DESCRIPTOR  NullDesc = {
+  { 0, 0 }
+};
+
+/**
+  Get Interrupt Handle from IDT Gate Descriptor.
+
+  @param  IdtGateDecriptor  IDT Gate Descriptor.
+
+  @return Interrupt Handle stored in IDT Gate Descriptor.
+
+**/
+UINTN
+GetInterruptHandleFromIdt (
+  IN IA32_IDT_GATE_DESCRIPTOR  *IdtGateDecriptor
+  )
+{
+  UINTN  InterruptHandle;
+
+  //
+  // InterruptHandle  0-15 : OffsetLow
+  // InterruptHandle 16-31 : OffsetHigh
+  // InterruptHandle 32-63 : OffsetUpper
+  //
+  InterruptHandle = ((UINTN)IdtGateDecriptor->Bits.OffsetLow) |
+                    (((UINTN)IdtGateDecriptor->Bits.OffsetHigh)  << 16) |
+                    (((UINTN)IdtGateDecriptor->Bits.OffsetUpper) << 32);
+
+  return InterruptHandle;
+}
+
+/**
+  Allocate pool for a new IDT entry stub.
+
+  Copy the generic stub into the new buffer and fixup the vector number
+  and jump target address.
+
+  @param  ExceptionType   This is the exception type that the new stub will be created
+                          for.
+  @param  Stub            On successful exit, *Stub contains the newly allocated entry stub.
+
+**/
+VOID
+CreateEntryStub (
+  IN EFI_EXCEPTION_TYPE  ExceptionType,
+  OUT VOID               **Stub
+  )
+{
+  UINT8  *StubCopy;
+
+  StubCopy = *Stub;
+
+  //
+  // Fixup the stub code for this vector
+  //
+
+  // The stub code looks like this:
+  //
+  //    00000000  6A 00               push    0                       ; push vector number - will be modified before installed
+  //    00000002  E9                  db      0e9h                    ; jump rel32
+  //    00000003  00000000            dd      0                       ; fixed up to relative address of CommonIdtEntry
+  //
+
+  //
+  // poke in the exception type so the second push pushes the exception type
+  //
+  StubCopy[0x1] = (UINT8)ExceptionType;
+
+  //
+  // fixup the jump target to point to the common entry
+  //
+  *(UINT32 *)&StubCopy[0x3] = (UINT32)((UINTN)CommonIdtEntry - (UINTN)&StubCopy[StubSize]);
+
+  return;
+}
+
+/**
+  This is the main worker function that manages the state of the interrupt
+  handlers.  It both installs and uninstalls interrupt handlers based on the
+  value of NewCallback.  If NewCallback is NULL, then uninstall is indicated.
+  If NewCallback is non-NULL, then install is indicated.
+
+  @param  NewCallback   If non-NULL, NewCallback specifies the new handler to register.
+                        If NULL, specifies that the previously registered handler should
+                        be uninstalled.
+  @param  ExceptionType Indicates which entry to manage.
+
+  @retval EFI_SUCCESS            Process is ok.
+  @retval EFI_INVALID_PARAMETER  Requested uninstalling a handler from a vector that has
+                                 no handler registered for it
+  @retval EFI_ALREADY_STARTED    Requested install to a vector that already has a handler registered.
+  @retval others                 Possible return values are passed through from UnHookEntry and HookEntry.
+
+**/
+EFI_STATUS
+ManageIdtEntryTable (
+  CALLBACK_FUNC       NewCallback,
+  EFI_EXCEPTION_TYPE  ExceptionType
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = EFI_SUCCESS;
+
+  if (CompareMem (&IdtEntryTable[ExceptionType].NewDesc, &NullDesc, sizeof (IA32_IDT_GATE_DESCRIPTOR)) != 0) {
+    //
+    // we've already installed to this vector
+    //
+    if (NewCallback != NULL) {
+      //
+      // if the input handler is non-null, error
+      //
+      Status = EFI_ALREADY_STARTED;
+    } else {
+      UnhookEntry (ExceptionType);
+    }
+  } else {
+    //
+    // no user handler installed on this vector
+    //
+    if (NewCallback == NULL) {
+      //
+      // if the input handler is null, error
+      //
+      Status = EFI_INVALID_PARAMETER;
+    } else {
+      HookEntry (ExceptionType, NewCallback);
+    }
+  }
+
+  return Status;
+}