LLVM Tutorial #11: Playing with REPL

In this series I walkthrough the LLVM "Kaleidoscope" Tutorial, where you follow step by step to create your first programming language frontend using LLVM as the backend. Last time we had a long grueling debugging session. This episode is a shorter session where I enjoy the fruits of that labor and play with the REPL a bit, and also talk a bit about LLVM.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : okay hi there this is Toby who are
00:03 : continuing on our series for following
00:07 : along with the LLVM tutorial from LOL
00:11 : byung org so we're at the end of chapter
00:15 : 3 I had a kind of a tough debugging
00:20 : session figuring out the the one line
00:24 : that I was missing from my toad in order
00:26 : to make everything work in person that
00:29 : the instantiation of the module I didn't
00:34 : have this line and that broke everything
00:37 : made the program sick fault figuring
00:43 : that out but we got that to work now so
00:46 : we have a program now that has disrupt
00:50 : or you can type in lines of code in the
00:54 : Kaleidoscope language and then it'll
00:56 : translate it into LLVM they are so for
01:02 : example the Kaleidoscope program 1+1
01:07 : gets translated this to this program in
01:11 : LLVM i are you might notice that first
01:14 : of all the it's a it defines a function
01:20 : which is unnamed well it's actually
01:22 : named at 0 so we will have the parser
01:30 : automatically wrap the top level of the
01:33 : program inside a function which is why
01:36 : we got this function construct and then
01:38 : a function construct that is part a
01:42 : function construct in the ast gets
01:44 : translated to a function construct in
01:47 : LLVM ir so that's why we see a function
01:51 : in LLVM right now the RVM we have to
01:56 : create a black construct in LLVM ir and
02:01 : we had to give that block a name we
02:04 : named it entry and that's why we see
02:05 : entry colon here and then this is a
02:08 : return statement
02:10 : construct a red construct this is a
02:13 : double type contract and this two
02:16 : literal is you can see that OPM decided
02:20 : to go ahead and add these two constants
02:22 : together automatically instead of having
02:25 : the program itself do that calculation
02:27 : because they're constants anyway
02:31 : this makes sense because the computer
02:35 : would execute it faster if you didn't
02:38 : have to do a calculation in the first
02:39 : place
02:40 : this experiment with this a little bit
02:43 : and do some other instructions also
02:49 : follow along with the tutorial here a
02:51 : little bit so you don't see that yeah it
02:55 : kind of gave this same kind of example
02:57 : four plus five it sort of magically
02:59 : added them together into this nine
03:01 : constant and I think this automatic
03:06 : calculation of constants is like both
03:10 : sides of your plus operator are
03:15 : constants you can just do that
03:17 : calculation at compile time and I
03:20 : believe that is called is that code
03:24 : constant propagation is that what that's
03:27 : called not sure but maybe that's what
03:30 : constant propagation means it's one of
03:32 : the compiler optimizations that LLVM
03:36 : does off the bat for you let's see the
03:44 : next example they showed is that which
03:48 : is very interesting I'm gonna do my own
03:50 : version let's define a distance formula
03:54 : one of my favorite examples x1 y1 x2 y2
04:00 : oh we don't have square root
04:08 : we don't have square root so we can just
04:11 : sort of fake it then so X 1 minus X 2
04:19 : [Music]
04:20 : times X 1 times y 2 this is the square
04:37 : of the distance okay so if I did this
04:40 : with a semicolon I get this LLVM I are a
04:45 : program wow that's impressive
04:48 : so we have define a function called act
04:51 : dist
04:52 : in the LLVM language it takes four
04:57 : parameters of them are doubles
04:59 : kaleidoscope only has doubles who cannot
05:04 : let's see if it did the order of
05:06 : presidents correctly because it's
05:09 : supposed to first do this and then do
05:11 : this and then multiply them together and
05:13 : then do this do this multiply them
05:16 : together and then add them together
05:18 : right so first it subtracts X 1 and X 2
05:24 : that is correct and then it subtracts X
05:30 : 1 and X 2 again that's true it did that
05:34 : and the first value the first result
05:38 : goes into sub time 1 and the second one
05:41 : goes into sub temp 2 and then we're
05:43 : going to multiply them together that's
05:46 : that's correct they goes into mall temp
05:49 : and then we're gonna do two subtractions
05:52 : again this time y1 and y2 that's correct
05:57 : and then we're gonna take those two
05:59 : results and multiply them together
06:00 : that's right and then finally we act
06:03 : together the result of that Plus that so
06:06 : the two multiple results of the two
06:08 : multiplications get added together so
06:11 : that looks correct to me and that is
06:15 : very cool
06:18 : so if you define a bar function which in
06:23 : turn calls a fool and a bar function its
06:27 : recursive okay sure
06:32 : I'm just gonna copy this chunk see what
06:36 : it does unknown function reference the
06:41 : foo I think it's the foo function that
06:44 : is on that note that this function would
06:49 : took a long time to execute if you call
06:51 : it in the future we'll add condition
06:54 : control flow to actually make
06:56 : recurrently useful we could define foo
06:59 : and then that would work so let's define
07:02 : foo did he define fool oh the he he
07:05 : defined food as this so let's define foo
07:09 : and then now we can define the other
07:12 : thing this the bar okay yeah that works
07:18 : so the bar it's gonna call there's this
07:22 : call instruction in hello VMI are we're
07:26 : calling foo with the double that's
07:32 : coming from this person a parameter
07:35 : apparently parameters prefixed with a %
07:40 : in this language and then this is a
07:44 : constant of four okay so this stuff
07:49 : looks like it works we also have an
07:51 : extern so I'm saying oh I don't know X
07:54 : turn okay sine X is the next time and
08:00 : then it declares that it just declares
08:03 : it when you do an extern okay
08:11 : and if you after you declare it as an
08:15 : extern you call it then it ends up being
08:20 : a call to that function
08:21 : okay what did I I did sign so 1.4 1.5
08:28 : yep you know to being a call to that
08:31 : function great yeah
08:36 : some other examples so this is all of
08:39 : the examples that he showed when you
08:42 : quit the current demo by control dealing
08:45 : or whatever it dumps out the IR for the
08:48 : entire module generated here you can see
08:50 : the big picture I don't think I have the
08:52 : line of code that does that but whatever
08:55 : but he's saying that in there too they
09:00 : have this line here that dumps all the
09:04 : code for the module let's put that in
09:07 : ours okay we compile the code who just
09:14 : killed my terminal for some reason I did
09:17 : not mean to do that
09:26 : LLVM first plane okay let's rebuild the
09:31 : sky with this extra line that prints out
09:34 : the contents of the whole module and
09:38 : perhaps we will do something like
09:58 : okay it compiled run it I'll do an
10:03 : extern maybe I'll define a function add
10:06 : that had X&Y together
10:10 : sure and now I X out of the program then
10:14 : it prints all of the code at the end
10:18 : okay great so this is very cool very
10:25 : exciting stuff I I definitely feel like
10:27 : I have a handle on how to work with LLVM
10:31 : I'm gonna cut this video here and in the
10:36 : next one we're gonna move on to the next
10:39 : chapter which is about adding JIT and
10:42 : optimizer support