ULM Generator: ALU Interface

ALU Interface

session07/ulm-generator/ulm0/hdw_alu.h 
#ifndef ULM0_HDWALU_H
#define ULM0_HDWALU_H

#include <stdbool.h>
#include <stdint.h>

// ALU
typedef uint64_t ulm_Reg;

enum
{
    ULM_ZF = 0,
    ULM_CF,
    ULM_SF,
    ULM_OF,
    ULM_NUM_STATUS_FLAGS,
};

extern bool ulm_statusReg[ULM_NUM_STATUS_FLAGS];

uint64_t ulm_regVal(ulm_Reg reg);
void ulm_setReg(uint64_t val, ulm_Reg reg);
void ulm_add64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_sub64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_mul64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_mul128(uint64_t a, uint64_t b, ulm_Reg dest0, ulm_Reg dest1);
void ulm_div128(uint64_t a, uint64_t b0, uint64_t b1, ulm_Reg dest0,
                ulm_Reg dest1, ulm_Reg dest2);
void ulm_idiv64(int64_t a, int64_t b, ulm_Reg dest);
void ulm_shiftLeft64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_shiftRightSigned64(uint64_t a, int64_t b, ulm_Reg dest);
void ulm_shiftRightUnsigned64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_and64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_or64(uint64_t a, uint64_t b, ulm_Reg dest);
void ulm_not64(uint64_t a, ulm_Reg dest);

#endif // ULM0_HDWALU_H

Register Content

1
uint64_t ulm_regVal(ulm_Reg reg);

For a given pattern \(\text{reg}\) returns \(\%\text{reg}\).

Register Initialization

1
void ulm_setReg(uint64_t val, ulm_Reg reg);

Initializes register: \(u(\text{val}) \to u(\%\text{reg})\)

Integer Addition

1
void ulm_add64(uint64_t a, uint64_t b, ulm_Reg dest);

Computes \(\left(u(\text{a}) + u(\text{b})\right) \bmod 2^{64} \to \%\text{dest}\) and updates the status registers:

Flag

Condition

ZF

\(\left(u(\text{a}) + u(\text{b})\right) \bmod 2^{64} = 0\)

CF

\(u(\text{a}) + u(\text{b}) \geq 2^{64}\)

OF

\(s(\text{a}) + s(\text{b}) \notin \{-2^{63},\dots,2^{63}-1\}\)

SF

\(s(\text{a}) + s(\text{b}) < 0\)

Integer Subtraction

1
void ulm_sub64(uint64_t a, uint64_t b, ulm_Reg dest);

Computes \(\left(-u(\text{a}) + u(\text{b})\right) \bmod 2^{64} \to \%\text{dest}\) (read as subtract a from b) and updates the status registers:

Flag

Condition

ZF

\(\left(-u(\text{a}) + u(\text{b})\right) \bmod 2^{64} = 0\)

CF

\(u(-\text{a}) + u(\text{b}) \geq 2^{64}\)

OF

\(s(-\text{a}) + s(\text{b}) \notin \{-2^{63},\dots,2^{63}-1\}\)

SF

\(-s(\text{a}) + s(\text{b}) < 0\)

(Signed) Integer Multiplication

1
void ulm_mul64(uint64_t a, uint64_t b, ulm_Reg dest);

Computes \(\left(u(\text{a}) \cdot u(\text{b})\right) \bmod 2^{64} \to \%\text{dest}\) (read as subtract a from b) and updates the following status registers:

Flag

Condition

CF

\(\left(u(\text{a}) \cdot u(\text{b})\right) \bmod 2^{64} \neq u(\text{a}) \cdot u(\text{b})\)

OF

\(\left(s(\text{a}) \cdot s(\text{b})\right) \bmod 2^{64} \neq s(\text{a}) \cdot s(\text{b})\)

Exercise

The following program is supposed to compute \((42-1) \cdot 13\) and then terminate with the result as exit code:

1
2
3
4
5
6
03 00 2A 01
03 00 01 02
06 02 01 02
03 00 0D 01
07 01 02 01
01 01 12 34

Use the ULM Generator to build a computer where this program actually does that.

Submit your description isa.txt of the instruction set with submit hpc quiz06 isa.txt.