[llvm] r357867 - various improvements in wording, also unbreak the bot
Chris Lattner via llvm-commits
llvm-commits at lists.llvm.org
Sun Apr 7 07:23:12 PDT 2019
Author: lattner
Date: Sun Apr 7 07:23:11 2019
New Revision: 357867
URL: http://llvm.org/viewvc/llvm-project?rev=357867&view=rev
Log:
various improvements in wording, also unbreak the bot
Modified:
llvm/trunk/docs/tutorial/LangImpl02.rst
llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/LangImpl01.rst
llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/index.rst
Modified: llvm/trunk/docs/tutorial/LangImpl02.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/LangImpl02.rst?rev=357867&r1=357866&r2=357867&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/LangImpl02.rst (original)
+++ llvm/trunk/docs/tutorial/LangImpl02.rst Sun Apr 7 07:23:11 2019
@@ -730,7 +730,7 @@ our makefile/command line about which op
Here is the code:
-.. literalinclude:: ../../examples/Kaleidoscope/Chapter2/toy.cpp
+.. literalinclude:: ../../../examples/Kaleidoscope/Chapter2/toy.cpp
:language: c++
`Next: Implementing Code Generation to LLVM IR <LangImpl03.html>`_
Modified: llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/LangImpl01.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/LangImpl01.rst?rev=357867&r1=357866&r2=357867&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/LangImpl01.rst (original)
+++ llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/LangImpl01.rst Sun Apr 7 07:23:11 2019
@@ -8,15 +8,15 @@ Kaleidoscope: Kaleidoscope Introduction
The Kaleidoscope Language
=========================
-This tutorial will be illustrated with a toy language that we'll call
+This tutorial is illustrated with a toy language called
"`Kaleidoscope <http://en.wikipedia.org/wiki/Kaleidoscope>`_" (derived
from "meaning beautiful, form, and view"). Kaleidoscope is a procedural
language that allows you to define functions, use conditionals, math,
etc. Over the course of the tutorial, we'll extend Kaleidoscope to
support the if/then/else construct, a for loop, user defined operators,
-JIT compilation with a simple command line interface, etc.
+JIT compilation with a simple command line interface, debug info, etc.
-Because we want to keep things simple, the only datatype in Kaleidoscope
+We want to keep things simple, so the only datatype in Kaleidoscope
is a 64-bit floating point type (aka 'double' in C parlance). As such,
all values are implicitly double precision and the language doesn't
require type declarations. This gives the language a very nice and
@@ -35,10 +35,10 @@ simple syntax. For example, the followin
# This expression will compute the 40th number.
fib(40)
-We also allow Kaleidoscope to call into standard library functions (the
-LLVM JIT makes this completely trivial). This means that you can use the
+We also allow Kaleidoscope to call into standard library functions - the
+LLVM JIT makes this really easy. This means that you can use the
'extern' keyword to define a function before you use it (this is also
-useful for mutually recursive functions). For example:
+useful for mutually recursive functions). For example:
::
@@ -52,7 +52,7 @@ A more interesting example is included i
little Kaleidoscope application that `displays a Mandelbrot
Set <LangImpl06.html#kicking-the-tires>`_ at various levels of magnification.
-Lets dive into the implementation of this language!
+Let's dive into the implementation of this language!
The Lexer
=========
@@ -89,7 +89,7 @@ values or it will be an 'unknown' charac
as its ASCII value. If the current token is an identifier, the
``IdentifierStr`` global variable holds the name of the identifier. If
the current token is a numeric literal (like 1.0), ``NumVal`` holds its
-value. Note that we use global variables for simplicity, this is not the
+value. We use global variables for simplicity, but this is not the
best choice for a real language implementation :).
The actual implementation of the lexer is a single function named
@@ -147,12 +147,12 @@ same loop, we handle them here inline. N
return tok_number;
}
-This is all pretty straight-forward code for processing input. When
+This is all pretty straightforward code for processing input. When
reading a numeric value from input, we use the C ``strtod`` function to
convert it to a numeric value that we store in ``NumVal``. Note that
this isn't doing sufficient error checking: it will incorrectly read
"1.23.45.67" and handle it as if you typed in "1.23". Feel free to
-extend it :). Next we handle comments:
+extend it! Next we handle comments:
.. code-block:: c++
Modified: llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/index.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/index.rst?rev=357867&r1=357866&r2=357867&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/index.rst (original)
+++ llvm/trunk/docs/tutorial/MyFirstLanguageFrontend/index.rst Sun Apr 7 07:23:11 2019
@@ -2,6 +2,9 @@
My First Language Frontend with LLVM Tutorial
=============================================
+**Requirements:** This tutorial assumes you know C++, but no previous
+compiler experience is necessary.
+
Welcome to the "My First Language Frontend with LLVM" tutorial. Here we
run through the implementation of a simple language, showing
how fun and easy it can be. This tutorial will get you up and running
@@ -12,70 +15,69 @@ This tutorial introduces the simple "Kal
iteratively over the course of several chapters, showing how it is built
over time. This lets us cover a range of language design and LLVM-specific
ideas, showing and explaining the code for it all along the way,
-and reduces the amount of overwhelming details up front. We strongly
+and reduces the overwhelming amount of details up front. We strongly
encourage that you *work with this code* - make a copy and hack it up and
experiment.
-Warning: In order to focus on teaching compiler techniques and LLVM
+**Warning**: In order to focus on teaching compiler techniques and LLVM
specifically,
this tutorial does *not* show best practices in software engineering
principles. For example, the code uses global variables
-all over the place, doesn't use nice design patterns like
+pervasively, doesn't use
`visitors <http://en.wikipedia.org/wiki/Visitor_pattern>`_, etc... but
instead keeps things simple and focuses on the topics at hand.
This tutorial is structured into chapters covering individual topics,
-allowing you to skip ahead or over things as you wish:
+allowing you to skip ahead as you wish:
-- `Chapter #1 <LangImpl01.html>`_: Introduction to the Kaleidoscope
- language, and the definition of its Lexer. This shows where we are
+- `Chapter #1: Kaleidoscope language and Lexer <LangImpl01.html>`_ -
+ This shows where we are
going and the basic functionality that we want to build. A lexer
is also the first part of building a parser for a language, and we
use a simple C++ lexer which is easy to understand.
-- `Chapter #2 <LangImpl02.html>`_: Implementing a Parser and AST -
+- `Chapter #2: Implementing a Parser and AST <LangImpl02.html>`_ -
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.
-- `Chapter #3 <LangImpl03.html>`_: Code generation to LLVM IR - with
+- `Chapter #3: Code generation to LLVM IR <LangImpl03.html>`_ - with
the AST ready, we show how easy it is to generate LLVM IR, and show
a simple way to incorporate LLVM into your project.
-- `Chapter #4 <LangImpl04.html>`_: Adding JIT and Optimizer Support
- - One great thing about LLVM is its support for JIT compilation, so
+- `Chapter #4: Adding JIT and Optimizer Support <LangImpl04.html>`_ -
+ One great thing about LLVM is its support for JIT compilation, so
we'll dive right into it and show you the 3 lines it takes to add JIT
support. Later chapters show how to generate .o files.
-- `Chapter #5 <LangImpl05.html>`_: Extending the Language: Control
- Flow - With the basic language up and running, we show how to extend
+- `Chapter #5: Extending the Language: Control Flow <LangImpl05.html>`_ - With the basic language up and running, we show how to extend
it with control flow operations ('if' statement and a 'for' loop). This
gives us a chance to talk about SSA construction and control
flow.
-- `Chapter #6 <LangImpl06.html>`_: Extending the Language:
- User-defined Operators - This chapter extends the language to let
- users define arbitrary unary and binary operators (with assignable
- precedence!). This lets us build a significant piece of the
+- `Chapter #6: Extending the Language: User-defined Operators
+ <LangImpl06.html>`_ - This chapter extends the language to let
+ users define arbitrary unary and binary operators - with assignable
+ precedence! This allows us to build a significant piece of the
"language" as library routines.
-- `Chapter #7 <LangImpl07.html>`_: Extending the Language: Mutable
- Variables - This chapter talks about adding user-defined local
+- `Chapter #7: Extending the Language: Mutable Variables
+ <LangImpl07.html>`_ - This chapter talks about adding user-defined local
variables along with an assignment operator. This shows how easy it is
to construct SSA form in LLVM: LLVM does *not* require your front-end
to construct SSA form in order to use it!
-- `Chapter #8 <LangImpl08.html>`_: Compiling to Object Files - This
+- `Chapter #8: Compiling to Object Files <LangImpl08.html>`_ - This
chapter explains how to take LLVM IR and compile it down to object
files, like a static compiler does.
-- `Chapter #9 <LangImpl09.html>`_: Extending the Language: Debug
- Information - A real language needs to support debuggers, so we add
- debug information that allows setting breakpoints in Kaleidoscope
+- `Chapter #9: Extending the Language: Debug Information
+ <LangImpl09.html>`_ - A real language needs to support debuggers, so we
+ add debug information that allows setting breakpoints in Kaleidoscope
functions, print out argument variables, and call functions!
-- `Chapter #10 <LangImpl10.html>`_: Conclusion and other useful LLVM
- tidbits - This chapter wraps up the series by talking about
- potential ways to extend the language, and includes some
- pointers to info on "special topics" like adding garbage
+- `Chapter #10: Conclusion and other tidbits <LangImpl10.html>`_ - This
+ chapter wraps up the series by discussing ways to extend the language
+ and includes pointers to info on "special topics" like adding garbage
collection support, exceptions, debugging, support for "spaghetti
- stacks", and random tips and tricks.
+ stacks", etc.
By the end of the tutorial, we'll have written a bit less than 1000 lines
-of non-comment, non-blank, lines of code. With this small amount of
+of (non-comment, non-blank) lines of code. With this small amount of
code, we'll have built up a nice little compiler for a non-trivial
language including a hand-written lexer, parser, AST, as well as code
-generation support with a JIT compiler. The breadth of this
-tutorial is a great testament to the strengths of LLVM and shows why
-it is such a popular target for language designers.
+generation support - both static and JIT! The breadth of this is a great
+testament to the strengths of LLVM and shows why it is such a popular
+target for language designers and others who need high performance code
+generation.
More information about the llvm-commits
mailing list