Foro de elhacker.net

Hola, soy nuevo por aquí y al estar investigando sobre nasm, encontré este foro
El caso es que estoy estudiando ingeniería en computación y me imparten una materia en la cual uso lenguaje ensamblador en nasm.
Estoy practicando con algunos ejercicios y tengo duda en como realizar uno.
Lo primero que debe hacerse es hacer, por ejemplo, mov eax, 1234ABCDh
Después de eso necesito crear una rutina que me imprima nibble, byte, word y dword
Con nibble debe salir D, byte debe salir CD, word debe salir ABCD y en dword debe salir 1234ABCD

Con la rutina que estaba creando solo puedo imprimir el nibble, de ahi en fuera me quede trabado en realizar lo demás, agradecería muchísimo el apoyo.

Entiendo que se deben usar corrimientos, rotaciones y así pero no estoy seguro como implementarlo.

Tengo unas rutinas creadas en clase que son printHex y printNumBase, la primera es para imprimir cualquier valor en hexadecimal y la segunda es para imprimir algun valor a hexadecimal, octal, binario, decimal dependiendo la base, esos los puse para tomarlos como referencia, la rutina que quiero usar es la de printHexx.

Puse también usar la librería porque para printNumBase se ocupa la librería pero con lo que estoy haciendo creo que no es muy necesario la librería.   

Este es mi código

%include "pc_io.inc"

section .data ; Datos inicializados
NL: db 13, 10
NL_L: equ $-NL
msg1: db "-----------PrintHex-------- "
msg1_L: equ $-msg1
msg2: db " Ejemplo 1: "
msg2_L: equ $-msg2
msg3: db " Ejemplo 2: "
msg3_L: equ $-msg3
msg4: db " Ejemplo 3: "
msg4_L: equ $-msg4
msg5: db " Ejemplo 4: "
msg5_L: equ $-msg5
orig: db " Original: "
orig_L: equ $-orig

section .bss ; Datos no inicializados
cadena resb 16
cad resb 16
cad1 resb 64
cad1_L equ $-cad1
A resb 64

section .text
global _start:

_start:


;-----inicio-----------
mov ecx, msg1
mov edx, msg1_L
call imprimir
call salto

mov ecx, orig
mov edx, orig_L
call imprimir

mov eax, 1234ABCDh
mov esi, cad
call printHex
call salto

mov ecx, msg2
mov edx, msg2_L
call imprimir

mov dword[A], eax
mov dl, 8
mov esi, cadena
call printHexx
call salto

;---------termino--------
mov eax, 1
mov ebx, 0
int 80h

salto:
push eax
push ebx
push ecx
push edx

mov eax, 4
mov ebx, 1
mov ecx, NL
mov edx, NL_L
int 80h

pop edx
pop ecx
pop ebx
pop eax
ret

imprimir:
push eax
push ebx
push ecx
push edx

mov eax, 4
mov ebx, 1
int 80h

pop edx
pop ecx
pop ebx
pop eax
ret

;printHex:
;pushad
;mov edx, eax
;mov ebx, 0fh
;mov cl, 28
;.nxt: shr eax,cl
;.msk: and eax,ebx
;cmp al, 9
;jbe .menor
;add al,7
;.menor:add al,'0'
;mov byte [esi],al
;inc esi
;mov eax, edx
;cmp cl, 0
;je .print
;sub cl, 4
;cmp cl, 0
;ja .nxt
;je .msk
;.print: mov eax, 4
;mov ebx, 1
;sub esi, 8
;mov ecx, esi
;mov edx, 8
;int 80h
;popad
;ret

printHexx:
pushad
and eax,0xf
cmp al,10
jb num
add al,7
shl al,cl
num:  add al,0x30    
call putchar
.print: mov eax, 4
mov ebx, 1
sub esi, 8
mov ecx, esi
mov edx, 8
int 80h
popad
ret


;printNumBase:
;pushad
;mov edi,0 ;usaremos como contador
;@@up:
;mov edx,0 ;para usar con EAX
;div ebx ;EAX = EDC:EAX/EBX ;EDX residuo
;cmp edx, 9
;jbe @@less
;add edx, 7
;@@less:
;add edx, 30h
;mov byte[esi + edi], DL
;inc edi
;cmp eax, 0
;je @@down
;jmp @@up
;@@down:
;mov eax,0h
;@@ciclo:
;dec edi
;mov AL, [esi+edi]
;cmp AL,0h
;je @@salir
;call putchar
;jmp @@ciclo
;@@salir:
;popad
;ret

Hola, no hace falta rotar bits, es solamente operaciones de and al registro eax:

(https://i.imgur.com/MBjrGrX.png)

#include <cstdio>
#include <cstdint>
 
extern "C" void printHex(uint32_t uiNumber)
{
    printf("%X\n", uiNumber);
}
 
int main(int argc, char*argv[])
{
    asm(
        "movl $0x1234ABCD, %eax;\r\n"
        "andl $0x0F, %eax;\r\n"
        "pushl %eax;\r\n"
        "call printHex;\r\n"
        "addl $0x04, %esp;\r\n"
 
        "movl $0x1234ABCD, %eax;\r\n"
        "andl $0xFF, %eax;\r\n"
        "pushl %eax;\r\n"
        "call printHex;\r\n"
        "addl $0x04, %esp;\r\n"
 
        "movl $0x1234ABCD, %eax;\r\n"
        "andl $0xFFFF, %eax;\r\n"
        "pushl %eax;\r\n"
        "call printHex;\r\n"
        "addl $0x04, %esp;\r\n"
 
        "movl $0x1234ABCD, %eax;\r\n"
        "pushl %eax;\r\n"
        "call printHex;\r\n"
        "addl $0x04, %esp;\r\n"
    );
 
    return 0;
}

B#

Una disculpa por responder hasta ahorita, la verdad no lo había pensado así y creo que me lo estaba complicando mas de lo que parece, te agradezco mucho que hayas respondido y por tu ayuda!