Fix CRLF format

Signed-off-by: Tian, Hot <hot.tian@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@15155 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 551 insertions, 551 deletions

diff --git a/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.S b/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.S
index e6a40e8dad..9783ec6b80 100644
--- a/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.S
+++ b/MdeModulePkg/Universal/DebugSupportDxe/X64/AsmFuncs.S
@@ -1,551 +1,551 @@
-///**@file
-// Low leve x64 specific debug support functions.
-//
-// Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
-// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//**/
-
-ASM_GLOBAL ASM_PFX(OrigVector)
-ASM_GLOBAL ASM_PFX(InterruptEntryStub)
-ASM_GLOBAL ASM_PFX(StubSize)
-ASM_GLOBAL ASM_PFX(CommonIdtEntry)
-ASM_GLOBAL ASM_PFX(FxStorSupport)
-
-.data
-
-ASM_PFX(StubSize):         .long   ASM_PFX(InterruptEntryStubEnd) - ASM_PFX(InterruptEntryStub)
-ASM_PFX(AppRsp):           .long   0x11111111 # ?
-                           .long   0x11111111 # ?
-ASM_PFX(DebugRsp):         .long   0x22222222 # ?
-                           .long   0x22222222 # ?
-ASM_PFX(ExtraPush):        .long   0x33333333 # ?
-                           .long   0x33333333 # ?
-ASM_PFX(ExceptData):       .long   0x44444444 # ?
-                           .long   0x44444444 # ?
-ASM_PFX(Rflags):           .long   0x55555555 # ?
-                           .long   0x55555555 # ?
-ASM_PFX(OrigVector):       .long   0x66666666 # ?
-                           .long   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 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
-
-.p2align 4
-DebugStackEnd : .ascii     "DbgStkEnd >>>>>>"    # 16 byte long string - must be 16 bytes to preserve alignment
-                .fill 0x1ffc, 4, 0x00000000
-                                                 # 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.
-                                                 #
-ASM_PFX(ExceptionNumber):  .long   0x77777777    # first entry will be the vector number pushed by the stub
-                           .long   0x77777777    # ?
-
-DebugStackBegin : .ascii    "<<<< DbgStkBegin"   # initial debug ESP == DebugStackBegin, set in stub
-
-
-.text
-
-//------------------------------------------------------------------------------
-// BOOLEAN
-// FxStorSupport (
-//   void
-//   )
-//
-// Abstract: Returns TRUE if FxStor instructions are supported
-//
-ASM_GLOBAL ASM_PFX(FxStorSupport)
-ASM_PFX(FxStorSupport):
-//
-// cpuid corrupts rbx which must be preserved per the C calling convention
-//
-                pushq   %rbx
-                movq    $1, %rax
-                cpuid
-                movl    %edx, %eax
-                andq    $0x01000000, %rax
-                shrq    $24, %rax
-                popq    %rbx
-                ret
-//------------------------------------------------------------------------------
-// void
-// Vect2Desc (
-//   IA32_IDT_GATE_DESCRIPTOR * DestDesc,  // rcx
-//   void (*Vector) (void)   // rdx
-//   )
-//
-// Abstract: Encodes an IDT descriptor with the given physical address
-//
-ASM_GLOBAL ASM_PFX(Vect2Desc)
-ASM_PFX(Vect2Desc):
-                movq    %rdx, %rax
-                movw    %ax, (%rcx)                  # write bits 15..0 of offset
-                movw    %cs, %dx
-                movw    %dx, 2(%rcx)                 # SYS_CODE_SEL from GDT
-                movw    $(0x0e00 | 0x8000), 4(%rcx)  # type = 386 interrupt gate, present
-                shrq    $16, %rax
-                movw    %ax, 6(%rcx)                 # write bits 31..16 of offset
-                shrq    $16, %rax
-                movl    %eax, 8(%rcx)                # 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_GLOBAL ASM_PFX(InterruptEntryStub)
-ASM_PFX(InterruptEntryStub):
-
-                pushq  $0                       # push vector number - will be modified before installed
-                jmp     ASM_PFX(CommonIdtEntry)
-
-ASM_GLOBAL ASM_PFX(InterruptEntryStubEnd)
-ASM_PFX(InterruptEntryStubEnd):
-
-//------------------------------------------------------------------------------
-// CommonIdtEntry
-//
-// Abstract: This code is not a function, but is the common part for all IDT
-//               vectors.
-//
-ASM_GLOBAL 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
-ASM_PFX(CommonIdtEntry):
-// NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp
-                pushq   %rax
-                movq    (8)(%rsp), %rax                  # save vector number
-                movq    %rax, ASM_PFX(ExceptionNumber)(%rip)   # save vector number
-                popq    %rax
-                addq    $8, %rsp                         # pop vector number
-                movq    %rsp, ASM_PFX(AppRsp)(%rip)      # save stack top
-                movq    DebugStackBegin(%rip), %rsp      # switch to debugger stack
-                subq    $8, %rsp                         # leave space for vector number
-// UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
-// UINT64  R8, R9, R10, R11, R12, R13, R14, R15;
-                pushq    %r15
-                pushq    %r14
-                pushq    %r13
-                pushq    %r12
-                pushq    %r11
-                pushq    %r10
-                pushq    %r9
-                pushq    %r8
-                pushq    %rax
-                pushq    %rcx
-                pushq    %rdx
-                pushq    %rbx
-                pushq    %rsp
-                pushq    %rbp
-                pushq    %rsi
-                pushq    %rdi
-// Save interrupt state rflags register...
-                pushfq
-                popq    %rax
-                movq    %rax, ASM_PFX(Rflags)(%rip)
-// 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.
-                cmpl    $0, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $10, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $11, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $12, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $13, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $14, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                cmpl    $17, ASM_PFX(ExceptionNumber)(%rip)
-                jz      ExtraPushOne
-                movl    $0, ASM_PFX(ExtraPush)(%rip)
-                movl    $0, ASM_PFX(ExceptData)(%rip)
-                jmp     ExtraPushDone
-ExtraPushOne:
-                movl  $1, ASM_PFX(ExtraPush)(%rip)
-
-// If there's some extra data, save it also, and modify the saved AppRsp to effectively
-// pop this value off the application's stack.
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    (%rax), %rbx
-                movq    %rbx, ASM_PFX(ExceptData)(%rip)
-                addq    $8, %rax
-                movq    %rax, ASM_PFX(AppRsp)(%rip)
-
-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...
-                movq    24(%rsp), %rax
-                movq    %rax, ASM_PFX(DebugRsp)(%rip)
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    24(%rax), %rax
-                # application stack has ss, rsp, rflags, cs, & rip, so
-                # last actual application stack entry is saved at offset
-                # 24 bytes from stack top.
-                movq    %rax, 24(%rsp)
-
-// continue building context record
-// UINT64  Gs, Fs, Es, Ds, Cs, Ss;  insure high 16 bits of each is zero
-                mov     %ss, %rax
-                pushq   %rax
-                # CS from application is one entry back in application stack
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movzxw  8(%rax), %rax
-                pushq   %rax
-
-                mov     %ds, %rax
-                pushq   %rax
-                movw    %es, %rax
-                pushq   %rax
-                mov     %fs, %rax
-                pushq   %rax
-                mov     %gs, %rax
-                pushq   %rax
-// UINT64  Rip;
-                # Rip from application is on top of application stack
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                pushq   (%rax)
-// UINT64  Gdtr[2], Idtr[2];
-                push    $0
-                push    $0
-                sidtq   (%rsp)
-                push    $0
-                push    $0
-                sgdtq   (%rsp)
-
-// UINT64  Ldtr, Tr;
-                xorq    %rax, %rax
-                str     %ax
-                pushq   %rax
-                sldt    %ax
-                pushq   %rax
-
-// UINT64  RFlags;
-// Rflags from application is two entries back in application stack
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                pushq   16(%rax)
-// 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...
-                movq    %cr8, %rax
-                pushq   %rax
-                movq    %cr4, %rax
-                orq     $0x208, %rax
-                movq    %rax, %cr4
-                pushq   %rax
-                movq    %cr3, %rax
-                pushq   %rax
-                movq    %cr2, %rax
-                pushq   %rax
-                push    $0
-                movq    %cr0, %rax
-                pushq   %rax
-// UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
-                movq    %dr7, %rax
-                pushq   %rax
-// clear Dr7 while executing debugger itself
-                xorq    %rax, %rax
-                movq    %rax, %dr7
-
-                movq    %dr6, %rax
-                pushq   %rax
-// insure all status bits in dr6 are clear...
-                xorq    %rax, %rax
-                movq    %rax, %dr6
-
-                movq    %dr3, %rax
-                pushq   %rax
-                movq    %dr2, %rax
-                pushq   %rax
-                movq    %dr1, %rax
-                pushq   %rax
-                movq    %dr0, %rax
-                pushq   %rax
-
-// FX_SAVE_STATE_X64 FxSaveState;
-                subq    $512, %rsp
-                movq    %rsp, %rdi
-                # 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.
-
-                #     FXSTOR_RDI
-                fxsave      (%rdi)
-
-// UEFI calling convention for x64 requires that Direction flag in EFLAGs is clear
-                cld
-                
-// UINT64  ExceptionData;
-                movq    ASM_PFX(ExceptData)(%rip),  %rax
-                pushq   %rax
-
-// call to C code which will in turn call registered handler
-// pass in the vector number
-                movq    %rsp, %rdx
-                movq    ASM_PFX(ExceptionNumber)(%rip), %rcx
-                subq    $40, %rsp
-                call    ASM_PFX(InterruptDistrubutionHub)
-                addq    $40, %rsp
-// restore context...
-// UINT64  ExceptionData;
-                addq    $8, %rsp
-
-// FX_SAVE_STATE_X64 FxSaveState;
-                movq    %rsp, %rsi
-
-                #    FXRSTOR_RSI
-                fxrstor     (%rsi)
-
-                addq    $512, %rsp
-
-// UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
-                popq    %rax
-                movq    %rax, %dr0
-                popq    %rax
-                movq    %rax, %dr1
-                popq    %rax
-                movq    %rax, %dr2
-                popq    %rax
-                movq    %rax, %dr3
-
-// skip restore of dr6.  We cleared dr6 during the context save.
-                addq    $8, %rsp
-                popq    %rax
-                movq    %rax, %dr7
-
-// UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
-                popq    %rax
-                movq    %rax, %cr0
-                addq    $8, %rsp
-                popq    %rax
-                movq    %rax, %cr2
-                popq    %rax
-                movq    %rax, %cr3
-                popq    %rax
-                movq    %rax, %cr4
-                popq    %rax
-                movq    %rax, %cr8
-// UINT64  RFlags;
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                popq    16(%rax)
-// UINT64  Ldtr, Tr;
-// UINT64  Gdtr[2], Idtr[2];
-// Best not let anyone mess with these particular registers...
-                addq    $48, %rsp
-// UINT64  Rip;
-                popq    (%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.
-//
-
-                popq    %rax
-                # mov     %rax, %gs
-                popq    %rax
-                # mov     %rax, %fs
-                popq    %rax
-                mov     %rax, %es
-                popq    %rax
-                mov     %rax, %ds
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                popq    8(%rax)
-                popq    %rax
-                mov     %rax, %ss
-## 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.
-
-                movq    24(%rsp), %rbx  # move the potentially modified AppRsp into rbx
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    24(%rax), %rax
-                cmpq    %rax, %rbx
-                je      NoAppStackMove
-
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    (%rax), %rcx     # RIP
-                movq    %rcx, (%rbx)
-
-                movq    8(%rax), %rcx    # CS
-                movq    %rcx, 8(%rbx)
-
-                movq    16(%rax), %rcx   # RFLAGS
-                movq    %rcx, 16(%rbx)
-
-                movq    24(%rax), %rcx   # RSP
-                movq    %rcx, 24(%rbx)
-
-                movq    32(%rax), %rcx   # SS
-                movq    %rcx, 32(%rbx)
-
-                movq    %rbx, %rax       # modify the saved AppRsp to the new AppRsp
-                movq    %rax, ASM_PFX(AppRsp)(%rip)
-NoAppStackMove:
-                movq    ASM_PFX(DebugRsp)(%rip), %rax   # restore the DebugRsp on the debug stack
-                                         # so our "pop" will not cause a stack switch
-                movq    %rax, 24(%rsp)
-
-                cmpl    $0x068, ASM_PFX(ExceptionNumber)(%rip)
-                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.
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    40(%rax), %rbx
-                pushq   %rbx
-                mov     %ss, %rax
-                pushq   %rax
-                movq    %rsp, %rax
-                addq    $16, %rax
-                pushq   %rax
-                movq    ASM_PFX(AppRsp)(%rip), %rax
-                movq    16(%rax), %rbx
-                andq    $0xfffffffffffffcff, %rbx  # special handling for IF and TF
-                pushq   %rbx
-                mov     %cs, %rax
-                pushq   %rax
-                movq    PhonyIretq(%rip), %rax
-                pushq   %rax
-                iretq
-PhonyIretq:
-
-// UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
-// UINT64  R8, R9, R10, R11, R12, R13, R14, R15;
-                popq    %rdi
-                popq    %rsi
-                popq    %rbp
-                popq    %rsp
-                popq    %rbx
-                popq    %rdx
-                popq    %rcx
-                popq    %rax
-                popq    %r8
-                popq    %r9
-                popq    %r10
-                popq    %r11
-                popq    %r12
-                popq    %r13
-                popq    %r14
-                popq    %r15
-
-// Switch back to application stack
-                movq    ASM_PFX(AppRsp)(%rip), %rsp
-// 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;
-                popq    %rdi
-                popq    %rsi
-                popq    %rbp
-                popq    %rsp
-                popq    %rbx
-                popq    %rdx
-                popq    %rcx
-                popq    %rax
-                popq    %r8
-                popq    %r9
-                popq    %r10
-                popq    %r11
-                popq    %r12
-                popq    %r13
-                popq    %r14
-                popq    %r15
-
-// Switch back to application stack
-                movq    ASM_PFX(AppRsp)(%rip), %rsp
-
-// We're outa here...
-                iret
+///**@file

+// Low leve x64 specific debug support functions.

+//

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

+// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//**/

+

+ASM_GLOBAL ASM_PFX(OrigVector)

+ASM_GLOBAL ASM_PFX(InterruptEntryStub)

+ASM_GLOBAL ASM_PFX(StubSize)

+ASM_GLOBAL ASM_PFX(CommonIdtEntry)

+ASM_GLOBAL ASM_PFX(FxStorSupport)

+

+.data

+

+ASM_PFX(StubSize):         .long   ASM_PFX(InterruptEntryStubEnd) - ASM_PFX(InterruptEntryStub)

+ASM_PFX(AppRsp):           .long   0x11111111 # ?

+                           .long   0x11111111 # ?

+ASM_PFX(DebugRsp):         .long   0x22222222 # ?

+                           .long   0x22222222 # ?

+ASM_PFX(ExtraPush):        .long   0x33333333 # ?

+                           .long   0x33333333 # ?

+ASM_PFX(ExceptData):       .long   0x44444444 # ?

+                           .long   0x44444444 # ?

+ASM_PFX(Rflags):           .long   0x55555555 # ?

+                           .long   0x55555555 # ?

+ASM_PFX(OrigVector):       .long   0x66666666 # ?

+                           .long   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 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

+

+.p2align 4

+DebugStackEnd : .ascii     "DbgStkEnd >>>>>>"    # 16 byte long string - must be 16 bytes to preserve alignment

+                .fill 0x1ffc, 4, 0x00000000

+                                                 # 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.

+                                                 #

+ASM_PFX(ExceptionNumber):  .long   0x77777777    # first entry will be the vector number pushed by the stub

+                           .long   0x77777777    # ?

+

+DebugStackBegin : .ascii    "<<<< DbgStkBegin"   # initial debug ESP == DebugStackBegin, set in stub

+

+

+.text

+

+//------------------------------------------------------------------------------

+// BOOLEAN

+// FxStorSupport (

+//   void

+//   )

+//

+// Abstract: Returns TRUE if FxStor instructions are supported

+//

+ASM_GLOBAL ASM_PFX(FxStorSupport)

+ASM_PFX(FxStorSupport):

+//

+// cpuid corrupts rbx which must be preserved per the C calling convention

+//

+                pushq   %rbx

+                movq    $1, %rax

+                cpuid

+                movl    %edx, %eax

+                andq    $0x01000000, %rax

+                shrq    $24, %rax

+                popq    %rbx

+                ret

+//------------------------------------------------------------------------------

+// void

+// Vect2Desc (

+//   IA32_IDT_GATE_DESCRIPTOR * DestDesc,  // rcx

+//   void (*Vector) (void)   // rdx

+//   )

+//

+// Abstract: Encodes an IDT descriptor with the given physical address

+//

+ASM_GLOBAL ASM_PFX(Vect2Desc)

+ASM_PFX(Vect2Desc):

+                movq    %rdx, %rax

+                movw    %ax, (%rcx)                  # write bits 15..0 of offset

+                movw    %cs, %dx

+                movw    %dx, 2(%rcx)                 # SYS_CODE_SEL from GDT

+                movw    $(0x0e00 | 0x8000), 4(%rcx)  # type = 386 interrupt gate, present

+                shrq    $16, %rax

+                movw    %ax, 6(%rcx)                 # write bits 31..16 of offset

+                shrq    $16, %rax

+                movl    %eax, 8(%rcx)                # 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_GLOBAL ASM_PFX(InterruptEntryStub)

+ASM_PFX(InterruptEntryStub):

+

+                pushq  $0                       # push vector number - will be modified before installed

+                jmp     ASM_PFX(CommonIdtEntry)

+

+ASM_GLOBAL ASM_PFX(InterruptEntryStubEnd)

+ASM_PFX(InterruptEntryStubEnd):

+

+//------------------------------------------------------------------------------

+// CommonIdtEntry

+//

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

+//               vectors.

+//

+ASM_GLOBAL 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

+ASM_PFX(CommonIdtEntry):

+// NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp

+                pushq   %rax

+                movq    (8)(%rsp), %rax                  # save vector number

+                movq    %rax, ASM_PFX(ExceptionNumber)(%rip)   # save vector number

+                popq    %rax

+                addq    $8, %rsp                         # pop vector number

+                movq    %rsp, ASM_PFX(AppRsp)(%rip)      # save stack top

+                movq    DebugStackBegin(%rip), %rsp      # switch to debugger stack

+                subq    $8, %rsp                         # leave space for vector number

+// UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

+// UINT64  R8, R9, R10, R11, R12, R13, R14, R15;

+                pushq    %r15

+                pushq    %r14

+                pushq    %r13

+                pushq    %r12

+                pushq    %r11

+                pushq    %r10

+                pushq    %r9

+                pushq    %r8

+                pushq    %rax

+                pushq    %rcx

+                pushq    %rdx

+                pushq    %rbx

+                pushq    %rsp

+                pushq    %rbp

+                pushq    %rsi

+                pushq    %rdi

+// Save interrupt state rflags register...

+                pushfq

+                popq    %rax

+                movq    %rax, ASM_PFX(Rflags)(%rip)

+// 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.

+                cmpl    $0, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $10, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $11, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $12, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $13, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $14, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                cmpl    $17, ASM_PFX(ExceptionNumber)(%rip)

+                jz      ExtraPushOne

+                movl    $0, ASM_PFX(ExtraPush)(%rip)

+                movl    $0, ASM_PFX(ExceptData)(%rip)

+                jmp     ExtraPushDone

+ExtraPushOne:

+                movl  $1, ASM_PFX(ExtraPush)(%rip)

+

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

+// pop this value off the application's stack.

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    (%rax), %rbx

+                movq    %rbx, ASM_PFX(ExceptData)(%rip)

+                addq    $8, %rax

+                movq    %rax, ASM_PFX(AppRsp)(%rip)

+

+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...

+                movq    24(%rsp), %rax

+                movq    %rax, ASM_PFX(DebugRsp)(%rip)

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    24(%rax), %rax

+                # application stack has ss, rsp, rflags, cs, & rip, so

+                # last actual application stack entry is saved at offset

+                # 24 bytes from stack top.

+                movq    %rax, 24(%rsp)

+

+// continue building context record

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

+                mov     %ss, %rax

+                pushq   %rax

+                # CS from application is one entry back in application stack

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movzxw  8(%rax), %rax

+                pushq   %rax

+

+                mov     %ds, %rax

+                pushq   %rax

+                movw    %es, %rax

+                pushq   %rax

+                mov     %fs, %rax

+                pushq   %rax

+                mov     %gs, %rax

+                pushq   %rax

+// UINT64  Rip;

+                # Rip from application is on top of application stack

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                pushq   (%rax)

+// UINT64  Gdtr[2], Idtr[2];

+                push    $0

+                push    $0

+                sidtq   (%rsp)

+                push    $0

+                push    $0

+                sgdtq   (%rsp)

+

+// UINT64  Ldtr, Tr;

+                xorq    %rax, %rax

+                str     %ax

+                pushq   %rax

+                sldt    %ax

+                pushq   %rax

+

+// UINT64  RFlags;

+// Rflags from application is two entries back in application stack

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                pushq   16(%rax)

+// 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...

+                movq    %cr8, %rax

+                pushq   %rax

+                movq    %cr4, %rax

+                orq     $0x208, %rax

+                movq    %rax, %cr4

+                pushq   %rax

+                movq    %cr3, %rax

+                pushq   %rax

+                movq    %cr2, %rax

+                pushq   %rax

+                push    $0

+                movq    %cr0, %rax

+                pushq   %rax

+// UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

+                movq    %dr7, %rax

+                pushq   %rax

+// clear Dr7 while executing debugger itself

+                xorq    %rax, %rax

+                movq    %rax, %dr7

+

+                movq    %dr6, %rax

+                pushq   %rax

+// insure all status bits in dr6 are clear...

+                xorq    %rax, %rax

+                movq    %rax, %dr6

+

+                movq    %dr3, %rax

+                pushq   %rax

+                movq    %dr2, %rax

+                pushq   %rax

+                movq    %dr1, %rax

+                pushq   %rax

+                movq    %dr0, %rax

+                pushq   %rax

+

+// FX_SAVE_STATE_X64 FxSaveState;

+                subq    $512, %rsp

+                movq    %rsp, %rdi

+                # 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.

+

+                #     FXSTOR_RDI

+                fxsave      (%rdi)

+

+// UEFI calling convention for x64 requires that Direction flag in EFLAGs is clear

+                cld

+                

+// UINT64  ExceptionData;

+                movq    ASM_PFX(ExceptData)(%rip),  %rax

+                pushq   %rax

+

+// call to C code which will in turn call registered handler

+// pass in the vector number

+                movq    %rsp, %rdx

+                movq    ASM_PFX(ExceptionNumber)(%rip), %rcx

+                subq    $40, %rsp

+                call    ASM_PFX(InterruptDistrubutionHub)

+                addq    $40, %rsp

+// restore context...

+// UINT64  ExceptionData;

+                addq    $8, %rsp

+

+// FX_SAVE_STATE_X64 FxSaveState;

+                movq    %rsp, %rsi

+

+                #    FXRSTOR_RSI

+                fxrstor     (%rsi)

+

+                addq    $512, %rsp

+

+// UINT64  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

+                popq    %rax

+                movq    %rax, %dr0

+                popq    %rax

+                movq    %rax, %dr1

+                popq    %rax

+                movq    %rax, %dr2

+                popq    %rax

+                movq    %rax, %dr3

+

+// skip restore of dr6.  We cleared dr6 during the context save.

+                addq    $8, %rsp

+                popq    %rax

+                movq    %rax, %dr7

+

+// UINT64  Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;

+                popq    %rax

+                movq    %rax, %cr0

+                addq    $8, %rsp

+                popq    %rax

+                movq    %rax, %cr2

+                popq    %rax

+                movq    %rax, %cr3

+                popq    %rax

+                movq    %rax, %cr4

+                popq    %rax

+                movq    %rax, %cr8

+// UINT64  RFlags;

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                popq    16(%rax)

+// UINT64  Ldtr, Tr;

+// UINT64  Gdtr[2], Idtr[2];

+// Best not let anyone mess with these particular registers...

+                addq    $48, %rsp

+// UINT64  Rip;

+                popq    (%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.

+//

+

+                popq    %rax

+                # mov     %rax, %gs

+                popq    %rax

+                # mov     %rax, %fs

+                popq    %rax

+                mov     %rax, %es

+                popq    %rax

+                mov     %rax, %ds

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                popq    8(%rax)

+                popq    %rax

+                mov     %rax, %ss

+## 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.

+

+                movq    24(%rsp), %rbx  # move the potentially modified AppRsp into rbx

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    24(%rax), %rax

+                cmpq    %rax, %rbx

+                je      NoAppStackMove

+

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    (%rax), %rcx     # RIP

+                movq    %rcx, (%rbx)

+

+                movq    8(%rax), %rcx    # CS

+                movq    %rcx, 8(%rbx)

+

+                movq    16(%rax), %rcx   # RFLAGS

+                movq    %rcx, 16(%rbx)

+

+                movq    24(%rax), %rcx   # RSP

+                movq    %rcx, 24(%rbx)

+

+                movq    32(%rax), %rcx   # SS

+                movq    %rcx, 32(%rbx)

+

+                movq    %rbx, %rax       # modify the saved AppRsp to the new AppRsp

+                movq    %rax, ASM_PFX(AppRsp)(%rip)

+NoAppStackMove:

+                movq    ASM_PFX(DebugRsp)(%rip), %rax   # restore the DebugRsp on the debug stack

+                                         # so our "pop" will not cause a stack switch

+                movq    %rax, 24(%rsp)

+

+                cmpl    $0x068, ASM_PFX(ExceptionNumber)(%rip)

+                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.

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    40(%rax), %rbx

+                pushq   %rbx

+                mov     %ss, %rax

+                pushq   %rax

+                movq    %rsp, %rax

+                addq    $16, %rax

+                pushq   %rax

+                movq    ASM_PFX(AppRsp)(%rip), %rax

+                movq    16(%rax), %rbx

+                andq    $0xfffffffffffffcff, %rbx  # special handling for IF and TF

+                pushq   %rbx

+                mov     %cs, %rax

+                pushq   %rax

+                movq    PhonyIretq(%rip), %rax

+                pushq   %rax

+                iretq

+PhonyIretq:

+

+// UINT64  Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;

+// UINT64  R8, R9, R10, R11, R12, R13, R14, R15;

+                popq    %rdi

+                popq    %rsi

+                popq    %rbp

+                popq    %rsp

+                popq    %rbx

+                popq    %rdx

+                popq    %rcx

+                popq    %rax

+                popq    %r8

+                popq    %r9

+                popq    %r10

+                popq    %r11

+                popq    %r12

+                popq    %r13

+                popq    %r14

+                popq    %r15

+

+// Switch back to application stack

+                movq    ASM_PFX(AppRsp)(%rip), %rsp

+// 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;

+                popq    %rdi

+                popq    %rsi

+                popq    %rbp

+                popq    %rsp

+                popq    %rbx

+                popq    %rdx

+                popq    %rcx

+                popq    %rax

+                popq    %r8

+                popq    %r9

+                popq    %r10

+                popq    %r11

+                popq    %r12

+                popq    %r13

+                popq    %r14

+                popq    %r15

+

+// Switch back to application stack

+                movq    ASM_PFX(AppRsp)(%rip), %rsp

+

+// We're outa here...

+                iret