Flujo de la función de ensamblaje

Question

Estoy leyendo una "programación desde cero", si no sabes qué es este libro, todavía puedes ayudarme.

En este libro (Capítulo 4) hay 2 cosas que no entiendo:

1. qué movl %ebx, -4(%ebp) #store current result por.
2. ¿Y qué significa "resultado actual"?

En la sección marcada en el código a continuación, hay:

movl 8(%ebp), %ebx

lo que significa salvar 8(%ebp) a %ebx, pero la razón por la que no entiendo es que el programador quiere 8(%ebp) Para ahorrar -4(%ebp), porque deberia 8(%ebp) pasar %ebx? Es "movl 8(%ebp), -4(%ebp)"¿Akward? ¿O hay algún error tipográfico en movl 8(%ebp), %ebx #put first argument in %eax? (Pienso %ebx debiera ser %eax o viceversa)

#PURPOSE: Program to illustrate how functions work
# This program will compute the value of
# 2^3 + 5^2
#Everything in the main program is stored in registers,
#so the data section doesn’t have anything.

.section .data
.section .text
.globl _start

_start:

pushl $3 #push second argument
pushl $2 #push first argument
call power #call the function
addl $8, %esp #move the stack pointer back
pushl %eax #save the first answer before

#calling the next function

pushl $2 #push second argument
pushl $5 #push first argument

call power #call the function
addl $8, %esp #move the stack pointer back
popl %ebx #The second answer is already

#in %eax. We saved the
#first answer onto the stack,
#so now we can just pop it
#out into %ebx

addl %eax, %ebx #add them together
#the result is in %ebx

movl $1, %eax #exit (%ebx is returned)
int $0x80

#PURPOSE: This function is used to compute
# the value of a number raised to
# a power.

#INPUT: First argument - the base number
# Second argument - the power to
# raise it to
#
#OUTPUT: Will give the result as a return value
#
#NOTES: The power must be 1 or greater
#
#VARIABLES:
# %ebx - holds the base number
# %ecx - holds the power
#
# -4(%ebp) - holds the current result
#
# %eax is used for temporary storage
#

.type power, @function
power:
pushl %ebp #save old base pointer
movl %esp, %ebp #make stack pointer the base pointer
subl $4, %esp #get room for our local storage
##########################################

movl 8(%ebp), %ebx #put first argument in %eax
movl 12(%ebp), %ecx #put second argument in %ecx
movl %ebx, -4(%ebp) #store current result

##########################################

power_loop_start:
cmpl $1, %ecx #if the power is 1, we are done
je end_power
movl -4(%ebp), %eax #move the current result into %eax
imull %ebx, %eax #multiply the current result by

#the base number
movl %eax, -4(%ebp) #store the current result
decl %ecx #decrease the power
jmp power_loop_start #run for the next power

end_power:
movl -4(%ebp), %eax #return value goes in %eax
movl %ebp, %esp #restore the stack pointer
popl %ebp #restore the base pointer
ret

Answer 1

Creo que esto:

 movl 8(%ebp), %ebx #put first argument in %eax  

era un error tipográfico, y realmente debería ser:

 movl 8(%ebp), %ebx #put first argument in %ebx  

Y si notó, más tarde el código es correcto:

 movl %ebx, -4(%ebp) #store current result

Al final, el autor podría haber usado %eax para esta operación también (en lugar de %ebx), no hay ninguna razón por la que no debería hacerlo, ya que no cambiaría el programa en absoluto.

Pero el comentario podría ser mucho más claro y creo que este es un error tipográfico también. En este punto, sería mejor si dijera: #storing 1st argument on the local stack frame.

etiqueta power_loop_start utiliza esa variable y la almacena temporalmente en %eax Para operaciones rápidas y luego vuelva a colocarlo en la misma ubicación en la pila para el siguiente bucle:

 movl %eax, -4(%ebp)   #store the current result
 decl %ecx             #decrease the power
 jmp  power_loop_start #run for the next power

Answer 2

Muchos códigos de operación de ensamblaje solo aceptan una Operando de memoria (ya sea fuente o destino). Esto probablemente explica por qué un movimiento de la memoria a la memoria se realiza a través de %EBX.

Answer 3

Como Gregón Consejo, x86, como la mayoría de las arquitecturas convencionales, no tiene una instrucción que copie datos de la memoria a la memoria [1]. Por lo tanto, debe copiar datos utilizando un carga y Tienda. Primero, carga los datos de la memoria fuente en un registro, luego almacena los datos de ese registro a la memoria de destino. Eso es todo lo que está sucediendo aquí.

1] Lo sé, lo sé, pero vamos a ir rep movs Fuera de esto y mantenga las cosas simples.