studying compilers every day until i land a compiler role (day 199)

Ajouté : 2026-05-11

[00:00:01]And we're live. Um I don't know if I'm on time or late. I don't remember what time I set the stream, but I remembered it had a six in it. So, um yeah, we're just gonna we're just going to stream now. Um this is day 199 of studying compilers every day until I land a compiler roll. Um last time we continued doing the big rewrite. This time we're going to continue continuing doing the big rewrite. Um yeah, it's it's going to be a good time. So yeah. Uh what's good is earth? Good to see you.

[00:00:33]Um okay, get log. Let's see. We were we were making this new like 2 mir thing and it was going all right. I won't say it was going great, but it was going it was going passively. So we got a we got a lot of stuff to do here.

[00:00:50]Um let's see.

[00:00:54]I think we finished up the like function def and function prototype stuff for the most part. Am I regular? Yes, you you very definitively are. Um I gave you the role in Discord as well. So yeah.

[00:01:09]Um okay, let's see what is the best place to start here.

[00:01:15]Um hi, I'm also writing compiler. Nice.

[00:01:18]Well, welcome. Um hopefully hopefully this is like a little bit interesting then improving reel. Hell yeah. Yeah, reel is reel is hard. I I struggled a lot with it. I just my IR doesn't preserve enough information to do it very well. So we just have a really we have a questionable heristic, but like it's it's fine.

[00:01:45]Um, okay. Let's see.

[00:01:51]What do we even do here? I think we should So, maybe I should start with the experts or maybe I should have like a h maybe I should have a pass that like dugars and that like replaces the hir pass.

[00:02:09]That might actually make things easier now that I think about it. Um.

[00:02:14]Huh.

[00:02:17]Yeah, this is this is rough.

[00:02:21]Um h I think that would simplify a lot of the logic, but I guess the big the big thing I'm concerned about is generating like control flow. That scares me a lot and I don't I don't even know how I'd go about doing that.

[00:02:40]I guess it'd be no different than what we currently do, right? Like we just have to like manage more basic blocks at a time, which is like fine.

[00:02:50]So if we look at like HR to MR, if there's anything like interesting that we do, I think that might be difficult.

[00:03:05]H I guess we don't really do anything interesting with it then, huh? Um yeah, it's kind of just like one to one. We just we just make more of a mess. So I guess we could we could try that. Um let's start with exper because I think all the expressions will handle pretty similarly to what they did before.

[00:03:32]Um, where do we start with this?

[00:03:37]I guess yeah, we can kind of we can kind of yank some of this.

[00:03:45]So h so terminal expert we want to oh I guess we need to figure out like uh we want to figure out like scopes and stuff. Uh compiler it's called panic. Uh it should be it should be pinned on my uh on my GitHub which is in the description.

[00:04:14]Um h yeah this is this is annoying actually.

[00:04:24]This is really annoying.

[00:04:29]Um yeah we're we're in we're in some trouble here.

[00:04:46]Yeah. Okay. Maybe we should start with instructions and then that will that will help make things make sense. Um scope might be easy or at least it's supposed to be easy.

[00:04:58]Um Oh man.

[00:05:07]Okay. So then we want like Yeah, this is this is kind of awkward to reason about.

[00:05:17]What do we have in the header to work with? We have like this cur scope thing.

[00:05:23]Uh we also need to set that in the constructor. I just realized. So let's do that real quick.

[00:05:29]Give that cur scope is zero.

[00:05:37]Yeah. So that's good.

[00:05:42]Um H and then everything else I think we can leave default. So now if we go into scope.

[00:05:54]So we want curcope++ and then afterwards we want to decrement it.

[00:06:07]And then inside here I guess each I in S we want to get instructions and what type is this unique pointer to instruction. So, we want to then we want to visit that. I guess we can kind of just steal what we had before here for the most part. I think yeah, we can we can kind of just do that. Um, it looks like we it looks like we will make a new scope. So, I guess that makes sense. Um, yeah, we should we should do it like that.

[00:06:46]So, we want to accept this Yeah.

[00:06:59]So that's what we need this like scope mappings thing for and I think we will probably keep that as well. Um yeah because this resolves like variable names I think.

[00:07:15]So like the current alive variable I guess or the current shadowing variable.

[00:07:21]I don't really know what the like precise term is but we should we should track it like that. So we have cur scope and then we have like stood vector of stood ordered set of stood string.

[00:07:38]So we have scope mappings or I guess we should call it bindings.

[00:07:46]Binding is that is that the right term for this bootstrapping approach? Uh what do you mean?

[00:08:05]Yeah. Okay. So this should be scope bindings.

[00:08:10]That might be more precise. So, we'll call it that.

[00:08:19]So, I can do that. And then here we pop back.

[00:08:24]Okay. So, that's straightforward enough at least.

[00:08:29]Um, let's see.

[00:08:43]So, okay.

[00:08:50]So, an expert. This should be straightforward. I think somehow I think we I think we do something with it here.

[00:09:00]Right. Instruction expert. Where does this live?

[00:09:05]Okay. Yeah. So, we just we just accept that which makes sense.

[00:09:14]So, that seems straightforward enough.

[00:09:18]Um declaration we kind of have to make a little bit of glue code, but we we can do it a little bit differently.

[00:09:30]So we want So what do we want from this? Right. We want we want an allocate and yeah we want an allocate and we want to guess we should we should steal from this like declaration assign thing for the most part.

[00:09:53]Um, yeah, it doesn't look like we get rid of a temporary.

[00:10:01]I think that's what we do. Uh, what's a Vansu?

[00:10:08]Okay, well, we'll skip declaration for a second. Uh, return should be pretty simple, though, cuz that we just generate a little bit of boiler plate.

[00:10:17]So, we definitely want these two.

[00:10:24]Uh, and then we can get rid of this like last extra thing, right? Cuz we we just generate code and then let's see what do we do from here?

[00:10:42]Where's our return? There's our return.

[00:10:46]Yeah. So we do that and then we make an allocate of some sort.

[00:10:58]Wait, what?

[00:11:00]Oh, we make this ahead of time. I see.

[00:11:04]Okay. Yeah, that makes that makes sense.

[00:11:08]Um, so definition we also want Oh man. Okay, so there's like a rat allocate that we store. Yeah, maybe we could just make it here. Or I guess we wanted to dduplicate it, which is why we did it like this.

[00:11:29]Um, I don't know. Maybe we should maybe we should just like have duplicative returns then. That might be cleaner and then we can like we can like GBN it out.

[00:11:41]I guess [snorts] we'll we'll do it like this for now.

[00:11:47]We'll do it the way we did and then like we could think about maybe doing it a different way.

[00:11:53]Um yeah.

[00:12:01]So, let's make a retake. Or that's that's what we call it.

[00:12:10]When do we make that?

[00:12:17]I see. We do it up here. Okay.

[00:12:22]So, we do it at the top of a We do it at the top of the entry block. It looks like so we should h Yeah. What is the correct order to do this then?

[00:12:44]Um maybe we should do it before then and then Huh.

[00:13:00]Yeah, we definitely need to do that anyway because we need to put all the damn allocates somewhere.

[00:13:06]So that would that seems like something we need to do beforehand. Um h so then yeah, this is this is getting a little it's getting a little messy.

[00:13:29]Okay. So, we got So, we make the entry block and then that's also presumably where we will make this rat allocate thing.

[00:13:38]Yeah, we'll just we'll plaster this somewhere here.

[00:13:44]So we want we want middle and mirror instruction alloc star that's alloc.

[00:14:03]Yeah. So we make that and then in here we should Yeah. We will we will make this here.

[00:14:18]And this should this should go at the front of the list, I think. Right.

[00:14:22]Actually, we could just we could write this real quick. We don't need to do this. So, um, so let's make unique. Actually, can we just steal it from like here?

[00:14:45]Yeah, we can yank that.

[00:14:52]Uh, and then we need the function type here, right? So, we want type we can do that.

[00:15:10]Then we should also change the signature real quick.

[00:15:22]Yeah, we'll just do that.

[00:15:31]Okay, so we have that. We make the alloc and then we need to make the basic block.

[00:15:42]So we want entry block equals make unique uh we can get rid of some of this.

[00:15:56]So this should be MI basic block and then that's fine I think right um oh wait no we need to this constructor is annoying.

[00:16:16]Yeah.

[00:16:22]So what what did this constructor take again?

[00:16:33][clears throat] Oh, I see.

[00:16:45]Okay, let's So we can make a no point.

[00:16:48]We could like no pointer that, right?

[00:17:00]Oh, right. That's annoying, actually.

[00:17:02]Okay.

[00:17:04]On second thought, maybe we can't actually do that, huh?

[00:17:12]Well, crap.

[00:17:15]Um.

[00:17:20]H.

[00:17:24]have the type.

[00:17:28]Maybe we should make that after and then we should like we should make a list of all and that will that will fit in the entry block perhaps.

[00:17:39]Yeah, I like I like that idea more more I think about this.

[00:17:46]Yeah. So we want that and we give it type I think.

[00:17:50]Yeah.

[00:17:53]And then Yeah. And then we can figure out the terminator from there, I think.

[00:18:05]Yeah, we need a basic block buffer, which we have. So we can probably just put it in the front of that.

[00:18:12]Or you could make it point to next in there.

[00:18:17]Um we should also we should make the entry block and we should definitely we should make the return block as well I think.

[00:18:29]Uh hi from India. Welcome.

[00:18:38]H what am I doing here?

[00:18:41]Does like the return block always just get made at the top then? Is that Is that how I do it?

[00:18:51]Huh?

[00:18:58]Wow. I guess it just I guess that is just how it gets made.

[00:19:02]Um yeah, not returns like function.

[00:19:08]This is per function. So that makes that makes sense.

[00:19:13]Um okay. Okay. So, we should probably make an instruction buffer then of some sort, right? Do we have an instruction buffer in here?

[00:19:25]No, we don't. Okay, we need to do that.

[00:19:31]So, we can do that and then Okay, that that simplifies it actually.

[00:19:42]So then we don't need like we don't need that in there at least.

[00:19:48]Um yeah, we don't even need this helper to be honest cuz then we can just get the frontmost block, right?

[00:20:07]Yeah. Wait, what am I doing here?

[00:20:15]What?

[00:20:17]Oh, I see. We put all the allocates in.

[00:20:20]Okay, that makes that makes sense.

[00:20:23]Um, yeah. Okay, that makes that makes so much sense. So, we want to Oh, man.

[00:20:38]Okay. So, we still want like create entry block like I guess I don't know create sounds wrong here at least.

[00:21:01]Let's at least put this up here somewhere.

[00:21:08]Yeah, we should we should do that.

[00:21:12]So, this should be set up return uh return block I guess.

[00:21:24]Yeah. So, we want to do that anyways.

[00:21:31]Maybe we want an allocate creator.

[00:21:43]Yeah. So, we want to do that, I guess.

[00:21:52]Um, maybe close entry block. I don't know. I don't know what to call it. I think crate's probably fine.

[00:22:04]Yeah. Okay, we'll just do that for now.

[00:22:11]Okay.

[00:22:16]Or we could call convert. I don't know.

[00:22:25]Yeah, there we go.

[00:22:31]Ah, what the hell? We'll keep it crate.

[00:22:34]Me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me me trying trying to make any semblance of a decision. Um okay anyways so that should just move the allocates into the entry block. So we can kind of steal this to be honest I think um what is wrong with this again? Oh, that's what we needed.

[00:23:07]I guess like front body.

[00:23:16]Okay. So, now we need to make this alloc list as well. So, we're we're holding on to more things, I guess, which is fine. We're kind of We're kind of getting to this point.

[00:23:36]Yeah. Okay.

[00:23:38]So, that's fine.

[00:23:41]Um Oh, man.

[00:23:51]We should probably have a helper that like makes an all Yeah, we should insert allocate or something. Is that what we want to call it?

[00:24:08]Yeah. So, that probably goes like somewhere here above this.

[00:24:15]Um, yeah. And then we give it like or this doesn't even need a function.

[00:24:37]This is just like two lines of code. I think it's probably fine to make this not really reused.

[00:24:45]Um, okay. So, we want So, we make that we could just Can we just push back this?

[00:25:00]Yeah, we definitely want that.

[00:25:03]And then actually Oh, wait. That shadows that.

[00:25:31]Yeah. So those should be value return value.

[00:25:43]Um yeah, I guess we would do that.

[00:25:52]So here I guess this is pretty trivial at the top.

[00:25:57]Um here we should do parse body or I guess lower body and uh I guess yeah I guess we could just yeah we could just call it lower body I if I can type.

[00:26:26]Okay.

[00:26:29]So, that that does that. Uh the nice thing about prototype is that it's pretty easy.

[00:26:40]Um okay, we'll worry about this later. So, we'll delete that. Expert is pretty straightforward though, I think, because we don't really do much else with it.

[00:26:57]Uh, good luck, bro. Thank you. Um, I'm not sure if I've seen you around here, so if if you haven't been here, then welcome. And if you have, then also welcome, I guess. [laughter] Um, yeah, let's do let's do return because this is what we wanted to do.

[00:27:17]Um, yeah. So, we we definitely want that.

[00:27:25]And then I forget why we didn't need like the last thing. Oh, we have preexper. So, we do want to do something like that.

[00:27:46]Um, okay. We we might want to redo that at some point, but for now we just want to like make a return.

[00:27:59]So that lives in instruction return wherever that is.

[00:28:04]There we are.

[00:28:09]Um okay. Wait. So, what does this take again?

[00:28:19]So, we store into the thing and then Oh, I see.

[00:28:29]Okay, I understand why we do this.

[00:28:33]Uh, what's up, Kaso? Uh, why we don't use Edge? because Firefox is fine and well on my Linux machine I use Firefox so I figured I may as well use Firefox here as well.

[00:28:47]Um, okay. So, let's let's see. What do we want to call this?

[00:28:55]That name seems wrong.

[00:28:59]Um, I guess we could call we could make like an outgoing edges. I don't know. I don't know what to call this.

[00:29:09]We should we should clean this up somehow.

[00:29:16]These are definitely buffers.

[00:29:20]So, we should treat them as such.

[00:29:34]And then these are all like temporary slash like stateful things. I guess maybe this also goes up here. I don't know. This is this is all very confusing.

[00:29:54]I guess this is like stuff we necessarily consume. I don't know. Well, I don't know how I'm sorting this. I'll figure that out at some other time. I might end up just not sorting it and it will it will have to burn for better or for worse.

[00:30:06]Um, yeah. So, we're going to need this like block edges maybe I guess like outgoing edges.

[00:30:21]Yeah. Yeah. So, what is this instruction to basic blocks thing?

[00:30:26]Oh my god, that's awful.

[00:30:30]Okay, we're going to we're just going to lift that.

[00:30:35]Um, so this should be um what do we call this? I guess.

[00:30:49]Yeah, I don't know.

[00:30:51]Um, have you tried the Chris Teris utility tool? I haven't. Um, I just I just make a mess with my windows to be honest. I kind of gave up on keeping it clean. I've decided that it's just going to be messy for whatever unfortunate reason.

[00:31:12]Okay, so we have this which is also why we have some other mapping type mappings I think.

[00:31:22]Uh that's not helpful.

[00:31:27]That's really not helpful. I guess labels I guess labels is probably what we want.

[00:31:34]Um Huh.

[00:31:40]Okay. Well, I'm going to go to the bathroom real quick. Um, I'll be right back. Should be like a minute or two.

[00:37:01]Okay, I'm back.

[00:37:04]Um, all right. Where was I? We were We were figuring out how to do returns properly.

[00:37:11]Um, outgoing edges.

[00:37:17]What was I doing with this again?

[00:37:22]Um, huh.

[00:37:31]Yeah, I don't remember what I was how I mapped this at least. So, let's let's see how I did that.

[00:37:39]Connect basic blocks.

[00:37:43]Um, okay. So we have like this dangling terminator.

[00:37:52]Um so zero is the return block I think is how we did that.

[00:38:00]And then what the hell.

[00:38:05]Okay. And then we make the return block.

[00:38:06]I see.

[00:38:10]Oh, that's really awful. Oh, I really don't like that.

[00:38:17]Um, so this labels thing. How the hell did we How do we do this? This is like completely unreadable.

[00:38:26]It's a wonder that this hasn't this wasn't the thing that broke the most frequently actually. This is like really really poorly written. So yeah.

[00:38:38]Okay.

[00:38:41]Okay. So, how do we even Yeah, actually, how do we even do this?

[00:38:54]H.

[00:38:58]So, where where did this go to? Labels.

[00:39:07]Oh, I see. That's how we identified it.

[00:39:09]Okay. So, we just went by the label of value, I guess. Okay.

[00:39:16]Wow, man. This is terrible. Okay, we're going to need to This is actually just way more mess than I thought it was. We'll figure that out in a second.

[00:39:31]Um, but we can at least make a return instruction maybe, right? Surely we can do that.

[00:39:38]All right, we Yeah. So, we make a store and then uh map the branch for uh yeah, we can we'll do something like that later.

[00:40:06]We can kind of yank that. I think I violated some naming convention somewhere here.

[00:40:20]Um, yeah. So, we want that and then Oh, man.

[00:40:37]We do want some way of like resolving atoms, I think.

[00:40:44]So, this would be like use, right?

[00:40:48]Um, yeah, this is this is terrible.

[00:41:00]Uh, which language? Um, I'm writing I'm writing this in uh I'm writing this in C++, but I'm compiling C down to x8664.

[00:41:19]Okay, so we can do this and then instead of putter we can do red allocate.

[00:41:30]Yeah, good luck. Thank you.

[00:41:35]Okay. So then cur or we just do instructions.

[00:41:43]Yeah. So we can do that.

[00:42:00]Yeah. Yeah. So, I think we should probably we should probably handle these things sooner than later, the experts, cuz I think that will help us figure out what we need to do for like scopes and stuff. Um, I I have an idea on how to simplify it. So, that will that will be very positive, but hopefully hopefully that all goes to plan.

[00:42:26]Um, okay. So, we do that and then we can kind of just yank that, I think.

[00:42:46]And then we want a thing to make a basic block out of this, I think, is how we do this.

[00:42:57]Um yeah.

[00:43:10]Um we can figure out how to like dduplicate later, but for now I want to just like keep this as as straight line as possible.

[00:43:27]So, where's our crate basic block? Yeah.

[00:43:29]So, we do this.

[00:43:42]So we give this stood move instructions and then stood move branch.

[00:43:58]Yes, we do that and push back uh we can push back basic block or Let's do that.

[00:44:17]Um, and then Oh man.

[00:44:26]Then we have to clear that presumably.

[00:44:30]Okay.

[00:44:31]So that's actually a lot shorter than it was here. At least this this function looks so much messier than the actual internal logic. So, I'm I'm kind of glad I decided to not do it that way.

[00:44:44]Um, yeah, we'll figure we'll figure right Bell out. Um, good luck, bro. Thank you.

[00:44:50]I I do appreciate it a lot.

[00:44:54]Uh, let's see what else do we need to do here. If we actually we could kind of do the same thing here with if and while. I think these instructions shouldn't be that bad.

[00:45:06]Um h Oh man. [laughter] Yeah. How do we How do we want it to do this?

[00:45:46]H.

[00:45:50]Luckily, scope is like pretty easy, so I'm not that concerned about that. Um, yeah.

[00:46:12]Okay, let's let's work on the experts now. I think I think that that will help us figure out what we need. So, we probably want helpers for like uh we probably will want more helpers, but we will we will build those out as as we see fit.

[00:46:30]Um let's see.

[00:46:34]So let's start with terminal expert.

[00:46:39]Um how's job search going for compiler roles? Um AMD and Nvidia have this. Um but also like quant firms sometimes hire um compiler engineers because they invest a lot in various different languages. Um yeah, hardware is like another big place. Big tech's another really big place.

[00:46:56]Um, right now I'm like I'm kind of chilling for a bit because I have an internship for the upcoming summer. So, I'll just like I'll kind of wait until then to like start applying to full-time proper. But yeah, that's kind of that's kind of where I'm at right now.

[00:47:12]Um, okay.

[00:47:17]So, what do we do with this?

[00:47:25]>> [snorts] >> Okay.

[00:47:30]I graduated from undergrad. Um I'm I'm like I guess I technically have finished my undergrad, but I'm I'm also finishing up my masters right now. So um I'm in like the combined BSMS program.

[00:47:45]So the consequence of that is I've got an extra I've got an extra summer to work with pretty much.

[00:47:54]Okay, we definitely need a way to resolve scopes because I'm going to go insane if I don't have that.

[00:48:00]So, let's see.

[00:48:05]I don't want to do it like this super convoluted way that I did here, though.

[00:48:09]I think cuz I have like four different Yeah, I have like four different functions for this.

[00:48:18]So, uh, what's up, Euglver?

[00:48:30]So, we want Oh, man.

[00:48:34]This is terrible. This is This is actually truly terrible.

[00:48:39]Um, let's see.

[00:48:46]Yeah, this is really difficult actually.

[00:48:49]This is difficult to figure out what to do what what to even do with cuz like here we're kind of making the thing. Um if it's a number then like we should probably just make a number. If it's I guess terminal expert we necessarily should be making the thing.

[00:49:12]Hm.

[00:49:16]Um, okay. Let's do if E.

[00:49:26]If it's the identifier, then we need to figure that out.

[00:49:32]Or actually, wait, what do we do here?

[00:49:40]So, we have this like last expert thing.

[00:49:47]Last expert should become a value star.

[00:49:49]I think I think that's what we want to do with it.

[00:49:56]Yeah, we should make this a value star.

[00:50:06]What's wrong with this? Oh, right. This is this is the one place where I actually can't do that.

[00:50:16]Yeah. Okay.

[00:50:20]With prev expert equals.

[00:50:26]So if it is identifier then we want to we want it to do otherwise then we should um oh man do we need this to be unique pointer? I think we need this to be unique pointer right or wait no uh we have literal We have this literal map thing.

[00:51:06]How the hell did we use this? This was like so dumb.

[00:51:23]A We did this thing.

[00:51:32]Okay, that makes that makes a lot of sense.

[00:51:36]Um Oh crap.

[00:51:42][laughter] God damn it. Okay, this is so dumb.

[00:51:52]What type is this? We don't know what type this is. That's the problem.

[00:51:58]Um, okay. Uh, what's the status of your code genen? Um, it's it's outputting x86 um with or in an ELF format.

[00:52:09]Um, prerequisites for developing a compiler. Um, kind of just like I don't know just like basic systems knowledge. Um, OS is probably helpful, but I think systems knowledge is probably the big thing. Also, probably some PL experience as well.

[00:52:26]Um, oh man.

[00:52:38]Okay.

[00:52:45]H. Yeah. What do we do with this?

[00:52:51]Let's just let's just wishlist program this.

[00:52:55]So, we can do get value or we'll just do like get literal.

[00:53:00]I don't know what type it is though.

[00:53:02]That's a really big problem actually.

[00:53:07]Um I think we do something like that in here though, right? We Right. We figure out the type Where's all of you scope?

[00:53:27]That doesn't help me at all.

[00:53:34]That's really annoying.

[00:53:36]That's so so so incredibly annoying.

[00:53:45]Now, where's the part where we figure out the type of things, right? Is this ever a problem at this in this?

[00:54:08]Yeah, this is this is causing a lot of headache.

[00:54:12]So, we want like I guess get use maybe and then we'll figure out what to do with that in a second.

[00:54:32]Oh man.

[00:54:35]Um, we can do get use and then let's give it like we can get the value. Maybe this is this is not going great. This is going very poorly actually.

[00:55:14]Yeah. Okay, we'll do that, I guess.

[00:55:18]Um, I see. If direction if direction is your problem, I think just like just like learning more different things or like trying to figure out how you can like add depth to whatever you're working on. Um, I know that doesn't really like say a lot, but yeah.

[00:55:37]Um, what are you doing on your masters?

[00:55:39]Um, it's focused on compilers in some capacity. Um, a lot of like analyzing codegen. I'm not going to like get too too into it right now, but that's kind of the that's kind of the short version.

[00:55:58]Um, okay. We'll we'll figure out what the hell we're going to do with get use and get literal.

[00:56:04]Um, yeah, we can probably just do prev expert.

[00:56:15]Yeah, that actually works perfectly.

[00:56:17]Then we'll figure out what goes in there later. Um, PN, this should be straightforward, I think.

[00:56:29]Um, yeah. How did we do this? Is Was it literally just like visit or visit the child?

[00:56:40]Yeah.

[00:56:48]Okay. And then call. We can kind of we can kind of reuse some of this. I think that that's also a little bit annoying.

[00:57:03]Let's do unary op and binary op. I think those are less annoying.

[00:57:24]Or actually, we could just make this last ex or private expert, I think we called it. Yeah, let's rename that.

[00:57:34]Um, oh yeah, I guess that kind of cleans things up a little bit.

[00:57:47]So you can just make variables now.

[00:57:53]So then we can just switch on e get or get up. I guess we can yank some of this.

[00:58:15]Uh, what are we doing here?

[00:58:19]Oh, right. We just like one to one this.

[00:58:21]This isn't really useful. This isn't useful for us. But I guess this type stuff might be helpful. I'm going to yink these case statements, though.

[00:58:35]Um yeah. So here we're just skipping ahead and we're just directly generating the thing.

[00:58:46]I think we have a unary op thing somewhere here.

[00:58:50]Yeah.

[00:58:56]So if it's maryy plus we don't need to do anything here I think um or we could actually yeah like wait like all of the times we call get literal I think, right? Wait. Yeah. Every time it's literally just I32. Like, there's no reason to make this complex.

[00:59:45]I should just make it I32 necessarily for now until we like stick types on things.

[00:59:51]Then we might make a bit of a mess, but that's fine.

[00:59:55]Um, let me fix my camera.

[00:59:59]Okay.

[01:00:02]Okay. So, what what was I looking at again?

[01:00:06]This was useful because we need to do stuff here.

[01:00:10]Um, yeah. So, we want Uny plus type conversion, right?

[01:00:24]So, this matters now because we have like a pointer type.

[01:00:30]Uh, what's up, Panda? I'm I'm doing all right. Hopefully hopefully you're chilling as well.

[01:00:40]Yeah. Okay. So, it promotes to int, I guess.

[01:00:45]Yeah, I had I had Chipotle for dinner.

[01:00:47]It was It was fine.

[01:00:52]Um, let's see.

[01:00:56]Yeah, we can do we can just get away with doing nothing here, I think.

[01:01:02]Um, yeah, we can keep prev expert I think here we want to zero.

[01:01:18]Oh, we want like we want these buffers for some reason.

[01:01:28]Oh, we need to store. Oh crap.

[01:01:33]Oh no. Okay.

[01:01:36]All right. We need these buffers then.

[01:01:38]That's That's so annoying.

[01:01:45]Okay.

[01:01:48]Uh, thank you confusing all for the $10.

[01:01:51]Um, yeah, I I appreciate it a lot.

[01:01:56]Uh, exam day for systems architecture and discrete structures. Yuch. That is that is rough. Hopefully you had time to eat between then. Or is that tomorrow?

[01:02:09]And then and then DSA. Damn. Wow, you're you're in you're in super hell. I hope I hope all goes well. Uh, what terminal are you using? Um, I'm using Westerm for my terminal emulator.

[01:02:22]We love Westerm.

[01:02:31]Uh, yeah. So, we can do this and this equals V, I guess.

[01:02:38]Have you think about adding some notif?

[01:02:40]Um, I've been pretty low production. Uh, very low on like production at least.

[01:02:45]So, like my setup is literally like this scene here and then like my camera here.

[01:02:51]So, um, I don't know. I haven't I haven't like heard that much about like about like production stuff.

[01:03:02]Um, but maybe in the future I'll take a look into it.

[01:03:06]Um, I was going to like invest a little bit more time into production overbreak and then I didn't. So, uh, whoops, I guess. But yeah, it will it'll happen at some point.

[01:03:21]Uh, let's see. So, minus we need to literal equals get literal zero. I guess we'll make get literal a thing at some point.

[01:03:38]Um, also, what the hell am I doing with literal map here?

[01:03:47]I guess we could we could just stick a type in here. Literal map like we will be dealing with types in the future. So, I think that's probably fine. Um, I should probably also have a type conversion instruction, but that's a future issue to worry about.

[01:04:03]Um, yeah.

[01:04:08]So, we can do type i32.

[01:04:14]We'll we'll make the function a thing at some point.

[01:04:23]Yeah. If if you're new here, you will find out very quickly that I frequently leave problems for my future self to resolve. And very rarely does that go well for me, but it's very pleasant in the present. So, we will we will keep that up because it makes me happy.

[01:04:48]Yeah. Okay. So, then we can kind of just copy this line as well, I think.

[01:05:01]Um, let's see. What is type here again?

[01:05:06]Type mappings at variable.

[01:05:11]Oh, I see. That's how we do it. Okay.

[01:05:14]Um.

[01:05:17]Huh.

[01:05:24]G.

[01:05:37]Yeah, we'll we'll figure that in a second. Let's clean this up a little bit though.

[01:05:43]So subtract we subtract val we subtract from zero cast to int question mark.

[01:06:06]Uh yeah, we'll just do that.

[01:06:16]What am I doing here?

[01:06:26]What am I casting that to? What the hell? Wait.

[01:06:40]H.

[01:06:43]Do I have to like double static cast this?

[01:06:49]Is that a thing?

[01:06:54]So, value star.

[01:06:58]Uh, let's see.

[01:07:04]Is there a way to not do this?

[01:07:15]Okay.

[01:07:30]H. Okay. Let's Let's just static cast it twice.

[01:07:38]This is a binary op star.

[01:07:48]And then this takes bin up.

[01:08:00]There we go. Okay.

[01:08:04]Um, and then we want [snorts] uh, so we can do that. Let's give it stood move bin op.

[01:08:22]Uh, is it worth writing compiler and C only or is that too much pain? Um, it is definitely rough. Um, I think it's pretty doable though. Um, you'll just have to like limit your scope a little bit.

[01:08:36]Um, specifically the middle end is like really awkward if you want to make it like modular.

[01:08:44]Um, okay. We also need to figure out this type thing.

[01:08:51]And where did we get type from? Up here.

[01:08:56]from the variable in that. Okay. Well, that doesn't that doesn't help me at all.

[01:09:02]Yeah, that really doesn't help me. Okay.

[01:09:04]Um I guess we can just get the type of this. We we can get the type of preexper.

[01:09:12]Yeah, we can literally do that.

[01:09:15]Yeah, let's let's do that.

[01:09:18]Um, okay.

[01:09:23]So, we can uh Ryan compiler in C++ to learn C++.

[01:09:31]That's exactly what I'm doing here. So, I' I'd say it went pretty well, but um your mileage may vary depending on how willing you are to like self-study stuff.

[01:09:47]Oh, what the hell am I doing here?

[01:09:58]What the [ __ ] What was I doing? Wait, this this change is nothing useful for me.

[01:10:16]Where do we use value? What the Wow, this was terrible.

[01:10:28]Okay, I think I think here I just gave up on like fixing things.

[01:10:33]So, this is not great reference code, but we will we will figure that out.

[01:10:39]Um, let's see.

[01:10:42]We should just not use a switch for this. I feel like I feel like that just makes things too messy.

[01:10:49]Which is insane to say, but we we've got all these like temporary buffers that we've like stuck at the top here. I don't really like it.

[01:10:59]Um let's see.

[01:11:06]I guess we could like put a lambda here, huh? And like it'd be perfectly fine.

[01:11:16]I don't know. Before I before I like tempt myself too much with that idea, we'll just move on swiftly.

[01:11:23]Um, what's wrong here? Oh, instructions.

[01:11:32]Okay. So if that uh what do we do with unop res?

[01:11:42]Oh, we do a store. Okay.

[01:11:46]Um ah this is getting really annoying.

[01:11:53]This is getting really hard to reason about at least. Maybe I shouldn't have started with unary op.

[01:11:59]Um, yeah, this is this is actually like breaking my brain. Uh, looking for C++ ideas. I see. Um, yeah, there's there's plenty of stuff you can do. Um, it it all kind of just depends on what you're interested in though. Um, I don't really have any generic recommendations, but I think if you like if you have something that you are very clearly interested in, then I think like that will lend itself pretty nicely. Um, there's a lot of different systems projects ideas that you can probably get started with. Um, compiler might be like a little bit insane for a first project, but um, it can be done. Um, yeah, I don't have any like great general recommendations though, at least unfortunately.

[01:12:50]Um, oh man.

[01:12:56]So we subtract from zero, we get the result of it.

[01:13:04]Yeah, of course.

[01:13:09]Oh boy.

[01:13:13]I guess we do need to make a temporary.

[01:13:15]I think that's probably what we want to do, actually.

[01:13:23]Yeah. Okay. That's actually I think that's what we want to do.

[01:13:31]So that's the result of that.

[01:13:35]Let's make an alloc.

[01:13:38]So we have I think we have a helper function to make an allocate, right?

[01:13:46]So we have like I guess I swear we have a thing, right? We better have a thing for this.

[01:14:09]No, we don't have a thing for it. Okay.

[01:14:11]All right. Fine. Fine. We'll make a we'll make a damn function for it. This is actually getting annoying.

[01:14:21]Yeah. Okay. So, let's let's add the helpers while we're at it. So, we want So, we want to like get allocate uh what the hell?

[01:14:39]Okay. So we want allocate. We want literal.

[01:14:46]Let's just look at it here.

[01:14:54]And then we want get use. And then we want a deaf as well, I think, probably because those will handle scope differently.

[01:15:21]Yeah. So, I think that makes sense.

[01:15:24]I guess this should be make allocate.

[01:15:36]Yeah, I want to keep this like resolve terminology. I don't know.

[01:15:44]So, this returns a literal and then these are death and use. Okay. Yeah, I think I think this makes sense.

[01:15:52]Um, let's actually rename that to make pms as well.

[01:16:06]Yeah. So, we need to we need to change some things, but we'll do that in a second.

[01:16:29]Okay. So, we've we fixed that up.

[01:16:35]Um, all right. Let's let's figure out the types for these now.

[01:16:40]So, this should be middle end mir instruction allocate star make allocate.

[01:16:52]And this should get a middle end and our type type.

[01:17:02]Uh, does your compiler work currently?

[01:17:04]Um, well, if I wasn't like completely tearing up the plumbing right now, um, it would work. Um, I believe the main branch is updated to work on the compiler.

[01:17:19]Uh, yeah, this should this should work.

[01:17:23]So, we'll just we'll just clone this.

[01:17:28]Uh yeah. So, if we build this, hopefully it works. Let's This actually a good test to see if I've set it up properly.

[01:17:51]paint drying slow build. Uh uh while this builds, uh the test suite I have is pretty crap.

[01:18:05]There's just a couple of tests here.

[01:18:07]There's like silly Fibonacci.

[01:18:10]There's some like really basic stuff.

[01:18:14]Um so on and so forth. This is broken I believe. Putter might be broken.

[01:18:24]Is this building with J32?

[01:18:30]It's supposed to be building with J32.

[01:18:33]That's odd.

[01:18:35]Uh what's up, Mike? Um I've been doing all right. Uh hopefully your day has been all right as well.

[01:18:41]Um there's also Oh, yeah. There's a really stupid benchmark here as well.

[01:18:46]This is just like a big Fibonacci.

[01:18:53]Are you using Ninja? No, I'm just I'm just using like raw CMake.

[01:18:58]Maybe I should use Ninja, but I recently learned CMake has a J30 has a - J flag, so I was like sure. Um, it looks like it failed one test.

[01:19:09]That one fails sometimes for some reason.

[01:19:13]I don't know why. And right now I don't care to figure out why.

[01:19:20]Uh many reg.

[01:19:26]Um so let's go do many regge that lives here.

[01:19:32]It's a pretty funny test. Um yeah, most of these pass. It just like it just runs the I guess that that's not really a good these are regression tests. So that doesn't test like the output correctness. Um like if you compare it to like the expected like there's the a this is the thing that this is the thing we're getting rid of. Um eventually you go down to like actual assembly and it's like really ugly but it works.

[01:20:05]Um, and then if we do uh test benchmark, and then this benchmark script is really stupid. Um, something appears to have broken somewhere um in my setup. But yeah, uh why would anyone build a compiler? Um cuz well, we don't we don't want to write assembly uh by hand. So to support more powerful languages, a compiler is used to, I guess, do the translation.

[01:20:41]Um, they're better than interpreters when you care about performance. And we need new compilers because we're making new languages and we're making new, I guess, assembly languages. So, we're going to need to update our existing technology as we go.

[01:20:58]Um, yeah, it looks like it looks like benchmark was broken, but that's that's fine. We'll we'll fix that later.

[01:21:08]Yeah, there was there was one point where it worked. I don't remember when it stopped working.

[01:21:14]Uh, you can probably check a stream from like two or 3 weeks ago for a reference.

[01:21:22]Um, okay. So, these should be MI value star I guess. H maybe this can be literal star even it should be value star.

[01:21:45]Yeah and then we can do that as well.

[01:21:49]Well, we need to change these types.

[01:21:54]Uh value and then we want type.

[01:22:04]Um let's see what what do we even do with def definite use?

[01:22:11]Um is there any language that's converted into machine code directly without transforming it to assembly?

[01:22:16]Um, I don't think so. I don't think there's at least any reason to do that. Like, um, like assemblers and linkers have been like a thing for a while. So, like it, um, it feels a little bit I don't really see why anyone would do that necessarily.

[01:22:36]Like, yeah, it it just feels like like it just feels like why, you know? Um but like um the other big reason I think people don't do it is because um C interoperability is like a really big thing. So yeah.

[01:23:00]Yeah. I guess I guess in a sense that is like assembly which is really funny to think about.

[01:23:08]Um, okay. So, what do we pass this at least?

[01:23:20]Oh, man. I guess we could just give it a Yeah, we could just give it in 64T ID.

[01:23:29]Yeah, we could like do that again as well.

[01:23:34]We could we could leave it like that for now.

[01:23:39]Okay. So, res putter equals get or make allocate and then this takes uh yeah, we'll we'll we'll save this for later. Um, let's make an I32 just to be boring.

[01:24:13]Okay, so that fixes most of our stuff. Um, value doesn't exist here. This is val now.

[01:24:30]Oh, we need to load. Okay, that's I'm not thinking an SSA right now. This is very awkward.

[01:24:38]Um, I'll just you know what? Let's just to do review it all. [laughter] Yeah, we need to we need to do some SSA stuff. Thanks for answers. Good luck.

[01:24:51]Um, thank you. Um, let me know if you have any other questions and I will I will attempt to explain them the best I can.

[01:25:03]Um, okay. This should be fine, I think.

[01:25:07]Uh, okay. Take care, Earth. Um, thanks thanks for stopping by.

[01:25:14]Okay. Um, yeah, let's let's make these helpers a thing and I think we will call it a day to be honest. I'm getting tired of this.

[01:25:26]Um, what version of C++ um are you using or would recommend? Um, I think it's always good to use latest, but um if you I think like generally C++ 17 has been a good stasis. Um I think one before most recent generally speaking is what people keep as a stasis. Um people residually have been using C++ 17 but uh I think technically C++ 20 is supposed to be the norm right now and 23 is just nice to use. So, I think it's probably good to like use 23 just because it's there's some cool features in there, but if you want like a very portable version of C++, I think 17 is probably like really safe. Or 17 is probably like the furthest back you could go without like going insane, I think.

[01:26:24]Um, okay, let's see. So, get result is here. So, let's just paste this whole pile here.

[01:26:37]Yeah, let's do more trimming. Okay, so this is two. Am I a visitor?

[01:26:49]Okay, we can do that.

[01:27:02]Yeah, it's it's not even it's not even complete. That's that's the kicker. Like we're they're still adding like they're still trying to implement features, but that's kind of that's kind of inevitable, I guess.

[01:27:15]Yeah, I think 23 is probably fine. Like all this I think I'm building with 23, right? Let's see. Yeah, I'm using 23.

[01:27:27]All this code is written manually. Yes, I am I'm trying to avoid using an LLM as much as possible. Um I'm still using it for like debugging sometimes or like if I'm really stuck trying to figure out what to do. Then like maybe I'll like maybe I'll like prompt Claude or something, but I'm not using it to generate code for the most part.

[01:27:46]Uh because it's just boring. It's just boring to sit there and like vibe code.

[01:27:51]Part of the like the fun part about writing code has always been like doing the tap in by hand.

[01:27:56]It's never been like a difficulty problem.

[01:28:00]It's just like a fun thing.

[01:28:04]Um, okay. What was I going to copy from?

[01:28:07]It was this thing.

[01:28:11]Uh, yeah. So, we want that.

[01:28:17]Yeah. Let's actually go back down here.

[01:28:20]We can figure that out in a second.

[01:28:27]Um ah oh I don't know what the best sequencing for this is. So we can just return K's back and get I think I think that's the best sequencing.

[01:28:59]What?

[01:29:04]Oh, I see. We can't do it that way. So we want we want resz or or let's call it all putter like that. There we go. So now we can replace this whole thing or we can replace this with or we don't even need this. We can just do make allocate of whatever type it was. It was just type.

[01:29:40]Nice.

[01:29:43]So that actually cleans things up a little bit.

[01:29:48]Uh what's your intellisense/stack analysis tool? Um yeah, I'm just using cling d um lsp.

[01:29:59]Yeah, my flags are very boring actually.

[01:30:01]I don't I don't do a whole lot with it.

[01:30:06]Okay, this is that's cleaned up. Uh let's implement get literal. I think we can just yank this for the most part from here.

[01:30:18]Yeah, we kind of we can kind of just do this.

[01:30:28]Yeah. So we can do that.

[01:30:35]Yeah. We want it to create the thing.

[01:30:39]So if it contains it then we return the thing. Otherwise we make the literal.

[01:30:50]Yeah. So we make it it has a type it has a value.

[01:30:55]Um, we have that.

[01:31:01]Uh, what bro is building? Um, I'm making a compiler from C to x8664. So, a compiler is a program that translates programming languages. Um, C is a programming language. x8664 is an assembly language. It's like kind of close to machine code.

[01:31:20]Um, okay. So, we do this. This is fine.

[01:31:29]Yeah, this this is fine. I think I like this implementation.

[01:31:36]Okay. And now we get to have we get to have more fun.

[01:31:41]Um Oh, no. [laughter] I'm so scared. I don't I don't even know what to do with this. I actually just don't know. Um crap. Okay.

[01:31:59]Okay. Um deaf. I think we can kind of draw inspiration from what we've done here.

[01:32:10]Uh where is this little where does this live? Yeah. This like declaration scope thing.

[01:32:22]Yeah. So we have declaration scope. So um let's see.

[01:32:33]Yeah. So the problem with the way I implemented this was I have like I like overloaded the hell out of this. And the upshot of that if we look in the header is we have we have so much bloat. We have resolve declaration scope resolve decoration scope and then like two uses as well. It's just like it's just awful.

[01:32:53]So, we're just going to resolve that externally and then we will do this here and it will it will be much less awful.

[01:33:05]So, and also instead of making just like atoms, we will be uh I guess we will just we will just straight up make uh what's it called?

[01:33:21]But I'm blinking. Uh we'll just make values actually or we're not making values.

[01:33:29]We're just getting a value from a mapping.

[01:33:32]So we can h What was I doing here?

[01:33:44]I see. So, oh man, this doesn't make sense because we necessar if it's a death, then we're just making the thing.

[01:33:58]So, this doesn't exist.

[01:34:02]Yeah, this shouldn't this just shouldn't exist, I feel like. So, we can get rid of this, to be honest.

[01:34:10]Yeah, we should just be inserting it in in the back scope. And there's like only two places that that happens.

[01:34:17]Um, okay. So now use [laughter] okay.

[01:34:30]Uh, yeah. What even is this mapping? I guess we should rename this to get value, I guess. Eh, yeah, we'll just call it get use. Um, so this is we want to like yank this sort of thing pretty much.

[01:35:05]Scope bindings. We want the size of that or size. Is there a way we can just reverse iterate for each?

[01:35:19]There should be like a very Okay, I guess there isn't a convenient way to do it.

[01:35:25]Okay, we'll just H Oh, we could we have that actually.

[01:35:33]But I really don't want to use ranges cuz ranges are annoying.

[01:35:43]Um okay. So yeah. So we can actually just use the reverse iterator.

[01:35:55]So we can use scope map uh bindings r begin iterator is not equals scope bindings r end.

[01:36:10]I don't remember what direction it goes actually.

[01:36:22]Oh so we plus plus it. Okay.

[01:36:31]Yeah. So, we can do that and then if Yeah. So if it contains ID then we can do something.

[01:36:56]What key type is this? Oh it's by string.

[01:37:03]Uh okay we we got to change that.

[01:37:11]Why did I do string?

[01:37:22]Yeah, it should be just by identifier.

[01:37:24]So this is 64t.

[01:37:36]Um, okay. Okay. So, we should actually just like we should just make this a map actually from that to middle end and our value star.

[01:37:49]Yeah, much better.

[01:37:56]Um, let's rename this to like uh scope it iterator. I guess this this really sucks. Naming things is hard.

[01:38:22]Uh what do we do here? What is the best way to do this?

[01:38:33]Um, this should unreachable out of here then, right? Surely there shouldn't be a world where that goes wrong, right?

[01:39:01]Yeah, cuz this definitely should exist unless we like completely broke something. So, let's just unreachable at this here.

[01:39:11]What could possibly go wrong?

[01:39:16]Uh, what's up, Skittles? I am I'm just making some helpers and probably going to call it a day. I'm I'm a little bit tired.

[01:39:27]Yeah, I am this this codebase has really really exploded uh for the worse, but you know that's how it goes. Um yeah, what do we do? What do we do with this?

[01:39:50]Check something.

[01:40:02]Okay.

[01:40:04]Uh, should you start with C or C++? Um, I I would say start with C because I think it helps motivate a lot of C++.

[01:40:12]Um, I've heard people say that the other way is fine as well. Um, I don't think there's a wrong answer though. I personally would start with C.

[01:40:26]Okay. So, [sighs] yeah. What do we do with this?

[01:40:46]So I guess bindings equals dref it iterator and then if bindings or I guess so what does find take?

[01:41:12]I see you.

[01:41:16]So, we want to find uh ID, I think.

[01:41:38]Um, okay. So, we can do that and then Okay, wait. So, can we actually Okay, let's do mapping equals that I or I guess binding.

[01:42:06]So if that equals bindings and or if not equals then we can return binding second I think arrow. Whoops. There we go.

[01:42:28]So we want to do it like that I guess.

[01:42:29]Otherwise it's unreachable.

[01:42:37]Uh, it doesn't exist.

[01:42:39]Get use it.

[01:42:44]Okay. Well, we we named it poorly.

[01:42:49]We should still call it get use, I think. Okay.

[01:42:57]Okay. So, that's fine.

[01:43:06]Yeah. Okay.

[01:43:09]So, now all of that kind of works sort of. Not really. A little bit.

[01:43:22]Is there anything else we can do real quick?

[01:43:27]We can probably do declaration real quick, actually.

[01:43:31]Um.

[01:43:34]Uh, good luck. Thank you.

[01:43:38]We can probably yank this real quick.

[01:43:40]This shouldn't be that bad.

[01:43:45]Yeah, we can kind of just copy this for the most part.

[01:43:54]Yeah. So, we can do that. auto [snorts] allocate.

[01:44:02]You want to make allocate with type I guess and that should be good.

[01:44:30]Yeah. So we can do that maybe and then if I get variable or get value and then we want to do something.

[01:44:48]Yeah. So if that's not a null pointer.

[01:44:58]Yeah.

[01:45:01]Um then we want to then we want to I get value accept this and then we want to make an assign. So, so assign equals or it should be store.

[01:45:39]You can kind of yank that and then we can give it Yeah. So we can do that and then here we give it okay and then we store the assign val there and then we can paste that there.

[01:46:19]Yeah, that wasn't so bad actually.

[01:46:22]That was pretty that was pretty reasonable.

[01:46:28]Okay.

[01:46:32]Um, okay. These are control flow and I'm lazy, so I'm going to do those later.

[01:46:37]Um, but it shouldn't be that hard in theory. We just have to like play around with scope a little bit. Um, and then the experts. Lord knows what I'm going to do with those. Um, yeah, I think that's I think this is a pretty good place to start.

[01:46:56]Um I guess here we can do start let's rename this more properly.

[01:47:03]Uh start to mr for experts and instruction or experts plus instructions plus some helpers.

[01:47:18]Okay.

[01:47:21]All right. I think that is a good place to call today's stream though. Um, [sighs] yeah. Uh, thank you all so much for showing up today. Um, I don't know what I'm going to do tomorrow actually because it is day 200 tomorrow and I need to do something I want to do something special for that. Um, I was thinking about doing some config rewrite stuff, but I'm not sure how interesting that would be. And yeah, so uh stay tuned on that. I'll I'll plan that out. Um, if you haven't already, like the stream, sub to the channel. Um, if you want to support me financially, my GitHub sponsors is in the description. Um, that would be probably the least that would probably be the best place to do that. Um, join the Discord. That's in the description. Um, best place to get pinged. And yeah, I guess there are like two socials down there as well. Um, yeah, that's about it. I've dragged this on for long enough. Take care, y'all. Take it easy.

[01:48:18]And I will see you all