RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-13 22:58:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add a real intro to the series.

Browse Source 
llvm-svn: 43752
This commit is contained in:
Chris Lattner 2007-11-06 05:02:48 +00:00
parent d0fb7600f9
commit 2480c20c7b
2 changed files with 85 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
docs/tutorial/LangImpl1.html
View File

@ -3,7 +3,7 @@
<html>
<head>
<title>Kaleidoscope: The basic language, with its lexer</title>
<title>Kaleidoscope: Tutorial Introduction and the Lexer</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<meta name="author" content="Chris Lattner">
<link rel="stylesheet" href="../llvm.css" type="text/css">
@ -11,7 +11,7 @@
<body>
<div class="doc_title">Kaleidoscope: The basic language, with its lexer</div>
<div class="doc_title">Kaleidoscope: Tutorial Introduction and the Lexer</div>
<ul>
<li><a href="index.html">Up to Tutorial Index</a></li>
@ -36,12 +36,88 @@
<div class="doc_text">
<p>Welcome to the "Implementing a language with LLVM" tutorial. This tutorial
will run the through implementation of a simple language, showing how fun and
runs through the implementation of a simple language, showing how fun and
easy it can be. This tutorial will get you up and started as well as help to
build a framework you can extend to other languages. You can also use this
tutorial to help you start playing with other LLVM specific things.
build a framework you can extend to other languages, allowing you to use this
as a way to start playing with other LLVM specific things.
</p>
<p>
The goal of this tutorial is to progressively unveil our language, describing
how it is built up over time. This will let us cover a fairly broad range of
language design and LLVM-specific usage issues, showing and explaining the code
for it all along the way, without overwhelming you with tons of details up
front.</p>
<p>It is useful to point out ahead of time that this tutorial is really about
teaching compiler techniques and LLVM specifically, <em>not</em> about teaching
modern and sane software engineering principles. In practice, this means that
we'll take a number of shortcuts to simplify the exposition. For example, the
code leaks memory, uses global variables all over the place, doesn't use nice
design patterns like visitors, etc... but it is very simple. If you dig in and
use the code as a basis for future projects, fixing these deficiencies shouldn't
be hard.</p>
<p>I've tried to put this tutorial together in a way that makes chapters easy to
skip over if you are already familiar or are uninterested with various pieces.
The structure of the tutorial is:
</p>
<ul>
<li><b><a href="#language">Chapter #1</a>: Introduction to the Kaleidoscope
language, and the definition of its Lexer</b> - This shows where we are going
and the basic functionality that we want it to do. In order to make this
tutorial maximally understandable and hackable, we choose to implement
everything in C++ instead of using lexer and parser generators. LLVM obviously
works just fine with such tools, feel free to use one if you prefer.</li>
<li><b><a href="LangImpl2.html">Chapter #2</a>: Implementing a Parser and
AST</b> - With the lexer in place, we can talk about parsing techniques and
basic AST construction. This tutorial describes recursive descent parsing and
operator precedence parsing. Nothing in Chapters 1 or 2 is LLVM-specific,
the code doesn't even link in LLVM at this point. :)</li>
<li><b><a href="LangImpl3.html">Chapter #3</a>: Code generation to LLVM IR</b> -
With the AST ready, we can show off how easy generation of LLVM IR really
is.</li>
<li><b><a href="LangImpl4.html">Chapter #4</a>: Adding JIT and Optimizer
Support</b> - Because a lot of people are interested in using LLVM as a JIT,
we'll dive right into it and show you the 3 lines it takes to add JIT support.
LLVM is also useful in many other ways, but this is one simple and "sexy" way
that shows off its power. :)</li>
<li><b><a href="LangImpl5.html">Chapter #5</a>: Extending the Language: Control
Flow</b> - With the language up and running, we show how to extend it with
control flow operations (if/then/else and a for loop). This gives us a chance
to talk about simple SSA construction and control flow.</li>
<li><b><a href="LangImpl6.html">Chapter #6</a>: Extending the Language:
User-defined Operators</b> - This is a silly but fun chapter that talks about
extending the language to let the user program define their own arbitrary
unary and binary operators (with assignable precedence!). This lets us build a
significant piece of the "language" as library routines.</li>
<li><b><a href="LangImpl7.html">Chapter #7</a>: Extending the Language: Mutable
Variables</b> - This chapter talks about adding user-defined local variables
along with variable assignment operator. The interesting part about this is how
easy and trivial it is to construct SSA form in LLVM (no, LLVM does <em>not</em>
require your front-end to construct SSA form!).</li>
<li><b><a href="LangImpl8.html">Chapter #8</a>: Conclusion and other useful LLVM
tidbits</b> - This chapter wraps up the series by talking about potential
ways to extend the language, but also includes a bunch of pointers to info about
"special topics" like adding garbage collection support, exceptions, debugging,
support for "spaghetti stacks", and a bunch of other tips and tricks.</li>
</ul>
<p>By the end of the tutorial, we'll have written about 700 lines of
non-comment, non-blank lines of code. With this small amount of code, we'll
have built up a very reasonable compiler for a non-trivial language including
a hand-written lexer, parser, AST, as well as code generation support with a JIT
compiler. While other systems may have interesting "hello world" tutorials,
I think the breadth of this tutorial is a great testament to the strengths of
LLVM and why you should consider it if you're interested in language or compiler
design.</p>
<p>A note about this tutorial: we expect you to extend the language and play
with it on your own. Take the code and go crazy hacking away at it. It can be
a lot of fun to play with languages! In any case, lets get into the code!</p>
</div>
<!-- *********************************************************************** -->
@ -93,20 +169,9 @@ atan2(sin(.4), cos(42))
</pre>
</div>
<p>In the first incarnation of the language, we will only support basic
arithmetic: if/then/else will be added in a future installment. Another
interesting aspect of the first implementation is that it is a completely
functional language, which does not allow you to have side-effects, etc. We
will eventually add side effects for those who prefer them.</p>
<p>In order to make this tutorial
maximally understandable and hackable, we choose to implement everything in C++
instead of using lexer and parser generators. LLVM obviously works just fine
with such tools, and making use of them doesn't impact the overall design.</p>
<p>A note about this tutorial: we expect you to extend the language and play
with it on your own. Take the code and go crazy hacking away at it. It can be
a lot of fun to play with languages!</p>
<p>A more interesting example is included in Chapter 6 where we show the code
used to <a href="LangImpl6.html#example">implement a Mandelbrot Set viewer</a>
in Kaleidoscope.</p>
</div>

2
docs/tutorial/index.html
View File

@ -27,7 +27,7 @@
</li>
<li>Implementing a language with LLVM: Kaleidoscope
<ol>
<li><a href="LangImpl1.html">The basic language, with its lexer</a></li>
<li><a href="LangImpl1.html">Tutorial Introduction and the Lexer</a></li>
<li><a href="LangImpl2.html">Implementing a Parser and AST</a></li>
<li><a href="LangImpl3.html">Implementing Code Generation to LLVM IR</a></li>
<li><a href="LangImpl4.html">Adding JIT and Optimizer Support</a></li>