HW$3-$ Binary Modulo

icode$$Behaviors:

icodeoperation$0$rA $=$ rB

$1$rA $+=$ rB

$2$rA &$=$ rB

$3$rA $=$read from memory at address$$rB

$4$write$$rA$$to memory at address$$rB

$5$do different things for different values of$$b:

baction$0$rA $=$ ~rA$1$rA $=-$rA$2$rA $=!$rA$3$rA $=$ pc

$6$do different things for different values of$$b:

baction$0$rA $=$read from memory at$$pc $+11$rA $+=$read from memory at$$pc $+12$rA &$=$read from memory at$$pc $+13$rA $=$read from memory at the address stored at$$pc $+1$

In all $4$ cases, increase$$pc$$by $2,$ not $1,$ at the end of this instruction

$7$Compare$$rA$($as an $8-$bit $2$s$-$complement number$)$ to$0$; $-$ if$$rA $<=0,$ set$$pc $=$ rB$-$ otherwise, increment$$pc$$like normal.

Task

code should

Load the values in memory at addresses$0$x$01$and$0$x$03$into registersNote: since we have not discussed ways to get other data into our memory yet, we will directly modify your code so that the second $(0$x$01)$ and fourth $(0$x$03)$ bytes are the input values.$$This means your first $(0$x$00)$ and third $(0$x$02)$ bytes $($instructions$)$ should be very specific operations.

Compute the modulo of those values $($i$.$e$.,($what$$s at $0$x$01)$ mod $($what$$s at $0$x$03))$

Store the product at address $0$xD$0$

Halt once it is done

For example, if$$mod$.$binary$$begins$\_\_10\_\_06$then when it is finished it should have$04$in address $0$xD$0$; in decimal, that is $16$ mod $6,$ which is $4.$ If$$mod$.$binary$$begins$\_\_7$F $\_\_0$A$$then when it is finished it should have$07$in address $0$xD$0$; in decimal, that is $127$ mod $10,$ which is $7.$

Note: We should be able to change the second and fourth bytes of your program to do other modulo calculations too.

You may assume that neither value will be negative, but either may be zero.$$If either operand is $0,$ your code should set the value at $0$xD$0$ to $0$x$00.$

Hints, tips, and suggestions

How to compute modulo

Modulo,$$a$$mod$$n$$or$$a $\%$ n$,$ is defined as the remainder when dividing$$a$$by$$n$.$ As in our examples above with$16$ mod $6,16/6=62+4$

$,$ where the quotient is $2$ and the remainder is $4.$ Therefore, $16$ mod $6=4.$ The$$Wikipedia page$$on modulo has a more formal definition.

Hint: For the division operation, think along the lines of $$how many times can$$

$$fit into$$

$?$ You may wish to consider multiples of$$

$.$

You$$definitely$$want to make sure you can write working code for this in some language you know well before trying to convert that code into binary.

How to write binary

We suggest following these steps, carefully, saving the result of each in a file so you can go back and fix them if they were wrong:

Write pseudocode that does the desired task

Convert any$$for$$loops to$$while$$loops with explicit counters

Change any$$if$$or$$while$$guards to the form$$something $<=0$

a $<=$ b$$becomes$$a$-$b $<=0$

a $<$ b$$becomes$$a$+1<=$ b$$becomes$$a$+1-$b $<=0$

a $>=$ b$$becomes$0>=$ b$-$a$$becomes$$b$-$a $<=0$

a $>$ b$$becomes$0>$ b$-$a$$becomes$$b$+1-$a $<=0$

a $==$ b$$becomes$$a$-$b $==0$becomes$!($a$-$b$)==1$becomes$!!($a$-$b$)<=0$

a $!=$ b$$becomes$$a$-$b $!=0$becomes$!($a$-$b$)==0$becomes$!($a$-$b$)<=0$

Add more variables to split multi$-$operation lines into a series of single$-$operation lines

Add more operations to convert ones not in the instruction set into ones in the instruction set

Change each loop into a pair of instructions, opening with $$spot$1=$pc$$ and closing with $$if $...,$ goto$$spot$1$

Count the number of variables neededIf$1$it is $<=4,$ skip to step $10$

else$2,$ continue with next step

Pick a memory address for each variable. Make these big enough your code is unlikely to get that big; for example, you might pick$0$x$80$though$0$x$80+$ number of variables

Convert each statement that uses variables intoregister $$ load variable$$s memory

original statement

store variable$$s memory $$ register

translate each instruction into numeric $($icode$,$a$,$b$)$ triples, possibly followed by a$$M$[$pc$+1]$immediate value

turn $($icode$,$a$,$b$)$ into hex

Write all the hex into$$mod$.$binary

Debugging binary is hard. That$$s part of why we don$$t generally write code in binary. If you get stuck, you should probably try pulling just the part you are stuck on separate from the rest and test it until it works, then put it back in the main solution.

Code:

$010101010203030200040703010004070501020201$ D$0$ FF

Still producting errors.

Hints and Comments:

looped forever $($for example, try $127$ mod $3)$

wrong result $($for example, try $55$ mod $23)$

Please note the values are displayed in decimal, not hexadecimal.

Zero $1(6/6)$

Correct! $0$ mod $5$ gives $0$

Zero $2(6/6)$

Correct! $4$ mod $0$ gives $0$

Even divide $(6/6)$

Correct! $6$ mod $2$ gives $0$

Big difference $(0/5)$

$127$ mod $3$ runs forever

$127$ mod $3$ gives $0$ but should give $1$

Gives $9(0/5)$

$55$ mod $23$ gives $0$ but should give $9$

Random $1(0/5)$

$72$ mod $70$ gives $0$ but should give $2$

Random $2(0/5)$

$94$ mod $84$ gives $0$ but should give $10$

Random $3(0/5)$

$37$ mod $4$ gives $0$ but should give $1$

Random $4(0/5)$

$114$ mod $70$ runs forever

$114$ mod $70$ gives $0$ but should give $44$

Random $5(0/5)$

$56$ mod $5$ gives $0$ but should give $1$

Random $6(0/5)$

$56$ mod $35$ gives $0$ but should give $21$

Random $7(0/5)$

$97$ mod $88$ gives $0$ b