LLVM Tutorial #24: Unary 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 code for the custom binary operators, this time we'll try to finish up the custom unary operators.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : hey there welcome back to the series
00:02 : where
00:03 : uh this where we walk through the llvm
00:06 : tutorial that is on
00:08 : llvm.org uh this tutorial is the c
00:11 : plus plus tutorial the one called
00:15 : my first language front end with llvm
00:19 : thus far we've made it through five
00:22 : chapters
00:22 : and a half we're going to continue on
00:24 : with chapter
00:25 : six implementing the
00:28 : parser and the generator the code
00:31 : generator
00:32 : for last time we did the binary
00:35 : operators
00:36 : and this time we're going to finish off
00:38 : with the ordinary operators
00:42 : so
00:45 : excuse me um
00:48 : so a bit of trickery
00:52 : that needs to happen here
00:56 : is previously uh when we're parsing
01:00 : a binary operator
01:03 : like this we call this function called
01:06 : parse primary
01:08 : i'll call that pp we call it parts
01:11 : primary
01:12 : to to eat off this one so
01:16 : when the when the token cursor is here
01:19 : we call
01:20 : parse primary and it'll parse this one
01:24 : uh stick it in well i don't know where
01:29 : it it it remembers the one somewhere
01:32 : and then it advances the cursor here
01:36 : and then it'll i believe peel off
01:41 : let me see it peels off the token and
01:45 : then
01:45 : yeah and then it it it'll
01:49 : peel off this uh operator token
01:53 : and then advance the cursor here and
01:56 : call
01:57 : primary parse primary again to get this
02:00 : two
02:01 : and then once it has both the one and
02:03 : two it'll combine them together
02:05 : to make this addition node right
02:09 : so previously that's what we had but now
02:13 : with the addition of unreal operators
02:15 : which
02:16 : previously did not exist we could have a
02:19 : situation where it's like this
02:23 : one plus not of two
02:27 : and also keep in mind we could also have
02:30 : one plus not not of two you could have
02:34 : multiple unreal operators
02:36 : stacked up like this so
02:39 : instead of calling the parse primary
02:42 : we're going to actually replace those
02:45 : calls with
02:46 : parse henry just in case
02:50 : that there could be an unreal operator
02:52 : associated with
02:54 : with this expression for example and and
02:57 : even for this expression we're going to
02:58 : call
02:59 : parse honorary to parse it just in case
03:02 : because we can't know
03:04 : whether this guy has some other
03:07 : operators on top of it so so basically
03:10 : when the cursor is here we're going to
03:12 : call
03:13 : parse henry to parse this guy
03:17 : and parse unrate will know to defer to
03:20 : pars primary
03:21 : so pars henry will defer to parts
03:24 : primary
03:25 : when it no longer has any unreal
03:27 : operators
03:28 : in front of it when the parse henry has
03:30 : peeled off
03:32 : of the unreal operators
03:35 : and then so and then the parse binary
03:39 : bit would take
03:40 : that bit and then move over and then
03:42 : again the
03:43 : parse henry will take that but since
03:46 : this guy has two unreal operators the
03:50 : first call to it will peel off one of
03:52 : them
03:55 : move this cursor over here and call
03:58 : another one of them
04:00 : move the cursor over here and then call
04:03 : parse primary because because there's
04:06 : two unreal operators here
04:09 : i hope that made sense uh let's let's
04:12 : try to code this
04:16 : um
04:19 : so i was in the middle of yeah
04:22 : writing this parse honorary
04:26 : function
04:29 : and this is the one that's going to peel
04:31 : off
04:32 : honorary operators as long as they exist
04:41 : and the first thing is it does a check
04:44 : to see it to make sure
04:47 : that to see whether the current token
04:50 : is actually an operator and that
04:53 : is told by this
04:56 : ask is ascii oh and if it's not
05:00 : a parenthesis or a
05:03 : comma okay
05:08 : this looks a little hairy
05:11 : but because this language is still
05:14 : relatively small
05:17 : we can still afford to do things like
05:22 : this
05:27 : okay so that's the case where we're not
05:30 : looking at a uh
05:33 : so that would be the case where you just
05:35 : have a
05:36 : naked naked
05:39 : number i believe so it's not
05:44 : uh oh i see if it is a
05:48 : open parenthesis or there's a comma
05:51 : we're gonna
05:51 : call parse primary to do it um
05:55 : but if it is an ascii
05:59 : if the current token is an ascii then
06:01 : we're not gonna do this
06:03 : we're gonna do the rest of it
06:09 : because that means that an operator
06:15 : so the current token is going to be the
06:17 : actual operator
06:20 : opc why do we call it opc
06:23 : we're going to advance the token by
06:25 : saying get
06:26 : next token
06:54 : okay we're going to create a new unreal
06:57 : expression
06:58 : node move the operand
07:02 : the operand is going to be the result of
07:07 : well of part another call to parse
07:10 : unreal so this car's under is actually
07:12 : recursive
07:14 : and that that's to to to handle the case
07:17 : where you have
07:18 : multiple honorees in front of you can
07:21 : have any number of
07:23 : these exclamation points in front of a
07:25 : value
07:27 : so that's what the recursion is doing
07:29 : for you
07:31 : and then if this doesn't work we're
07:33 : going to return a null pointer
07:35 : to signal failure here and then
07:40 : basically all the places where we called
07:42 : parse primary
07:47 : we're gonna switch it to be parse
07:56 : binary
08:01 : those are all the places okay great
08:05 : um with these two simple changes which
08:10 : we made
08:11 : we're now able to parse only operators
08:14 : and build the ast for them next up we'll
08:16 : need to add
08:18 : parser support for prototypes to parse
08:21 : the unread
08:22 : operator oh oh i see
08:27 : i already did this i thought they forgot
08:30 : about this
08:32 : in the previous episode i i didn't
08:34 : realize they were
08:35 : first doing binary and then doing andre
08:38 : so i just
08:38 : went ahead and added this code here
08:43 : um here is saying as with so i already
08:46 : did this
08:46 : as with binary operators we name unreal
08:49 : operators
08:50 : with a name that includes the operator
08:55 : character so unreal and then the
08:58 : character um
09:01 : okay now we're gonna write the code gen
09:03 : for the honorary
09:05 : expression ast
09:10 : let's find the class okay let's write
09:12 : the cogen
09:13 : for it
09:21 : okay
09:32 : okay so we're gonna coach on the operand
09:38 : and if that didn't work
09:41 : we're gonna return a null pointer
09:46 : and then we're gonna look up the
09:48 : function just like
09:50 : what we did with the binary
09:53 : operator
10:02 : so again if if if the um if we
10:06 : the operator is exclamation point and
10:10 : it's an
10:10 : honorary operator then we're gonna have
10:14 : a function
10:15 : with that name and so we're creating
10:18 : this name here and then using that name
10:21 : to
10:22 : look up a function um
10:25 : and i think if it's not there already
10:28 : well it needs to
10:29 : have been registered yeah but i think
10:31 : then once you call the function it'll
10:34 : dynamically generate the ast node
10:37 : in llvm on the fly
10:41 : when you call this get function function
10:45 : you can look at it
10:48 : yeah it costs the let me see
10:52 : [Music]
10:56 : just saying if it already exists then
10:58 : just
10:59 : return it but otherwise
11:02 : we're gonna find a function proto which
11:05 : is our ast representation
11:11 : and then cogen this yeah we're going to
11:14 : code gen
11:16 : and then
11:20 : and then return it
11:23 : i think coaching will register it inside
11:26 : the module
11:27 : if i'm not mistaken but that's how it
11:30 : works
11:31 : i just wanted to show you that
11:38 : okay so now we have this guy and if it
11:41 : didn't work
11:43 : we're gonna log an error
11:52 : otherwise we're gonna create a call
11:56 : to this function that we found
12:01 : and this is just a name
12:05 : we're using here okay i think this it's
12:08 : done the code is done
12:10 : well not if it has errors in it
12:13 : then it wouldn't be done but
12:24 : it does have errors in it um
12:28 : okay let's fix some errors
12:33 : let's see here uh this
12:36 : is saying member initializer op code
12:40 : does not have
12:42 : does not name a non-static member
12:46 : or base class
12:49 : oh app code a cased it differently
13:07 : okay uh uh case that one
13:11 : wrong
13:14 : i'm kind of wondering which one is the
13:16 : right one
13:19 : okay
13:23 : let's go to this one nine two fifty four
13:30 : there's one it doesn't like this one
13:32 : just a build it is this builder
13:35 : not built and then let's go to this one
13:38 : 751
13:41 : is saying i don't know about this thing
13:44 : called
13:44 : parse honoring okay
13:48 : i'm just gonna move this the order of
13:50 : the definition so if i move it above it
13:53 : then it'll work i could also have
13:56 : done a um
14:00 : what is this called i could have moved
14:03 : the signature of the function way up but
14:06 : in this case i'm
14:07 : i think i'm just gonna switch the order
14:10 : so that part honorary is defined before
14:12 : it's actually referenced
14:16 : that should solve that
14:19 : problem and then
14:23 : i misspelled std
14:34 : [Music]
14:37 : here 8 29.
14:41 : it's fn not fun name
14:44 : okay
14:52 : okay you're close 847
14:57 : or are we
15:00 : this is just called log error
15:14 : we have more errors
15:20 : this looks kind of cryptic um no
15:23 : matching constructor
15:27 : for initialization of prototype
15:31 : ast
15:38 : and it's pointing to a line of code that
15:40 : i don't recognize
15:42 : this is in this memory library
15:47 : oh but there's code that i do there is
15:49 : my code
15:50 : here in the instantiation of this
15:53 : function
15:53 : template specialization so this is
15:57 : on line 9 11.
16:00 : excuse me let me go close the door
16:15 : sorry about that okay so it's on this
16:20 : line
16:23 : i didn't change this line of code
16:27 : that's interesting i wonder what
16:29 : triggered this
16:32 : problem it could be because i mod made a
16:35 : modification
16:36 : to prototype ast
16:48 : oh
16:50 : it requires four arguments per the two
16:52 : were provided oh i see
16:56 : uh yes yes yes yes
16:59 : yes so this guy we're making
17:03 : we're instantiating a prototype a ast
17:08 : let me split screen here but we added
17:11 : two more arguments to its constructor i
17:15 : think that's what
17:16 : happened
17:19 : and there is operator and presidents
17:23 : so we could
17:26 : make a constructor that doesn't have
17:29 : those two things
17:31 : or we could just pass in the
17:35 : like test this and as false
17:38 : and zero that will probably
17:41 : do it
17:54 : yes that worked
17:59 : i wonder what they did in the
18:02 : in their code listing so i'm gonna
18:06 : search for
18:09 : this um
18:15 : they didn't change this which suggests
18:18 : to me
18:20 : they probably had a second constructor
18:23 : that just does has two parameters
18:27 : so i think i'm gonna do that
18:30 : here with make sense
18:35 : so this is gonna be a constructor
18:38 : overload
18:39 : i believe
18:45 : and i'm going to get rid of these two
18:49 : arguments or parameters
19:03 : all right let's see if that this
19:08 : compiles
19:22 : um
19:25 : it does all right let's try to run this
19:28 : all right what can you do here i can
19:30 : define a custom
19:36 : operator
19:39 : what like i guess i can define
19:45 : um
19:49 : dn operator so
19:52 : define a binary operator
19:55 : n with precedence of
19:59 : 40 maybe and then it takes a
20:03 : x and a y
20:10 : expected function name
20:14 : oh we have a sig fault and we also have
20:18 : unknown unreal operator
20:22 : ouch
20:25 : let me try to do it all in one line
20:34 : i'm just gonna return x
20:38 : plus y plus y maybe
20:43 : dang it okay we have a problem
20:48 : we might have to do some debugging oh my
20:50 : god
20:51 : this mandelbrot set is super awesome
20:55 : um okay so print
21:00 : density
21:06 : okay it's i'm gonna read this it is
21:09 : somewhat hard to believe but with a few
21:12 : simple extensions we've covered in the
21:14 : last chapters we have grown a real-ish
21:16 : language with this we can do a lot of
21:19 : interesting things
21:20 : including io math and a bunch of other
21:22 : things for example we can now
21:24 : add a nice sequencing operator
21:29 : um so print d
21:33 : is defined to print out the specified
21:36 : value in the new line
21:39 : print the okay we're using
21:42 : print d we're gonna
21:45 : oh we're gonna define the colon
21:51 : oh i see well
21:55 : let's see if this works i guess
21:58 : i have a feeling i'm gonna need to have
22:01 : a separate session debugging this
22:04 : um okay
22:08 : now i'm gonna define a binary operator
22:11 : like this
22:13 : no okay all right ouch okay
22:17 : so i'm gonna need to have a separate
22:19 : debugging session
22:21 : uh right after this session so
22:25 : if you're interested in seeing me
22:27 : struggle through this
22:28 : then then i will meet you over there