Función en GAS retorna 65534 cuando multiplico 255 * 2 en Windows x64 por medio de GCC del compilador TDM-GCC 10.3.0

Question

Esté es el código de la función con .intel_syntax activado.

gnwmult8_32:
    movzbw ax, cl # Muevo el valor del registro cl al registro ax
    cbw           # Extiende el registro dl a 16 bits
    imul dl       # multiplico el valor de ax por dl y se vuelve a almacenar en ax
    ret           # fin de la función

Código en C

#include <stdio.h>
extern int __fastcall gnwmult8_32(int a, int b);
int main() {
    printf("%d", gnwmult8_32(255, 2));
    return 0;
}

Imprime 65534 cuando debería ser 510

El código funciona cuando agrego un movzbw bx, dl y multiplico los registros imul ax, bx

Se me hace raro que no haga lo mismo si se supone que extiendo dl a 16 bits con cbw

En cierto punto intente quitar cbw y el resultado era el mismo.

Intente ver el hexadecimal generado por "objdump" a través de hacer a mi archivo ASM y C archivos "obj" y combinandolos en uno solo con "ld.exe"

El desensamblado no funciono.

Luego intente usar "gbd" con el "GBD online Debugger | Compiler" y este fue lo que hice.

(Marqué imul dl como punto de quiebre)

(gdb) run
(gdb) info registers  # Verifica que ax contiene 0x00FF

(gdb) stepi  # Ejecutar imul dl
(gdb) info registers  # Verificar que ax contiene 0x01FE (510 en decimal)

El código era diferente, pero creo que en esencia lo mismo.

Código que use en GBD online.

.intel_syntax noprefix
.global main

main:
    mov cl, 255        # cl = 255
    mov dl, 2          # dl = 2
    movzbw ax, cl      # ax = 255 extendido a 16 bits
    imul dl            # ax = 255 * 2 = 510
    movzx rbx, ax        # Guardar el resultado en rbx
    mov rax, 60        # syscall: exit
    xor edi, edi       # status 0
    syscall

Después de ejecutar imul, rax debería ser 0x01FE pero es 0x55555555fffe.

Sé que rax no es lo mismo que ax pero al parecer a GBD online eso le da igual.

En ente punto no sé cual podría ser el error.

En caso de necesiten más información díganme.

Answer 1

imul es una multiplicación con signo, al utilizar registros de 8 bits estás multiplicando al * dl... al es 255 o -1 si lo consideras un entero de 1 byte con signo y por tanto el resutado es 0xfe o -2 (-1x2 = -2).

Simplemente utiliza más precisión para tu operación:

main:
    mov    cl, 255        # cl = 255
    mov    dx, 2          # dl = 2
    movzbw ax, cx         # 
    imul   dx             # ax = 255 * 2 = 510
    movzx  rbx, ax        # Guardar el resultado en rbx
    mov    rax, 60        # syscall: exit
    xor    edi, edi       # status 0
    syscall

Ten en cuenta que ahora el resultado de la multiplicación se almacenará en DX:AX si fuera superior a 16 bits. Para tu ejemplo el resultado cabe en AX.