X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=main.asm;h=a4db7329bb1f8ed39570b1196f0df2556f75e761;hb=f0df53c35124c9a5e2b045aba60b513faa344567;hp=d2cd54deb29e91c65f5d366d344aba29911eba39;hpb=02f53b20b4f7244a84a442bbae10eb8401abcfc5;p=rrq%2Fjonasforth.git diff --git a/main.asm b/main.asm index d2cd54d..a4db732 100644 --- a/main.asm +++ b/main.asm @@ -1,5 +1,35 @@ +;; vim: syntax=fasm + format ELF64 executable +;; "Syscalls" {{{ + +;; [NOTE] Volatile registers Linux (syscalls) vs UEFI +;; +;; Linux syscalls: RAX, RCX, R11 +;; UEFI: RAX, RCX, R11, RDX, R8, R9, R10 + +;; We are in the process of replacing our dependency on Linux with a dependency +;; on UEFI. The following macros attempt to isolate what would be syscalls in +;; Linux; thus, we will be able to replace these with UEFI-based implementations, +;; and in theory we should expect the program to work. + +;; Print a string of a given length. +;; +;; Input: +;; - RCX = Pointer to buffer +;; - RDX = Buffer length +;; +;; Clobbers: RAX, RCX, R11, RDI, RSI +macro sys_print_string { + mov rax, 1 + mov rdi, 1 + mov rsi, rcx + syscall +} + +;; }}} + ;; The code in this macro is placed at the end of each Forth word. When we are ;; executing a definition, this code is what causes execution to resume at the ;; next word in that definition. @@ -57,18 +87,12 @@ macro forth_asm label, name, immediate { .start: } -;; Define a Forth word that is implemented in Forth. (The body will be a list of -;; 'dq' statements.) -macro forth label, name, immediate { - header label, name, immediate - dq DOCOL -} - segment readable executable entry main -include "impl.asm" +include "impl.asm" ; Misc. subroutines +include "bootstrap.asm" ; Forth words encoded in Assembly main: cld ; Clear direction flag so LODSQ does the right thing. @@ -161,28 +185,16 @@ forth_asm EXEC, 'EXEC' forth_asm EMIT, 'EMIT' pushr rsi pushr rax - mov rax, 1 - mov rdi, 1 - lea rsi, [rsp] + + lea rcx, [rsp] mov rdx, 1 - syscall + sys_print_string + add rsp, 8 popr rax popr rsi next -;; Prints a newline to standard output. -forth NEWLINE, 'NEWLINE' - dq LIT, $A - dq EMIT - dq EXIT - -;; Prints a space to standard output. -forth SPACE, 'SPACE' - dq LIT, ' ' - dq EMIT - dq EXIT - ;; Read a word from standard input and push it onto the stack as a pointer and a ;; size. The pointer is valid until the next call to READ_WORD. forth_asm READ_WORD, 'READ-WORD' @@ -195,11 +207,30 @@ forth_asm READ_WORD, 'READ-WORD' mov rsi, [.rsi] next +;; Read a word from a buffer. Expects (buffer buffer-length) on the stack. +;; Updates buffer and buffer-length, such that the word has been removed from +;; the buffer. Appends (word-buffer word-buffer-length) to the stack. +forth_asm POP_WORD, 'POP-WORD' + pushr rsi + + pop rcx ; Length + pop rsi ; Buffer + + call pop_word + + push rsi ; Updated buffer + push rcx ; Length of updated buffer + push rdi ; Word buffer + push rdx ; Length of word buffer + + popr rsi + next + ;; Takes a string on the stack and replaces it with the decimal number that the ;; string represents. forth_asm PARSE_NUMBER, 'PARSE-NUMBER' - pop [parse_number.length] ; Length - pop [parse_number.buffer] ; String pointer + pop rcx ; Length + pop rdi ; String pointer push rsi call parse_number @@ -208,25 +239,18 @@ forth_asm PARSE_NUMBER, 'PARSE-NUMBER' push rax ; Result next -forth READ_NUMBER, 'READ-NUMBER' - dq READ_WORD - dq PARSE_NUMBER - dq EXIT - ;; Takes a string (in the form of a pointer and a length on the stack) and ;; prints it to standard output. forth_asm TELL, 'TELL' - mov rbx, rsi - mov rcx, rax + pushr rax + pushr rsi - mov rax, 1 - mov rdi, 1 - pop rdx ; Length - pop rsi ; Buffer - syscall + pop rdx ; Length + pop rcx ; Buffer + sys_print_string - mov rax, rcx - mov rsi, rbx + popr rsi + popr rax next ;; Exit the program cleanly. @@ -235,16 +259,6 @@ forth_asm TERMINATE, 'TERMINATE' mov rdi, 0 syscall -forth HELLO, 'HELLO' - dq LIT, 'H', EMIT - dq LIT, 'e', EMIT - dq LIT, 'l', EMIT - dq LIT, 'l', EMIT - dq LIT, 'o', EMIT - dq LIT, '!', EMIT - dq NEWLINE - dq EXIT - ;; Duplicate a pair of elements. forth_asm PAIRDUP, '2DUP' pop rbx @@ -279,54 +293,6 @@ forth_asm NOT_, 'NOT' push 1 next -;; The INTERPRET word reads and interprets user input. It's behavior depends on -;; the current STATE. It provides special handling for integers. -forth INTERPRET, 'INTERPRET' - ;; Read word - dq READ_WORD - dq PAIRDUP - ;; Stack is (word length word length). - dq FIND ; Try to find word - dq DUP_ - dq ZBRANCH, 8 * 20 ; Check if word is found - - ;; - Word is found - - - dq STATE, GET, ZBRANCH, 8 * 9 ; Check whether we are in compilation or immediate mode - - ;; (Word found, compilation mode) - dq DUP_, IS_IMMEDIATE, NOT_, ZBRANCH, 8 * 4 ; If the word is immediate, continue as we would in immediate mode - - ;; Otherwise, we want to compile this word - dq TCFA - dq COMMA - dq EXIT - - ;; (Word found, immediate mode) - ;; Execute word - dq TCFA - ;; Stack is (word length addr) - dq SWAP, DROP - dq SWAP, DROP - ;; Stack is (addr) - dq EXEC - dq EXIT - - ;; - No word is found, assume it is an integer literal - - ;; Stack is (word length addr) - dq DROP - dq PARSE_NUMBER - - dq STATE, GET, ZBRANCH, 8 * 5 ; Check whether we are in compilation or immediate mode - - ;; (Number, compilation mode) - dq LIT, LIT, COMMA - dq COMMA - dq EXIT - - ;; (Number, immediate mode) - dq EXIT - ;; .U prints the value on the stack as an unsigned integer in hexadecimal. forth_asm DOTU, '.U' mov [.length], 0 @@ -378,11 +344,9 @@ forth_asm DOTU, '.U' loop .flip ;; Print the buffer - mov rax, 1 - mov rdi, 1 - mov rsi, .buffer + mov rcx, .buffer mov rdx, [.printed_length] - syscall + sys_print_string ;; Restore RSI and continue execution pop rsi @@ -442,34 +406,12 @@ forth_asm TIMESMOD, '/MOD' push rdx ; a % b next -;; Get the location of the STATE variable. It can be set with '!' and read with -;; '@'. -forth STATE, 'STATE' - dq LIT, var_STATE - dq EXIT - -;; Get the location of the LATEST variable. It can be set with '!' and read with -;; '@'. -forth LATEST, 'LATEST' - dq LIT, latest_entry - dq EXIT - -;; Get the location at which compiled words are expected to be added. This -;; pointer is usually modified automatically when calling ',', but we can also -;; read it manually with 'HERE'. -forth HERE, 'HERE' - dq LIT, here - dq EXIT - -forth COMMA, ',' - dq HERE, GET, PUT ; Set the memory at the address pointed to by HERE - dq HERE, GET, LIT, 8, PLUS ; Calculate new address for HERE to point to - dq HERE, PUT ; Update HERE to point to the new address - dq EXIT - ;; Read user input until next " character is found. Push a string containing the ;; input on the stack as (buffer length). Note that the buffer is only valid -;; until the next call to S" and that no more than 255 character can be read. +;; until the next call to S" and that no more than 255 characters can be read. +;; +;; [TODO] We want to be able to use this when reading from buffers (e.g. in +;; INTERPRET-STRING) too! forth_asm READ_STRING, 'S"' push rsi @@ -500,6 +442,47 @@ forth_asm READ_STRING, 'S"' next +;; BUF" works a bit like S, but it reads the string from the current input +;; buffer described in INPUT-BUFFER and INPUT-LENGTH. We use this fucntion in +;; sys.f to store strings. +forth_asm BUF_READ_STRING, 'BUF"' + push rsi + + ;; We borrow READ_STRING's buffer. They won't mind. + mov [READ_STRING.length], 0 + + ;; Skip space ([TODO]: Shouldn't we do this while parsing instead?) + inc [input_buffer] + dec [input_buffer_length] + +.read_char: + mov rbx, [input_buffer] + mov al, [rbx] + cmp al, '"' + je .done + + mov rdx, READ_STRING.buffer + add rdx, [READ_STRING.length] + mov [rdx], al + inc [READ_STRING.length] + + inc [input_buffer] + dec [input_buffer_length] + + jmp .read_char + +.done: + pop rsi + + ;; Skip closing " + inc [input_buffer] + dec [input_buffer_length] + + push READ_STRING.buffer + push [READ_STRING.length] + + next + ;; CREATE inserts a new header in the dictionary, and updates LATEST so that it ;; points to the header. To compile a word, the user can then call ',' to ;; continue to append data after the header. @@ -533,36 +516,73 @@ forth_asm CREATE, 'CREATE' next -;; Mark the last added word as immediate. -forth IMMEDIATE, 'IMMEDIATE', 1 - dq LIT, 1 - dq LATEST, GET - dq LIT, 8, PLUS - dq PUT_BYTE - dq EXIT +forth_asm TICK, "'" + lodsq + push rax + next -;; Given the address of a word, return 0 if the given word is not immediate. -forth IS_IMMEDIATE, 'IMMEDIATE?' - dq LIT, 8, PLUS - dq GET_BYTE - dq EXIT +forth_asm ROT, 'ROT' + pop rax + pop rbx + pop rdx + push rax + push rdx + push rbx + next -;; Enter immediate mode, immediately -forth INTO_IMMEDIATE, '[', 1 - dq LIT, 0, STATE, PUT_BYTE - dq EXIT +forth_asm PICK, 'PICK' + pop rax + lea rax, [rsp + 8 * rax] + mov rax, [rax] + push rax + next -;; Enter compilation mode -forth OUTOF_IMMEDIATE, ']' - dq LIT, 1, STATE, PUT_BYTE - dq EXIT +forth_asm EQL, '=' + pop rax + pop rbx + cmp rax, rbx + je .eq +.noteq: + push 0 + next +.eq: + push 1 + next forth MAIN, 'MAIN' - dq HELLO + dq SYSCODE + dq INTERPRET_STRING dq INTERPRET dq BRANCH, -8 * 2 dq TERMINATE +;; Built-in variables: + +forth STATE, 'STATE' + dq LIT, var_STATE + dq EXIT + +forth LATEST, 'LATEST' + dq LIT, latest_entry + dq EXIT + +forth HERE, 'HERE' + dq LIT, here + dq EXIT + +forth SYSCODE, 'SYSCODE' + dq LIT, sysf + dq LIT, sysf.len + dq EXIT + +forth INPUT_BUFFER, 'INPUT-BUFFER' + dq LIT, input_buffer + dq EXIT + +forth INPUT_LENGTH, 'INPUT-LENGTH' + dq LIT, input_buffer_length + dq EXIT + segment readable writable ;; The LATEST variable holds a pointer to the word that was last added to the @@ -591,8 +611,23 @@ DOTU.printed_length dq ? ;; Reserve space for compiled words, accessed through HERE. here dq here_top -here_top rq $2000 +here_top rq $4000 + +;; Pointer to input buffer and its length. Used as local variable in +;; INTERPRET-STRING (see bootstrap.asm). [TODO] The code organization is a bit +;; awkward here. +input_buffer dq ? +input_buffer_length dq ? ;; Return stack rq $2000 return_stack_top: + +segment readable + +;; We store some Forth code in sys.f that defined common words that the user +;; would expect to have available at startup. To execute these words, we just +;; include the file directly in the binary, and then interpret it at startup. +sysf file 'sys.f' +sysf.len = $ - sysf +