google/gemini-3.5-flash 🖼️🔢📝❓ → 📝

To move a file in assembly, we use the operating system's system calls. In modern operating systems, "moving" a file within the same filesystem is achieved by renaming its path.

Here is the assembly code written for Linux x86_64 using NASM syntax. It uses the sys_rename system call (system call number 82).

Assembly Code (Linux x86_64)

section .data
    ; Define the source and destination paths (must be null-terminated)
    src_path db "/tmp/folder_A/myfile.txt", 0
    dst_path db "/tmp/folder_B/myfile.txt", 0

    ; Error/Success messages
    success_msg db "File moved successfully!", 10, 0
    success_len equ $ - success_msg
    error_msg   db "Error moving file.", 10, 0
    error_len   equ $ - error_msg

section .text
    global _start

_start:
    ;---------------------------------------------------------
    ; sys_rename (syscall 82)
    ; Arguments:
    ;   rax = 82 (syscall number for sys_rename)
    ;   rdi = const char *oldpath (source)
    ;   rsi = const char *newpath (destination)
    ;---------------------------------------------------------
    mov rax, 82             ; syscall number for sys_rename
    mov rdi, src_path       ; pointer to old path
    mov rsi, dst_path       ; pointer to new path
    syscall                 ; call kernel

    ; Check the return value in RAX
    ; In Linux, a negative return value indicates an error (e.g., -2 for file not found)
    test rax, rax
    js .on_error            ; Jump if Sign flag is set (RAX is negative)

    ; If successful, print success message
    mov rax, 1              ; sys_write
    mov rdi, 1              ; stdout
    mov rsi, success_msg    ; message pointer
    mov rdx, success_len    ; message length
    syscall
    jmp .exit

.on_error:
    ; If failed, print error message
    mov rax, 1              ; sys_write
    mov rdi, 1              ; stdout
    mov rsi, error_msg      ; message pointer
    mov rdx, error_len      ; message length
    syscall
    jmp .exit_failure

.exit:
    ; Exit program with status 0 (success)
    mov rax, 60             ; sys_exit
    xor rdi, rdi            ; exit code 0
    syscall

.exit_failure:
    ; Exit program with status 1 (error)
    mov rax, 60             ; sys_exit
    mov rdi, 1              ; exit code 1
    syscall

How to Compile and Run (Linux)

To test this code, you will need nasm (Netwide Assembler) and ld (GNU Linker).

1. Create the dummy folders and file to test:

   mkdir -p /tmp/folder_A /tmp/folder_B
   touch /tmp/folder_A/myfile.txt
   

2. Save the assembly code into a file named move.asm.

3. Assemble and link the code:

   nasm -f elf64 move.asm -o move.o
   ld move.o -o move
   

4. Run the executable:

   ./move
   

How it Works (Under the Hood)

1. The Rename Syscall (sys_rename): Moving a file is technically a "rename" operation in the OS kernel. It updates the directory entry pointers rather than physically rewriting the file data on the disk (as long as it remains on the same partition).
2. Registers:
   • rax holds the system call ID (82 for rename, 1 for write, 60 for exit).
   • rdi and rsi pass the pointers of our source and destination strings to the kernel.
3. Error Handling: The CPU test rax, rax checks if the kernel returned a negative number (error). If so, it branches to the error printing section.