72 lines
2.5 KiB
Markdown
72 lines
2.5 KiB
Markdown
# Example MiMa programs
|
|
|
|
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
|
|
|
|
### [`subtract.mimasm`](subtract.mimasm)
|
|
|
|
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 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.
|
|
|
|
### [`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.
|
|
|
|
### [`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:
|
|
|
|
``` c++
|
|
int fib(int n) {
|
|
if (n == 0) return 0;
|
|
if (n == 1) return 1;
|
|
return fib(n - 1) + fib(n - 2);
|
|
}
|
|
```
|
|
|
|
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.
|