myFunc:

addi sp$,$ sp$,-128$ # assume $128$ bytes is enough

sw ra$,0($sp$)$

sw fp$,4($sp$)$

mv fp$,$ sp

sw a$0,8($fp$)$

sw a$1,12($fp$)$

sw a$2,16($fp$)$

la t$0,.$SC$0$

mv a$0,$ t$0$

jal printStr

la t$0,.$SC$1$

mv a$1,$ t$0$

jal printStr

#$--$assignment$--$

li t$0,42$

sw t$0,$ x

mv sp$,$ fp # for safety, restore sp from fp

lw ra$,0($sp$)$

lw fp$,4($sp$)$

addi sp$,$ sp$,128$

ret

The above is my output, please can you fix the code to match the Description of Needed Functionality below

Short Description of Needed Functionality.

Parameters $($up to six$)$: See the info page, but in short, to use parameters we first store them from the argument registers onto the stack and then access them using a constant offset from the frame pointer $($fp$)$ register. Our symbol table record and our AST$\_$VARREF node for each parameter must remember the parameter position $($starting with $0$ perhaps$)$ in the ival field; then when we generate code we can use an offset based on ival that accesses the correct position on the stack. We should also set the varKind field to V$\_$PARAM. $($see the updated addSymbol$()$ function; it has a new last parameter$).$

Local variables: Local variables are also stored on the stack, so we need to open up space for them, too. We should also use the AST$\_$VARREF ival field to store a position number for them; it is most useful to just continue the parameter counter into the local variables, and give them position counts that continue from the parameters. This way they can be handled exactly the same in code generation. We should also set the varKind field to V$\_$LOCAL.

# Function prologue addi sp$,$ sp$,-128$ # Allocate $128$ bytes on the stack sw ra$,0($sp$)$ # Save return address sw fp$,4($sp$)$ # Save old frame pointer mv fp$,$ sp # Set new frame pointer # Parameters are at offsets from fp # Local variables start at offset $36($fp$)$ # Function body code here... # Function epilogue mv sp$,$ fp # Restore stack pointer from frame pointer lw ra$,0($sp$)$ # Restore return address lw fp$,4($sp$)$ # Restore old frame pointer addi sp$,$ sp$,128$ # Deallocate stack space ret # Return from function # AST Assignment Handling case AST$\_$ASSIGNMENT: fprintf$($out$,"\backslash$t# $--$ assignment $--$

$")$; genCodeFromASTree$($node$->$child$[0],0,$ out$)$; $//$ Generate code for RHS if $($node$->$varKind $==$ V$\_$GLOBAL$)\{$ fprintf$($out$,"\backslash$tsw$\backslash$tt$0,\%$s

$",$ node$->$strval$)$; $//$ Store in global variable $\}$ else if $($node$->$varKind $==$ V$\_$PARAM $||$ node$->$varKind $==$ V$\_$LOCAL$)\{$ fprintf$($out$,"\backslash$tsw$\backslash$tt$0,\%$d$($fp$)$

$",$ node$->$ival $*4+8)$; $//$ Store in local$/$param $\}$ else if $($node$->$varKind $==$ V$\_$GLARRAY$)\{//$ Handle global array assignment fprintf$($out$,"\backslash$taddi$\backslash$tsp$,$ sp$,-4$

$""\backslash$tsw$\backslash$tt$0,0($sp$)$

$")$; $//$ Save RHS value onto stack genCodeFromASTree$($node$->$child$[1],0,$ out$)$; $//$ Generate index expression code fprintf$($out$,"\backslash$tla$\backslash$tt$1,\%$s

$"//$ Load base address of array into t$1"\backslash$tmul$\backslash$tt$2,$ t$0,4$

$"//$ Multiply index by size of int $(4)"\backslash$tadd$\backslash$tt$1,$ t$1,$ t$2$

$"//$ Add offset to base address $"\backslash$tlw$\backslash$tt$0,0($sp$)$

$"//$ Pop RHS value from stack into t$0"\backslash$taddi$\backslash$tsp$,$ sp$,4$

$"//$ Restore stack pointer $"\backslash$tsw$\backslash$tt$0,0($t$1)$

$",//$ Store value into array element node$->$strval$)$; $\}$ else $\{$ fprintf$($out$,$"Unknown variable kind assignment

$")$; $\}$ break; # Function Handling in AST case AST$\_$FUNCTION: fprintf$($out$,"\%$s:

$"$ "addi$\backslash$tsp$,$ sp$,-128$

$""$# assume $128$ bytes is enough

$""$sw$\backslash$tra$,0($sp$)$

$""$sw$\backslash$tfp$,4($sp$)$

$""$mv$\backslash$tfp$,$ sp

$",$ node$->$strval$)$; ptr $=$ node$->$child$[0]$; while $($ptr $!=$ NULL$)\{$ fprintf$($out$,"$sw$\backslash$ta$\%$d$,\%$d$($fp$)$

$",$ ptr$->$ival, ptr$->$ival $*4+8)$; ptr $=$ ptr$->$next; $\}$ genCodeFromASTree$($node$->$child$[2],$ hval, out$)$; $//$ Generate function body fprintf$($out$,"$mv$\backslash$tsp$,$ fp

$""$# for safety restore sp from fp

$""$lw$\backslash$tra $,0($sp$)$

$""$lw$\backslash$tfp $,4($sp$)$

$"$ "addi$\backslash$tsp $,$sp $,128$

$"$ "ret

$")$; break; # Variable Reference Handling in AST case AST$\_$VARREF: if $($node$->$varKind $==$ V$\_$GLOBAL$)\{$ fprintf$($out$,"$lw$\backslash$tt$0,\%$s

$",$ node$->$strval$)$; $\}$ else if $($node$->$varKind $==$ V$\_$PARAM $||$ node$->$varKind $==$ V$\_$LOCAL$)\{$ fprintf$($out$,"$lw$\backslash$tt$0,\%$d$($fp$)$

$",$ node$->$ival $*4+8)$; $\}$ else if $($node$->$varKind $==$ V$\_$GLARRAY$)\{$ genCodeFromASTree$($node$->$child$[0],$ hval, out$)$; $//$ Generate index expression code fprintf$($out$,"$la$\backslash$tt$1,\%$s

$"$ "mul$\backslash$tt$2,$t$0,4$

$"$ "add$\backslash$tt$1,$t$1,$t$2$

$""$lw$\backslash$tt$0,0($t$1)$

$",$ node$->$strval$)$; $\}$ else $\{$ fprintf$($out$,$"Unknown variable kind reference

$")$; $\}$ break;