From 0f0dd1012d6b1768eb91f1b35e8a7006d09414ab Mon Sep 17 00:00:00 2001 From: bd Date: Thu, 10 Apr 2025 20:40:40 -0400 Subject: Fix swapped destination + source in immediate i-type instructions --- src/parse.lisp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index d971444..6b0d31d 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -107,7 +107,7 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (defrule-instr r-type-1 'emit::r (1 2 0) register register) (defrule-instr r-type-2 'emit::r (0 1 2) register register) (defrule-instr r-type-3 'emit::r (1 2 0) register register register) -(defrule-instr i-type-3 'emit::i (0 1 2) register register immediate) +(defrule-instr i-type-3 'emit::i (1 0 2) register register immediate) (defrule-instr j-type-3 'emit::j (1 0) label) (esrap:defrule i-type-1 (and i-type-1-m space register space (or dereference var)) -- cgit v1.2.3 From 42ae34d6f2ee0f0eb10e6ecc1e914c5d4753a184 Mon Sep 17 00:00:00 2001 From: bd Date: Thu, 10 Apr 2025 21:56:36 -0400 Subject: Allow all integers to be negative --- src/parse.lisp | 12 ++++++++---- t/parse.lisp | 13 +++++++++++-- 2 files changed, 19 insertions(+), 6 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index 6b0d31d..687474b 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -18,6 +18,8 @@ (incf line-number) nil)) +(esrap:defrule sign (or #\+ #\-)) + (esrap:defrule alpha (+ (alphanumericp character)) (:text t)) @@ -38,7 +40,9 @@ "A" "B" "C" "D" "E" "F"))) (:lambda (e) (parse-integer (esrap:text (cddr e)) :radix 16))) -(esrap:defrule int (or binary octal hex decimal)) +(esrap:defrule int (and (esrap:? sign) (or binary octal hex decimal)) + (:destructure (s i) + (if (and s (string= s "-")) (- i) i))) ;;; defines rules to parse an operand @@ -49,10 +53,10 @@ (esrap:defrule var alpha (:lambda (e) (list (list 'emit::rr 0) (list 'emit::var e)))) -(esrap:defrule dereference (and (esrap:? (or #\+ #\-)) int #\( register #\)) - (:destructure (s i1 w1 r w2) +(esrap:defrule dereference (and int #\( register #\)) + (:destructure (i1 w1 r w2) (declare (ignore w1 w2)) - (list r (list 'emit::imm (if (and s (string= s "-")) (- i1) i1))))) + (list r (list 'emit::imm i1)))) (esrap:defrule immediate int (:lambda (e) (list 'emit::imm e))) diff --git a/t/parse.lisp b/t/parse.lisp index 8f636e5..f82c98c 100644 --- a/t/parse.lisp +++ b/t/parse.lisp @@ -113,6 +113,15 @@ JRL FOO~t~%PUSH $5~%"))))) (esrap:parse 'parse:str->ast (format nil "~%~t.DATA~t~%F 5 6 7 8~t~%G 4 H 3 5~%.TEXT~%"))))) +(test esrap-negative-ints + (is (equal + '(emit::p + (emit::d + -1) + (emit::x + (emit::i "LOADV" (emit::rr -8) (emit::rr -3) (emit::imm -3)))) + (esrap:parse 'parse:str->ast (format nil ".DATA~%~tm -1~%.TEXT~%~tLOADV $-8 -3($-3)~%"))))) + (test esrap-data-full (is (equal '(emit::p @@ -122,11 +131,11 @@ H 3 5~%.TEXT~%"))))) (emit::i "LOAD" (emit::rr 5) (emit::rr 0) (emit::var "S")) (emit::i "LOAD" (emit::rr 10) (emit::rr 0) (emit::var "ARR")) (emit::i "LOAD" (emit::rr 6) (emit::rr 0) (emit::var "I")) - (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 19)) + (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 20)) (emit::r "ADD" (emit::rr 10) (emit::rr 6) (emit::rr 9)) (emit::i "ADDI" (emit::rr 6) (emit::rr 6) (emit::imm 1)) (emit::r "CMP" (emit::rr 6) (emit::rr 5) (emit::rr 0)) - (emit::j "BGT" (emit::rr 0) (emit::l "L" 23)))) + (emit::j "BGT" (emit::rr 0) (emit::l "L" 24)))) (esrap:parse 'parse:str->ast (format nil " .DATA ARR 1 2 3 4 -- cgit v1.2.3 From c02164cfee4d8c3d3eca76fa8cc60b6ca60c2ca0 Mon Sep 17 00:00:00 2001 From: bd Date: Thu, 10 Apr 2025 23:29:36 -0400 Subject: Switch to allowing variables to be used as immediate fields --- src/parse.lisp | 10 +++++----- t/parse.lisp | 22 +++++++++++----------- 2 files changed, 16 insertions(+), 16 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index 687474b..73e98c5 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -50,15 +50,15 @@ (:function cadr) (:lambda (e) (list 'emit::rr e))) -(esrap:defrule var alpha - (:lambda (e) (list (list 'emit::rr 0) (list 'emit::var e)))) +(esrap:defrule variable alpha + (:lambda (e) (list 'emit::var e))) (esrap:defrule dereference (and int #\( register #\)) (:destructure (i1 w1 r w2) (declare (ignore w1 w2)) (list r (list 'emit::imm i1)))) -(esrap:defrule immediate int +(esrap:defrule immediate (or int variable) (:lambda (e) (list 'emit::imm e))) ;;; defines rules to parse labels @@ -114,12 +114,12 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (defrule-instr i-type-3 'emit::i (1 0 2) register register immediate) (defrule-instr j-type-3 'emit::j (1 0) label) -(esrap:defrule i-type-1 (and i-type-1-m space register space (or dereference var)) +(esrap:defrule i-type-1 (and i-type-1-m space register space dereference) (:destructure (m w1 s w2 di) (declare (ignore w1 w2)) `(emit::i ,m ,s ,@di))) -(esrap:defrule i-type-2 (and i-type-2-m space register space (or dereference var)) +(esrap:defrule i-type-2 (and i-type-2-m space register space dereference) (:destructure (m w1 s w2 di) (declare (ignore w1 w2)) `(emit::i ,m ,@(util:insert-in-middle di s)))) diff --git a/t/parse.lisp b/t/parse.lisp index f82c98c..bd5ee97 100644 --- a/t/parse.lisp +++ b/t/parse.lisp @@ -62,10 +62,10 @@ '(emit::p (emit::d) (emit::x - (emit::i "LOADV" (emit::rr 8) (emit::rr 0) (emit::var "vector")) - (emit::i "STORE" (emit::rr 0) (emit::rr 5) (emit::var "int")))) - (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tLOADV $8 vector -~tSTORE $5 int~%"))))) + (emit::i "LOADV" (emit::rr 8) (emit::rr 4) (emit::imm 2)) + (emit::i "STORE" (emit::rr 1) (emit::rr 5) (emit::imm 2)))) + (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tLOADV $8 2($4) +~tSTORE $5 2($1)~%"))))) (test esrap-instr-type-all-lazy-spaces (is (equal @@ -86,7 +86,7 @@ JRL FOO~t~%PUSH $5~%"))))) (emit::x)) (esrap:parse 'parse:str->ast (format nil ".DATA~%~tA 1~%.TEXT~%"))))) -(test esrap-data-loaded +(test esrap-data-loadedp (is (equal '(emit::p (emit::d @@ -128,9 +128,9 @@ H 3 5~%.TEXT~%"))))) (emit::d 1 2 3 4 3 0) (emit::x - (emit::i "LOAD" (emit::rr 5) (emit::rr 0) (emit::var "S")) - (emit::i "LOAD" (emit::rr 10) (emit::rr 0) (emit::var "ARR")) - (emit::i "LOAD" (emit::rr 6) (emit::rr 0) (emit::var "I")) + (emit::i "ADDI" (emit::rr 0) (emit::rr 5) (emit::imm (emit::var "S"))) + (emit::i "ADDI" (emit::rr 0) (emit::rr 10) (emit::imm (emit::var "ARR"))) + (emit::i "ADDI" (emit::rr 0) (emit::rr 6) (emit::imm (emit::var "I"))) (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 20)) (emit::r "ADD" (emit::rr 10) (emit::rr 6) (emit::rr 9)) (emit::i "ADDI" (emit::rr 6) (emit::rr 6) (emit::imm 1)) @@ -143,9 +143,9 @@ H 3 5~%.TEXT~%"))))) I 0 .TEXT - LOAD $5 S - LOAD $10 ARR - LOAD $6 I + ADDI $5 $0 S + ADDI $10 $0 ARR + ADDI $6 $0 I JRL CMP L: ADD $9 $10 $6 -- cgit v1.2.3 From 57bf0a940b3d1fdbe13684f545f0ce8707cdcd35 Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 00:19:36 -0400 Subject: Add comments to parsing --- src/parse.lisp | 13 ++++++++----- t/parse.lisp | 18 +++++++++++++++--- 2 files changed, 23 insertions(+), 8 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index 73e98c5..8eca782 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -9,10 +9,13 @@ (+ (or #\space #\tab)) (:constant nil)) -(esrap:defrule nl (+ #\newline) +(esrap:defrule eol (and (esrap:? space) (esrap:? (and #\; (* (not #\newline)))) #\newline) (:constant nil)) -(esrap:defrule nl-inc (+ #\newline) +(esrap:defrule nl (+ eol) + (:constant nil)) + +(esrap:defrule nl-inc (+ eol) (:lambda (n) (declare (ignore n)) (incf line-number) @@ -139,10 +142,10 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma ;;; defines rules to parse the .text segment -(esrap:defrule instr-clean (and (esrap:? space) instr (esrap:? space) nl-inc) +(esrap:defrule instr-clean (and (esrap:? space) instr nl-inc) (:function cadr)) -(esrap:defrule label-clean (and label-decl (esrap:? space) nl) +(esrap:defrule label-clean (and label-decl nl) (:function car)) (esrap:defrule text-line (or instr-clean label-clean)) @@ -164,7 +167,7 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (util:add-variable e var-offset) nil)) -(esrap:defrule data-line (and (esrap:? space) var-decl (+ data-word) (esrap:? space) nl) +(esrap:defrule data-line (and (esrap:? space) var-decl (+ data-word) nl) (:function caddr)) (esrap:defrule data (and ".DATA" (esrap:? space) nl (* data-line)) diff --git a/t/parse.lisp b/t/parse.lisp index bd5ee97..993447f 100644 --- a/t/parse.lisp +++ b/t/parse.lisp @@ -78,6 +78,18 @@ (esrap:parse 'parse:str->ast (format nil ".DATA~%~%.TEXT~t~%JMP 3($3)~t JRL FOO~t~%PUSH $5~%"))))) +(test esrap-instr-type-comments + (is (equal + '(emit::p + (emit::d) + (emit::x + (emit::j "JMP" (emit::rr 3) (emit::imm 3)) + (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 17)) + (emit::j "PUSH" (emit::rr 5) (emit::imm 0)))) + (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT;; dot dot dot +~tJMP 3($3) ;; this does things +~tJRL FOO~%~tPUSH $5~%"))))) + (test esrap-data-singleton (is (equal '(emit::p @@ -86,7 +98,7 @@ JRL FOO~t~%PUSH $5~%"))))) (emit::x)) (esrap:parse 'parse:str->ast (format nil ".DATA~%~tA 1~%.TEXT~%"))))) -(test esrap-data-loadedp +(test esrap-data-loaded (is (equal '(emit::p (emit::d @@ -131,11 +143,11 @@ H 3 5~%.TEXT~%"))))) (emit::i "ADDI" (emit::rr 0) (emit::rr 5) (emit::imm (emit::var "S"))) (emit::i "ADDI" (emit::rr 0) (emit::rr 10) (emit::imm (emit::var "ARR"))) (emit::i "ADDI" (emit::rr 0) (emit::rr 6) (emit::imm (emit::var "I"))) - (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 20)) + (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 23)) (emit::r "ADD" (emit::rr 10) (emit::rr 6) (emit::rr 9)) (emit::i "ADDI" (emit::rr 6) (emit::rr 6) (emit::imm 1)) (emit::r "CMP" (emit::rr 6) (emit::rr 5) (emit::rr 0)) - (emit::j "BGT" (emit::rr 0) (emit::l "L" 24)))) + (emit::j "BGT" (emit::rr 0) (emit::l "L" 27)))) (esrap:parse 'parse:str->ast (format nil " .DATA ARR 1 2 3 4 -- cgit v1.2.3 From 23d2ccc3e1b05a1ca0ff72317cc6da0773a0a9d1 Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 00:22:57 -0400 Subject: Simplify newline rules --- src/parse.lisp | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index 8eca782..a3c9cbd 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -15,12 +15,6 @@ (esrap:defrule nl (+ eol) (:constant nil)) -(esrap:defrule nl-inc (+ eol) - (:lambda (n) - (declare (ignore n)) - (incf line-number) - nil)) - (esrap:defrule sign (or #\+ #\-)) (esrap:defrule alpha (+ (alphanumericp character)) @@ -142,8 +136,9 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma ;;; defines rules to parse the .text segment -(esrap:defrule instr-clean (and (esrap:? space) instr nl-inc) - (:function cadr)) +(esrap:defrule instr-clean (and (esrap:? space) instr nl) + (:function cadr) + (:lambda (i) (incf line-number) i)) (esrap:defrule label-clean (and label-decl nl) (:function car)) -- cgit v1.2.3 From 5d63924222856e9decd4f8981869141ac5a5b430 Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 00:27:40 -0400 Subject: Rename some grammar rules (for better error output --- src/parse.lisp | 43 ++++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 21 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/parse.lisp b/src/parse.lisp index a3c9cbd..2e1cf55 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -12,58 +12,59 @@ (esrap:defrule eol (and (esrap:? space) (esrap:? (and #\; (* (not #\newline)))) #\newline) (:constant nil)) -(esrap:defrule nl (+ eol) +(esrap:defrule newline (+ eol) (:constant nil)) (esrap:defrule sign (or #\+ #\-)) -(esrap:defrule alpha (+ (alphanumericp character)) +(esrap:defrule alphanumeric (+ (alphanumericp character)) (:text t)) ;;; defines rules to parse an integer in various bases (defmacro define-number-rule ()) -(esrap:defrule binary (and #\0 #\B (+ (or "0" "1"))) +(esrap:defrule binary-number (and #\0 #\B (+ (or "0" "1"))) (:lambda (e) (parse-integer (esrap:text (cddr e)) :radix 2))) -(esrap:defrule octal (and #\0 #\O (+ (or (esrap:character-ranges (#\0 #\7))))) +(esrap:defrule octal-number (and #\0 #\O (+ (or (esrap:character-ranges (#\0 #\7))))) (:lambda (e) (parse-integer (esrap:text (cddr e)) :radix 8))) -(esrap:defrule decimal (+ (or (esrap:character-ranges (#\0 #\9)))) +(esrap:defrule decimal-number (+ (or (esrap:character-ranges (#\0 #\9)))) (:lambda (e) (parse-integer (esrap:text e) :radix 10))) -(esrap:defrule hex (and #\0 #\X (+ (or (esrap:character-ranges (#\0 #\9)) +(esrap:defrule hexadecimal-number (and #\0 #\X (+ (or (esrap:character-ranges (#\0 #\9)) "A" "B" "C" "D" "E" "F"))) (:lambda (e) (parse-integer (esrap:text (cddr e)) :radix 16))) -(esrap:defrule int (and (esrap:? sign) (or binary octal hex decimal)) +(esrap:defrule integer (and (esrap:? sign) (or binary-number octal-number + hexadecimal-number decimal-number)) (:destructure (s i) (if (and s (string= s "-")) (- i) i))) ;;; defines rules to parse an operand -(esrap:defrule register (and #\$ int) +(esrap:defrule register (and #\$ integer) (:function cadr) (:lambda (e) (list 'emit::rr e))) -(esrap:defrule variable alpha +(esrap:defrule variable alphanumeric (:lambda (e) (list 'emit::var e))) -(esrap:defrule dereference (and int #\( register #\)) +(esrap:defrule dereference (and integer #\( register #\)) (:destructure (i1 w1 r w2) (declare (ignore w1 w2)) (list r (list 'emit::imm i1)))) -(esrap:defrule immediate (or int variable) +(esrap:defrule immediate (or integer variable) (:lambda (e) (list 'emit::imm e))) ;;; defines rules to parse labels -(esrap:defrule label alpha +(esrap:defrule label alphanumeric (:lambda (e) (list 'emit::l e line-number))) -(esrap:defrule label-decl (and alpha #\:) +(esrap:defrule label-declaration (and alphanumeric #\:) (:function car) (:lambda (e) (util:add-label e line-number) @@ -136,41 +137,41 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma ;;; defines rules to parse the .text segment -(esrap:defrule instr-clean (and (esrap:? space) instr nl) +(esrap:defrule instr-clean (and (esrap:? space) instr newline) (:function cadr) (:lambda (i) (incf line-number) i)) -(esrap:defrule label-clean (and label-decl nl) +(esrap:defrule label-clean (and label-declaration newline) (:function car)) (esrap:defrule text-line (or instr-clean label-clean)) -(esrap:defrule text (and ".TEXT" (esrap:? space) nl (* text-line)) +(esrap:defrule text (and ".TEXT" (esrap:? space) newline (* text-line)) (:function cadddr) (:lambda (e) `(emit::x ,@(remove nil e)))) ;;; defines rules to parse the .data segment -(esrap:defrule data-word (and (esrap:? space) int) +(esrap:defrule data-word (and (esrap:? space) integer) (:function cadr) (:lambda (e) (incf var-offset) e)) -(esrap:defrule var-decl alpha +(esrap:defrule var-declaration alphanumeric (:lambda (e) (util:add-variable e var-offset) nil)) -(esrap:defrule data-line (and (esrap:? space) var-decl (+ data-word) nl) +(esrap:defrule data-line (and (esrap:? space) var-declaration (+ data-word) newline) (:function caddr)) -(esrap:defrule data (and ".DATA" (esrap:? space) nl (* data-line)) +(esrap:defrule data (and ".DATA" (esrap:? space) newline (* data-line)) (:function cadddr) (:lambda (e) `(emit::d ,@(apply #'append e)))) ;;; defines rules to parse a program -(esrap:defrule str->ast (and (* (or space nl)) data text) +(esrap:defrule str->ast (and (* (or space newline)) data text) (:function cdr) (:lambda (e) `(emit::p ,@e))) -- cgit v1.2.3 From 1904e4e800dcf37becb3bba17c3a3aaca3c7a47c Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 03:32:24 -0400 Subject: Add a few new test files --- input/add-loop-directive.asm | 21 --------------- input/add-loop.asm | 24 ----------------- input/adjacent-adder-manual.asm | 30 +++++++++++++++++++++ input/adjacent-adder.asm | 25 +++++++++++++++++ input/dominative-functions.asm | 54 +++++++++++++++++++++++++++++++++++++ input/identity.asm | 59 +++++++++++++++++++++++++++++++++++++++++ input/rabbits.asm | 17 ++++++++++++ input/simple.asm | 5 ---- src/main.lisp | 2 +- src/parse.lisp | 10 +++---- 10 files changed, 191 insertions(+), 56 deletions(-) delete mode 100644 input/add-loop-directive.asm delete mode 100644 input/add-loop.asm create mode 100644 input/adjacent-adder-manual.asm create mode 100644 input/adjacent-adder.asm create mode 100644 input/dominative-functions.asm create mode 100644 input/identity.asm create mode 100644 input/rabbits.asm delete mode 100644 input/simple.asm (limited to 'src/parse.lisp') diff --git a/input/add-loop-directive.asm b/input/add-loop-directive.asm deleted file mode 100644 index 5bccff3..0000000 --- a/input/add-loop-directive.asm +++ /dev/null @@ -1,21 +0,0 @@ -.data - arr 1 2 3 4 - s 3 - i 0 - -.text - load $5 s - load $10 arr - load $6 i - jrl CMP -L: - add $9 $10 $6 - load $7 0($9) - load $8 1($9) - add $7 $7 $8 - - store $7 0($9) - addi $6 $6 0x1 -CMP: - cmp $6 $5 - bgt L diff --git a/input/add-loop.asm b/input/add-loop.asm deleted file mode 100644 index 53520f3..0000000 --- a/input/add-loop.asm +++ /dev/null @@ -1,24 +0,0 @@ -.data -.text - addi $2 $0 0x200 - addi $5 $0 0x1 - store $5 0($2) - addi $5 $0 0x2 - store $5 1($2) - addi $5 $0 0x3 - store $5 2($2) - addi $5 $0 0x4 - store $5 3($2) - addi $5 $0 0x0 - addi $6 $0 0x3 - jrl CHECK -LOOP: - add $9 $2 $5 - load $7 -0($9) - load $8 +1($9) - add $7 $7 $8 - store $7 0($9) - addi $5 $5 0x1 -CHECK: - cmp $6 $5 - bgt LOOP diff --git a/input/adjacent-adder-manual.asm b/input/adjacent-adder-manual.asm new file mode 100644 index 0000000..b575959 --- /dev/null +++ b/input/adjacent-adder-manual.asm @@ -0,0 +1,30 @@ +;;;;;;;; +;;; adds adjacent elements of a 4-element vector together, +;;; storing the result in place. +;;; Does not make use of variables. + +.data + ;; empty +.text + addi $2 $0 0x200 + addi $5 $0 0x1 + store $5 0($2) + addi $5 $0 0x2 + store $5 1($2) + addi $5 $0 0x3 + store $5 2($2) + addi $5 $0 0x4 + store $5 3($2) + addi $5 $0 0x0 + addi $6 $0 0x3 + jrl CHECK +LOOP: + add $9 $2 $5 + load $7 -0($9) + load $8 +1($9) + add $7 $7 $8 + store $7 0($9) + addi $5 $5 0x1 +CHECK: + cmp $6 $5 + bgt LOOP diff --git a/input/adjacent-adder.asm b/input/adjacent-adder.asm new file mode 100644 index 0000000..35704d2 --- /dev/null +++ b/input/adjacent-adder.asm @@ -0,0 +1,25 @@ +;;;;;;;; +;;; adds adjacent elements of a 4-element vector together, +;;; storing the result in place. + +.data + arr 1 2 3 4 + s 3 + i 0 + +.text + addi $5 $5 s + addi $10 $10 arr + addi $6 $6 i + jrl CMP +L: + add $9 $10 $6 + load $7 0($9) + load $8 1($9) + add $7 $7 $8 + + store $7 0($9) + addi $6 $6 0x1 +CMP: + cmp $5 $6 + bgt L diff --git a/input/dominative-functions.asm b/input/dominative-functions.asm new file mode 100644 index 0000000..cb8564e --- /dev/null +++ b/input/dominative-functions.asm @@ -0,0 +1,54 @@ +;;;;;;;; +;;; makes use of a designated function to add two numbers together +;;; uses a stack-based paradigm with a base pointer to manage argument passing +;;; TODO this file is incomplete due to remaining ISA subroutine design issues + +.data + answer 0 + +.text +MAIN: + addi $5 $2 0x0 ; establish frame pointer + + addi $6 $0 -11 + + push $6 + ;; jal SUB23 + store $6 answer($0) +SUB23: + push $5 ; push old frame pointer + addi $5 $2 0x0 + subi $2 $2 0x4 + + addi $6 $0 -23 + store $6 -4($5) + + load $7 +4($5) ; access argument + load $6 -4($5) + + add $6 $6 $7 + push $6 + ;; jal ADD76 + pop $6 ; retrieve and pass along + store $6 +4($5) + + addi $2 $5 0x0 ; restore stack pointer + pop $5 ; restore frame pointer + ;; ret +ADD76: + push $5 + addi $5 $2 0x0 + subi $2 $2 0x4 + + addi $6 $0 +76 + store $6 -4($5) + + load $7 +4($5) ; access argument + load $6 -4($5) + + add $6 $6 $7 + store $6 +4($5) + + addi $2 $5 0x0 + pop $5 + ;; ret diff --git a/input/identity.asm b/input/identity.asm new file mode 100644 index 0000000..e6d9260 --- /dev/null +++ b/input/identity.asm @@ -0,0 +1,59 @@ +;;;;;;;; +;;; performs a matrix multiply on the 4x4 square matrices +;;; m1 and m2, +;;; the result of which is placed into +;;; r, +;;; in this case, the result is the identity +;;; does not use designated vector instructions + +.data + m1 01 00 -1 00 00 01 00 -1 00 00 01 00 00 00 00 01 + m2 01 00 01 00 00 01 00 01 00 00 01 00 00 00 00 01 + r 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +.text + addi $8 $0 0x4 ; dimensions + addi $9 $0 0x0 ; tracks the rows + addi $10 $0 0x0 ; tracks the columns + jrl ROWCOND + +ROW: + jrl COLCOND +COL: + addi $11 $0 0x0 ; tracks the element being added + addi $12 $0 0x0 ; the accumulated result to place into $9,$10 + + mul $7 $9 $8 ; setup the index into m1 + addi $5 $7 m1 + + addi $6 $0 m2 ; setup the index into m2 + add $6 $6 $10 + + jrl ELECOND +ELE: + add $5 $5 $11 ; increment m1 + + mul $13 $11 $8 ; increment m2 + add $6 $6 $13 + + load $13 0($5) ; retrieve and accumulate + load $14 0($6) + add $12 $14 $13 + + addi $11 $11 0x1 +ELECOND: + cmp $8 $11 + bgt ELE + addi $10 $10 0x1 +COLCOND: + cmp $8 $10 + bgt COL + + add $7 $7 $10 ; setup the index into r + addi $7 $7 r + + store $12 0($7) + + addi $9 $9 0x1 +ROWCOND: + cmp $8 $9 + bgt ROW diff --git a/input/rabbits.asm b/input/rabbits.asm new file mode 100644 index 0000000..c848116 --- /dev/null +++ b/input/rabbits.asm @@ -0,0 +1,17 @@ +;;;;;;;; +;;; multiplies numbers until an overflow occurs + +.data + rabbits 2 + rate 300 + +.text + load $5 rabbits($0) + load $6 rate($0) + +BREED: + mul $5 $5 $6 + store $5 rabbits($0) + bof DONE + jrl BREED +DONE: diff --git a/input/simple.asm b/input/simple.asm deleted file mode 100644 index 3e60ee8..0000000 --- a/input/simple.asm +++ /dev/null @@ -1,5 +0,0 @@ - addi $sp $0 512 - addi $5 $0 1 - store $5 0($sp) - addi $5 $0 2 - store $5 1($sp) diff --git a/src/main.lisp b/src/main.lisp index 517d395..f1f3021 100644 --- a/src/main.lisp +++ b/src/main.lisp @@ -65,7 +65,7 @@ _/_/ _/_/ " (let ((words (emit:emit ast))) (if write? (postprocess words file) - (format t "Emission successfull, got: ~%~a~%" words))) + (format t "Emission successful, got: ~%~a~%" words))) (format t "Parse successful, got:~%~a~%" (emit:ast->str ast)))) (error "The file does not exist, or it could not be opened.~%"))))))) diff --git a/src/parse.lisp b/src/parse.lisp index 2e1cf55..f435c0a 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -51,14 +51,14 @@ (esrap:defrule variable alphanumeric (:lambda (e) (list 'emit::var e))) -(esrap:defrule dereference (and integer #\( register #\)) - (:destructure (i1 w1 r w2) - (declare (ignore w1 w2)) - (list r (list 'emit::imm i1)))) - (esrap:defrule immediate (or integer variable) (:lambda (e) (list 'emit::imm e))) +(esrap:defrule dereference (and immediate #\( register #\)) + (:destructure (i1 w1 r w2) + (declare (ignore w1 w2)) + (list r i1))) + ;;; defines rules to parse labels (esrap:defrule label alphanumeric -- cgit v1.2.3 From 5c9ac514d0556d875a12b2c7d3c4aedf23b9575b Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 03:54:53 -0400 Subject: Remove unnecessary imm ast node --- src/emit.lisp | 2 -- src/parse.lisp | 4 ++-- t/parse.lisp | 34 +++++++++++++++++----------------- 3 files changed, 19 insertions(+), 21 deletions(-) (limited to 'src/parse.lisp') diff --git a/src/emit.lisp b/src/emit.lisp index a6e4bbb..213eb1a 100644 --- a/src/emit.lisp +++ b/src/emit.lisp @@ -52,8 +52,6 @@ concatenated with TYPE." (util:format-as-binary val 5) (error (format nil "~a is not a valid register id!~%" val)))) -(defun imm (val) val) - (defun l (l s) (let ((d (util:get-label l))) (- d s))) diff --git a/src/parse.lisp b/src/parse.lisp index f435c0a..e58dea0 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -52,7 +52,7 @@ (:lambda (e) (list 'emit::var e))) (esrap:defrule immediate (or integer variable) - (:lambda (e) (list 'emit::imm e))) + (:lambda (e) e)) (esrap:defrule dereference (and immediate #\( register #\)) (:destructure (i1 w1 r w2) @@ -130,7 +130,7 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (esrap:defrule j-type-2 (and j-type-2-m space register) (:destructure (m w r) (declare (ignore w)) - `(emit::j ,m ,r (emit::imm 0)))) + `(emit::j ,m ,r 0))) (esrap:defrule instr (or r-type-1 r-type-2 r-type-3 i-type-1 i-type-2 i-type-3 j-type-1 j-type-2 j-type-3)) diff --git a/t/parse.lisp b/t/parse.lisp index 993447f..7c084aa 100644 --- a/t/parse.lisp +++ b/t/parse.lisp @@ -32,9 +32,9 @@ '(emit::p (emit::d) (emit::x - (emit::i "LOADV" (emit::rr 8) (emit::rr 9) (emit::imm 1)) - (emit::i "STORE" (emit::rr 3) (emit::rr 5) (emit::imm 3)) - (emit::i "ADDI" (emit::rr 4) (emit::rr 5) (emit::imm 2)))) + (emit::i "LOADV" (emit::rr 8) (emit::rr 9) 1) + (emit::i "STORE" (emit::rr 3) (emit::rr 5) 3) + (emit::i "ADDI" (emit::rr 4) (emit::rr 5) 2))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tLOADV $8 1($9) ~tSTORE $5 3($3)~%~tADDI $5 $4 2~%"))))) @@ -43,9 +43,9 @@ '(emit::p (emit::d) (emit::x - (emit::j "JMP" (emit::rr 3) (emit::imm 3)) + (emit::j "JMP" (emit::rr 3) 3) (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 8)) - (emit::j "PUSH" (emit::rr 5) (emit::imm 0)))) + (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tJMP 3($3) ~tJRL FOO~%~tPUSH $5~%"))))) @@ -54,7 +54,7 @@ '(emit::p (emit::d) (emit::x - (emit::i "LOADV" (emit::rr 8) (emit::rr 3) (emit::imm -3)))) + (emit::i "LOADV" (emit::rr 8) (emit::rr 3) -3))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tLOADV $8 -3($3)~%"))))) (test esrap-instr-type-i-vars @@ -62,8 +62,8 @@ '(emit::p (emit::d) (emit::x - (emit::i "LOADV" (emit::rr 8) (emit::rr 4) (emit::imm 2)) - (emit::i "STORE" (emit::rr 1) (emit::rr 5) (emit::imm 2)))) + (emit::i "LOADV" (emit::rr 8) (emit::rr 4) 2) + (emit::i "STORE" (emit::rr 1) (emit::rr 5) 2))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tLOADV $8 2($4) ~tSTORE $5 2($1)~%"))))) @@ -72,9 +72,9 @@ '(emit::p (emit::d) (emit::x - (emit::j "JMP" (emit::rr 3) (emit::imm 3)) + (emit::j "JMP" (emit::rr 3) 3) (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 14)) - (emit::j "PUSH" (emit::rr 5) (emit::imm 0)))) + (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%~%.TEXT~t~%JMP 3($3)~t JRL FOO~t~%PUSH $5~%"))))) @@ -83,9 +83,9 @@ JRL FOO~t~%PUSH $5~%"))))) '(emit::p (emit::d) (emit::x - (emit::j "JMP" (emit::rr 3) (emit::imm 3)) + (emit::j "JMP" (emit::rr 3) 3) (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 17)) - (emit::j "PUSH" (emit::rr 5) (emit::imm 0)))) + (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT;; dot dot dot ~tJMP 3($3) ;; this does things ~tJRL FOO~%~tPUSH $5~%"))))) @@ -131,7 +131,7 @@ H 3 5~%.TEXT~%"))))) (emit::d -1) (emit::x - (emit::i "LOADV" (emit::rr -8) (emit::rr -3) (emit::imm -3)))) + (emit::i "LOADV" (emit::rr -8) (emit::rr -3) -3))) (esrap:parse 'parse:str->ast (format nil ".DATA~%~tm -1~%.TEXT~%~tLOADV $-8 -3($-3)~%"))))) (test esrap-data-full @@ -140,12 +140,12 @@ H 3 5~%.TEXT~%"))))) (emit::d 1 2 3 4 3 0) (emit::x - (emit::i "ADDI" (emit::rr 0) (emit::rr 5) (emit::imm (emit::var "S"))) - (emit::i "ADDI" (emit::rr 0) (emit::rr 10) (emit::imm (emit::var "ARR"))) - (emit::i "ADDI" (emit::rr 0) (emit::rr 6) (emit::imm (emit::var "I"))) + (emit::i "ADDI" (emit::rr 0) (emit::rr 5) (emit::var "S")) + (emit::i "ADDI" (emit::rr 0) (emit::rr 10) (emit::var "ARR")) + (emit::i "ADDI" (emit::rr 0) (emit::rr 6) (emit::var "I")) (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 23)) (emit::r "ADD" (emit::rr 10) (emit::rr 6) (emit::rr 9)) - (emit::i "ADDI" (emit::rr 6) (emit::rr 6) (emit::imm 1)) + (emit::i "ADDI" (emit::rr 6) (emit::rr 6) 1) (emit::r "CMP" (emit::rr 6) (emit::rr 5) (emit::rr 0)) (emit::j "BGT" (emit::rr 0) (emit::l "L" 27)))) (esrap:parse 'parse:str->ast (format nil " -- cgit v1.2.3 From 639098b1ea82be82bd18a4af415458fcbaf5e20b Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 11 Apr 2025 16:39:21 -0400 Subject: Add RET and NOP j-type instructions --- input/dominative-functions.asm | 5 +++-- src/parse.lisp | 11 ++++++++--- src/util.lisp | 2 +- t/parse.lisp | 11 ++++++----- 4 files changed, 18 insertions(+), 11 deletions(-) (limited to 'src/parse.lisp') diff --git a/input/dominative-functions.asm b/input/dominative-functions.asm index cb8564e..530717d 100644 --- a/input/dominative-functions.asm +++ b/input/dominative-functions.asm @@ -14,6 +14,7 @@ MAIN: push $6 ;; jal SUB23 + pop $6 store $6 answer($0) SUB23: push $5 ; push old frame pointer @@ -34,7 +35,7 @@ SUB23: addi $2 $5 0x0 ; restore stack pointer pop $5 ; restore frame pointer - ;; ret + ret ADD76: push $5 addi $5 $2 0x0 @@ -51,4 +52,4 @@ ADD76: addi $2 $5 0x0 pop $5 - ;; ret + ret diff --git a/src/parse.lisp b/src/parse.lisp index e58dea0..0ea6c0d 100644 --- a/src/parse.lisp +++ b/src/parse.lisp @@ -84,11 +84,12 @@ (generate-mnemonic 'i-type-2-m '("STOREV" "STORE")) (generate-mnemonic 'j-type-1-m '("JMP" "JAL")) (generate-mnemonic 'j-type-2-m '("PUSH" "POP")) +(generate-mnemonic 'j-type-3-m '("RET" "NOP")) ;; we need to reverse to ensure rules like "ADDV" are matched before "ADD" (generate-mnemonic 'r-type-3-m (reverse util:r-type)) (generate-mnemonic 'i-type-3-m (reverse util:i-type)) -(generate-mnemonic 'j-type-3-m (reverse util:j-type)) +(generate-mnemonic 'j-type-4-m (reverse util:j-type)) ;; TODO this is pretty gross (defmacro defrule-instr (name type-id order &rest destructure-pattern) @@ -110,7 +111,7 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (defrule-instr r-type-2 'emit::r (0 1 2) register register) (defrule-instr r-type-3 'emit::r (1 2 0) register register register) (defrule-instr i-type-3 'emit::i (1 0 2) register register immediate) -(defrule-instr j-type-3 'emit::j (1 0) label) +(defrule-instr j-type-4 'emit::j (1 0) label) (esrap:defrule i-type-1 (and i-type-1-m space register space dereference) (:destructure (m w1 s w2 di) @@ -132,8 +133,12 @@ DESTRUCTURE-PATTERN is the list of non-terminals on the right side of the gramma (declare (ignore w)) `(emit::j ,m ,r 0))) +(esrap:defrule j-type-3 j-type-3-m + (:lambda (m) + `(emit::j ,m (emit::rr 0) 0))) + (esrap:defrule instr (or r-type-1 r-type-2 r-type-3 i-type-1 i-type-2 - i-type-3 j-type-1 j-type-2 j-type-3)) + i-type-3 j-type-1 j-type-2 j-type-3 j-type-4)) ;;; defines rules to parse the .text segment diff --git a/src/util.lisp b/src/util.lisp index 8d98680..e52d7aa 100644 --- a/src/util.lisp +++ b/src/util.lisp @@ -76,5 +76,5 @@ of the elements from both lists. Returns nil if the lists are not equal size." "I-type instructions.") (defvar j-type - '("JMP" "JRL" "JAL" "BEQ" "BGT" "BUF" "BOF" "PUSH" "POP") + '("JMP" "JRL" "JAL" "BEQ" "BGT" "BUF" "BOF" "PUSH" "POP" "RET" "NOP") "J-type instructions.") diff --git a/t/parse.lisp b/t/parse.lisp index 7c084aa..2612f45 100644 --- a/t/parse.lisp +++ b/t/parse.lisp @@ -45,9 +45,10 @@ (emit::x (emit::j "JMP" (emit::rr 3) 3) (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 8)) + (emit::j "RET" (emit::rr 0) 0) (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT~%~tJMP 3($3) -~tJRL FOO~%~tPUSH $5~%"))))) +~tJRL FOO~%~tRET~%~tPUSH $5~%"))))) (test esrap-instr-type-i-negative (is (equal @@ -73,7 +74,7 @@ (emit::d) (emit::x (emit::j "JMP" (emit::rr 3) 3) - (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 14)) + (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 15)) (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%~%.TEXT~t~%JMP 3($3)~t JRL FOO~t~%PUSH $5~%"))))) @@ -84,7 +85,7 @@ JRL FOO~t~%PUSH $5~%"))))) (emit::d) (emit::x (emit::j "JMP" (emit::rr 3) 3) - (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 17)) + (emit::j "JRL" (emit::rr 0) (emit::l "FOO" 18)) (emit::j "PUSH" (emit::rr 5) 0))) (esrap:parse 'parse:str->ast (format nil ".DATA~%.TEXT;; dot dot dot ~tJMP 3($3) ;; this does things @@ -143,11 +144,11 @@ H 3 5~%.TEXT~%"))))) (emit::i "ADDI" (emit::rr 0) (emit::rr 5) (emit::var "S")) (emit::i "ADDI" (emit::rr 0) (emit::rr 10) (emit::var "ARR")) (emit::i "ADDI" (emit::rr 0) (emit::rr 6) (emit::var "I")) - (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 23)) + (emit::j "JRL" (emit::rr 0) (emit::l "CMP" 24)) (emit::r "ADD" (emit::rr 10) (emit::rr 6) (emit::rr 9)) (emit::i "ADDI" (emit::rr 6) (emit::rr 6) 1) (emit::r "CMP" (emit::rr 6) (emit::rr 5) (emit::rr 0)) - (emit::j "BGT" (emit::rr 0) (emit::l "L" 27)))) + (emit::j "BGT" (emit::rr 0) (emit::l "L" 28)))) (esrap:parse 'parse:str->ast (format nil " .DATA ARR 1 2 3 4 -- cgit v1.2.3