nasm linux x64 how do i find and cmp EOF to stop printing data from file to screen

section .data
 
Nile_2 db '/home/mark/Desktop/mynewfile.txt', 0;
  

section .bss
 fd_out resd 4  ; use this here instead of resb so there is enough room for long file names
 fd_in  resd 4
 info resd  26

section .text
   global _start         ;must be declared for using gcc
    
_start:
;open the file for reading
   mov rax, 5
   mov rbx, Nile_2      ; was file_name
   mov rcx, 0             ;for read only access
  ; mov rdx, 0777          ;read, write and execute by all
   int  0x80
    
   mov  [fd_in], eax
   ;mov rdx, 20
READ:    
   ;read from file
   mov rax, 3
   mov rbx, [fd_in]
   mov rcx, info
   ;mov rdx, 26
   int 0x80
    
      
    
   ; print the info 
   mov rax, 4
   mov rbx, 1
   mov rcx, info
   ;mov rdx, 26
   int 0x80
   
   mov r10, info                 ; dec rdx
   cmp r10, 00
   jnz READ
   ;jmp READ           ;jnz Read
HERE:   

   ; close the file
   mov rax, 6
   mov rbx, [fd_in]
   int  0x80 
       
   mov  eax,1             ;system call number (sys_exit)
   int  0x80              ;call kernel

how do i find out if sys_read or info is zero how do i find out EOF ??? i dont know how to use sys_read to check if no bytes have been read... when i try to cmp that info is zero bytes read i get the last few bytes over and over ???

CodePudding user response：

You are using int 0x80 in your 64-bit code. Normally, in 64-bit code, you would use the syscall instruction and use other register arguments. For some light reading, see What happens if you use the 32-bit int 0x80 Linux ABI in 64-bit code?

how do i find out if sys_read or info is zero how do i find out EOF ???

If a request to read a certain number of bytes from a file, reports a count that is less than the number that you requested, then the end-of-file has been reached. If the reported count is 0, then the end-of-file was already reached before you made the request, else we say that a partial record was read.

i dont know how to use sys_read to check if no bytes have been read...

sys_read provides you with the number of bytes that were actually read in the eax register. I mentioned this already in my answer to your previous question Nasm linux for some reason i cant use two file variable names at the same time for opening a file and creating a file?

when i try to cmp that info is zero bytes read i get the last few bytes over and over ???

You have managed to create an endless loop!
In NASM, an instruction like mov r10, info loads the address of info in the register. So not the contents that are stored at info which is what you were trying to get.
Since the address is not zero, code like:

mov r10, info
cmp r10, 00
jnz READ

will always jump and thus continue the loop ad infinitum.

fd_out resd 4  ; use this here instead of `resb` so there is **enough room for long file names**
fd_in  resd 4
info resd  26

What sys_creat and sys_open return to you in the eax register is a file descriptor (it's in the names fd_in and fd_out), and it's a handle by which the system can identify the open file. It is a single dword and it is meaningless to assign 4 dwords for its storage.

Also, I find it strange that, in response to my previous answer, you changed info resb 26 into info resd 26. This does not make much sense.

With using 64-bit registers this time, you did introduce another mismatch on the fd_in variable! If you stored a dword (mov [fd_in], eax) then don't retrieve a qword (mov rbx, [fd_in])

section .bss
    fd_out resd 1
    fd_in  resd 1
    info   resb  26

    ...

READ:
    ;read from file
    mov  edx, 26
    mov  ecx, info
    mov  ebx, [fd_in]
    mov  eax, 3
    int  0x80        ; -> EAX
    test eax, eax
    js   ERROR       ; Some error occured
    jz   HERE        ; End-of-file
    ; print the info 
    mov  edx, eax    ; Could be a partial record
    mov  ecx, info
    mov  ebx, 1
    mov  eax, 4
    int  0x80
    jmp  READ
ERROR:

HERE:

CodePudding user response：

i found out that if i check eax and if its zero thats the end of file

cmp rax, 0
   je HERE
'''
so that there does the job and not it will end almost properly when it reaches the end of the file it does spit out an extra bit tho dont know why