BrainFu*k interpreter in nasm

brainf.asm

;  $ nasm -f elf64 brainf.asm && ld brainf.o
;  $ ./a.out

BUFF equ 32*1024

global _start

section .bss
    buffer            resb BUFF
    input_size        resw 1

section .data
    cells     times 256 db 0
    cell_ind            db 0
    cursor              dw 0

section .text

_start:
    mov rax, 0
    mov rdi, 0
    mov rsi, buffer
    mov rdx, BUFF
    syscall

    mov [input_size], ax
    xor rbx, rbx

.l0:
    call advance
    call decide
    cmp bx, [input_size]
    jl .l0

_end:
    mov rax, 60
    xor rdi, rdi
    syscall

advance:
    mov  bx, [cursor]
    inc word[cursor]
    mov  al, [buffer+rbx]
    ret

retreat:
    xor rbx, rbx
    dec word[cursor]
    mov  bx, [cursor]
    mov  al, [buffer+rbx-1]
    ret

decide:
    cmp  al, '>'
    je right_cell
    cmp  al, '<'
    je left_cell

    xor rsi, rsi
    mov sil, [cell_ind]
    add rsi, cells

    cmp  al, '+'
    je increment
    cmp  al, '-'
    je decrement

    cmp  al, '.'
    je output
    cmp  al, ','
    je input

    xor rcx, rcx
    mov  cl, [cursor]

    cmp  al, '['
    je jump_past
    cmp  al, ']'
    je jump_back

    xor rax, rax
    ret

right_cell:
    inc byte[cell_ind]
    ret

left_cell:
    dec byte[cell_ind]
    ret

increment:
    inc byte[rsi]
    ret

decrement:
    dec byte[rsi]
    ret

output:
    mov rax, 1
    mov rdi, 1
    mov rdx, 1
    syscall
    ret

input:
    mov rax, 0
    mov rdi, 0
    mov rdx, 1
    syscall
    ret

jump_past:
    cmp byte[rsi], 0
    jne .e1
    mov di, 1
.l1:
    call advance
    call checkb
    cmp di, 0
    jne .l1
.e1:
    ret

jump_back:
    cmp byte[rsi], 0
    je .e2
    mov di, -1
.l2:
    call retreat
    call checkb
    cmp di, 0
    jne .l2
.e2:
    ret

checkb:
    cmp al, ']'
    je .de
    cmp al, '['
    jne .fi
.in:
    inc di
    jmp .fi
.de:
    dec di
.fi:
    ret