Code Generation 1
COP-3402

Here is the start to compiler/CodeGen.py

import os
import sys
import math
from textwrap import indent, dedent
from antlr4 import *
from grammar.SimpleIRLexer import SimpleIRLexer
from grammar.SimpleIRParser import SimpleIRParser
from grammar.SimpleIRListener import SimpleIRListener
import logging
logging.basicConfig(level=logging.DEBUG)

# This class defines a complete listener for a parse tree produced by SimpleIRParser.
class CodeGen(SimpleIRListener):
    def __init__(self, filename, outfile):
        self.filename = filename
        self.outfile = outfile
        self.symtab = {}
        self.bytewidth = 8

    def enterUnit(self, ctx:SimpleIRParser.UnitContext):
        """Creates the object file sections"""
        self.outfile.write(
f'''\t.file "{self.filename}"
\t.section .note.GNU-stack,"",@progbits
\t.text
''')

    def enterFunction(self, ctx:SimpleIRParser.FunctionContext):
        """Emits the label and prologue"""
        # TODO

    def exitFunction(self, ctx:SimpleIRParser.FunctionContext):
        """Emits the epilogue"""
        # TODO

    def enterReturn(self, ctx:SimpleIRParser.ReturnContext):
        """Sets the return value"""
        # TODO

    def enterCall(self, ctx:SimpleIRParser.CallContext):
        """Function call"""
        # TODO


def main():
    import sys
    if len(sys.argv) > 1:
        filepath = sys.argv[1]
        input_stream = FileStream(filepath)
        filename = os.path.basename(filepath)
    else:
        input_stream = StdinStream()
        filename = "stdin"

    lexer = SimpleIRLexer(input_stream)
    stream = CommonTokenStream(lexer)
    parser = SimpleIRParser(stream)
    tree = parser.unit()
    if parser.getNumberOfSyntaxErrors() > 0:
        print("syntax errors")
        exit(1)
    # print(tree.toStringTree())
    walker = ParseTreeWalker()
    walker.walk(CodeGen(filename, sys.stdout), tree)

if __name__ == '__main__':
    main()

The CodeGen class provides a self.outfile file to write to. In python, write a string using

self.outfile.write("The string to emit")

Alternatively, you can use a format string to make creating templates easier, where anything inside curly braces is evaluated, e.g., the following prints a string followed by the contents of a variable called name:

self.outfile.write(f"This is the what is in the name variable: {name}")

To retrive ANTLR parse tree contents, use the ctx context parameter provided to each listener using the name of the token, e.g., the following will get the NAME token from the syntax tree for a function production and store it in the name python variable.

name = ctx.NAME()

For this project, you do not need to support parameters, just emit the assembly code to call the function, e.g., the following calls function factorial:

call	factorial

In our SimpleIR ANTLR grammar, the call production has several NAME tokens, i.e., in grammar/SimpleIR.g4

call: NAME ':=' 'call' NAME NAME*;

To collect them into a list in python, do the following:

call = [ name.getText() for name in ctx.NAME() ]

• call[0] will contain the name of the variable to store the function's return value to
• call[1] will contain the name of the function to be called
• call[2:] will contain the names of all the parameters to the call ([2:] is python syntax to slice a list into all elements at and after index 2)

Use the name of the function to generate the call in assembly.

For this project, you only need to support returning integer constants. The return IR instruction, incidentally, does not call the assembly ret, which has to come after the epilogue. Instead sets the return value to the %rax register, which is the register that holds the return value according to the System V x86 64 ABI.

# set return value
mov	$10, %rax

To get the text of the operand, e.g., return 5 has the operand "5", use ctx.operand.text. Use the operand text to generate an immediate mov that puts the operand into %rax, the register for the return value.

# enterFunction generates function declaration, label, and prologue
  .globl main
  .type main, @function
main:
  # prologue, update stack pointer
  pushq	%rbp # save old base ponter
  movq	%rsp, %rbp # set new base pointer
  push	%rbx # %rbx is callee-saved

  # enterCall generates the function call
  call	func

  # enterReturn generates the store to %rax
  mov	$10, %rax

  # exitFunction generates the epilogue and return instruction
  pop %rbx # restore rbx for the caller
  mov	%rbp, %rsp # restore old stack pointer
  pop	%rbp # restore old base pointer
  ret

One way to help trace the function call is to use gdb. The following will rebuild the main program with debugging symbols ;on, run gdb, then step through each assembly instructions.

gcc -g -o main main.s func.s  # compile with debugging symbols (-g)
gdb main 
b main # setup breakpoint at main
r # start running, breaks at main
si # step instruction to see next instruction
# hitting enter will repeat last command, e.g., si
c # one done use c to continue running without stopping

The only file you need to submit is compiler/CodeGen.py.

Once you have set up the repo, all you need to do is use git add, git commit, and git push to stage, commit, and sync your repo to the grading git server.

You can check that you've submitted correctly by cloning, building, and testing your repo.

cd ~
git clone gitolite3@eustis3.eecs.ucf.edu:cop3402/NID/codegen1 codegen1_new
cd codegen1_new
pipenv install -e ./
pipenv shell
make -C grammar/
codegen << EOT > main.s
function main
return 10
EOT
gcc -o main main.s
./main
echo $? # you should see 10 as the exit code

What should be the correct output, i.e., assignments of the variables, for these arithmetic operations?