У меня проблема с простым массивом в сборке. Это правильный подход. Мне нужно заполнить массив последовательными числами, в данном случае это 10. Код следующим образом:

section .data
array TIMES 10 db 0

section .text
global _start
_start:
mov eax,10  ;counter
mov ebx,0   ;start from value 0
mov ecx,array;

loop:   
mov [ecx],ebx
inc ecx     ;increase pointer to next array element
inc ebx     ;increase inputted value
dec eax     ;decrease iterator
jnz loop    ;if iterator not 0 loop

mov eax,1   ;eit
int 0x80

Это правильный код?

Во время отладки с использованием gdb . Точка останова на линии 11 (5 петель) показывает следующие выходы:

$1: $eax = 4
$2: $ebx = 6
$3: $ecx = 134516902

x/d $ecx-1   0x80490a5:   5

Как я могу искать значения из всего массива? Только это место во мне $ ecx-1 показывает правильное значение введенного числа. Я почти уверен, что проблема в моем коде.

С уважением

1
jadupl 31 Мар 2017 в 00:29

2 ответа

Лучший ответ

Извините, я до сих пор не осознавал, что мой последний ответ был не тем, что вы просили. Предполагает размер байта элементов.

section .bss                                                                                                                                                            
        array:   resb 10                                                                                                                                                
section .data                                                                                                                                                           

section .text                                                                                                                                                           
        global _start                                                                                                                                                   
_start:                                                                                                                                                                 
        lea edi, [array]    ; pointer                                                                                                                                             
        mov ecx, 0   ; element counter                                                                                                                                                   
        mov eax, 1   ; starting number                                                                                                                                                   
loop:                                                                                                                                                                   
        mov [edi+ecx], eax   ; mov n to array element x                                                                                                                                           

        add ecx, 1                                                                                                                                                      
        add eax, 1                                                                                                                                                      
        cmp eax, 10                                                                                                                                                     
        jl loop                                                                                                                                                         

_exit:                                                                                                                                                                  
        mov eax,1   

Вывод: (gdb) x / 8b & array

0x80490a8 <array>:      1       2       3       4       5       6       0       0
21              cmp eax, 10
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       0       0
22              jl loop
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       0       0
17              mov [esi+ecx], eax
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       0
19              add ecx, 1
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       0
20              add eax, 1
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       0
21              cmp eax, 10
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       0
22              jl loop
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       0
17              mov [esi+ecx], eax
(gdb) 
0x80490a8 <array>:      1       2       3       4       5       6       7       8
1
InfinitelyManic 31 Мар 2017 в 15:16

Есть несколько способов подойти к этому. В приведенном ниже примере мы используем инструкцию lodsb (строка загрузки размера байта) для извлечения значений из массива элементов размера байта. Я не предполагаю, что это самый эффективный метод.

  1 section .data
  2         array  db       3,1,4,1,5,9,2,6,5
  3         len.array equ   $-array
  4
  5 section .text
  6         global _start
  7 _start:
  8         lea esi, [array]  ; load array pointer
  9         mov ecx, len.array  ; use length of array as counter
 10 loop:
 11         lodsb        ; load string byte - will place loads in al;
 12         dec ecx      ; decrements ecx 
 13         cmp ecx, 0   ; 
 14         jnz loop
 15
 16 _exit:
 17
 18         mov eax,1   ;exit
 19         int 0x80

(gdb) отображать $ ax; вы можете видеть, что топор заполняется элементами массива, когда вы шагаете по коду.

12              dec ecx
1: $ax = 3
(gdb)
13              cmp ecx, 0
1: $ax = 3
(gdb)
14              jnz loop
1: $ax = 3
(gdb)
11              lodsb
1: $ax = 3
(gdb)
12              dec ecx
1: $ax = 1
(gdb)
13              cmp ecx, 0
1: $ax = 1
(gdb)
14              jnz loop
1: $ax = 1
(gdb)
11              lodsb
1: $ax = 1
(gdb)
12              dec ecx
1: $ax = 4
(gdb)
13              cmp ecx, 0
1: $ax = 4
(gdb)
14              jnz loop
1: $ax = 4
(gdb)
11              lodsb
1: $ax = 4
2
InfinitelyManic 30 Мар 2017 в 22:12