es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Añadiendo el valor del registro a la variable: error de segmentación NASM.

Básicamente estoy tratando de convertir los valores ASCII de una cadena (restando 48 si es un número y 55 si es una letra) y luego multiplicar esos valores y sumarlos. Está bien la parte de la multiplicación, pero cuando intento sumarlos a una variable “sum”, obtengo un error de segmentación. Aquí está el código:

section.data
    factor: dd 7,3,1,7,3,1,7,3,1
    sum: dd 0
    decNumFormat:
    db '%d', 10, 0
section.text
    main:
        mov eax, [esp+4]
        mov eax, [esp+8]
        mov ebx, [eax+4]  ; estas 3 líneas son para obtener la entrada del usuario

        mov ecx, dword[factor] ; factor es el valor con el que quiero multiplicar
        push ebx
        call checksum

    checksum:
        mov al, [ebx] ; obtener 1 byte de la entrada
        add ebx, 1
        sub al, 55 ; supongamos que es una letra
        movzx eax, al
        mul ecx
        mov ecx, 1 ; cambiar mi variable factor
        add [sum], eax ; aquí es donde obtengo el error de segmentación. También intenté con mov pero también me dio un error de segmentación.
        push dword [sum]
        push decNumFormat
        call printf ; solo estoy llamando a imprimir para ver si tengo un valor correcto, pero por supuesto no se imprime debido al error de segmentación
        mov al, [ebx]
        add ebx, 1
        sub al, 48 ; supongamos que es un número
        movzx eax, al
        mul ecx
        mov ecx, 1
        add [sum], eax
        ret

Hay muchas preguntas similares, lo sé, pero he intentado todo y realmente no puedo entender la razón del error de segmentación. El valor de mi eax hasta esa suma siempre es correcto, ya lo verifiqué. Es para Linux de 32 bits y mis comandos son:

nasm -f elf32 file.asm -o test.o
gcc test.o
./a.out A1 (cadena de entrada)
Tags:  , ,

Answer

  1. Avatar for davy.ai

    Al analizar el código, parece que el problema radica en el uso de la instrucción add en la variable [sum]. La instrucción add solo puede sumar a un registro o a la memoria, pero no a una dirección de memoria señalada por otro registro.

    Para solucionar esto, puedes primero mover el valor de [sum] a un registro, sumar el resultado de la multiplicación al registro, y luego mover ese valor de vuelta a la ubicación de memoria [sum].

    Aquí tienes una versión actualizada de la función checksum:

    checksum:
        mov al, [ebx]  ; para obtener 1 byte de la entrada
        add ebx, 1
        sub al, 55  ; asumir que es una letra
        movzx eax, al
        mul ecx
        mov ecx, 1  ; cambiar la variable de factor
        mov edx, [sum]  ; mover sum a edx
        add edx, eax  ; sumar eax a edx
        mov [sum], edx  ; mover el resultado de vuelta a sum
        push dword [sum]
        push decNumFormat
        call printf
        mov al, [ebx]
        add ebx, 1
        sub al, 48  ; asumir que es un número
        movzx eax, al
        mul ecx
        mov ecx, 1
        mov edx, [sum]
        add edx, eax
        mov [sum], edx
        ret 
    

    Esto debería solucionar el problema de violación de segmento al intentar sumar a la ubicación de memoria [sum].

Comments are closed.