CS4121 Cminus Expression Evaluation Compiler Project
Due Date: Tuesday, June. 3, 2025 at11:59 am
Purpose
The purpose of this project is to gain experience in giving meaning to a programming language by generating
Mips assembly for a subset of Cminus. Specifically, you will be generating assembly for integer I/O operations,
integer arithmetic and logical expressions and assignment statements.
Project Summary
In this project, you will add actions to a parser provided by me. You must add code to do the following:
1. Assign space for global and local integer variables declared in a Cminus program.
2. Generate assembly pseudo-ops for string constants used in a Cminus program.
3. Generate assembly to print string constants.
4. Generate assembly to print integers.
5. Generate assembly to read integers.
6. Generate assembly to compute integer expressions.
7. Generate assembly to compute logic expressions.
8. Generate assembly to assign values to integer variables.
Prologue and Epilogue Code
Since you are converting a Cminus program to Mips assembly, you must begin each assembly file with any
data declarations and a declaration of where themainprogram begins. This is done with the following code:
.data
.newl: .asciiz "\n"
.text
.globl main
main: nop
This code declares a data section with a string.newlthat is just the newline character, followed by a text
section (instructions) containing a declaration of the main routine. Each Mips assembly file should begin
with this sequence. Any space that you allocate for strings or floating-point constants in the static data area
may be allocated with directives after the .data directive and before the .text directive.
Assigning Variable Space
Memory for global variables declared in a Cminus program will be address as an offset off of$gp. The
register$gppoints to the middle of a 64K region in the static data area. You may address this area as a
positive or negative offset off of$gp. I will guarantee that you will need no more than 64K of space in the
static data area for any input program for any of the projects in this class.
Memory for local variables is allocated on the stack. Each integer requires four bytes of space. Local space
is allocated by adjusting the stack pointer the requisite number of bytes. Since stacks grow in the negative
direction in memory, space is allocated by subtracting from the stack pointer. The Cminus declarations
1
int i,j,k;
require 12 bytes of space. That space is allocated on the stack with the instructions
sw $fp, ($sp)
move $fp, $sp
sub $sp, $sp, 12
which should be placedimmediatelyfollowing the prologue code. The first instruction stores the old frame
pointer. The second sets the new frame pointer,$fp, and the third instruction allocates the space for the 3
variables.
String Constants
A Cminus program may use string constants in write statements. These constants are declared in the data
section using the.asciizpseudo-op. For the Cminus statement,
write( Hello );
The following declaration must be added to the data section of the assembly file:
.string0: .asciiz "Hello"
The label.string0is implementation dependent. You may name your string constants however you wish.
Printing Strings
Printing strings requires using a system call. The system call service for printing strings is 4. Since a
character string is stored in memory, you must pass the address of the string to the system call in register
$a0. As an example, the code to implement thewritestatement in the previous section would be:
la $a0, .string0
li $v0, 4
syscall
Note that you will need to additionally print the newline character when printing any data.
Printing Integers
Printing integers is similar to printing strings except that the actual integer is passed to the system call
rather than an address and the system call service is 1. As an example, to implement the statement:
write(7);
the following Mips assembly would need to be generated:
li $a0, 7
li $v0, 1
syscall
Reading Integers
To read an integer, the system call service is 5. The read value is returned in register$v0. Thus, to read an
integer, the following instructions are needed:
li $v0, 5
syscall
2
Accessing Variables
You may access local variables by loading them from an offset of the frame pointer ($fp). As an example,
assuming that the variableais assigned the second 4 bytes of local space. The following code might be
generated to accessa:
sub $s0, $fp, 4
lw $s1, 0($s0)
Loading a global variable is similar except that we use$gpinstead of$fp. Ifais a global variable that is
store 8 bytes (in the positive direction) off of$gp, the following code might be generated to access it:
add $s0, $gp, 8
lw $s1, 0($s0)
Integer Arithmetic Expressions
In Mips assembly, all operations are done on registers. The best way to generate code is to store all interme-
diate values in Mips registers. Using the registers$s0, ..., $s7,$t0, ..., $t9should be sufficient. You
should not need any other temporary registers. For an operation, the operands should all be put into regis-
ters, a result register should be allocated, the operations should be performed and then the input registers
should be released to be reused later. As an example, the statement
write(a+b);
might result in the code (ifais the first declared variable andbis the second)
lw $s1, 0($fp)
sub $s0, $fp, 4
lw $s2, 0($s0)
add $s3, $s1, $s2
move $a0, $s3
li $v0, 1
syscall
Logic Expressions
Logic expressions are similar to arithmetic expressions. For the mips, the value forfalseis 0 and the value
fortrueis 1.
Storing Integer Variables
To store a value in a variable, first compute the address and then store the value into that location. For
example, the statement
a = 5;
could be implemented with
li $s0, 5
sub $s1, $fp, 4
sw $s0, 0($s1)
3
Exiting the Program
Theexitstatement in Cminus can be implemented in Mips assembly as follows:
li $v0, 10
syscall
These instructions call the system routine that exits a program. Everymainroutine in a Cminus program
will end in anexitstatement.
Requirements
Write all of your code in C or C++ . It will be tested on a CS machine and MUST work there. You will
receive no special consideration for programs which work elsewhere, but not on a CS machine.
Input.The fileCminusProject2.tgzcontains the parser need to begin this project. You will need to
modifiy the actions in the project fileparser/CminusParser.yto do this project. Currently, the actions
just emit the rules that are reduced. Sample input for this project is provided in the project directoryinput.
To run your compiler, use the command
cmc .cm
To execute the resulting assembly file, use the Mars simulator(http://courses.missouristate.edu/KenVollmar/mars/).
Submission.Your code should be well-documented. You will submit all of your files, by tarring up your
project directory using the command
tar -czf CminusProject2.tgz CminusProject2
Submit the fileCminusProject2.tgzvia the CS4121 Canvas page. Make sure you do a make clean of your
directory before executing the tar command. This will remove all of the .o files and make your tar file much
smaller.
Data Structures and DocumentationI have provided several C data structures for those who will
be programming in C. There are doubly linked list, symbol table and string manipulation routines in the
workspace directoryCminusProject2/util. The HTML Doxygen documentation for the provided code
is inCminusProject1/Documentation/html/index.html. You may ask me any questions regarding these
routines. You will not likely need any of these structures now, but you may want to familiarize yourself with
them. For those coding in C++, you may use STL.
codegen directoryI have created the codegen directory where the codegen.*, reg.* and other files are
store. You will add fuctions to generate instructions for different productions in parser and these functions
are in codegen.c. In addition, the register allocation management untily implimenation files are reg.c and
reg.h, which makes you use registers simple. Before generatging the compiler, you need issue make command
under the codegen direcetory.
Makefile StructureThe Makefiles for the project are set up to automatically generate make dependences.
In a particular directory (e.g.,parser), you may add new files for compilation by adding the source file name
to theSRCSvariable declaration on the first line of that directory sMakefile. For example, to add the file
newfile.cto be compiled in theparserdirectory, change the first line ofparser/Makefilefrom
SRCS = CminusScanner.c CminusParser.c
4
to
SRCS = CminusScanner.c CminusParser.c newfile.c
Nothing else needs to be done. Do not add source files to the root directoryCminusProject2as the make
files assume there are no source files in that directory.
If you would like to add your own subdirectory (e.g.,newdir) toCminusProject2, then change the line
DIRS = parser util
inCminusProject1/Makefileto
DIRS = parser util newdir
and the line
LIBS = parser/libparser-g.a util/libutil-g.a
inCminusProject1/Makefileto
LIBS = parser/libparser-g.a util/libutil-g.a newdir/libnewdir-g.a
Then, copyutil/Makefiletonewdir/Makefile. Finally, change theSRCSdeclaration innewdir/Makefile
to contain only the source files in that directory and change the line
請加QQ：99515681 郵箱：99515681@qq.com WX：codinghelp
