WebSVN – Kolibri OS – Diff – /programs/develop/mtdbg/mtdbg.asm


format binary
include '../../macros.inc'
use32
        db      'MENUET01'
        dd      1
        dd      start
        dd      i_end
        dd      used_mem
        dd      used_mem
        dd      i_param
        dd      0
 
;-----------------------------------------------------------------------------
 
REG_MODE_CPU equ 1
REG_MODE_MMX equ 2
REG_MODE_SSE equ 3
REG_MODE_AVX equ 4
 
;-----------------------------------------------------------------------------
 
include 'gui.inc' ; GUI routines
 
;-----------------------------------------------------------------------------
;                          Find command in list
 
find_cmd:
; all commands are case-insensitive
        push    edi
 
    .x4:
        mov     al, [edi]
        cmp     al, 0
        jz      .x5
        cmp     al, 'A'
        jb      @f
        cmp     al, 'Z'
        ja      @f
        or      al, 20h
 
    @@:
        stosb
        jmp     .x4
 
    ; find command
    .x5:
        pop     edi
 
    .x6:
        cmp     dword [esi], 0
        jz      .x7
        push    esi
        mov     esi, [esi]
        lodsb
        movzx   ecx, al
        push    edi
        repz cmpsb
        pop     edi
        pop     esi
        jz      .x8
        add     esi, 17
        jmp     .x6
 
    .x7:
        stc
 
    .x8:
        ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;-----------------------------------------------------------------------------
;                                 Help event
 
OnHelp:
        mov     esi, help_msg
        mov     edi, [curarg]
        cmp     byte [edi], 0
        jz      .x
        mov     esi, help_groups
        call    find_cmd
        jc      .nocmd
        mov     esi, [esi+12]
 
    .x:
        jmp     put_message
 
    .nocmd:
        mov     esi, aUnknownCommand
        jmp     .x
 
;-----------------------------------------------------------------------------
;                                Quit event
OnQuit:
        mcall  -1
 
;-----------------------------------------------------------------------------
;                        Working with debug context
 
get_new_context:
        mov     esi, context
        mov     edi, oldcontext
        mov     ecx, 10
        rep movsd
 
get_context:
        ;push    1
        ;pop     ebx
        ;push    69
        ;pop     eax
        ;mov     ecx, [debuggee_pid]
        ;mov     esi, context
        ;push    28h
        ;pop     edx
        mcall    69, 1, [debuggee_pid], 28h, context
        ret
 
set_context:
        ;push    2
        ;pop     ebx
        ;push    69
        ;pop     eax
        ;mov     ecx, [debuggee_pid]
        ;mov     esi, context
        ;push    28h
        ;pop     edx
        mcall    69, 2, [debuggee_pid], 28h, context
        ret
 
get_dump:
        mov     edi, dumpdata
        mov     esi, [edi-4]
        mov     edx, dump_height*10h
        mov     ecx, edx
        xor     eax, eax
        push    edi
        rep stosb
        pop     edi
        ;mov     ecx, [debuggee_pid]
        ;mov     al, 69
        ;push    6
        ;pop     ebx
        mcall    69, 6, [debuggee_pid]
        cmp     eax, -1
        jnz     @f
        mov     esi, read_mem_err
        call    put_message
        xor     eax, eax
 
    @@:
        mov     [edi-8], eax
;       call    restore_from_breaks
;       ret
 
; in: edi=buffer,eax=size,esi=address
restore_from_breaks:
        mov     ebx, breakpoints
 
    @@:
        test    byte [ebx+4], 1
        jz      .cont           ; ignore invalid
        test    byte [ebx+4], 2 or 8
        jnz     .cont           ; ignore disabled and memory breaks
        mov     ecx, [ebx]
        sub     ecx, esi
        cmp     ecx, eax
        jae     .cont
        mov     dl, [ebx+5]
        mov     [edi+ecx], dl
 
    .cont:
        add     ebx, 6
        cmp     ebx, breakpoints+breakpoints_n*6
        jb      @b
        ret
 
;-----------------------------------------------------------------------------
;                           Load executable event
 
OnLoad:
        mov     esi, [curarg]
 
OnLoadInit:
        mov     edi, loadname
        or      [prgname_len], -1
        mov     [prgname_ptr], edi
 
    .copyname:
        lodsb
        stosb
        inc     [prgname_len]
        cmp     al, '/'
        jnz     @f
        or      [prgname_len], -1
        mov     [prgname_ptr], edi
 
    @@:
        cmp     al, ' '
        ja      .copyname
        mov     byte [edi-1], 0
        and     [load_params], 0
        dec     esi
        call    get_arg.skip_spaces
        cmp     al, 0
        jz      @f
        mov     [load_params], esi
 
    @@:
        and     [dumppos], 0
        mov     ecx, [symbols]
        jecxz   do_reload
        mcall   68, 13
        and     [symbols], 0
        and     [num_symbols], 0
 
; TODO: make it local
do_reload:
        ;push    18
        ;pop     eax
        ;push    7
        ;pop     ebx
        mcall    18, 7
        mov     [dbgwnd], eax
        xchg    ecx, eax
        ;push    70
        ;pop     eax
        ;mov     ebx, fn70_load_block
        mcall    70, fn70_load_block
        test    eax, eax
        jns     .load_ok
 
    .load_err:
        push    eax
        mov     esi, load_err_msg
        call    put_message
        pop     eax
        not     eax
        cmp     eax, 0x20
        jae     .unk_err
        mov     esi, [load_err_msgs+eax*4]
        test    esi, esi
        jnz     put_message
 
    .unk_err:
        mov     esi, unk_err_msg
        inc     eax
        push    eax
        call    put_message_nodraw
        jmp     draw_messages
 
    .load_ok:
        mov     [debuggee_pid], eax
        mov     [bSuspended], 1
        push    ecx
        call    get_context
        mov     edi, oldcontext
        mov     ecx, 10
        rep movsd
 
    ; activate debugger window
        pop     ecx
        ;mov     bl, 3
        ;push    18
        ;pop     eax
        mcall    18, 3
        call    redraw_title
        call    draw_registers.redraw
    ; read and draw dump of memory
        call    get_dump
        call    draw_dump.redraw
        call    update_disasm_eip_force
        mov     esi, load_succ_msg
        push    [debuggee_pid]
        call    put_message_nodraw
        call    draw_messages
    ; try to load symbols
        mov     esi, loadname
        mov     edi, symbolsfile
        push    edi
 
    @@:
        lodsb
        stosb
        test    al, al
        jnz     @b
        lea     ecx, [edi-1]
 
    @@:
        dec     edi
        cmp     edi, symbolsfile
        jb      @f
        cmp     byte [edi], '/'
        jz      @f
        cmp     byte [edi], '.'
        jnz     @b
        mov     ecx, edi
 
    @@:
        mov     dword [ecx], '.dbg'
        mov     byte [ecx+4], 0
        pop     esi
        mov     ebp, esi
        call    OnLoadSymbols.silent
    
    ; now test for packed progs
        cmp     [disasm_buf_size], 100h
        jz      @f
        ret
 
    @@:
        mov     esi, mxp_nrv_sig
        mov     ebp, disasm_buffer
        mov     edi, ebp
        push    3
        pop     ecx
        repz cmpsb
        jnz     .not_mxp_nrv
        cmpsb
        mov     cl, mxp_nrv_sig_size-4
        repz cmpsb
        mov     esi, mxp_nrv_name
        jz      .packed
 
    .not_mxp_nrv:
        mov     esi, mxp_sig
        mov     edi, ebp
        mov     cl, mxp_sig_size
        repz cmpsb
        mov     esi, mxp_name
        jz      .packed
 
    .not_mxp:
        mov     esi, mxp_lzo_sig1
        mov     edi, ebp
        mov     cl, mxp_lzo_sig1_size
        repz cmpsb
        mov     esi, mxp_lzo_name
        jz      .packed
        mov     esi, mxp_lzo_sig2
        mov     edi, ebp
        mov     cl, 8
        repz cmpsb
        jnz     .not_mxp_lzo
        cmpsb
        mov     cl, mxp_lzo_sig2_size - 9
        repz cmpsb
        mov     esi, mxp_lzo_name
        jz      .packed
 
    .not_mxp_lzo:
        mov     esi, mtappack_name
        cmp     dword [ebp], 0xBF5E246A
        jnz     .not_mtappack
        cmp     dword [ebp+8], 0xEC4E8B57
        jnz     .not_mtappack1
        cmp     dword [ebp+12], 0x8D5EA4F3
        jnz     .not_mtappack1
        cmp     byte [ebp+12h], 0xE9
        jz      .packed
 
    .not_mtappack1:
        cmp     word [ebp+8], 0xB957
        jnz     .not_mtappack
        cmp     dword [ebp+14], 0x575EA4F3
        jnz     .not_mtappack2
        cmp     byte [ebp+17h], 0xE9
        jz      .packed
 
    .not_mtappack2:
        cmp     dword [ebp+14], 0x5F8DA4F3
        jnz     .not_mtappack3
        cmp     word [ebp+18], 0xE9FC
        jz      .packed
 
    .not_mtappack3:
        cmp     word [ebp+14], 0xA4F3
        jnz     .not_mtappack
        cmp     byte [ebp+15h], 0xE9
        jz      .packed
 
    .not_mtappack:
        ret
 
    .packed:
        push    esi
        mov     esi, aPacked1
        call    put_message_nodraw
        pop     esi
        call    put_message_nodraw
        mov     esi, aPacked2
        call    put_message
        call    hide_cursor
        ;push    40
        ;pop     eax
        ;push    7
        ;pop     ebx
        mcall    40, 7
 
    .wait:
        ;push    10
        ;pop     eax
        mcall    10
        dec     eax
        jz      .redraw
        dec     eax
        jz      .key
        or      eax, -1
        mcall
 
    .redraw:
        call    draw_window
        call    hide_cursor
        jmp     .wait
 
    .key:
        mov     al, 2
        mcall
        cmp     ah, 'y'
        jz      .yes
        cmp     ah, 'Y'
        jz      .yes
        cmp     ah, 0xD
        jz      .yes
        cmp     ah, 'n'
        jz      .no
        cmp     ah, 'N'
        jnz     .wait
 
    .no:
        ;push    40
        ;pop     eax
        ;mov     ebx, 0x107
        mcall    40, 0x107
        call    draw_cursor
        mov     esi, aN_str
        jmp     put_message
 
    .yes:
        ;push    40
        ;pop     eax
        ;mov     ebx, 0x107
        mcall    40, 0x107
        call    draw_cursor
        mov     esi, aY_str
        call    put_message
        call    OnUnpack
        ret
 
;-----------------------------------------------------------------------------
;                       Searching signatures
 
mxp_nrv_sig:
        xor     eax, eax
        mov     ecx, 0x95       ; 0xA1 for programs with parameters
        mov     [eax], ecx
        add     ecx, [eax+24h]
        push    40h
        pop     esi
        mov     edi, [eax+20h]
        push    edi
        rep movsb
        jmp     dword [esp]
        pop     esi
        add     esi, [eax]
        xor     edi, edi
 
mxp_nrv_sig_size = $ - mxp_nrv_sig
 
mxp_sig:
        mov     ecx, 1CBh
        push    46h
        pop     esi
        mov     edi, [20h]
        rep movsb
        mov     ecx, [24h]
        rep movsb
        jmp     dword [20h]
        mov     eax, [20h]
        add     eax, 1CBh
        push    eax
        push    dword [24h]
        push    0
        push    8
        call    $+0x25
 
mxp_sig_size = $ - mxp_sig
 
mxp_lzo_sig1:
        xor     eax, eax
        mov     ebp, 0FFh
        mov     ecx, 175h
        mov     [eax], ecx
        add     ecx, [eax+24h]
        push    45h
        pop     esi
        mov     edi, [eax+20h]
        push    edi
        rep movsb
        jmp     dword [esp]
        pop     ebx
        add     ebx, [eax]
        xor     edi, edi
        cmp     byte [ebx], 11h
        jbe     $+0x1A
 
mxp_lzo_sig1_size = $ - mxp_lzo_sig1
 
mxp_lzo_sig2:
        xor     eax, eax
        mov     ebp, 0FFh
        mov     ecx, 188h       ; or 177h
        mov     [eax], ecx
        add     ecx, [eax+24h]
        push    44h
        pop     esi
        mov     edi, [eax+20h]
        rep movsb
        jmp     dword [eax+20h]
        mov     ebx, [eax+20h]
        add     ebx, [eax]
 
mxp_lzo_sig2_size = $ - mxp_lzo_sig2
 
;-----------------------------------------------------------------------------
;                         Reload executable event
 
OnReload:
        cmp     [debuggee_pid], 0
        jnz     terminate_reload
        mov     esi, need_debuggee
        cmp     byte [loadname], 0
        jnz     do_reload
        jz      put_message
 
; TODO: make it local
terminate_reload:
        mov     [bReload], 1
 
;-----------------------------------------------------------------------------
;                        Terminate process event
 
OnTerminate:
        ;mov     ecx, [debuggee_pid]
        ;push    8
        ;pop     ebx
        ;push    69
        ;pop     eax
        mcall    69, 8, [debuggee_pid]
        ret
;-----------------------------------------------------------------------------
;                         Suspend process event
 
AfterSuspend:
        mov     [bSuspended], 1
        call    get_new_context
        call    get_dump
        call    redraw_title
        call    draw_registers.redraw
        call    draw_dump.redraw
        call    update_disasm_eip
        ret
 
OnSuspend:
        ;mov     ecx, [debuggee_pid]
        ;push    4
        ;pop     ebx
        ;push    69
        ;pop     eax
        mcall    69, 4, [debuggee_pid]
        call    AfterSuspend
        mov     esi, aSuspended
        jmp     put_message
 
;-----------------------------------------------------------------------------
;                        Resume process event
 
DoResume:
        ;mov     ecx, [debuggee_pid]
        ;push    5
        ;pop     ebx
        ;push    69
        ;pop     eax
        mcall    69, 5, [debuggee_pid]
        mov     [bSuspended], 0
        ret
 
OnResume:
        mov     esi, [curarg]
        cmp     byte [esi], 0
        jz      GoOn
        call    calc_expression
        jc      .ret
        mov     eax, ebp
        push    eax
        call    find_enabled_breakpoint
        pop     eax
        jz      GoOn
        mov     bl, 5   ; valid enabled one-shot
        call    add_breakpoint
        jnc     GoOn
        mov     esi, aBreakpointLimitExceeded
        call    put_message
 
    .ret:
        ret
 
GoOn:
    ; test for enabled breakpoint at eip
        mov     eax, [_eip]
        call    find_enabled_breakpoint
        jnz     .nobreak
    ; temporarily disable breakpoint, make step, enable breakpoint, continue
        inc     eax
        mov     [temp_break], eax
        mov     [bAfterGo], 1
        dec     eax
        call    disable_breakpoint
        call    get_context
        or      byte [_eflags+1], 1             ; set TF
        call    set_context
        and     byte [_eflags+1], not 1
        call    DoResume
        ret
 
    .nobreak:
        call    DoResume
        call    redraw_title
        call    draw_registers.redraw
        call    draw_dump.redraw
        ret
 
;-----------------------------------------------------------------------------
;                        Detach process event
 
OnDetach:
        ;mov     ecx, [debuggee_pid]
        ;push    3
        ;pop     ebx
        ;push    69
        ;pop     eax
        mcall    69, 3, [debuggee_pid]
        and     [debuggee_pid], 0
        call    redraw_title
        call    draw_registers.redraw
        call    draw_dump.redraw
        call    free_symbols
        mov     esi, aContinued
        jmp     put_message
 
after_go_exception:
        push    eax
        mov     eax, [temp_break]
        dec     eax
        push    esi
        call    enable_breakpoint
    ; in any case, clear TF and RF
        call    get_new_context
        and     [_eflags], not 10100h           ; clear TF,RF
        call    set_context
        xor     edx, edx
        mov     [temp_break], edx
        xchg    dl, [bAfterGo]
        pop     esi
        pop     eax
        cmp     dl, 2
        jnz     @f
        lodsd
        push    esi
        call    get_dump
        jmp     exception.done
 
    @@:
        test    eax, eax
        jz      .notint1
    ; if exception is result of single step, simply ignore it and continue
        test    dword [esi], 0xF
        jnz     dbgmsgstart.5
        lodsd
        push    esi
        mov     esi, oldcontext
        mov     edi, context
        mov     ecx, 28h/4
        rep movsd
        call    DoResume
        jmp     dbgmsgend
 
    .notint1:
    ; in other case, work as without temp_break
        lodsd
        push    esi
        push    eax
        jmp     exception.4
 
    .notour:
 
; TODO: split it out
debugmsg:
        neg     [dbgbufsize]
        mov     esi, dbgbuf
 
; TODO: make it local
dbgmsgstart:
        lodsd
;       push    eax esi
;       push    dword [esi]
;       mov     esi, dbgmsg_str
;       call    put_message_nodraw
;       pop     esi eax
        add     esi, 4
        dec     eax
        jz      exception
        dec     eax
        jz      terminated
        mov     [bSuspended], 1
        cmp     [bAfterGo], 0
        jnz     after_go_exception
        push    esi
        call    get_new_context
        and     [_eflags], not 10100h           ; clear TF,RF
        call    set_context
        pop     esi
 
    ; TODO: WTF? Need for meaning label names
    .5:
        push    esi
        call    get_dump
        pop     esi
        lodsd
        xor     ecx, ecx
 
    .6:
        bt      eax, ecx
        jnc     .7
        mov     ebx, [drx_break+ecx*4]
        test    ebx, ebx
        jz      .7
        pushad
        dec     ebx
        push    ebx
        mov     esi, aBreakStop
        call    put_message_nodraw
        popad
 
    .7:
        inc     ecx
        cmp     cl, 4
        jb      .6
        push    esi
        jmp     exception.done_draw
 
; TODO: make it local
terminated:
        push    esi
        mov     esi, terminated_msg
        call    put_message
        and     [debuggee_pid], 0
        and     [temp_break], 0
        mov     [bAfterGo], 0
        xor     eax, eax
        mov     ecx, breakpoints_n*6/4+4
        mov     edi, breakpoints
        rep stosd
        cmp     [bReload], 1
        sbb     [bReload], -1
        jnz     exception.done
        call    free_symbols
        jmp     exception.done
 
exception:
        mov     [bSuspended], 1
        cmp     [bAfterGo], 0
        jnz     after_go_exception
        lodsd
        push    esi
        push    eax
        call    get_new_context
        and     [_eflags], not 10100h           ; clear TF,RF
        call    set_context
 
    ; TODO: fix for useful name
    .4:
        call    get_dump
        pop     eax
    ; int3 command generates exception 0D, #GP
        push    eax
        cmp     al, 0Dh
        jnz     .notdbg
    ; check for 0xCC byte at eip
        push    0
        ;push    69
        ;pop     eax
        ;push    6
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        ;mov     edi, esp
        ;mov     esi, [_eip]
        ;push    1
        ;pop     edx
        mcall    69, 6, [debuggee_pid], 1, [_eip], esp
        pop     eax
        cmp     al, 0xCC
        jnz     .notdbg
    ; this is either dbg breakpoint or int3 cmd in debuggee
        mov     eax, [_eip]
        call    find_enabled_breakpoint
        jnz     .user_int3
    ; dbg breakpoint; clear if one-shot
        pop     ecx
        push    eax
        mov     esi, aBreakStop
        test    byte [edi+4], 4
        jz      .put_msg_eax
        pop     ecx
        call    clear_breakpoint
        jmp     .done
 
    .user_int3:
        mov     eax, [_eip]
        inc     [_eip]
        pop     ecx
        push    eax
        call    set_context
        mov     esi, aUserBreak
        jmp     .put_msg_eax
 
    .notdbg:
        mov     esi, aException
 
    .put_msg_eax:
        call    put_message_nodraw
 
    .done_draw:
        call    draw_messages
 
    .done:
        ;push    18
        ;pop     eax
        ;push    3
        ;pop     ebx
        ;mov     ecx, [dbgwnd]
        mcall    18, 3, [dbgwnd]    ; activate dbg window
        call    redraw_title
        call    draw_registers.redraw
        call    draw_dump.redraw
        call    update_disasm_eip
 
dbgmsgend:
        pop     esi
        mov     ecx, [dbgbuflen]
        add     ecx, dbgbuf
        cmp     esi, ecx
        jnz     dbgmsgstart
        and     [dbgbuflen], 0
        neg     [dbgbufsize]
        cmp     [bReload], 2
        jnz     @f
        mov     [bReload], 0
        call    do_reload
 
    @@:
        jmp     waitevent
 
; TODO: make it local
CtrlF7:
        cmp     [debuggee_pid], 0
        jz      .no
        call    OnStep
 
    .no:
        jmp     waitevent
 
; TODO: make it local
CtrlF8:
        cmp     [debuggee_pid], 0
        jz      CtrlF7.no
        call    OnProceed
        jmp     CtrlF7.no
 
;-----------------------------------------------------------------------------
;                       Step execution event
 
;Here we get [] argument at do step  times
OnStep:
        cmp     [bSuspended], 0
        jz      .running
        cmp     [step_num], 0
        jg      .stepone
        mov     esi, [curarg]
        cmp     esi, 0
        jz	    .stepone
        cmp     byte [esi], 0
        jz      .stepone
        call    get_hex_number
        jc      .ret
        cmp     eax, 0 ; check if lesser or equal than 0
        jle     .ret
        mov     [step_num], eax
        mov     [curarg], 0
 
    .stepone:
        call    get_context
        or      byte [_eflags+1], 1             ; set TF
        call    set_context
        and     byte [_eflags+1], not 1
    ; if instruction at eip is "int xx", set one-shot breakpoint immediately after
        mov     eax, [_eip]
        call    find_enabled_breakpoint
        jnz     @f
        cmp     byte [edi+5], 0xCD
        jz      .int
 
     @@:
        push    0
        ;push    69
        ;pop     eax
        ;push    6
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        ;push    3
        ;pop     edx
        ;mov     edi, esp
        ;mov     esi, [_eip]
        mcall    69, 6, [debuggee_pid], 3, [_eip], esp
        cmp     eax, edx
        pop     eax
        jnz     .doit
        cmp     al, 0xCD
        jz      .int
        cmp     ax, 0x050F
        jz      .syscall
        cmp     ax, 0x340F
        jz      .sysenter
 
    ; resume process
    .doit:
        call    GoOn
        cmp     [bAfterGo], 0
        jz      @f
        mov     [bAfterGo], 2
 
    @@:
        mov     eax, [step_num]
        dec     eax
        cmp     eax, 0
        jle     .ret
        mov     [step_num], eax
        jmp     .stepone
 
    .ret:
        mov     [step_num], 0
        ret
 
    ; return address is [ebp-4]
    .sysenter:
        push    0
        ;push    69
        ;pop     eax
        inc     edx     ; read 4 bytes
        mov     esi, [_ebp]
        sub     esi, 4
        mcall    69
        cmp     eax, edx
        pop     eax
        jnz     .syscall
        push    eax
        and     byte [_eflags+1], not 1
        call    set_context
        pop     eax
        jmp     @f
 
    .syscall:
        and     byte [_eflags+1], not 1 ; clear TF - avoid system halt (!)
        call    set_context
 
    .int:
        mov     eax, [_eip]
        inc     eax
        inc     eax
 
    @@:
        push    eax
        call    find_enabled_breakpoint
        pop     eax
        jz      .doit
    ; there is no enabled breakpoint yet; set temporary breakpoint
        mov     bl, 5
        call    add_breakpoint
        jmp     .doit
 
    .running:
        mov     esi, aRunningErr
        jmp     put_message
 
;-----------------------------------------------------------------------------
;                       Proceed process event
 
OnProceed:
        cmp     [bSuspended], 0
        jz      OnStep.running
        cmp     [proc_num], 0
        jg      .procone
        mov     esi, [curarg]
        cmp     esi, 0
        jz      .procone
        cmp     byte [esi], 0
        jz      .procone
        call    get_hex_number
        jc      .ret
        cmp     eax, 0 ; check if lesser than 0
        jle     .ret
        mov     [proc_num], eax
        mov     [curarg], 0
 
    .procone:
        mov     esi, [_eip]
 
    @@:
        call    get_byte_nobreak
        jc      OnStep.stepone
        inc     esi
    ; skip prefixes
        call    is_prefix
        jz      @b
        cmp     al, 0xE8        ; call
        jnz     @f
        add     esi, 4
        jmp     .doit
 
    ; A4,A5 = movs; A6,A7 = cmps
    @@:
        cmp     al, 0xA4
        jb      @f
        cmp     al, 0xA8
        jb      .doit
 
    ; AA,AB = stos; AC,AD = lods; AE,AF = scas
    @@:
        cmp     al, 0xAA
        jb      @f
        cmp     al, 0xB0
        jb      .doit
 
    ; E0 = loopnz; E1 = loopz; E2 = loop
    @@:
        cmp     al, 0xE0
        jb      .noloop
        cmp     al, 0xE2
        ja      .noloop
        inc     esi
        jmp     .doit
 
    ; FF /2 = call
    .noloop:
        cmp     al, 0xFF
        jnz     OnStep.stepone
        call    get_byte_nobreak
        jc      OnStep.stepone
        inc     esi
        mov     cl, al
        and     al, 00111000b
        cmp     al, 00010000b
        jnz     OnStep.stepone
    ; skip instruction
        mov     al, cl
        and     eax, 7
        shr     cl, 6
        jz      .mod0
        jp      .doit
        cmp     al, 4
        jnz     @f
        inc     esi
 
    @@:
        inc     esi
        dec     cl
        jz      @f
        add     esi, 3
 
    @@:
        jmp     .doit
 
    .mod0:
        cmp     al, 4
        jnz     @f
        call    get_byte_nobreak
        jc      OnStep.stepone
        inc     esi
        and     al, 7
 
    @@:
        cmp     al, 5
        jnz     .doit
        add     esi, 4
 
    .doit:
    ; insert one-shot breakpoint at esi and resume
        call    get_byte_nobreak
        jc      OnStep.stepone
        mov     eax, esi
        call    find_enabled_breakpoint
        jz      @f
        mov     eax, esi
        mov     bl, 5
        call    add_breakpoint
        jmp     OnStep.doit
 
    @@:
        mov     eax, [proc_num]
        dec     eax
        cmp     eax, 0
        jle     .ret
        mov     [proc_num], eax
        jmp     .procone
 
    .ret:
        mov     [proc_num], 0
        ret
 
;-----------------------------------------------------------------------------
;                        Read next byte of machine code
 
get_byte_nobreak:
        mov     eax, esi
        call    find_enabled_breakpoint
        jnz     .nobreak
        mov     al, [edi+5]
        clc
        ret
    
    .nobreak:
        ;push    69
        ;pop     eax
        ;push    6
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        xor     edx, edx
        push    edx
        inc     edx
        mov     edi, esp
        mcall    69, 6, [debuggee_pid]
        dec     eax
        clc
        jz      @f
        stc
    
    @@:
        pop     eax
        ret
 
include 'parser.inc'
 
;-----------------------------------------------------------------------------
;                        Calculate expression event
 
OnCalc:
        mov     esi, [curarg]
        call    calc_expression
        jc      .ret
        push    ebp
        mov     esi, calc_string
        call    put_message_nodraw
        jmp     draw_messages
    
    .ret:
        ret
 
;-----------------------------------------------------------------------------
;                            Dump memory event
 
OnDump:
        mov     esi, [curarg]
        cmp     byte [esi], 0
        jnz     .param
        add     [dumppos], dump_height*10h
        jmp     .doit
    
    .param:
        call    calc_expression
        jc      .ret
        mov     [dumppos], ebp
 
    .doit:
        call    get_dump
        call    draw_dump.redraw
 
    .ret:
        ret
 
;-----------------------------------------------------------------------------
;                   Dissassemble block of executable event
 
OnUnassemble:
        mov     esi, [curarg]
        cmp     byte [esi], 0
        jnz     .param
        mov     eax, [disasm_start_pos]
        mov     ecx, disasm_height
        mov     [disasm_cur_pos], eax
 
    .l:
        mov     eax, [disasm_cur_pos]
        call    find_symbol
        jc      @f
        dec     ecx
        jz      .m
 
    @@:
        push    ecx
        call    disasm_instr
        pop     ecx
        jc      .err
        loop    .l
 
    .m:
        mov     eax, [disasm_cur_pos]
        jmp     .doit
 
    .param:
        call    calc_expression
        jc      .ret
        mov     eax, ebp
 
    .doit:
        push    eax
        push    [disasm_start_pos]
        mov     [disasm_start_pos], eax
        call    update_disasm
        pop     [disasm_start_pos]
        pop     eax
        cmp     [disasm_cur_str], 0
        jz      @f
        mov     [disasm_start_pos], eax
 
    .ret:
        ret
 
    @@:
        call    update_disasm
 
    .err:
        mov     esi, aInvAddr
        jmp     put_message
 
;-----------------------------------------------------------------------------
;                       Access to register value event
 
OnReg:
        mov     esi, [curarg]
        call    get_arg.skip_spaces
        call    find_reg
        jnc     @f
 
    .err:
        mov     esi, RSyntax
        jmp     put_message
 
    @@:
        call    get_arg.skip_spaces
        test    al, al
        jz      .err
        cmp     al, '='
        jnz     @f
        inc     esi
        call    get_arg.skip_spaces
        test    al, al
        jz      .err
 
    @@:
        push    edi
        call    calc_expression
        pop     edi
        jc      .ret
    ; now edi=register id, ebp=value
        cmp     [bSuspended], 0
        mov     esi, aRunningErr
        jz      put_message
        xchg    eax, ebp
        cmp     edi, 24
        jz      .eip
        sub     edi, 4
        jb      .8lo
        sub     edi, 4
        jb      .8hi
        sub     edi, 8
        jb      .16
        mov     [_eax+edi*4], eax
        jmp     .ret
 
    .16:
        mov     word [_eax+(edi+8)*4], ax
        jmp     .ret
 
    .8lo:
        mov     byte [_eax+(edi+4)*4], al
        jmp     .ret
 
    .8hi:
        mov     byte [_eax+(edi+4)*4+1], al
        jmp     .ret
 
    .eip:
        mov     [_eip], eax
        call    update_disasm_eip
 
    .ret:
        call    set_context
        jmp     draw_registers.redraw
 
;-----------------------------------------------------------------------------
;                        Breakpoints manipulation
OnBp:
        mov     esi, [curarg]
        call    calc_expression
        jc      .ret
        xchg    eax, ebp
        push    eax
        call    find_breakpoint
        inc     eax
        pop     eax
        jz      .notfound
        mov     esi, aDuplicateBreakpoint
        jmp     .sayerr
 
    .notfound:
        mov     bl, 1
        call    add_breakpoint
        jnc     .ret
        mov     esi, aBreakpointLimitExceeded
 
    .sayerr:
        call    put_message
 
    .ret:
        jmp     draw_disasm.redraw
 
OnBpmb:
        mov     dh, 0011b
        jmp     DoBpm
 
OnBpmw:
        mov     dh, 0111b
        jmp     DoBpm
 
OnBpmd:
        mov     dh, 1111b
 
DoBpm:
        mov     esi, [curarg]
        cmp     byte [esi], 'w'
        jnz     @f
        and     dh, not 2
        inc     esi
 
    @@:
        push    edx
        call    calc_expression
        pop     edx
        jnc     @f
        ret
 
    ; ebp = expression, dh = flags
    @@:
        movzx   eax, dh
        shr     eax, 2
        test    ebp, eax
        jz      @f
        mov     esi, aUnaligned
        jmp     put_message
 
    @@:
        mov     eax, ebp
        mov     bl, 0Bh
        call    add_breakpoint
        jnc     @f
        mov     esi, aBreakpointLimitExceeded
        jmp     put_message
 
    ; now find index
    @@:
        push    eax
        xor     ecx, ecx
 
    .l1:
        cmp     [drx_break+ecx*4], 0
        jnz     .l2
        ;push    69
        ;pop     eax
        push    ecx
        mov     dl, cl
        ;mov     ecx, [debuggee_pid]
        mov     esi, ebp
        ;push    9
        ;pop     ebx
        mcall    69, 9, [debuggee_pid]
        test    eax, eax
        jz      .ok
        pop     ecx
 
    .l2:
        inc     ecx
        cmp     ecx, 4
        jb      .l1
        pop     eax
        call    clear_breakpoint
        mov     esi, aBreakpointLimitExceeded
        jmp     put_message
 
    .ok:
        pop     ecx
        pop     eax
        and     byte [edi], not 2       ; breakpoint is enabled
        shl     dl, 6
        or      dl, dh
        mov     byte [edi+1], dl
        inc     eax
        mov     [drx_break+ecx*4], eax
        ret
 
OnBc:
        mov     esi, [curarg]
 
    @@:
        call    get_hex_number
        jc      OnBp.ret
        call    clear_breakpoint
        jmp     @b
 
OnBd:
        mov     esi, [curarg]
 
    @@:
        call    get_hex_number
        jc      OnBp.ret
        call    disable_breakpoint
        jmp     @b
 
OnBe:
        mov     esi, [curarg]
 
    @@:
        call    get_hex_number
        jc      OnBp.ret
        push    eax
        call    find_enabled_breakpoint
        pop     eax
        jz      .err
        call    enable_breakpoint
        jmp     @b
 
    .err:
        mov     esi, OnBeErrMsg
        jmp     put_message
 
; TODO: split it out in parser.inc
get_hex_number:
        call    get_arg.skip_spaces
        xor     ecx, ecx
        xor     edx, edx
 
    @@:
        lodsb
        call    is_hex_digit
        jc      .ret
        shl     edx, 4
        or      dl, al
        inc     ecx
        jmp     @b
 
    .ret:
        dec     esi
        cmp     ecx, 1
        xchg    eax, edx
        ret
 
;-----------------------------------------------------------------------------
;                       Breakpoints list event
 
OnBl:
        mov     esi, [curarg]
        cmp     byte [esi], 0
        jz      .listall
        call    get_hex_number
        jc      .ret
        cmp     eax, breakpoints_n
        jae     .err
        push    eax
        add     eax, eax
        lea     edi, [breakpoints + eax + eax*2]
        pop     eax
        test    byte [edi+4], 1
        jz      .err
        call    show_break_info
 
    .ret:
        ret
 
    .err:
        mov     esi, aInvalidBreak
        jmp     put_message
 
    .listall:
        mov     edi, breakpoints
        xor     eax, eax
 
    @@:
        test    byte [edi+4], 1
        jz      .cont
        push    edi eax
        call    show_break_info
        pop     eax edi
 
    .cont:
        add     edi, 6
        inc     eax
        cmp     eax, breakpoints_n
        jb      @b
        ret
 
;-----------------------------------------------------------------------------
                              
show_break_info:
        push    edi
        test    byte [edi+4], 8
        jnz     .dr
        push    dword [edi]
        push    eax
        mov     esi, aBreakNum
        call    put_message_nodraw
        jmp     .cmn
 
    .dr:
        push    eax
        mov     esi, aMemBreak1
        call    put_message_nodraw
        pop     edi
        push    edi
        mov     esi, aMemBreak2
        test    byte [edi+5], 2
        jz      @f
        mov     esi, aMemBreak3
 
    @@:
        call    put_message_nodraw
        pop     edi
        push    edi
        mov     esi, aMemBreak6
        test    byte [edi+5], 8
        jnz     @f
        mov     esi, aMemBreak5
        test    byte [edi+5], 4
        jnz     @f
        mov     esi, aMemBreak4
 
    @@:
        call    put_message_nodraw
        pop     edi
        push    edi
        push    dword [edi]
        mov     esi, aMemBreak7
        call    put_message_nodraw
 
    .cmn:
        pop     edi
        test    byte [edi+4], 2
        jz      @f
        push    edi
        mov     esi, aDisabled
        call    put_message_nodraw
        pop     edi
 
    @@:
        test    byte [edi+4], 4
        jz      @f
        mov     esi, aOneShot
        call    put_message_nodraw
 
    @@:
        mov     esi, newline
        jmp     put_message
 
;-----------------------------------------------------------------------------
;                        Add breakpoint
; in: EAX = address; BL = flags
; out: CF = 1 => error
;      CF = 0 and EAX = breakpoint number
 
add_breakpoint:
        xor     ecx, ecx
        mov     edi, breakpoints
 
    @@:
        test    byte [edi+4], 1
        jz      .found
        add     edi, 6
        inc     ecx
        cmp     ecx, breakpoints_n
        jb      @b
        stc
        ret
 
    .found:
        stosd
        xchg    eax, ecx
        mov     [edi], bl
        test    bl, 2
        jnz     @f
        or      byte [edi], 2
        push    eax
        call    enable_breakpoint
        pop     eax
 
    @@:
        clc
        ret
 
;-----------------------------------------------------------------------------
;                         Remove breakpoint
 
clear_breakpoint:
        cmp     eax, breakpoints_n
        jae     .ret
        mov     ecx, 4
        inc     eax
 
    .1:
        cmp     [drx_break-4+ecx*4], eax
        jnz     @f
        and     [drx_break-4+ecx*4], 0
 
    @@:
        loop    .1
        dec     eax
        push    eax
        add     eax, eax
        lea     edi, [breakpoints + eax + eax*2 + 4]
        test    byte [edi], 1
        pop     eax
        jz      .ret
        push    edi
        call    disable_breakpoint
        pop     edi
        mov     byte [edi], 0
 
    .ret:
        ret
 
;-----------------------------------------------------------------------------
;                          Disable breakpoint
 
disable_breakpoint:
        cmp     eax, breakpoints_n
        jae     .ret
        add     eax, eax
        lea     edi, [breakpoints + eax + eax*2 + 5]
        test    byte [edi-1], 1
        jz      .ret
        test    byte [edi-1], 2
        jnz     .ret
        or      byte [edi-1], 2
        test    byte [edi-1], 8
        jnz     .dr
        push    esi
        ;push    7
        ;pop     ebx
        ;push    69
        ;pop     eax
        ;mov     ecx, [debuggee_pid]
        ;xor     edx, edx
        ;inc     edx
        ;mov     esi, [edi-5]
        mcall    69, 7, [debuggee_pid], 1, [edi-5]
        pop     esi
 
    .ret:
        ret
 
    .dr:
        mov     dl, [edi]
        shr     dl, 6
        mov     dh, 80h
        ;push    69
        ;pop     eax
        ;push    9
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        mcall    69, 9, [debuggee_pid]
        ret
 
;-----------------------------------------------------------------------------
;                           Enable breakpoint
 
enable_breakpoint:
        push    esi
        cmp     eax, breakpoints_n
        jae     .ret
        add     eax, eax
        lea     edi, [breakpoints + eax + eax*2 + 5]
        test    byte [edi-1], 1
        jz      .ret
        test    byte [edi-1], 2
        jz      .ret
        and     byte [edi-1], not 2
        test    byte [edi-1], 8
        jnz     .dr
        ;push    6
        ;pop     ebx
        ;push    69
        ;pop     eax
        ;mov     esi, [edi-5]
        ;mov     ecx, [debuggee_pid]
        ;xor     edx, edx
        ;inc     edx
        mcall    69, 6, [debuggee_pid], 1, [edi-5]
        dec     eax
        jnz     .err
        ;mov     al, 69
        push    0xCC
        mov     edi, esp
        inc     ebx
        mcall    69
        pop     eax
 
    .ret:
        pop     esi
        ret
 
    .err:
        or      byte [edi-1], 2
        mov     esi, aBreakErr
        call    put_message
        pop     esi
        ret
 
    .dr:
        ;push    9
        ;pop     ebx
        ;push    69
        ;pop     eax
        mov     esi, [edi-5]
        ;mov     ecx, [debuggee_pid]
        mov     dl, [edi]
        shr     dl, 6
        mov     dh, [edi]
        and     dh, 0xF
        mcall    69, 9, [debuggee_pid]
        test    eax, eax
        jnz     .err
        pop     esi
        ret
 
;-----------------------------------------------------------------------------
;                             Find breakpoint
 
find_breakpoint:
        xor     ecx, ecx
        xchg    eax, ecx
        mov     edi, breakpoints
 
    @@:
        test    byte [edi+4], 1
        jz      .cont
        test    byte [edi+4], 8
        jnz     .cont
        cmp     [edi], ecx
        jz      .found
 
    .cont:
        add     edi, 6
        inc     eax
        cmp     eax, breakpoints_n
        jb      @b
        or      eax, -1
 
    .found:
        ret
 
;-----------------------------------------------------------------------------
;
 
find_enabled_breakpoint:
        xor     ecx, ecx
        xchg    eax, ecx
        mov     edi, breakpoints
 
    @@:
        test    byte [edi+4], 1
        jz      .cont
        test    byte [edi+4], 2 or 8
        jnz     .cont
        cmp     [edi], ecx
        jz      .found
 
    .cont:
        add     edi, 6
        inc     eax
        cmp     eax, breakpoints_n
        jb      @b
        or      eax, -1
 
    .found:
        ret
 
; TODO: add find_disabled_breakpoint
 
;-----------------------------------------------------------------------------
;                       Unpack executable event
 
OnUnpack:
    ; program must be loaded - checked when command was parsed
    ; program must be stopped
        mov     esi, aRunningErr
        cmp     [bSuspended], 0
        jz      put_message
   ; all breakpoints must be disabled
        mov     edi, breakpoints
 
    @@:
        test    byte [edi+4], 1
        jz      .cont
        test    byte [edi+4], 2
        jnz     .cont
        mov     esi, aEnabledBreakErr
        jmp     put_message
 
    .cont:
        add     edi, 6
        cmp     edi, breakpoints+breakpoints_n*6
        jb      @b
    ; ok, now do it
    ; set breakpoint on 0xC dword access
        push    9
        pop     ebx
        mov     ecx, [debuggee_pid]
        mov     dx, 1111b*256
        push    0xC
        pop     esi
 
    @@:
        ;push    69
        ;pop     eax
        mcall    69
        test    eax, eax
        jz      .breakok
        inc     edx
        cmp     dl, 4
        jb      @b
 
    .breakok:
        call    GoOn
 
    ; now wait for event
    .wait:
        ;push    10
        ;pop     eax
        mcall    10
        dec     eax
        jz      .redraw
        dec     eax
        jz      .key
        dec     eax
        jnz     .debug
    ; button; we have only one button, close
        or      eax, -1
        mcall
 
    .redraw:
        call    draw_window
        jmp     .wait
 
    .key:
        mov     al, 2
        mcall
        cmp     ah, 3   ; Ctrl+C
        jnz     .wait
 
    .userbreak:
        mov     esi, aInterrupted
 
    .x1:
        push    edx esi
        call    put_message
        pop     esi edx
        or      dh, 80h
        ;push    69
        ;pop     eax
        ;push    9
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        mcall    69, 9, [debuggee_pid]
        cmp     esi, aUnpacked
        jnz     OnSuspend
        jmp     AfterSuspend
 
    .debug:
        cmp     [dbgbuflen], 4*3
        jnz     .notour
        cmp     dword [dbgbuf], 3
        jnz     .notour
        test    byte [dbgbuf+8], 1
        jnz     .our
 
    .notour:
        mov     esi, aInterrupted
        push    edx
        call    put_message
        pop     edx
        or      dh, 80h
        ;push    69
        ;pop     eax
        ;push    9
        ;pop     ebx
        ;mov     ecx, [debuggee_pid]
        mcall    69, 9, [debuggee_pid]
        jmp     debugmsg
 
    .our:
        and     [dbgbuflen], 0
        push    edx
        call    get_context
        push    eax
        ;mov     al, 69
        ;mov     bl, 6
        ;mov     ecx, [debuggee_pid]
        ;mov     edi, esp
        ;push    4
        ;pop     edx
        ;push    0xC
        ;pop     esi
        mcall    69, 6, [debuggee_pid], 4, 0xC, esp
        pop     eax
        pop     edx
        cmp     eax, [_eip]
        jz      .done
        call    DoResume
        jmp     .wait
 
    .done:
        mov     esi, aUnpacked
        jmp     .x1
 
;-----------------------------------------------------------------------------
;                  Working with program symbols
;
;  TODO: split to symbols.inc
 
include 'sort.inc'
 
; compare what? Add context-relative comment and name
compare:
        cmpsd
        jnz     @f
        cmp     esi, edi
 
    @@:
        ret
 
; purpose of this function?
compare2:
        cmpsd
 
    @@:
        cmpsb
        jnz     @f
        cmp     byte [esi-1], 0
        jnz     @b
        cmp     esi, edi
 
    @@:
        ret
 
free_symbols:
        mov     ecx, [symbols]
        jecxz   @f
        mcall   68, 13
        and     [symbols], 0
        and     [num_symbols], 0
 
    @@:
        ret
;-----------------------------------------------------------------------------
;                        Load symbols event
 
OnLoadSymbols.fileerr:
        test    ebp, ebp
        jz      @f
        mcall   68, 13, edi
        ret
 
    @@:
        push    eax
        mcall   68, 13, edi
        mov     esi, aCannotLoadFile
        call    put_message_nodraw
        pop     eax
        cmp     eax, 0x20
        jae     .unk
        mov     esi, [load_err_msgs + eax*4]
        test    esi, esi
        jnz     put_message
 
    .unk:
        mov     esi, unk_err_msg2
        jmp     put_message
 
OnLoadSymbols:
        xor     ebp, ebp
   ; load input file
        mov     esi, [curarg]
        call    free_symbols
 
    .silent:
        xor     edi, edi
        cmp     [num_symbols], edi
        jz      @f
                                             
        call    free_symbols
        ;ret                                        
  
    @@:
        mov     ebx, fn70_attr_block
        mov     [ebx+21], esi
        mcall   70
        test    eax, eax
        jnz     .fileerr
        cmp     dword [fileattr+36], edi
        jnz     .memerr
        mov     ecx, dword [fileattr+32]
        mcall   68, 12
        test    eax, eax
        jz      .memerr
        mov     edi, eax
        mov     ebx, fn70_read_block
        mov     [ebx+12], ecx
        mov     [ebx+16], edi
        mov     [ebx+21], esi
        mcall   70
        test    eax, eax
        jnz     .fileerr
    ; calculate memory requirements
        lea     edx, [ecx+edi-1]        ; edx = EOF-1
        mov     esi, edi
        xor     ecx, ecx
 
    .calcloop:
        cmp     esi, edx
        jae     .calcdone
        cmp     word [esi], '0x'
        jnz     .skipline
        inc     esi
        inc     esi
 
    @@:
        cmp     esi, edx
        jae     .calcdone
        lodsb
        or      al, 20h
        sub     al, '0'
        cmp     al, 9
        jbe     @b
        sub     al, 'a'-'0'-10
        cmp     al, 15
        jbe     @b
        dec     esi
 
    @@:
        cmp     esi, edx
        ja      .calcdone
        lodsb
        cmp     al, 20h
        jz      @b
        jb      .calcloop
        cmp     al, 9
        jz      @b
        add     ecx, 12+1
        inc     [num_symbols]
 
    @@:
        inc     ecx
        cmp     esi, edx
        ja      .calcdone
        lodsb
        cmp     al, 0xD
        jz      .calcloop
        cmp     al, 0xA
        jz      .calcloop
        jmp     @b
 
    .skipline:
        cmp     esi, edx
        jae     .calcdone
        lodsb
        cmp     al, 0xD
        jz      .calcloop
        cmp     al, 0xA
        jz      .calcloop
        jmp     .skipline
 
    .calcdone:
        mcall   68, 12
        test    eax, eax
        jnz     .memok
        inc     ebx
        mov     ecx, edi
        mov     al, 68
        mcall
 
    .memerr:
        mov     esi, aNoMemory
        jmp     put_message
 
    .memok:
        mov     [symbols], eax
        mov     ebx, eax
        push    edi
        mov     esi, edi
        mov     edi, [num_symbols]
        lea     ebp, [eax+edi*4]
        lea     edi, [eax+edi*8]
 
    ; parse input data, 
    ; esi->input, edx->EOF, ebx->ptrs, edi->names
    .readloop:
        cmp     esi, edx
        jae     .readdone
        cmp     word [esi], '0x'
        jnz     .readline
        inc     esi
        inc     esi
        xor     eax, eax
        xor     ecx, ecx
 
    @@:
        shl     ecx, 4
        add     ecx, eax
        cmp     esi, edx
        jae     .readdone
        lodsb
        or      al, 20h
        sub     al, '0'
        cmp     al, 9
        jbe     @b
        sub     al, 'a'-'0'-10
        cmp     al, 15
        jbe     @b
        dec     esi
 
    @@:
        cmp     esi, edx
        ja      .readdone
        lodsb
        cmp     al, 20h
        jz      @b
        jb      .readloop
        cmp     al, 9
        jz      @b
        mov     dword [ebx], edi
        add     ebx, 4
        mov     dword [ebp], edi
        add     ebp, 4
        mov     dword [edi], ecx
        add     edi, 4
        stosb
 
    @@:
        xor     eax, eax
        stosb
        cmp     esi, edx
        ja      .readdone
        lodsb
        cmp     al, 0xD
        jz      .readloop
        cmp     al, 0xA
        jz      .readloop
        mov     byte [edi-1], al
        jmp     @b
 
    .readline:
        cmp     esi, edx
        jae     .readdone
        lodsb
        cmp     al, 0xD
        jz      .readloop
        cmp     al, 0xA
        jz      .readloop
        jmp     .readline
 
    .readdone:
        pop     ecx
        mcall   68, 13
        mov     ecx, [num_symbols]
        mov     edx, [symbols]
        mov     ebx, compare
        call    sort
        mov     ecx, [num_symbols]
        lea     edx, [edx+ecx*4]
        mov     ebx, compare2
        call    sort
        mov     esi, aSymbolsLoaded
        call    put_message
        jmp     draw_disasm.redraw
 
;-----------------------------------------------------------------------------
;
; in: EAX = address
; out: ESI, CF
 
find_symbol:
        cmp     [num_symbols], 0
        jnz     @f
 
    .ret0:
        xor     esi, esi
        stc
        ret
 
    @@:
        push    ebx ecx edx
        xor     edx, edx
        mov     esi, [symbols]
        mov     ecx, [num_symbols]
        mov     ebx, [esi]
        cmp     [ebx], eax
        jz      .donez
        jb      @f
        pop     edx ecx ebx
        jmp     .ret0
 
    @@:
    ; invariant: symbols_addr[edx] < eax < symbols_addr[ecx]
    ; TODO: add meaningful label names
    .0:
        push    edx
 
    .1:
        add     edx, ecx
        sar     edx, 1
        cmp     edx, [esp]
        jz      .done2
        mov     ebx, [esi+edx*4]
        cmp     [ebx], eax
        jz      .done
        ja      .2
        mov     [esp], edx
        jmp     .1
 
    .2:
        mov     ecx, edx
        pop     edx
        jmp     .0
 
    .donecont:
        dec     edx
 
    .done:
        test    edx, edx
        jz      @f
        mov     ebx, [esi+edx*4-4]
        cmp     [ebx], eax
        jz      .donecont
 
    @@:
        pop     ecx
 
    .donez:
        mov     esi, [esi+edx*4]
        add     esi, 4
        pop     edx ecx ebx
        clc
        ret
 
    .done2:
        lea     esi, [esi+edx*4]
        pop     ecx edx ecx ebx
        stc
        ret
 
;-----------------------------------------------------------------------------
;
; in: esi->name
; out: if found: CF = 0, EAX = value
;      otherwise CF = 1
find_symbol_name:
        cmp     [num_symbols], 0
        jnz     @f
 
    .stc_ret:
        stc
        ret
 
    @@:
        push    ebx ecx edx edi
        push    -1
        pop     edx
        mov     ebx, [symbols]
        mov     ecx, [num_symbols]
        lea     ebx, [ebx+ecx*4]
    
    ; invariant: symbols_name[edx] < name < symbols_name[ecx]
    .0:
        push    edx
 
    .1:
        add     edx, ecx
        sar     edx, 1
        cmp     edx, [esp]
        jz      .done2
        call    .cmp
        jz      .done
        jb      .2
        mov     [esp], edx
        jmp     .1
 
    .2:
        mov     ecx, edx
        pop     edx
        jmp     .0
 
    .done:
        pop     ecx
 
    .donez:
        mov     eax, [ebx+edx*4]
        mov     eax, [eax]
        pop     edi edx ecx ebx
        clc
        ret
 
    .done2:
        pop     edx edi edx ecx ebx
        stc
        ret
 
    .cmp:
        mov     edi, [ebx+edx*4]
        push    esi
        add     edi, 4
 
    @@:
        cmpsb
        jnz     @f
        cmp     byte [esi-1], 0
        jnz     @b
 
    @@:
        pop     esi
        ret
 
;-----------------------------------------------------------------------------
;                        Include disassembler engine
 
include 'disasm.inc'
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
caption_str db 'Kolibri Debugger',0
caption_len = $ - caption_str
 
begin_str db    'Kolibri Debugger, version 0.33',10
        db      'Hint: type "help" for help, "quit" for quit'
newline db      10,0
prompt  db      '> ',0
 
help_groups:
        dd      aControl, 0, 0, help_control_msg
        db      0
        dd      aData, 0, 0, help_data_msg
        db      0
        dd      aBreakpoints, 0, 0, help_breaks_msg
        db      0
 
;-----------------------------------------------------------------------------
;                   Commands format definitions
 
; TODO: make it with macros
 
; flags field:
; &1: command may be called without parameters
; &2: command may be called with parameters
; &4: command may be called without loaded program
; &8: command may be called with loaded program
commands:
        dd      _aH, OnHelp, HelpSyntax, HelpHelp
        db      0Fh
        dd      aHelp, OnHelp, HelpSyntax, HelpHelp
        db      0Fh
        dd      aQuit, OnQuit, QuitSyntax, QuitHelp
        db      0Dh
        dd      aLoad, OnLoad, LoadSyntax, LoadHelp
        db      6
        dd      aReload, OnReload, ReloadSyntax, ReloadHelp
        db      0Dh
        dd      aTerminate, OnTerminate, TerminateSyntax, TerminateHelp
        db      9
        dd      aDetach, OnDetach, DetachSyntax, DetachHelp
        db      9
        dd      aSuspend, OnSuspend, SuspendSyntax, SuspendHelp
        db      9
        dd      aResume, OnResume, ResumeSyntax, ResumeHelp
        db      0Bh
        dd      aStep, OnStep, StepSyntax, StepHelp
        db      0Bh
        dd      aProceed, OnProceed, ProceedSyntax, ProceedHelp
        db      0Bh
        dd      aCalc, OnCalc, CalcSyntax, CalcHelp
        db      0Eh
        dd      aDump, OnDump, DumpSyntax, DumpHelp
        db      0Bh
        dd      aUnassemble, OnUnassemble, UnassembleSyntax, UnassembleHelp
        db      0Bh
        dd      aBp, OnBp, BpSyntax, BpHelp
        db      0Ah
        dd      aBpm, OnBpmb, BpmSyntax, BpmHelp
        db      0Ah
        dd      aBpmb, OnBpmb, BpmSyntax, BpmHelp
        db      0Ah
        dd      aBpmw, OnBpmw, BpmSyntax, BpmHelp
        db      0Ah
        dd      aBpmd, OnBpmd, BpmSyntax, BpmHelp
        db      0Ah
        dd      aBl, OnBl, BlSyntax, BlHelp
        db      0Bh
        dd      aBc, OnBc, BcSyntax, BcHelp
        db      0Ah
        dd      aBd, OnBd, BdSyntax, BdHelp
        db      0Ah
        dd      aBe, OnBe, BeSyntax, BeHelp
        db      0Ah
        dd      aReg, OnReg, RSyntax, RHelp
        db      0Ah
        dd      aUnpack, OnUnpack, UnpackSyntax, UnpackHelp
        db      9
        dd      aLoadSymbols, OnLoadSymbols, LoadSymbolsSyntax, LoadSymbolsHelp
        db      0Ah
        dd      0
 
;-----------------------------------------------------------------------------
;                   Help messages for commands groups
 
aHelp   db      5,'help',0
_aH     db      2,'h',0
HelpHelp db     'Help on specified function',10
HelpSyntax db   'Usage: h or help [group | command]',10,0
 
help_msg db     'List of known command groups:',10
        db      '"help control"     - display list of control commands',10
        db      '"help data"        - display list of commands concerning data',10
        db      '"help breakpoints" - display list of commands concerning breakpoints',10,0
 
;               Control commands group
 
aControl db     8,'control',0
help_control_msg db     'List of control commands:',10
        db      'h = help             - help',10
        db      'quit                 - exit from debugger',10
        db      'load  [params] - load program for debugging',10
        db      'reload               - reload debugging program',10
        db      'load-symbols   - load information on symbols for program',10
        db      'terminate            - terminate loaded program',10
        db      'detach               - detach from debugging program',10
        db      'stop                 - suspend execution of debugging program',10
        db      'g []     - go on (resume execution of debugging program)',10
        db      's []            - program step, also ',10
        db      'p []            - program wide step, also ',10
        db      'unpack               - try to bypass unpacker code (heuristic)',10,0
 
;               Data commands group
 
aData   db      5,'data',0
help_data_msg db        'List of data commands:',10
        db      '?        - calculate value of expression',10
        db      'd []     - dump data at given address',10
        db      'u []     - unassemble instructions at given address',10
        db      'r   or',10
        db      'r = - set register value',10,0
    
;               Breakpoints commands group
 
aBreakpoints db 12,'breakpoints',0
help_breaks_msg db      'List of breakpoints commands:',10
        db      'bp       - set breakpoint on execution',10
        db      'bpm[b|w|d]   - set breakpoint on memory access',10
        db      'bl []        - breakpoint(s) info',10
        db      'bc ...       - clear breakpoint',10
        db      'bd ...       - disable breakpoint',10
        db      'be ...       - enable breakpoint',10,0
 
;-----------------------------------------------------------------------------
;                    Individual command help messages
 
aQuit   db      5,'quit',0
QuitHelp db     'Quit from debugger',10
QuitSyntax db   'Usage: quit',10,0
 
aLoad   db      5,'load',0
LoadHelp db     'Load program for debugging',10
LoadSyntax db   'Usage: load  [parameters]',10,0
 
aReload db      7,'reload',0
ReloadHelp db   'Reload debugging program (restart debug session)',10
ReloadSyntax db 'Usage: reload',10,0
 
aTerminate db   10,'terminate',0
TerminateHelp db 'Terminate debugged program',10
TerminateSyntax db 'Usage: terminate',10,0
 
aDetach db      7,'detach',0
DetachHelp db   'Detach from debugged program',10
DetachSyntax db 'Usage: detach',10,0
 
aSuspend db     5,'stop',0
SuspendHelp db  'Suspend execution of debugged program',10
SuspendSyntax db 'Usage: stop',10,0
 
aResume db      2,'g',0
ResumeHelp db   'Go (resume execution of debugged program)',10
ResumeSyntax db 'Usage: g',10
        db      '   or: g  - wait until specified address is reached',10,0
 
aStep   db      2,'s',0
StepHelp db     'Make step in debugged program',10
StepSyntax db   'Usage: s []',10,0
 
aProceed db     2,'p',0
ProceedHelp db  'Make wide step in debugged program (step over CALL, REPxx, LOOP)',10
ProceedSyntax db 'Usage: p []',10,0
 
aDump   db      2,'d',0
DumpHelp db     'Dump data of debugged program',10
DumpSyntax db   'Usage: d  - dump data at specified address',10
        db      '   or: d              - continue current dump',10,0
 
aCalc   db      2,'?',0
CalcHelp db     'Calculate value of expression',10
CalcSyntax db   'Usage: ? ',10,0
 
aUnassemble db  2,'u',0
UnassembleHelp db 'Unassemble',10
UnassembleSyntax db      'Usage: u  - unassemble instructions at specified address',10
                 db      '   or: u              - continue current unassemble screen',10,0
 
aReg    db      2,'r',0
RHelp   db      'Set register value',10
RSyntax db      'Usage: r  ',10
        db      '   or: r = - set value of  to ',10,0
 
aBp     db      3,'bp',0
BpHelp  db      'set BreakPoint on execution',10
BpSyntax db     'Usage: bp ',10,0
 
aBpm    db      4,'bpm',0
aBpmb   db      5,'bpmb',0
aBpmw   db      5,'bpmw',0
aBpmd   db      5,'bpmd',0
BpmHelp db      'set BreakPoint on Memory access',10
        db      'Maximum 4 breakpoints of this type are allowed',10
        db      'Note that for this breaks debugger is activated after access',10
BpmSyntax db    'Usage: bpmb [w] ',10
        db      '       bpmw [w] ',10
        db      '       bpmd [w] ',10
        db      '       bpm is synonym for bpmd',10
        db      '"w" means break only on writes (default is on read/write)',10,0
 
aBl     db      3,'bl',0
BlHelp  db      'Breakpoint List',10
BlSyntax db     'Usage: bl          - list all breakpoints',10
        db      '       bl  - display info on particular breakpoint',10,0
 
aBc     db      3,'bc',0
BcHelp  db      'Breakpoint Clear',10
BcSyntax db     'Usage: bc ',10
        db      'Examples: bc 2',10
        db      '          bc 1 3 4 A',10,0
 
aBd     db      3,'bd',0
BdHelp  db      'Breakpoint Disable',10
BdSyntax db     'Usage: bd ',10
        db      'Examples: bd 2',10
        db      '          bd 1 3 4 A',10,0
 
aBe     db      3,'be',0
BeHelp  db      'Breakpoint Enable',10
BeSyntax db     'Usage: be ',10
        db      'Examples: be 2',10
        db      '          be 1 3 4 A',10,0
 
aUnpack db      7,'unpack',0
UnpackHelp db   'Try to bypass unpacker code',10
UnpackSyntax db 'Usage: unpack',10,0
 
aLoadSymbols db 13,'load-symbols',0
LoadSymbolsHelp db 'Load symbolic information for executable',10
LoadSymbolsSyntax db 'Usage: load-symbols ',10,0
 
aUnknownCommand db 'Unknown command',10,0
 
;-----------------------------------------------------------------------------
;                             Error messages
 
load_err_msg    db      'Cannot load program. ',0
unk_err_msg     db      'Unknown error code -%4X',10,0
aCannotLoadFile db      'Cannot load file. ',0
unk_err_msg2    db      'Unknown error code %4X.',10,0
load_err_msgs:
        dd      .1, 0, .3, 0, .5, .6, 0, 0, .9, .A, 0, 0, 0, 0, 0, 0
        dd      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, .1E, .1F, .20
.1              db      'HD undefined.',10,0
.3              db      'Unknown FS.',10,0
.5              db      'File not found.',10,0
.6              db      'Unexpected EOF.',10,0
.9              db      'FAT table corrupted.',10,0
.A              db      'Access denied.',10,0
.1E             db      'No memory.',10,0
.1F             db      'Not Menuet/Kolibri executable.',10,0
.20             db      'Too many processes.',10,0
load_succ_msg   db      'Program loaded successfully! PID=%4X. Use "g" to run.',10,0
need_debuggee   db      'No program loaded. Use "load" command.',10,0
aAlreadyLoaded  db      'Program is already loaded. Use "terminate" or "detach" commands',10,0
terminated_msg  db      'Program terminated.',10,0
aException      db      'Debugged program caused an exception %2X. '
aSuspended      db      'Suspended',10,0
aContinued      db      'Continuing',10,0
aRunningErr     db      'Program is running',10,0
read_mem_err    db      'ERROR: cannot read process memory!!!',10,0
aBreakpointLimitExceeded db 'Breakpoint limit exceeded',10,0
aBreakErr       db      'Cannot activate breakpoint, it will be disabled',10,0
aDuplicateBreakpoint db 'Duplicate breakpoint',10,0
aInvalidBreak   db      'Invalid breakpoint number',10,0
OnBeErrMsg      db      'There is already enabled breakpoint on this address',10,0
aBreakNum       db      '%2X: at %8X',0
aMemBreak1      db      '%2X: on ',0
aMemBreak2      db      'read from ',0
aMemBreak3      db      'access of ',0
aMemBreak4      db      'byte',0
aMemBreak5      db      'word',0
aMemBreak6      db      'dword',0
aMemBreak7      db      ' at %8X',0
aOneShot        db      ', one-shot',0
aDisabled       db      ', disabled',0
aBreakStop      db      'Breakpoint #%2X',10,0
aUserBreak      db      'int3 command at %8X',10,0
;dbgmsg_str     db      'Debug message for process %4X.',10,0
aInvAddr        db      'Invalid address',10,0
NoPrgLoaded_str db      'No program loaded'
NoPrgLoaded_len = $ - NoPrgLoaded_str
aRunning        db      'Running'
aPaused         db      'Paused'
aMain            db        '[ CPU ]'
aSSE            db        '[ SSE ]'
aAVX            db        '[ AVX ]'
aMSR            db        '[ MSR ]'
aPoint          db      0x1C
aMinus          db      '-'
aColon          db      ':'
aSpace          db      ' '
aQuests         db      '??'
aDots           db      '...'
aParseError     db      'Parse error',10,0
aDivByZero      db      'Division by 0',10,0
calc_string     db      '%8X',10,0
aNoMemory       db      'No memory',10,0
aSymbolsLoaded  db      'Symbols loaded',10,0
aUnaligned      db      'Unaligned address',10,0
aEnabledBreakErr db     'Enabled breakpoints are not allowed',10,0
aInterrupted    db      'Interrupted',10,0
aUnpacked       db      'Unpacked successful!',10,0
aPacked1        db      'Program is probably packed with ',0
aPacked2        db      '.',10,'Try to unpack automatically? [y/n]: ',0
aY_str          db      'y',10,0
aN_str          db      'n',10,0
mxp_nrv_name    db      'mxp_nrv',0
mxp_name        db      'mxp',0
mxp_lzo_name    db      'mxp_lzo',0
mtappack_name   db      'mtappack',0
flags           db      'CPAZSDO'
flags_bits      db      0,2,4,6,7,10,11
 
;-----------------------------------------------------------------------------
;                         Registers strings
 
regs_strs:
        db      'EAX='
        db      'EBX='
        db      'ECX='
        db      'EDX='
        db      'ESI='
        db      'EDI='
        db      'EBP='
        db      'ESP='
        db      'EIP='
        db      'EFLAGS='
fpu_strs:
        db        'ST0='
        db        'ST1='
        db        'ST2='
        db        'ST3='
        db        'ST4='
        db        'ST5='
        db        'ST6='
        db        'ST7='
mmx_strs:
        db        'MM0='
        db        'MM1='
        db        'MM2='
        db        'MM3='
        db        'MM4='
        db        'MM5='
        db        'MM6='
        db        'MM7='
sse_strs:
        db        '-XMM0-'
        db      '-XMM1-'
        db      '-XMM2-'
        db      '-XMM3-'
        db      '-XMM4-'
        db      '-XMM5-'
        db      '-XMM6-'
        db      '-XMM7-'
avx_strs:
        db      '-YMM0-'
        db      '-YMM1-'
        db      '-YMM2-'
        db      '-YMM3-'
        db      '-YMM4-'
        db      '-YMM5-'
        db      '-YMM6-'
        db      '-YMM7-'
 
debuggee_pid    dd      0
bSuspended      db      0
bAfterGo        db      0
temp_break      dd      0
reg_mode        db        1
 
include 'disasm_tbl.inc'
 
reg_table:
        db      2,'al',0
        db      2,'cl',1
        db      2,'dl',2
        db      2,'bl',3
        db      2,'ah',4
        db      2,'ch',5
        db      2,'dh',6
        db      2,'bh',7
        db      2,'ax',8
        db      2,'cx',9
        db      2,'dx',10
        db      2,'bx',11
        db      2,'sp',12
        db      2,'bp',13
        db      2,'si',14
        db      2,'di',15
        db      3,'eax',16
        db      3,'ecx',17
        db      3,'edx',18
        db      3,'ebx',19
        db      3,'esp',20
        db      3,'ebp',21
        db      3,'esi',22
        db      3,'edi',23
        db      3,'eip',24
        db      0
 
IncludeIGlobals
 
fn70_read_block:
        dd      0
        dq      0
        dd      ?
        dd      ?
        db      0
        dd      ?
 
fn70_attr_block:
        dd      5
        dd      0,0,0
        dd      fileattr
        db      0
        dd      ?
 
fn70_load_block:
        dd      7
        dd      1
load_params dd  0
        dd      0
        dd      0
i_end:
loadname:
        db      0
        rb      255
 
symbolsfile     rb      260
 
prgname_ptr dd ?
prgname_len dd ?
 
IncludeUGlobals
 
dbgwnd          dd      ?
 
messages        rb      messages_height*messages_width
messages_pos    dd      ?
 
cmdline         rb      cmdline_width+1
cmdline_len     dd      ?
cmdline_pos     dd      ?
curarg          dd      ?
 
cmdline_prev    rb      cmdline_width+1
 
was_temp_break  db      ?
 
dbgbufsize      dd      ?
dbgbuflen       dd      ?
dbgbuf          rb      256
 
fileattr        rb      40
 
needzerostart:
 
context:
 
_eip    dd      ?
_eflags dd      ?
_eax    dd      ?
_ecx    dd      ?
_edx    dd      ?
_ebx    dd      ?
_esp    dd      ?
_ebp    dd      ?
_esi    dd      ?
_edi    dd      ?
oldcontext rb $-context
 
mmx_context:
_mm0    dq        ?
_mm1    dq        ?
_mm2    dq        ?
_mm3    dq        ?
_mm4    dq        ?
_mm5    dq        ?
_mm6    dq        ?
_mm7    dq        ?
oldmmxcontext rb $-mmx_context
 
fpu_context:
_st0    dq      ?
_st1    dq      ?
_st2    dq      ?
_st3    dq      ?
_st4    dq      ?
_st5    dq      ?
_st6    dq      ?
_st7    dq      ?
oldfpucontext rb $-fpu_context
 
sse_context:
_xmm0    dq        2 dup ?
_xmm1   dq        2 dup ?
_xmm2   dq      2 dup ?
_xmm3   dq      2 dup ?
_xmm4   dq      2 dup ?
_xmm5   dq      2 dup ?
_xmm6   dq      2 dup ?
_xmm7   dq      2 dup ?
oldssecontext rb $-sse_context
 
avx_context:
_ymm0   dq      4 dup ?
_ymm1   dq      4 dup ?
_ymm2   dq      4 dup ?
_ymm3   dq      4 dup ?
_ymm4   dq      4 dup ?
_ymm5   dq      4 dup ?
_ymm6   dq      4 dup ?
_ymm7   dq      4 dup ?
oldavxcontext rb $-avx_context
 
step_num dd 0
proc_num dd 0
dumpread dd     ?
dumppos dd      ?
dumpdata rb     dump_height*10h
 
; breakpoint structure:
; dword +0: address
; byte +4: flags
; bit 0: 1 <=> breakpoint valid
; bit 1: 1 <=> breakpoint disabled
; bit 2: 1 <=> one-shot breakpoint
; bit 3: 1 <=> DRx breakpoint
; byte +5: overwritten byte
;          for DRx breaks: flags + (index shl 6)
breakpoints_n = 256
breakpoints     rb      breakpoints_n*6
drx_break       rd      4
 
disasm_buf_size         dd      ?
 
symbols         dd      ?
num_symbols     dd      ?
 
bReload                 db      ?
 
needzeroend:
 
disasm_buffer           rb      256
disasm_start_pos        dd      ?
disasm_cur_pos          dd      ?
disasm_cur_str          dd      ?
disasm_string           rb      256
 
i_param         rb      256
 
; stack
        align   400h
        rb      400h
used_mem:
 
; vim: ft=fasm tabstop=4

Rev 3675	Rev 4285
1	format binary	1	format binary
2	include '../../macros.inc'	2	include '../../macros.inc'
3	use32	3	use32
4	db 'MENUET01'	4	db 'MENUET01'
5	dd 1	5	dd 1
6	dd start	6	dd start
7	dd i_end	7	dd i_end
8	dd used_mem	8	dd used_mem
9	dd used_mem	9	dd used_mem
10	dd i_param	10	dd i_param
11	dd 0	11	dd 0
12		12
13	;-----------------------------------------------------------------------------	13	;-----------------------------------------------------------------------------
14		14
15	REG_MODE_CPU equ 1	15	REG_MODE_CPU equ 1
16	REG_MODE_MMX equ 2	16	REG_MODE_MMX equ 2
17	REG_MODE_SSE equ 3	17	REG_MODE_SSE equ 3
18	REG_MODE_AVX equ 4	18	REG_MODE_AVX equ 4
19		19
20	;-----------------------------------------------------------------------------	20	;-----------------------------------------------------------------------------
21		21
22	include 'gui.inc' ; GUI routines	22	include 'gui.inc' ; GUI routines
23		23
24	;-----------------------------------------------------------------------------	24	;-----------------------------------------------------------------------------
25	; Find command in list	25	; Find command in list
26		26
27	find_cmd:	27	find_cmd:
28	; all commands are case-insensitive	28	; all commands are case-insensitive
29	push edi	29	push edi
30		30
31	.x4:	31	.x4:
32	mov al, [edi]	32	mov al, [edi]
33	cmp al, 0	33	cmp al, 0
34	jz .x5	34	jz .x5
35	cmp al, 'A'	35	cmp al, 'A'
36	jb @f	36	jb @f
37	cmp al, 'Z'	37	cmp al, 'Z'
38	ja @f	38	ja @f
39	or al, 20h	39	or al, 20h
40		40
41	@@:	41	@@:
42	stosb	42	stosb
43	jmp .x4	43	jmp .x4
44		44
45	; find command	45	; find command
46	.x5:	46	.x5:
47	pop edi	47	pop edi
48		48
49	.x6:	49	.x6:
50	cmp dword [esi], 0	50	cmp dword [esi], 0
51	jz .x7	51	jz .x7
52	push esi	52	push esi
53	mov esi, [esi]	53	mov esi, [esi]
54	lodsb	54	lodsb
55	movzx ecx, al	55	movzx ecx, al
56	push edi	56	push edi
57	repz cmpsb	57	repz cmpsb
58	pop edi	58	pop edi
59	pop esi	59	pop esi
60	jz .x8	60	jz .x8
61	add esi, 17	61	add esi, 17
62	jmp .x6	62	jmp .x6
63		63
64	.x7:	64	.x7:
65	stc	65	stc
66		66
67	.x8:	67	.x8:
68	ret	68	ret
69		69
70	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	70	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
71	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	71	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
72	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	72	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
73		73
74	;-----------------------------------------------------------------------------	74	;-----------------------------------------------------------------------------
75	; Help event	75	; Help event
76		76
77	OnHelp:	77	OnHelp:
78	mov esi, help_msg	78	mov esi, help_msg
79	mov edi, [curarg]	79	mov edi, [curarg]
80	cmp byte [edi], 0	80	cmp byte [edi], 0
81	jz .x	81	jz .x
82	mov esi, help_groups	82	mov esi, help_groups
83	call find_cmd	83	call find_cmd
84	jc .nocmd	84	jc .nocmd
85	mov esi, [esi+12]	85	mov esi, [esi+12]
86		86
87	.x:	87	.x:
88	jmp put_message	88	jmp put_message
89		89
90	.nocmd:	90	.nocmd:
91	mov esi, aUnknownCommand	91	mov esi, aUnknownCommand
92	jmp .x	92	jmp .x
93		93
94	;-----------------------------------------------------------------------------	94	;-----------------------------------------------------------------------------
95	; Quit event	95	; Quit event
96	OnQuit:	96	OnQuit:
97	mcall -1	97	mcall -1
98		98
99	;-----------------------------------------------------------------------------	99	;-----------------------------------------------------------------------------
100	; Working with debug context	100	; Working with debug context
101		101
102	get_new_context:	102	get_new_context:
103	mov esi, context	103	mov esi, context
104	mov edi, oldcontext	104	mov edi, oldcontext
105	mov ecx, 10	105	mov ecx, 10
106	rep movsd	106	rep movsd
107		107
108	get_context:	108	get_context:
109	;push 1	109	;push 1
110	;pop ebx	110	;pop ebx
111	;push 69	111	;push 69
112	;pop eax	112	;pop eax
113	;mov ecx, [debuggee_pid]	113	;mov ecx, [debuggee_pid]
114	;mov esi, context	114	;mov esi, context
115	;push 28h	115	;push 28h
116	;pop edx	116	;pop edx
117	mcall 69, 1, [debuggee_pid], 28h, context	117	mcall 69, 1, [debuggee_pid], 28h, context
118	ret	118	ret
119		119
120	set_context:	120	set_context:
121	;push 2	121	;push 2
122	;pop ebx	122	;pop ebx
123	;push 69	123	;push 69
124	;pop eax	124	;pop eax
125	;mov ecx, [debuggee_pid]	125	;mov ecx, [debuggee_pid]
126	;mov esi, context	126	;mov esi, context
127	;push 28h	127	;push 28h
128	;pop edx	128	;pop edx
129	mcall 69, 2, [debuggee_pid], 28h, context	129	mcall 69, 2, [debuggee_pid], 28h, context
130	ret	130	ret
131		131
132	get_dump:	132	get_dump:
133	mov edi, dumpdata	133	mov edi, dumpdata
134	mov esi, [edi-4]	134	mov esi, [edi-4]
135	mov edx, dump_height*10h	135	mov edx, dump_height*10h
136	mov ecx, edx	136	mov ecx, edx
137	xor eax, eax	137	xor eax, eax
138	push edi	138	push edi
139	rep stosb	139	rep stosb
140	pop edi	140	pop edi
141	;mov ecx, [debuggee_pid]	141	;mov ecx, [debuggee_pid]
142	;mov al, 69	142	;mov al, 69
143	;push 6	143	;push 6
144	;pop ebx	144	;pop ebx
145	mcall 69, 6, [debuggee_pid]	145	mcall 69, 6, [debuggee_pid]
146	cmp eax, -1	146	cmp eax, -1
147	jnz @f	147	jnz @f
148	mov esi, read_mem_err	148	mov esi, read_mem_err
149	call put_message	149	call put_message
150	xor eax, eax	150	xor eax, eax
151		151
152	@@:	152	@@:
153	mov [edi-8], eax	153	mov [edi-8], eax
154	; call restore_from_breaks	154	; call restore_from_breaks
155	; ret	155	; ret
156		156
157	; in: edi=buffer,eax=size,esi=address	157	; in: edi=buffer,eax=size,esi=address
158	restore_from_breaks:	158	restore_from_breaks:
159	mov ebx, breakpoints	159	mov ebx, breakpoints
160		160
161	@@:	161	@@:
162	test byte [ebx+4], 1	162	test byte [ebx+4], 1
163	jz .cont ; ignore invalid	163	jz .cont ; ignore invalid
164	test byte [ebx+4], 2 or 8	164	test byte [ebx+4], 2 or 8
165	jnz .cont ; ignore disabled and memory breaks	165	jnz .cont ; ignore disabled and memory breaks
166	mov ecx, [ebx]	166	mov ecx, [ebx]
167	sub ecx, esi	167	sub ecx, esi
168	cmp ecx, eax	168	cmp ecx, eax
169	jae .cont	169	jae .cont
170	mov dl, [ebx+5]	170	mov dl, [ebx+5]
171	mov [edi+ecx], dl	171	mov [edi+ecx], dl
172		172
173	.cont:	173	.cont:
174	add ebx, 6	174	add ebx, 6
175	cmp ebx, breakpoints+breakpoints_n*6	175	cmp ebx, breakpoints+breakpoints_n*6
176	jb @b	176	jb @b
177	ret	177	ret
178		178
179	;-----------------------------------------------------------------------------	179	;-----------------------------------------------------------------------------
180	; Load executable event	180	; Load executable event
181		181
182	OnLoad:	182	OnLoad:
183	mov esi, [curarg]	183	mov esi, [curarg]
184		184
185	OnLoadInit:	185	OnLoadInit:
186	mov edi, loadname	186	mov edi, loadname
187	or [prgname_len], -1	187	or [prgname_len], -1
188	mov [prgname_ptr], edi	188	mov [prgname_ptr], edi
189		189
190	.copyname:	190	.copyname:
191	lodsb	191	lodsb
192	stosb	192	stosb
193	inc [prgname_len]	193	inc [prgname_len]
194	cmp al, '/'	194	cmp al, '/'
195	jnz @f	195	jnz @f
196	or [prgname_len], -1	196	or [prgname_len], -1
197	mov [prgname_ptr], edi	197	mov [prgname_ptr], edi
198		198
199	@@:	199	@@:
200	cmp al, ' '	200	cmp al, ' '
201	ja .copyname	201	ja .copyname
202	mov byte [edi-1], 0	202	mov byte [edi-1], 0
203	and [load_params], 0	203	and [load_params], 0
204	dec esi	204	dec esi
205	call get_arg.skip_spaces	205	call get_arg.skip_spaces
206	cmp al, 0	206	cmp al, 0
207	jz @f	207	jz @f
208	mov [load_params], esi	208	mov [load_params], esi
209		209
210	@@:	210	@@:
211	and [dumppos], 0	211	and [dumppos], 0
212	mov ecx, [symbols]	212	mov ecx, [symbols]
213	jecxz do_reload	213	jecxz do_reload
214	mcall 68, 13	214	mcall 68, 13
215	and [symbols], 0	215	and [symbols], 0
216	and [num_symbols], 0	216	and [num_symbols], 0
217		217
218	; TODO: make it local	218	; TODO: make it local
219	do_reload:	219	do_reload:
220	;push 18	220	;push 18
221	;pop eax	221	;pop eax
222	;push 7	222	;push 7
223	;pop ebx	223	;pop ebx
224	mcall 18, 7	224	mcall 18, 7
225	mov [dbgwnd], eax	225	mov [dbgwnd], eax
226	xchg ecx, eax	226	xchg ecx, eax
227	;push 70	227	;push 70
228	;pop eax	228	;pop eax
229	;mov ebx, fn70_load_block	229	;mov ebx, fn70_load_block
230	mcall 70, fn70_load_block	230	mcall 70, fn70_load_block
231	test eax, eax	231	test eax, eax
232	jns .load_ok	232	jns .load_ok
233		233
234	.load_err:	234	.load_err:
235	push eax	235	push eax
236	mov esi, load_err_msg	236	mov esi, load_err_msg
237	call put_message	237	call put_message
238	pop eax	238	pop eax
239	not eax	239	not eax
240	cmp eax, 0x20	240	cmp eax, 0x20
241	jae .unk_err	241	jae .unk_err
242	mov esi, [load_err_msgs+eax*4]	242	mov esi, [load_err_msgs+eax*4]
243	test esi, esi	243	test esi, esi
244	jnz put_message	244	jnz put_message
245		245
246	.unk_err:	246	.unk_err:
247	mov esi, unk_err_msg	247	mov esi, unk_err_msg
248	inc eax	248	inc eax
249	push eax	249	push eax
250	call put_message_nodraw	250	call put_message_nodraw
251	jmp draw_messages	251	jmp draw_messages
252		252
253	.load_ok:	253	.load_ok:
254	mov [debuggee_pid], eax	254	mov [debuggee_pid], eax
255	mov [bSuspended], 1	255	mov [bSuspended], 1
256	push ecx	256	push ecx
257	call get_context	257	call get_context
258	mov edi, oldcontext	258	mov edi, oldcontext
259	mov ecx, 10	259	mov ecx, 10
260	rep movsd	260	rep movsd
261		261
262	; activate debugger window	262	; activate debugger window
263	pop ecx	263	pop ecx
264	;mov bl, 3	264	;mov bl, 3
265	;push 18	265	;push 18
266	;pop eax	266	;pop eax
267	mcall 18, 3	267	mcall 18, 3
268	call redraw_title	268	call redraw_title
269	call draw_registers.redraw	269	call draw_registers.redraw
270	; read and draw dump of memory	270	; read and draw dump of memory
271	call get_dump	271	call get_dump
272	call draw_dump.redraw	272	call draw_dump.redraw
273	call update_disasm_eip_force	273	call update_disasm_eip_force
274	mov esi, load_succ_msg	274	mov esi, load_succ_msg
275	push [debuggee_pid]	275	push [debuggee_pid]
276	call put_message_nodraw	276	call put_message_nodraw
277	call draw_messages	277	call draw_messages
278	; try to load symbols	278	; try to load symbols
279	mov esi, loadname	279	mov esi, loadname
280	mov edi, symbolsfile	280	mov edi, symbolsfile
281	push edi	281	push edi
282		282
283	@@:	283	@@:
284	lodsb	284	lodsb
285	stosb	285	stosb
286	test al, al	286	test al, al
287	jnz @b	287	jnz @b
288	lea ecx, [edi-1]	288	lea ecx, [edi-1]
289		289
290	@@:	290	@@:
291	dec edi	291	dec edi
292	cmp edi, symbolsfile	292	cmp edi, symbolsfile
293	jb @f	293	jb @f
294	cmp byte [edi], '/'	294	cmp byte [edi], '/'
295	jz @f	295	jz @f
296	cmp byte [edi], '.'	296	cmp byte [edi], '.'
297	jnz @b	297	jnz @b
298	mov ecx, edi	298	mov ecx, edi
299		299
300	@@:	300	@@:
301	mov dword [ecx], '.dbg'	301	mov dword [ecx], '.dbg'
302	mov byte [ecx+4], 0	302	mov byte [ecx+4], 0
303	pop esi	303	pop esi
304	mov ebp, esi	304	mov ebp, esi
305	call OnLoadSymbols.silent	305	call OnLoadSymbols.silent
306		306
307	; now test for packed progs	307	; now test for packed progs
308	cmp [disasm_buf_size], 100h	308	cmp [disasm_buf_size], 100h
309	jz @f	309	jz @f
310	ret	310	ret
311		311
312	@@:	312	@@:
313	mov esi, mxp_nrv_sig	313	mov esi, mxp_nrv_sig
314	mov ebp, disasm_buffer	314	mov ebp, disasm_buffer
315	mov edi, ebp	315	mov edi, ebp
316	push 3	316	push 3
317	pop ecx	317	pop ecx
318	repz cmpsb	318	repz cmpsb
319	jnz .not_mxp_nrv	319	jnz .not_mxp_nrv
320	cmpsb	320	cmpsb
321	mov cl, mxp_nrv_sig_size-4	321	mov cl, mxp_nrv_sig_size-4
322	repz cmpsb	322	repz cmpsb
323	mov esi, mxp_nrv_name	323	mov esi, mxp_nrv_name
324	jz .packed	324	jz .packed
325		325
326	.not_mxp_nrv:	326	.not_mxp_nrv:
327	mov esi, mxp_sig	327	mov esi, mxp_sig
328	mov edi, ebp	328	mov edi, ebp
329	mov cl, mxp_sig_size	329	mov cl, mxp_sig_size
330	repz cmpsb	330	repz cmpsb
331	mov esi, mxp_name	331	mov esi, mxp_name
332	jz .packed	332	jz .packed
333		333
334	.not_mxp:	334	.not_mxp:
335	mov esi, mxp_lzo_sig1	335	mov esi, mxp_lzo_sig1
336	mov edi, ebp	336	mov edi, ebp
337	mov cl, mxp_lzo_sig1_size	337	mov cl, mxp_lzo_sig1_size
338	repz cmpsb	338	repz cmpsb
339	mov esi, mxp_lzo_name	339	mov esi, mxp_lzo_name
340	jz .packed	340	jz .packed
341	mov esi, mxp_lzo_sig2	341	mov esi, mxp_lzo_sig2
342	mov edi, ebp	342	mov edi, ebp
343	mov cl, 8	343	mov cl, 8
344	repz cmpsb	344	repz cmpsb
345	jnz .not_mxp_lzo	345	jnz .not_mxp_lzo
346	cmpsb	346	cmpsb
347	mov cl, mxp_lzo_sig2_size - 9	347	mov cl, mxp_lzo_sig2_size - 9
348	repz cmpsb	348	repz cmpsb
349	mov esi, mxp_lzo_name	349	mov esi, mxp_lzo_name
350	jz .packed	350	jz .packed
351		351
352	.not_mxp_lzo:	352	.not_mxp_lzo:
353	mov esi, mtappack_name	353	mov esi, mtappack_name
354	cmp dword [ebp], 0xBF5E246A	354	cmp dword [ebp], 0xBF5E246A
355	jnz .not_mtappack	355	jnz .not_mtappack
356	cmp dword [ebp+8], 0xEC4E8B57	356	cmp dword [ebp+8], 0xEC4E8B57
357	jnz .not_mtappack1	357	jnz .not_mtappack1
358	cmp dword [ebp+12], 0x8D5EA4F3	358	cmp dword [ebp+12], 0x8D5EA4F3
359	jnz .not_mtappack1	359	jnz .not_mtappack1
360	cmp byte [ebp+12h], 0xE9	360	cmp byte [ebp+12h], 0xE9
361	jz .packed	361	jz .packed
362		362
363	.not_mtappack1:	363	.not_mtappack1:
364	cmp word [ebp+8], 0xB957	364	cmp word [ebp+8], 0xB957
365	jnz .not_mtappack	365	jnz .not_mtappack
366	cmp dword [ebp+14], 0x575EA4F3	366	cmp dword [ebp+14], 0x575EA4F3
367	jnz .not_mtappack2	367	jnz .not_mtappack2
368	cmp byte [ebp+17h], 0xE9	368	cmp byte [ebp+17h], 0xE9
369	jz .packed	369	jz .packed
370		370
371	.not_mtappack2:	371	.not_mtappack2:
372	cmp dword [ebp+14], 0x5F8DA4F3	372	cmp dword [ebp+14], 0x5F8DA4F3
373	jnz .not_mtappack3	373	jnz .not_mtappack3
374	cmp word [ebp+18], 0xE9FC	374	cmp word [ebp+18], 0xE9FC
375	jz .packed	375	jz .packed
376		376
377	.not_mtappack3:	377	.not_mtappack3:
378	cmp word [ebp+14], 0xA4F3	378	cmp word [ebp+14], 0xA4F3
379	jnz .not_mtappack	379	jnz .not_mtappack
380	cmp byte [ebp+15h], 0xE9	380	cmp byte [ebp+15h], 0xE9
381	jz .packed	381	jz .packed
382		382
383	.not_mtappack:	383	.not_mtappack:
384	ret	384	ret
385		385
386	.packed:	386	.packed:
387	push esi	387	push esi
388	mov esi, aPacked1	388	mov esi, aPacked1
389	call put_message_nodraw	389	call put_message_nodraw
390	pop esi	390	pop esi
391	call put_message_nodraw	391	call put_message_nodraw
392	mov esi, aPacked2	392	mov esi, aPacked2
393	call put_message	393	call put_message
394	call hide_cursor	394	call hide_cursor
395	;push 40	395	;push 40
396	;pop eax	396	;pop eax
397	;push 7	397	;push 7
398	;pop ebx	398	;pop ebx
399	mcall 40, 7	399	mcall 40, 7
400		400
401	.wait:	401	.wait:
402	;push 10	402	;push 10
403	;pop eax	403	;pop eax
404	mcall 10	404	mcall 10
405	dec eax	405	dec eax
406	jz .redraw	406	jz .redraw
407	dec eax	407	dec eax
408	jz .key	408	jz .key
409	or eax, -1	409	or eax, -1
410	mcall	410	mcall
411		411
412	.redraw:	412	.redraw:
413	call draw_window	413	call draw_window
414	call hide_cursor	414	call hide_cursor
415	jmp .wait	415	jmp .wait
416		416
417	.key:	417	.key:
418	mov al, 2	418	mov al, 2
419	mcall	419	mcall
420	cmp ah, 'y'	420	cmp ah, 'y'
421	jz .yes	421	jz .yes
422	cmp ah, 'Y'	422	cmp ah, 'Y'
423	jz .yes	423	jz .yes
424	cmp ah, 0xD	424	cmp ah, 0xD
425	jz .yes	425	jz .yes
426	cmp ah, 'n'	426	cmp ah, 'n'
427	jz .no	427	jz .no
428	cmp ah, 'N'	428	cmp ah, 'N'
429	jnz .wait	429	jnz .wait
430		430
431	.no:	431	.no:
432	;push 40	432	;push 40
433	;pop eax	433	;pop eax
434	;mov ebx, 0x107	434	;mov ebx, 0x107
435	mcall 40, 0x107	435	mcall 40, 0x107
436	call draw_cursor	436	call draw_cursor
437	mov esi, aN_str	437	mov esi, aN_str
438	jmp put_message	438	jmp put_message
439		439
440	.yes:	440	.yes:
441	;push 40	441	;push 40
442	;pop eax	442	;pop eax
443	;mov ebx, 0x107	443	;mov ebx, 0x107
444	mcall 40, 0x107	444	mcall 40, 0x107
445	call draw_cursor	445	call draw_cursor
446	mov esi, aY_str	446	mov esi, aY_str
447	call put_message	447	call put_message
448	call OnUnpack	448	call OnUnpack
449	ret	449	ret
450		450
451	;-----------------------------------------------------------------------------	451	;-----------------------------------------------------------------------------
452	; Searching signatures	452	; Searching signatures
453		453
454	mxp_nrv_sig:	454	mxp_nrv_sig:
455	xor eax, eax	455	xor eax, eax
456	mov ecx, 0x95 ; 0xA1 for programs with parameters	456	mov ecx, 0x95 ; 0xA1 for programs with parameters
457	mov [eax], ecx	457	mov [eax], ecx
458	add ecx, [eax+24h]	458	add ecx, [eax+24h]
459	push 40h	459	push 40h
460	pop esi	460	pop esi
461	mov edi, [eax+20h]	461	mov edi, [eax+20h]
462	push edi	462	push edi
463	rep movsb	463	rep movsb
464	jmp dword [esp]	464	jmp dword [esp]
465	pop esi	465	pop esi
466	add esi, [eax]	466	add esi, [eax]
467	xor edi, edi	467	xor edi, edi
468		468
469	mxp_nrv_sig_size = $ - mxp_nrv_sig	469	mxp_nrv_sig_size = $ - mxp_nrv_sig
470		470
471	mxp_sig:	471	mxp_sig:
472	mov ecx, 1CBh	472	mov ecx, 1CBh
473	push 46h	473	push 46h
474	pop esi	474	pop esi
475	mov edi, [20h]	475	mov edi, [20h]
476	rep movsb	476	rep movsb
477	mov ecx, [24h]	477	mov ecx, [24h]
478	rep movsb	478	rep movsb
479	jmp dword [20h]	479	jmp dword [20h]
480	mov eax, [20h]	480	mov eax, [20h]
481	add eax, 1CBh	481	add eax, 1CBh
482	push eax	482	push eax
483	push dword [24h]	483	push dword [24h]
484	push 0	484	push 0
485	push 8	485	push 8
486	call $+0x25	486	call $+0x25
487		487
488	mxp_sig_size = $ - mxp_sig	488	mxp_sig_size = $ - mxp_sig
489		489
490	mxp_lzo_sig1:	490	mxp_lzo_sig1:
491	xor eax, eax	491	xor eax, eax
492	mov ebp, 0FFh	492	mov ebp, 0FFh
493	mov ecx, 175h	493	mov ecx, 175h
494	mov [eax], ecx	494	mov [eax], ecx
495	add ecx, [eax+24h]	495	add ecx, [eax+24h]
496	push 45h	496	push 45h
497	pop esi	497	pop esi
498	mov edi, [eax+20h]	498	mov edi, [eax+20h]
499	push edi	499	push edi
500	rep movsb	500	rep movsb

Subversion Repositories Kolibri OS

(root)/programs/develop/mtdbg/mtdbg.asm – Rev 3675 → 4285