From f415595a407fe6b67959b20e75ef210a3882ddf6 Mon Sep 17 00:00:00 2001 From: Joscha Date: Mon, 25 Nov 2019 22:11:43 +0000 Subject: [PATCH] Update examples and add simple example --- examples/README.md | 61 +++++++++++++++++++++------------ examples/subtract.mima | Bin 0 -> 42 bytes examples/subtract.mima-symbols | 4 +++ examples/subtract.mimasm | 22 ++++++++++++ 4 files changed, 66 insertions(+), 21 deletions(-) create mode 100644 examples/subtract.mima create mode 100644 examples/subtract.mima-symbols create mode 100644 examples/subtract.mimasm diff --git a/examples/README.md b/examples/README.md index d323e8e..77e700c 100644 --- a/examples/README.md +++ b/examples/README.md @@ -1,44 +1,50 @@ # Example MiMa programs -This folder contains a few example programs, both as `.mimasm` and as -assembled `.mima` files. +This folder contains a few example programs, both as `.mimasm` and as assembled +`.mima` files. * [Basic programs](#basic-programs) * [Advanced programs](#advanced-programs) ## Basic programs -### [`jmp_to_address_in_acc.mimasm`](jmp_to_address_in_acc.mimasm) +### [`subtract.mimasm`](subtract.mimasm) -This program demonstrates two different techniques for jumping to an -address that is currently stored in the `ACC` register. +This is a very simple program that just subtracts a value from another and +stores the result in memory. It is meant as a starting point for working with +this repo's tools. ### [`call_ret.mimasm`](call_ret.mimasm) -This program demonstrates how the `CALL` and `RET` instructions -behave. It doesn't use any sort of stack, so the call depth is limited -to 1. +This program demonstrates how the `CALL` and `RET` instructions behave. It +doesn't use any sort of stack, so the call depth is limited and recursion is not +easily possible. ### [`call_ret_stack.mimasm`](call_ret_stack.mimasm) -This program works similar to `call_ret.mimasm`, but uses the `SP` -register for a stack. This way, it can have nested `CALL`s by storing -the content of the `RA` register on the stack. +This program works similar to `call_ret.mimasm`, but uses the `SP` register for +a stack. This way, it can have nested `CALL`s by storing the content of the `RA` +register on the stack. + +### [`jmp_to_address_in_acc.mimasm`](jmp_to_address_in_acc.mimasm) + +This program demonstrates two different techniques for jumping to an address +that is currently stored in the `ACC` register. ## Advanced programs ### [`stack.mimasm`](stack.mimasm) -This program demonstrates the use of stack frames for calling a -function and passing parameters. To call a function, it creates a -shared stack frame containing the function's input parameters and -enough space for its return values. +This program demonstrates the use of stack frames for calling a function and +passing parameters. To call a function, it creates a shared stack frame +containing the function's input parameters and enough space for its return +values. ### [`fib.mimasm`](fib.mimasm) -This program calculates the first few fibonacci numbers and stores -them in consecutive memory locations. It uses a stack with stack -frames and recursive calls according to the following pattern: +This program calculates the first few fibonacci numbers and stores them in +consecutive memory locations. It uses a stack with stack frames and recursive +calls according to the following pattern: ``` c++ int fib(int n) { @@ -48,6 +54,19 @@ int fib(int n) { } ``` -This recursive solution for calculating fibonacci numbers is by far -not the most efficient, but it demonstrates recursion and stack usage -quite well. +This recursive solution for calculating fibonacci numbers is by far not the most +efficient, but it demonstrates recursion and stack usage quite well. + +### [`bench.mimasm`](bench.mimasm) + +This program is `fib.miamsm`, but it calculates the first 24 fibonacci numbers +instead of the first 10. It is meant as a benchmark for MiMa emulators and takes +11877318 steps to execute (not counting the HALT instruction). + +### [`sort.mimasm`](sort.mimasm) + +This program sorts an array of numbers that starts at memory address 0. It +demonstrates a few more advanced assembler directives, including flags, as well +as a bit of non-trivial, non-stack-management logic. It is based on an exercise +that defined areas for the array, temporary variables and code, as well as a +field containg the address of the array's last element. diff --git a/examples/subtract.mima b/examples/subtract.mima new file mode 100644 index 0000000000000000000000000000000000000000..8dc64263c4c978131b57c0207113345d799e6c5d GIT binary patch literal 42 mcmZQzU}iu85)2Hy3=9kc42&Nc7%ng{8Za;@Ffe^!U;qFjc>_KG literal 0 HcmV?d00001 diff --git a/examples/subtract.mima-symbols b/examples/subtract.mima-symbols new file mode 100644 index 0000000..cf3ea9c --- /dev/null +++ b/examples/subtract.mima-symbols @@ -0,0 +1,4 @@ +00000: val1 +00001: val2 +00002: result +00003: start diff --git a/examples/subtract.mimasm b/examples/subtract.mimasm new file mode 100644 index 0000000..befdb69 --- /dev/null +++ b/examples/subtract.mimasm @@ -0,0 +1,22 @@ +; This program computes 'val1 - val2' and stores the result in memory again. + +; Set the IAR to the instruction at the 'start' label +.reg IAR start + +; Prepare the input and output +val1: .lit 24 +val2: .lit 13 +result: .lit 0 + +; First, we load and negate val2 +start: +LDV val2 +NOT +ADC 1 + +; Then, we can add val1 and store the result +ADD val1 +STV result + +; Don't forget to halt, or the MiMa will run until the IAR hits the maximum address. +HALT