All such things may be inappropriate for the top notch commercial compilers due to a limited performance, but are great for DSLs and for an amateur work, because they're so much easier than an ad hoc hand-coded approach.
Tiny does not mean "simple", and this is very true in compilers. There are ways of making a compiler trivial and extremely comprehensible, but it involves somewhat lengthy code. A tiny compiler which fuses multiple transforms into one may be much harder to comprehend than a larger compiler made of a long sequence of much simpler passes.
So your suggestion may be quite intimidating to the beginners. I'd rather recommend to start with the Racket-style language extensions and DSLs first.
It is nice and simple indeed but does not really show anything instructive in terms of backend, which is the focus of this thread.
And once you go into SSA and proper isel, there is no way to do it both easily and compactly at the same time, passes must be split for simplicity or fused into a mess for a compactness.
Of course, I am only talking about a number of lines of code, besides this you can keep your compiler totally trivial for any degree of optimisations complexity.
It does show you how to approach building a back-end in the first place, which I would consider to be quite instructive for someone who has never done it before. And it does separate the phases and still remains compact.
Of course, once you have progressed to things like SSA, you might want to study something more complex.
BTW, the current version of SubC has a much more interesting back-end and even uses AST-level optimization.
Also worth looking int pl/0 and the p-code machine.
Edit:
Also, Thomas W Christopher used to have some pdfs on the tools of computing web page that dealt with compilers. Had an interesting one about using matrices to computer first and follow sets. I wish I could find those again.
It is lightweight, well-documented and easy to use. It has an IntelliJ plugin that wills how you the sequence of API calls you'd need to make to create a given compiled Java class.
I still recommend reading the spec. You'll need to understand the JVM execution model and the meaning of the byte codes to successfully target it.
17 comments
[ 4.1 ms ] story [ 53.2 ms ] threadOn SSA, for example, the best introduction is S. Pop thesis: http://www.cri.ensmp.fr/people/pop/papers/2006-12-thesis.pdf
Nanopass: http://www.cs.indiana.edu/~dyb/pubs/nano-jfp.pdf http://andykeep.com/pubs/np-preprint.pdf
An extremely useful technique, somewhat related to what Sebastian Pop was doing with Prolog in his thesis: http://people.csail.mit.edu/mcarbin/papers/aplas05.pdf
also http://www.cs.cmu.edu/~aldrich/courses/654/tools/bierhoff-bd...
All such things may be inappropriate for the top notch commercial compilers due to a limited performance, but are great for DSLs and for an amateur work, because they're so much easier than an ad hoc hand-coded approach.
On LLVM specifically, can be used as a nice introduction into how backend works: http://eli.thegreenplace.net/2012/11/24/life-of-an-instructi...
https://news.ycombinator.com/item?id=9125912
https://news.ycombinator.com/item?id=8576068
https://news.ycombinator.com/item?id=8558822
http://bellard.org/otcc/
So your suggestion may be quite intimidating to the beginners. I'd rather recommend to start with the Racket-style language extensions and DSLs first.
Nils Holm, master compiler educator http://www.lulu.com/shop/search.ep?contributorId=740596
And once you go into SSA and proper isel, there is no way to do it both easily and compactly at the same time, passes must be split for simplicity or fused into a mess for a compactness.
Of course, I am only talking about a number of lines of code, besides this you can keep your compiler totally trivial for any degree of optimisations complexity.
Of course, once you have progressed to things like SSA, you might want to study something more complex.
BTW, the current version of SubC has a much more interesting back-end and even uses AST-level optimization.
https://github.com/melling/ComputerLanguages/blob/master/com...
Edit: Also, Thomas W Christopher used to have some pdfs on the tools of computing web page that dealt with compilers. Had an interesting one about using matrices to computer first and follow sets. I wish I could find those again.
http://asm.ow2.org/
It is lightweight, well-documented and easy to use. It has an IntelliJ plugin that wills how you the sequence of API calls you'd need to make to create a given compiled Java class.
I still recommend reading the spec. You'll need to understand the JVM execution model and the meaning of the byte codes to successfully target it.
If you want to think about memory models, then I recently wrote an introduction: http://beza1e1.tuxen.de/articles/memory_models.html