[mirror_edk2.git] / MdeModulePkg / Universal / DebugSupportDxe / X64 / AsmFuncs.S

///**@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
Commit	Line	Data
24851580	1	///**@file
	2	// Low leve x64 specific debug support functions.
	3	//
24f7e42c	4	// Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
e5eed7d3 HT	5	// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
e5eed7d3 HT	6	// This program and the accompanying materials
24851580	7	// are licensed and made available under the terms and conditions of the BSD License
	8	// which accompanies this distribution. The full text of the license may be found at
	9	// http://opensource.org/licenses/bsd-license.php
	10	//
	11	// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	12	// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	13	//
c7a5da72	14	//**/
24851580	15
	16	ASM_GLOBAL ASM_PFX(OrigVector)
	17	ASM_GLOBAL ASM_PFX(InterruptEntryStub)
	18	ASM_GLOBAL ASM_PFX(StubSize)
	19	ASM_GLOBAL ASM_PFX(CommonIdtEntry)
	20	ASM_GLOBAL ASM_PFX(FxStorSupport)
c7a5da72	21
c7a5da72	22	.data
24851580	23
	24	ASM_PFX(StubSize): .long ASM_PFX(InterruptEntryStubEnd) - ASM_PFX(InterruptEntryStub)
	25	ASM_PFX(AppRsp): .long 0x11111111 # ?
	26	.long 0x11111111 # ?
	27	ASM_PFX(DebugRsp): .long 0x22222222 # ?
	28	.long 0x22222222 # ?
	29	ASM_PFX(ExtraPush): .long 0x33333333 # ?
	30	.long 0x33333333 # ?
	31	ASM_PFX(ExceptData): .long 0x44444444 # ?
	32	.long 0x44444444 # ?
	33	ASM_PFX(Rflags): .long 0x55555555 # ?
	34	.long 0x55555555 # ?
	35	ASM_PFX(OrigVector): .long 0x66666666 # ?
	36	.long 0x66666666 # ?
	37
	38	// The declarations below define the memory region that will be used for the debug stack.
	39	// The context record will be built by pushing register values onto this stack.
	40	// It is imparitive that alignment be carefully managed, since the FXSTOR and
	41	// FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.
	42	//
	43	// The stub will switch stacks from the application stack to the debuger stack
	44	// and pushes the exception number.
	45	//
	46	// Then we building the context record on the stack. Since the stack grows down,
	47	// we push the fields of the context record from the back to the front. There
	48	// are 336 bytes of stack used prior allocating the 512 bytes of stack to be
	49	// used as the memory buffer for the fxstor instruction. Therefore address of
	50	// the buffer used for the FXSTOR instruction is &Eax - 336 - 512, which
	51	// must be 16 byte aligned.
	52	//
	53	// We carefully locate the stack to make this happen.
	54	//
	55	// For reference, the context structure looks like this:
	56	// struct {
	57	// UINT64 ExceptionData;
	58	// FX_SAVE_STATE_X64 FxSaveState; // 512 bytes, must be 16 byte aligned
	59	// UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
	60	// UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
	61	// UINT64 RFlags;
	62	// UINT64 Ldtr, Tr;
	63	// UINT64 Gdtr[2], Idtr[2];
	64	// UINT64 Rip;
	65	// UINT64 Gs, Fs, Es, Ds, Cs, Ss;
	66	// UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
	67	// UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
	68	// } SYSTEM_CONTEXT_X64; // 64 bit system context record
	69
	70	.p2align 4
	71	DebugStackEnd : .ascii "DbgStkEnd >>>>>>" # 16 byte long string - must be 16 bytes to preserve alignment
	72	.fill 0x1ffc, 4, 0x00000000
	73	# 32K should be enough stack
	74	# This allocation is coocked to insure
	75	# that the the buffer for the FXSTORE instruction
	76	# will be 16 byte aligned also.
	77	#
	78	ASM_PFX(ExceptionNumber): .long 0x77777777 # first entry will be the vector number pushed by the stub
	79	.long 0x77777777 # ?
	80
	81	DebugStackBegin : .ascii "<<<< DbgStkBegin" # initial debug ESP == DebugStackBegin, set in stub
c7a5da72	82
24851580	83
	84	.text
	85
	86	//------------------------------------------------------------------------------
	87	// BOOLEAN
	88	// FxStorSupport (
	89	// void
	90	// )
	91	//
	92	// Abstract: Returns TRUE if FxStor instructions are supported
	93	//
	94	ASM_GLOBAL ASM_PFX(FxStorSupport)
c7a5da72	95	ASM_PFX(FxStorSupport):
24851580	96	//
	97	// cpuid corrupts rbx which must be preserved per the C calling convention
	98	//
	99	pushq %rbx
	100	movq $1, %rax
	101	cpuid
	102	movl %edx, %eax
	103	andq $0x01000000, %rax
	104	shrq $24, %rax
	105	popq %rbx
	106	ret
	107	//------------------------------------------------------------------------------
	108	// void
	109	// Vect2Desc (
	110	// IA32_IDT_GATE_DESCRIPTOR * DestDesc, // rcx
	111	// void (*Vector) (void) // rdx
	112	// )
	113	//
	114	// Abstract: Encodes an IDT descriptor with the given physical address
	115	//
	116	ASM_GLOBAL ASM_PFX(Vect2Desc)
	117	ASM_PFX(Vect2Desc):
	118	movq %rdx, %rax
	119	movw %ax, (%rcx) # write bits 15..0 of offset
	120	movw %cs, %dx
	121	movw %dx, 2(%rcx) # SYS_CODE_SEL from GDT
	122	movw $(0x0e00 \| 0x8000), 4(%rcx) # type = 386 interrupt gate, present
	123	shrq $16, %rax
	124	movw %ax, 6(%rcx) # write bits 31..16 of offset
	125	shrq $16, %rax
	126	movl %eax, 8(%rcx) # write bits 63..32 of offset
	127
	128	ret
	129
	130	//------------------------------------------------------------------------------
	131	// InterruptEntryStub
	132	//
	133	// Abstract: This code is not a function, but is a small piece of code that is
	134	// copied and fixed up once for each IDT entry that is hooked.
	135	//
	136	ASM_GLOBAL ASM_PFX(InterruptEntryStub)
	137	ASM_PFX(InterruptEntryStub):
	138
	139	pushq $0 # push vector number - will be modified before installed
	140	jmp ASM_PFX(CommonIdtEntry)
c7a5da72	141
24851580	142	ASM_GLOBAL ASM_PFX(InterruptEntryStubEnd)
	143	ASM_PFX(InterruptEntryStubEnd):
	144
	145	//------------------------------------------------------------------------------
	146	// CommonIdtEntry
	147	//
	148	// Abstract: This code is not a function, but is the common part for all IDT
	149	// vectors.
	150	//
	151	ASM_GLOBAL ASM_PFX(CommonIdtEntry)
	152	//
	153	// At this point, the stub has saved the current application stack esp into AppRsp
	154	// and switched stacks to the debug stack, where it pushed the vector number
	155	//
	156	// The application stack looks like this:
	157	//
	158	// ...
	159	// (last application stack entry)
	160	// [16 bytes alignment, do not care it]
	161	// SS from interrupted task
	162	// RSP from interrupted task
	163	// rflags from interrupted task
	164	// CS from interrupted task
	165	// RIP from interrupted task
	166	// Error code <-------------------- Only present for some exeption types
	167	//
	168	// Vector Number <----------------- pushed in our IDT Entry
	169	//
	170
	171
	172	// The stub switched us to the debug stack and pushed the interrupt number.
	173	//
	174	// Next, construct the context record. It will be build on the debug stack by
	175	// pushing the registers in the correct order so as to create the context structure
	176	// on the debug stack. The context record must be built from the end back to the
	177	// beginning because the stack grows down...
	178	//
	179	// For reference, the context record looks like this:
	180	//
	181	// typedef
	182	// struct {
	183	// UINT64 ExceptionData;
	184	// FX_SAVE_STATE_X64 FxSaveState;
	185	// UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
	186	// UINT64 Cr0, Cr2, Cr3, Cr4, Cr8;
	187	// UINT64 RFlags;
	188	// UINT64 Ldtr, Tr;
	189	// UINT64 Gdtr[2], Idtr[2];
	190	// UINT64 Rip;
	191	// UINT64 Gs, Fs, Es, Ds, Cs, Ss;
	192	// UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
	193	// UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
	194	// } SYSTEM_CONTEXT_X64; // 64
	195	ASM_PFX(CommonIdtEntry):
	196	// NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp
	197	pushq %rax
	198	movq (8)(%rsp), %rax # save vector number
	199	movq %rax, ASM_PFX(ExceptionNumber)(%rip) # save vector number
	200	popq %rax
	201	addq $8, %rsp # pop vector number
	202	movq %rsp, ASM_PFX(AppRsp)(%rip) # save stack top
	203	movq DebugStackBegin(%rip), %rsp # switch to debugger stack
	204	subq $8, %rsp # leave space for vector number
	205	// UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
206	// UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
207	pushq %r15
208	pushq %r14
209	pushq %r13
210	pushq %r12
211	pushq %r11
212	pushq %r10
213	pushq %r9
214	pushq %r8
215	pushq %rax
216	pushq %rcx
217	pushq %rdx
218	pushq %rbx
219	pushq %rsp
220	pushq %rbp
221	pushq %rsi
222	pushq %rdi
223	// Save interrupt state rflags register...
224	pushfq
225	popq %rax
226	movq %rax, ASM_PFX(Rflags)(%rip)
227	// We need to determine if any extra data was pushed by the exception, and if so, save it
228	// To do this, we check the exception number pushed by the stub, and cache the
229	// result in a variable since we'll need this again.
230	cmpl $0, ASM_PFX(ExceptionNumber)(%rip)
231	jz ExtraPushOne
232	cmpl $10, ASM_PFX(ExceptionNumber)(%rip)
233	jz ExtraPushOne
234	cmpl $11, ASM_PFX(ExceptionNumber)(%rip)
235	jz ExtraPushOne
236	cmpl $12, ASM_PFX(ExceptionNumber)(%rip)
237	jz ExtraPushOne
238	cmpl $13, ASM_PFX(ExceptionNumber)(%rip)
239	jz ExtraPushOne
240	cmpl $14, ASM_PFX(ExceptionNumber)(%rip)
241	jz ExtraPushOne
242	cmpl $17, ASM_PFX(ExceptionNumber)(%rip)
243	jz ExtraPushOne
244	movl $0, ASM_PFX(ExtraPush)(%rip)
245	movl $0, ASM_PFX(ExceptData)(%rip)
246	jmp ExtraPushDone
247	ExtraPushOne:
248	movl $1, ASM_PFX(ExtraPush)(%rip)
249
250	// If there's some extra data, save it also, and modify the saved AppRsp to effectively
251	// pop this value off the application's stack.
c7a5da72	252	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	253	movq (%rax), %rbx
	254	movq %rbx, ASM_PFX(ExceptData)(%rip)
	255	addq $8, %rax
	256	movq %rax, ASM_PFX(AppRsp)(%rip)
	257
	258	ExtraPushDone:
	259
	260	// The "push" above pushed the debug stack rsp. Since what we're actually doing
	261	// is building the context record on the debug stack, we need to save the pushed
	262	// debug RSP, and replace it with the application's last stack entry...
	263	movq 24(%rsp), %rax
	264	movq %rax, ASM_PFX(DebugRsp)(%rip)
c7a5da72	265	movq ASM_PFX(AppRsp)(%rip), %rax
c7a5da72	266	movq 24(%rax), %rax
24851580	267	# application stack has ss, rsp, rflags, cs, & rip, so
c7a5da72	268	# last actual application stack entry is saved at offset
c7a5da72	269	# 24 bytes from stack top.
24851580	270	movq %rax, 24(%rsp)
	271
	272	// continue building context record
	273	// UINT64 Gs, Fs, Es, Ds, Cs, Ss; insure high 16 bits of each is zero
	274	mov %ss, %rax
	275	pushq %rax
	276	# CS from application is one entry back in application stack
	277	movq ASM_PFX(AppRsp)(%rip), %rax
	278	movzxw 8(%rax), %rax
	279	pushq %rax
	280
	281	mov %ds, %rax
	282	pushq %rax
	283	movw %es, %rax
	284	pushq %rax
	285	mov %fs, %rax
	286	pushq %rax
	287	mov %gs, %rax
	288	pushq %rax
	289	// UINT64 Rip;
	290	# Rip from application is on top of application stack
c7a5da72	291	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	292	pushq (%rax)
	293	// UINT64 Gdtr[2], Idtr[2];
	294	push $0
	295	push $0
	296	sidtq (%rsp)
	297	push $0
	298	push $0
	299	sgdtq (%rsp)
	300
	301	// UINT64 Ldtr, Tr;
	302	xorq %rax, %rax
	303	str %ax
	304	pushq %rax
	305	sldt %ax
	306	pushq %rax
	307
	308	// UINT64 RFlags;
	309	// Rflags from application is two entries back in application stack
c7a5da72	310	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	311	pushq 16(%rax)
	312	// UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
	313	// insure FXSAVE/FXRSTOR is enabled in CR4...
	314	// ... while we're at it, make sure DE is also enabled...
	315	movq %cr8, %rax
	316	pushq %rax
	317	movq %cr4, %rax
	318	orq $0x208, %rax
	319	movq %rax, %cr4
	320	pushq %rax
	321	movq %cr3, %rax
	322	pushq %rax
	323	movq %cr2, %rax
	324	pushq %rax
	325	push $0
	326	movq %cr0, %rax
	327	pushq %rax
	328	// UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
	329	movq %dr7, %rax
	330	pushq %rax
	331	// clear Dr7 while executing debugger itself
	332	xorq %rax, %rax
	333	movq %rax, %dr7
	334
	335	movq %dr6, %rax
	336	pushq %rax
	337	// insure all status bits in dr6 are clear...
	338	xorq %rax, %rax
	339	movq %rax, %dr6
	340
	341	movq %dr3, %rax
	342	pushq %rax
	343	movq %dr2, %rax
	344	pushq %rax
	345	movq %dr1, %rax
	346	pushq %rax
	347	movq %dr0, %rax
	348	pushq %rax
	349
	350	// FX_SAVE_STATE_X64 FxSaveState;
	351	subq $512, %rsp
	352	movq %rsp, %rdi
	353	# IMPORTANT!! The debug stack has been carefully constructed to
	354	# insure that rsp and rdi are 16 byte aligned when we get here.
	355	# They MUST be. If they are not, a GP fault will occur.
c7a5da72	356
24851580	357	# FXSTOR_RDI
	358	fxsave (%rdi)
	359
24f7e42c	360	// UEFI calling convention for x64 requires that Direction flag in EFLAGs is clear
	361	cld
	362
24851580	363	// UINT64 ExceptionData;
	364	movq ASM_PFX(ExceptData)(%rip), %rax
	365	pushq %rax
	366
	367	// call to C code which will in turn call registered handler
	368	// pass in the vector number
	369	movq %rsp, %rdx
c7a5da72	370	movq ASM_PFX(ExceptionNumber)(%rip), %rcx
24851580	371	subq $40, %rsp
	372	call ASM_PFX(InterruptDistrubutionHub)
	373	addq $40, %rsp
	374	// restore context...
	375	// UINT64 ExceptionData;
	376	addq $8, %rsp
	377
	378	// FX_SAVE_STATE_X64 FxSaveState;
	379	movq %rsp, %rsi
c7a5da72	380
24851580	381	# FXRSTOR_RSI
	382	fxrstor (%rsi)
	383
	384	addq $512, %rsp
	385
	386	// UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
	387	popq %rax
	388	movq %rax, %dr0
	389	popq %rax
	390	movq %rax, %dr1
	391	popq %rax
	392	movq %rax, %dr2
	393	popq %rax
	394	movq %rax, %dr3
	395
	396	// skip restore of dr6. We cleared dr6 during the context save.
	397	addq $8, %rsp
	398	popq %rax
	399	movq %rax, %dr7
	400
	401	// UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
	402	popq %rax
	403	movq %rax, %cr0
	404	addq $8, %rsp
	405	popq %rax
	406	movq %rax, %cr2
	407	popq %rax
	408	movq %rax, %cr3
	409	popq %rax
	410	movq %rax, %cr4
	411	popq %rax
	412	movq %rax, %cr8
	413	// UINT64 RFlags;
c7a5da72	414	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	415	popq 16(%rax)
	416	// UINT64 Ldtr, Tr;
	417	// UINT64 Gdtr[2], Idtr[2];
	418	// Best not let anyone mess with these particular registers...
	419	addq $48, %rsp
	420	// UINT64 Rip;
	421	popq (%rax)
	422
	423	// UINT64 Gs, Fs, Es, Ds, Cs, Ss;
	424	// NOTE - modified segment registers could hang the debugger... We
	425	// could attempt to insulate ourselves against this possibility,
	426	// but that poses risks as well.
	427	//
	428
	429	popq %rax
	430	# mov %rax, %gs
	431	popq %rax
	432	# mov %rax, %fs
	433	popq %rax
	434	mov %rax, %es
	435	popq %rax
	436	mov %rax, %ds
c7a5da72	437	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	438	popq 8(%rax)
	439	popq %rax
	440	mov %rax, %ss
	441	## The next stuff to restore is the general purpose registers that were pushed
	442	## using the "push" instruction.
	443	##
	444	## The value of RSP as stored in the context record is the application RSP
	445	## including the 5 entries on the application stack caused by the exception
	446	## itself. It may have been modified by the debug agent, so we need to
	447	## determine if we need to relocate the application stack.
	448
	449	movq 24(%rsp), %rbx # move the potentially modified AppRsp into rbx
c7a5da72	450	movq ASM_PFX(AppRsp)(%rip), %rax
c7a5da72	451	movq 24(%rax), %rax
24851580	452	cmpq %rax, %rbx
	453	je NoAppStackMove
	454
c7a5da72	455	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	456	movq (%rax), %rcx # RIP
	457	movq %rcx, (%rbx)
	458
	459	movq 8(%rax), %rcx # CS
	460	movq %rcx, 8(%rbx)
	461
	462	movq 16(%rax), %rcx # RFLAGS
	463	movq %rcx, 16(%rbx)
	464
	465	movq 24(%rax), %rcx # RSP
	466	movq %rcx, 24(%rbx)
	467
	468	movq 32(%rax), %rcx # SS
	469	movq %rcx, 32(%rbx)
	470
	471	movq %rbx, %rax # modify the saved AppRsp to the new AppRsp
	472	movq %rax, ASM_PFX(AppRsp)(%rip)
	473	NoAppStackMove:
	474	movq ASM_PFX(DebugRsp)(%rip), %rax # restore the DebugRsp on the debug stack
	475	# so our "pop" will not cause a stack switch
	476	movq %rax, 24(%rsp)
	477
	478	cmpl $0x068, ASM_PFX(ExceptionNumber)(%rip)
	479	jne NoChain
	480
	481	Chain:
	482
	483	// Restore rflags so when we chain, the flags will be exactly as if we were never here.
	484	// We gin up the stack to do an iretq so we can get ALL the flags.
c7a5da72	485	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	486	movq 40(%rax), %rbx
	487	pushq %rbx
	488	mov %ss, %rax
	489	pushq %rax
	490	movq %rsp, %rax
	491	addq $16, %rax
	492	pushq %rax
c7a5da72	493	movq ASM_PFX(AppRsp)(%rip), %rax
24851580	494	movq 16(%rax), %rbx
	495	andq $0xfffffffffffffcff, %rbx # special handling for IF and TF
	496	pushq %rbx
	497	mov %cs, %rax
	498	pushq %rax
c7a5da72	499	movq PhonyIretq(%rip), %rax
24851580	500	pushq %rax
	501	iretq
	502	PhonyIretq:
	503
	504	// UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
	505	// UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
	506	popq %rdi
	507	popq %rsi
	508	popq %rbp
	509	popq %rsp
	510	popq %rbx
	511	popq %rdx
	512	popq %rcx
	513	popq %rax
	514	popq %r8
	515	popq %r9
	516	popq %r10
	517	popq %r11
	518	popq %r12
	519	popq %r13
	520	popq %r14
	521	popq %r15
	522
	523	// Switch back to application stack
c7a5da72	524	movq ASM_PFX(AppRsp)(%rip), %rsp
24851580	525	// Jump to original handler
	526	jmp ASM_PFX(OrigVector)
	527	NoChain:
	528	// UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
	529	// UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
	530	popq %rdi
	531	popq %rsi
	532	popq %rbp
	533	popq %rsp
	534	popq %rbx
	535	popq %rdx
	536	popq %rcx
	537	popq %rax
	538	popq %r8
	539	popq %r9
	540	popq %r10
	541	popq %r11
	542	popq %r12
	543	popq %r13
	544	popq %r14
	545	popq %r15
	546
	547	// Switch back to application stack
c7a5da72	548	movq ASM_PFX(AppRsp)(%rip), %rsp
24851580	549
	550	// We're outa here...
	551	iret