| 1,4 → 1,4 |
|---|
| COLOR_THEME equ BLACK_ON_WHITE |
| COLOR_THEME fix BLACK_ON_WHITE |
| |
| |
| format binary as "" |
| 305,7 → 305,15 |
|---|
| mov byte [ecx+4], 0 |
| pop esi |
| mov ebp, esi |
| push ecx esi |
| call OnLoadSymbols.silent ; Try to load .dbg file |
| pop esi ecx |
| xor eax, eax |
| cmp [num_symbols], eax |
| jne @f |
| mov dword[ecx], '.map' ; If failed, try .map file too |
| call OnLoadSymbols.silent |
| @@: |
| |
| ; now test for packed progs |
| cmp [disasm_buf_size], 100h |
| 1941,413 → 1949,11 |
|---|
| jmp .x1 |
| |
| ;----------------------------------------------------------------------------- |
| ; Working with program symbols |
| ; |
| ; TODO: split to symbols.inc |
| ; Include Symbol parser |
| |
| include 'sort.inc' |
| include 'symbols.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' |
| 2357,9 → 1963,8 |
|---|
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| caption_str db 'Kolibri Debugger',0 |
| caption_len = $ - caption_str |
| |
| begin_str db 'Kolibri Debugger, version 0.33',10 |
| begin_str db 'Kolibri Debugger, version 0.34',10 |
| db 'Hint: type "help" for help, "quit" to quit' |
| newline db 10,0 |
| prompt db '> ',0 |
| 2692,6 → 2297,7 |
|---|
| db 'ESP=' |
| db 'EIP=' |
| db 'EFLAGS=' |
| |
| fpu_strs: |
| db 'ST0=' |
| db 'ST1=' |
| 2701,6 → 2307,7 |
|---|
| db 'ST5=' |
| db 'ST6=' |
| db 'ST7=' |
| |
| mmx_strs: |
| db 'MM0=' |
| db 'MM1=' |
| 2813,6 → 2420,7 |
|---|
| cmdline_prev rb cmdline_width+1 |
| |
| was_temp_break db ? |
| symbol_section db ? |
| |
| dbgbufsize dd ? |
| dbgbuflen dd ? |