Develop an assembler that translates programs written in RISC$-$V assembly language into the binary code

understood by the processor.

You have been provided with starter code in C for the assembler which take the RISC$-$V assembly$-$language

file as a command$-$line argument. If the input file name is trace $1,$ usage is as follows:

$$./$assembler trace$\_1$

The trace file consists of text lines, each representing a RISC$-$V assembly instruction. Your assembler must

translate each of these instructions into machine code and store them in instruction memory. Use the skeleton

code provided to you as a starting point for your solution. In particular, an example of how to assemble an

R$-$type instruction is provided within the parse R type$()$ function in parser.c$.$

Testing Your Assembler

Test the correctness of the machine code generated by your assembler using the provided trace file which

contains the following instruction classes: R$-$type, I$-$type, and SB$-$type.

add x$10,$ x$10,$ x$25$

ld x$9,0($x$10)$

addi x$22,$ x$22,1$

slli x$11,$ x$22,3$

bne x$8,$ x$24,-4$

First, translate these instructions into their corresponding binary representation by hand. Then, run the file

through your assembler implementation to compare the results and verify correctness.

Code for the Parser.c file to be edited is

#include "parser.h$"$

$//$ FIXME: add support to identify and parse I$-$type and SB$-$type instructions

void load$\_$instructions$($instruction$\_$memory$\_$t $*$i$\_$mem, const char $*$trace$)$

$\{$

printf$("$Loading trace file: $\%$s

$",$ trace$)$;

FILE $*$fd $=$ fopen$($trace$,"$r$")$;

if $($fd $==$ NULL$)\{$

perror$("$Cannot open trace file.

$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

$//$ Iterate over all the assembly instructions

char $*$line $=$ NULL;

size$\_$t len $=0$;

ssize$\_$t read;

addr$\_$t PC $=0$; $//$ program counter points to the zeroth location initially.

int IMEM$\_$index $=0$;

while $(($read $=$ getline$($&line, &len, fd$))!=-1)\{$

$//$ Assign program counter

i$\_$mem$->$instructions$[$IMEM$\_$index$].$addr $=$ PC;

$//$ Extract operation or opcode from the assembly instruction

char $*$raw$\_$instr $=$ strtok$($line$,"")$;

if $($strcmp$($raw$\_$instr, "add"$)==0||$

strcmp$($raw$\_$instr, "sub"$)==0||$

strcmp$($raw$\_$instr, $"$sll$")==0||$

strcmp$($raw$\_$instr, $"$srl$")==0||$

strcmp$($raw$\_$instr, "xor"$)==0||$

strcmp$($raw$\_$instr, $"$or$")==0||$

strcmp$($raw$\_$instr, "and"$)==0)\{$

parse$\_$R$\_$type$($raw$\_$instr, &$($i$\_$mem$->$instructions$[$IMEM$\_$index$]))$;

i$\_$mem$->$last $=$ &$($i$\_$mem$->$instructions$[$IMEM$\_$index$])$;

$\}$

IMEM$\_$index$++$;

PC $+=4$;

$\}$

fclose$($fd$)$;

$\}$

$//$ Parse and assemble R$-$type instruction

void parse$\_$R$\_$type$($char $*$opr$,$ instruction$\_$t $*$instr$)$

$\{$

instr$->$instruction $=0$;

unsigned opcode $=0$;

unsigned funct$3=0$;

unsigned funct$7=0$;

if $($strcmp$($opr$,$ "add"$)==0)\{$

opcode $=51$;

funct$3=0$;

funct$7=0$;

$\}$

char $*$reg $=$ strtok$($NULL$,",")$;

unsigned rd $=$ get$\_$register$\_$number$($reg$)$;

reg $=$ strtok$($NULL$,",")$;

unsigned rs$\_1=$ get$\_$register$\_$number$($reg$)$;

reg $=$ strtok$($NULL$,",")$;

reg$[$strlen$($reg$)-1]=\text{'}\backslash 0\text{'}$;

unsigned rs$\_2=$ get$\_$register$\_$number$($reg$)$;

$//$ Print the tokens

printf$("$Opcode: $\%$u

$",$ opcode$)$;

printf$("$funct$3$: $\%$u

$",$ funct$3)$;

printf$("$funct$7$: $\%$u

$",$ funct$7)$;

printf$("$Source register $1$: $\%$u

$",$ rs$\_1)$;

printf$("$Source register $2$: $\%$u

$",$ rs$\_2)$;

printf$("$Destination register: $\%$u

$",$ rd$)$;

$//$ Contruct instruction

instr$->$instruction $|=$ opcode;

instr$->$instruction $|=($rd $<<7)$;

instr$->$instruction $|=($funct$3<<(7+5))$;

instr$->$instruction $|=($rs$\_1<<(7+5+3))$;

instr$->$instruction $|=($rs$\_2<<(7+5+3+5))$;

instr$->$instruction $|=($funct$7<<(7+5+3+5+5))$;

$\}$

$//$ FIXME: parse and assemble I$-$type instruction

void parse$\_$I$\_$type$($char $*$opr$,$ instruction$\_$t $*$instr$)$

$\{$

$\}$

$//$ FIXME: parse and assemble SB$-$type instruction

void parse$\_$SB$\_$type$($char $*$opr$,$ instruction$\_$t $*$instr$)$

$\{$

$\}$

unsigned int get$\_$register$\_$number$($char $*$reg$)$

$\{$

unsigned i $=0$;

for $($i; i $<$ NUM$\_$OF$\_$REGS; i$++)\{$

if $($strcmp$($REGISTER$\_$NAME$[$i$],$ reg$)==0)$

break;

$\}$

return i;

$\}$

Code for main.c is

#include

#include

#include "parser.h$"$

int main$($int argc, char $**$argv$)$

$\{$

if $($argc $!=2)\{$

printf$("$Usage: $\%$s $\%$s

$",$ argv$[0],"")$;

exit$($EXIT$\_$SUCCESS$)$;

$\}$

$//$ Load instructions from the trace file into memory

instruction$\_$memory$\_$t instr$\_$mem;

instr$\_$mem.last $=$ NULL;

load$\_$instructions$($&instr$\_$mem, argv$[1])$;

$//$ Print instructions in binary format

unsigned PC $=0$;

while $(1)\{$

instruction$\_$t $*$instr $=$ &$($instr$\_$mem.instructions$[$PC $/4])$;

printf$("$

Instruction at PC: $\%$u

$",$ PC$)$;

unsigned mask $=(1<<31)$;

for $($int i $=31$; i $>=0$; i$--)\{$

if $($instr$->$instruction & mask$)$

printf$("1")$;

else

printf