Execute Brain****/x86 Assembly

From Rosetta Code

x86_64 Assembly[edit]

GAS Syntax for Linux. Called it "Brainkrieg" after Teen Girl Squad. Operating principle is a little like a multi-cycle processor. Uses a jump table. Fixed data memory block.

Implementation:[edit]

// Assembly brainf*** interpreter
// Alternative name: "ASSembly brainF*** interpretER"
// Compiles with `gcc -nostdlib brainkrieg.sx -o brainkrieg`
// Usage: ./brainkrieg "filename"
// Return 0 if normal exit
#define SYS_READ    $0
#define SYS_WRITE   $1
#define SYS_OPEN    $2
#define SYS_CLOSE   $3
#define SYS_FSTAT   $5
#define SYS_MMAP    $9
#define SYS_MUNMAP  $11
#define SYS_EXIT    $60

// From experiments:
#define FSIZEOFF    48
#define STATSIZE    144

// From Linux source:
#define RDONLY      $00     
#define PROT_READ   $0x1
#define MAP_PRIVATE $0x02
#define STDIN       $0
#define STDOUT      $1
#define STDERR      $2

#define DEBUGMODE   0

.global _start
.text

.macro ERRCHECK code
    cmpq    $\code, %rax
    je      fs_error
.endm

/* Local stack notes: 
    0: int fd
*/
#define STACKSIZE $4
_start:
    /* Entry Point: */
    // Open:
    movq    RDONLY, %rsi
    // Filename ptr is on stack currently as argv[1]:
    cmpq    $1, (%rsp)          // if argc is 1, error
    jnz     open_file
    jmp     fs_error
    
    open_file:
    movq    16(%rsp), %rdi      // argc(8), argv0(8) => rsp+16. filename
    movq    SYS_OPEN, %rax
    syscall
    ERRCHECK    -1
    subq    STACKSIZE, %rsp           // local stack
    movl    %eax, (%rsp)        // int fd = open(argv[1], RDONLY)
    
    // fstat to get filesize
    fstat:
    movq    $statstruct, %rsi
    movl    (%rsp), %edi        // fd
    movq    SYS_FSTAT, %rax
    syscall                     // fstat(fd, statstruct)
    ERRCHECK    -1
    
    // mmap - don't forget to munmap.
    mmap:
    movq    $0, %r9             // offset
    movq    (%rsp), %r8         // fd
    movq    MAP_PRIVATE, %r10
    movq    PROT_READ, %rdx
    movq    filesize, %rsi
    movq    (%rsp), %rdi        // vmemptr
    movq    SYS_MMAP, %rax
    syscall
    ERRCHECK    -1
    
    // Set up machine:
    boot:
    movq    %rax, head          // head = mmap'd file start
    movq    %rax, inst_ptr      // inst_ptr = head
    addq    filesize, %rax
    movq    %rax, end           // end = head+filesize
    movq    $tape, data_ptr     // data_ptr = tape
    xorq    %rax, %rax
    /* Magic happens here:
        - Fetch symbol
        - Decode symbol
        - Execute opcode
        - Instruction out of range = halt
        - Data out of range = halt
     */
    OS_start:
    fetch:
        movq    inst_ptr, %rbx
        cmpq    end, %rbx
        ja      shutdown            // End of code
        movzbq  (%rbx), %rax
        incq    %rbx
        movq    %rbx, inst_ptr
    decode:
        #if DEBUGMODE
            movb    %al, debugChar
            movq    $1, %rdx
            movq    $debugChar, %rsi
            movq    STDERR, %rdi
            movq    SYS_WRITE, %rax
            syscall
            ERRCHECK    -1
            movzbq  debugChar, %rax
        #endif
        mov     $branch_table, %rcx
        jmp     *(%rcx,%rax,8)
    // execute:
    dp_left:
        cmpq    $tape, data_ptr
        jz      scram
        decq    data_ptr
        jmp     fetch
    dp_right:
        cmpq    $endtape, data_ptr
        jz      scram
        incq    data_ptr
        jmp     fetch
    dec_data:
        movq    data_ptr, %rbx
        decb    (%rbx)
        jmp     fetch
    inc_data:
        movq    data_ptr, %rbx
        incb    (%rbx)
        jmp     fetch
    out_data:
        movq    $1, %rdx
        movq    data_ptr, %rsi
        movq    STDOUT, %rdi
        movq    SYS_WRITE, %rax
        syscall
        ERRCHECK    -1
        jmp     fetch
    in_data:
        movq    $1, %rdx
        movq    data_ptr, %rsi
        movq    STDIN, %rdi
        movq    SYS_READ, %rax
        syscall
        ERRCHECK    -1
        cmpb    $'\n, (%rsi)
        je      fetch
        movq    %rax, junkChar
        jmp     fetch
    brf: // branch if *dp=0
        movq    data_ptr, %rbx
        cmpb    $0, (%rbx)
        jnz     fetch
        matchfwd:
            movq    inst_ptr, %rbx
            movb    (%rbx), %al
            cmpb    $'[, %al
            jne     no_smph
            incq    brack_smph
            cmpq    end, %rbx
            je      scram
            incq    inst_ptr
            jmp     matchfwd
            no_smph:    // no semaphore needed
            cmpb    $'], %al
            je      check_smph
            cmpq    end, %rbx
            je      scram
            incq    inst_ptr
            jmp     matchfwd
            check_smph:     // check if semaphore set
            cmpq    $0, brack_smph
            jz      donematch
            decq    brack_smph
            cmpq    end, %rbx
            je      scram
            incq    inst_ptr
            jmp     matchfwd
    brb: // branch if *dp!=0
        movq    data_ptr, %rbx
        cmpb    $0, (%rbx)
        jz      fetch
        subq    $2, inst_ptr        // Branch taken, scan back.
        matchbwd:
            movq    inst_ptr, %rbx
            movb    (%rbx), %al
            cmpb    $'], %al
            jne     no_smph2
            incq    brack_smph
            cmpq    head, %rbx
            je      scram
            decq    inst_ptr
            jmp     matchbwd
            no_smph2:   // no semaphore needed
            cmpb    $'[, %al
            je      check_smph2
            cmpq    head, %rbx
            je      scram
            decq    inst_ptr
            jmp     matchbwd
            check_smph2:    // check if semaphore set
            cmpq    $0, brack_smph
            jz      donematch2
            decq    brack_smph
            cmpq    head, %rbx
            je      scram
            decq    inst_ptr
            jmp     matchbwd
        donematch:
        incq    inst_ptr
        donematch2:
        jmp     fetch
    
    scram:      // Memory breached
    movq    $0x7f, err_val
    
    shutdown:
    // Consume rest of stdin if we used it.
    cmpb    $0, junkChar
    jz      skip_flush
    flush_stdin:
    movq    SYS_READ, %rax
    movq    STDIN, %rdi 
    movq    $junkChar, %rsi 
    movq    $1, %rdx
    syscall
    cmpq    $0, %rax            // EOF
    jz      skip_flush
    cmpb    $'\n, junkChar
    jne     flush_stdin
    
    // munmap
    skip_flush:
    movq    filesize, %rsi
    movq    head, %rdi
    movq    SYS_MUNMAP, %rax
    syscall                     // munmap(vmemptr, filesize)
    cmpq    $-1, %rax
    je      fs_error
    // close
    movl    (%rsp), %edi
    movq    SYS_CLOSE, %rax
    syscall                     // close(fd)
    ERRCHECK    -1

exit:
    movq    SYS_EXIT, %rax
    movzbq  err_val, %rdi
    syscall

fs_error:
    movq    SYS_EXIT, %rax
    movq    $-1, %rdi
    syscall                         // exit(-1)

.data
branch_table:
    .rept   43
    .quad   fetch
    .endr
    
    .quad   inc_data
    .quad   in_data
    .quad   dec_data
    .quad   out_data
    
    .rept   13
    .quad   fetch
    .endr
    
    .quad   dp_left
    .quad   fetch
    .quad   dp_right
    
    .rept   28
    .quad   fetch
    .endr
    
    .quad   brf
    .quad   fetch
    .quad   brb
    
    .rept   162
    .quad   fetch
    .endr

.bss
brack_smph:    // Bracket matching semaphore
    .quad   0

junkChar:       // Also used to check if input was used.
    .byte   0

#if DEBUGMODE
debugChar:
    .byte   0
#endif

err_val:
    .byte   0
    
// fstat:
statstruct:     // This struct is 144 bytes. Only want size (+48)
    .zero FSIZEOFF
    filesize:  // 8 bytes.
    .quad   0
    .zero   STATSIZE-FSIZEOFF+8
    
// Program:
head:
    .quad   0
end:
    .quad   0
inst_ptr:
    .quad   0
    
// Data:
data_ptr:
    .quad   0    
tape:
    .zero   (1<<20)
endtape:
    .zero   1