Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4885 → Rev 4886

/programs/develop/mtdbg/symbols.inc
0,0 → 1,452
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;; Working with program symbols ;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
include 'sort.inc'
 
; compare proc for sorter
compare:
cmpsd
jnz @f
cmp esi, edi
 
@@:
ret
 
; compare proc for sorter 2
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:
; esi = ptr to symbols filename
xor edi, edi
cmp [num_symbols], edi ; Any previously loaded symbols?
je .loadfile
call free_symbols ; Yep, free them
 
.loadfile:
mov ebx, fn70_attr_block ; Get file attributes
mov [ebx+21], esi
mcall 70
test eax, eax
jnz .fileerr
cmp dword [fileattr+36], edi ; Is upper dword of filesize larger then 0?
jnz .memerr
mov ecx, dword [fileattr+32] ; Lower dword of filesize
mcall 68, 12 ; allocate the memory
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 ; Read the file into the allocated buffer
test eax, eax
jnz .fileerr
 
 
; calculate memory requirements to load debug symbols
 
lea edx, [ecx+edi-1] ; edx = EOF-1
mov esi, edi
xor ecx, ecx
 
mov [symbol_section], 1 ;;;;;
 
.calcloop:
cmp esi, edx
jae .calcdone
cmp byte[esi], ' ' ; skip spaces at the beginning of a line
jne .not_space
inc esi
jmp .calcloop
.not_space:
cmp byte[esi], '.'
jne .not_section
inc esi
mov [symbol_section], 0
cmp dword[esi], 'text'
jne .skipline
inc [symbol_section]
jmp .skipline
.not_section:
cmp [symbol_section], 0
je .skipline
 
cmp word[esi], '0x'
jne .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
je @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:
 
; Allocate memory to place the debug symbols in
 
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]
 
; Actual loading of the debug symbols
; esi->input, edx->EOF, ebx->ptrs, edi->names
 
mov [symbol_section], 1 ;;;;;
 
.readloop:
cmp esi, edx
jae .readdone
cmp byte[esi], ' '
jne .not_space2
inc esi
jmp .readloop
.not_space2:
cmp byte[esi], '.'
jne .not_section2
inc esi
mov [symbol_section], 0
cmp dword[esi], 'text'
jne .readline
inc [symbol_section]
jmp .readline
.not_section2:
cmp [symbol_section], 0
je .readline
 
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