Bdtjtk

You have to convert it in a string; if you're talking about hex numbers it's pretty easy. Any number can be represented this way:

0xa31f = 0xf * 16^0 + 0x1 * 16^1 + 3 * 16^2 + 0xa * 16^3

So when you have this number you have to split it like I've shown then convert every "section" to its ASCII equivalent.

Getting the four parts is easily done with some bit magic, in particular with a right shift to move the part we're interested in in the first four bits then AND the result with 0xf to isolate it from the rest. Here's what I mean (soppose we want to take the 3):

0xa31f -> shift right by 8 = 0x00a3 -> AND with 0xf = 0x0003

Now that we have a single number we have to convert it into its ASCII value. If the number is smaller or equal than 9 we can just add 0's ASCII value (0x30), if it's greater than 9 we have to use a's ASCII value (0x61).

Here it is, now we just have to code it:

    mov si, ???         ; si points to the target buffer

    mov ax, 0a31fh      ; ax contains the number we want to convert

    mov bx, ax          ; store a copy in bx

    xor dx, dx          ; dx will contain the result

    mov cx, 3           ; cx's our counter



convert_loop:

    mov ax, bx          ; load the number into ax

    and ax, 0fh         ; we want the first 4 bits

    cmp ax, 9h          ; check what we should add

    ja  greater_than_9

    add ax, 30h         ; 0x30 ('0')

    jmp converted



greater_than_9:

    add ax, 61h         ; or 0x61 ('a')



converted:

    xchg    al, ah      ; put a null terminator after it

    mov [si], ax        ; (will be overwritten unless this

    inc si              ; is the last one)



    shr bx, 4           ; get the next part

    dec cx              ; one less to do

    jnz convert_loop



    sub di, 4           ; di still points to the target buffer

PS: I know this is 16 bit code but I still use the old TASM :P

PPS: this is Intel syntax, converting to AT&T syntax isn't difficult though, look here.

Linux x86-64 with printf

extern printf, exit

section .data

    format db "%x", 10, 0

section .text

    global main

    main:

        sub rsp, 8

        mov rsi, 0x12345678

        mov rdi, format

        xor rax, rax

        call printf

        mov rdi, 0

        call exit

Then:

nasm -f elf64 main.asm

gcc main.o

./a.out

The "hard points" of the System V AMD64 ABI calling convention:

• 
  sub rsp, 8: How to write assembly language hello world program for 64 bit Mac OS X using printf?
  


• 
  mov rax, 1: Why is %eax zeroed before a call to printf?
  

If you want hex without the C library: https://stackoverflow.com/a/32756303/895245

It depends on the architecture/environment you are using.

For instance, if I want to display a number on linux, the ASM code will be different from the one I would use on windows.

Edit:

You can refer to THIS for an example of conversion.

I'm relatively new to assembly, and this obviously is not the best solution,
but it's working. The main function is _iprint, it first checks whether the
number in eax is negative, and prints a minus sign if so, than it proceeds
by printing the individual numbers by calling the function _dprint for
every digit. The idea is the following, if we have 512 than it is equal to: 512 = (5 * 10 + 1) * 10 + 2 = Q * 10 + R, so we can found the last digit of a number by dividing it by 10, and
getting the reminder R, but if we do it in a loop than digits will be in a
reverse order, so we use the stack for pushing them, and after that when
writing them to stdout they are popped out in right order.

; Build        : nasm -f elf -o baz.o baz.asm

;                ld -m elf_i386 -o baz baz.o

section .bss

c: resb 1 ; character buffer

section .data

section .text

; writes an ascii character from eax to stdout

_cprint:

    pushad        ; push registers

    mov [c], eax  ; store ascii value at c

    mov eax, 0x04 ; sys_write

    mov ebx, 1    ; stdout

    mov ecx, c    ; copy c to ecx

    mov edx, 1    ; one character

    int 0x80      ; syscall

    popad         ; pop registers

    ret           ; bye

; writes a digit stored in eax to stdout 

_dprint:

    pushad        ; push registers

    add eax, '0'  ; get digit's ascii code

    mov [c], eax  ; store it at c

    mov eax, 0x04 ; sys_write

    mov ebx, 1    ; stdout

    mov ecx, c    ; pass the address of c to ecx

    mov edx, 1    ; one character

    int 0x80      ; syscall

    popad         ; pop registers

    ret           ; bye

; now lets try to write a function which will write an integer

; number stored in eax in decimal at stdout

_iprint:

    pushad       ; push registers

    cmp eax, 0   ; check if eax is negative

    jge Pos      ; if not proceed in the usual manner

    push eax     ; store eax

    mov eax, '-' ; print minus sign

    call _cprint ; call character printing function 

    pop eax      ; restore eax

    neg eax      ; make eax positive

Pos:

    mov ebx, 10 ; base

    mov ecx, 1  ; number of digits counter

Cycle1:

    mov edx, 0  ; set edx to zero before dividing otherwise the

    ; program gives an error: SIGFPE arithmetic exception

    div ebx     ; divide eax with ebx now eax holds the

    ; quotent and edx the reminder

    push edx    ; digits we have to write are in reverse order

    cmp eax, 0  ; exit loop condition

    jz EndLoop1 ; we are done

    inc ecx     ; increment number of digits counter

    jmp Cycle1  ; loop back

EndLoop1:

; write the integer digits by poping them out from the stack

Cycle2:

    pop eax      ; pop up the digits we have stored

    call _dprint ; and print them to stdout

    dec ecx      ; decrement number of digits counter

    jz EndLoop2  ; if it's zero we are done

    jmp Cycle2   ; loop back

EndLoop2:   

    popad ; pop registers

    ret   ; bye

global _start

_start:

    nop           ; gdb break point

    mov eax, -345 ;

    call _iprint  ; 

    mov eax, 0x01 ; sys_exit

    mov ebx, 0    ; error code

    int 0x80      ; край

Because you didn't say about number representation I wrote the following code for unsigned number with any base(of course not too big), so you could use it:

BITS 32

global _start



section .text

_start:



mov eax, 762002099 ; unsigned number to print

mov ebx, 36        ; base to represent the number, do not set it too big

call print



;exit

mov eax, 1

xor ebx, ebx

int 0x80



print:

mov ecx, esp

sub esp, 36   ; reserve space for the number string, for base-2 it takes 33 bytes with new line, aligned by 4 bytes it takes 36 bytes.



mov edi, 1

dec ecx

mov [ecx], byte 10



print_loop:



xor edx, edx

div ebx

cmp dl, 9     ; if reminder>9 go to use_letter

jg use_letter



add dl, '0'

jmp after_use_letter



use_letter:

add dl, 'W'   ; letters from 'a' to ... in ascii code



after_use_letter:

dec ecx

inc edi

mov [ecx],dl

test eax, eax

jnz print_loop



; system call to print, ecx is a pointer on the string

mov eax, 4    ; system call number (sys_write)

mov ebx, 1    ; file descriptor (stdout)

mov edx, edi  ; length of the string

int 0x80



add esp, 36   ; release space for the number string



ret

It's not optimised for numbers with base of power of two and doesn't use printf from libc.

The function print outputs the number with a new line. The number string is formed on stack. Compile by nasm.

Output:

clockz

https://github.com/tigertv/stackoverflow-answers/tree/master/8194141-how-to-print-a-number-in-assembly-nasm