-
Notifications
You must be signed in to change notification settings - Fork 1
Daily reports
We have all read the documents. Our plan for the day is to assign tasks to each other (roughly). We will then do the step 4 together. We will get familiar with git and OCaml.
Front end
- Etienne
- Andrey
- Sara
Back end
- Jules
- Théo
- Ning
Testing
- Should be done in parallel
Finished the first version of the parser with arithmetic expressions. Wrote the associated tests. We should be able to start working on arm generation. Reworked on the parser to implement the correct structure.
Played with ARM cross-compilation and emulation. Worked with Jules on a first draft for arm generation
Started working on the very basic register allocation for arm allocation.
Started creating the new type for knormalisation. Creating tests. Our functions are working up to nested let reduction using the syntax type, we will update the type tomorrow.
Brief with everyone on the state of the project. Make a git unstable branch. Close issues.
Back end : ARM generation is starting to look better. Goal for today : write proper automated tests. The very basic algorithm should be done today
Front end: using the types Andrey created today we will work on type closure. Now nested let works using the knorm type. App(f, list) works. Eventually we postponed the closure for next week, we will work on asml code generation.
Adendum: backend Finished (?) arm generation -> Write strong tests -> Proof read everything, check it's compliant with all the specs -> Look into how to print ints in ARM
Andrey was thinking on conditionals. Sara was working on alpha conversion and tests (valid and invalid). Etienne started working on asml code generation (by ignoring closures for now).
Ning work on the spill everything register allocation. Jules worked on tests for arm generation + handling external function calls with the parser
Goals for the day : clean the project and put all files together.
Build a snowman
Understand the way registers are called for function calls. Implement the spill everythin register allocation. Change the way we allocate the registers to generate a table. Think about linear scanning.
Clean up the files, put everything into the common folder. Import the type from the backend instead of using our own frontend copy. Work on closures for function definitions (no free variables). Finished alpha-conversion. Added conditionals to K-normalization. Work on type checking.
Implement external function calls (up to 4 parameters and no return values). Merge all our different versions of code and make sure it works. Finish implementing command line options.
Continuing work on typechecking. Finished GenEquations.
Continuing work on closures. Added support for function calls and put aside the closure support for now.
Work on the command line options.
Make sure everything is working for friday. Do not add anything more Start working on documentation and testing.
We will make more tests and clean up the code
We keep working on tests. We should write tests for code generation as well as asml parsing. We will also write scripts to automate them. We will improve the makefile to call the tests. We will improve the repository hierarchy, add symbolic links.
We write tests for the type checking.
Completed the autotests as well as automated make.
Wrote documentation and checked that everything is working.
We should not always use failwith.
Let rec and fclosures are working now (un-nesting of let recs)
Start working on traducing let recs. We will start by considering only function that have no parameters. Then functions with less than 4 parameters. Then we will consider return values (for let recs and external functions). Then we will consider functions with more than 4 parameters.
Made an agreement on the input and output type of register allocation for linear scanning part and started working on it.
Beginning of a fix to put the letrecs at the beginning of the program. For now they were placed randomly among lets.
Modified the type fundef in bsyntax.ml Modified the code in fasmlgen.ml to adapt to the new type and be prepared for internal function definition.
Starting to work
Added some features
work on traducing function definitions. There is more work than expected because of the way we have to handle the stack. We are near completion. Work on traducing if then else statements. It seems to work with a few tests. We need more complete tests, then write the documentations. We should tidy the code a bit. Finish the computing of live intervals for variables (for linear scanning allocation).
Starting to work on implementing type checking for function calls. Trying to merge Theo's work with Etienne's. Fix some issues with ASML generation. Closures are partially working. Added a suffixe to external functions in closure Working on a new version of print_asml
Finished work and tests for if then else statements, and written apropriate documentation. Starting to work on arrays : think about how to solve the problem, learn how to use syscalls. Tested live intervals algorithm and partially implemented linear scan register allocation.
Closure and recursive function are still we need to take care of that later. But we can now output asml correctly. Redid the function that edit the name of internal and external functions. new print_asml done We will need to create a type for closure and add support in the backend For tomorrow : add if-then-else to asmlgen.ml
Continuing implement linearscan register allocation.
Adding tuples & arrays.
Worked on implementing and testing memory allocation (mem operator). Worked on implementing the new() operator by using the previous work.
Adding remaining optimization functions: elimination of unnecessary definitions & inline expansion
Finishing linear scan register allocation. Work on improving the test scripts : they will now print the success rate the tests. Added tests in the backend (asml file). Went back to the original asml grammar (allowing ident_or_imm where they should be)
Finishing extending asml generation to take into account the closures. Debugging closure conversion.