x86-64位汇编Linux输入

Question

我正在尝试输入我的程序...它所做的全部工作并在屏幕上打印一个“ 0”。 我很确定PRINTDECI函数可以工作，我前一阵子就可以了。 我是否只需要遍历输入代码并仅在输入特定值时退出？ 我不确定该怎么做...除非是通过ACSII值吸收的。...无论如何，这是我的代码（Yasm（nasm克隆），Intel语法）：

GLOBAL _start
SECTION .text

PRINTDECI:
 LEA R9,[NUMBER + 18]       ; last character of buffer
 MOV R10,R9                 ; copy the last character address
 MOV RBX,10                 ; base10 divisor

 DIV_BY_10:

 XOR RDX,RDX                ; zero rdx for div
 DIV RBX                    ; rax:rdx = rax / rbx
 ADD RDX,0x30               ; convert binary digit to ascii
 TEST RAX,RAX               ; if rax == 0 exit DIV_BY_10
 JZ CHECK_BUFFER
 MOV byte [R9],DL           ; save remainder
 SUB R9,1                   ; decrement the buffer address
 JMP DIV_BY_10

 CHECK_BUFFER:

 MOV byte [R9],DL
 SUB R9,1

 CMP R9,R10                 ; if the buffer has data print it
 JNE PRINT_BUFFER 
 MOV byte [R9],'0'          ; place the default zero into the empty buffer
 SUB R9,1

 PRINT_BUFFER:

 ADD R9,1                   ; address of last digit saved to buffer
 SUB R10,R9                 ; end address minus start address
 ADD R10,1                  ; R10 = length of number
 MOV RAX,1                  ; NR_write
 MOV RDI,1                  ; stdout
 MOV RSI,R9                 ; number buffer address
 MOV RDX,R10                ; string length
 SYSCALL
RET

_start:
 MOV RCX, SCORE     ;Input into Score
 MOV RDX, SCORELEN
 MOV RAX, 3
 MOV RBX, 0
 SYSCALL

 MOV RAX, [SCORE]
 PUSH RAX           ;Print Score
  CALL PRINTDECI
 POP RAX

 MOV RAX,60         ;Kill the Code
 MOV RDI,0
 SYSCALL

SECTION .bss
 SCORE:         RESQ 1
 SCORELEN EQU $-SCORE

谢谢你的帮助！ -凯尔

附带说明一下，RCX中的指针根据DDD指向了一个非常大的数字……所以我想我必须让它暂停并等待我键入，但是我不知道该怎么做。 ..

Answer 1

在x86_64系统上调用syscall 0 （READ）的“设置”为：

@xenon:~$ syscalls_lookup read
read:
        rax = 0  (0x0)
        rdi = unsigned int fd
        rsi = char *buf
        rdx = size_t count

因此，您的_start代码应类似于：

_start:
    mov  rax, 0         ; READ
    mov  rdi, 0         ; stdin
    mov  rsi, SCORE     ; buffer
    mov  rdx, SCORELEN  ; length
    syscall

x86_64的寄存器约定和系统调用号与i386 完全不同。

您似乎遇到的一些概念性问题：

• READ不会对您键入的内容进行任何解释，您似乎希望它可以键入数字（例如57），并使其返回值57。不。 它将返回“ 5”，“ 7”，“ ENTER”，“垃圾” ...您的SCORELEN可能为8（resq 1的长度），因此您将以8个字节的速度读取。 或字符，如果您想称呼他们。 而且，除非您键入EOF字符（^ D），否则您将需要键入这8个字符，然后READ调用才能返回您的代码。

• 您必须将接收到的字符转换为值...您可以通过简单的方法进行操作，并与C库中的ATOI（）链接，或者编写自己的解析器以通过加法和乘法将字符转换为值（不难，请参见下面的代码）。

在下面用作参考：

@xenon:~$ syscalls_lookup write
write:
        rax = 1  (0x1)
        rdi = unsigned int fd
        rsi = const char *buf
        rdx = size_t count

嗯...。这么多...我将重写位：

    global _start
    section .text

PRINTDECI:
; input is in RAX
    lea  r9, [NUMBER + NUMBERLEN - 1 ]  ; + space for \n
    mov  r10, r9            ; save end position for later
    mov  [r9], '\n'         ; store \n at end
    dec  r9
    mov  rbx, 10            ; base10 divisor

DIV_BY_10:
    xor  rdx, rdx       ; zero rdx for div
    div  rbx            : rax = rdx:rax / rbx, rdx = remainder
    or   dl, 0x30       ; make REMAINDER a digit
    mov  [r9], dl
    dec  r9
    or   rax, rax
    jnz  DIV_BY_10

PRINT_BUFFER:
    sub  r10, r9        ; get length (r10 - r9)
    inc  r9             ; make r9 point to initial character
    mov  rax, 1         ; WRITE (1)
    mov  rdi, 1         ; stdout
    mov  rsi, r9        ; first character in buffer
    mov  rdx, r10       ; length
    syscall
    ret

MAKEVALUE:
; RAX points to buffer
    mov  r9, rax        ; save pointer
    xor  rcx, rcx       ; zero value storage

MAKELOOP:
    mov  al, [r9]       ; get a character
    or   al, al         ; set flags
    jz   MAKEDONE       ; zero byte? we're done!
    and  rax, 0x0f      ; strip off high nybble and zero rest of RAX (we're lazy!)
    add  rcx, rcx       ; value = value * 2
    mov  rdx, rcx       ; save it
    add  rcx, rcx       ; value = value * 4
    add  rcx, rcx       ; value = value * 8
    add  rcx, rdx       ; value = value * 8 + value * 2 (== value * 10)
    add  rcx, rax       ; add new digit
    jmp  MAKELOOP       ; do it again

MAKEDONE:
    mov  rax, rcx       ; put value in RAX to return
    ret

_start:
    mov  rax, 0         ; READ (0)
    mov  rdi, 0         ; stdin
    mov  rsi, SCORE     ; buffer
    mov  rdx, SCORELEN  ; length
    syscall

; RAX contains HOW MANY CHARS we read!
; -OR-, -1 to indicate error, really
; should check for that, but that's for
; you to do later... right? (if RAX==-1,
; you'll get a segfault, just so you know!)

    add  rax, SCORE     ; get position of last byte
    movb [rax], 0       ; force a terminator at end

    mov  rax, SCORE     ; point to beginning of buffer
    call MAKEVALUE      ; convert from ASCII to a value

; RAX now should have the VALUE of the string of characters
; we input above. (well, hopefully, right?)

    mov  [VALUE], rax   ; store it, because we can!

; it's stored... pretend it's later... we need value of VALUE!

    mov  rax, [VALUE]   ; get the VALUE
    call PRINTDECI      ; convert and display value

; all done!
    mov  rax, 60        ; EXIT (60/0x3C)
    mov  rdi, 0         ; exit code = 0
    syscall

    section .bss
SCORE:  resb 11   ; 10 chars + zero terminator
SCORELEN equ $-SCORE
NUMBER: resb 19   ; 18 chars + CR terminator
NUMBERLEN equ $-NUMBER

我要说这应该是第一次工作，对我来说这是现成的，尚未经过测试，但这应该很好。 我们最多读取10个字符，将其终止为零，转换为值，然后转换为ASCII并将其写出。

更准确地说，您应该将寄存器保存到每个子例程中的堆栈中，好吧，某些寄存器，确实如此，只有在您要与库进行接口连接时...自己做事才能让您拥有所有想玩的自由使用收银机，您只需要记住放置在哪里！

是的，有人会说：“为什么不乘10而不是奇怪地加？” ...呃...因为它在寄存器上更容易，而且我不必在rdx：rax中全部设置。 此外，它是可读性和可理解性的，尤其是注释。 滚吧！ 这不是比赛，是学习！

机器码很有趣！ 虽然要弄乱所有鸡蛋，但是这里的编译器无济于事！

从技术上讲，您应该检查READ和WRITE的系统调用的返回结果（RAX），适当地处理错误，yadda yadda yadda...。学习使用调试器（gdb或其他工具）。

希望这可以帮助。