Assembler program that prints an integer as hex to standard output

Question

I have to Write a nasm (or other) assembler program for an x86 processor that prints a 32-bit hexadecimal number on the standard output, such as printf("%x\n",123456), and use the write system call to display. I wrote some code but it seems to not work. Can comeone help me?

section .data
    message db '0x',0
    number dq 123456

section .text
    global _start

_start:
    ; Print "0x"
    mov eax, 4
    mov ebx, 1
    mov ecx, message
    mov edx, 2
    int 0x80

    ; Print number in hex
    mov eax, number
    push eax
    call print_hex
    add esp, 4

    ; Exit
    mov eax, 1
    xor ebx, ebx
    int 0x80

; Function to print number in hex
print_hex:
    push ebx
    push edx
    mov ebx, 16
    mov edx, 0
    mov ecx, 0

print_hex_loop:
    xor edx, edx
    div ebx
    add edx, '0'
    cmp edx, '9'
    jg print_hex_digit
    push edx
    inc ecx
    test eax, eax
    jne print_hex_loop

print_hex_done:
    mov eax, 4
    mov ebx, 1
    mov edx, ecx
    int 0x80

print_hex_pop_loop:
    pop edx
    mov [esp], edx
    inc esp
    dec ecx
    jne print_hex_pop_loop
    pop edx
    pop ebx
    ret

print_hex_digit:
    add edx, 'A' - '9' - 1
    jmp print_hex_done

I am new to assembler so I don't have many ideas how to get this to work properly

Answer 1

I assume the function takes an unsigned 32 bit number like below

void printhex( uint32_t number );

The idea here is to reserve the maximum length for a 32 bit integer (16 characters plus the null char at the end) and then start filling the hex number backwards.

Once the number becomes zero, we print and return.

/************ print 32-bit hexadecimal number ***********/
.globl  printhex
printhex:
        // On entry EDI contains number to be printed
        // We will print from the back to the front
        subq    $24, %rsp      // Reserve stack (multiple of 8)
        movb    $0, 18(%rsp)   // Set a null \0 at the end
        leaq    18(%rsp), %rax // ptr = pointer to that null
loop:
        movl    %edi, %esi     // Save number to ESI
        decq    %rax           // Decrement pointer
        movl    %edi, %edx     // Store number into EDX
        shrl    $4, %edi       // number = number / 16
        andl    $15, %edx      // digit = number % 16
        leal    87(%rdx), %ecx // hexdigit = digit + ('a'-10)
        cmpl    $9, %edx      // is digit > 10?
        ja      greater10
        leal    48(%rdx), %ecx // hexdigit = digit + '0'
greater10:
        movb    %cl, (%rax)    // *ptr = hexdigit
        cmpl    $15, %esi      // (saved) number > 15?
        ja      loop           // yes, loop back
                               // no, print and finish
        movb    $120,-1(%rax)  // store '0x'
        movb    $48,-2(%rax)
        leaq    -2(%rax), %rdi // 1st arg to puts = ptr
        call    puts           // print
        addq    $24, %rsp      // Restore stack
        ret                    // Return

The caller can be

.globl _start
_start:
        movl    $0x12abcdef, %edi  // 4660 = 0x1234
        call    printhex
        movq    $60, %rax    // Finish with syscall
        movl    $0,%edi
        syscall

Running it produces

$ gcc printhex.S -o printhex -nostartfiles
$ ./printhex
0x12abcdef