OSDev.org

Code: Select all

macro ISR_AUTOERR [NUM] {
  public isr#NUM
  isr#NUM:
        cli
        push 0
        push NUM
        jmp  isr_common_stub
}

macro ISR_CPUERR [NUM] {
  public isr#NUM
  isr#NUM:
        cli
        push NUM
        jmp  isr_common_stub
}

; This works the same as calling the macro many times with
; a different number as the parameter each time.
; Reason for this is the [] around NUM in the macro declaration
ISR_AUTOERR 0, 1, 2, 3, 4, 5, 6, 7
ISR_CPUERR  8
ISR_AUTOERR 9
ISR_CPUERR  10, 11, 12, 13, 14
ISR_AUTOERR 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
ISR_AUTOERR 25, 26, 27, 28, 29, 30, 31

Code: Select all

.text
.code64

.macro function name
    .align 0x10;
    .globl          \name;
    .type           \name, @function;
    \name:
.endm

.macro  vector1     number
    .align 0x10;
    pushq           %rdi;
    movq            $(_ZN3x6420interruptVectorTableE + (\number * 8)), %rdi;
    jmp             interruptVectorStage2;
.endm

.macro  vector1List from, to
    .align 0x10;
    vector1        \from;
    .if             \to - \from
        vector1List "(\from+1)", \to
    .endif
.endm

.macro  vector2     number
    .align 0x10;
    pushq           %rdi;       //- 1 Byte opcode for dummy error code.
    pushq           %rdi;
    movq            $(_ZN3x6420interruptVectorTableE + (\number * 8)), %rdi;
    jmp             interruptVectorStage2;
.endm

.macro  vector2List from, to
    .align 0x10;
    vector2         \from;
    .if             \to - \from
        vector2List "(\from+1)", \to
    .endif
.endm

function    interruptVectorBase
    vector2List       0,   7
    vector1           8
    vector2           9         //- reserved
    vector1List      10, 14
    vector2List      15, 16     //- reserved
    vector1          17
    vector2List      18,  63
    vector2List      64, 127
    vector2List     128, 191
    vector2List     192, 255

//function    interruptVectorStage2
.align 0x10;
interruptVectorStage2:
    //- stackframe at this point:
    //- %SS | %RSP | %RFL | %CS | %RIP | ERR | %RDI
    //- %RDI : contains vector address.
    //- save general purpose registers.
    pushq           %rsi;
    pushq           %rax;
    pushq           %rbx;
    pushq           %rcx;
    pushq           %rdx;
    pushq           %rbp;
    pushq           %r8;
    pushq           %r9;
    pushq           %r10;
    pushq           %r11;
    pushq           %r12;
    pushq           %r13;
    pushq           %r14;
    pushq           %r15;
    pushw           %fs;
    pushw           %gs;

    //- call the interrupt handler (vector).
    movq            %rsp, %rsi;
    call            *(%rdi);

    //- restore general purpose registers.
    popw            %gs;
    popw            %fs;
    popq            %r15;
    popq            %r14;
    popq            %r13;
    popq            %r12;
    popq            %r11;
    popq            %r10;
    popq            %r9;
    popq            %r8;
    popq            %rbp;
    popq            %rdx;
    popq            %rcx;
    popq            %rbx;
    popq            %rax;
    popq            %rsi;
    popq            %rdi;
    addq            $0x08, %rsp;
    iretq;

Code: Select all

ISR_AUTOERR 0, 1, 2, 3, 4, 5, 6, 7 
ISR_CPUERR  8 
ISR_AUTOERR 9

Code: Select all

ISR_AUTOERR 0
ISR_AUTOERR 1
ISR_AUTOERR 2
ISR_AUTOERR 3
ISR_AUTOERR 4
ISR_AUTOERR 5
ISR_AUTOERR 6
ISR_AUTOERR 7
ISR_CPUERR  8
ISR_AUTOERR 9

Code: Select all

LoadLibrary ("hal.dll");                 // load dynamic library
void (*Initialize) () = GetProcAddress ("Initialize");

// Initialize HAL. Initialize default chipset configuration for x86 specific
// motherboards
(*Initialize) ();

// enable interrupts. HAL has set up default stub interrupt handler
sti();

// register whatever callbacks we want to handle hardware faults:
void (*RegisterHandler)(LPHANDLER, int) = GetProcAddress ("RegisterHandler");

// Register our interrupt handler. DivideHandler is the interrupt handler,
// ID_DIVIDE_BY_0 is a special name given in the HAL meaning
// divide by 0 interrupt handler (interrupt 0)
(*RegisterHandler) (DivideHandler, ID_DIVIDE_BY_0);

Code: Select all

int __cdecl DivideHandler (REGS* regs, int lparam, int rparam, int code) {

   // regs contains the register state at the time of the interrupt.
   // lparam and rparam contains extra data, if any.
   // code contains the error code. The HAL should have symbolic names
   // for the error codes.

   return HANDLER_CONTINUE;  // continue execution after handler
}