Сборка x86 читает целые числа в массиве структуры, затем печатает

Question

Я должен прочитать 10 дюймов, сохранить их как точки x и y в структуре, а затем распечатать их. ESI не увеличивается правильно в моем цикле ввода. Когда я помещаю значения в структуру в коде, они печатаются правильно, когда я использую цикл ввода, я получаю:

What are the x and y values for the points?
1
2
3
4
5
6
7
8
9
0
The point coordinates are 
134520936
134520940
134520936
134520940
134520936
134520940
134520936
134520940
134520936
134520940

Мне нужно освоить GDB, но инструктор даже не коснулся этого в курсе, который я беру.

В любом случае, кажется, что два адреса памяти, один для x и один для y, снова и снова сохраняются в массиве struc и затем печатаются. Я пробовал extern C printf вместо функции printDec, и я получаю тот же вывод. Можете ли вы понять, почему адрес вместо целого числа входит в мои точечные переменные? Знаете ли вы, если scanf изменяет регистр esi?

STRUC Point ;define a point structure
.x RESD 1   ;reserve 4 bytes for x coordinate
.y RESD 1   ;reserve 4 bytes for y coordinate
.size:
ENDSTRUC

section .data   ;data section

msgPt: db "What are the x and y values for the points?", 10, 0
msgPtL: equ $-msgPt

msg2: db"The point coordinates are ", 10  ,0
msgL2: equ $-msg2

formatPointScan: db "%d", 0

xVal: dd 0
yVal: dd 0

loopCount: dd 0

section .bss    ;bss section

PtArr: RESB Point.size*5    ;reserver place for 5 structures
;PtArr points to the start of array
ArrCount: EQU($ - PtArr)/Point.size ;should be 5


section .text

extern scanf

global main
main:
    push ebp
    mov ebp, esp

   mov ecx, msgPt
   mov edx, msgPtL
   call PString

    mov dword[loopCount], ArrCount  ;ecx has the number of array elements
    mov esi, PtArr  ;esi contains address of first struct in array

getPointsLoop:
    push xVal
    push formatPointScan
    call scanf
    mov dword[esi + Point.x], xVal  

    push yVal
    push formatPointScan
    call scanf
    mov dword[esi + Point.y], yVal
    add esi, Point.size
    dec dword[loopCount]
    cmp dword[loopCount], 0
jne getPointsLoop

    mov ecx, msg2
    mov edx, msgL2
    call PString
    mov dword[loopCount], ArrCount ;set ecx to num of array elements
    mov esi, PtArr  ;point esi to 1st element of array

printPointsLoop:
    mov eax, [esi + Point.x]    ;indirect access to x value
    call printDec
    call println

    mov eax, [esi + Point.y]    ;indirect access to y value
    call printDec
    call println

    add esi, Point.size
    dec dword[loopCount]
    cmp dword[loopCount], 0
jne printPointsLoop

    ;exit program and cleaning
    mov esp, ebp
    pop ebp
    ret

PString:; save register values of the called function
    pusha
    mov eax,4 ; use 'write' system call = 4
    mov ebx,1 ; file descriptor 1 = STDOUT
    int 80h ; call the kernel

    ; restore the old register values of the called function
    popa
    ret

println:
    ;will call PString func
    ;will change content of ecx and edx
    ;need to save registers used by the main program
    section .data
    nl db 10
    section .text
    pusha

    mov ecx, nl
    mov edx, 1
    call PString

    ;return original register values
    popa
    ret

printDec:
;saves all registers so they return unmodified
;build the function to handle dword size

    section .bss
    decstr resb 10 ; 10 32-bit digits
    ct1 resd 1 ;keep track of dec-string size

    section .text
    pusha; save registers

    mov dword[ct1],0 ;initially assume 0
    mov edi, decstr ; edi points to dec-string
    add edi, 9 ; moved to the last element of string
    xor edx, edx ; clear edx for 64-bit div
whileNotZero:
    mov ebx, 10 ; get ready to divide by 10
    div ebx ; divide by 10
    add edx, '0' ; convert to ascii
    mov byte[edi], dl ; put it in string
    dec edi ; move to next char in str
    inc dword[ct1] ; inc char counter
    xor edx, edx ; clear edx
    cmp eax, 0  ;is remainder 0?
    jne whileNotZero ;if no, keep on looping

    inc edi ; conversion finished, bring edi
    mov ecx, edi ; back to start of string. make ecx
    mov edx, [ct1] ; point to counterm edx gets # chars
    mov eax, 4 ; print to stdout
    mov ebx, 1
    int 0x80 ; call kernel

    popa ; restore registers
    ret

Answer 1

mov dword[esi + Point.x], xVal - это mov-немедленный адрес. Вы заполняете свой массив копиями адреса статического хранилища, которое вы передаете scanf, а не значением scanf, хранящимся там.

mov [mem], [mem] недопустимо, поэтому вам нужно загрузить во временный регистр, чтобы скопировать его в другое место с помощью mov.

Или, лучше, сначала передать scanf правильный адрес.Единственная причина, по которой ваш xVal вообще существует - это пустое пространство для scanf, которое совершенно не нужно.(Как и в большинстве остальных ваших статических хранилищ, где вы можете просто использовать регистры.)

section .rodata
fmt_2int: db "%d %d", 0

section .text

lea   eax, [esi + Point.y]
push  eax
push  esi         ; no LEA needed, Point.x = 0
push  fmt_2int
call  scanf        ; eax = scanf("%d %d", &arr[i].x, &arr[i].y);

add   esp, 12     ; pop args

Или вы можете хранить аргументы с помощью mov и оставить для них место в стеке по всему циклу вместо нажатия иpopping.

---

Обратите внимание, что esi, edi, и ebx сохраняются в соответствии с соглашением о вызовах i386 System V вместе с ebp и esp.Ваш main не сохраняет значения вызывающего из этих регистров.И это иронично, потому что вы используете супер-медленные pusha / popa в функциях, которые вы вызываете из main, но которые только заглушают несколько регистров, которые main не нуждаются в них для сохранения.

Обычные библиотечные функции будут блокировать EAX, ECX и EDX, поэтому имеет смысл использовать это соглашение о вызовах.(Передача аргументов в регистры, как вы делаете, хорошо, хотя; стандартное 32-битное соглашение о вызовах, которое передает аргументы в стеке, устарело и неэффективно.)

Системные вызовы, сделанные с помощью int 0x80, сохраняют все регистры(кроме EAX, который получает возвращаемое значение).

Вам не нужна отдельная функция println: ваш printDec может напечатать новую строку в конце числа.