dabeaz's Compilers Course And X86 Registers

In this video I tell Huiqi about David Beazley's "Write a Compiler" course and X86 registers.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : i'll first give you a very short recap
00:03 : of
00:03 : my the course that i took last week
00:06 : so okay so uh basically
00:10 : um i told you about the course it was um
00:13 : david beasley's compilers course
00:16 : david beasley is like a pretty famous
00:21 : member of the python community he's very
00:24 : well known there
00:25 : and it was actually from from one of his
00:29 : articles
00:30 : i learned about generators and and
00:33 : and that's how i know generators uh
00:37 : but anyway but anyway what is
00:40 : generating what is generators um
00:44 : javascript actually has generators now
00:46 : it's
00:47 : actually quite similar to async await so
00:50 : you know async await uh async away is
00:55 : uh is actually stolen
00:59 : it is a concept that was stolen from
01:01 : generators
01:02 : in fact whereas async away is meant to
01:07 : well the way that async await works is
01:09 : like
01:11 : you just you're just gonna pause there
01:12 : until this asynchronous thing comes back
01:15 : and then you keep you keep going uh
01:18 : generator
01:20 : can do that multiple times
01:23 : you can pause
01:26 : and then wait for the thing to come back
01:28 : and then pause again wait for the thing
01:30 : to come back
01:30 : and pause again wait for the thing to
01:32 : come back uh it it
01:33 : a generator can generate a series of
01:36 : values
01:37 : uh and you can yeah
01:40 : it's a pretty cool concept um
01:44 : it's it's used uh it it's a good fit for
01:49 : some for the tokenizing phase of a
01:52 : compiler and we did use that in the
01:55 : course for that uh but anyway
01:58 : so the course um i think overall
02:02 : it was very good for me um
02:06 : for some of the students thought like it
02:09 : was a little
02:10 : too fast for them and they would have
02:12 : they would have like
02:14 : like more time to work on their project
02:17 : instead of getting it cramped
02:18 : into like five days um and
02:22 : it was okay for me because like i've
02:25 : already
02:26 : sort of i'm already experienced with
02:30 : a lot of those concepts uh one thing i
02:34 : did that was deviating from the rest of
02:37 : the class
02:38 : is i wanted to generate
02:41 : uh direct assembly code
02:45 : instead of using llvm uh remember we
02:48 : talked about llvm
02:50 : which is like a layer in between
02:54 : sort of the compiler and the actual
02:56 : machine code
02:57 : i wanted to go one layer lower than that
03:01 : and and generate the assembly code
03:03 : directly
03:04 : uh and dealing with registers and stuff
03:07 : like that
03:08 : and i was able to i was able to do that
03:11 : to
03:11 : an extent i haven't solved i i went up
03:15 : to the point where
03:17 : so your cpu has a fixed number of
03:20 : registers
03:22 : that that are in the cpu like a register
03:25 : is like a small
03:26 : like a memory location inside the cpu
03:29 : that holds uh that holds
03:33 : 64 bits of information for for for
03:36 : 64-bit
03:37 : architectures each register holds 64
03:41 : bits of information
03:43 : and if if you had an older cpu that was
03:46 : a 32-bit architecture
03:48 : then a register would only hold 32 bits
03:50 : of information
03:53 : um and your cpu has a fixed number of
03:56 : those
03:57 : and and basically i took the simplestic
04:01 : strategy of
04:03 : uh every variable i have in my program
04:07 : i'm going to assign it to a register
04:10 : okay okay and our programming language
04:13 : was very simple so it
04:14 : didn't have strings it it it just had
04:18 : numbers uh floating point numbers
04:21 : integers and characters and a character
04:24 : as we discussed in the unicode episode
04:27 : uh a character can be represented by
04:30 : a number right so it's still a number
04:34 : in reality so so so all three of those
04:37 : things
04:37 : can be represented as a 64-bit number
04:42 : so i just said uh i'm just gonna say
04:46 : any variable you define in the program
04:48 : i'm gonna
04:49 : assign that to a register and
04:53 : and and i register uh i can i can choose
04:57 : so this is the page for david beasley's
04:59 : courses and
05:00 : the one i took was write a compiler
05:04 : i do overall i do recommend this
05:08 : course for
05:11 : i would say for seasoned developers
05:14 : who uh uh
05:18 : you should be good at debugging if you
05:20 : want to take this course
05:22 : there will be a lot of debugging um how
05:25 : much
05:25 : is it it costs like a thousand and two
05:28 : hundred
05:29 : dollars i believe okay
05:35 : well i i don't think i can do it any
05:37 : times no
05:38 : but if it's like a little bit later
05:42 : okay no at least
05:46 : yeah sure sure maybe like a little bit
05:49 : later
05:50 : but i think this probably sounds really
05:52 : good nice
05:54 : nice yeah um
05:57 : and yeah if you want to take it at like
06:00 : a slower pace
06:01 : then you could can also consider
06:05 : learning compilers with my guidance but
06:08 : then
06:08 : it it would still take a lot of work
06:12 : either either either way it's gonna take
06:14 : a lot of work
06:15 : on your part gotcha
06:18 : yeah because because it compilers is a
06:21 : lot of
06:22 : stuff a compiler is just a lot of stuff
06:24 : there's no getting around the a lot of
06:26 : work
06:27 : um okay
06:31 : yeah yes cramming it into five days is a
06:34 : little much
06:36 : um i think but um
06:39 : yeah but
06:42 : it depends on what you want like i think
06:45 : if you starting out with
06:47 : absolutely no knowledge about compilers
06:50 : and you want to be able to
06:53 : be you you want to be able to
06:57 : sort of build your own programming
06:59 : language at the end of the course that
07:02 : might not be
07:02 : totally realistic but you have the
07:05 : beginnings
07:06 : of that knowledge and then you need to
07:08 : go
07:09 : further on your own after that
07:12 : um okay so
07:16 : what did i wanted to show you oh yeah
07:19 : my oh one thing i do want to say is that
07:22 : i throughout this course because the the
07:25 : course uses python
07:27 : uh throughout this course i've been
07:28 : using my debugger to debug my problems
07:32 : and and it has been extremely helpful
07:35 : and and there are
07:36 : bugs in the debugger um that i
07:39 : encountered
07:40 : and there are times when the debugger
07:43 : like
07:43 : we were hitting the limits of what the
07:45 : debugger could do because
07:46 : of the bugs in the debugger but despite
07:49 : that
07:50 : it has been helpful more often than not
07:54 : and and and like as a result of that
07:57 : i had to do very very little print based
08:01 : debugging
08:02 : nice yeah it's just like very like you
08:05 : will not see
08:06 : many print statements littered through
08:08 : my code at all
08:09 : because i just didn't do that all that
08:11 : often because of this debugger
08:15 : yeah it was actually really amazing
08:18 : feeling
08:18 : to to get this kind of experience using
08:21 : this debugger
08:23 : like that often for the first time
08:26 : um anyway what was i going to show you
08:28 : oh i was going to show you my registers
08:31 : so these are the examples of the
08:34 : registers
08:35 : that are in an intel chip okay and they
08:38 : have specific
08:39 : they have very specific but cryptic
08:42 : names
08:42 : that you probably will not able to
08:44 : memorize
08:46 : unless you looked at it a lot so ebx
08:50 : and each register has different names
08:53 : different aliases
08:55 : for if you were because the register is
08:58 : like like there's another name for this
09:01 : which is rbx and then there's
09:05 : ebx and then there's bl
09:09 : all three of these are referring to the
09:11 : same register
09:13 : except that the rbx is the 64-bit
09:17 : version of that and the ebx is the
09:19 : 32-bit version
09:21 : which means if you use ebx it's only
09:24 : going to use
09:24 : half of the register it's going to
09:27 : ignore the other half
09:28 : and and bl is only going to be
09:31 : like the eight bytes or eight bits
09:35 : of the register so you're using even
09:37 : less of the register
09:38 : if you write bl
09:41 : um so so i'm in my case i'm only using
09:46 : 32-bit and 8-bit so i'm ignoring the
09:50 : 42-bit version and the 16-bit version
09:53 : i'm only using the 32-bit and the 8-bit
09:55 : uh so i've made my registers like this
09:59 : they have the long name and the short
10:01 : name and then
10:03 : and then when i have variables in my
10:05 : program
10:07 : like oh i don't know
10:11 : like this is a program in this
10:14 : programming language that we use in the
10:16 : course
10:16 : it it's called wabit so if i
10:19 : if i have a variable or oh not cons cons
10:22 : i don't use registers but a variable
10:25 : like this this is
10:26 : x it's a float then i'm gonna i'm gonna
10:29 : allocate this variable
10:31 : to a register in in my list of registers
10:35 : and also for floating point numbers you
10:38 : have to use these
10:39 : special registers for floating point
10:41 : numbers
10:43 : and then there are actually not these
10:46 : these are invalid
10:47 : there's only like eight
10:50 : there's only eight of them and also i'm
10:53 : skipping
10:54 : the zeroth one because the zeroth one
10:56 : has a special use
10:58 : so i didn't want to collaborate the
11:00 : special use
11:01 : so i'm gonna say these are my general
11:03 : purpose ones that i can use for
11:05 : variables
11:07 : i want to assign to which variable
11:11 : like say you have that variable right
11:13 : which one does it go
11:15 : yeah oh i i put basically i put it in a
11:18 : list
11:19 : and it's a first come first serve it's
11:21 : like a queue
11:24 : exactly then then i'm in trouble so and
11:27 : i i
11:28 : i haven't gotten to that part yet
11:30 : basically but but uh
11:31 : normally what but basically i went i i
11:34 : implemented all of this the assign
11:36 : variables to register
11:38 : until i try to run this program oh not
11:41 : this one but a similar one
11:43 : that uh there's another
11:48 : it's this one and then i tried to run
11:49 : this program and i ran out of registers
11:52 : when i tried to
11:53 : i tried to allocate another register
11:55 : it's like no no more registers
11:57 : sorry and correct with the reg
12:01 : like how do you interact with the cpu
12:04 : like what is
12:05 : that they have an api like does
12:07 : powerpoint have
12:08 : if not no okay
12:11 : so what i did was um i
12:14 : i'm using a assembler
12:17 : which which is a thing that converts
12:20 : assembly language
12:21 : to compile binary code
12:25 : so um and i
12:28 : i just run
12:32 : i run my compiler to compile
12:37 : say
12:40 : this script
12:47 : okay so what it did was it created this
12:50 : dot
12:50 : asm file which is a is which is code in
12:54 : assembly language uh it's like a
12:58 : slightly more it's a more humanly
13:00 : readable
13:02 : version of assembly language that i can
13:04 : still read and debug
13:06 : and then i use the assembler to compile
13:09 : the asm file to a bin file which is a
13:11 : binary
13:13 : code that the machine can actually
13:16 : execute
13:17 : so you run the bin file and it executes
13:20 : the program
13:21 : outputs that but the asym file
13:24 : let's go take a look at that
13:31 : is here and it looks like this
13:36 : whoops so so
13:39 : to show you what's happening maybe just
13:41 : a little bit
13:42 : um
13:46 : oh is memory location like r
13:49 : whatever uh yeah so so
13:52 : yeah so this is on the left is the
13:54 : original program
13:55 : on the right is the assembly language
13:58 : program that represents the
14:02 : program on the left and yeah the first
14:04 : instruction is
14:06 : i'm going to move the value 97 which is
14:09 : the ascii code for the character a
14:13 : i'm going to move it into the register
14:15 : called r15b
14:18 : that that's a register in in your
14:21 : intel chip i'm going to do the same for
14:24 : b which is the code for that is 98. move
14:27 : it into the r14b
14:29 : register and then here here i'm
14:33 : doing a bunch of comparison because this
14:35 : particular test has to do with
14:38 : the greater than and less like comparing
14:41 : characters
14:43 : and and and so like a
14:46 : less than b should be true so i'm doing
14:49 : this
14:50 : comp operator or
14:53 : in comp instruction comparing the value
14:56 : of
14:56 : this register to the value of this
14:58 : register
15:00 : and and then when you do that it sets a
15:03 : bit
15:04 : in another in in another register which
15:07 : will tell you whether the comparison
15:10 : you know was greater than less than or
15:12 : equal
15:14 : and and then and then this set l it's
15:18 : now in if you it's super weird