Last updated at 5:09 am UTC on 5 June 2008
- implement a system, contained in itself, capable of compiling methods down to metal without need to use any external tools.
- implement a Smalltalk compiler which transforms parsed syntax tree into lambda message sends
- design a basic object memory model with nominal requirements to object's memory formats
- implement a basic set of classes & methods to be able to run the system with its own new message sends
- implement a virtual machine simulator with sufficient bootstrapping code to be able to perform messages in it
- implement a basic, moving garbage collector
- implement compiler for compiling methods down to native code.
List of contributors:
Klaus D. Witzel
Currently we working on:
- parser based on Squeak's parser for transforming syntax tree to lambdas.
- a minimal set prototypes classes
- object memory simulator
Nearest goal is to make a system capable running in simulated mode, to test initial implementation of basic
object memory model & message sending semantics.
After this stage we'll be focused on providing a compiler layer for compiling lambdas down to native code.
We plan to use Exupery as backend for generating machine code.
Then, a facility will be to autoconvert Squeak classes to new object memory and for replacing Squeak's primitives by new native methods.
The system will be fully implemented in Smalltalk. We think that future VMs will require a tiny bootstrap C executable which provides minimal set of functions to be able to load an image and start it.
As small as:
int main(int argc, char**argv)
image = loadImage();
entryPoint = findEntryPoint(image, ARCHITECTURE, PLATFORM);
[x] - implemented
[~] - under construction
[ ] - planned
- [x] implementation of smalltalk-80 parser. Currently using slightly extended Squeak's parser, will be replaced with Scanner made by Klaus
- [~] implementation of code generator which produces low-level lambdas which represents smalltalk methods
- [x] native methods compiler
- [x] basic code transformations
- [x] branches
- [x] method inlining
- [x] blocks inlining
- [x] generator of CompiledMethod instance for simulator
- [x] polymorphic sends from native code
- [~] transforming ST methods to be compiled with native method compiler
- [x] polymorphic sends
- [x] block closures
- [x] instance variables (currently simple inline of Object>>instVarAt:/instVarAt:put:)
- [~] global & pool vars
- [~] machine simulator for new object memory
- [x] object memory bootstrapping
- [~] object memory formats
- [x] native method format
- [x] stack layout
- [x] method context memory layout & low-level support
- [x] ST block context memory layout & low-level support
- [ ] compilation to native code
- [ ] SmallInteger support
- [ ] smalltalk kernel classes hierarchy
- [ ] object memory file format
- [ ] small C program for image bootstrap