This project for CSE 141L presents a general purpose instruction set and processor design files for the Cumulus architecture. This processor was designed primarily to accelerate specific lfsr encryption and decryption algorithms which feature specialized operations and simple memory access patterns. As a result, many instructions are restricted to use Special Purpose (SP) registers in an attempt to minimize required operand encoding space. Additionally, there are few General Purpose (GP) registers. Finally, the architecture uses a direct register addressing mode since 8 byte addresses are sufficient for the memory requirements.
The Cumulus architecture is an Accumulator processor and features a direct register addressing mode. Registers are 8 bits, and instructions are 9 bits.
There are 16 total registers supported, but only 8 General Purpose registers. The register map is included below. Although r10 and r11 are indicated as read and write incrementors, they can be used for any incrementation purpose.
| Register(s) | Type | Purpose |
|---|---|---|
| r0 | GP | A = accumulator |
| r1 - r7 | GP | 7 extra general purpose registers |
| r8 - r10 | SP | decrementors |
| r11 | SP | read incrementor |
| r12 | SP | write incrementor |
| r13 | SP | incrementor |
| r14 | GP | link register |
| r15 | GP | processor flags = [done, 0, 0, 0, 0, 0, 0, zero] |
The done flag will be set by the program when the program has finished, and will be unset by the test bench when the next program should run. The done flag is not automatically set after each instruction, so it can be modified by programs using the PUT command.
| Type | Layout |
|---|---|
| Large Immediate (I) Type | 1 bit opcode, 8 bit operand |
| Small Immediate (T) Type | 6 bit opcode, 3 bit immediate |
| Special Purpose register source (S) Type | 6 bit opcode, 3 bit operand |
| General Purpose register source (G) Type | 6 bit opcode, 3 bit operand |
| Any register source (A) Type (4 bit operand) | 5 bit opcode, 4 bit operand |
| Instruction | Type | Description | Pseudocode | Encoding |
|---|---|---|---|---|
| LDI | I | loads an 8 bit immediate field into A | A = #immd; | [1 xxxx xxxx] where x is the 8 bit immediate |
| PUT | A | Copies the accumulator value to any destination register | reg[x]= A; | [0 0000 xxxx] where x is the destination register |
| GET | A | Gets any source register and saves it to the accumulator | A = reg[x]; | [0 0001 xxxx] where x is the source register |
| LDW | S | Load word from memory at index address to A | A = mem[index]; | [0 0010 1xxx] where x is the index which is an SP register |
| STW | S | Store word from G0 register to memory at index address (SP) | mem[index] = A; | [0 0011 1xxx] where x is the index which is an SP register |
| NXT | S | Increments/Decrements/Next-state a SP register according to their type | src = next_state(src); | [0 0100 1xxx] where x is the source which is an SP register |
| CLB | G | Sets the leading (parity) bit of a GP register to 0 | reg[src][7] = 0; | [0 0101 0xxx] where x is the source and destination GP register |
| ADD | A | Add src to A | A = A + src; | [0 0110 xxxx] where x is the source which can be any register |
| AND | A | Bitwise AND between A and src | A = A & src; | [0 0111 xxxx] where x is the source which can be any register |
| LSH | T | Perform a left shift on A by the immediate amount | A = A << #imm; | [0 1000 0xxx] where x is a 3 bit immediate |
| NOP | T | No operation performed, encoded as a LSH by 0 | A = A << 0; | [0 1000 0000] |
| RXR | A | Generate an xor reduction parity bit from src is an error | A = ^(src); | [0 1001 xxxx] where x is any register |
| XOR | A | Bitwise XOR between A and src | A = A ^ src; | [0 1010 xxxx] where x is the source which can be any register |
| DNE | T | Set the done flag, indicates the program is finished, stalls the PC | done = 1; | [0 1011 1111] although marked as T type, the immediate does not matter |
| JNZ | G | Jump to value in src if Zero flag is false | pc = Z == 0? src : pc; | [0 1100 0xxx] where x is the jump target which is an GP |
| JEZ | G | Jump to value in src if Zero flag is true | pc = Z == 1? src : pc; | [0 1101 0xxx] where x is the jump target which is an GP |
| JMP | G | Unconditional jump to instruction address in src | pc = src; | [0 1110 0xxx] where x is the jump target which is an GP |
| JAL | G | Jump to address in src (GP) and save pc+4 to link | pc = src; link = pc + 4; | [0 1111 0xxx] where x is the jump target which is an GP |
Example instruction for incrementing the read incrementor state by one stage:
NXT $r11 = [0 0001 0011]
Note: although the operand is $r11 since the NXT instruction can only apply to SP registers, the leading bit of the register address is ignored in the operand encoding. Thus, 14 = ‘b1011 becomes ‘b011 when encoded into this instruction.
The example programs can be found in firmware/*.asm.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent