+
+
Welcome to the the final chapter of the "Implementing a
+language with LLVM" tutorial. In the course of this tutorial, we have grown
+our little Kaleidoscope language from being a useless toy, to being a
+semi-interesting (but probably still useless) toy. :)
+
+
It is interesting to see how far we've come, and how little code it has
+taken. We built the entire lexer, parser, AST, code generator, and an
+interactive run-loop (with a JIT!) by-hand in under 700 lines of
+(non-comment/non-blank) code.
+
+
Our little language supports a couple of interesting features: it supports
+user defined binary and unary operators, it uses JIT compilation for immediate
+evaluation, and it supports a few control flow constructs with SSA construction.
+
+
+
Part of the idea of this tutorial was to show you how easy and fun it can be
+to define, build, and play with languages. Building a compiler need not be a
+scary or mystical process! Now that you've seen some of the basics, I strongly
+encourage you to take the code and hack on it. For example, try adding:
+
+
+- global variables - While global variables have questional value in
+modern software engineering, they are often useful when putting together quick
+little hacks like the Kaleidoscope compiler itself. Fortunately, our current
+setup makes it very easy to add global variables: just have value lookup check
+to see if an unresolved variable is in the global variable symbol table before
+rejecting it. To create a new global variable, make an instance of the LLVM
+GlobalVariable class.
+
+- typed variables - Kaleidoscope currently only supports variables of
+type double. This gives the language a very nice elegance, because only
+supporting one type means that you never have to specify types. Different
+languages have different ways of handling this. The easiest way is to require
+the user to specify types for every variable definition, and record the type
+of the variable in the symbol table along with its Value*.
+
+- arrays, structs, vectors, etc - Once you add types, you can start
+extending the type system in all sorts of interesting ways. Simple arrays are
+very easy and are quite useful for many different applications. Adding them is
+mostly an exercise in learning how the LLVM getelementptr instruction works.
+The getelementptr instruction is so nifty/unconventional, it has its own FAQ!).
+
+- standard runtime - Our current language allows the user to access
+arbitrary external functions, and we use it for things like "printd" and
+"putchard". As you extend the language to add higher-level constructs, often
+these constructs make the most amount of sense to be lowered into calls into a
+language-supplied runtime. For example, if you add hash tables to the language,
+it would probably make sense to add the routines to a runtime, instead of
+inlining them all the way.
+
+- memory management - Currently we can only access the stack in
+Kaleidoscope. It would also be useful to be able to allocate heap memory,
+either with calls to the standard libc malloc/free interface or with a garbage
+collector. If you choose to use garbage collection, note that LLVM fully
+supports Accurate Garbage Collection
+including algorithms that move objects and need to scan/update the stack.
+
+- debugger support - LLVM supports generation of DWARF Debug info which is understood by
+common debuggers like GDB. Adding support for debug info is fairly
+straight-forward. The best way to understand it is to compile some C/C++ code
+with "llvm-gcc -g -O0" and taking a look at what it produces.
+
+- exception handlingsupport - LLVM supports generation of zero cost exceptions which interoperate
+with code compiled in other languages. You could also generate code by
+implicitly making every function return an error value and checking it. You
+could also make explicit use of setjmp/longjmp. There are many different ways
+to go here.
+
+- object orientation, generics, database access, complex numbers,
+geometric programming, ... - Really, there is
+no end of crazy features that you can add to the language.
+
+
+
+
+Have fun - try doing something crazy and unusual. Building a language like
+everyone else always has is much less fun than trying something a little crazy
+and off the wall and seeing how it turns out. If you get stuck or want to talk
+about it, feel free to email the llvmdev mailing
+list: it has lots of people who are interested in languages and are often
+willing to help out.
+
+
+
Before we end, I want to talk about some "tips and tricks" for generating
+LLVM IR. These are some of the more subtle things that may not be obvious, but
+are very useful if you want to take advantage of LLVM's capabilities.
+
+
