mirror of https://github.com/acidanthera/audk.git
788 lines
20 KiB
NASM
788 lines
20 KiB
NASM
;------------------------------------------------------------------------------
|
|
;*
|
|
;* Copyright 2006, Intel Corporation
|
|
;* All rights reserved. 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.
|
|
;*
|
|
;* efi64.asm
|
|
;*
|
|
;* Abstract:
|
|
;*
|
|
;------------------------------------------------------------------------------
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; Now in 64-bit long mode.
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
.486
|
|
.model flat
|
|
.stack
|
|
.code
|
|
org 21000h
|
|
|
|
DEFAULT_HANDLER_SIZE EQU INT1 - INT0
|
|
|
|
JmpCommonIdtEntry macro
|
|
; jmp commonIdtEntry - this must be hand coded to keep the assembler from
|
|
; using a 8 bit reletive jump when the entries are
|
|
; within 255 bytes of the common entry. This must
|
|
; be done to maintain the consistency of the size
|
|
; of entry points...
|
|
db 0e9h ; jmp 16 bit reletive
|
|
dd commonIdtEntry - $ - 4 ; offset to jump to
|
|
endm
|
|
|
|
|
|
Start:
|
|
|
|
mov esp,0001fffe8h ; make final stack aligned
|
|
|
|
; set OSFXSR and OSXMMEXCPT because some code will use XMM register
|
|
db 0fh
|
|
db 20h
|
|
db 0e0h
|
|
; mov rax, cr4
|
|
bts eax, 9
|
|
bts eax, 0ah
|
|
db 0fh
|
|
db 22h
|
|
db 0e0h
|
|
; mov cr4, rax
|
|
|
|
call ClearScreen
|
|
|
|
; Populate IDT with meaningful offsets for exception handlers...
|
|
mov eax, offset Idtr
|
|
sidt fword ptr [eax] ; get fword address of IDT
|
|
|
|
mov eax, offset Halt
|
|
mov ebx, eax ; use bx to copy 15..0 to descriptors
|
|
shr eax, 16 ; use ax to copy 31..16 to descriptors
|
|
; 63..32 of descriptors is 0
|
|
mov ecx, 78h ; 78h IDT entries to initialize with unique entry points (exceptions)
|
|
mov esi, [offset Idtr + 2]
|
|
mov edi, [esi]
|
|
|
|
@@: ; loop through all IDT entries exception handlers and initialize to default handler
|
|
mov word ptr [edi], bx ; write bits 15..0 of offset
|
|
mov word ptr [edi+2], 38h ; SYS_CODE64_SEL from GDT
|
|
mov word ptr [edi+4], 0e00h OR 8000h ; type = 386 interrupt gate, present
|
|
mov word ptr [edi+6], ax ; write bits 31..16 of offset
|
|
mov dword ptr [edi+8], 0 ; write bits 63..32 of offset
|
|
add edi, 16 ; move up to next descriptor
|
|
add bx, DEFAULT_HANDLER_SIZE ; move to next entry point
|
|
loop @b ; loop back through again until all descriptors are initialized
|
|
|
|
;; at this point edi contains the offset of the descriptor for INT 20
|
|
;; and bx contains the low 16 bits of the offset of the default handler
|
|
;; so initialize all the rest of the descriptors with these two values...
|
|
; mov ecx, 101 ; there are 100 descriptors left (INT 20 (14h) - INT 119 (77h)
|
|
;@@: ; loop through all IDT entries exception handlers and initialize to default handler
|
|
; mov word ptr [edi], bx ; write bits 15..0 of offset
|
|
; mov word ptr [edi+2], 38h ; SYS_CODE64_SEL from GDT
|
|
; mov word ptr [edi+4], 0e00h OR 8000h ; type = 386 interrupt gate, present
|
|
; mov word ptr [edi+6], ax ; write bits 31..16 of offset
|
|
; mov dword ptr [edi+8], 0 ; write bits 63..32 of offset
|
|
; add edi, 16 ; move up to next descriptor
|
|
; loop @b ; loop back through again until all descriptors are initialized
|
|
|
|
|
|
;; DUMP location of IDT and several of the descriptors
|
|
; mov ecx, 8
|
|
; mov eax, [offset Idtr + 2]
|
|
; mov eax, [eax]
|
|
; mov edi, 0b8000h
|
|
; call PrintQword
|
|
; mov esi, eax
|
|
; mov edi, 0b80a0h
|
|
; jmp OuterLoop
|
|
|
|
;;
|
|
;; just for fun, let's do a software interrupt to see if we correctly land in the exception handler...
|
|
; mov eax, 011111111h
|
|
; mov ebx, 022222222h
|
|
; mov ecx, 033333333h
|
|
; mov edx, 044444444h
|
|
; mov ebp, 055555555h
|
|
; mov esi, 066666666h
|
|
; mov edi, 077777777h
|
|
; push 011111111h
|
|
; push 022222222h
|
|
; push 033333333h
|
|
; int 119
|
|
|
|
mov esi,022000h ; esi = 22000
|
|
mov eax,[esi+014h] ; eax = [22014]
|
|
add esi,eax ; esi = 22000 + [22014] = Base of EFILDR.C
|
|
mov ebp,[esi+03ch] ; ebp = [22000 + [22014] + 3c] = NT Image Header for EFILDR.C
|
|
add ebp,esi
|
|
mov edi,[ebp+030h] ; edi = [[22000 + [22014] + 3c] + 2c] = ImageBase (63..32 is zero, ignore)
|
|
mov eax,[ebp+028h] ; eax = [[22000 + [22014] + 3c] + 24] = EntryPoint
|
|
add eax,edi ; eax = ImageBase + EntryPoint
|
|
mov ebx, offset EfiLdrOffset
|
|
mov dword ptr [ebx],eax ; Modify far jump instruction for correct entry point
|
|
|
|
mov bx,word ptr[ebp+6] ; bx = Number of sections
|
|
xor eax,eax
|
|
mov ax,word ptr[ebp+014h] ; ax = Optional Header Size
|
|
add ebp,eax
|
|
add ebp,018h ; ebp = Start of 1st Section
|
|
|
|
SectionLoop:
|
|
push esi ; Save Base of EFILDR.C
|
|
push edi ; Save ImageBase
|
|
add esi,[ebp+014h] ; esi = Base of EFILDR.C + PointerToRawData
|
|
add edi,[ebp+00ch] ; edi = ImageBase + VirtualAddress
|
|
mov ecx,[ebp+010h] ; ecs = SizeOfRawData
|
|
|
|
cld
|
|
shr ecx,2
|
|
rep movsd
|
|
|
|
pop edi ; Restore ImageBase
|
|
pop esi ; Restore Base of EFILDR.C
|
|
|
|
add bp,028h ; ebp = ebp + 028h = Pointer to next section record
|
|
db 66h
|
|
db 0ffh
|
|
db 0cbh
|
|
; dec bx
|
|
cmp bx,0
|
|
jne SectionLoop
|
|
|
|
mov edx, offset Idtr
|
|
movzx eax, word ptr [edx] ; get size of IDT
|
|
db 0ffh
|
|
db 0c0h
|
|
; inc eax
|
|
add eax, dword ptr [edx + 2] ; add to base of IDT to get location of memory map...
|
|
xor ecx, ecx
|
|
mov ecx, eax ; put argument to RCX
|
|
|
|
db 48h
|
|
db 0c7h
|
|
db 0c0h
|
|
EfiLdrOffset:
|
|
dd 000401000h ; Offset of EFILDR
|
|
; mov rax, 401000h
|
|
db 50h
|
|
; push rax
|
|
|
|
; ret
|
|
db 0c3h
|
|
|
|
; db "**** DEFAULT IDT ENTRY ***",0
|
|
align 02h
|
|
Halt:
|
|
INT0:
|
|
push 0h ; push error code place holder on the stack
|
|
push 0h
|
|
JmpCommonIdtEntry
|
|
; db 0e9h ; jmp 16 bit reletive
|
|
; dd commonIdtEntry - $ - 4 ; offset to jump to
|
|
|
|
INT1:
|
|
push 0h ; push error code place holder on the stack
|
|
push 1h
|
|
JmpCommonIdtEntry
|
|
|
|
INT2:
|
|
push 0h ; push error code place holder on the stack
|
|
push 2h
|
|
JmpCommonIdtEntry
|
|
|
|
INT3:
|
|
push 0h ; push error code place holder on the stack
|
|
push 3h
|
|
JmpCommonIdtEntry
|
|
|
|
INT4:
|
|
push 0h ; push error code place holder on the stack
|
|
push 4h
|
|
JmpCommonIdtEntry
|
|
|
|
INT5:
|
|
push 0h ; push error code place holder on the stack
|
|
push 5h
|
|
JmpCommonIdtEntry
|
|
|
|
INT6:
|
|
push 0h ; push error code place holder on the stack
|
|
push 6h
|
|
JmpCommonIdtEntry
|
|
|
|
INT7:
|
|
push 0h ; push error code place holder on the stack
|
|
push 7h
|
|
JmpCommonIdtEntry
|
|
|
|
INT8:
|
|
; Double fault causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 8h
|
|
JmpCommonIdtEntry
|
|
|
|
INT9:
|
|
push 0h ; push error code place holder on the stack
|
|
push 9h
|
|
JmpCommonIdtEntry
|
|
|
|
INT10:
|
|
; Invalid TSS causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 10
|
|
JmpCommonIdtEntry
|
|
|
|
INT11:
|
|
; Segment Not Present causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 11
|
|
JmpCommonIdtEntry
|
|
|
|
INT12:
|
|
; Stack fault causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 12
|
|
JmpCommonIdtEntry
|
|
|
|
INT13:
|
|
; GP fault causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 13
|
|
JmpCommonIdtEntry
|
|
|
|
INT14:
|
|
; Page fault causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 14
|
|
JmpCommonIdtEntry
|
|
|
|
INT15:
|
|
push 0h ; push error code place holder on the stack
|
|
push 15
|
|
JmpCommonIdtEntry
|
|
|
|
INT16:
|
|
push 0h ; push error code place holder on the stack
|
|
push 16
|
|
JmpCommonIdtEntry
|
|
|
|
INT17:
|
|
; Alignment check causes an error code to be pushed so no phony push necessary
|
|
nop
|
|
nop
|
|
push 17
|
|
JmpCommonIdtEntry
|
|
|
|
INT18:
|
|
push 0h ; push error code place holder on the stack
|
|
push 18
|
|
JmpCommonIdtEntry
|
|
|
|
INT19:
|
|
push 0h ; push error code place holder on the stack
|
|
push 19
|
|
JmpCommonIdtEntry
|
|
|
|
INTUnknown:
|
|
REPEAT (78h - 20)
|
|
push 0h ; push error code place holder on the stack
|
|
; push xxh ; push vector number
|
|
db 06ah
|
|
db ( $ - INTUnknown - 3 ) / 9 + 20 ; vector number
|
|
JmpCommonIdtEntry
|
|
ENDM
|
|
|
|
commonIdtEntry:
|
|
push eax
|
|
push ecx
|
|
push edx
|
|
push ebx
|
|
push esp
|
|
push ebp
|
|
push esi
|
|
push edi
|
|
db 41h
|
|
db 50h
|
|
; push r8
|
|
db 41h
|
|
db 51h
|
|
; push r9
|
|
db 41h
|
|
db 52h
|
|
; push r10
|
|
db 41h
|
|
db 53h
|
|
; push r11
|
|
db 41h
|
|
db 54h
|
|
; push r12
|
|
db 41h
|
|
db 55h
|
|
; push r13
|
|
db 41h
|
|
db 56h
|
|
; push r14
|
|
db 41h
|
|
db 57h
|
|
; push r15
|
|
db 48h
|
|
mov ebp, esp
|
|
; mov rbp, rsp
|
|
|
|
;;
|
|
;; At this point the stack looks like this:
|
|
;;
|
|
;; Calling SS
|
|
;; Calling RSP
|
|
;; rflags
|
|
;; Calling CS
|
|
;; Calling RIP
|
|
;; Error code or 0
|
|
;; Int num or 0ffh for unknown int num
|
|
;; rax
|
|
;; rcx
|
|
;; rdx
|
|
;; rbx
|
|
;; rsp
|
|
;; rbp
|
|
;; rsi
|
|
;; rdi
|
|
;; r8
|
|
;; r9
|
|
;; r10
|
|
;; r11
|
|
;; r12
|
|
;; r13
|
|
;; r14
|
|
;; r15 <------- RSP, RBP
|
|
;;
|
|
|
|
call ClearScreen
|
|
mov esi, offset String1
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp + 16*8] ;; move Int number into RAX
|
|
db 48h
|
|
cmp eax, 18
|
|
ja PrintDefaultString
|
|
PrintExceptionString:
|
|
shl eax, 3 ;; multiply by 8 to get offset from StringTable to actual string address
|
|
add eax, offset StringTable
|
|
mov esi, [eax]
|
|
jmp PrintTheString
|
|
PrintDefaultString:
|
|
mov esi, offset IntUnknownString
|
|
; patch Int number
|
|
mov edx, eax
|
|
call A2C
|
|
mov [esi + 1], al
|
|
mov eax, edx
|
|
shr eax, 4
|
|
call A2C
|
|
mov [esi], al
|
|
PrintTheString:
|
|
call PrintString
|
|
mov esi, offset String2
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+19*8] ; CS
|
|
call PrintQword
|
|
mov al, ':'
|
|
mov byte ptr [edi], al
|
|
add edi, 2
|
|
db 48h
|
|
mov eax, [ebp+18*8] ; RIP
|
|
call PrintQword
|
|
mov esi, offset String3
|
|
call PrintString
|
|
|
|
mov edi, 0b8140h
|
|
|
|
mov esi, offset StringRax ; rax
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+15*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringRcx ; rcx
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+14*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringRdx ; rdx
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+13*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b81e0h
|
|
|
|
mov esi, offset StringRbx ; rbx
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+12*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringRsp ; rsp
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+21*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringRbp ; rbp
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+10*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b8280h
|
|
|
|
mov esi, offset StringRsi ; rsi
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+9*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringRdi ; rdi
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+8*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringEcode ; error code
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+17*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b8320h
|
|
|
|
mov esi, offset StringR8 ; r8
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+7*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringR9 ; r9
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+6*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringR10 ; r10
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+5*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b83c0h
|
|
|
|
mov esi, offset StringR11 ; r11
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+4*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringR12 ; r12
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+3*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringR13 ; r13
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+2*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b8460h
|
|
|
|
mov esi, offset StringR14 ; r14
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+1*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringR15 ; r15
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+0*8]
|
|
call PrintQword
|
|
|
|
mov esi, offset StringSs ; ss
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+22*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b8500h
|
|
|
|
mov esi, offset StringRflags ; rflags
|
|
call PrintString
|
|
db 48h
|
|
mov eax, [ebp+20*8]
|
|
call PrintQword
|
|
|
|
mov edi, 0b8640h
|
|
|
|
mov esi, ebp
|
|
add esi, 23*8
|
|
mov ecx, 4
|
|
|
|
|
|
OuterLoop:
|
|
push ecx
|
|
mov ecx, 4
|
|
db 48h
|
|
mov edx, edi
|
|
|
|
InnerLoop:
|
|
db 48h
|
|
mov eax, [esi]
|
|
call PrintQword
|
|
add esi, 8
|
|
mov al, ' '
|
|
mov [edi], al
|
|
add edi, 2
|
|
loop InnerLoop
|
|
|
|
pop ecx
|
|
add edx, 0a0h
|
|
mov edi, edx
|
|
loop OuterLoop
|
|
|
|
|
|
mov edi, 0b8960h
|
|
|
|
db 48h
|
|
mov eax, [ebp+18*8] ; RIP
|
|
sub eax, 8 * 8
|
|
db 48h
|
|
mov esi, eax ; esi = rip - 8 QWORD linear (total 16 QWORD)
|
|
|
|
mov ecx, 4
|
|
|
|
OuterLoop1:
|
|
push ecx
|
|
mov ecx, 4
|
|
mov edx, edi
|
|
|
|
InnerLoop1:
|
|
db 48h
|
|
mov eax, [esi]
|
|
call PrintQword
|
|
add esi, 8
|
|
mov al, ' '
|
|
mov [edi], al
|
|
add edi, 2
|
|
loop InnerLoop1
|
|
|
|
pop ecx
|
|
add edx, 0a0h
|
|
mov edi, edx
|
|
loop OuterLoop1
|
|
|
|
|
|
|
|
;wbinvd
|
|
@@:
|
|
jmp @b
|
|
|
|
;
|
|
; return
|
|
;
|
|
mov esp, ebp
|
|
; mov rsp, rbp
|
|
db 41h
|
|
db 5fh
|
|
; pop r15
|
|
db 41h
|
|
db 5eh
|
|
; pop r14
|
|
db 41h
|
|
db 5dh
|
|
; pop r13
|
|
db 41h
|
|
db 5ch
|
|
; pop r12
|
|
db 41h
|
|
db 5bh
|
|
; pop r11
|
|
db 41h
|
|
db 5ah
|
|
; pop r10
|
|
db 41h
|
|
db 59h
|
|
; pop r9
|
|
db 41h
|
|
db 58h
|
|
; pop r8
|
|
pop edi
|
|
pop esi
|
|
pop ebp
|
|
pop eax ; esp
|
|
pop ebx
|
|
pop edx
|
|
pop ecx
|
|
pop eax
|
|
|
|
db 48h
|
|
db 83h
|
|
db 0c4h
|
|
db 10h
|
|
; add esp, 16 ; error code and INT number
|
|
|
|
db 48h
|
|
db 0cfh
|
|
; iretq
|
|
|
|
PrintString:
|
|
push eax
|
|
@@:
|
|
mov al, byte ptr [esi]
|
|
cmp al, 0
|
|
je @f
|
|
mov byte ptr [edi], al
|
|
db 0ffh
|
|
db 0c6h
|
|
; inc esi
|
|
add edi, 2
|
|
jmp @b
|
|
@@:
|
|
pop eax
|
|
ret
|
|
|
|
;; RAX contains qword to print
|
|
;; RDI contains memory location (screen location) to print it to
|
|
PrintQword:
|
|
push ecx
|
|
push ebx
|
|
push eax
|
|
|
|
db 48h
|
|
db 0c7h
|
|
db 0c1h
|
|
dd 16
|
|
; mov rcx, 16
|
|
looptop:
|
|
db 48h
|
|
rol eax, 4
|
|
mov bl, al
|
|
and bl, 0fh
|
|
add bl, '0'
|
|
cmp bl, '9'
|
|
jle @f
|
|
add bl, 7
|
|
@@:
|
|
mov byte ptr [edi], bl
|
|
add edi, 2
|
|
loop looptop
|
|
;wbinvd
|
|
|
|
pop eax
|
|
pop ebx
|
|
pop ecx
|
|
ret
|
|
|
|
ClearScreen:
|
|
push eax
|
|
push ecx
|
|
|
|
mov al, ' '
|
|
mov ah, 0ch
|
|
mov edi, 0b8000h
|
|
mov ecx, 80 * 24
|
|
@@:
|
|
mov word ptr [edi], ax
|
|
add edi, 2
|
|
loop @b
|
|
mov edi, 0b8000h
|
|
|
|
pop ecx
|
|
pop eax
|
|
|
|
ret
|
|
|
|
A2C:
|
|
and al, 0fh
|
|
add al, '0'
|
|
cmp al, '9'
|
|
jle @f
|
|
add al, 7
|
|
@@:
|
|
ret
|
|
|
|
String1 db "*** INT ",0
|
|
|
|
Int0String db "00h Divide by 0 -",0
|
|
Int1String db "01h Debug exception -",0
|
|
Int2String db "02h NMI -",0
|
|
Int3String db "03h Breakpoint -",0
|
|
Int4String db "04h Overflow -",0
|
|
Int5String db "05h Bound -",0
|
|
Int6String db "06h Invalid opcode -",0
|
|
Int7String db "07h Device not available -",0
|
|
Int8String db "08h Double fault -",0
|
|
Int9String db "09h Coprocessor seg overrun (reserved) -",0
|
|
Int10String db "0Ah Invalid TSS -",0
|
|
Int11String db "0Bh Segment not present -",0
|
|
Int12String db "0Ch Stack fault -",0
|
|
Int13String db "0Dh General protection fault -",0
|
|
Int14String db "0Eh Page fault -",0
|
|
Int15String db "0Fh (Intel reserved) -",0
|
|
Int16String db "10h Floating point error -",0
|
|
Int17String db "11h Alignment check -",0
|
|
Int18String db "12h Machine check -",0
|
|
Int19String db "13h SIMD Floating-Point Exception -",0
|
|
IntUnknownString db "??h Unknown interrupt -",0
|
|
|
|
StringTable dq offset Int0String, offset Int1String, offset Int2String, offset Int3String,
|
|
offset Int4String, offset Int5String, offset Int6String, offset Int7String,
|
|
offset Int8String, offset Int9String, offset Int10String, offset Int11String,
|
|
offset Int12String, offset Int13String, offset Int14String, offset Int15String,
|
|
offset Int16String, offset Int17String, offset Int18String, offset Int19String
|
|
|
|
String2 db " HALT!! *** (",0
|
|
String3 db ")",0
|
|
StringRax db "RAX=",0
|
|
StringRcx db " RCX=",0
|
|
StringRdx db " RDX=",0
|
|
StringRbx db "RBX=",0
|
|
StringRsp db " RSP=",0
|
|
StringRbp db " RBP=",0
|
|
StringRsi db "RSI=",0
|
|
StringRdi db " RDI=",0
|
|
StringEcode db " ECODE=",0
|
|
StringR8 db "R8 =",0
|
|
StringR9 db " R9 =",0
|
|
StringR10 db " R10=",0
|
|
StringR11 db "R11=",0
|
|
StringR12 db " R12=",0
|
|
StringR13 db " R13=",0
|
|
StringR14 db "R14=",0
|
|
StringR15 db " R15=",0
|
|
StringSs db " SS =",0
|
|
StringRflags db "RFLAGS=",0
|
|
|
|
Idtr df 0
|
|
df 0
|
|
|
|
org 21ffeh
|
|
BlockSignature:
|
|
dw 0aa55h
|
|
|
|
end
|