DuetPkg/BootSector/efi64.asm - edk2 - Git at Google

 ;------------------------------------------------------------------------------
 ;*
 ;*   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
	;------------------------------------------------------------------------------
	;*
	;* 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