///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   halkdx86.cpp - Processor-specific support routines for halkd.cpp.
//
#include "hal.h"
#include "halkd.h"

#define KDDBG if (0) kdprintf

extern "C" void *  __cdecl memcpy(void *, const void *, size_t);

//////////////////////////////////////////////// User visible progress beacon.
//
static UINT16 KdpSpinBase = 0x2f00;
void KdpSpin()
{
    if (KdpSpinBase != 0) {
        static UINT8 state = 0;

        // Write the spinner to the screen.
        *((UINT16 *)0xb809e) = KdpSpinBase + ("+-|*" [state++ & 0x3]);
    }
}

///////////////////////////////////////// Debugger Unique Interrupts Routines.
//
//  NB: Without these, we share routines with the mainline code and we get
//  caught in a loop when the debugger inserts a break after the pushfd when
//  someone tries to single step through Processor:g_DisableInterrupts!
//
bool __declspec(naked) KdpDisableInterruptsInline()
{
    __asm {
        pushfd;
        pop eax;
        test eax, Struct_Microsoft_Singularity_Isal_IX_EFlags_IF;
        setnz al;
        nop;    // required so that the linker doesn't combine with g_Disable
        cli;
        ret;
    }
}

void __declspec(naked) KdpRestoreInterruptsInline(bool enabled)
{
    __asm {
        nop;
        test cl, cl;
        je done;
        nop;    // required so that the linker doesn't combine with g_Restore
        sti;
      done:
        ret;
    }
}

// Pause processor in deference to other hardware threads on the same core.
void __declspec(naked) KdpPause()
{
    __asm {
        pause;
        ret;
    }
}

// Flush instruction cache.
void __declspec(naked) KdpFlushInstCache()
{
    __asm {
        wbinvd;   // privileged instruction
        ret;
    }
}

// Break into the debugger.
void __declspec(naked) Class_Microsoft_Singularity_DebugStub::g_Break()
{
    __asm {
        int 3;
        ret;
    }
}

// Read a machine specific register (MSR on x86 & x64).
bool KdpReadMsr(UINT32 msr, UINT32 *plo, UINT32 *phi)
{
    UINT32 lo;
    UINT32 hi;

    __asm {
        mov ecx, msr;
        rdmsr;
        mov hi, edx;
        mov lo, eax;
    }

    *phi = hi;
    *plo = lo;

    return true;
}

// Write a machine specific register (MSR on x86 & x64).
bool KdpWriteMsr(UINT32 msr, UINT32 lo, UINT32 hi)
{
    __asm {
        mov ecx, msr;
        mov edx, hi;
        mov eax, lo;
        wrmsr;
    }
    return true;
}

//////////////////////////////////////////////////////////////////////////////
//
void KdpToKdContext(IN CONST Struct_Microsoft_Singularity_Isal_SpillContext *singularity,
                    OUT CONTEXT *windbg)
{
    windbg->ContextFlags = (CONTEXT_CONTROL |
                            CONTEXT_INTEGER |
                            CONTEXT_SEGMENTS |
                            CONTEXT_FLOATING_POINT |
                            CONTEXT_EXTENDED_REGISTERS);

    // CONTEXT_FULL;
    windbg->Eax = singularity->ax;
    windbg->Ebx = singularity->bx;
    windbg->Ecx = singularity->cx;
    windbg->Edx = singularity->dx;
    windbg->Esp = singularity->sp;
    windbg->Ebp = singularity->bp;
    windbg->Esi = singularity->si;
    windbg->Edi = singularity->di;
    windbg->Eip = singularity->ip;
    windbg->EFlags = singularity->fl;

    windbg->FloatSave.ControlWord = singularity->mmx.fcw;
    windbg->FloatSave.StatusWord = singularity->mmx.fsw;
    windbg->FloatSave.TagWord = singularity->mmx.ftw;
    windbg->FloatSave.ErrorOffset = singularity->mmx.ip;
    windbg->FloatSave.ErrorSelector = singularity->mmx.cs;
    windbg->FloatSave.DataOffset = singularity->mmx.dp;
    windbg->FloatSave.DataSelector = singularity->mmx.ds;

    memcpy(&windbg->FloatSave.St0, &singularity->mmx.st0, 10);
    memcpy(&windbg->FloatSave.St1, &singularity->mmx.st1, 10);
    memcpy(&windbg->FloatSave.St2, &singularity->mmx.st2, 10);
    memcpy(&windbg->FloatSave.St3, &singularity->mmx.st3, 10);
    memcpy(&windbg->FloatSave.St4, &singularity->mmx.st4, 10);
    memcpy(&windbg->FloatSave.St5, &singularity->mmx.st5, 10);
    memcpy(&windbg->FloatSave.St6, &singularity->mmx.st6, 10);
    memcpy(&windbg->FloatSave.St7, &singularity->mmx.st7, 10);

    memcpy(&windbg->ExtendedRegisters, &singularity->mmx, 512);

    // Segment registers other than cs don't change so they are live
    windbg->SegCs = singularity->cs;
    __asm {
        mov ebx, windbg;

        xor eax, eax;
        mov ax, gs;
        mov [ebx]CONTEXT.SegGs, eax;
        mov ax, fs;
        mov [ebx]CONTEXT.SegFs, eax;
        mov ax, es;
        mov [ebx]CONTEXT.SegEs, eax;
        mov ax, ds;
        mov [ebx]CONTEXT.SegDs, eax;
        mov ax, ss;
        mov [ebx]CONTEXT.SegSs, eax;
    }
}

void KdpFromKdContext(IN CONST CONTEXT *windbg,
                      OUT Struct_Microsoft_Singularity_Isal_SpillContext *singularity)
{
    singularity->ax = windbg->Eax;
    singularity->bx = windbg->Ebx;
    singularity->cx = windbg->Ecx;
    singularity->dx = windbg->Edx;
    singularity->sp = windbg->Esp;
    singularity->bp = windbg->Ebp;
    singularity->si = windbg->Esi;
    singularity->di = windbg->Edi;
    singularity->ip = windbg->Eip;
    singularity->fl = windbg->EFlags;

    // CONTEXT_FLOATING_POINT
    if (windbg->ContextFlags & CONTEXT_FLOATING_POINT) {
        singularity->mmx.fcw = windbg->FloatSave.ControlWord;
        singularity->mmx.fsw = windbg->FloatSave.StatusWord;
        singularity->mmx.ftw = windbg->FloatSave.TagWord;
        singularity->mmx.cs = windbg->FloatSave.ErrorSelector;
        singularity->mmx.ip = windbg->FloatSave.ErrorOffset;
        singularity->mmx.ds = windbg->FloatSave.DataSelector;
        singularity->mmx.dp = windbg->FloatSave.DataOffset;
        memcpy(&singularity->mmx.st0, &windbg->FloatSave.St0, 10);
        memcpy(&singularity->mmx.st1, &windbg->FloatSave.St1, 10);
        memcpy(&singularity->mmx.st2, &windbg->FloatSave.St2, 10);
        memcpy(&singularity->mmx.st3, &windbg->FloatSave.St3, 10);
        memcpy(&singularity->mmx.st4, &windbg->FloatSave.St4, 10);
        memcpy(&singularity->mmx.st5, &windbg->FloatSave.St5, 10);
        memcpy(&singularity->mmx.st6, &windbg->FloatSave.St6, 10);
        memcpy(&singularity->mmx.st7, &windbg->FloatSave.St7, 10);
    }

    // CONTEXT_EXTENDED_REGISTERS
    if (windbg->ContextFlags & CONTEXT_EXTENDED_REGISTERS) {
        memcpy(&singularity->mmx, &windbg->ExtendedRegisters, 512);
    }
}

void KdpSetControlReport(IN OUT PDBGKD_CONTROL_REPORT report,
                         IN CONST Struct_Microsoft_Singularity_Isal_SpillContext *x86Context)
    //  Routine Description:
    //      Fill in the Wait_State_Change message record.
    //
    //  Arguments:
    //      WaitStateChange - Supplies pointer to record to fill in
    //      x86Context - Supplies a pointer to a context record.
{
    UINT32 _dr6;
    UINT32 _dr7;
    UINT16 _cs;
    UINT16 _ds;
    UINT16 _es;
    UINT16 _fs;

    __asm {
        mov eax, dr6;
        mov _dr6, eax;
        mov eax, dr7;
        mov _dr7, eax;

        mov ax, cs;
        mov _cs, ax;
        mov ax, ds;
        mov _ds, ax;
        mov ax, es;
        mov _es, ax;
        mov ax, fs;
        mov _fs, ax;
    }

    report->Dr6 = _dr6;
    report->Dr7 = _dr7;
    report->SegCs  = _cs;
    report->SegDs  = _ds;
    report->SegEs  = _es;
    report->SegFs  = _fs;
    report->EFlags = x86Context->fl;
    report->ReportFlags = X86_REPORT_INCLUDES_SEGS;

#if !PAGING
    // Let the debugger know so that it doesn't have to retrieve the CS descriptor.
    report->ReportFlags |= X86_REPORT_STANDARD_CS;
#endif
}

void KdpSetControlSet(IN CONST DBGKD_CONTROL_SET * control,
                      IN OUT Struct_Microsoft_Singularity_Isal_SpillContext *x86Context)
{
    if (control->TraceFlag) {
        //KDDBG("KD: Warning - trace flag set prev efl=%x\n",x86Context->efl);
        x86Context->fl |= Struct_Microsoft_Singularity_Isal_IX_EFlags_TF;
    }
    else {
        //KDDBG("KD: turning off tracing in efl\n");
        x86Context->fl &= ~Struct_Microsoft_Singularity_Isal_IX_EFlags_TF;
    }

    UINT32 _dr7 = control->Dr7;

    __asm {
        mov eax, _dr7;
        mov dr7, eax
    }
}

//////////////////////////////////////////////////////////////////////////////

void KdpReadSpecialRegisters(KSPECIAL_REGISTERS *pksp,
                             IN CONST Struct_Microsoft_Singularity_Isal_SpillContext *x86Context)
{
    Struct_Microsoft_Singularity_Kd_X86Descriptor idtp;
    Struct_Microsoft_Singularity_Kd_X86Descriptor gdtp;

    __asm {
        mov ebx, pksp;

        sidt idtp.Limit;
        sgdt gdtp.Limit;

        mov eax, cr0;
        mov [ebx]KSPECIAL_REGISTERS.Cr0, eax;
        mov eax, cr2;
        mov [ebx]KSPECIAL_REGISTERS.Cr2, eax;
        mov eax, cr3;
        mov [ebx]KSPECIAL_REGISTERS.Cr3, eax;
        _emit 0x0f;  // mov eax,cr4
        _emit 0x20;
        _emit 0xe0;
        mov [ebx]KSPECIAL_REGISTERS.Cr4, eax;

        // Should we save segment regs as well?
        str ax;
        mov [ebx]KSPECIAL_REGISTERS.Tr, ax;
    }

    pksp->Idtr = idtp;
    pksp->Gdtr = gdtp;
}

void KdpWriteSpecialRegisters(CONST KSPECIAL_REGISTERS *pksp)
{
    __asm {
        mov ebx, pksp;

        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr0;
        mov dr0, eax;
        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr1;
        mov dr1, eax;
        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr2;
        mov dr2, eax;
        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr3;
        mov dr3, eax;
        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr6;
        mov dr6, eax;
        mov eax, [ebx]KSPECIAL_REGISTERS.KernelDr7;
        mov dr7, eax;
    }
}

//////////////////////////////////////////////////////////////////////////////

KdDebugTrapData * KdpIsDebugTrap(IN CONST Struct_Microsoft_Singularity_Isal_SpillContext *context,
                                 int id)
{
    if (id == Struct_Microsoft_Singularity_Isal_IX_EVectors_FirstChanceException) {
        return (KdDebugTrapData *)(context->ax);
    }
    return NULL;
}

// Convert a trap into a exception record.
void KdpConvertTrapToException(IN OUT EXCEPTION_RECORD64 *per,
                               IN OUT Struct_Microsoft_Singularity_Isal_SpillContext *context,
                               int id)
{
    // Breakpoints:
    switch (id) {

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_SingleStep:
            KDDBG("SingleStep\n");
            per->ExceptionCode = STATUS_SINGLE_STEP;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            // context->efl &= ~Struct_Microsoft_Singularity_Isal_IX_EFlags_TF;
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_Breakpoint:
            KDDBG("Breakpoint\n");
            context->ip -= 1;
            per->ExceptionCode = STATUS_BREAKPOINT;
            per->NumberParameters = 1;
            per->ExceptionInformation0 = BREAKPOINT_BREAK;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_IllegalInstruction:
            KDDBG("Illegal Instruction\n");
            per->ExceptionCode = STATUS_ILLEGAL_INSTRUCTION;
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_PageFault:
            KDDBG("KD: 0x0E %d\n", id);
            per->ExceptionCode = STATUS_ACCESS_VIOLATION;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            per->NumberParameters = 1;
            {
                UINT32 _cr2;
                __asm {
                    mov eax, cr2;
                    mov _cr2, eax;
                }
                per->ExceptionInformation0 = SIGN_EXTEND(_cr2);
            }
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_FirstChanceException: {
            KdDebugTrapData *trapData = (KdDebugTrapData *) (context->ax);
            switch (trapData->tag) {
                case KdDebugTrapData::FIRST_CHANCE_EXCEPTION:
                    context->ax = trapData->firstChanceException.throwAddr;
                    KDDBG("KD: First chance C# exception\n");
                    // per->ExceptionCode = STATUS_CPP_EH_EXCEPTION; //0xe06d7363;
                    per->ExceptionCode = STATUS_VCPP_EXCEPTION; //0x8000ff1f;
                    per->ExceptionAddress = SIGN_EXTEND(context->ip);
                    per->NumberParameters = 1;
                    per->ExceptionInformation0 = BREAKPOINT_BREAK;
                    break;
                default:
                    KDDBG("KD: Unexpected interrupt %d\n", id);
                    per->ExceptionCode = 0x80000000 + id;
                    per->ExceptionAddress = SIGN_EXTEND(context->ip);
                    break;
            }
            break;
        }

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_SecondChanceException:
            KDDBG("KD: Second chance C# exception\n");
            per->ExceptionCode = STATUS_VCPP_EXCEPTION;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_DebuggerBreakRequest:
            KDDBG("KD: Debugger ctrl-break\n");
            per->ExceptionCode = STATUS_BREAKPOINT;
            per->ExceptionInformation0 = BREAKPOINT_BREAK;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            break;

        case Struct_Microsoft_Singularity_Isal_IX_EVectors_Nmi:
            KDDBG("KD: NMI exception\n");
            per->ExceptionCode = STATUS_UNHANDLED_EXCEPTION;
            per->ExceptionInformation0 = BREAKPOINT_BREAK;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            break;

        default:
            KDDBG("KD: Unexpected interrupt %d\n", id);
            per->ExceptionCode = 0x80000000 + id;
            per->ExceptionAddress = SIGN_EXTEND(context->ip);
            break;

    }

    KDDBG("Trap: Context at %p\n", context);
    KDDBG("  CXT=%08x  THR=%08x\n",
          context,
          Class_Microsoft_Singularity_Processor::g_GetCurrentThreadContext()->_thread);
    KDDBG("  EIP=%08x  EFL=%08x\n",
          context->ip, context->fl);
    KDDBG("  EAX=%08x  EBX=%08x  ECX=%08x  EDX=%08x\n",
          context->ax, context->bx, context->cx, context->dx);
    KDDBG("  ESP=%08x  EBP=%08x  ESI=%08x  EDI=%08x\n",
          context->sp, context->bp, context->si, context->di);
}

//
// Read or Write I/O Space.
//
// Return:
//
// iowrite == 0: value read from port
//
// iowrite !=0:  zero
//
int KdpReadWriteIoSpace(
    int      size,    // 1, 2, 4
    int      iowrite, // true if write, false if read
    unsigned short addr,
    unsigned int   value
    )
{
    unsigned int retValue = 0;

    if (iowrite != 0) {
        // I/O Write's

        if (size == 1) {
            unsigned char byteValue = (unsigned char)value;
            __outbyte(addr, value);
        }
        else if (size == 2) {
            unsigned short wordValue = (unsigned short)value;
            __outword(addr, value);
        }
        else if (size == 4) {
            __outdword(addr, value);
        }
    }
    else {
        // I/O Read's

        if (size == 1) {
            retValue = __inbyte(addr);
        }
        else if (size == 2) {
            retValue = __inword(addr);
        }
        else if (size == 4) {
            retValue = __indword(addr);
        }
    }

    return retValue;
}