stack example

[sevilla-larry]

Existing issues

• I have searched the existing issues.

Affected document

https://github.com/0xAX/asm/blob/master/content/asm_3.md

Issue description

using a VM with Gentoo Linux
nasm 3.1
ld 2.46.0

Tried the stack.asm file.

---

1st trial (add .exe for VS code .gitignore purpose)
nasm -f elf64 -o stack.o stack.asm
ld -o stack.exe stack.o

./stack.exe
Error: expected two command-line arguments

./stack.exe 12 34
11429229181862520690

./stack.exe 5 10
11429229181862520690

---

2nd trial (as published)
nasm -f elf64 -o stack.o stack.asm
ld -o stack stack.o

./stack
Error: expected two command-line arguments

./stack 12 34
11733211430697485338

./stack 5 10
11733211430697485338

---

Attachments

No response

[0xAX]

hello @sevilla-larry, thank you for the report. Can you try this variant:

;; Definition of the .data section
section .data
        ;; Number of the `sys_write` system call
        SYS_WRITE equ 1
        ;; Number of the `sys_exit` system call
        SYS_EXIT equ 60
        ;; Number of the standard output file descriptor
        STD_OUT equ 1
        ;; Exit code from the program. The 0 status code is a success.
        EXIT_CODE equ 0
        ;; ASCII code of the new line symbol ('\n')
        NEW_LINE db 0xa
        ;; Error message that is printed in a case of not enough command-line arguments
        WRONG_ARGC_MSG  db "Error: expected two command-line arguments", 0xa
        ;; Length of the WRONG_ARGC_MSG message
        WRONG_ARGC_MSG_LEN equ 42

;; Define the .bss section for uninitialized data
section .bss
        ;; Buffer to store the result string (max 20 digits for 64-bit number)
        result_buffer resb 20

;; Definition of the .text section
section .text
        ;; Reference to the entry point of our program
        global _start

;; Entry point
_start:
        ;; Fetch the number of arguments from the stack and store it in the rcx register.
        pop rcx
        ;; Check the number of the given command-line arguments.
        cmp rcx, 3
        ;; If not enough, jump to the error subroutine.
        jne argcError

        ;; Skip the first command-line argument which is usually the program name.
        add rsp, 8

        ;; Fetch the first command-line argument from the stack and store it in the rsi register.
        pop rsi
        ;; Convert the first command-line argument to an integer number.
        call str_to_int
        ;; Store the result in the r10 register.
        mov r10, rax

        ;; Fetch the second command-line argument from the stack and store it in the rsi register.
        pop rsi
        ;; Convert the second command-line argument to an integer number.
        call str_to_int
        ;; Store the result in the r11 register.
        mov r11, rax

        ;; Calculate the sum of the arguments. The result will be stored in the r10 register.
        add r10, r11

        ;; Move the sum value to the rax register.
        mov rax, r10
        ;; Initialize counter by resetting it to 0. It will store the length of the result string.
        xor rcx, rcx
        ;; Convert the sum from a number to a string to print the result to the standard output.
        jmp int_to_str

;; Print the error message if not enough command-line arguments.
argcError:
        ;; Specify the system call number (1 is `sys_write`).
        mov rax, SYS_WRITE
        ;; Set the first argument of `sys_write` to 1 (`stdout`).
        mov rdi, STD_OUT
        ;; Set the second argument of `sys_write` to the reference of the `WRONG_ARGC_MSG` variable.
        mov rsi, WRONG_ARGC_MSG
        ;; Set the third argument to the length of the `WRONG_ARGC_MSG` variable's value.
        mov rdx, WRONG_ARGC_MSG_LEN
        ;; Call the `sys_write` system call.
        syscall
        ;; Go to the exit of the program.
        jmp exit

;; Convert the command-line argument to the integer number.
str_to_int:
        ;; Set the value of the rax register to 0. It will store the result.
        xor rax, rax
        ;; Base for multiplication
        mov rcx, 10
__repeat:
        ;; Compare the first element in the given string with the `NUL` terminator (end of the string).
        cmp [rsi], byte 0
        ;; If we reached the end of the string, return from the procedure. The result is stored in the rax register.
        je __return
        ;; Move the current character from the command-line argument to the bl register.
        mov bl, [rsi]
        ;; Subtract the value 48 from the ASCII code of the current character.
        ;; This will give us the numeric value of the character.
        sub bl, 48
        ;; Multiple our result number by 10 to get the place for the next digit.
        mul rcx
        ;; Add the next digit to our result number.
        add rax, rbx
        ;; Move to the next character in the command-line argument string.
        inc rsi
        ;; Repeat until we reach the end of the string.
        jmp __repeat
__return:
        ;; Return from the str_to_int procedure.
        ret

;; Convert the sum to a string and print it to the standard output.
int_to_str:
        ;; High part of the dividend. The low part is in the rax register.
        mov rdx, 0
        ;; Set the divisor to 10.
        mov rbx, 10
        ;; Divide the sum stored in `rax. The resulting quotient will be stored in `rax`,
        ;; and the remainder will be stored in the `rdx` register.
        div rbx
        ;; Add 48 to the remainder to get a string ASCII representation of the number value.
        add rdx, 48
        ;; Store the remainder on the stack.
        push rdx
        ;; Increase the counter.
        inc rcx
        ;; Compare the rest of the sum with zero.
        cmp rax, 0x0
        ;; If it is not zero, continue to convert it to string.
        jne int_to_str
        ;; Otherwise, prepare to print the result by copying from stack to buffer
        jmp copyToBuffer

;; Copy digits from stack to buffer in correct order
copyToBuffer:
        ;; rdi will point to our buffer
        lea rdi, [result_buffer]
        ;; rcx contains the number of digits
        mov r12, rcx
__copy_loop:
        ;; Pop a digit from the stack
        pop rax
        ;; Store only the low byte (the ASCII character) in the buffer
        mov [rdi], al
        ;; Move to the next position in the buffer
        inc rdi
        ;; Decrease the counter
        dec r12
        ;; Continue until all digits are copied
        jnz __copy_loop
        ;; Now print the result
        jmp printResult

;; Print the result to the standard output.
printResult:
        ;; Specify the system call number (1 is `sys_write`).
        mov rax, SYS_WRITE
        ;; Set the first argument of `sys_write` to 1 (`stdout`).
        mov rdi, STD_OUT
        ;; Set the second argument of `sys_write` to the reference of the result buffer.
        lea rsi, [result_buffer]
        ;; Set the third argument to the length (number of digits in rcx).
        mov rdx, rcx
        ;; Call the `sys_write` system call.
        syscall

        ;; Specify the system call number (1 is `sys_write`).
        mov rax, SYS_WRITE
        ;; Set the first argument of `sys_write` to 1 (`stdout`).
        mov rdi, STD_OUT
        ;; Set the second argument of `sys_write` to the reference of the `NWE_LINE` variable.
        mov rsi, NEW_LINE
        ;; Set the third argument to the length of the `NEW_LINE` variable's value (1 byte).
        mov rdx, 1
        ;; Call the `sys_write` system call.
        syscall

exit:
        ;; Specify the number of the system call (60 is `sys_exit`).
        mov rax, SYS_EXIT
        ;; Set the first argument of `sys_exit` to 0. The 0 status code is a success.
        mov rdi, EXIT_CODE
        ;; Call the `sys_exit` system call.
        syscall

[sevilla-larry]

Hi 0xAX,

tried but still NOT what is expected

./stack 5 10
16412878334445667354

[0xAX]

@sevilla-larry can you please add the xor rbx, rbx line to str_to_int:

str_to_int:
        ;; Set the value of the rax register to 0. It will store the result.
        xor rax, rax
        xor rbx, rbx

and retry?

Also if it does not help, it would be great if you can run the program in debugger:

gdb --args ./stack 11 12
The target architecture is set to "i386:x86-64".
Reading symbols from ./stack...
(gdb) break str_to_int 
Breakpoint 1 at 0x4000f5: file stack.asm, line 77.
(gdb) run
Starting program: /home/alex/dev/asm/stack/stack 11 12

Breakpoint 1, str_to_int () at stack.asm:77

(gdb) x/s $rsi
0x7fffffffe729:	"11"

[sevilla-larry]

Hi @0xAX ,

xor rbx,rbx did not help

gdb

Reading symbols from ./stack.exe...
(gdb) break str_to_int
Breakpoint 1 at 0x401048: file stack.asm, line 82.
(gdb) run
Starting program: /mnt/Dat/GitHub/asm-0xAX/Part1/stack.exe 11 12

Breakpoint 1, str_to_int () at stack.asm:82
82 xor rax, rax
(gdb) x/s $rsi
0x7fffffffe0c5: "11"

sorry, I added .exe above (for VS Code .gitignore)

stack (without .exe)

Reading symbols from ./stack...
(gdb) break str_to_int
Breakpoint 1 at 0x401048: file stack.asm, line 82.
(gdb) run
Starting program: /mnt/Dat/GitHub/asm-0xAX/Part1/stack 11 12

Breakpoint 1, str_to_int () at stack.asm:82
82 xor rax, rax
(gdb) x/s $rsi
0x7fffffffe0c9: "11"

[0xAX]

ok, so str_to_int points to arguments properly.

Can you please add str_to_int_result_1 and str_to_int_result_2 labels after the str_to_int calls:

        ;; Convert the first command-line argument to an integer number.
        call str_to_int
str_to_int_result_1:
        ;; Store the result in the r10 register.
        mov r10, rax

        ;; Fetch the second command-line argument from the stack and store it in the rsi register.
        pop rsi
        ;; Convert the second command-line argument to an integer number.
        call str_to_int
str_to_int_result_2:
        ;; Store the result in the r11 register.
        mov r11, rax

and run again it with gdb, but set breakpoints on these labels and int_to_str + show registers state after breakpoints are caught:

gdb --args ./stack 11 12
The target architecture is set to "i386:x86-64".
Reading symbols from ./stack...
(No debugging symbols found in ./stack)
(gdb) break str_to_int_result_1
Breakpoint 1 at 0x4000c1
(gdb) break str_to_int_result_2
Breakpoint 2 at 0x4000ca
(gdb) break int_to_str
Breakpoint 3 at 0x400113
(gdb) run
Starting program: /home/alex/dev/asm/stack/stack 11 12

Breakpoint 1, 0x00000000004000c1 in str_to_int_result_1 ()
(gdb) i r
rax            0xb                 11
rbx            0x1                 1
rcx            0xa                 10
rdx            0x0                 0
rsi            0x7fffffffe67d      140737488348797
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffe268      0x7fffffffe268
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x4000c1            0x4000c1 <str_to_int_result_1>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
fs_base        0x0                 0
gs_base        0x0                 0
(gdb) c
Continuing.

Breakpoint 2, 0x00000000004000ca in str_to_int_result_2 ()
(gdb) i r
rax            0xc                 12
rbx            0x2                 2
rcx            0xa                 10
rdx            0x0                 0
rsi            0x7fffffffe680      140737488348800
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffe270      0x7fffffffe270
r8             0x0                 0
r9             0x0                 0
r10            0xb                 11
r11            0x0                 0
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x4000ca            0x4000ca <str_to_int_result_2>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
fs_base        0x0                 0
gs_base        0x0                 0
(gdb) c
Continuing.

Breakpoint 3, 0x0000000000400113 in int_to_str ()
(gdb) i r
rax            0x17                23
rbx            0x2                 2
rcx            0x0                 0
rdx            0x0                 0
rsi            0x7fffffffe680      140737488348800
rdi            0x0                 0
rbp            0x0                 0x0
rsp            0x7fffffffe270      0x7fffffffe270
r8             0x0                 0
r9             0x0                 0
r10            0x17                23
r11            0xc                 12
r12            0x0                 0
r13            0x0                 0
r14            0x0                 0
r15            0x0                 0
rip            0x400113            0x400113 <int_to_str>
eflags         0x246               [ PF ZF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0
fs_base        0x0                 0
gs_base        0x0                 0

[sevilla-larry]

Hi @0xAX,

gdb --args ./stack 11 12
GNU gdb (Gentoo 17.1 vanilla) 17.1
...
Reading symbols from ./stack...
(gdb) break str_to_int_result_1
Breakpoint 1 at 0x401011: file stack.asm, line 46.
(gdb) break str_to_int_result_2
Breakpoint 2 at 0x40101a: file stack.asm, line 54.
(gdb) break int_to_str
Breakpoint 3 at 0x40106a: file stack.asm, line 113.
(gdb) run
Starting program: /mnt/Dat/GitHub/asm-0xAX/Part1/stack 11 12

Breakpoint 1, str_to_int_result_1 () at stack.asm:46
46 mov r10, rax
(gdb) i r
rax 0xcaf491aa4f8611cd -3822270023066054195
rbx 0x3b 59
rcx 0xa 10
rdx 0x8 8
rsi 0x7fffffffeff7 140737488351223
rdi 0x0 0
rbp 0x0 0x0
rsp 0x7fffffffdd58 0x7fffffffdd58
r8 0x0 0
r9 0x0 0
r10 0x0 0
r11 0x0 0
r12 0x0 0
r13 0x0 0
r14 0x0 0
r15 0x0 0
rip 0x401011 0x401011 <str_to_int_result_1>
eflags 0x246 [ PF ZF IF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
fs_base 0x0 0
gs_base 0x0 0
(gdb) c
Continuing.

Breakpoint 2, str_to_int_result_2 () at stack.asm:54
54 mov r11, rax
(gdb) i r
rax 0xcaf491aa4f8611cd -3822270023066054195
rbx 0x3b 59
rcx 0xa 10
rdx 0x8 8
rsi 0x7fffffffeff7 140737488351223
rdi 0x0 0
rbp 0x0 0x0
rsp 0x7fffffffdd60 0x7fffffffdd60
r8 0x0 0
r9 0x0 0
r10 0xcaf491aa4f8611cd -3822270023066054195
r11 0x0 0
r12 0x0 0
r13 0x0 0
r14 0x0 0
r15 0x0 0
rip 0x40101a 0x40101a <str_to_int_result_2>
eflags 0x246 [ PF ZF IF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
fs_base 0x0 0
gs_base 0x0 0
(gdb) c
Continuing.

Breakpoint 3, int_to_str () at stack.asm:113
113 mov rdx, 0
(gdb) i r
rax 0x95e923549f0c239a -7644540046132108390
rbx 0x3b 59
rcx 0x0 0
rdx 0x8 8
rsi 0x7fffffffeff7 140737488351223
rdi 0x0 0
rbp 0x0 0x0
rsp 0x7fffffffdd60 0x7fffffffdd60
r8 0x0 0
r9 0x0 0
r10 0x95e923549f0c239a -7644540046132108390
r11 0xcaf491aa4f8611cd -3822270023066054195
r12 0x0 0
r13 0x0 0
r14 0x0 0
r15 0x0 0
rip 0x40106a 0x40106a <int_to_str>
eflags 0x246 [ PF ZF IF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
fs_base 0x0 0
gs_base 0x0 0

[0xAX]

ok, something is broken within str_to_int. I will try to figure out tomorrow. Thank you for reporting!

[0xAX]

The value of rbx is weird here:

Breakpoint 1, str_to_int_result_1 () at stack.asm:46
46 mov r10, rax
(gdb) i r
rax 0xcaf491aa4f8611cd -3822270023066054195
rbx 0x3b 59

Can you please re-run in gdb with:

gdb --args ./stack 11 12
The target architecture is set to "i386:x86-64".
Reading symbols from ./stack...
(No debugging symbols found in ./stack)
(gdb) break __repeat
Breakpoint 1 at 0x4000fd
(gdb) run
Starting program: /home/alex/dev/asm/stack/stack 11 12

Breakpoint 1, 0x00000000004000fd in __repeat ()
(gdb) p/x $rbx
$1 = 0x0
(gdb) x/s $rsi
0x7fffffffe6ec:	"11"
(gdb) c
Continuing.

Breakpoint 1, 0x00000000004000fd in __repeat ()
(gdb) p/x $rbx
$2 = 0x1
(gdb) x/s $rsi
0x7fffffffe6ed:	"1"
(gdb) c
Continuing.

Breakpoint 1, 0x00000000004000fd in __repeat ()
(gdb) p/x $rbx
$3 = 0x1
(gdb) x/s $rsi
0x7fffffffe6ee:	""
(gdb) c
Continuing.

Breakpoint 1, 0x00000000004000fd in __repeat ()
(gdb) x/s $rsi
0x7fffffffe6ef:	"12"

[sevilla-larry]

hi @0xAX

gdb --args ./stack 11 12
GNU gdb (Gentoo 17.1 vanilla) 17.1
...
Reading symbols from ./stack...
(gdb) break __repeat
Breakpoint 1 at 0x401053: file stack.asm, line 90.
(gdb) run
Starting program: /mnt/Dat/GitHub/asm-0xAX/Part1/stack 11 12

Breakpoint 1, __repeat () at stack.asm:90
90 cmp [rsi], byte 0
(gdb) p/x $rbx
$1 = 0x0
(gdb) x/s $rsi
0x7fffffffe0c9: "11"
(gdb) c
Continuing.

Breakpoint 1, __repeat () at stack.asm:90
90 cmp [rsi], byte 0
(gdb) p/x $rbx
$2 = 0x1
(gdb) x/s $rsi
0x7fffffffe0ca: "1"
(gdb) c
Continuing.

Breakpoint 1, __repeat () at stack.asm:90
90 cmp [rsi], byte 0
(gdb) p/x $rbx
$3 = 0x1
(gdb) x/s $rsi
0x7fffffffe0cb: ""
(gdb) c
Continuing.

Breakpoint 1, __repeat () at stack.asm:90
90 cmp [rsi], byte 0
(gdb) x/s $rsi
0x7fffffffe0cc: "12"

[0xAX]

Thank you @sevilla-larry. I think I finally found it and reproduced with nasm 3. This:

cmp [rsi], byte 0,

generated word encoding, so 2 bytes were compared instead of one. If you will replace the cmp instruction within the __repeat with:

cmp byte [rsi], 0

it should work.

Can you please try?

[sevilla-larry]

Hi @0xAX,

now it works. thx.

./stack 11 12
23

[0xAX]

Thank you for reporting and help with debugging. Should be fixed now in #79