linux x64加法程序

Question

I am making an addition program using x64 assembly, but it does not display a value when run (compiled with nasm, elf64).

section .text
global _start

_start:
mov rax, 0
add rax, [num1B]
add rax, [num2B]
mov [result], rax
mov rsi, [result]
;mov    rdx, 8  
mov rax, 4
mov rdi, 1
int 80h

mov rax, 1
mov rdi, 0
int 080h


section .data

num1B: dq 0Ah
num2B: dq 0Ah
result: dq 00h

Does anyone know why this is not displaying anything

Answer 1

1.later use printf instead of interrupts, much better, 2.why put values of numB1 and numB2 instead of their location. Use: mov rax, numB1. 3.in 64bit nasm assembly you use the: rdi, rsi, rbx, rcx,... Registers for putting in values for interrupts. For example:

mov rdi, 01
mov rsi, 00
syscall

1. DON't USE int0x80 !, for more-portability use syscall and besides int 0x80 didn't work on my system.

Hope it helps, Correct me if I'm wrong.

Answer 2

Looks like you want to print 'result' to stdout and you are using the 32-bit system call values.

In 64-bit linux the system call for write is 1 and you would write to stdout like this... att&t syntax: first strip values in %rax and push them byte by byte on stack, say %rax holds the value 0x7ffffff8:

mov $0xa, %rbx        # divisor

nibble:
xor %rdx, %rdx        # will hold bytes values you need
div %rbx, %rax
push %rdx             # save remainder
inc  %r8              # count digit, write seems to trash %rcx
cmp  $0,  %rax        # done?
jne  nibble           # no, get another digit

#set up for write to stdout

mov $1, %rax          # sys_call for write
mov $1, %rdi          # write to stdout
mov $result, %rsi     # addr. of value to print

# now get values from stack, make ascii and write to stdout

decimal:
pop %rdx              # get digit off stack
add $0x30, %dl        # make ascii printable
movb %dl, result      # load addr. with value
mov $1, %rdx          # print 1 byte
syscall

dec %r8
jnz decimal           # go till %r8 is zero 

You just need to set up a 1 byte data holder for digits,either in data section:

.section .data
    result:
    .byte 0             # reserves 1 byte and inits to 0

or the uninitialized data area:

.section .bss
    .lcomm result, 1    # reserves 1 byte 

I'm sure there are better ways to do this, should give you some ideas though.

Get a 64-bit system call list, they have changed quite a lot from the 32-bit calls.