llvm/docs/tutorial/MyFirstLanguageFrontend/index.rst

   1 =============================================
   2 My First Language Frontend with LLVM Tutorial
   3 =============================================
   4
   5 .. toctree::
   6    :hidden:
   7
   8    LangImpl01
   9    LangImpl02
  10    LangImpl03
  11    LangImpl04
  12    LangImpl05
  13    LangImpl06
  14    LangImpl07
  15    LangImpl08
  16    LangImpl09
  17    LangImpl10
  18
  19 **Requirements:** This tutorial assumes you know C++, but no previous
  20 compiler experience is necessary.
  21
  22 Welcome to the "My First Language Frontend with LLVM" tutorial. Here we
  23 run through the implementation of a simple language, showing
  24 how fun and easy it can be.  This tutorial will get you up and running
  25 fast and show a concrete example of something that uses LLVM to generate
  26 code.
  27
  28 This tutorial introduces the simple "Kaleidoscope" language, building it
  29 iteratively over the course of several chapters, showing how it is built
  30 over time. This lets us cover a range of language design and LLVM-specific
  31 ideas, showing and explaining the code for it all along the way,
  32 and reduces the overwhelming amount of details up front.  We strongly
  33 encourage that you *work with this code* - make a copy and hack it up and
  34 experiment.
  35
  36 **Warning**: In order to focus on teaching compiler techniques and LLVM
  37 specifically,
  38 this tutorial does *not* show best practices in software engineering
  39 principles.  For example, the code uses global variables
  40 pervasively, doesn't use
  41 `visitors <http://en.wikipedia.org/wiki/Visitor_pattern>`_, etc... but
  42 instead keeps things simple and focuses on the topics at hand.
  43
  44 This tutorial is structured into chapters covering individual topics,
  45 allowing you to skip ahead as you wish:
  46
  47 -  `Chapter #1: Kaleidoscope language and Lexer <LangImpl01.html>`_ -
  48    This shows where we are
  49    going and the basic functionality that we want to build.  A lexer
  50    is also the first part of building a parser for a language, and we
  51    use a simple C++ lexer which is easy to understand.
  52 -  `Chapter #2: Implementing a Parser and AST <LangImpl02.html>`_ -
  53    With the lexer in place, we can talk about parsing techniques and
  54    basic AST construction. This tutorial describes recursive descent
  55    parsing and operator precedence parsing.
  56 -  `Chapter #3: Code generation to LLVM IR <LangImpl03.html>`_ - with
  57    the AST ready, we show how easy it is to generate LLVM IR, and show
  58    a simple way to incorporate LLVM into your project.
  59 -  `Chapter #4: Adding JIT and Optimizer Support <LangImpl04.html>`_ -
  60    One great thing about LLVM is its support for JIT compilation, so
  61    we'll dive right into it and show you the 3 lines it takes to add JIT
  62    support. Later chapters show how to generate .o files.
  63 -  `Chapter #5: Extending the Language: Control Flow <LangImpl05.html>`_ - With
  64    the basic language up and running, we show how to extend
  65    it with control flow operations ('if' statement and a 'for' loop). This
  66    gives us a chance to talk about SSA construction and control
  67    flow.
  68 -  `Chapter #6: Extending the Language: User-defined Operators
  69    <LangImpl06.html>`_ - This chapter extends the language to let
  70    users define arbitrary unary and binary operators - with assignable
  71    precedence!  This allows us to build a significant piece of the
  72    "language" as library routines.
  73 -  `Chapter #7: Extending the Language: Mutable Variables
  74    <LangImpl07.html>`_ - This chapter talks about adding user-defined local
  75    variables along with an assignment operator. This shows how easy it is
  76    to construct SSA form in LLVM: LLVM does *not* require your front-end
  77    to construct SSA form in order to use it!
  78 -  `Chapter #8: Compiling to Object Files <LangImpl08.html>`_ - This
  79    chapter explains how to take LLVM IR and compile it down to object
  80    files, like a static compiler does.
  81 -  `Chapter #9: Debug Information <LangImpl09.html>`_ - A real language
  82    needs to support debuggers, so we
  83    add debug information that allows setting breakpoints in Kaleidoscope
  84    functions, print out argument variables, and call functions!
  85 -  `Chapter #10: Conclusion and other tidbits <LangImpl10.html>`_ - This
  86    chapter wraps up the series by discussing ways to extend the language
  87    and includes pointers to info on "special topics" like adding garbage
  88    collection support, exceptions, debugging, support for "spaghetti
  89    stacks", etc.
  90
  91 By the end of the tutorial, we'll have written a bit less than 1000 lines
  92 of (non-comment, non-blank) lines of code. With this small amount of
  93 code, we'll have built up a nice little compiler for a non-trivial
  94 language including a hand-written lexer, parser, AST, as well as code
  95 generation support - both static and JIT!  The breadth of this is a great
  96 testament to the strengths of LLVM and shows why it is such a popular
  97 target for language designers and others who need high performance code
  98 generation.