LLVM Tutorial #23: Codegen for Binary Operators

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 updated the parser for binary operators to support custom operators. This time we'll work on the code generator part.

Transcript

The following transcript was automatically generated by an algorithm.

00:01 : hello welcome back to the series where
00:04 : we uh build our first llvm language
00:08 : front end
00:08 : uh this is a tutorial walkthrough
00:11 : of the of this tutorial
00:15 : that is found on llvm.org
00:19 : um and there are two versions of the
00:22 : tutorial the old camel version and the c
00:24 : plus version we're doing the c plus
00:26 : version
00:27 : uh in this series so far we've gone
00:31 : through five full chapters and then
00:34 : a little bit of the sixth chapter we're
00:37 : gonna continue on with the
00:39 : sixth chapter uh last time we
00:44 : implemented the parser
00:45 : for the custom operators
00:48 : uh and this time we're gonna implement
00:50 : the code generation for that
00:52 : so let's do that
00:58 : okay so we're going to find this
01:01 : binary expression ast
01:04 : class which that means
01:11 : that means there's a binary expression
01:14 : in the code
01:15 : such as one plus two and now
01:18 : since we're allowing custom operators
01:21 : it can actually allow us to do like one
01:25 : add sign to and we can define the add
01:27 : sign to do whatever
01:29 : the heck we want just like a function
01:31 : can
01:32 : right so we're gonna change
01:35 : the code generator for the binary
01:39 : expression
01:40 : to be able to relate to the
01:44 : defined code for that custom
01:49 : operator code
01:53 : um yeah
01:57 : so let's see how we're going to do that
01:59 : um
02:00 : so so far we have code that looks like
02:03 : this we're first gonna
02:05 : generate the llvm code for the left hand
02:08 : side
02:09 : and then do the same for the right hand
02:10 : side we're going to then
02:12 : combine it with one of these operations
02:16 : add subtract multiply
02:20 : do we even have divide we don't have
02:24 : divide implemented actually
02:28 : and actually we we only have less than
02:32 : implemented not greater than
02:36 : and that's interesting but the case that
02:40 : we're going to add
02:43 : is this one if it wasn't a built-in
02:45 : binary operator
02:46 : it must be a user-defined one emit a
02:50 : call to it so
02:54 : how are we going to do that uh oh we're
02:56 : not going to
02:58 : error out if we don't find it
03:02 : actually so let me see
03:06 : um i see we're gonna
03:09 : call this get function function which
03:12 : we previously wrote to find a function
03:15 : object by the name of the function
03:20 : um okay oh
03:23 : these all four of these guys already
03:25 : return
03:26 : that's why
03:30 : i feel that it's better
03:33 : form to write this code inside this
03:36 : default
03:37 : case that's just my prefer
03:40 : so to to keep consistent this to this
03:43 : pattern of returning
03:46 : within the switch statement although i
03:49 : can see the argument the other way as
03:51 : well
03:53 : that we're trying to not sort of
03:56 : make this switch statement too bulky i
03:59 : think that's what he was going for
04:01 : okay i'll follow his i'll follow his
04:07 : method
04:12 : okay
04:17 : so the standard string
04:24 : the up is the operator
04:28 : okay i see if we have a
04:33 : function defined
04:36 : for a binary operator then it would
04:40 : start with the word binary so like if we
04:43 : define
04:44 : a custom if we define
04:48 : the at operator its name would be that
04:53 : so this op would be the add operator
04:56 : we're gonna
04:57 : concatenate it with the prefix binary
05:01 : and that would be the name of that
05:03 : function
05:04 : in our system so that's what we're doing
05:08 : um we have
05:11 : a little assert to make sure that
05:16 : function is found if it's not
05:19 : found it
05:22 : looks like it's just gonna error out
05:25 : it's interesting that we're using a new
05:27 : method of
05:28 : reporting errors instead of returning at
05:32 : no
05:32 : point or um that's probably just due to
05:36 : laziness
05:40 : okay so these are the
05:44 : operands i believe oh the
05:47 : oh the operands that go into the llvm
05:51 : um builder call so then we're going to
05:54 : use the builder to
05:56 : go to create call
05:59 : with this function object and they ah
06:02 : this
06:02 : this ops the operators
06:06 : and this is going to be a bin up
06:10 : i guess this is just a name i think this
06:12 : bin knob is just a name
06:14 : okay so we did binary
06:17 : expressions but i we also need to do
06:20 : other operations i think
06:26 : or not
06:30 : the final piece of code we're missing is
06:32 : a bit of top
06:34 : level magic beautiful
06:37 : i love top level magic
06:40 : uh where is this now
06:46 : function ast
06:50 : code gen again
06:54 : uh transfer
06:58 : ownership of the prototype to the
07:01 : function
07:02 : protos map
07:05 : but keep a reference to it for use below
07:14 : did we do that previously
07:17 : yes we did do that previously
07:21 : [Music]
07:27 : i might have like changed it a little
07:30 : bit
07:30 : from what they have here um
07:36 : so let me let me try to understand what
07:39 : has changed
07:41 : right now um
07:45 : so this is just to get the name so that
07:48 : we can call get function to find the
07:51 : function
07:52 : uh oh if it's a binary operator
07:58 : install it oh i see i need to add this
08:02 : little bit of code
08:08 : function cannot be redefined
08:11 : okay so if
08:19 : p whatever p
08:22 : is oh i need to
08:27 : use this weirdness
08:32 : just so that i can access p i see
08:37 : okay if it's a binary operator we're
08:39 : gonna need to
08:42 : oh by install it i think it means
08:46 : set up its binary precedence in this
08:50 : in this hash in this bin
08:53 : our president's hash
09:02 : oh shoot
09:12 : i decided to deviate from the way they
09:15 : do it
09:17 : so i actually do not have this binary
09:19 : hatch because i
09:20 : decided to implement
09:24 : inheritance not inheritance precedence
09:28 : using a switch statement instead of a
09:31 : hash map
09:32 : so i'm going to change it to use a hash
09:35 : map then
09:36 : i guess so if we had
09:40 : all right
09:44 : you can you refer to the
09:48 : you can refer to the code listing at the
09:51 : bottom
09:52 : um but i i'm gonna try to do it myself
09:56 : just as an exercise so i believe
09:59 : this is a global variable and it's
10:01 : probably static
10:04 : and it's i believe this is going to be a
10:07 : standard map
10:10 : that maps a
10:14 : map something to an unsigned number
10:18 : and that something is a
10:22 : character probably
10:26 : it maps a char to an unsigned because
10:29 : get operator names whatever get operator
10:33 : name is yeah it's a char
10:36 : so it maps a char
10:40 : which represents the operator to an
10:42 : unsigned number which
10:43 : is an unsigned number that represents
10:46 : the president's
10:48 : and we're gonna set it up
10:51 : can i just like do
10:55 : standard map
11:04 : like that i hope
11:07 : and then i i already included map
11:11 : okay i hope this works and then i'm
11:13 : gonna need to
11:14 : change the president's logic
11:19 : to look up this map instead
11:24 : here instead of using this switch
11:26 : statement i'm gonna do
11:33 : card talk
11:37 : [Music]
11:38 : unsigned press
11:44 : and then i guess if
11:49 : i don't know what would happen if this
11:51 : lookup failed
11:53 : uh in my past experience i have had
11:57 : situations where if this fails really
12:00 : really bad things can happen
12:02 : um i'm gonna look at their code listing
12:06 : to see how they did it
12:16 : okay so they did this
12:20 : oh you you don't actually have to assign
12:23 : to
12:24 : you don't have to assign to it it'll
12:26 : just get initialized
12:27 : i believe and then okay so this is how
12:31 : they did this
12:36 : okay
12:38 : okay so they have this little check
12:42 : if it's not ascii then return negative
12:45 : one
12:51 : and then oh
13:03 : i don't really know why that's necessary
13:06 : if it's
13:07 : unsigned it should not be signed
13:11 : but okay all right
13:15 : oh i use a different variable name than
13:18 : they did uh
13:21 : okay honestly i don't think that's
13:25 : necessary
13:25 : i'm gonna get rid of that if it's needed
13:29 : i
13:29 : may have to put it back later but i
13:32 : don't think it's needed
13:33 : okay uh
13:36 : all right go back to the main flow
13:40 : of the of the of the tutorial now
13:46 : let's see did we
13:49 : parse
14:00 : this code
14:04 : no okay we were here
14:08 : this is the code gen for binary
14:10 : expression
14:11 : we did that we were working on this
14:14 : okay
14:20 : okay we're working on this and
14:25 : wait is that right yeah okay
14:29 : and then now we have this map which
14:32 : we're gonna add an entry to
14:35 : as we're generating the code for uh the
14:39 : function declarations
14:45 : and then one we're gonna have this code
14:49 : that creates the basic
14:50 : block for this function etc i don't
14:54 : think
14:54 : this code changes
14:58 : okay
15:03 : yeah we're registering the president in
15:06 : the president's table
15:09 : all right so that was binary operators
15:13 : that was binary operators next we're
15:15 : going to do other
15:17 : operators
15:20 : [Music]
15:22 : the other operators doesn't look very
15:24 : long
15:25 : so i'm just gonna do it hopefully
15:28 : it doesn't take too long okay
15:34 : we don't actually have an honorary
15:37 : expert ast yet
15:40 : okay let's add it
15:48 : i'm going to add it right after the
15:51 : binary one
16:21 : you
16:55 : okay anony expression has
16:58 : the character represents the operator
17:01 : symbol
17:02 : and then the operand which is a
17:06 : unique pointer to the expression node
17:08 : that represents the operand and this is
17:10 : just a
17:11 : constructor that allow the creator of
17:15 : this
17:15 : object to pass in those two pieces of
17:19 : information
17:20 : and again we're going to have to declare
17:23 : the code gen
17:25 : method as a override
17:30 : and then later override it um
17:33 : let's let's parse othery
17:37 : um let me think
17:40 : how do you know if it's unreal or a
17:42 : binary
17:44 : oh because we we're gonna
17:47 : we're gonna trojan horse it into the
17:50 : binary
17:51 : the parts binary up one
17:55 : that guy will have to figure out whether
17:57 : it's an unreal or not
17:59 : okay that's interesting but let's do
18:04 : let's add a
18:10 : [Music]
18:12 : um
18:17 : i'm gonna define the
18:20 : parts
18:24 : i'm gonna define the parts on honorary
18:28 : function right above the parse
18:32 : binary up right hand side
18:35 : one left hand side or right hand side oh
18:39 : i think
18:42 : this is saying
19:08 : i'm trying to understand this scheme
19:12 : he's saying previously
19:15 : we have this parse primary
19:20 : um we're gonna replace this call
19:23 : to parse primary
19:27 : this is parse right hand side by the way
19:30 : so
19:32 : um so this is like saying
19:35 : we're parsing this code that looks like
19:38 : this and
19:42 : this parse expression is trying to parse
19:44 : this whole thing
19:47 : and but it's gonna first parse
19:50 : primary and parse primary is gonna parse
19:54 : just this part so it's gonna advance
19:56 : this pointer
19:58 : to over here and then once the pointer
20:00 : is looking at the plus symbol we're
20:03 : gonna call
20:04 : parse binary operation
20:07 : right hand side as as in right hand side
20:10 : as in this guy this is it that's the
20:12 : right hand side but i believe
20:15 : it also it this this symbol
20:19 : this plus symbol is still there
20:22 : where the cursor is pointing to because
20:25 : this is getting the token precedence
20:28 : and that can only work when we're still
20:30 : pointing to this plus symbol
20:32 : so anyway it's kind of saying
20:38 : um the place where
20:41 : it was calling pars primary
20:45 : we're gonna not do that anymore we're
20:48 : going to call
20:49 : parse honoree
20:55 : because you could interpret this plus
20:58 : symbol as an honorary
21:02 : operator at this point and that's a
21:06 : weird way of looking at it
21:09 : um and then
21:16 : oh and then this is guys
21:19 : so parse unary is gonna either defer to
21:23 : parse primary
21:24 : if it determines that the current token
21:27 : is not an operator
21:29 : or if it is an operator then it's gonna
21:37 : eat that symbol
21:41 : and then parse unreal again
21:56 : this is actually more complicated than i
21:58 : thought okay
22:00 : um okay
22:04 : so since this is a little more
22:06 : complicated than i
22:07 : thought i'm gonna stop this video here
22:10 : and it will complete
22:11 : this part in the next one i'll see you
22:14 : there