NASM Drucken ein Zeichen zu einem Zeitpunkt

Kommen, wie dieses Programm ist nicht ausdrucken auf dem Bildschirm, bin ich etwas fehlt auf der INT 80 Befehl?

  section .bss

  section .data
      hello: db "Hello World",0xa      ;10 is EOL

  section .text
      global _start

  _start:

      mov ecx, 0;                      ; int i = 0;
  loop:
      mov dl, byte [hello + ecx]       ; while(data[i] != EOF) {
      cmp dl, 0xa                      ;
      je  exit                         ;
      mov ebx, ecx                     ; store conetents of i (ecx)

      ; Print single character
      mov eax, 4                       ; set sys_write syscall
      mov ecx, byte [hello + ebx]      ; ...
      mov edx, 1                       ; move one byte at a time
      int 0x80                         ;

      inc ebx                          ; i++
      mov ecx, ebx                     ; move ebx back to ecx
      jmp loop                         ;

  exit:
      mov eax, 0x01                    ; 0x01 = syscall for exit
      int 0x80                         ;

NEBEN

Meinem Makefile:

sandbox: sandbox.o
    ld -o sandbox sandbox.o

sandbox.o: sandbox.asm
    nasm -f elf -g -F stabs sandbox.asm -l sandbox.lst

Modifizierte Code:

section .bss

section .data
    hello: db "Hello World",0xa      ;10 is EOL

section .text
    global _start

_start:

    mov ecx, 0;                      ; int i = 0;
while:
    mov dl, byte [hello + ecx]       ; while(data[i] != EOF) {
    cmp dl, 0xa                      ;   
    je  exit                         ;   
    mov ebx, ecx                     ; store conetents of i (ecx)

    ; Print single character
    mov eax, 4                       ; set sys_write syscall
    mov cl, byte [hello + ebx]       ; ...
    mov edx, 1                       ; move one byte at a time
    int 0x80                         ;   

    inc ebx                          ; i++
    mov ecx, ebx                     ; move ebx back to ecx
    jmp while                        ;   

exit:    
    mov eax, 0x01                    ; 0x01 = syscall for exit
    int 0x80                         ;
  • Lesen Sie meinen Kommentar über das zusätzliche Zeichen, das Sie erwähnt in der "Bearbeiten".
InformationsquelleAutor Matthew Hoggan | 2011-12-08
  1. 5

    Einer der Gründe, warum es nicht gedruckt ist, weil ebx ist soll Sie den Wert 1 angeben stdin, und ein anderer ist, weil sys_write nimmt einen Zeiger (die Adresse des Strings) als ein argument, nicht eine tatsächliche Charakter Wert.

    Wie auch immer, lassen Sie mich Ihnen zeigen, eine einfachere Möglichkeit der Strukturierung Ihres Programms:

    section .data

   SYS_EXIT  equ  1
   SYS_WRITE equ  4
   STDOUT    equ  1
   TRAP      equ  0x80
   NUL       equ  0

   hello: db "Hello World",0xA,NUL    ; 0xA is linefeed, terminate with NUL

section .text
    global _start

_start:
   nop                     ; for good old gdb
   mov ecx, hello          ; ecx is the char* to be passed to sys_write

read:
   cmp byte[ecx], NUL      ; NUL indicates the end of the string
   je exit                 ; if reached the NUL terminator, exit

   ; setup the registers for a sys_write call
   mov eax, SYS_WRITE      ; syscall number for sys_write
   mov ebx, STDOUT         ; print to stdout
   mov edx, 1              ; write 1 char at a time
   int TRAP;               ; execute the syscall

   inc ecx                 ; increment the pointer to the next char
   jmp read                ; loop back to read

exit:    
mov eax, SYS_EXIT      ; load the syscall number for sys_exit
mov ebx, 0             ; return a code of 0
int TRAP               ; execute the syscall

    Kann es einfacher sein, zu NULL zu beenden Sie Ihren string so wie ich, oder Sie können auch $-hello zu erhalten es ist die Länge, die zur compile-Zeit. Ich habe auch die Register für sys_write bei jeder iteration in der Schleife (wie Sie tun), da sys_write nicht erhalten Sie alle Register.

    • Zusätzliche Zeichen gedruckt wird, ist beabsichtigt. Es macht Sinn, um eine neue Zeile gedruckt am Ende der Zeichenfolge, und für den Wert 0 (NULL), um anzugeben, das Ende einer Zeichenfolge. Wenn Sie nicht möchten, dass der zusätzliche Wert, entfernen Sie die 0xA ab Ende hello, aber nicht verwenden Sie den Wert 0xA als string Kündigung Wert.
    • Ist es nicht verschwenderisch um einen Systemaufruf für jedes Zeichen? Würde nicht wollen, um zu bestimmen, die Länge der Schleife und übergeben Sie dann den Puffer zu sys_write in einem Rutsch?
    InformationsquelleAutor AusCBloke
  2. 0

    Ich weiß nicht, wie Sie Ihren code zu montieren, aber es hat nicht montieren, hier ein paar sehr gute Gründe.

    Können Sie nicht verwenden loop als label-Namen, weil dieser name ist reserviert für die loop Unterricht.

    Ihre Linie 20 die Anweisung mov ecx, byte [hello + ebx] nicht montieren, weil entweder die Quell-und Ziel-Operanden-Größen nicht übereinstimmen (byte vs dword). Mögliche änderungen:

    mov cl, byte [Hallo + ebx]

    mov ecx, dword [Hallo + ebx]

    movzx ecx, byte [Hallo + ebx]

    War das oben nicht der eigentliche code, den Sie hatte?

    • Ich bin auf dem FC-15 und I eingefügt haben mein make-Datei oben, ich habe die änderungen vorgenommen und ich bin immer noch nicht immer alles ausdrucken am terminal.
    • Ich würde davon ausgehen, "sys_write()" will die Adresse der Daten, nicht die tatsächlichen Daten (z.B. versuchen "lea ecx,[Hallo+ebx]").
    InformationsquelleAutor Alexey Frunze
Schreibe einen Kommentar