From 390ca18660df46c6ec66744302e5008772915592 Mon Sep 17 00:00:00 2001 From: BuildTools Date: Sun, 29 Sep 2024 09:58:25 +0200 Subject: [PATCH 1/3] Ajout TP3 --- MiniC/.coveragerc | 11 + MiniC/.gitignore | 20 ++ MiniC/Lib/Errors.py | 18 + MiniC/Makefile | 123 +++++++ MiniC/MiniC.g4 | 138 ++++++++ MiniC/MiniCC.py | 333 ++++++++++++++++++ MiniC/MiniCLexer.pyi | 16 + MiniC/MiniCParser.pyi | 22 ++ MiniC/README-interpreter.md | 32 ++ MiniC/TP03/MiniCInterpretVisitor.py | 185 ++++++++++ MiniC/TP03/MiniCTypingVisitor.py | 148 ++++++++ .../tests/provided/examples-types/bad_def01.c | 13 + .../provided/examples-types/bad_type00.c | 10 + .../provided/examples-types/bad_type01.c | 14 + .../provided/examples-types/bad_type02.c | 11 + .../provided/examples-types/bad_type03.c | 10 + .../provided/examples-types/bad_type04.c | 11 + .../examples-types/bad_type_bool_bool.c | 9 + .../provided/examples-types/double_decl00.c | 12 + MiniC/TP03/tests/provided/examples/bad_main.c | 12 + MiniC/TP03/tests/provided/examples/no_main.c | 7 + .../tests/provided/examples/test_assign.c | 13 + .../tests/provided/examples/test_basic_bool.c | 33 ++ .../tests/provided/examples/test_basic_expr.c | 23 ++ .../tests/provided/examples/test_compare.c | 47 +++ .../TP03/tests/provided/examples/test_expr.c | 11 + .../TP03/tests/provided/examples/test_print.c | 15 + .../tests/provided/examples/test_print_int.c | 9 + .../tests/provided/examples/test_str_assign.c | 11 + .../tests/provided/strcat/test_string01.c | 15 + .../tests/provided/strcat/test_string02.c | 17 + .../tests/provided/strcat/unititialized_str.c | 14 + .../TP03/tests/provided/uninitialised/bool.c | 17 + .../TP03/tests/provided/uninitialised/float.c | 13 + MiniC/TP03/tests/provided/uninitialised/int.c | 13 + MiniC/TP03/tests/students/README.md | 1 + MiniC/TP03/tests/students/ext-for-c/README.md | 1 + MiniC/doc/Makefile | 20 ++ MiniC/doc/conf.py | 61 ++++ MiniC/doc/index.rst | 77 ++++ MiniC/libprint.s | 251 +++++++++++++ MiniC/printlib.h | 21 ++ MiniC/pyproject.toml | 2 + MiniC/test_expect_pragma.py | 317 +++++++++++++++++ MiniC/test_interpreter.py | 100 ++++++ TP03/arith-visitor/.gitignore | 2 + TP03/arith-visitor/Arit.g4 | 33 ++ TP03/arith-visitor/Makefile | 23 ++ TP03/arith-visitor/MyAritVisitor.py | 58 +++ TP03/arith-visitor/arit.py | 28 ++ TP03/arith-visitor/myexample | 5 + TP03/arith-visitor/test_arith_visitor.py | 36 ++ TP03/tp3.pdf | Bin 0 -> 229668 bytes TP03/tree/Tree.g4 | 16 + 54 files changed, 2458 insertions(+) create mode 100644 MiniC/.coveragerc create mode 100644 MiniC/.gitignore create mode 100644 MiniC/Lib/Errors.py create mode 100644 MiniC/Makefile create mode 100644 MiniC/MiniC.g4 create mode 100755 MiniC/MiniCC.py create mode 100644 MiniC/MiniCLexer.pyi create mode 100644 MiniC/MiniCParser.pyi create mode 100644 MiniC/README-interpreter.md create mode 100644 MiniC/TP03/MiniCInterpretVisitor.py create mode 100644 MiniC/TP03/MiniCTypingVisitor.py create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_def01.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type00.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type01.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type02.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type03.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type04.c create mode 100644 MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c create mode 100644 MiniC/TP03/tests/provided/examples-types/double_decl00.c create mode 100644 MiniC/TP03/tests/provided/examples/bad_main.c create mode 100644 MiniC/TP03/tests/provided/examples/no_main.c create mode 100644 MiniC/TP03/tests/provided/examples/test_assign.c create mode 100644 MiniC/TP03/tests/provided/examples/test_basic_bool.c create mode 100644 MiniC/TP03/tests/provided/examples/test_basic_expr.c create mode 100644 MiniC/TP03/tests/provided/examples/test_compare.c create mode 100644 MiniC/TP03/tests/provided/examples/test_expr.c create mode 100644 MiniC/TP03/tests/provided/examples/test_print.c create mode 100644 MiniC/TP03/tests/provided/examples/test_print_int.c create mode 100644 MiniC/TP03/tests/provided/examples/test_str_assign.c create mode 100644 MiniC/TP03/tests/provided/strcat/test_string01.c create mode 100644 MiniC/TP03/tests/provided/strcat/test_string02.c create mode 100644 MiniC/TP03/tests/provided/strcat/unititialized_str.c create mode 100644 MiniC/TP03/tests/provided/uninitialised/bool.c create mode 100644 MiniC/TP03/tests/provided/uninitialised/float.c create mode 100644 MiniC/TP03/tests/provided/uninitialised/int.c create mode 100644 MiniC/TP03/tests/students/README.md create mode 100644 MiniC/TP03/tests/students/ext-for-c/README.md create mode 100644 MiniC/doc/Makefile create mode 100644 MiniC/doc/conf.py create mode 100644 MiniC/doc/index.rst create mode 100644 MiniC/libprint.s create mode 100644 MiniC/printlib.h create mode 100644 MiniC/pyproject.toml create mode 100644 MiniC/test_expect_pragma.py create mode 100755 MiniC/test_interpreter.py create mode 100644 TP03/arith-visitor/.gitignore create mode 100644 TP03/arith-visitor/Arit.g4 create mode 100644 TP03/arith-visitor/Makefile create mode 100644 TP03/arith-visitor/MyAritVisitor.py create mode 100644 TP03/arith-visitor/arit.py create mode 100644 TP03/arith-visitor/myexample create mode 100755 TP03/arith-visitor/test_arith_visitor.py create mode 100644 TP03/tp3.pdf create mode 100644 TP03/tree/Tree.g4 diff --git a/MiniC/.coveragerc b/MiniC/.coveragerc new file mode 100644 index 0000000..eb6325c --- /dev/null +++ b/MiniC/.coveragerc @@ -0,0 +1,11 @@ +[report] +exclude_lines = + pragma: no cover + raise MiniCInternalError + raise MiniCUnsupportedError + if debug: + if debug_graphs: + if self._debug: + if self.debug: + if self._debug_graphs: + if self.debug_graphs: diff --git a/MiniC/.gitignore b/MiniC/.gitignore new file mode 100644 index 0000000..ad8ad89 --- /dev/null +++ b/MiniC/.gitignore @@ -0,0 +1,20 @@ +/MiniCLexer.py +/MiniCParser.py +/MiniCVisitor.py +/TP*/tests/**/*.s +/TP*/**/*.riscv +/TP*/**/*-naive.s +/TP*/**/*-all_in_mem.s +/TP*/**/*-smart.s +/TP*/**/*.trace +/TP*/**/*.dot +/TP*/**/*.dot.pdf +/MiniC-stripped.g4 +.coverage +htmlcov/ +doc/api +doc/_build +log-*.txt +.eval-done.txt +*.py.diff +*.g4.diff diff --git a/MiniC/Lib/Errors.py b/MiniC/Lib/Errors.py new file mode 100644 index 0000000..e466aa4 --- /dev/null +++ b/MiniC/Lib/Errors.py @@ -0,0 +1,18 @@ +class MiniCRuntimeError(Exception): + pass + + +class MiniCInternalError(Exception): + pass + + +class MiniCUnsupportedError(Exception): + pass + + +class MiniCTypeError(Exception): + pass + + +class AllocationError(Exception): + pass diff --git a/MiniC/Makefile b/MiniC/Makefile new file mode 100644 index 0000000..bb90ed4 --- /dev/null +++ b/MiniC/Makefile @@ -0,0 +1,123 @@ +MYNAME = JohnDoe +PACKAGE = MiniC +# Example: stop at the first failed test: +# make PYTEST_OPTS=-x test +PYTEST_OPTS = +# Run the whole test infrastructure for a subset of test files e.g. +# make FILTER='TP03/**/bad*.c' test +ifdef FILTER +export FILTER +endif + +# code generation mode +ifdef MODE +MINICC_OPTS+=--mode $(MODE) +endif + +export MINICC_OPTS + +PYTEST_BASE_OPTS=-vv -rs --failed-first --cov="$(PWD)" --cov-report=term --cov-report=html + +ifndef ANTLR4 +abort: + $(error variable ANTLR4 is not set) +endif + +all: antlr + +.PHONY: antlr +antlr MiniCLexer.py MiniCParser.py: $(PACKAGE).g4 + $(ANTLR4) $< -Dlanguage=Python3 -visitor -no-listener + +main-deps: MiniCLexer.py MiniCParser.py TP03/MiniCInterpretVisitor.py TP03/MiniCTypingVisitor.py + +doc: antlr + sphinx-apidoc -e -f -o doc/api . TP* replace_* *Wrapper* MiniC* conf* test* + make -C doc html + +test: test-interpret + + + +test-pyright: antlr + pyright . + +test-parse: test-pyright antlr + MINICC_OPTS="$(MINICC_OPTS) --mode=parse" python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'naive' + +test-typecheck: test-pyright antlr + MINICC_OPTS="$(MINICC_OPTS) --mode=typecheck" python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'naive' + +test-interpret: test-pyright test_interpreter.py main-deps + python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) test_interpreter.py + + +ifndef MODE +# The export must be on the same line as the command (note the ';'), because +# make starts a new shell for each line. +LINEAR=export MINICC_OPTS="${MINICC_OPTS} --mode codegen-linear"; +else +LINEAR= +endif + +# Test for naive allocator (also runs test_expect to check // EXPECTED directives): +test-naive: test-pyright antlr + $(LINEAR) python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'test_naive or test_expect' + +test-mem: test-pyright antlr + $(LINEAR) python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'test_alloc_mem' + +test-hybrid: test-pyright antlr + $(LINEAR) python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'test_alloc_hybrid' + +# Test for all but the smart allocator, i.e. everything that lab4 should pass: +test-lab4: test-pyright antlr + $(LINEAR) python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'not test_smart' + +# Test just the smart allocator (quicker than tests) +test-smart: test-pyright antlr + python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py -k 'test_smart' + +# Complete testsuite (should pass for lab5): +test-codegen: test-pyright antlr + python3 -m pytest $(PYTEST_BASE_OPTS) $(PYTEST_OPTS) ./test_codegen.py + +NAME_CLEAN = ${shell printf '%s' "$(MYNAME)" | tr -cd '[0-9a-zA-Z]'} +BASEDIR=$$(basename "$$PWD") +tar: clean + dir=$$(basename "$$PWD") && cd .. && \ + tar cvfz "$$dir"-$(NAME_CLEAN).tgz --exclude=".git" --exclude=".pytest_cache" \ + --exclude="htmlcov" "$$dir" + @echo "Created ../$$(basename "$$PWD")-$(NAME_CLEAN).tgz" + +# Remove any assembly file that was created by a test. +# Don't just find -name \*.s -exec rm {} \; because there may be legitimate .s files in the testsuite. +define CLEAN +import glob +import os +for f in glob.glob("**/tests/**/*.c", recursive=True): + for s in ("{}-{}.s".format(f[:-2], test) for test in ("naive", "smart", "gcc", "all-in-mem", "hybrid")): + try: + os.remove(s) + print("Removed {}".format(s)) + except OSError: + pass +endef +export CLEAN +clean-tests: + @python3 -c "$$CLEAN" + find . -iname "*.riscv" -print0 | xargs -0 rm -rf \; + +clean: clean-tests + find . \( -iname "*~" -or -iname ".cache*" -or -iname "*.diff" -or -iname "log*.txt" -or -iname "__pycache__" -or -iname "*.tokens" -or -iname "*.interp" \) -print0 | xargs -0 rm -rf \; + rm -rf *~ $(PACKAGE)Parser.py $(PACKAGE)Lexer.py $(PACKAGE)Visitor.py .coverage .benchmarks + +.PHONY: install-deps +install-deps: + python3 -m pip install antlr4-python3-runtime==4.13.1 pytest pytest-cov pytest-xdist coverage graphviz networkx pygraphviz + +.PHONY: test test-interpret test-codegen clean clean-tests tar antlr +# multiple invocations of pytest in parallel would share temporary file names +# and sometimes break. Parallelism can be achieved within pytest with +# pytest-xdist, which is efficient and safe. +.NOTPARALLEL: diff --git a/MiniC/MiniC.g4 b/MiniC/MiniC.g4 new file mode 100644 index 0000000..0fb24e9 --- /dev/null +++ b/MiniC/MiniC.g4 @@ -0,0 +1,138 @@ +grammar MiniC; + +prog: function* EOF #progRule; + +// For now, we don't have "real" functions, just the main() function +// that is the main program, with a hardcoded profile and final +// 'return 0' (actually a 'return INT' because we don't have a ZERO +// lexical token). +function: INTTYPE ID OPAR CPAR OBRACE vardecl_l block + RETURN INT SCOL CBRACE #funcDef; + +vardecl_l: vardecl* #varDeclList; + +vardecl: typee id_l SCOL #varDecl; + + +id_l: ID #idListBase + | ID COM id_l #idList + ; + +block: stat* #statList; + +stat: assignment SCOL + | if_stat + | while_stat + | print_stat + ; + +assignment: ID ASSIGN expr #assignStat; + +if_stat: IF OPAR expr CPAR then_block=stat_block + (ELSE else_block=stat_block)? #ifStat; + +stat_block: OBRACE block CBRACE + | stat + ; + +while_stat: WHILE OPAR expr CPAR body=stat_block #whileStat; + + +print_stat + : PRINTLN_INT OPAR expr CPAR SCOL #printlnintStat + | PRINTLN_FLOAT OPAR expr CPAR SCOL #printlnfloatStat + | PRINTLN_BOOL OPAR expr CPAR SCOL #printlnboolStat + | PRINTLN_STRING OPAR expr CPAR SCOL #printlnstringStat + ; + +expr: MINUS expr #unaryMinusExpr + | NOT expr #notExpr + | expr myop=(MULT|DIV|MOD) expr #multiplicativeExpr + | expr myop=(PLUS|MINUS) expr #additiveExpr + | expr myop=(GT|LT|GTEQ|LTEQ) expr #relationalExpr + | expr myop=(EQ|NEQ) expr #equalityExpr + | expr AND expr #andExpr + | expr OR expr #orExpr + | atom #atomExpr + ; + +atom + : OPAR expr CPAR #parExpr + | INT #intAtom + | FLOAT #floatAtom + | (TRUE | FALSE) #booleanAtom + | ID #idAtom + | STRING #stringAtom + ; + +typee + : mytype=(INTTYPE|FLOATTYPE|BOOLTYPE|STRINGTYPE) #basicType + ; + +OR : '||'; +AND : '&&'; +EQ : '=='; +NEQ : '!='; +GT : '>'; +LT : '<'; +GTEQ : '>='; +LTEQ : '<='; +PLUS : '+'; +MINUS : '-'; +MULT : '*'; +DIV : '/'; +MOD : '%'; +NOT : '!'; + +COL: ':'; +SCOL : ';'; +COM : ','; +ASSIGN : '='; +OPAR : '('; +CPAR : ')'; +OBRACE : '{'; +CBRACE : '}'; + +TRUE : 'true'; +FALSE : 'false'; +IF : 'if'; +ELSE : 'else'; +WHILE : 'while'; +RETURN : 'return'; +PRINTLN_INT : 'println_int'; +PRINTLN_BOOL : 'println_bool'; +PRINTLN_STRING : 'println_string'; +PRINTLN_FLOAT : 'println_float'; + +INTTYPE: 'int'; +FLOATTYPE: 'float'; +STRINGTYPE: 'string'; +BOOLTYPE : 'bool'; + +ID + : [a-zA-Z_] [a-zA-Z_0-9]* + ; + +INT + : [0-9]+ + ; + +FLOAT + : [0-9]+ '.' [0-9]* + | '.' [0-9]+ + ; + +STRING + : '"' (~["\r\n] | '""')* '"' + ; + + +COMMENT +// # is a comment in Mini-C, and used for #include in real C so that we ignore #include statements + : ('#' | '//') ~[\r\n]* -> skip + ; + +SPACE + : [ \t\r\n] -> skip + ; + diff --git a/MiniC/MiniCC.py b/MiniC/MiniCC.py new file mode 100755 index 0000000..6d72ca7 --- /dev/null +++ b/MiniC/MiniCC.py @@ -0,0 +1,333 @@ +#! /usr/bin/python3 +""" +Evaluation and code generation labs, main file. +Usage: + python3 MiniCC.py --mode + python3 MiniCC.py --help +""" + +from __future__ import annotations + +from typing import cast +from enum import Enum + +from MiniCLexer import MiniCLexer +from MiniCParser import MiniCParser +from TP03.MiniCTypingVisitor import MiniCTypingVisitor, MiniCTypeError +from TP03.MiniCInterpretVisitor import MiniCInterpretVisitor +from Lib.Errors import (MiniCUnsupportedError, MiniCInternalError, + MiniCRuntimeError, AllocationError) + +import antlr4 +from antlr4.error.ErrorListener import ErrorListener + +from argparse import ArgumentParser +from traceback import print_exc +import os +import sys + + +class Mode(Enum): + PARSE = 0 + EVAL = 1 + LINEAR = 2 + CFG = 3 + SSA = 4 + OPTIM = 5 + + def is_codegen(self) -> bool: + return self.value >= Mode.LINEAR.value + + def is_ssa(self) -> bool: + return self.value >= Mode.SSA.value + + +def valid_modes(): + modes = ['parse', 'typecheck', 'eval'] + + try: + import TP04.MiniCCodeGen3AVisitor # pyright: ignore # noqa: F401, type: ignore + modes.append('codegen-linear') + except ModuleNotFoundError: + return modes + + try: + import Lib.CFG # pyright: ignore # noqa: F401, type: ignore + modes.append('codegen-cfg') + except ModuleNotFoundError: + return modes + + try: + import TP05.EnterSSA # pyright: ignore # noqa: F401, type: ignore + modes.append('codegen-ssa') + except ModuleNotFoundError: + return modes + + try: + import TPoptim.OptimSSA # pyright: ignore # noqa: F401, type: ignore + modes.append('codegen-optim') + except ModuleNotFoundError: + pass + + return modes + + +class CountErrorListener(ErrorListener): + """Count number of errors. + + Parser provides getNumberOfSyntaxErrors(), but the Lexer + apparently doesn't provide an easy way to know if an error occurred + after the fact. Do the counting ourserves with a listener. + """ + + def __init__(self): + super(CountErrorListener, self).__init__() + self.count = 0 + + def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e): + self.count += 1 + + +def main(inputname, reg_alloc, mode, + typecheck=True, stdout=False, output_name=None, debug=False, + debug_graphs=False, ssa_graphs=False, dom_graphs=False): + (basename, rest) = os.path.splitext(inputname) + if mode.is_codegen(): + if stdout: + output_name = None + print("Code will be generated on standard output") + elif output_name is None: + output_name = basename + ".s" + print("Code will be generated in file " + output_name) + + input_s = antlr4.FileStream(inputname, encoding='utf-8') + lexer = MiniCLexer(input_s) + counter = CountErrorListener() + lexer._listeners.append(counter) + stream = antlr4.CommonTokenStream(lexer) + parser = MiniCParser(stream) + parser._listeners.append(counter) + tree = parser.prog() + if counter.count > 0: + exit(3) # Syntax or lexicography errors occurred, don't try to go further. + if typecheck: + typing_visitor = MiniCTypingVisitor() + try: + typing_visitor.visit(tree) + except MiniCTypeError as e: + print(e.args[0]) + exit(2) + + if mode == Mode.EVAL: + # interpret Visitor + interpreter_visitor = MiniCInterpretVisitor() + try: + interpreter_visitor.visit(tree) + except MiniCRuntimeError as e: + print(e.args[0]) + exit(1) + except MiniCInternalError as e: + print(e.args[0], file=sys.stderr) + exit(4) + return + + if not mode.is_codegen(): + if debug: + print("Not running code generation because of --typecheck-only.") + return + + # Codegen 3@ CFG Visitor, first argument is debug mode + from TP04.MiniCCodeGen3AVisitor import MiniCCodeGen3AVisitor # type: ignore[import] + visitor3 = MiniCCodeGen3AVisitor(debug, parser) + + # dump generated code on stdout or file. + with open(output_name, 'w') if output_name else sys.stdout as output: + visitor3.visit(tree) + for function in visitor3.get_functions(): + fdata = function.fdata + # Allocation part + if mode == Mode.LINEAR: + code = function + else: + from TP04.BuildCFG import build_cfg # type: ignore[import] + code = build_cfg(function) + if debug_graphs: + s = "{}.{}.dot".format(basename, code.fdata.get_name()) + print("CFG:", s) + code.print_dot(s, view=True) + if mode.is_ssa(): + from TP05.EnterSSA import enter_ssa # type: ignore[import] + from Lib.CFG import CFG # type: ignore[import] + enter_ssa(cast(CFG, code), dom_graphs, basename) + if ssa_graphs: + s = "{}.{}.enterssa.dot".format(basename, code.fdata.get_name()) + print("SSA:", s) + code.print_dot(s, view=True) + if mode == Mode.OPTIM: + from TPoptim.OptimSSA import OptimSSA # type: ignore[import] + OptimSSA(cast(CFG, code), debug=debug) + if ssa_graphs: + s = "{}.{}.optimssa.dot".format(basename, code.fdata.get_name()) + print("SSA after optim:", s) + code.print_dot(s, view=True) + allocator = None + if reg_alloc == "naive": + from Lib.Allocator import NaiveAllocator # type: ignore[import] + allocator = NaiveAllocator(fdata) + comment = "naive allocation" + elif reg_alloc == "all-in-mem": + from TP04.AllInMemAllocator import AllInMemAllocator # type: ignore[import] + allocator = AllInMemAllocator(fdata) + comment = "all-in-memory allocation" + elif reg_alloc == "hybrid": + from TP04.HybridNaiveAllocator import HybridNaiveAllocator # type: ignore[import] + allocator = HybridNaiveAllocator(fdata) + comment = "hybrid, naive allocation" + elif reg_alloc == "smart": + liveness = None + if mode.is_ssa(): + from TP05.LivenessSSA import LivenessSSA # type: ignore[import] + try: + from Lib.CFG import CFG # type: ignore[import] + liveness = LivenessSSA(cast(CFG, code), debug=debug) + except NameError: + form = "CFG in SSA form" + raise ValueError("Invalid dataflow form: \ +liveness file not found for {}.".format(form)) + else: + try: + from TP05.LivenessDataFlow import LivenessDataFlow # type: ignore[import] + liveness = LivenessDataFlow(code, debug=debug) + except NameError: + form = "CFG not in SSA form" + raise ValueError("Invalid dataflow form: \ +liveness file not found for {}.".format(form)) + from TP05.SmartAllocator import SmartAllocator # type: ignore[import] + allocator = SmartAllocator(fdata, basename, liveness, + debug, debug_graphs) + comment = "smart allocation with graph coloring" + elif reg_alloc == "none": + comment = "non executable 3-Address instructions" + else: + raise ValueError("Invalid allocation strategy:" + reg_alloc) + if allocator: + allocator.prepare() + if mode.is_ssa(): + from Lib.CFG import CFG # type: ignore[import] + from TP05.ExitSSA import exit_ssa # type: ignore[import] + exit_ssa(cast(CFG, code), reg_alloc == 'smart') + comment += " with SSA" + if allocator: + allocator.rewriteCode(code) + if mode.is_ssa() and ssa_graphs: + s = "{}.{}.exitssa.dot".format(basename, code.fdata.get_name()) + print("CFG after SSA:", s) + code.print_dot(s, view=True) + from Lib.LinearCode import LinearCode # type: ignore[import] + output.write(f"# Code generated by {os.path.realpath(sys.argv[0])}\n") + for v in os.environ: + if v.startswith("REPLACE_"): + output.write(f"# {v}={os.environ[v]}\n") + output.write(f"# Options: {' '.join(sys.argv[1:])}\n") + if isinstance(code, LinearCode): + code.print_code(output, comment=comment) + else: + from Lib.CFG import CFG # type: ignore[import] + from TP04.LinearizeCFG import linearize # type: ignore[import] + assert (isinstance(code, CFG)) + code.print_code(output, linearize=linearize, comment=comment) + if debug: + visitor3.printSymbolTable() + + +# command line management +if __name__ == '__main__': + + modes = valid_modes() + + parser = ArgumentParser(description='CAP/MIF08 MiniCC compiler') + + parser.add_argument('filename', type=str, + help='Source file.') + parser.add_argument('--mode', type=str, + choices=modes, + required=True, + help='Operation to perform on the input program') + parser.add_argument('--debug', action='store_true', + default=False, + help='Emit verbose debug output') + parser.add_argument('--disable-typecheck', action='store_true', + default=False, + help="Don't run the typechecker before evaluation or code generation") + + if "codegen-linear" in modes: + parser.add_argument('--reg-alloc', type=str, + choices=['none', 'naive', 'all-in-mem', 'hybrid', 'smart'], + help='Register allocation to perform during code generation') + parser.add_argument('--stdout', action='store_true', + help='Generate code to stdout') + parser.add_argument('--output', type=str, + help='Generate code to outfile') + + if "codegen-cfg" in modes: + parser.add_argument('--graphs', action='store_true', + default=False, + help='Display graphs (CFG, conflict graph).') + + if "codegen-ssa" in modes: + parser.add_argument('--ssa-graphs', action='store_true', + default=False, + help='Display the CFG at SSA entry and exit.') + parser.add_argument('--dom-graphs', action='store_true', + default=False, + help='Display dominance-related graphs (DT, DF).') + + args = parser.parse_args() + reg_alloc = args.reg_alloc if "codegen-linear" in modes else None + to_stdout = args.stdout if "codegen-linear" in modes else False + outfile = args.output if "codegen-linear" in modes else None + graphs = args.graphs if "codegen-cfg" in modes else False + ssa_graphs = args.ssa_graphs if "codegen-ssa" in modes else False + dom_graphs = args.dom_graphs if "codegen-ssa" in modes else False + + if reg_alloc is None and "codegen" in args.mode: + print("error: the following arguments is required: --reg-alloc") + exit(1) + elif reg_alloc is not None and "codegen" not in args.mode: + print("error: register allocation is only available in code generation mode") + exit(1) + + typecheck = not args.disable_typecheck + + if args.mode == "parse": + mode = Mode.PARSE + typecheck = False + elif args.mode == "typecheck": + mode = Mode.PARSE + elif args.mode == "eval": + mode = Mode.EVAL + elif args.mode == "codegen-linear": + mode = Mode.LINEAR + if reg_alloc == "smart": + print("error: smart register allocation is not compatible with linear code generation") + exit(1) + elif args.mode == "codegen-cfg": + mode = Mode.CFG + elif args.mode == "codegen-ssa": + mode = Mode.SSA + elif args.mode == "codegen-optim": + mode = Mode.OPTIM + else: + raise ValueError("Invalid mode:" + args.mode) + + try: + main(args.filename, reg_alloc, mode, + typecheck, + to_stdout, outfile, args.debug, + graphs, ssa_graphs, dom_graphs) + except MiniCUnsupportedError as e: + print(e) + exit(5) + except (MiniCInternalError, AllocationError): + print_exc() + exit(4) diff --git a/MiniC/MiniCLexer.pyi b/MiniC/MiniCLexer.pyi new file mode 100644 index 0000000..6451f39 --- /dev/null +++ b/MiniC/MiniCLexer.pyi @@ -0,0 +1,16 @@ +from antlr4.error.ErrorListener import ErrorListener +from antlr4.Lexer import Lexer +from typing import Callable, Any, List + +class MiniCLexer(Lexer): + _listeners: List[ErrorListener] + EQ: int + LT: int + LTEQ: int + GT: int + GTEQ: int + PLUS: int + MINUS: int + MULT: int + DIV: int + MOD: int diff --git a/MiniC/MiniCParser.pyi b/MiniC/MiniCParser.pyi new file mode 100644 index 0000000..bc36f65 --- /dev/null +++ b/MiniC/MiniCParser.pyi @@ -0,0 +1,22 @@ +from antlr4.error.ErrorListener import ErrorListener +from antlr4.Parser import Parser +from typing import Callable, Any, List + +class MiniCParser(Parser): + _listeners: List[ErrorListener] + prog: Callable[[], Any] + EQ: int + LT: int + LTEQ: int + GT: int + GTEQ: int + PLUS: int + MINUS: int + MULT: int + DIV: int + MOD: int + NEQ: int + INTTYPE: int + FLOATTYPE: int + BOOLTYPE: int + STRINGTYPE: int diff --git a/MiniC/README-interpreter.md b/MiniC/README-interpreter.md new file mode 100644 index 0000000..3d6f6c5 --- /dev/null +++ b/MiniC/README-interpreter.md @@ -0,0 +1,32 @@ +# MiniC interpreter and typer +LAB3, MIF08 / CAP / CS444 2022-23 + + +# Authors + +TODO: YOUR NAME HERE + +# Contents + +TODO for STUDENTS : Say a bit about the code infrastructure ... + +# Howto + +`make test-interpret TEST_FILES='TP03/tests/provided/examples/test_print_int.c'` for a single run + +`make test` to test all the files in `*/tests/*` according to `EXPECTED` results. + +You can select the files you want to test by using `make test TEST_FILES='TP03/**/*bad*.c'` (`**` means +"any number of possibly nested directories"). + +# Test design + +TODO: explain your tests. Do not repeat what test files already contain, just give the main objectives of the tests. + +# Design choices + +TODO: explain your choices - explain the limitations of your implementation. + +# Known bugs + +TODO: document any known bug and limitations. Did you do everything asked for? Did you implement an extension? diff --git a/MiniC/TP03/MiniCInterpretVisitor.py b/MiniC/TP03/MiniCInterpretVisitor.py new file mode 100644 index 0000000..c9716f6 --- /dev/null +++ b/MiniC/TP03/MiniCInterpretVisitor.py @@ -0,0 +1,185 @@ +# Visitor to *interpret* MiniC files +from typing import ( + Dict, + List) +from MiniCVisitor import MiniCVisitor +from MiniCParser import MiniCParser +from Lib.Errors import MiniCRuntimeError, MiniCInternalError, MiniCUnsupportedError + +MINIC_VALUE = int | str | bool | float | List['MINIC_VALUE'] + + +class MiniCInterpretVisitor(MiniCVisitor): + + _memory: Dict[str, MINIC_VALUE] + + def __init__(self): + self._memory = dict() # store all variable ids and values. + self.has_main = False + + # visitors for variable declarations + + def visitVarDecl(self, ctx) -> None: + # Initialise all variables in self._memory + type_str = ctx.typee().getText() + raise NotImplementedError(f"Initialization for type {type_str}") + + def visitIdList(self, ctx) -> List[str]: + raise NotImplementedError() + + def visitIdListBase(self, ctx) -> List[str]: + return [ctx.ID().getText()] + + # visitors for atoms --> value + + def visitParExpr(self, ctx) -> MINIC_VALUE: + return self.visit(ctx.expr()) + + def visitIntAtom(self, ctx) -> int: + return int(ctx.getText()) + + def visitFloatAtom(self, ctx) -> float: + return float(ctx.getText()) + + def visitBooleanAtom(self, ctx) -> bool: + return ctx.getText() == "true" + + def visitIdAtom(self, ctx) -> MINIC_VALUE: + raise NotImplementedError() + + def visitStringAtom(self, ctx) -> str: + return ctx.getText()[1:-1] # Remove the "" + + # visit expressions + + def visitAtomExpr(self, ctx) -> MINIC_VALUE: + return self.visit(ctx.atom()) + + def visitOrExpr(self, ctx) -> bool: + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + return lval | rval + + def visitAndExpr(self, ctx) -> bool: + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + return lval & rval + + def visitEqualityExpr(self, ctx) -> bool: + assert ctx.myop is not None + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + # be careful for float equality + if ctx.myop.type == MiniCParser.EQ: + return lval == rval + else: + return lval != rval + + def visitRelationalExpr(self, ctx) -> bool: + assert ctx.myop is not None + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + if ctx.myop.type == MiniCParser.LT: + return lval < rval + elif ctx.myop.type == MiniCParser.LTEQ: + return lval <= rval + elif ctx.myop.type == MiniCParser.GT: + return lval > rval + elif ctx.myop.type == MiniCParser.GTEQ: + return lval >= rval + else: + raise MiniCInternalError( + f"Unknown comparison operator '{ctx.myop}'" + ) + + def visitAdditiveExpr(self, ctx) -> MINIC_VALUE: + assert ctx.myop is not None + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + if ctx.myop.type == MiniCParser.PLUS: + if any(isinstance(x, str) for x in (lval, rval)): + return '{}{}'.format(lval, rval) + else: + return lval + rval + elif ctx.myop.type == MiniCParser.MINUS: + return lval - rval + else: + raise MiniCInternalError( + f"Unknown additive operator '{ctx.myop}'") + + def visitMultiplicativeExpr(self, ctx) -> MINIC_VALUE: + assert ctx.myop is not None + lval = self.visit(ctx.expr(0)) + rval = self.visit(ctx.expr(1)) + if ctx.myop.type == MiniCParser.MULT: + return lval * rval + elif ctx.myop.type == MiniCParser.DIV: + if rval == 0: + raise MiniCRuntimeError("Division by 0") + if isinstance(lval, int): + return lval // rval + else: + return lval / rval + elif ctx.myop.type == MiniCParser.MOD: + # TODO : interpret modulo + raise NotImplementedError() + else: + raise MiniCInternalError( + f"Unknown multiplicative operator '{ctx.myop}'") + + def visitNotExpr(self, ctx) -> bool: + return not self.visit(ctx.expr()) + + def visitUnaryMinusExpr(self, ctx) -> MINIC_VALUE: + return -self.visit(ctx.expr()) + + # visit statements + + def visitPrintlnintStat(self, ctx) -> None: + val = self.visit(ctx.expr()) + print(val) + + def visitPrintlnfloatStat(self, ctx) -> None: + val = self.visit(ctx.expr()) + if isinstance(val, float): + val = f"{val:.2f}" + print(val) + + def visitPrintlnboolStat(self, ctx) -> None: + val = self.visit(ctx.expr()) + print('1' if val else '0') + + def visitPrintlnstringStat(self, ctx) -> None: + val = self.visit(ctx.expr()) + print(val) + + def visitAssignStat(self, ctx) -> None: + raise NotImplementedError() + + def visitIfStat(self, ctx) -> None: + raise NotImplementedError() + + def visitWhileStat(self, ctx) -> None: + raise NotImplementedError() + + # TOPLEVEL + def visitProgRule(self, ctx) -> None: + self.visitChildren(ctx) + if not self.has_main: + # A program without a main function is compilable (hence + # it's not a typing error per se), but not executable, + # hence we consider it a runtime error. + raise MiniCRuntimeError("No main function in file") + + # Visit a function: ignore if non main! + def visitFuncDef(self, ctx) -> None: + funname = ctx.ID().getText() + if funname == "main": + self.has_main = True + self.visit(ctx.vardecl_l()) + self.visit(ctx.block()) + else: + raise MiniCUnsupportedError("Functions are not supported in evaluation mode") + + def visitFuncCall(self, ctx) -> None: # pragma: no cover + raise MiniCUnsupportedError("Functions are not supported in evaluation mode") diff --git a/MiniC/TP03/MiniCTypingVisitor.py b/MiniC/TP03/MiniCTypingVisitor.py new file mode 100644 index 0000000..f9c5fcd --- /dev/null +++ b/MiniC/TP03/MiniCTypingVisitor.py @@ -0,0 +1,148 @@ +# Visitor to *typecheck* MiniC files +from typing import List, NoReturn +from MiniCVisitor import MiniCVisitor +from MiniCParser import MiniCParser +from Lib.Errors import MiniCInternalError, MiniCTypeError + +from enum import Enum + + +class BaseType(Enum): + Float, Integer, Boolean, String = range(4) + + +# Basic Type Checking for MiniC programs. +class MiniCTypingVisitor(MiniCVisitor): + + def __init__(self): + self._memorytypes = dict() # id -> types + # For now, we don't have real functions ... + self._current_function = "main" + + def _raise(self, ctx, for_what, *types): + raise MiniCTypeError( + 'In function {}: Line {} col {}: invalid type for {}: {}'.format( + self._current_function, + ctx.start.line, ctx.start.column, for_what, + ' and '.join(t.name.lower() for t in types))) + + def _assertSameType(self, ctx, for_what, *types): + if not all(types[0] == t for t in types): + raise MiniCTypeError( + 'In function {}: Line {} col {}: type mismatch for {}: {}'.format( + self._current_function, + ctx.start.line, ctx.start.column, for_what, + ' and '.join(t.name.lower() for t in types))) + + def _raiseNonType(self, ctx, message) -> NoReturn: + raise MiniCTypeError( + 'In function {}: Line {} col {}: {}'.format( + self._current_function, + ctx.start.line, ctx.start.column, message)) + + # type declaration + + def visitVarDecl(self, ctx) -> None: + raise NotImplementedError() + + def visitBasicType(self, ctx): + assert ctx.mytype is not None + if ctx.mytype.type == MiniCParser.INTTYPE: + return BaseType.Integer + elif ctx.mytype.type == MiniCParser.FLOATTYPE: + return BaseType.Float + else: # TODO: same for other types + raise NotImplementedError() + + def visitIdList(self, ctx) -> List[str]: + raise NotImplementedError() + + def visitIdListBase(self, ctx) -> List[str]: + raise NotImplementedError() + + # typing visitors for expressions, statements ! + + # visitors for atoms --> type + def visitParExpr(self, ctx): + return self.visit(ctx.expr()) + + def visitIntAtom(self, ctx): + return BaseType.Integer + + def visitFloatAtom(self, ctx): + return BaseType.Float + + def visitBooleanAtom(self, ctx): + raise NotImplementedError() + + def visitIdAtom(self, ctx): + try: + return self._memorytypes[ctx.getText()] + except KeyError: + self._raiseNonType(ctx, + "Undefined variable {}".format(ctx.getText())) + + def visitStringAtom(self, ctx): + return BaseType.String + + # now visit expr + + def visitAtomExpr(self, ctx): + return self.visit(ctx.atom()) + + def visitOrExpr(self, ctx): + raise NotImplementedError() + + def visitAndExpr(self, ctx): + raise NotImplementedError() + + def visitEqualityExpr(self, ctx): + raise NotImplementedError() + + def visitRelationalExpr(self, ctx): + raise NotImplementedError() + + def visitAdditiveExpr(self, ctx): + assert ctx.myop is not None + raise NotImplementedError() + + def visitMultiplicativeExpr(self, ctx): + assert ctx.myop is not None + raise NotImplementedError() + + def visitNotExpr(self, ctx): + raise NotImplementedError() + + def visitUnaryMinusExpr(self, ctx): + raise NotImplementedError() + + # visit statements + + def visitPrintlnintStat(self, ctx): + etype = self.visit(ctx.expr()) + if etype != BaseType.Integer: + self._raise(ctx, 'println_int statement', etype) + + def visitPrintlnfloatStat(self, ctx): + etype = self.visit(ctx.expr()) + if etype != BaseType.Float: + self._raise(ctx, 'println_float statement', etype) + + def visitPrintlnboolStat(self, ctx): + etype = self.visit(ctx.expr()) + if etype != BaseType.Boolean: + self._raise(ctx, 'println_bool statement', etype) + + def visitPrintlnstringStat(self, ctx): + etype = self.visit(ctx.expr()) + if etype != BaseType.String: + self._raise(ctx, 'println_string statement', etype) + + def visitAssignStat(self, ctx): + raise NotImplementedError() + + def visitWhileStat(self, ctx): + raise NotImplementedError() + + def visitIfStat(self, ctx): + raise NotImplementedError() diff --git a/MiniC/TP03/tests/provided/examples-types/bad_def01.c b/MiniC/TP03/tests/provided/examples-types/bad_def01.c new file mode 100644 index 0000000..366bc74 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_def01.c @@ -0,0 +1,13 @@ +#include "printlib.h" + +int main(){ + int n; + n=17; + m=n+3; + println_int(m); + return 0; +} + +// EXPECTED +// EXITCODE 2 +// In function main: Line 6 col 2: Undefined variable m diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type00.c b/MiniC/TP03/tests/provided/examples-types/bad_type00.c new file mode 100644 index 0000000..9d3580e --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type00.c @@ -0,0 +1,10 @@ +#include "printlib.h" + +int main(){ + int x; + x="blablabla"; + return 0; +} +// EXITCODE 2 +// EXPECTED +// In function main: Line 5 col 2: type mismatch for x: integer and string diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type01.c b/MiniC/TP03/tests/provided/examples-types/bad_type01.c new file mode 100644 index 0000000..1a84239 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type01.c @@ -0,0 +1,14 @@ +#include "printlib.h" + +int main(){ + int n; + string s; + n=17; + s="seventeen"; + s = n*s; + return 0; +} + +// EXITCODE 2 +// EXPECTED +// In function main: Line 8 col 6: invalid type for multiplicative operands: integer and string diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type02.c b/MiniC/TP03/tests/provided/examples-types/bad_type02.c new file mode 100644 index 0000000..1a9796e --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type02.c @@ -0,0 +1,11 @@ +#include "printlib.h" + +int main(){ + string x; + x=1; + return 0; +} + +// EXITCODE 2 +// EXPECTED +// In function main: Line 5 col 2: type mismatch for x: string and integer diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type03.c b/MiniC/TP03/tests/provided/examples-types/bad_type03.c new file mode 100644 index 0000000..1dd7199 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type03.c @@ -0,0 +1,10 @@ +#include "printlib.h" + +int main(){ + int x; + x=34+f; + return 0; +} +// EXITCODE 2 +// EXPECTED +// In function main: Line 5 col 7: Undefined variable f diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type04.c b/MiniC/TP03/tests/provided/examples-types/bad_type04.c new file mode 100644 index 0000000..7f71583 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type04.c @@ -0,0 +1,11 @@ +#include "printlib.h" + +int main(){ + println_int("foo"); + return 0; +} + +// EXITCODE 2 +// EXPECTED +// In function main: Line 4 col 2: invalid type for println_int statement: string + diff --git a/MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c b/MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c new file mode 100644 index 0000000..7ad9582 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c @@ -0,0 +1,9 @@ +#include "printlib.h" + +int main(){ + println_bool(true+true); + return 0; +} +// EXITCODE 2 +// EXPECTED +// In function main: Line 4 col 15: invalid type for additive operands: boolean and boolean diff --git a/MiniC/TP03/tests/provided/examples-types/double_decl00.c b/MiniC/TP03/tests/provided/examples-types/double_decl00.c new file mode 100644 index 0000000..5a4bbbd --- /dev/null +++ b/MiniC/TP03/tests/provided/examples-types/double_decl00.c @@ -0,0 +1,12 @@ +#include "printlib.h" + +int main(){ + int x,y; + int z,x; + x=42; + return 0; +} + +// EXITCODE 2 +// EXPECTED +// In function main: Line 5 col 2: Variable x already declared diff --git a/MiniC/TP03/tests/provided/examples/bad_main.c b/MiniC/TP03/tests/provided/examples/bad_main.c new file mode 100644 index 0000000..3c3695a --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/bad_main.c @@ -0,0 +1,12 @@ +#include "printlib.h" + +int toto(){ + println_int(42); + return 0; +} + +// SKIP TEST EXPECTED +// EXITCODE 5 +// EXPECTED +// Functions are not supported in evaluation mode + diff --git a/MiniC/TP03/tests/provided/examples/no_main.c b/MiniC/TP03/tests/provided/examples/no_main.c new file mode 100644 index 0000000..a57eeda --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/no_main.c @@ -0,0 +1,7 @@ +#include "printlib.h" + +// SKIP TEST EXPECTED +// EXECCODE 1 +// EXPECTED +// No main function in file + diff --git a/MiniC/TP03/tests/provided/examples/test_assign.c b/MiniC/TP03/tests/provided/examples/test_assign.c new file mode 100644 index 0000000..c7b4bee --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_assign.c @@ -0,0 +1,13 @@ +#include "printlib.h" + +int main() +{ + int n,u; + n=17; + u=n; + println_int(n); + return 0; +} + +// EXPECTED +// 17 diff --git a/MiniC/TP03/tests/provided/examples/test_basic_bool.c b/MiniC/TP03/tests/provided/examples/test_basic_bool.c new file mode 100644 index 0000000..c754dc8 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_basic_bool.c @@ -0,0 +1,33 @@ +#include "printlib.h" + +int main() { + println_bool(1 == 1); + println_bool(1 == 2); + println_bool(1 != 1); + println_bool(1 != 2); + println_bool(1 < 2); + println_bool(1 < 0); + println_bool(1 <= 2); + println_bool(1 <= 0); + println_bool(1 > 2); + println_bool(1 > 0); + println_bool(1 >= 2); + println_bool(1 >= 0); + println_bool(!(1 < 2)); + return 0; +} + +// EXPECTED +// 1 +// 0 +// 0 +// 1 +// 1 +// 0 +// 1 +// 0 +// 0 +// 1 +// 0 +// 1 +// 0 diff --git a/MiniC/TP03/tests/provided/examples/test_basic_expr.c b/MiniC/TP03/tests/provided/examples/test_basic_expr.c new file mode 100644 index 0000000..12d43c2 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_basic_expr.c @@ -0,0 +1,23 @@ +#include "printlib.h" + +int main() { + println_int(42); + println_int(3 - 2); + println_int(-42); + println_int(- -42); + println_int(10 / 3); + println_int(9 / 3); + println_int(8 / 3); + println_float(42.3); + return 0; +} + +// EXPECTED +// 42 +// 1 +// -42 +// 42 +// 3 +// 3 +// 2 +// 42.30 diff --git a/MiniC/TP03/tests/provided/examples/test_compare.c b/MiniC/TP03/tests/provided/examples/test_compare.c new file mode 100644 index 0000000..d5f9481 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_compare.c @@ -0,0 +1,47 @@ +#include "printlib.h" + +int main() +{ + if (2 < 3) + { + println_int(1); + } + if (2 > 3) + { + println_int(2); + } + if (2 <= 2) + { + println_int(3); + } + if (2 >= 2) + { + println_int(4); + } + + if (2 == 3) + { + println_int(10); + } + if (2 != 3) + { + println_int(20); + } + if (2 == 2) + { + println_int(30); + } + if (2 != 2) + { + println_int(40); + } + + return 0; +} + +// EXPECTED +// 1 +// 3 +// 4 +// 20 +// 30 diff --git a/MiniC/TP03/tests/provided/examples/test_expr.c b/MiniC/TP03/tests/provided/examples/test_expr.c new file mode 100644 index 0000000..faed46f --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_expr.c @@ -0,0 +1,11 @@ +#include "printlib.h" + +int main() { + if ((1.0 + 2.0) * 3.0 == 9.0) { + println_string("OK"); + } + return 0; +} + +// EXPECTED +// OK diff --git a/MiniC/TP03/tests/provided/examples/test_print.c b/MiniC/TP03/tests/provided/examples/test_print.c new file mode 100644 index 0000000..4ad499b --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_print.c @@ -0,0 +1,15 @@ +#include "printlib.h" + +int main(){ + println_int(3/2+45*(2/1)); + println_int(23+19); + println_bool( (false || 3 != 77 ) && (42<=1515) ); + println_string("coucou"); + return 0; +} + +// EXPECTED +// 91 +// 42 +// 1 +// coucou diff --git a/MiniC/TP03/tests/provided/examples/test_print_int.c b/MiniC/TP03/tests/provided/examples/test_print_int.c new file mode 100644 index 0000000..21015d6 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_print_int.c @@ -0,0 +1,9 @@ +#include "printlib.h" + +int main(){ + println_int(42); + return 0; +} + +// EXPECTED +// 42 diff --git a/MiniC/TP03/tests/provided/examples/test_str_assign.c b/MiniC/TP03/tests/provided/examples/test_str_assign.c new file mode 100644 index 0000000..d0eda85 --- /dev/null +++ b/MiniC/TP03/tests/provided/examples/test_str_assign.c @@ -0,0 +1,11 @@ +#include "printlib.h" + +int main(){ + int x; + x="blabla"; + return 0; +} + +// EXPECTED +// In function main: Line 5 col 2: type mismatch for x: integer and string +// EXITCODE 2 diff --git a/MiniC/TP03/tests/provided/strcat/test_string01.c b/MiniC/TP03/tests/provided/strcat/test_string01.c new file mode 100644 index 0000000..b01fbad --- /dev/null +++ b/MiniC/TP03/tests/provided/strcat/test_string01.c @@ -0,0 +1,15 @@ +#include "printlib.h" + +int main(){ + string x,y,z; + x = "ENS"; + y = "De Lyon"; + z = x + " " + y; + println_string(z); + return 0; +} + +// SKIP TEST EXPECTED +// EXPECTED +// ENS De Lyon + diff --git a/MiniC/TP03/tests/provided/strcat/test_string02.c b/MiniC/TP03/tests/provided/strcat/test_string02.c new file mode 100644 index 0000000..7ea28a7 --- /dev/null +++ b/MiniC/TP03/tests/provided/strcat/test_string02.c @@ -0,0 +1,17 @@ +#include "printlib.h" + +int main(){ + string n,m; + n = "foo"; + m = "bar"; + println_string(n); + println_string(m); + println_string(n + m); // non-standard C + return 0; +} + +// SKIP TEST EXPECTED +// EXPECTED +// foo +// bar +// foobar diff --git a/MiniC/TP03/tests/provided/strcat/unititialized_str.c b/MiniC/TP03/tests/provided/strcat/unititialized_str.c new file mode 100644 index 0000000..e1ceea4 --- /dev/null +++ b/MiniC/TP03/tests/provided/strcat/unititialized_str.c @@ -0,0 +1,14 @@ +#include "printlib.h" + +int main() { + string s; + println_string(s); + s = s + "Coucou"; + println_string(s); + return 0; +} + +// SKIP TEST EXPECTED +// EXPECTED +// +// Coucou diff --git a/MiniC/TP03/tests/provided/uninitialised/bool.c b/MiniC/TP03/tests/provided/uninitialised/bool.c new file mode 100644 index 0000000..6a80cec --- /dev/null +++ b/MiniC/TP03/tests/provided/uninitialised/bool.c @@ -0,0 +1,17 @@ +#include "printlib.h" + +int main() { + bool x; + if (x) { + println_int(1); + } + x = !x; + if (x) { + println_int(2); + } + return 0; +} + +// SKIP TEST EXPECTED +// EXPECTED +// 2 diff --git a/MiniC/TP03/tests/provided/uninitialised/float.c b/MiniC/TP03/tests/provided/uninitialised/float.c new file mode 100644 index 0000000..df033a3 --- /dev/null +++ b/MiniC/TP03/tests/provided/uninitialised/float.c @@ -0,0 +1,13 @@ +#include "printlib.h" + +int main() { + float x; + println_float(x); + x = x + 1.0; + println_float(x); + return 0; +} + +// EXPECTED +// 0.00 +// 1.00 \ No newline at end of file diff --git a/MiniC/TP03/tests/provided/uninitialised/int.c b/MiniC/TP03/tests/provided/uninitialised/int.c new file mode 100644 index 0000000..b3afe0c --- /dev/null +++ b/MiniC/TP03/tests/provided/uninitialised/int.c @@ -0,0 +1,13 @@ +#include "printlib.h" + +int main() { + int x; + println_int(x); + x = x + 1; + println_int(x); + return 0; +} + +// EXPECTED +// 0 +// 1 \ No newline at end of file diff --git a/MiniC/TP03/tests/students/README.md b/MiniC/TP03/tests/students/README.md new file mode 100644 index 0000000..f7c87d9 --- /dev/null +++ b/MiniC/TP03/tests/students/README.md @@ -0,0 +1 @@ +Add your own tests in this directory. \ No newline at end of file diff --git a/MiniC/TP03/tests/students/ext-for-c/README.md b/MiniC/TP03/tests/students/ext-for-c/README.md new file mode 100644 index 0000000..f2a3430 --- /dev/null +++ b/MiniC/TP03/tests/students/ext-for-c/README.md @@ -0,0 +1 @@ +Add your own tests for the C-like 'for' loop in this directory (tests for the interpreter). diff --git a/MiniC/doc/Makefile b/MiniC/doc/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/MiniC/doc/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/MiniC/doc/conf.py b/MiniC/doc/conf.py new file mode 100644 index 0000000..0c9f373 --- /dev/null +++ b/MiniC/doc/conf.py @@ -0,0 +1,61 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys +sys.path.insert(0, os.path.abspath('..')) + + +# -- Project information ----------------------------------------------------- + +project = 'MiniC' +copyright = '2023, compil-lyon' +author = 'compil-lyon' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.viewcode', +] + +autodoc_default_options = { + 'member-order': 'bysource', + 'members': True, + 'undoc-members': True, + 'ignore-module-all': True, +} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] diff --git a/MiniC/doc/index.rst b/MiniC/doc/index.rst new file mode 100644 index 0000000..ebe38e6 --- /dev/null +++ b/MiniC/doc/index.rst @@ -0,0 +1,77 @@ +.. MiniC documentation master file, created by + sphinx-quickstart on Thu Feb 3 16:47:38 2022. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to MiniC's documentation! +================================= + +.. toctree:: + :maxdepth: 4 + :caption: Contents: + + Base library - Errors + Base library - Statement + Base library - RISC-V instructions + Base library - Operands + Base library - Function data + Base library - Graphs + Linear intermediate representation + Temporary allocation + Control Flow Graph - CFG and Basic blocks + Control Flow Graph - Terminators + SSA form - Dominance frontier + SSA form - Phi Nodes + +These pages document the various Python sources in the Lib/ +folder of MiniC. You should not have to edit them *at all*. + +Base library +------------ + +The :doc:`api/Lib.Statement` defines various classes that represent +RISC-V assembly statements, such as labels or 3-address instructions. + +We won't create objects of these classes directly very often. +Instead, to easily create such statements for standard RISC-V assembly instructions +and pseudo-instructions, we give you the :doc:`api/Lib.RiscV`. + +RISC-V instructions take arguments of various kinds, +as defined in the :doc:`api/Lib.Operands`. + +At some point, we will need some basic functions about oriented and non oriented graphs, +those are present in :doc:`api/Lib.Graphes`. + +Linear Intermediate representation +---------------------------------- + +The :doc:`api/Lib.LinearCode` allows to work with assembly source code +modeled as a list of statements. + +Temporary allocation +-------------------- + +Before implementing the all-in-memory allocator of lab 4a, +you should understand the naive allocator in the :doc:`api/Lib.Allocator`. + +Control Flow Graph Intermediate representation +---------------------------------------------- + +The classes for the CFG and its basic blocks are in the :doc:`api/Lib.CFG`. +Each block ends with a terminator, as documented in the :doc:`api/Lib.Terminator`. + +SSA form +-------- + +The translation of the CFG into SSA form makes use of dominance frontiers. +Functions to work with dominance are defined in the :doc:`api/Lib.Dominators`. + +Phi nodes, a special kind of statement that appears in CFGs in SSA form, +are defined in the :doc:`api/Lib.PhiNode`. + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/MiniC/libprint.s b/MiniC/libprint.s new file mode 100644 index 0000000..01845bd --- /dev/null +++ b/MiniC/libprint.s @@ -0,0 +1,251 @@ + .globl println_int +println_int: + .globl println_bool +println_bool: + addi sp,sp,-8 + sd ra, 0(sp) + call print_int + call newline + ld ra, 0(sp) + addi sp,sp,8 + ret + + .globl println_char +println_char: + addi sp,sp,-8 + sd ra, 0(sp) + call print_char + call newline + ld ra, 0(sp) + addi sp,sp,8 + ret + + .text + .align 1 + .globl println_string + .type println_string, @function +println_string: #address stored in a0 + addi sp,sp,-152 + sd ra,24(sp) + sd s0,16(sp) + addi s0,sp,32 + sd t0,32(sp) + sd t1,40(sp) + sd t2,48(sp) + sd t3,56(sp) + sd t4,64(sp) + sd t5,72(sp) + sd t6,80(sp) + + sd a0,88(sp) + sd a1,96(sp) + sd a2,104(sp) + sd a3,112(sp) + sd a4,120(sp) + sd a5,128(sp) + sd a6,136(sp) + sd a7,144(sp) + + ## Argument is already in a0, just forward it to puts + call puts + + ld ra,24(sp) + ld s0,16(sp) + + ld t0,32(sp) + ld t1,40(sp) + ld t2,48(sp) + ld t3,56(sp) + ld t4,64(sp) + ld t5,72(sp) + ld t6,80(sp) + + ld a0,88(sp) + ld a1,96(sp) + ld a2,104(sp) + ld a3,112(sp) + ld a4,120(sp) + ld a5,128(sp) + ld a6,136(sp) + ld a7,144(sp) + + addi sp,sp,152 + jr ra + .size println_string, .-println_string + .section .rodata + .align 3 +fmt_int: + .string "%ld" +str_empty: + .string "" + .text + .align 1 + .globl print_int + .type print_int, @function +print_int: # print int stored in a0, saves/restores all scratch registers (except ft which we don't use) + addi sp,sp,-152 + + sd ra,24(sp) + sd s0,16(sp) + + sd t0,32(sp) + sd t1,40(sp) + sd t2,48(sp) + sd t3,56(sp) + sd t4,64(sp) + sd t5,72(sp) + sd t6,80(sp) + + sd a0,88(sp) + sd a1,96(sp) + sd a2,104(sp) + sd a3,112(sp) + sd a4,120(sp) + sd a5,128(sp) + sd a6,136(sp) + sd a7,144(sp) + + ## first parameter of print_int is second parameter of printf + mv a1,a0 + ## first parameter of printf is the format string + la a0,fmt_int + call printf + + ld ra,24(sp) + ld s0,16(sp) + + ld t0,32(sp) + ld t1,40(sp) + ld t2,48(sp) + ld t3,56(sp) + ld t4,64(sp) + ld t5,72(sp) + ld t6,80(sp) + + ld a0,88(sp) + ld a1,96(sp) + ld a2,104(sp) + ld a3,112(sp) + ld a4,120(sp) + ld a5,128(sp) + ld a6,136(sp) + ld a7,144(sp) + + addi sp,sp,152 + jr ra + .size print_int, .-print_int + .align 1 + .globl newline + .type newline, @function +newline: # print int stored in a0, saves/restores all scratch registers (except ft which we don't use) + addi sp,sp,-152 + + sd ra,24(sp) + sd s0,16(sp) + + sd t0,32(sp) + sd t1,40(sp) + sd t2,48(sp) + sd t3,56(sp) + sd t4,64(sp) + sd t5,72(sp) + sd t6,80(sp) + + sd a0,88(sp) + sd a1,96(sp) + sd a2,104(sp) + sd a3,112(sp) + sd a4,120(sp) + sd a5,128(sp) + sd a6,136(sp) + sd a7,144(sp) + + ## first parameter of printf is the format string + la a0,str_empty + call puts + + ld ra,24(sp) + ld s0,16(sp) + + ld t0,32(sp) + ld t1,40(sp) + ld t2,48(sp) + ld t3,56(sp) + ld t4,64(sp) + ld t5,72(sp) + ld t6,80(sp) + + ld a0,88(sp) + ld a1,96(sp) + ld a2,104(sp) + ld a3,112(sp) + ld a4,120(sp) + ld a5,128(sp) + ld a6,136(sp) + ld a7,144(sp) + + addi sp,sp,152 + jr ra + .size newline, .-newline + .align 1 + .globl print_char + .type print_char, @function +print_char: # print char stored in a0 (ascii code) + addi sp,sp,-152 + sd ra,24(sp) + sd s0,16(sp) + + addi s0,sp,32 + + + sd t0,32(sp) + sd t1,40(sp) + sd t2,48(sp) + sd t3,56(sp) + sd t4,64(sp) + sd t5,72(sp) + sd t6,80(sp) + + sd a0,88(sp) + sd a1,96(sp) + sd a2,104(sp) + sd a3,112(sp) + sd a4,120(sp) + sd a5,128(sp) + sd a6,136(sp) + sd a7,144(sp) + + # call to putchar + mv a5,a0 + sb a5,-17(s0) + lbu a5,-17(s0) + sext.w a5,a5 + mv a0,a5 + call putchar + + #restore registers + ld ra,24(sp) + ld s0,16(sp) + + ld t0,32(sp) + ld t1,40(sp) + ld t2,48(sp) + ld t3,56(sp) + ld t4,64(sp) + ld t5,72(sp) + ld t6,80(sp) + + ld a0,88(sp) + ld a1,96(sp) + ld a2,104(sp) + ld a3,112(sp) + ld a4,120(sp) + ld a5,128(sp) + ld a6,136(sp) + ld a7,144(sp) + + addi sp,sp,152 + jr ra + .size print_char, .-print_char + + diff --git a/MiniC/printlib.h b/MiniC/printlib.h new file mode 100644 index 0000000..ea43937 --- /dev/null +++ b/MiniC/printlib.h @@ -0,0 +1,21 @@ +#include +/** + * Compatibility layer with C (meant to be #included in MiniC source + * files). Defines types, constants and functions that are built-in + * MiniC, to allow compiling MiniC programs with GCC. + */ + +typedef char * string; +typedef int bool; +static const int true = 1; +static const int false = 0; + +void print_int(int); +void println_int(int); +void println_bool(int); + +#define print_float(f) do { printf("%.2f", f); } while(0) +#define println_float(f) do { printf("%.2f\n", f); } while(0) + +void print_string(string); +void println_string(string); diff --git a/MiniC/pyproject.toml b/MiniC/pyproject.toml new file mode 100644 index 0000000..883b26b --- /dev/null +++ b/MiniC/pyproject.toml @@ -0,0 +1,2 @@ +[tool.pyright] +ignore = ["replace_cfgssa.py", "replace_smart_alloc.py", "replace_sequentialize_moves.py", "replace_target_api.py", "test_replace_mem.py", "MiniCCWrapper.py", "MiniCLexer.py", "MiniCParser.py", "MiniCVisitor.py", "*.diff.py", "**/*.diff.py"] diff --git a/MiniC/test_expect_pragma.py b/MiniC/test_expect_pragma.py new file mode 100644 index 0000000..bc5aca9 --- /dev/null +++ b/MiniC/test_expect_pragma.py @@ -0,0 +1,317 @@ +import collections +from pathlib import PurePath +import re +import os +import subprocess +import sys +import pytest + +testinfo = collections.namedtuple( + 'testinfo', + ['exitcode', 'execcode', 'output', 'linkargs', 'skip_test_expected']) +default_testinfo = testinfo( + exitcode=0, execcode=0, output='', linkargs=[], skip_test_expected=False) + +ASM = 'riscv64-unknown-elf-gcc' +SIMU = 'spike' + +LIBPRINT = 'libprint.s' +if 'LIBPRINT' in os.environ: + LIBPRINT = os.environ['LIBPRINT'] + + +def cat(filename): + with open(filename, "rb") as f: + for line in f: + sys.stdout.buffer.write(line) + + +def env_bool_variable(name, globals): + if name not in globals: + globals[name] = False + if name in os.environ: + globals[name] = True + + +def env_str_variable(name, globals): + if name in os.environ: + globals[name] = os.environ[name] + + +def filter_pathnames(pathlist, pattern): + return tuple(path for path in pathlist if PurePath(path).match(pattern)) + + +class TestExpectPragmas(object): + """Base class for tests that read the expected result as annotations + in test files. + + get_expect(file) will parse the file, looking EXPECT and EXITCODE + pragmas. + + run_command(command) is a wrapper around subprocess.check_output() + that extracts the output and exit code. + + """ + + def get_expect(self, filename): + """Parse "filename" looking for EXPECT and EXITCODE annotations. + + Look for a line "EXPECTED" (possibly with whitespaces and + comments). Text after this "EXPECTED" line is the expected + output. + + The file may also contain a line like "EXITCODE " where + is an integer, and is the expected exitcode of the command. + + The result is cached to avoid re-parsing the file multiple + times. + """ + if filename not in self.__expect: + self.__expect[filename] = self._extract_expect(filename) + return self.__expect[filename] + + def skip_if_partial_match(self, actual, expect, ignore_error_message): + if not ignore_error_message: + return False + + if expect.exitcode != actual.exitcode: + # Not the same exit code => something's wrong anyway + return False + + if actual.exitcode == 3: + # There's a syntax error in both expected and actual, + # but the actual error may slightly differ if we don't + # have the exact same .g4. + return True + + # Let the test pass with 'return True' if appropriate. + # Otherwise, continue to the full assertion for a + # complete diagnostic. + if actual.exitcode != 0 and expect.exitcode == actual.exitcode: + if expect.output == '': + # No output expected, but we know there must be an + # error. If there was a particular error message + # expected, we'd have written it in the output, + # hence just ignore the actual message. + return True + # Ignore difference in error message except in the + # line number (ignore the column too, it may + # slightly vary, eg. in "foo" / 4, the error may + # be considered on "foo" or on /): + if re.match(r'^In function [^ :]*: Line [0-9]* col [0-9]*:', actual.output): + out_loc = re.sub(r' col [0-9]*:.*$', '', actual.output) + exp_loc = re.sub(r' col [0-9]*:.*$', '', expect.output) + if out_loc == exp_loc: + return True + if any(x.output and (x.output.endswith('has no value yet!' + os.linesep) + or x.output.endswith(' by 0' + os.linesep)) + for x in (actual, expect)): + # Ignore the error message when our compiler + # raises this error (either in actual or expect, + # depending on what we're testing). + return True + + return False + + __expect = {} + + def _extract_expect(self, file): + exitcode = 0 + execcode = 0 + linkargs = [] + inside_expected = False + skip_test_expected = False + expected_lines = [] + expected_present = False + with open(file, encoding="utf-8") as f: + for line in f.readlines(): + # Ignore non-comments + if not re.match(r'\s*//', line): + continue + # Cleanup comment start and whitespaces + line = re.sub(r'\s*//\s*', '', line) + line = re.sub(r'\s*$', '', line) + + if line == 'END EXPECTED': + inside_expected = False + elif line.startswith('EXITCODE'): + words = line.split(' ') + assert len(words) == 2 + exitcode = int(words[1]) + elif line.startswith('EXECCODE'): + words = line.split(' ') + assert len(words) == 2 + execcode = int(words[1]) + elif line.startswith('LINKARGS'): + words = line.split(' ') + assert len(words) >= 2 + linkargs += [w.replace("$dir", os.path.dirname(file)) + for w in words[1:]] + elif line == 'EXPECTED': + inside_expected = True + expected_present = True + elif line == 'SKIP TEST EXPECTED': + skip_test_expected = True + elif inside_expected: + expected_lines.append(line) + + if not expected_present: + pytest.fail("Missing EXPECTED directive in test file") + + if expected_lines == []: + output = '' + else: + output = os.linesep.join(expected_lines) + os.linesep + + return testinfo(exitcode=exitcode, execcode=execcode, + output=output, linkargs=linkargs, + skip_test_expected=skip_test_expected) + + +class TestCompiler(object): + DISABLE_CODEGEN: bool + SKIP_NOT_IMPLEMENTED: bool + MINIC_COMPILE: str + MINICC_OPTS: list[str] + + def remove(self, file): + """Like os.remove(), but ignore errors, e.g. don't complain if the + file doesn't exist. + """ + try: + os.remove(file) + except OSError: + pass + + def run_command(self, cmd, scope="compile"): + """Run the command cmd (given as [command, arg1, arg2, ...]), and + return testinfo(exitcode=..., output=...) containing the + exit code of the command it its standard output + standard error. + + If scope="compile" (resp. "runtime"), then the exitcode (resp. + execcode) is set with the exit status of the command, and the + execcode (resp. exitcode) is set to 0. + """ + try: + output = subprocess.check_output(cmd, timeout=60, + stderr=subprocess.STDOUT) + status = 0 + except subprocess.CalledProcessError as e: + output = e.output + status = e.returncode + if scope == "runtime": + return default_testinfo._replace(execcode=status, + output=output.decode()) + else: + return default_testinfo._replace(exitcode=status, + output=output.decode()) + + def run_with_gcc(self, file, info): + return self.compile_and_simulate(file, info, reg_alloc='gcc', use_gcc=True) + + def compile_with_gcc(self, file, output_name): + print("Compiling with GCC...") + result = self.run_command( + [ASM, '-S', '-I./', + '--output=' + output_name, + '-Werror', + '-Wno-div-by-zero', # We need to accept 1/0 at compile-time + file]) + print(result.output) + print("Compiling with GCC... DONE") + return result + + def compile_and_simulate(self, file, info, reg_alloc, + use_gcc=False): + basename, _ = os.path.splitext(file) + output_name = basename + '-' + reg_alloc + '.s' + if use_gcc: + result = self.compile_with_gcc(file, output_name) + if result.exitcode != 0: + # We don't consider the exact exitcode, and ignore the + # output (our error messages may be different from + # GCC's) + return result._replace(exitcode=1, + output=None) + else: + result = self.compile_with_ours(file, output_name, reg_alloc) + if (self.DISABLE_CODEGEN or + reg_alloc == 'none' or + info.exitcode != 0 or result.exitcode != 0): + # Either the result is meaningless, or we already failed + # and don't need to go any further: + return result + # Only executable code past this point. + exec_name = basename + '-' + reg_alloc + '.riscv' + return self.link_and_run(output_name, exec_name, info) + + def link_and_run(self, output_name, exec_name, info): + self.remove(exec_name) + cmd = [ + ASM, output_name, LIBPRINT, + '-o', exec_name + ] + info.linkargs + print(info) + print("Assembling and linking " + output_name + ": " + ' '.join(cmd)) + try: + subprocess.check_output(cmd, timeout=60, stderr=subprocess.STDOUT) + except subprocess.CalledProcessError as e: + print("Assembling failed:\n") + print(e.output.decode()) + print("Assembler code below:\n") + cat(output_name) + pytest.fail() + assert (os.path.isfile(exec_name)) + sys.stdout.write("Assembling and linking ... OK\n") + try: + result = self.run_command( + [SIMU, + '-m100', # Limit memory usage to 100MB, more than enough and + # avoids crashing on a VM with <= 2GB RAM for example. + 'pk', + exec_name], + scope="runtime") + output = re.sub(r'bbl loader\r?\n', '', result.output) + print("Output of the program:") + print(output) + return testinfo(execcode=result.execcode, + exitcode=result.exitcode, + output=output, + linkargs=[], + skip_test_expected=False) + except subprocess.TimeoutExpired: + pytest.fail("Timeout executing program. Infinite loop in generated code?") + + def compile_with_ours(self, file, output_name, reg_alloc): + print("Compiling ...") + self.remove(output_name) + alloc_opt = '--reg-alloc=' + reg_alloc + out_opt = '--output=' + output_name + cmd = [sys.executable, self.MINIC_COMPILE] + if not self.DISABLE_CODEGEN: + cmd += [out_opt, alloc_opt] + cmd += self.MINICC_OPTS + cmd += [file] + result = self.run_command(cmd) + print(' '.join(cmd)) + print("Exited with status:", result.exitcode) + print(result.output) + if result.exitcode == 4: + if "AllocationError" in result.output: + if reg_alloc == 'naive': + pytest.skip("Too big for the naive allocator") + else: + pytest.skip("Offsets too big to be manipulated") + elif ("NotImplementedError" in result.output and + self.SKIP_NOT_IMPLEMENTED): + pytest.skip("Feature not implemented in this compiler") + if result.exitcode != 0: + # May either be a failing test or a test with expected + # compilation failure (bad type, ...). Let the caller + # do the assertion and decide: + return result + if not self.DISABLE_CODEGEN: + assert os.path.isfile(output_name) + print("Compiling ... OK") + return result diff --git a/MiniC/test_interpreter.py b/MiniC/test_interpreter.py new file mode 100755 index 0000000..1da3fe2 --- /dev/null +++ b/MiniC/test_interpreter.py @@ -0,0 +1,100 @@ +#! /usr/bin/env python3 +import pytest +import glob +import os +import sys +from test_expect_pragma import ( + TestExpectPragmas, cat, + TestCompiler, filter_pathnames + ) + +HERE = os.path.dirname(os.path.realpath(__file__)) +if HERE == os.path.realpath('.'): + HERE = '.' +TEST_DIR = HERE +IMPLEM_DIR = HERE + +SKIP_EXPECT = False +if 'SKIP_EXPECT' in os.environ: + SKIP_EXPECT = True + +DISABLE_TYPECHECK = False # True to skip typechecking + +ALL_FILES = [] +# tests for typing AND evaluation +ALL_FILES += glob.glob(os.path.join(TEST_DIR, 'TP03/tests/provided/**/*.c'), + recursive=True) +ALL_FILES += glob.glob(os.path.join(TEST_DIR, 'TP03/tests/students/**/*.c'), + recursive=True) + + +# Path setting +if 'TEST_FILES' in os.environ: + ALL_FILES = glob.glob(os.environ['TEST_FILES'], recursive=True) +MINIC_EVAL = os.path.join(IMPLEM_DIR, 'MiniCC.py') + +if 'FILTER' in os.environ: + ALL_FILES = filter_pathnames(ALL_FILES, os.environ['FILTER']) + + +class TestInterpret(TestExpectPragmas, TestCompiler): + DISABLE_CODEGEN = False + + def evaluate(self, file): + if not DISABLE_TYPECHECK: + res = self.run_command([sys.executable, MINIC_EVAL, + "--mode", "eval", file]) + else: + res = self.run_command([sys.executable, MINIC_EVAL, + "--mode", "eval", + "--disable-typecheck", file]) + if res.exitcode == 1: + # Execution can't distinguish exit code at runtime and static + # rejection of the program. But we know that an exit code of 1 is + # reserved for runtime errors, hence convert this exitcode + # into an execcode. + res = res._replace(exitcode=0, execcode=1) + return res + + # Not in test_expect_pragma to get assertion rewritting + def assert_equal(self, actual, expected, compiler): + if expected.output is not None and actual.output is not None: + assert actual.output == expected.output, \ + f"Output of the program is incorrect (using {compiler})." + assert actual.exitcode == expected.exitcode, \ + f"Exit code of the compiler ({compiler}) is incorrect" + assert actual.execcode == expected.execcode, \ + f"Exit code of the execution is incorrect (using {compiler})" + + @pytest.mark.parametrize('filename', ALL_FILES) + def test_expect(self, filename): + """Test the EXPECTED annotations in test files by launching the + program with GCC.""" + if SKIP_EXPECT: + pytest.skip("Skipping all test_expect " + "because $SKIP_EXPECT is set.") + cat(filename) # For diagnosis + expect = self.get_expect(filename) + if expect.skip_test_expected: + pytest.skip("Skipping test_expect with GCC because " + "the test contains SKIP TEST EXPECTED") + if expect.exitcode != 0: + # GCC is more permissive than us, so trying to compile an + # incorrect program would bring us no information (it may + # compile, or fail with a different message...) + pytest.skip("Not testing the expected value for " + "tests expecting exitcode!=0") + gcc_result = self.run_with_gcc(filename, expect) + self.assert_equal(gcc_result, expect, "gcc") + + @pytest.mark.parametrize('filename', ALL_FILES) + def test_eval(self, filename): + cat(filename) # For diagnosis + expect = self.get_expect(filename) + actual = self.evaluate(filename) + if expect: + self.assert_equal(actual, expect, "MiniCC") + + +if __name__ == '__main__': + pytest.main(sys.argv) diff --git a/TP03/arith-visitor/.gitignore b/TP03/arith-visitor/.gitignore new file mode 100644 index 0000000..cfd98dc --- /dev/null +++ b/TP03/arith-visitor/.gitignore @@ -0,0 +1,2 @@ +/AritListener.py +/AritVisitor.py diff --git a/TP03/arith-visitor/Arit.g4 b/TP03/arith-visitor/Arit.g4 new file mode 100644 index 0000000..47c322b --- /dev/null +++ b/TP03/arith-visitor/Arit.g4 @@ -0,0 +1,33 @@ +grammar Arit; + +prog: statement+ EOF #statementList + ; + +statement + : expr SCOL #exprInstr + | 'set' ID '=' expr SCOL #assignInstr + ; + +expr: expr multop=(MULT | DIV) expr #multiplicationExpr + | expr addop=(PLUS | MINUS) expr #additiveExpr + | atom #atomExpr + ; + +atom: INT #numberAtom + | ID #idAtom + | '(' expr ')' #parens + ; + + +SCOL : ';'; +PLUS : '+'; +MINUS : '-'; +MULT : '*'; +DIV : '/'; +ID: [a-zA-Z_] [a-zA-Z_0-9]*; + +INT: [0-9]+; + +COMMENT: '#' ~[\r\n]* -> skip; +NEWLINE: '\r'? '\n' -> skip; +WS : (' '|'\t')+ -> skip; diff --git a/TP03/arith-visitor/Makefile b/TP03/arith-visitor/Makefile new file mode 100644 index 0000000..78daa82 --- /dev/null +++ b/TP03/arith-visitor/Makefile @@ -0,0 +1,23 @@ +PACKAGE = Arit +MAINFILE = arit + +ifndef ANTLR4 +abort: + $(error variable ANTLR4 is not set) +endif + +all: $(PACKAGE).g4 + $(ANTLR4) $^ -Dlanguage=Python3 -visitor + +run: $(MAINFILE).py + python3 $^ + +ex: $(MAINFILE).py + python3 $^ < myexample + +test: all + python3 ./test_arith_visitor.py + +clean: + find . \( -iname "~" -or -iname "*.cache*" -or -iname "*.diff" -or -iname "log.txt" -or -iname "*.pyc" -or -iname "*.tokens" -or -iname "*.interp" \) -exec rm -rf '{}' \; + rm -rf $(PACKAGE)*.py diff --git a/TP03/arith-visitor/MyAritVisitor.py b/TP03/arith-visitor/MyAritVisitor.py new file mode 100644 index 0000000..10b4590 --- /dev/null +++ b/TP03/arith-visitor/MyAritVisitor.py @@ -0,0 +1,58 @@ +from AritVisitor import AritVisitor +from AritParser import AritParser + + +class UnknownIdentifier(Exception): + pass + + +class MyAritVisitor(AritVisitor): + """Visitor that evaluates an expression. Derives and overrides methods + from ArithVisitor (generated by ANTLR4).""" + def __init__(self): + self._memory = dict() # store id -> values + + def visitNumberAtom(self, ctx): + try: + value = int(ctx.getText()) + return value + except ValueError: + return float(ctx.getText()) + + def visitIdAtom(self, ctx): + try: + return self._memory[ctx.getText()] + except KeyError: + raise UnknownIdentifier(ctx.getText()) + + def visitMultiplicationExpr(self, ctx): + # Recursive calls to children. The visitor will choose the + # appropriate method (visitSomething) automatically. + leftval = self.visit(ctx.expr(0)) + rightval = self.visit(ctx.expr(1)) + # an elegant way to match the token: + if ctx.multop.type == AritParser.MULT: + return leftval * rightval + else: + return leftval / rightval + + def visitAdditiveExpr(self, ctx): + leftval = self.visit(ctx.expr(0)) + rightval = self.visit(ctx.expr(1)) + if ctx.addop.type == AritParser.PLUS: + return leftval + rightval + else: + return leftval - rightval + + def visitExprInstr(self, ctx): + val = self.visit(ctx.expr()) + print('The value is ' + str(val)) + + def visitParens(self, ctx): + return self.visit(ctx.expr()) + + def visitAssignInstr(self, ctx): + val = self.visit(ctx.expr()) + name = ctx.ID().getText() + print('now ' + name + ' has value ' + str(val)) + self._memory[name] = val diff --git a/TP03/arith-visitor/arit.py b/TP03/arith-visitor/arit.py new file mode 100644 index 0000000..d488343 --- /dev/null +++ b/TP03/arith-visitor/arit.py @@ -0,0 +1,28 @@ +from AritLexer import AritLexer +from AritParser import AritParser +# from AritVisitor import AritVisitor +from MyAritVisitor import MyAritVisitor, UnknownIdentifier + +from antlr4 import InputStream, CommonTokenStream +import sys + +# example of use of visitors to parse arithmetic expressions. +# stops when the first SyntaxError is launched. + + +def main(): + lexer = AritLexer(InputStream(sys.stdin.read())) + stream = CommonTokenStream(lexer) + parser = AritParser(stream) + tree = parser.prog() + print("Parsing : done.") + visitor = MyAritVisitor() + try: + visitor.visit(tree) + except UnknownIdentifier as exc: + print('Unknown identifier: {}'.format(exc.args[0])) + exit(-1) + + +if __name__ == '__main__': + main() diff --git a/TP03/arith-visitor/myexample b/TP03/arith-visitor/myexample new file mode 100644 index 0000000..53c1d21 --- /dev/null +++ b/TP03/arith-visitor/myexample @@ -0,0 +1,5 @@ +1 ; +12 ; +1+2 ; +1+2*3+4; +(1+2)*(3+4); diff --git a/TP03/arith-visitor/test_arith_visitor.py b/TP03/arith-visitor/test_arith_visitor.py new file mode 100755 index 0000000..47e4d4d --- /dev/null +++ b/TP03/arith-visitor/test_arith_visitor.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python +from AritLexer import AritLexer +from AritParser import AritParser +import pytest +from MyAritVisitor import MyAritVisitor + +from antlr4 import InputStream, CommonTokenStream +import sys + + +@pytest.mark.parametrize("input, expected", [ + pytest.param('1+1;', 2), + pytest.param('2-1;', 1), + pytest.param('2*3;', 6), + pytest.param('6/2;', 3), + pytest.param('set x=42; x+1;', 43), + pytest.param('set x=42; set x=12; x+1;', 13) +]) +def test_expr(input, expected): + lexer = AritLexer(InputStream(input)) + stream = CommonTokenStream(lexer) + parser = AritParser(stream) + tree = parser.prog() + print("Parsing : done.") + visitor = MyAritVisitor() + + def patched_visit(self, ctx): + self.last_expr = self.visit(ctx.expr()) + + visitor.visitExprInstr = patched_visit.__get__(visitor) + visitor.visit(tree) + assert visitor.last_expr == expected + + +if __name__ == '__main__': + pytest.main(sys.argv) diff --git a/TP03/tp3.pdf b/TP03/tp3.pdf new file mode 100644 index 0000000000000000000000000000000000000000..01f65757fa64ccd72f99957086372ec3c4e22420 GIT binary patch literal 229668 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�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 skip; + + + From adc6b5df065b24a6825f49bf1c1d1573c2fc370b Mon Sep 17 00:00:00 2001 From: Emma Nardino Date: Mon, 30 Sep 2024 10:44:54 +0200 Subject: [PATCH 2/3] Update TP3 --- TP03/tp3.pdf | Bin 229668 -> 229785 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/TP03/tp3.pdf b/TP03/tp3.pdf index 01f65757fa64ccd72f99957086372ec3c4e22420..f3fd1a5b3abba790674399b78a4d16a27f44919b 100644 GIT binary patch delta 6594 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 lXR9+imeuL{Gn}$bRV!O_k>(NvphD;85%eN2~w< From e367aaf970785844ed9298fd4d9013b0d4363cff Mon Sep 17 00:00:00 2001 From: Emma Nardino Date: Mon, 30 Sep 2024 11:11:19 +0200 Subject: [PATCH 3/3] Date --- TP03/tp3.pdf | Bin 229785 -> 229785 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/TP03/tp3.pdf b/TP03/tp3.pdf index f3fd1a5b3abba790674399b78a4d16a27f44919b..84a6c461c870f8d0fbc7485cf4971529156d4dab 100644 GIT binary patch delta 3040 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 bMdlZH;>W93u@=2o~=3Xcn zvcJP&u%^Qb>`a$*cpL~{I~*vB2LLkQl0@mp4HSX{upTPqdE10JMybKOuq(jZZ(0i1 zuss%MG+6sIL^+}iWdOf@e|Jxuv<`J>or%n-sV3L$#(SY}<#Msf$#X6t{CSD9y#K0% zvJ&vUZ`+SN^0^4!Iek48hRuYOYV52(bIcLP`$w9L-~!_or^>i3PW_Sfj`yQPg(RH& z_P{->HE?v#Pq$Sw;49@Uhm;C0S4(g)oS3RnBOn_!0@6_w%^B{S1=&uBFa?HcI~;-)|g1%UoLTcY`4iSjS12 zKN4;|9g*U+AicpG*GfBs2Y97s+@#_*R_0o*@Wnc;yx;I=4VM=h{A31t%7K)n9}mF_NOL~9iZ4zd5ZHJpSx8wlzQ%27P#RYh2IX) z)mm50%n4Nqqk~kBC){SPpNGjYO#4!Q9yx7&e_sl%@@a&Be<*SYH4~9fYI76aj!Tkq zC;&pC;bHzAOfu2OF2K>*VD*fQ(iff=pO)tan8@j*Wto9}R%_eRb=6aAOc{LV6 z2RhAyJ<6K^!C?EUTssVtOD9g^rgF1G;701adBJ#_^7m-Wp(t=I%QQ8vsd~?oN_XBu zU+${$9RYv1f6leAwX}~!yiw~D%j1&QXsDmz`ilz0ZPSYgb~CC55#j>(I|p|6bnFMU zEd}2YazX($%GC}S<2#lZb00dkxo5wthN`AKa8)Bm(tw*$bJ&ceZAQ{IavFI@^so12 z*CFQSO3t-@T=g_5$AWaaadFl=&XCyI_Tzf6Z{KVRf61+CCdk(vnRcGU&@kj)ocr1d z%z2fs-$*Y3TDhsz*V~HOBY;$xBw+n-ZrXM>WF(@$N3KoN_KSNY=Wsk-m%YbM_4#m&pghv;eDwuHG z)l#pnNF17PhH2E5gBOHpaZv85^F-c7FZ?>yf2MMatj=!k0cZNn$Qkx7p5WVcdpL5C zS#d|C?(g{x>!|aBuH06jQr2g~_d{XeCSdyqug4`Qiw_%A6bB|9_(OvH84c4h;E0eW zJT6IfN=KJbU2%)lby&U6K*?Yw{URw=2{0naRn^b4!)+JkczF#B_P2@?FzH!kfA zK!K(@JhnorWYWrD#5c=o81kp_dUHsBP3I7oQCKu2lK}syTOpt(@0$@c^Ovz1KWabi-Y(L zhxiQvhxiQwxA+YMCS52nG%_$UD=;!AFfb=63NKA>WJF5<^5WGc`doHZ(&wGC?&%H$+4^ML|O`I7K!^IYTfrK}0?vJVY@wH9<2r iG($HsK{Z1+L_|47K|?V(MK(n_LohQzM7JM)19}67l&w1e