2 # Low leve x64 specific debug support functions.
4 # Copyright (c) 2006 - 2009, Intel Corporation
5 # All rights reserved. This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 ASM_GLOBAL ASM_PFX(OrigVector)
16 ASM_GLOBAL ASM_PFX(InterruptEntryStub)
17 ASM_GLOBAL ASM_PFX(StubSize)
18 ASM_GLOBAL ASM_PFX(CommonIdtEntry)
19 ASM_GLOBAL ASM_PFX(FxStorSupport)
23 ASM_PFX(StubSize): .long ASM_PFX(InterruptEntryStubEnd) - ASM_PFX(InterruptEntryStub)
24 ASM_PFX(AppRsp): .long 0x11111111 # ?
26 ASM_PFX(DebugRsp): .long 0x22222222 # ?
28 ASM_PFX(ExtraPush): .long 0x33333333 # ?
30 ASM_PFX(ExceptData): .long 0x44444444 # ?
32 ASM_PFX(Rflags): .long 0x55555555 # ?
34 ASM_PFX(OrigVector): .long 0x66666666 # ?
37 ## The declarations below define the memory region that will be used for the debug stack.
38 ## The context record will be built by pushing register values onto this stack.
39 ## It is imparitive that alignment be carefully managed, since the FXSTOR and
40 ## FXRSTOR instructions will GP fault if their memory operand is not 16 byte aligned.
42 ## The stub will switch stacks from the application stack to the debuger stack
43 ## and pushes the exception number.
45 ## Then we building the context record on the stack. Since the stack grows down,
46 ## we push the fields of the context record from the back to the front. There
47 ## are 336 bytes of stack used prior allocating the 512 bytes of stack to be
48 ## used as the memory buffer for the fxstor instruction. Therefore address of
49 ## the buffer used for the FXSTOR instruction is &Eax - 336 - 512, which
50 ## must be 16 byte aligned.
52 ## We carefully locate the stack to make this happen.
54 ## For reference, the context structure looks like this:
56 ## UINT64 ExceptionData;
57 ## FX_SAVE_STATE_X64 FxSaveState; // 512 bytes, must be 16 byte aligned
58 ## UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
59 ## UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
62 ## UINT64 Gdtr[2], Idtr[2];
64 ## UINT64 Gs, Fs, Es, Ds, Cs, Ss;
65 ## UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
66 ## UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
67 ## } SYSTEM_CONTEXT_X64; // 64 bit system context record
70 DebugStackEnd : .ascii "DbgStkEnd >>>>>>" # 16 byte long string - must be 16 bytes to preserve alignment
71 .fill 0x1ffc, 4, 0x00000000
72 # 32K should be enough stack
73 # This allocation is coocked to insure
74 # that the the buffer for the FXSTORE instruction
75 # will be 16 byte aligned also.
77 ASM_PFX(ExceptionNumber): .long 0x77777777 # first entry will be the vector number pushed by the stub
80 DebugStackBegin : .ascii "<<<< DbgStkBegin" # initial debug ESP == DebugStackBegin, set in stub
85 #------------------------------------------------------------------------------
91 # Abstract: Returns TRUE if FxStor instructions are supported
93 ASM_GLOBAL ASM_PFX(FxStorSupport)
94 ASM_PFX(FxStorSupport):
96 # cpuid corrupts rbx which must be preserved per the C calling convention
102 andq $0x01000000, %rax
106 #------------------------------------------------------------------------------
109 # IA32_IDT_GATE_DESCRIPTOR * DestDesc, // rcx
110 # void (*Vector) (void) // rdx
113 # Abstract: Encodes an IDT descriptor with the given physical address
115 ASM_GLOBAL ASM_PFX(Vect2Desc)
118 movw %ax, (%rcx) # write bits 15..0 of offset
120 movw %dx, 2(%rcx) # SYS_CODE_SEL from GDT
121 movw $(0x0e00 | 0x8000), 4(%rcx) # type = 386 interrupt gate, present
123 movw %ax, 6(%rcx) # write bits 31..16 of offset
125 movl %eax, 8(%rcx) # write bits 63..32 of offset
129 #------------------------------------------------------------------------------
132 # Abstract: This code is not a function, but is a small piece of code that is
133 # copied and fixed up once for each IDT entry that is hooked.
135 ASM_GLOBAL ASM_PFX(InterruptEntryStub)
136 ASM_PFX(InterruptEntryStub):
138 pushq $0 # push vector number - will be modified before installed
139 jmp ASM_PFX(CommonIdtEntry)
141 ASM_GLOBAL ASM_PFX(InterruptEntryStubEnd)
142 ASM_PFX(InterruptEntryStubEnd):
144 #------------------------------------------------------------------------------
147 # Abstract: This code is not a function, but is the common part for all IDT
150 ASM_GLOBAL ASM_PFX(CommonIdtEntry)
152 ## At this point, the stub has saved the current application stack esp into AppRsp
153 ## and switched stacks to the debug stack, where it pushed the vector number
155 ## The application stack looks like this:
158 ## (last application stack entry)
159 ## [16 bytes alignment, do not care it]
160 ## SS from interrupted task
161 ## RSP from interrupted task
162 ## rflags from interrupted task
163 ## CS from interrupted task
164 ## RIP from interrupted task
165 ## Error code <-------------------- Only present for some exeption types
167 ## Vector Number <----------------- pushed in our IDT Entry
171 ## The stub switched us to the debug stack and pushed the interrupt number.
173 ## Next, construct the context record. It will be build on the debug stack by
174 ## pushing the registers in the correct order so as to create the context structure
175 ## on the debug stack. The context record must be built from the end back to the
176 ## beginning because the stack grows down...
178 ## For reference, the context record looks like this:
182 ## UINT64 ExceptionData;
183 ## FX_SAVE_STATE_X64 FxSaveState;
184 ## UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
185 ## UINT64 Cr0, Cr2, Cr3, Cr4, Cr8;
188 ## UINT64 Gdtr[2], Idtr[2];
190 ## UINT64 Gs, Fs, Es, Ds, Cs, Ss;
191 ## UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
192 ## UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
193 ## } SYSTEM_CONTEXT_X64; // 64
194 ASM_PFX(CommonIdtEntry):
195 ## NOTE: we save rsp here to prevent compiler put rip reference cause error AppRsp
197 movq (8)(%rsp), %rax # save vector number
198 movq %rax, ASM_PFX(ExceptionNumber) # save vector number
200 addq $8, %rsp # pop vector number
201 movq %rsp, ASM_PFX(AppRsp) # save stack top
202 movq DebugStackBegin, %rsp # switch to debugger stack
203 subq $8, %rsp # leave space for vector number
204 ## UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
205 ## UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
222 ## Save interrupt state rflags register...
225 movq %rax, ASM_PFX(Rflags)
226 ## We need to determine if any extra data was pushed by the exception, and if so, save it
227 ## To do this, we check the exception number pushed by the stub, and cache the
228 ## result in a variable since we'll need this again.
229 cmpl $0, ASM_PFX(ExceptionNumber)
231 cmpl $10, ASM_PFX(ExceptionNumber)
233 cmpl $11, ASM_PFX(ExceptionNumber)
235 cmpl $12, ASM_PFX(ExceptionNumber)
237 cmpl $13, ASM_PFX(ExceptionNumber)
239 cmpl $14, ASM_PFX(ExceptionNumber)
241 cmpl $17, ASM_PFX(ExceptionNumber)
243 movl $0, ASM_PFX(ExtraPush)
244 movl $0, ASM_PFX(ExceptData)
247 movl $1, ASM_PFX(ExtraPush)
249 ## If there's some extra data, save it also, and modify the saved AppRsp to effectively
250 ## pop this value off the application's stack.
251 movq ASM_PFX(AppRsp), %rax
253 movq %rbx, ASM_PFX(ExceptData)
255 movq %rax, ASM_PFX(AppRsp)
259 ## The "push" above pushed the debug stack rsp. Since what we're actually doing
260 ## is building the context record on the debug stack, we need to save the pushed
261 ## debug RSP, and replace it with the application's last stack entry...
263 movq %rax, ASM_PFX(DebugRsp)
264 movq ASM_PFX(AppRsp), %rax
266 # application stack has ss, rsp, rflags, cs, & rip, so
267 # last actual application stack entry is 40 bytes
268 # into the application stack.
271 ## continue building context record
272 ## UINT64 Gs, Fs, Es, Ds, Cs, Ss; insure high 16 bits of each is zero
275 # CS from application is one entry back in application stack
276 movq ASM_PFX(AppRsp), %rax
289 # Rip from application is on top of application stack
290 movq ASM_PFX(AppRsp), %rax
292 ## UINT64 Gdtr[2], Idtr[2];
308 ## Rflags from application is two entries back in application stack
309 movq ASM_PFX(AppRsp), %rax
311 ## UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
312 ## insure FXSAVE/FXRSTOR is enabled in CR4...
313 ## ... while we're at it, make sure DE is also enabled...
327 ## UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
330 ## clear Dr7 while executing debugger itself
336 ## insure all status bits in dr6 are clear...
349 ## FX_SAVE_STATE_X64 FxSaveState;
352 # IMPORTANT!! The debug stack has been carefully constructed to
353 # insure that rsp and rdi are 16 byte aligned when we get here.
354 # They MUST be. If they are not, a GP fault will occur.
359 ## UINT64 ExceptionData;
360 movq ASM_PFX(ExceptData), %rax
363 # call to C code which will in turn call registered handler
364 # pass in the vector number
366 movq ASM_PFX(ExceptionNumber), %rcx
368 call ASM_PFX(InterruptDistrubutionHub)
371 ## UINT64 ExceptionData;
374 ## FX_SAVE_STATE_X64 FxSaveState;
382 ## UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
392 ## skip restore of dr6. We cleared dr6 during the context save.
397 ## UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
410 movq ASM_PFX(AppRsp), %rax
413 ## UINT64 Gdtr[2], Idtr[2];
414 ## Best not let anyone mess with these particular registers...
419 ## UINT64 Gs, Fs, Es, Ds, Cs, Ss;
420 ## NOTE - modified segment registers could hang the debugger... We
421 ## could attempt to insulate ourselves against this possibility,
422 ## but that poses risks as well.
433 movq ASM_PFX(AppRsp), %rax
437 ## The next stuff to restore is the general purpose registers that were pushed
438 ## using the "push" instruction.
440 ## The value of RSP as stored in the context record is the application RSP
441 ## including the 5 entries on the application stack caused by the exception
442 ## itself. It may have been modified by the debug agent, so we need to
443 ## determine if we need to relocate the application stack.
445 movq 24(%rsp), %rbx # move the potentially modified AppRsp into rbx
446 movq ASM_PFX(AppRsp), %rax
451 movq ASM_PFX(AppRsp), %rax
452 movq (%rax), %rcx # RIP
455 movq 8(%rax), %rcx # CS
458 movq 16(%rax), %rcx # RFLAGS
461 movq 24(%rax), %rcx # RSP
464 movq 32(%rax), %rcx # SS
467 movq %rbx, %rax # modify the saved AppRsp to the new AppRsp
468 movq %rax, ASM_PFX(AppRsp)
470 movq ASM_PFX(DebugRsp), %rax # restore the DebugRsp on the debug stack
471 # so our "pop" will not cause a stack switch
474 cmpl $0x068, ASM_PFX(ExceptionNumber)
479 ## Restore rflags so when we chain, the flags will be exactly as if we were never here.
480 ## We gin up the stack to do an iretq so we can get ALL the flags.
481 movq ASM_PFX(AppRsp), %rax
489 movq ASM_PFX(AppRsp), %rax
491 andq $0xfffffffffffffcff, %rbx # special handling for IF and TF
495 movq PhonyIretq, %rax
500 ## UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
501 ## UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
519 ## Switch back to application stack
520 movq ASM_PFX(AppRsp), %rsp
521 ## Jump to original handler
522 jmp ASM_PFX(OrigVector)
524 ## UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
525 ## UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
543 ## Switch back to application stack
544 movq ASM_PFX(AppRsp), %rsp
546 ## We're outa here...