Louve

Louve is a 16 bits processor architecture. She^* has 16 operations and handles 16 bits numbers (which means the highest positive number is 65535).

Memory addresses are also 16 bits numbers, so the highest amount of memory a program can have is 64K words.

* Louve is a female wolf in the Ferale Computer project.

Operations

Operation encoding

Each operation is expressed in binary as a 16 bits number. It's easy to express in hexadecimal because every nibble (pack of 4 bits) encodes a different part of the operation.

Example

The operation 1AB9 reads memory at address given by register A, increment this address (pull mode), then reads memory at address given by register B, adds the values together (ADD) and puts the result in memory at address given by register B.

In assembly language, it would be written ADD (A++), (B).

In a real situation, it could be part of a "sum" function: Register A would point to the list of values to be summed, and B to the result. Calling this in a loop would sum up all values.

Modes

(1) Shift and Rotate

Those two operations don't use the Source argument like others. Instead of using Source as a register, it tells how many bits to shift or rotate, and the Source mode gives the direction.

(2) Comparison

CMP compares two values and save the result in three flags. It's up to you to decide which result is significant depending on what the initial numbers were supposed to be.

(3) Direct Memory Copy

DMC does an immediate copy of multiple consecutive values from one part of memory to another.

It's faster than implementing a loop yourself.

Source and Destination registers must contain addresses. They will be read with mode 10 (pull).

Size register must contain an unsigned number which will act as a counter for the operation.

Example

    MOV 1200, R8 ; source of the data
    MOV F000, R9 ; destination address
    MOV   80, RA ; size = 128 words
    DMC R8,R9,RA

(4) Command

(5) Jump

Jump example

Registers and flags

Numbers

Numbers are 16 bits. It means there are encoded in binary with 16 digits.

Depending on your interpretation, numbers can be considerer unsigned (all the bits encode a positive value), or signed (the highest bit means "negative" and the remaining 15 bits encode the value).

Mixing them in operations is not recommended, and might trigger the "overflow" flag.

Parts of a binary number have special names.

Louve expects the memory to contain 64K words (65536 numbers of 16 bits).

It's usually implemented in hardware by putting two 64KB memory chips together.

Bourdon syntax (assembly language)

It can be tedious to write (and read!) a whole program in hexadecimal. So there's a program called an assembler, which reads source code and transforms it into the equivalent binary format.

The assembler for Louve is called Bourdon and has the following syntax.

Syntax

label          OPERATION arg1, arg2, ...

      sublabel OPERATION arg1, arg2, ...

               META arg1 arg2 ...

; comment

Meta operations

AT address

DEF name value

DATA val1 val2 ...

FILL num val1 val2 ...

STR string

RET

Meta examples

AT F100

DEF STDOUT 7F80

DATA 6C 6F 1234

FILL 0F    A0A0 B0B0

STR Hello,\0ATo the world\21

Hello world example

0000:
0002:
0004:






0005:
0006:
0008:
0009:
000A:
000C:
000E:
000F:


0010:
0011:
0013:
0015:
0017:
0019:
001B:
001D:

0F88 0010
FF09 0005
E000






E300
0F18 F100
0808
0819
3F08 0001
FFB8 0009
E400
0DF8


000D
0048 0065
006C 006C
006F 0020
0057 006F
0072 006C
0064 0021
000A

DEF STDOUT F100

AT 0000

program  MOV hello, R8
         CALL A, print
         HALT

;; (print) a length-prefixed string to STDOUT
;; in --
;; R8 string address
;; out --
;; None
print    INCB
         MOV STDOUT, R1
         MOV (R8++), R0    ; get length
    loop MOV (R8++), (R1)  ; put char out
         SUB 1, R0         ; len--
         JUMP !Z, loop     ; repeat until len=0
         DECB
         RET

hello
DATA 0D
STR Hello world!\0A

Lexer/Parser/Assembler algorithm

• Start with space?
• NO: Meta or Operation or Label
• YES: Meta or Operation or Sublabel
• Semicolon: Skip until end of line

Forbidden identifiers for labels

Operations: MOV ADD ADC SUB SBC SHF ROT SWP NOT AND IOR XOR CMP DMC JUMP CALL
Commands: HALT RTI SWI INCB DECB
Meta: AT DEF DATA FILL STR RET
1 letter words, including flags: I V N Z C M A
Register names: R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 RA RB RC RD RE RF SP SR PC
2 and 4 digits hexadecimal numbers: FEED, DEAD, BEAF, F00D, AD, FADE...

5 letters words and above will always pass as labels. The check is only required for the first 4 letters.

A finite state machine is used to quickly check if a token is a reserved keyword (and determine which one, to be used in the parser too).

A-D-D    Operation 1
|  \
|   C    Operation 2
|\
| N-D    Operation 9
 \
  T      Meta AT

S-U-B    Operation 3
|\
| B-C    Operation 4
|\
| H-F    Operation 5
|\
| W-P    Operation 7
|  \
|   I    Command E2
|\
| P      Register RD
|\
| R      Register RE
 \
  T-R    Meta STR

D-M-C    Operation D
|\
| E-C-B  Command E4
|  \
|   F    Meta DEF
 \
  A-T-A  Meta DATA

R-O-T    Operation 6
|\
| T-I    Command E1
|\
| E-T    Meta RET
 \
  hex?   Register R?

C-M-P    Operation C
 \
  A-L-L  Operation F (call)

I-O-R    Operation A
 \
  N-C-B  Command 3

P-C      Register RF
M-O-V    Operation 0
N-O-T    Operation 8
X-O-R    Operation B
J-U-M-P  Operation F (jump)
H-A-L-T  Command 0
F-I-L-L  Meta FILL

This tree is used on every token to generate the Abstract Syntax Tree (AST) of the source code.

Then the parser checks the grammar.

Then the assembler can move through the AST and apply two passes: Generate as much binary as possible while leaving "holes" for the missing references, then passing again filling those holes with calculated values.

Credits

The initial Louve design was heavily inspired from the QNICE architecture by Bernd Ulmann and their team. Thanks to them!

The uxn architecture and the Varvara project were also a big influence on my work. The uxn community rocks!

Apart from those inspirations, the Ferale Computer project is made with love and dedication by Zoé since 2018.