In this video we walk through a real example of maintaining an AVL tree by performing a rotation. We start with an unbalanced tree, compute balance factors, identify the Z Y and X nodes, and apply a double right rotation to restore balance. Perfect follow-up if you’ve seen the basics of binary search trees and AVL trees.

Watch as we turn an invalid AVL tree into a perfectly balanced one with clear step-by-step instructions.

If you’re learning data structures and algorithms, this practical example will help you understand when and how to rotate.

00:00 Introduction to AVL Tree Rotation
00:14 Prerequisites and Previous Videos
00:36 AVL Trees Overview
00:40 Types of Rotations and Balance Factors
01:01 Examining the Example Tree
01:24 Confirming Binary Search Tree Properties
01:27 Computing Balance Factors
01:39 Identifying Imbalance at Node 65
02:01 Locating the Z Node
02:54 Finding Y and X Nodes
04:08 Assigning X Y Z Values
04:33 Creating ABC In-Order Representation
04:58 Drawing the Target Rotation Pattern
05:34 Updating Node Values in Pattern
06:04 Checking Unaccounted Children
07:00 Reattaching Nodes and Performing Rotation
07:56 Recomputing Balance Factors
08:24 Updating Root Balance Factor
08:41 Resulting Perfectly Balanced Tree
08:48 Identifying Double Right Rotation
09:06 Explaining the Rotation Process
10:16 Conclusion and Next Video Teaser
11:56 Channel Promotion and Outro
15:48 Final Hello and Recap

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hey there! Let’s maintain and rotate an AVL tree which is a self-balancing binary search tree.

Okay. Alright, so hopefully by now you’ve seen my other videos. If you haven’t,

you probably won’t understand this unless you’ve seen other videos elsewhere.

But in my previous videos we talked about what is a binary search tree, how to make one, how to

binary search tree, how to make one, how to define one, how to know you’re looking at one, how to build one, search,

insert, remove all the operations and time complexities.

And then we talked about AVL trees, which are a self-balancing binary search tree.

And we talked about what are the different types of rotations you can do? Why would you rotate?

How do you compute balance factors? How do you know when it’s time to rotate?

How do you do the rotation? Stuff like that. So this is just going to be one

example tree, and we’re just going to try to burn through it. If you want to learn more about

see my previous videos. Okay, so supposing now that you have a tree that looks like this, let’s

confirm that this is a valid AVL tree. This seems to be a tree. It’s a connected graph. It’s got no

cycles. It’s a rooted tree. It’s a binary tree. There are no more than two children per every

single node. And the data is in order. So 14, 22, 36, 41, 48, 55, 65. So this is a valid binary search

Now to determine if it’s a valid AVL tree, we just have to compute balance factors.

So in my previous videos, we talked about doing this.

So I’m just going to try to burn through this quickly.

I want to put zeros on all the leaves because that’s pretty easy.

This 48 gets a 1.

The 65 actually gets a 2.

So at this point already, we know there’s something wrong with our tree.

We need to rotate it.

This is not a valid AVL tree because we see a balance factor that is worse than, you know,

plus or minus 1.

61 is going to have a balance factor of, let’s see, just a 1.

And so really the only thing that we need to rotate is going to be this 65 node.

This is the node that’s out of whack.

Sometimes you see, you know, the bad balance factor in other areas of the tree,

maybe like a little bit higher and also a little bit lower.

You want to rotate as low as possible first because sometimes when you rotate low,

it fixes stuff that’s higher.

This is actually only true if the thing that you’re rotating is a direct descendant,

Not necessarily a direct child, but just a descendant of the thing that you see that is higher if you have two different nodes that are

unrelated in terms of

You know, they’re not direct descendants or ancestors of one another. They’re sort of like siblings or cousins

Then it doesn’t really matter so much which one you rotate first because they’re not really going to affect each other

but

In this case if we rotate, you know starting with the 65 there’s a chance that the 41 will get fixed up a little bit

I haven’t tried this yet, so I don’t know for sure, but I have a feeling it might.

Let’s see what happens.

So we know that the first node that is out of balance we’ll call the Z node.

So I’m just going to put a Z here.

Let me just duplicate this and we’ll say Z.

Hang on a second.

I got some dashes in my pen.

There we go.

We’ll make this the Z node.

And then we have to find X and Y.

We’ll do that backwards.

We’ll find the Y first and then the X.

them by going down one level at a time so the Y node will be a child of Z and

we’ll have to find the child that has the taller subtree in this case there’s

no choice because there’s no subtree on the right side of 65 so we can only go

left but just keep in mind if there was a subtree let’s say like that then we

would still go to the left and select that 48 as the Y node let me just write

down Y node here because it would have a taller subtree notice the left subtree

in this little example has a height of 2 and the right subtree has a height of 1

That subtree has a height of one.

So let’s just get rid of that little extra thing.

Same thing for the X.

We want to find a child of Y and we’ll always take the taller subtree.

So you know, if there was a subtree over here and maybe like another like node down there,

then we would still go to the right to get the 55 because it would have the taller subtree.

In this case, there’s only one choice.

So the X node is just going to be this 55 and that’s it.

So let me just put an X right here.

are x and y and z i’m just going to write that down real fast x equals 55 i’m going to probably

change the color here y is equal to 48 uh z is equal to 65 um and then we want to make an in

order representation of xyz and just call it abc so i’m going to say a is equal to something

and so is c so a is going to be the least value the value that belongs on the left because again

these are supposed to have ordered data like binary search trees so i’m going to put 48 here

and 55 there and then 65 here now abc is the in order representation of xyz now that we’ve done

that i’m going to draw our target pattern here so let’s see i’m going to do i’m going to do a

to connect with some blue lines because that’s just like such a cool connection.

Hang on a second.

I put that a little bit too far down.

Okay.

So we’ll do that.

And then I’m going to do another connected in line.

Okay.

I had to make a little edit there.

So I’m going to just continue making this blue line.

So I’m going to do this.

And I have to update the values now.

the values now. So this 14 on the left, that should be the A node. So we’re going to see 48,

and then the new parent is going to be 55, and then the right child is going to be 65.

Always after you fill in these values, ask yourself, have I actually drawn a valid binary

search tree? If you haven’t, meaning if the data is out of order in some way, then you haven’t

drawn a valid binary search tree, and you probably need to try again. So we’ve got 48 and 55 and 60.

is are there any children that are unaccounted for in terms of the input nodes to the pattern

that we’ve just drawn down here, the output pattern.

So let me just kind of remind you that there could have been, you know, potentially some

nodes, right?

Like we could have had a right child of 65, we could have had a left child of 48, and

we could have had two children of 55.

So there’s always a potential for four nodes that are unaccounted for.

We’ll just check them one by one real fast here.

Look at the 48 first. The 48 had a right child of 55, but that’s already taken care of in the output pattern, so we don’t have to worry about that.

Now we look at the 55. We could go XYZ if we wanted to, but I like looking at the output pattern.

55 had no children, so that’s fine. And then we look at the 65. The 65 had a left child of 48, but that’s already in the output pattern.

So at this point, all children are accounted for. We don’t really need to do that much.

that were unaccounted for they would need to be attached under the 48 and 65 somewhere and each

child would only go in one place without an there’s only one place that the child could go

without invalidating the binary search tree but that’ll be i’m going to make a harder example in

the next video so now that we’ve done this we’re ready to reattach all the nodes are accounted for

that we’re about to remove from the diagram we’re not actually going to be deleting nodes or creating

creating nodes or anything like that in the code we’re really just disconnecting

pointers and reattaching them so I’m gonna just erase this from the diagram

but keeping in mind that the nodes are not really being recreated and I’ll just

put the 55 over here where the old trinode subtree was and then I’m gonna

recompute the balance factors for all of the nodes involved so you know I just

the output pattern someone put a 0 48 also 0 because their leaves the 55 it’s a 0 it’s perfectly

balanced that’s pretty sweet and now that we’re done with the nodes that we touched we have to

work our way up to the root node we don’t have to worry about anything over here on the left

because those nodes couldn’t possibly be affected by uh by the rotation we just did because only

nodes that are above the rotation will be affected so uh the last one we you know looked at was this

basically going to say all right 55 let’s look up one more parent it’s going to be the root node

the 41 so what’s the new balance factor of the 41 node it’s actually going to be better it’s going

to be a zero so with that in mind we’ve actually created a perfectly balanced binary search tree

this is definitely a log time tree super super fast and super super cool and what type of rotation

So we had XYZ. If you don’t have the rotations memorized, keep in mind my previous videos explain all of that with some fun ways to help you remember, hopefully. Maybe some unfun ways.

So I’ll just kind of like reiterate real fast here. There are two nodes that need to be moved into position. Notice how 55 is supposed to be the new parent node, which means the 65 needs to be rotated under the 55, and so does the 48.

And so does the 48. So the 48 and the 65 both are going to be rotated into position.

That means two nodes are rotated, which means it’s a double rotation, not a single rotation.

Which node was rotated first? I always rotate the Z node first, you know, the node on the very top.

And so I’ll just use the rotation direction of that Z node.

So that’s a regular clockwise rotation.

And that’s a right rotation, so this is a double right rotation.

you can do to remember is if you go from y to z you’re going up into the right so that’s a right

rotation you could also imagine that there is some negative space kind of sitting here on the right

side a little right pocket so that’s a right rotation and i’m sure there were some other ways

that i added in the other video but i can no longer remember them so i’ll just move on we’ll

say we did a double right rotation in order to get this uh this perfectly balanced binary search tree

research tree so I’m gonna cut the video here in the next video we’re going to I

think probably rotate a linear tree you can kind of see I’ve already started to

draw one here in the next video we’re gonna look at this like giant gnarly

linear tree and we’re gonna pretend that we have the ABL rotating disabled for a

while while we built this tree and then all at once we’re gonna turn it on and

do like a whole bunch of rotations and see what the tree is gonna end up

looking like it’s gonna be pretty ugly and fun anyway thank you so much for

Anyway, thank you so much for watching this video.

I hope you learned a little bit of stuff and you had a little bit of fun.

I’ll see you in a moment, hopefully.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

as you do on the current social media website that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able

to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I

know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you could troll me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, uh, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

Which I think is also named somewhere at the bottom of this video

And it’ll take you to my main website where you can just kind of like see

All the videos I published and the services and tutorials and things that I offer and all that good stuff and

and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

would really appreciate it so again thank you so much for watching this video and um enjoy the cool

Enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

Hello there.

Hi there.

Hi there. Let’s maintain a self-balancing AVL tree,

which is recursive. Hello there. Let’s,

The post How to Perform AVL Tree Rotations – Step By Step Example appeared first on NeuralLantern.com.

Learn AVL trees in this beginner-friendly introduction. We cover balance factors, why regular BSTs get slow, and how AVL trees stay balanced with rotations. Great for coding interviews and data structure understanding.

00:00 AVL Trees Introduction
00:00:28 Problems with Regular BSTs
00:00:56 AVL Tree Balance Rule
00:02:10 Balance Factor Explained
00:02:48 Computing Balance Factors
00:03:11 Example Tree Analysis
00:04:40 Imbalance at 65 Node
00:05:08 Invalid AVL Tree
00:06:18 Linear Tree Problem
00:06:50 Trinode Subtree
00:07:40 Selecting Z Y X Nodes
00:09:20 Rotation Overview
00:10:03 Next Videos Preview
00:11:09 Thank You and Subscribe

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about a type of self-balancing binary search tree called an AVL tree.

Okay, so by now I hope you’ve seen my other videos that I’ve posted

previously where we talked about binary search trees, how to define them,

terminology, how to know you’re actually looking at one, how to build them, insert,

If you finish those videos already with me, then you know that binary search trees can actually get slow sometimes because if we have bad data, regular binary search trees don’t really know how to rearrange themselves.

They just might become slow depending on how good or bad the data is.

The data is totally random.

Then on average, it’ll, you know, the trees will be log time, but that’s not always the case.

Maybe sometimes you have bad data, sorted data, poison data, whatever kind of data.

The secret to AVL trees is we’re going to start with the binary search tree.

And so first it has to satisfy all the rules of the binary search tree.

And then we add on another rule.

The rule is going to be that we don’t have a valid AVL tree.

If the balance factor for any of the nodes, we’ll talk about balance factors in a second.

If the balance factor for any node is two or worse.

Meaning if we think the tree is too imbalanced at any node, it’s not a valid AVL tree.

and therefore we must rebalance the tree with something called a rotation.

After we do enough rotations and we see that the tree is balanced again, then it’ll be valid.

And so AVL trees sometimes are invalid in some intermediate state.

Like if you have an AVL tree and you add some data into it,

for a moment it might be an invalid AVL tree and then internally it’s sort of just like rotating itself and rebalancing itself.

Then when the tree is done, you’ll have a valid AVL tree again, if that makes sense.

AVL tree again if that makes sense. So suppose this tree here we can tell this is a valid binary

search tree because it follows all the rules that we talked about before. So let’s start implementing

the first rule of an AVL tree which is let’s compute the balance factors for every single node.

How do we compute balance factors? The basic idea is I want to say BF for balance factor

the left subtree height minus the right subtree height.

If you don’t know what a subtree or height is,

you should probably check out my other videos right now.

But basically, we’re just going to take the absolute value

just to get the difference in the height of the left

and the height of the right.

So if you know binary search trees already,

then you know that the leaves, they don’t have any subtrees.

So their balance factor is going to be pretty easy to compute.

It’s just going to be a zero.

I should also point out that some other tutorials out there use positive and negative numbers

for the balance factor.

That’s okay.

I’m just going to use absolute values here because it’s a little bit more simple.

So all the leaves get a balance factor of zero, which is fine.

We’re looking to see if we can find a balance factor of two or worse to indicate to us that

we have an invalid AVL tree.

So far, so good.

Let’s look at the 22 node.

we’ll compute the height of the left subtree versus the height of the right subtree.

So, you know, I’m going to highlight its left subtree.

That’s just the 14 node that has a height of 1.

And then its right subtree is just the 36 node that also has a height of 1,

which means the balance factor for the 22 node is the absolute value of 1 minus 1 is 0.

So actually the 22 node is perfectly balanced.

If you think about it, that makes sense.

Left and right subtrees have the same height.

No problem.

have the same height no problem so I’m going to move on let’s compute the balance factor for the

48 node this is a little trickier notice how the right subtree has a height of one and there is no

left subtree which means its height is zero so for the 48 node it’s actually going to be

the absolute value of zero minus one or just one so we find our first node that’s a little bit out

imbalance here but avl trees tolerate imbalances of one they don’t really care we sort of try to

make a trade-off between constantly always rotating every single time anything happens

which would perhaps burn a little too much cpu versus letting the tree just be imbalanced to a

reasonable amount so we could still call this a log tree in the end so we consider this to be okay

65 node and compute the balance factor so 65 node has no right subtree so the height is zero there

and its left subtree is those two nodes on the left so that has a height of two which means the

balance factor for the 65 node is going to be the absolute value of two minus zero is two at this

point we are already certain that this is not a valid avl tree and it would need to be rebalanced

you know, consider it a valid AVL tree in the future.

So invalid AVL tree, still a valid binary search tree.

Something has to be done.

Normally what I would say is if you find some nodes

way down lower in the tree that are imbalanced,

then just go ahead and perform a rebalancing

or a rotation immediately,

because sometimes when you rotate lower in the tree,

you’ll end up fixing nodes that are a little higher.

But since we started with this tree

and we’re not kind of, you know,

building a tree step-by-step,

I just want to compute the balance factor for all of the nodes at the same time.

So we’ll do the same thing for the 41 node, the root node.

Its left subtree has a height of two and its right subtree has a height of three.

So its balance factor is the absolute value of two minus three is one.

So actually the root node is okay.

If it was only up to the root node, we would say this is a valid AVL tree

and we don’t really need to do anything.

need to do anything however we’ve already seen that the 65 node is invalid so again uh we we

need to do something here’s another quick example before we move on to actually identifying which

nodes to to modify and rotate just real fast i want to show you you know that a binary search

tree could actually end up being a linear tree if you had really really really bad data the binary

This is slow because this is a linear tree.

The time complexity of searching through this tree is linear time.

It scales linearly with the number of nodes in your data set.

That’s really far away from log time, which is supposed to be lightning fast.

So an AVL tree will fix this kind of bad data.

Let’s take a step back here and focus your attention for a second on these three nodes.

We noticed that there is one node that’s actually out of whack.

It’s the 65 node, right?

What we’re going to do is we’re going to find a trinode subtree that starts with the first node or the lowest node we can find that’s out of whack.

It’s the 65 node.

And you can tell that if we just kind of go down a level and down another level to select the other two nodes,

it’s just going to be this little, you know, subtree of three nodes or otherwise known as a trinode subtree.

So here’s kind of a diagram for that.

Whoops, forgot to delete that earlier.

Let me get rid of that.

So this is the trinode subtree that we selected, right?

So we’ve got the 65 and the 48 and the 55.

How did we actually select this?

So what you kind of want to do is the first node that is out of whack,

you want to call that Z.

So I’m going to write a Z here.

What we’re looking for is a trinode subtree,

which we’ll first call X and Y and Z.

And then we’ll end up reordering the nodes

and then rearranging all the pointers to the nodes

so that the trinode subtree is a little bit more in balance.

more in balance. So we see the Z node. We have to find the Y node next. To find the Y node,

what’s going on with my computer? Oh, there we go. We have the Z node. To find the Y node,

really, we’re just going to take the child of the 65 node that has the taller subtree. So

there’s only one subtree, you know, on the left, there’s no subtree on the right of the 65 node.

So the choice is obvious. But just so you know, if there was, you know, another, you know, child

another you know child hanging off of the right for some reason we would still choose the number

48 node as the y node because it has the taller subtree notice how the subtree on the left is two

and the subtree on the right has a height of one so always take the taller subtree when you’re

looking for uh y and then x so then we do the same thing we go down to the grandchild of the z node

and if we had a choice to go left or right again we would always choose the taller subtree in this

taller subtree in this case there’s only one choice so that x node is going to be the 55

now in this next slide i’ve kind of redrawn this in a little bit different of a way

notice the trinode subtree that we just selected here the 65 48 55 subtree it has a height of three

i mean that should be obvious right it’s just got a height of three

or height. Notice on the left, these are the same three nodes. Exactly. 48, 55, and 65. That’s the

same three nodes that we originally had. But notice how the height is too. So the basic idea for ABL

trees is, you know, compute the balance factors. And as soon as you identify a node that’s out of

whack, you grab a tri-node sub-tree starting at the node that’s out of whack, the Z node.

And then we’ll perform, quote unquote, a rotation where we just kind of smoosh it to be a little

be a little bit more balanced and a little bit more a little bit shorter so the height goes from

three to two once we do that the rest of the tree it’s going to get a little bit better you’ll notice

that this will end up sometimes completely but sometimes partially fixing bad balance factors

in the tree so um this is the end of the intro i only wanted to spend a little time just kind of

like warming you up to the idea in the next videos uh we’re going to actually look at performing

identifying the four different types of rotations that you could see and like how to do them.

We’ll talk more about the idea that we’re really just rearranging pointers here.

If you’re thinking about code, you’re thinking about, oh, I’ve got some pointers between these

nodes. We’re not going to delete any nodes or add any nodes. We’re just going to like

rearrange who is a parent of who, who is a child of who. And then eventually we’ll deal with some

really bad trees and we’ll become experts at just like maintaining ABL trees.

talk about ways to visualize the rotations, which makes it a little bit easier to remember these

patterns and stuff. Okay, so thank you for watching this video. I hope you learned a little bit of

stuff and had a little bit of fun. In the next one, we’re going to get started. We’re going to

go deep. I’m going to get my gear. Sorry.

Hey, everybody. Thanks for watching this video again from the bottom of my heart. I really

from the bottom of my heart. I really appreciate it. I do hope you did learn something and have

some fun. If you could do me a please, a small little favor, could you please subscribe and

follow this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now? It would really mean the world to me and it’ll help make more

videos and grow this community. So we’ll be able to do more videos, longer videos, better videos,

Do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website.

in order to go to the website which i think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos i published

and the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know

I also wake up for those in the middle of the night. I get I wake up in a cold sweat and I’m like

it would really it really mean the world to me. I would really appreciate it. So again thank you

so much for watching this video and enjoy the cool music as I fade into the darkness

which is coming for us all.

Thank you.

The post AVL Tree Tutorial: Balance Factors and Why They Fix Slow BSTs appeared first on NeuralLantern.com.

Get hands-on with x86-64 YASM assembly in this in-depth tutorial on writing functions! Perfect for beginners and seasoned coders, we cover the basics of function creation, calling conventions, argument handling, and return values. Learn to avoid crashes, respect the ABI, and use prologue/epilogue for clean code. From printing messages to returning integers, see practical examples and tips to simplify your assembly programs. Subscribe for more low-level programming tutorials and take your skills to the next level!

Introduction to Functions 00:00:00
Makefile Overview 00:00:19
Assembly Program Setup 00:02:01
Data Section Definitions 00:02:08
Text Section and Entry Point 00:03:02
Basic Assembly Program Demo 00:03:38
Return Codes Explained 00:04:30
Function Concepts Introduced 00:06:10
Creating a Simple Function 00:07:04
Function Call vs Jump 00:08:00
Adding Return Statement 00:09:06
Moving Print Logic to Function 00:09:48
Benefits of Functions 00:10:01
Calling Function Multiple Times 00:11:58
Creating Print Function with Arguments 00:14:00
Handling Function Arguments 00:15:45
Respecting the ABI 00:17:16
Prologue and Epilogue 00:23:15
Stack Operations 00:24:34
Calling Print Function 00:25:25
Avoiding Recursive Loop 00:34:17
Modifying Print Function to Print Line 00:35:21
Adding CRLF Function 00:30:13
Printing Multiple Messages 00:37:00
Returning Integer Values 00:37:48
Preserving Registers in Entry Point 00:41:50
Final Program Demo 00:43:24
Conclusion and Call to Subscribe 00:45:16

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there! Let’s talk about functions in x8664 Yasm Assembly.

I’m just going to give you the basics of how to write a function.

So let’s get started here. First thing I want to show you is just a makefile.

This is not a makefile video, so you don’t have to worry about it too much.

I just have it up because I need it for this demo.

If you’re interested in makefiles, that would be a really, really good thing.

thing i’ll probably make videos in the future about them but for now we’ll just say you hopefully have

a script or method already set up that allows you to compile or assemble assembly programs

so i’m just going to skim through it real fast if you’re interested you can kind of study it

but basically i have like a little define here that allows me to print out a message that looks

nice and then i define the repo path as the current path and i take the absolute path of that

This is where the real work happens.

I have Yasm flags because I’m using the Yasm assembler.

I’m going to be assembling to x86 64.

I like to out.

I like to convert all of my warnings to errors to make sure that I don’t write sloppy code

export debug symbols and export debug symbols for the linking stage to the name of my executable

is going to be called a main.

have set up and well I can just do make run or make debug as a little shortcut

to run it in GDB if you don’t know GDB don’t worry that’s going to happen in a

future video and make clean which just cleans the build area I like a clean

build area and then this is the main command here we’re going to be using LD

to do our linking because this is going to be a pure assembly program instead of

a hybrid program which would require GCC or something else and then here’s my

And then here’s my program main ASM is going to get compiled down to main.o and

That’s it for the make pile

Okay, so for the main assembly program I have some stuff written up already here, but I think I’m going to modify it for this video

For starters, we have our data section which hopefully you understand already

I’m just going to define a bunch of stuff in the data section like I’m going to define

The system call code to write a string so I can print a message pretty easily

so I can print a message pretty easily the system call code to actually exit the program

remember when you’re writing a pure assembly program that has start as an entry point

you need to be you know you’re responsible for exiting the program so the system call code is

60 there and then I’m going to say exiting for success is a zero that’s kind of a standard thing

and then I’m going to make two file descriptors for the standard input it’s going to be zero and

the standard output it’s going to be one actually I don’t think we need that for this video we just

We just need standard output, but not standard input.

And then I’m just going to make two strings.

That’s not my name, but I like those names.

And then the BSS section.

Actually, I’m going to get rid of that

because we don’t really need that for this video.

And then I have a text section, which is where all the code is.

We’re going to begin our entry point.

If you are writing a pure assembly program

and this is your entry point module,

make a function called underscore start.

It’s not actually technically going to be a function because it won’t return anywhere.

It’ll actually just call the system exit service.

And then I mark start as global so that the operating system can go into it,

can call it from the outside.

And then all I’m doing right now is I’m printing a hello.

So far, this is not really a demo of functions.

This is just like a very basic pure assembly program.

All it’s going to do is it’s going to enter.

going to print the hello message and then down here it’s going to do a system call to exit the

program with zero for success so let’s just see what that looks like real fast I’m going to do

make run and then make run you can see the first line it just kind of prints and then the second

line that’s make sort of echoing the command that I’m issuing it’s just going to assemble the main

dot asm into a main dot o and then it’s letting me know that if there are any warnings it will

It will refuse to compile.

And then I use the LD linker to link the main executable.

And then I actually run the executable.

So only below this line that I have highlighted right now

is gonna be the actual program.

So you can see all it really did was just,

you know, print the message and then exit.

Just, you know, a little note here.

I’ve probably said this in other videos,

but the return code zero is kind of a standard

to indicate success for programs,

which is very useful if you want programs to automate other programs.

If I change the system, let’s see what is it, exit success.

If I just change that variable to a 3 so that I will exit with a return code of 3 instead of 0,

then the operating system, or actually bash, since we’re in a terminal emulator,

should consider the program to have exited in error.

So you can see now it’s like, hey, hey, hey, the makefile system,

oh not bash, the makefile system is like that program exited with code 3,

three something went wrong and normally if you don’t add any extra stuff into your make file it’ll

just refuse to continue at that point well so i’m just going to change it back to a zero and make

sure that it still works and then we’ll get on to actually writing functions so i’m going to go clear

and make run so it’s a little bit faster for me to run this repeatedly you can see actually the

first time that i did that um the make file recompiled notice how it recompiled um and

and relinked because I changed that source code.

This is not a make file video, but I just want you to be aware.

One of the great reasons to use make or a build system in general

is because it makes it really easy to compile your code faster.

Notice how if I didn’t actually change, let’s see.

So I recompiled it because I just changed it again,

but now I haven’t changed it since I’m going to recompile or rerun.

Make just kind of like skips reassembling that file because it hasn’t changed.

it can make your compilations and assemblies much, much faster.

So anyway, functions. Functions in assembly are kind of simple and you’ll realize that

some of the stuff that we take for granted in higher level languages is being done for us

automatically by the compiler. But in assembly, we have labels. So for example, this start entry

some valid symbols like characters underscore numbers I don’t think you can start a label with

a number correct me if I’m wrong but I don’t think you can so we have like a label which is just like

this collection of characters and then we have a colon after it and so you can jump into a label

which I’ll talk about in a different video but you can jump into a label you can call a label as a

function and so a label isn’t actually a function by itself you have to treat it in a certain way

the abstract so notice how there’s no return statement at the bottom here let me write a

function real fast and maybe i will have it so that i have a function that just says hello for

me so i’ll make a label down here function that says hello and i’ll give it a label and i’ll say

maybe like say hello and i’ll do a little label there first thing that you should do when you are

trying to create a function is just put a return statement at the very end of it.

That way it will return to the caller because if you don’t then it’s just going to continue

to execute downward until it reaches no code and then the program will probably crash. In fact

maybe I should do that. I’m going to do say hello as a label with no return so it’s not really a

function now. It’s more of just like a label that you can jump to but there’s no code under it so

I’m not even sure this will assemble, but it’ll definitely crash if we can call into this.

So let me do, at the very start of our program, I’m going to type call say hello.

Or actually, you know what, maybe first I’ll jump to hello.

Jumping is going to be for a different video, but jumping just means go to that place.

It’s a go-to statement, essentially.

You’re not supposed to be able to return from a jump.

but it doesn’t really follow the same design pattern logic as a function.

So I’m going to immediately jump to the say hello logic and see what happens.

I think that it’ll crash.

Here we go.

SegFault, core dumped, oh no.

So, hey, it crashed.

So instead of jumping there, let’s do a call.

Now we’re treating it a little bit more like a function.

We still don’t have the return statement down here.

So it should still crash, I think.

Let’s try that again.

Yep, it crashed again.

Because you’re supposed to exit from the operator, or you’re supposed to exit from the program

properly to the operating system.

So now I’m going to do a return statement here.

There’s never an argument for the return statement.

You just simply return to the caller.

This uses the stack.

If you don’t know what the stack is, I’ll probably make another video about that in

the future.

But the stack, you know, it helps your program understand where it just called to and how

to get back from it.

to get back from it it also stores local variables and things but so if i have a call it should jump

down to the hello function and then return meaning it’ll just return to the caller immediately without

actually doing anything but the program should be able to continue without crashing notice how

there’s no crash here all it does is print out the welcome message and then no problem all right

printing stuff and I’m just going to cut it and stick it inside of the say hello

function that way when I call that function it should still print hello but

now notice how we have less code to deal with in this primary function you know

one of the first things that that programmers learn is that you know we’re

human beings we’re not computers it’s really hard for us to write complex

logic in a program without tools to help us and design patterns to help us to

help us stay on track to help us you know make sure that we’re not going to

we’re not going to be forgetting anything or screwing something up or you know to debug so

you know one awesome design pattern is to write functions because you you you realize in your

program you might be calling the same logic several times so you’re sort of like repeating a bunch of

code that already is bad it’s really hard to debug repeating code and it’s really hard to make updates

to it and it becomes unwieldy right so as soon as you realize you’re repeating the same logic

places you should think about taking it and putting that logic into a function

and then just simply calling that function many times it makes your coding

a lot easier and then once you put all the work into getting a function to

work you’re just you can just be done with it as soon as you’re sure that

this function actually works you can just put it to the side and just forget

about it you can stick it at the bottom of the source or just ignore it put it

into a different module whatever you want to do and then the other parts of

of the program that you’re still working on they become a lot more simple and so you know because

we’re human beings we need all the advantages we can get to write powerful code so i am now just

i’m not i don’t have to think anymore about all the system call things that’s happening

to print the hello message all i have to do is think about calling the say hello function

and of course this is simple but you can imagine using this for more complicated

concepts in the future so let’s see if this still works if i didn’t screw this up

It printed the same exact message.

And if I keep running it, you know, the make file doesn’t compile as much, but it still

runs the program.

If you don’t believe me that this is inside of a function now, let’s actually just call

that same function many times.

We’ll call say hello.

Let’s say we call it five times.

This should work.

I’m going to run the program again.

Notice how it printed that message five times.

Just to reemphasize my earlier point, wouldn’t it be a huge pain in the butt if you wrote

all the code for the system call and the message printing five duplicate times?

Wouldn’t that be hard to update? What if you had a hundred of those in there?

What if you had something that was really complicated and you called on it like

50 times,

wouldn’t that be so much better than maintaining 50 different versions of the

exact same idea of code and, and, you know,

making sure that if you needed to upgrade it or change it in some way,

you actually got it right for all 50 copies. So this is way better.

All right. So that’s the basic idea for a function.

for a function let’s see what else can i do um let’s let’s make a function that just prints

anything because that would be kind of a good little practice in the uh in the arguments that

we can use remember in c plus plus and other languages you have function signatures that

you can use so for example say hello we know for sure that say hello is not actually doing anything

it’s not receiving any arguments and it’s also not returning anything so if we know it’s not

returning anything. So if we know it’s not returning anything, we can say that it’s a

void function if we’re talking C++. We’ll do the name here. We’ll say say hello. And in the

argument list, we know that it doesn’t take any arguments. So it’s just say hello with nothing,

right? Okay. So let’s make another function that just prints something. And this function will

kind of be a little redundant because if you just sort of look at the system call here,

we have to load up the system call with the standard output and the system write code.

So that’s going to be repeated.

So we could move that into the print something function, but then, you know, giving an argument

of like, here’s the string I want to print.

And here’s the length of the string that I want to print that, that is something that

we can pass as arguments every time.

So we’ll be saving like a little bit of work, but it’s still, I think, I hope illustrates

the idea.

Maybe we will, oh, print something.

Okay.

So print something.

Maybe we’ll do the signature here.

Print something will not return any value.

So we’ll just give it a void return type.

And I’ll do a description up here.

Print a message given by a character pointer.

A pointer to a string.

character is also a pointer to a C string, not a regular string class, but a C string.

So I don’t know how to describe it. I think I’ll just say a pointer to a C string

and length and integer length maybe. So that means the print something function should take

two arguments. We want to be able to call that function and tell it, here’s a pointer to the

string I want you to print. And here’s how long the string is. So still talking about C++, I’m

character pointer p and maybe i’ll put like string just to remind myself when i look at this later

it’s a pointer to the string or like p char for the pointer to like the first character in the

string something like that and then length so the length is going to be a long because we’re using

64-bit integers in this video long and i’ll just say maybe size or length or something so now we

I want to use the same symbol that I’m describing in this little prototype here.

So I’m just going to copy paste it and use a colon.

And then because it’s a function, I immediately want to put a return statement at the very end.

Okay.

So then what I need to do is grab the incoming arguments.

Okay.

So, well, the first thing that every system call that prints a string should do,

at least if it’s going to print it to standard output,

to print it to standard output is it should start setting up the system call code registers or the

system call registers to say all right the system call wants rax to describe what the system call

is going to do we already have system write set up so that just means we’re telling syscall that

we want to print something where do we want to print it we want to print to the standard output

which if you look at earlier in the video that was just a file descriptor of one so that’s fine

up the system call and then the next two things can be kind of variable uh you know we can we

can grab that from incoming arguments so rsi wants a pointer to the string we’re not going to load

hello string but we’re going to load whatever character pointer we were given in the incoming

RDI is the first incoming integer argument.

We’re not going to talk about mixed arguments with floats.

If we just assume that we’re only going to use integer arguments or pointer arguments,

then the first one is going to be RDI.

So that means by the time print something gets called,

by the time we come into this code right here,

RDI should be loaded with the pointer to the character to the C string that we want to print.

Again, this follows something called the ABI, which you should absolutely respect,

which you should absolutely respect even if you’re the only one writing any of the code that you

interact with your code will be bad and considered not good if you don’t respect the abi on this type

of architecture so we definitely still need to load rsi with the string pointer but art whoops

but rdi is what’s going to have the string pointer so we actually already just ruined rdi when we

probably either load it up backwards or i think probably a better way to explain functions is

let’s just use another register so i’m going to use another register to sort of store our incoming

arguments i personally like to do this i admit that this will cost you cpu cycles to sort of

like move things around in registers but it’s still way faster than sticking something into

a global variable because then you’ll be hitting memory so first i’m going to say let’s move

to r12 and I want to store the incoming argument so I’m just going to write here save the

the p care you know c string character pointer or something like that so we’re going to save it

and then the next thing we need to do is save the size because as soon as we load up rsi we’re also

going to be destroying the second integer argument which should come to us in rsi

Okay, so I’m going to save that too, I guess, with R13.

So I’m going to move something into R13, RSI, and then save the size of the C string.

Okay, so we saved both of those.

Now, when we load RSI, we can just sort of say, RDI is saved.

And then when we load RSI…

Oh, that’ll be when we hit RDX.

Oh, that’ll be when we hit RDX. Okay, I got confused. So we stored R12 was the character

pointer. And then for the length of the string, we stored that as R13. Also for me personally,

I feel like it’s a pretty good idea to kind of make a comment at the very top, because this is

assembly. It’s really, really hard, right? Make a little comment at the top, just kind of reminding

yourselves what you use all of the registers for. I know sometimes you’ll use the same register for

sometimes you’ll use the same register for multiple purposes.

You could either write that down

or you could consider breaking up your function

into multiple functions.

That’s totally valid

and it probably will make your life a lot easier.

Anyway, so I’m gonna say register usage

and then I’m gonna say R12 pointer to string, C string.

And then I’m gonna say R13 is gonna be

size of the string. And that seems simple but remember assembly especially when you’re new

it’s really confusing and for me when I was first learning and even sometimes now I’ll be staring

at a big blob of assembly code and I’ll just be like what register was I using you know or I’ll

look at a register and I’ll be like what was that thing even for? So just make yourself a little

comment up here to help you understand and then you’ll thank yourself later when you get a little

a little bit too overloaded or maybe even if you come back to your code a month from

now probably having totally forgotten what you even wrote then you’ll just have a nice

little reminder here.

It’s good to document and this is one of the ways that I recommend.

Okay, so we’re saying that R12 and R13 are going to be used.

We’re loading them up here from the incoming arguments.

Now RDI and RSI are free to be destroyed if we want and of course we have to destroy them

because RDI and RSI were incoming arguments when this function first came in but now that

first came in but now that we’re going to be doing a system call we have to use

them for incoming arguments to the sys call so they’re just they’re just meant

to be constantly destroyed so we’re gonna do call code there and then the

standard output is gonna be the first argument and then the string that we did

which is an r12 is going to be the second argument and then rdx is going to

be the next argument which is r13 which came into us through the second argument

wait wait wait the string to write came into us through the first argument the

came into us through the second argument but if you just kind of look at what we’re doing to the

system call it’s actually the second and the third so I mean just forget about it okay so we set all

that up let me make sure I’m not forgetting something by scrolling up real fast yeah so now

we can do a system call one other thing that’s very very important about functions is you have

to respect the ABI and that doesn’t just include using the right registers for incoming arguments

out a call but you also have to keep in mind which registers are denoted as callee saved

if something is callee saved then that means you know if i’m inside of print something

i’m being called that means i’m the callee so that means if i’m going to use r12 and r13 which

are designated as callee saved maybe i’ll pull up that my favorite assembly book after this

but if i’m using registers which are designated as callee saved then i have to preserve those

then I have to preserve those registers, meaning those registers,

they should have their same values from when they first came in on the call

when I exit the function. So when I exit the function, those registers,

register values should appear to be untouched to the caller.

Remember these registers are not local variables.

They’re global to the entire system. There’s only one R12 on the whole CPU.

So every program that runs every function that gets called,

see the same exact R12 register. So if we’re not careful about preserving when we have to,

we could end up crashing other programs or our own program. So anyway, let’s do something that

I like to call the prologue and the epilogue. That’s another nod to my favorite assembly book,

which I’ll probably show at the end of this video. So prologue is just, hey, let’s preserve

the stuff that we need to preserve. We will preserve the R12 with a push and we will preserve

and we will preserve the R13 with another push.

We then have to restore them.

So right now when we do this push,

that just means that whatever value R12 and R13 had

is going to go to the stack.

So we’re going to hit memory.

That’s not great, but like we have to in this case.

We’re going to push it onto memory

in order to preserve the value.

And now we’re free to destroy the value if we want.

And then right before we return,

we’ll just pop those values.

So that means we’re going to go to memory.

We’re going to go to the stack.

to go to the stack we’re going to grab the values that we just pushed and put them back onto the

registers oops forgot to do 13 and 12 and I’ll call this the epilogue just meaning like we’re

done we’re cleaning up and of course look very carefully at the fact that the push and the pop

sequence are in reverse order notice how we push 12 first and we push our 13 second then at the end

Then at the end, we pop R13 first, so it’s backwards.

It’s like a little shell, you know, the R13s are on the inside

and the R12s are on the outside.

That logic would persist if we pushed,

or if we had to preserve more Kali saved registers,

if we were using more stuff.

The reason we do that is because the stack as a data structure

will return data to you backwards in the reverse order

that you returned it or that you sent it into the stack.

it into the stack so if i send a 12 and a 13 let’s just say the number 12 and the number 13

into the stack then if i start popping stuff out of the stack it’s first going to give me the most

recent item which is going to be the 13 so it’s going to give me backwards data and then it’ll

give me the art the 12 seconds so um the type of data structure a stack is is first in last out

last out no that’s a that’s a queue anyway so we’re preserving the registers we’re doing the

system call we’re probably okay to call this function now so let me see if i can do this

i’m going to comment out all of these things that the the say hello function does and i’m just going

to call on print something in order to call that function but i have to load up my arguments i have

pass arguments remember in the print something function it’s got a signature

it wants a character pointer and a size we can’t just call it without giving it

those things or it’s going to look at the registers anyway and just grab

whatever junk data happened to be in there so that would be bad so first we

have to load up the registers load up argument registers and call print

load up the argument registers and call print something.

So the first thing is going to be RDI, so we have to move something into RDI

and then the second register for the second integer argument is going to be RSI.

As far as I recall, if I’m wrong this is going to go horribly wrong.

I’ll double check the book after this.

And what do we want to do?

We want to basically, inside of say hello,

we could assume for now that say hello hardcodes the pointer and the length.

So we’ll just say it’s going to grab the string from global and it’s going to grab the string

length from the global variables.

So it’s going to load up those two arguments and then call on print something.

This still ends up being three lines.

That’s why I was saying before, we’re not going to save too much, but we did save, you

know, these two lines right here, you know, and the system call line.

So it’s like slightly faster to do.

You just load up two pointers and then you make a call.

in this video so I can’t really make the function better but in the future when

you learn how to loop and and learn about null terminated strings you could

basically just pass a pointer to just the string only and then call on a

function if the function was smart enough to scan through the string and

figure out how long it was based on where the null terminator was but that’s

gonna happen in another video anyway so if we call print something it should

Notice also that we’re having a function call another function, which is pretty cool.

So we have our entry point, it’s going to call on say hello, and then once we’re inside

of say hello, we’re just going to load up some arguments and then call on the print

something function.

The print something function then does most of the work for the printing, and I think

we’re ready to go.

Let’s see if this works.

All right, so we’re going to clear and then just run the program.

Oh, that was so fast.

That was so fast I don’t even feel like I’ve proved anything.

Let’s comment out the system call so that all we really do is just load up some registers

and then don’t do anything.

And then you should see here that the print something function no longer actually does

anything because it was too fast.

Now if I uncomment the system call, you know that the print something function is actually

doing something and it’s printing the message five times.

We can also make some more messages if we wanted to,

just as a way to make this video slightly more interesting.

I’ll say msg1 is going to be a string of bytes,

and I’m going to say this is message number one.

Boring, sorry.

And we’ll do a crlf there.

Actually you know what, let’s make a function that does a crlf.

Okay, let me just finish message one length,

and we’ll do it equals that special string that you can do in yasm am i doing this right yeah okay

so this is message number one so now we’ll call again with message we’ll call say hello just once

and then we’ll call on print something loading it up first move something with rdi and then move

message one is that what I had message underscore one and then RSI is going to

get message underscore one length so basically we’re just you know print the

first message it’s always a good idea to put comments on each line when you’re

learning so that you don’t forget what’s happening in addition to like a comment

for the whole block but I’m not going to do that here let’s just make sure that

make sure that this actually works so it should print two different messages now

one okay nice let’s enhance this a little bit more later i think i’m going to have us print like a i

don’t know a character or maybe we’ll do a return value from something so we can just show you how

to do the return values but i’m just going to enhance this a little bit more we’re going to say

let’s make another function we’ll call it crlf the crlf function i don’t want it to do all the

system call stuff because print something already does that for us i’m instead just going to make

message so now that means i’m going to go crlf and that’s just going to be a 13 and a 10. remember

you can define a c string with quotes but you can also separate quoted strings by commas and also

integers just to sort of tack it on so you know this variable right here it’s going to be a

sequence of characters representing the string that you see and then at the very end of the

string it’s going to have a crlf carriage return line feed so that the cursor goes to the next line

goes to the next line so I’m actually gonna take that off of message one

because it’s gonna be here just on CRLF and then I’ll say CRLF length is gonna

be two I could also do that special thing probably a little smarter CRLF

yeah I mean it’s it’s better to avoid hard coding things if you can avoid

hard coding the number two or any number just do it I guess I have to hard code

So, so CRLF and then length.

And so that means in my CRLF function, let’s see, let’s do CRLF, CRLF immediately return

because it’s going to be a function.

I’ll just say void CRLF with no arguments and prints a carriage return new line, also

known as CRLF.

and so that just kind of describes it and I don’t need to preserve RSI and RDI

because those are not callie saved registers so respecting the ABI kind of

helps you in this case I’m just gonna copy paste here and maybe I’ll copy

paste that comment real fast too so I don’t have to like type that whole thing

out and instead of doing hello string we’ll just say CRLF and then for here

And now when I call CRLF, it should just make the cursor go down a little bit.

So let’s test that out.

I took the CRLF off of message one.

So if we actually run this right now on modified, it should have the cursor.

Now, what did I just do wrong?

On number 28 and 29, instructions expected after label.

I guess I forgot to complete something.

Oh, I forgot to put, it’s a byte sequence right there.

there and I forgot to put that this is basically a defined sequence you know

that EQU okay my bad okay so now it prints notice how the message line it no

longer does a new line and no longer jumps to the next line CRLF so that

means when the program exits the terminal prompt is on the same line as

the program just printed that’s ugly and awful so let’s call

We could either say, let’s call CRLF after printing the first message,

or we could just assume that print something is like print a line.

I don’t know how you feel,

but I think if we always called CRLF after every time we printed a message,

I would probably be a little irritated.

So maybe let’s change this to print line and then make it call CRLF.

You can just keep adding this like 1013 at the end of every string, but I think I want

to try to make this as compact as possible.

So let’s add the CRLF for now and then we’ll change print something later.

So we print the message.

Now the prompt should be, you know, a line further down.

So great works.

I am now going to take the CRLF off and I’m going to put it inside of print something

so that right after we do the system call to print the string in question, we’ll print

we’ll print a new line this should now accomplish the same thing that we just saw

oh no what did i do i think i did uh i think i have a infinite loop of recursive calls in there

somewhere i had a stack overflow probably so let’s see what did i just do say hello is call

print something and then crlf is call print something oh whoops print something calls crlf

at the end so i should do one or the other and not have them call both so maybe just because crlf is

special maybe i’ll just use a direct system call inside of crlf i thought i was so clever

but i was wrong so we’re going to repeat a little code for the crlf and we’re going to load it up

with um crlf dang how embarrassing i like to say this is the most public of my many humiliations

of my many humiliations. But anyway, so now we don’t need to rely on print something. So this

won’t be an infinite loop and it should work if print something calls on crlf now. Do it again.

Okay, it works. So now let’s modify print something so that it is just print

a line. Print a line. And then that, in my eyes, you don’t have to do it this way. It sort of

to do it this way it sort of justifies printing a crlf at the end every single time so this is

just my personal thinking and then maybe i’ll add a comment after prints a crlf

so now when we call print line we no longer have to call crlf

and then when we print that message should be pretty good oh we got to update that to print line

Then for say hello, let’s just double check.

We can get rid of this system call code here.

Probably a good idea at this point.

And then we just say print hello string.

And then from the hello string, we can get rid of this CRLF at the end of it.

So I’m just going to get rid of that.

Actually, let’s do it first without getting rid of it.

Just so you see, oh, what did I do wrong?

Lion 61, forgot to update the symbol name.

Oh, there we go.

call print line because we don’t have print something anymore and try it again notice how

the first message hello my name is it has two line feeds after it because it is calling print line

which will do a crlf but then also in the string itself there’s a crlf so again the point is i’m

to my advantage.

Okay, so we got that working now.

I’m just going to print like five different kinds of messages.

How about three?

So we don’t have to sit here and watch me typing for too long.

So I’m going to say message two and then I’m going to do message three.

Message three.

This is message three unless I got that wrong.

One, two, three, one, two, three, one, two, three.

Now we can just call a print string on three different messages.

And I’ll just change this to say, you know, print the second message, print the third

message.

And then I’m going to change that to message two and then message three.

All right.

So then I’m going to do that again.

And then all three messages get printed.

Nice.

So now one more thing.

I just want to show you how to return an integer to the caller in a basic YASM x86 assembly function.

Again, this will not cover floats.

This does not show you how to return floats.

With floats, you have to use a different register called xmm0.

That’s going to be a different video.

But for now, I’m going to say all integer or pointer return values, like longs is going to be what we’re using,

that is the register that is designated for return values.

So what about this?

Instead of just returning the exit success code

that I’ve defined up above,

we’ll return whatever some function call gives us.

Maybe I’ll make another function down here

and then I’ll say a function

that just returns a simple long value.

And we’ll call this function gimme long.

We’ll call this function gimme long.

It’ll take no arguments because we’re just keeping this simple for now.

And instead of having a void return type, it’ll have a long return type because we expect

RAX to be loaded up.

So then I’m going to say gimme long and immediately do a return because it is a function.

And then I’m just going to load up a value from somewhere.

Obviously, it’s better if you’re doing something complicated to stick with registers as much

or defines and hit memory only if you need to.

And try not to hard code immediate into your code

if you can possibly avoid it.

It’s probably a lot better to define a value up at the top

in the data area than to just hard code it here.

But I’m gonna just hard code something here.

No, I always second guess myself.

I’m gonna say exit gimme.

I’m gonna define something up here.

So it’s easy to find what value I’m gonna return

for the gimme.

I’m just going to say 88, 89, 90, I don’t even know.

About 33, I don’t even know.

So we’re defining exitGimme as a symbol

to just be a replacement of just the number 33.

So down here, I’m going to say,

let’s have gimme long simply return exitGimme into RAX.

Nice, okay.

And so that means it’s the official return value

once you call gimme long.

call gimme long so that means up here get our whoops get out it’s coming from inside the house

get our return value from gimme long and again imagine gimme long might be a big complicated

function that decides what a return value is going to be or does something so i’ll start with saying

call gimme long because gimme long does not take any arguments i don’t have to load up any registers

load up any registers nor do i have to worry about preserving them or setting them up or doing

anything i just call but then let’s see inside of this function we’ll use rax in order to you know

load up the system call to let it know what function or sorry what function we want from

the system call so we got to give rax system exit so that means down here we can’t actually use rax

those other registers again I’m going to use I’m going to use the r12 register

I’m going to do like a little comment here that says register usage and I’ll say r12

maybe I’ll do a tab r12 is going to be old return value

or the syscall to exit you know whatever and that’s all we’re going to do so in the prologue

I’m going to push R12.

You should probably even preserve registers in the start function

because something might, or in your entry point,

because something that called you might be counting on those registers.

This is going to be probably especially true if you’re using GCC

to have a main entry point within a hybrid program.

So I’m just going to go prolog, push R12,

and then pop R12 at the very end.

Pop R12.

That’s not going to work because by the time we get there,

because by the time we get there,

it’s gonna exit the program.

I’ll do this here.

I’ll just try to be a good citizen.

I’m not actually sure if we need this

for a pure assembly function,

but it’s just a really good habit to get into.

And what is it gonna cost you?

Just a touch memory,

just one time right before the program exits.

It’s not gonna be a giant for loop or anything.

Okay, so epilog,

probably I might be showing you bad practice

by preserving things in the underscore start function.

But again, you will definitely wanna do this

Again, you will definitely want to do this for the main when you return from main.

So we do prolog R12, epilog R12.

I made a comment there.

And then we’re going to store the return value in R12.

So that means here we’re going to move something into R12.

It’s getting precarious because we restored it right before the system call,

but I think it’ll be okay.

system call but i think it’ll be okay we’re going to grab rax because rax is supposed to be the

return value register so when we called gimme long it loaded up rax with our return value

we then send rax into r12 so we can use r12 uh even though our rax has been you know destroyed

we’ll still have the return value that we wanted to use so i’m just going to load r12 up into the

first argument of the sys exit call let’s see if i if i got this to work or if i totally ruin this

work or if i totally ruin this okay all right so let’s see here what was

why is it not erroring gimme 33 exit gimme should i did i load the wrong value exit gimme what is

it doing exit gimme it’s moving rex into exit gimme so you call gimme long and then you move

r a x into r 12 and r 12 i wonder if that destroyed it

hmm let me get rid of this push pop pair because it’s supposed to be giving me

an ever message that the function or that the program did not exit maybe this is proof that

you don’t need to preserve inside of the underscore start function let’s see here

yeah okay i guess that proves it hey don’t take my word for it i’m wrong all the time

For yourself, be a scientist, be a computer scientist.

Try it out.

Try to do something different.

Okay, so I guess this is proof we don’t really need a prolog and epilog in just a pure assembly,

at least the entry point for start.

But if you were calling any other functions, then they definitely need to preserve.

And again, if you’re using GCC, so you can have a main for your entry point, then you

still have to preserve.

you know print the message and then print our other three messages and then the return code

is going to be 33 that was the gimme code that we did so now we know how to return a value from a

function and um let me set this back to just zero so the make system thinks that we succeeded

run it again succeeded all right i guess this concludes the video i hope you had a little bit

and I hope you learn a little bit of stuff and I’ll see you in the next video.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now.

world to me and it’ll help make more videos and grow this community so we’ll

be able to do more videos longer videos better videos or just I’ll be able to

keep making videos in general so please do do me a kindness and and subscribe

you know sometimes I’m sleeping in the middle of the night and I just wake up

because I know somebody subscribed or followed it just wakes me up and I get

filled with joy that’s exactly what happens every single time so you could

do it as a nice favor to me or you could you control me if you want to just wake

just subscribe and then I’ll just wake up. I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code, which you

can scan in order to go to the website, which I think is also named somewhere at the bottom of

this video. And it’ll take you to my main website where you can just kind of like see

all the videos I published and the services and tutorials and things that I offer and all that

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever

i also wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so

again thank you so much for watching this video and um enjoy the cool music as as i fade into the

which is coming for us all.

Thank you.

The post Mastering x86-64 YASM Assembly: Functions Made Simple appeared first on NeuralLantern.com.

Join us for a clear, engaging look at x86-64 program segments! We break down the text, data, and BSS sections, explore stack vs. heap memory, and show a real stack overflow in C++. Learn why segmentation faults happen, how virtual memory works, and tips to avoid crashes. Whether you’re new to assembly or leveling up your coding skills, this video is packed with insights to boost your understanding of low-level programming. Subscribe for more coding deep dives!

Introduction to x86-64 program segments 00:00:01
Understanding segmentation faults 00:00:12
Importance of segments in assembly 00:00:32
Overview of assembly program structure 00:01:09
Defining segments in Yasm assembly 00:01:49
Data section: Initialized global variables 00:02:20
BSS section: Uninitialized variables 00:03:23
Text section: Code and functions 00:03:59
Global and extern function declarations 00:04:41
Stack: Local variables and return addresses 00:07:11
Stack overflow example in C++ 00:08:48
Heap: Dynamic memory allocation 00:11:31
Stack vs heap memory growth 00:11:56
Virtual memory and memory allocation 00:14:00
Demonstrating memory overflow with heap allocation 00:16:59
Summary of segments and their purposes 00:17:59
Closing remarks and call to subscribe 00:18:47

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hi there!

Let’s talk about x86-64 programs and their segments and the purpose of the segments.

Probably when you’ve been programming in the past you’ve seen segmentation fault errors.

If you’ve accidentally crossed the bounds of some appropriate memory location, if you

have an array and you try to index it way outside of bounds or something, you might

have seen a segfault.

SegFaults basically come from the idea that you have crossed a segment boundary.

Segments used to be really, really important.

They’re a little bit less important now that we have virtual memory.

I’ll just talk a little bit about them.

I’m going to be discussing this from the perspective of an assembly program,

just because even in higher level languages,

your languages will typically be compiled down to assembly

first before they actually hit machine code and your actual executable binary.

So if you’re not interested in Yasm Assembly,

Yasm assembly I think this could still be worth it for you to watch because

you’ll be able to see the different segments and just kind of get a better

understanding of what they are okay so I’m gonna actually write a very very

very quick program in assembly it’s not gonna really do anything I just want you

to show I just want you to see the segments that are involved so for

starters let’s just pretend that I’m writing a an assembly program here we’ll

This is a comment just so you know what I’m about to type.

Perhaps actually this is not the best editor.

I don’t know why I pulled this up.

Let me get Gene here.

It’s a little bit better.

Gene.

There we go.

Maybe I’ll save it somewhere.

I’ll say segments assembly.

And then now the comment gets highlighted.

Okay.

So in assembly in the ASM assembly,

we denote various segments by using the section keywords.

keywords so we’ll say section and then dot something indicating the type of segment that we’re

defining so section text and then up here we’ll have another one section dot bss and you know if

you already program assembly you know that somewhere in here is where the code goes right

between these sections so just a quick recap of what the data section is it just is where you

can name and initialize at the same time at the very top.

Globals are not great, but sometimes you want to do that in assembly, depending.

It’s better if you stick all your variables on the stack.

Like if they’re a local variable, it’s a little bit better.

Think of higher level languages.

You typically want to avoid global variables if you can possibly avoid them and make

everything else a local variable or a member variable.

So that means somewhere else other than data, probably the stack, but or the heap.

Anyway, you know, this is like the basic pattern.

We’ll say, you know, my variable and then we’ll decide to say what data size it is.

In this case, it’s DB for one byte of data.

You could put a, I think DD in there or a DW for a word.

Sorry, sorry, DW would be for a word.

And then I think DD would be a double and then DQ would definitely be a quad word.

So here quad word is eight bytes.

And then I can sort of initialize it to some number.

some number and now I have a global variable so not like a huge deal the BSS section is basically

where you have uninitialized variables but there you can make huge amounts of variables you can

make an array of variables so if I say my array something like that I could put resource queue

to say I want the type of one item to be a quad word so you know eight bytes per item and then I

could just say I want you know a hundred thousand items or something and I’ll

double check that after I stop recording this video and correct it if I’m wrong

it’s been a while since I actually typed BSS here and then in the text section

this is where you put code and functions and things you typically want to have at

least one entry point somewhere you know if you want to make like if you want to

make this the entry point of your entire program you’ll probably do global main

main and then this assumes that you use the GCC libraries and just sort of return from the label

sort of makes it a function assuming you didn’t ruin any of the other data.

So those are the three sections that we can start off looking at the data section,

the BSS section, and the tech section. It’s important to note that besides marking functions

as global so that they’re accessible to other segments or other modules, we also mark

We also mark functions and labels that we would like to access that are in other modules.

So if we’re using the GCC libraries, we could say something like global printf,

and then right away we’re able to call the printf function.

Or say if you have another function in another module,

like a different source code file that’s compiled somewhere else,

we could say, you know, my other function.

Something like that.

Just mark it as global.

Or sorry, not global.

Extern.

Xtern. Global is when you have the function in the current module and you want it to be available to other modules.

Xtern is when the function or label is in another module and it’s already been made available to you,

but you want your current module to know that it can access it for the purposes of assembling the program.

So that means inside of here we could do something like call.

We could say, let’s call my other function.

my other function that will work if the other function is actually a function

with a return statement and it respects the ABI you know it pushes registers that

it’s going to modify if they’re callie saved if it’s not another function maybe

we’ll say extern my other jump point so like not a proper function but just

something that you might want to jump to then instead of using call we would use

jump, you know, and so forth. So those are the basic sections. Let’s see, for the BSS,

I definitely talked about token size and count. And then there’s resource B, resource W, resource

D, resource Q for the different sizes. So basically just take all the different sizes you could put

in the regular data section and assume that that could be popped on to the end of RES inside of

the BSS section. If you’re interested, this is a segments video, not an assembly video.

assembly video um another segment uh another segment that we’re not showing here in this

source code is the actual stack probably i guess the best way that i could show it is

i don’t know by messing around with the stack pointer increase uh

oh rsp why did i think it was the instruction pointer we could increase the stack pointer and

stack pointer and then decrease the stack pointer.

It doesn’t really help a whole lot.

But in another video, I’m gonna talk more in depth

about what the stack is and how to use it and such.

But just keep in mind that the stack

is where local variables are stored

and you can use it in assembly and C++

and other higher level languages.

You can even make virtual stacks

in any type of program almost

to just sort of have a stack like structure.

But in C++, if you make any local variable,

any local variable, then it’s usually going on the stack.

And the stack tends to have a fixed size.

And so if you sort of put too much data on the stack,

you risk a stack overflow, which will crash your program.

Besides local variables, the stack will hold other information that the current scope needs,

like its return address.

So when we make a function and then let’s say we call another function inside of it,

actually just up here even when we call another function on line 22 the stack will receive the

return address of where we currently are so that later when we return from the other function you

know the program knows where to jump back and forth it’s actually under the hood just jump

instructions when you do call it’s it’s not it’s not like a special thing it’s just jumping to

another location and then pushing the return address on the call stack so that’s other stuff

other stuff that the stack holds, which means if you have like an endless or like a infinite

recursion happening in your function where just a function calls itself over and over

and over again, or you have some complicated call graph and you end up calling too many

functions without ever returning, you could overflow the stack.

So that’s not good.

Let me show you a quick example that I’m going to make for you real fast.

Oh shoot.

Did I actually make this?

Where is the, it’s on the desktop.

Okay, I guess I’m going to make more on the desktop.

Let’s do a stack overflow.

Let me do desktop here.

Let’s do stack overflow.

That’s CBP.

I’m just going to make a quick program.

In C++, that doesn’t really do anything except overflow the stack.

So I just want you to know the stack can overflow.

I’ll make a function called F.

And F just calls itself.

calls itself. So that’s going to be an infinite recursion.

And that means, you know, every single time F calls itself,

the return address of like line five is going to get pushed onto the stack again.

So it’s just going to get pushed and pushed and pushed and pushed.

The stack will overflow faster if I had local variables because every scope that

gets called, even if it’s the same function name, it’ll have its own allocation on

the stack. So if I just sort of like call this from main and then I’ll just need

and then I’ll just need to make a little uh a little make file that just kind of compiles

I don’t really even need to make a make file I could do a build script but I’m going to do it

anyway we’ll say g plus plus standard equals c plus plus 23 show all warnings show pedantic

the input file will be stack overflow cpp and then the output file will be main

main and then assuming that succeeds I’ll just run main so this is like not a make

file video I have other videos for make files let’s see let me get to the

desktop if I run the make file with just the word make you should see a stack

overflow we should also see a warning about the fact that there’s infinite

That’s funny, I must have done something wrong or different because on a different computer

not too long ago I did the same thing and I saw a warning.

Okay, well thanks for not warning me.

But anyway, you can see that we have a segmentation fault here because the stack overflowed.

We just made a stack that was too huge.

This is a reminder that the stack is not necessarily as dynamic as the heap.

You can definitely overflow it.

It’s not really meant to store gigantic amounts of data.

What am I talking about when I say the heap though?

So just keep in mind that whenever you allocate dynamic data,

well, maybe, well, what do you think?

Maybe, maybe inside of, instead of calling F, let’s call G.

The heap is where you allocate dynamic data.

So anytime you use the malloc operator in C or the new allocator in C++,

you’re creating like a dynamic allocation of data.

I’ll do a new integer and then I’ll do like a thousand integers so this is

basically going to allocate a thousand new integers in the heap which is a

segment that is right up against the stack I should mention also that the

stack it’s important the stack its memory locations go down as the stack

grows keep that in mind because typically when you when you imagine a

stack I’ll make more videos in the future so you can visualize the stack better but most of you who

know what a stack is already you imagine that the stack grows upward visually right but in your

computer the memory locations of the stack grow downward so if I add something to the stack then

the new stack head pointer is actually going to be a lesser address and the reason for that is the

stack and the heap they grow in the same direction towards the same unallocated space we’ll call that

We’ll call that space the unallocated memory space or the unmapped memory space.

And it’s just, you know, a segment stack in the heap.

And then there’s the unallocated space that they grow towards each other.

If they ever meet, then your program is out of memory and it’ll crash.

But the heap actually can be dynamically allocated to store tons of RAM.

I’m probably about to crash this computer.

So maybe this video won’t finish recording.

recording so maybe I’ll try to crash this at the very end I just wanted you to

see let me let me do this I’ll say while true we’ll just allocate a new integer

this is kind of bad form because when you allocate you know a new variable

somewhere you want to have access to it after the allocation you would usually

send that into a pointer you’d say like you know integer pointer P equals new

in something like that right but in this case I don’t really care I’m not gonna

that memory i just want you to see how fast the memory can grow when we did the stack overflow

seemed like the program died pretty quickly but here we’re going to be able to see the memory

boom pretty pretty big before the whole computer just starts to you know fall to its knees

so i’m going to do a call to g here and then i won’t actually run this until

i’m ready to crash this whole video let’s see what else can i say

Oh, the reason that the heap can grow so much larger than the stack is our programs now in the modern era, they use virtual memory.

So it’s not like when we allocate, let’s say we’re accessing a memory location via a pointer inside of our program.

It’s not that the pointer has the absolute memory location through the whole system.

Like it doesn’t, it’s not able to name locations outside of the current program.

Every program sees its own start memory location as just zero.

And then under the hood, there are some extra tricks so that when you try to access a memory location,

let’s say memory location 100, because you’ve made, I don’t know, this many integers or whatever.

Then under the hood, the computer will know what is the start offset of the program’s memory.

So maybe the start offset is 1000.

It’s like totally unrealistic, but just pretend.

The start offset is 1000.

1000 then that means if it’s trying to access a pointer with memory location 100 it just gets added to the offset the virtual offset

So it’ll be a thousand and 100 is the real you know physical memory location or at least at that point

It’ll probably go to the paging system, but that’s that’s another video

So just know that it’s virtual which means the program thinks it has the full range of of the 64 bit memory address space

Even if you don’t even have that much memory on your computer, which there’s no way there’s no way you have so much memory

there’s no way you have so much memory that it’s going to overflow or even meet

64 bits at all but the program thinks it can so it’s just going to grow and grow

and grow until you actually run out of physical memory and then eventually

probably your program is going to start going to the page file or to the swap

file and then when you run out of that then your whole computer probably is

going to start crashing to be honest it’ll probably start crashing as soon as

it hits the swap file because at that point none of the other programs really

None of the other programs really have enough leftover memory to to breathe to do extra

allocations and things so everything’s going to start slowing down it’s going to be pretty bad

and well i think that’s all i really need to say this is not supposed to be a really long video

let me uh let me show you this crasher i’m going to say goodbye now thank you so much for watching

the video i hope you learned a little bit and had some fun too and and that way i’ve already said

if it actually crashes the computer. So I’m going to open up this and then I’m going to do maybe

HTOP so that I can see memory. So if you kind of like look at HTOP real fast,

this is just a Linux command line tool that you can install. It’s pretty cool.

What the heck’s going on here? Oh, that’s my recorder. You can see here’s the memory allocation.

So I’m using two gigs of eight gigs on this virtual machine and then I’m not using any swap

space which means I have not exhausted all my memory and and I have not been forced to go to

the disk for like additional memory but in a second we’ll see that will probably change

so I’m going to do make just to run that it looks like it’s stuck but if you keep looking at the

memory allocation oh it already hit eight gigs now it’s into the swap already probably

The out of memory killer, the OOM, successfully killed the program.

Thank goodness.

Or the whole computer would have been down.

I always forget that that’s going to happen lately.

But you can see it spiked, right?

It went right up to the full physical memory allocation of 7.75 gigs.

And then the swap file went all the way up to 2 gigs.

You can see that the swap file still has about 700 megs inside of it.

That just means that there’s memory that isn’t really being accessed.

the operating system doesn’t feel like it’s necessary to pull it back out of swap and put

it into RAM but I wonder if the video skipped when I did that or stuttered or anything I’m

interested to find out now okay so that’s the end of this video I hope you have a decent basic

understanding of segments and then you know like the segments and their purpose you know the heap

and the stack they grow together the heap can dynamically allocate to grow bigger notice how it

Whereas the stack will crash a lot faster.

If the stack and the heap meet, then you’ve ran out of memory.

At that point, you know, you probably want to like resize the heap or the stack just crashes.

And then we got the text section of the program and the data section and the BSS section of the program.

And these sections are a little bit less relevant in the modern era because we have, you know, virtual memory and stuff.

That definitely means you have tried to access outside of your segment and it’s a no go.

Okay.

Thank you for watching this video.

I will see you at a later date and time.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

as you do on the current social media website

that you’re looking at right now,

it would really mean the world to me

and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos,

longer videos, better videos,

or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping

in the middle of the night

and I just wake up

because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you could troll me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan

in order to go to the website which I think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see

all the videos I published and the services and tutorials and things that I offer

and all that good stuff and

and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

would really appreciate it so again thank you so much for watching this video and um enjoy the cool

Enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Demystifying x86-64 Program Segments: Stack, Heap, and More appeared first on NeuralLantern.com.

Want to learn how to input double precision floating point numbers in C? This beginner-friendly tutorial walks you through the process step-by-step, showing how to use fgets and sscanf to get user input, validate it, and handle errors like a pro. With clear code examples and a simple program demo, you’ll see how to check if input succeeds or fails. Perfect for C programming newbies or anyone looking to sharpen their skills. Subscribe for more practical coding tips and tutorials!

Introduction 00:00:00
Overview of Inputting Doubles 00:00:02
Program Setup and Includes 00:00:44
Main Function Explanation 00:01:13
Get Input Function Introduction 00:02:10
Defining Get Input Function 00:02:34
Character Buffer Creation 00:02:54
Using fgets for Input 00:03:49
Parsing Input with sscanf 00:06:33
Handling Success and Failure 00:08:07
Running the Program 00:09:05
Testing with Valid Input 00:09:20
Testing with Invalid Input 00:10:05
Conclusion and Call to Action 00:11:50

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there!

In this video I’m going to show you how to input a double precision floating point number

in C from the user into your program and decide whether or not it has succeeded or failed.

Okay so for starters I just want you to know that this video is not about generating makefiles.

own make files or how to compile link execute or even the basics of c see my other videos for now

i’m just going to assume that you know how to make a make file here it is basically very quickly

but i’m just i’m just compiling a simple program here’s my program here it’s called main.c it

doesn’t really have anything else to it i’m going to start off by importing a couple includes or a

few includes that’ll just help me get some stuff that i need so here’s an include for the standard

input output here’s an include for the standard library here’s an include that

helps with c string functions here’s an include that helps with limits not

actually sure every single one of those includes is needed but we’ll see anyway

here’s my main program or I guess my main function since this program only is

just one module notice how we have a double called value here and then we

make a call to a function called get input and we give a pointer to to the

double as an argument to get input so basically get input should be able to just return to us

the value by reference and then get input will be able to tell us whether or not it has succeeded

as in has the user entered valid input by its return type or not not its return type but its

return value so the result is going to be a long from get input and that’ll indicate

runs we’re just going to print you know get input returned and then print the return value that it

returned and then it’s going to print the double that it inputted from the user and then a new line

so nothing uh nothing too big of a deal let me show you the main workhorse function that has

all the logic you need to input from the user and check that the input was valid so this is called

get input i’m sticking it on top of the main function because i don’t want to deal with

because I don’t want to deal with prototypes right now.

It’s a better idea to put prototypes up at the top of your source code file

if your source code is even a little bit complicated.

But in this case, it’s just one other function.

So I will just put get input on top of main.

That way, when the compiler is scanning the source code,

it will have already seen that get input exists before main calls it,

and it’ll compile.

So first thing I’m going to do is say that get input returns along

get input returns along like we just saw and it takes in a pointer to a double no references just

a pointer then we have to create a character buffer and what that’s going to be for is basically

you know the user is going to type some characters and i want that to go into the buffer so um

a line max is the number of characters that the buffer can hold and that’s uh i think where we

I think where we have limits, I think limits is providing that for us.

But basically, you know, you could stick a number here if you wanted to like an eight

character, eight kilobyte buffer, if you wanted like eight, one, nine, two, or just whatever.

I’m just putting line max so that it sort of aligns with the system’s idea of what

the maximum size of a line should be.

Okay.

So then I don’t know why I have it say grab side one.

I’ll just say grab input here.

Let me change my solution real fast.

Grab input.

That’s probably because that was part of a program.

that’s probably because that was part of a program in the past so then the function that I’m going to

actually use is called fget s which basically is saying let’s uh let’s input a string a c string

from a file and we’re providing the target for the input so that’s going to be the character string

right there and then we’re going to provide um the maximum number of characters that we’ll accept

length of the buffer and then what file are we going to input from standard

input if you don’t know standard input see my other videos but it’s basically a

special file handle that means when the program first launches you know the

operating system sort of gives it a special file handle for standard input

standard output standard error and so this will be basically the user typing

on the terminal so f get s will essentially take input from standard

terminal until they you know hit like a new line or they disconnect the input

buffer it will take up to this many characters line max which should match

the buffer whatever value you put in the buffer and then it will write the

characters into the buffer that’s why you have to match the length of the

buffer so basically here this function call will return something if it returns

a zero then that means we have failed so if it returns null then we’re going to return zero

meaning fail so get input is kind of a boolean even though we don’t have booleans in c and it’s

basically going to return a zero on a failure and a one on success so like you know zero is a falsy

value and one is a truely value so we’re not going to use system style return codes where zero is

codes where zero is success we’re going to use boolean style return codes where a zero is failure

and one is uh success so you can see i’ve kind of chained two commands here i’ve decided to say all

right um we’ll first grab some input into the buffer array with f get s if that is null then

we immediately return zero because this this logical or operator says if one or the other thing

is equal to a true then just go ahead and evaluate to true so here I’m asking like did the call

equal null if the answer is yes then that part will evaluate to true and then it’ll basically

short circuit the rest of that logical expression and just return zero right away and then if the

previous command succeeds like the fget s succeeds then it will look at the buffer and try to scan it

for valid input.

So the left side is just taking raw input.

The right side is parsing for certain data type.

So you can see sscanf,

we’re scanning a buffer that we put into the first argument.

So that’s at that point, by the time sscanf gets called,

the buffer should be filled

with whatever input the user typed.

So we’re scanning that

and then here’s a little formatting argument,

which is very similar to,

use the same tokens basically as printf. So, you know, here we’re saying percent lf. So we’re

looking for a long float, which means a double precision floating point number. And that

percentage just means like, here’s a special token that comes after it to describe what sort of

value we’re looking to scan for. So then if we’re successful, if it actually scans,

the double. So fscanf expects a pointer to the variable that’s going to receive the value that

has been scanned if it is scanned correctly. So notice how the double we don’t have an ampersand

in front of it because it’s already a pointer because it came into us as a pointer in the first

place. So we’re going to look at the buffer that the user just typed, the user just provided,

and we’re going to try to scan for a double precision floating point number. If we’re

then the system should write that double into the variable referred to by the

pointer known as the double if all that succeeded then the value should be

greater than or equal to zero if these if this command failed then the value

should be less than one so that basically means if we have a value of

less than one then we have failed and we’re going to return zero so now whether

the initial scanning sorry whether the initial input fails or the parsing of

the users input fails then we’re gonna end up returning zero for fail so then

in main you can see all we’re doing is we’re just calling on input we’re giving

it a pointer to the double that we want to populate and then we’re looking at

the result so in your you know program logic you can do something like if the

result is zero then assume we failed and if the result is one assume we succeeded

And if the result is one, assume we succeeded and, you know, respond to the user or, you

know, do something that’s appropriate for success or fail.

I think that’s everything that I need to explain.

Let’s try to run the program now.

Open a terminal.

I want to do make run and see if that works.

Maybe I’ll do a clear here.

Okay.

So I didn’t print any, you know, prompting or anything special.

so the cursor is just blinking at this point i can just enter 33.12 i guess whatever hit enter

and the program now says get it get input returned one which means success so the value that i entered

was a valid double and the value is now 33.12 so it successfully grabbed the float keep in mind

these zeros or just precision related issues are related to the printing of the double not

not necessarily related to what is inside of the double so I’m just saying

you know print along float you can you can mess with print F a little bit more

if you want to have a different value printed or more precision or less

percent precision printed let’s try to do this with some invalid input I’m just

going to do some letters and hit enter notice how the value didn’t actually

change it’s it started or actually it did change it got set to a zero because

initialized it as junk data so it got set to a zero but then more importantly get input returns

zero as its return code so when you see zero that means the command failed so you should not consider

the double as valid in any way you shouldn’t use it you should complain to the user or do whatever

and that is how to get input let’s just try something for fun double value equals 3.333

bad input i’m assuming it might but i haven’t done this in a while so we’ll see so bad input

and looks like it did not change it so whatever junk data was already in value by the time you

called on get input if get input failed then the value should probably be unchanged but again more

importantly the return value is zero meaning fail because zero is a falsy value so i’m going to get

so i’m going to get rid of that so i can go back to my solution there okay so now hopefully you are

uh you’re on your way to start getting input in c at least in the in in terms of longs uh you can

look up the formatting codes for print f if you would like to input different types of data like

so this video is just for long floats doubles uh you can you can look up all other all sorts of

five years I’ll make another video that has different types of tokens but I guess that’s

it for this video. Thanks for watching I hope you learned a little bit and had a little bit of fun.

See you in the next one.

Hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it. I do hope you did learn something and have some fun. If you could do me a please

subscribe and follow this channel or these videos or whatever it is you do

on the current social media website that you’re looking at right now it would

really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or

just I’ll be able to keep making videos in general so please do do me a

kindness and and subscribe you know sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed it

followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could

you control me if you want to just wake me up in the middle of the night just

subscribe and then I’ll just wake up I promise that’s what will happen also if

you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named

somewhere at the bottom of this video and it’ll take you to my main website

where you can just kind of like see all the videos I published and the services

videos I published and the services and tutorials and things that I offer and all that good stuff

and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever I also wake up for those in the middle of the night I

get I wake up in a cold sweat and I’m like it would really it really mean the world to me I

it. So again, thank you so much for watching this video and enjoy the cool music as I fade

into the darkness, which is coming for us all.

Thank you.

The post How to Input Double Precision Floating Point Numbers in C: Step-by-Step Guide with Error Handling appeared first on NeuralLantern.com.

Hey coders, ever wonder why your program’s acting funky? Join me to master debugging with xxd! This vid walks you through inspecting text or binary file output at the byte level, catching sneaky characters like null bytes that mess up automation or school assignments. From assembly to redirects, learn practical tips to ensure clean output. Perfect for beginners and pros alike! Hit subscribe for more coding tutorials, and check my site for extra goodies. Let’s debug smarter, not harder!

Introduction to xxd 00:00:00
Purpose of debugging 00:00:12
Why debug output 00:00:23
Example assembly program 00:00:56
Running the program 00:01:26
Corrupting the message 00:01:45
Terminal vs automation 00:02:27
Installing xxd 00:03:16
Redirecting output 00:03:29
Using xxd to debug 00:04:33
Identifying newline issue 00:05:36
Finding zero in string 00:06:04
Debugging conclusion 00:06:32
Weird symbols warning 00:06:47
Debugging standard error 00:07:23
Closing remarks 00:07:40
Call to subscribe 00:07:56
QR code and website 00:08:45
Request for comments 00:09:09
Fade out 00:09:31

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there, I’d like to talk to you about debugging your program’s output with xxd.

What am I talking about? Well, there’s a program called xxd that can sort of inspect

at the byte level the output of some text file or binary file. It’s really useful for

inspecting things. Why would you want to debug the output of your program? Well, I don’t know.

print a message from your program the program might be printing some extra characters somewhere

or some garbage and maybe maybe you don’t notice because you’re sort of looking at your program’s

output in the terminal but then maybe if your output is being sent to another program

for the purposes of automation or like you’re getting a grade from a class or something like

that then um well it can it can sort of it can sort of get you without you realizing what’s wrong

you an example real fast of what i’m talking about i have a simple assembly program here this is not

a video about how to write assembly code so just assume that you know if you want to know assembly

see my other videos but um i’m just going to print a simple message i’m just going to print

hello i feel awesome and then the length of the message i’m specifying here you don’t know you

don’t need to know too much about this for this particular video i’m just printing a string in

assembly that’s all i’m doing and then here you can see i’m just kind of like printing it and then

I’m just kind of like printing it and then I’m like exiting.

So if we go back to the terminal here, I can type make run.

This is not a make file video.

See my other videos.

I want to type make run just to compile and run the program.

And then here’s the message that it prints, right?

Hello, I feel awesome.

It looks good in the terminal.

I can’t be 100% sure though, because think about this.

What if I corrupted the message on purpose?

This can happen in assembly all the time.

Wrong or if you add extra characters at the end of it or even if you have you know a corrupted register somewhere

That either reads from the wrong spot

To get a string or maybe it it writes over the string for some reason. There’s a lot of things that can go wrong

So for now just suppose that I’ve corrupted my message somehow by I don’t know. Let’s put a zero

In between the string so I’m gonna say is that it’s gonna be like H E L

0 L O and what that should do is

lo and what that should do uh well it should look like just the word hello but if i’m automating

this program or sending it in to get a grade at a school somewhere then this should you know not

match what is expected if i’m automating with like another system in some way but it should look okay

in the terminal let’s see i’m going to do clear and make run notice how the message looks the same

I feel awesome. So if I was automating, you know, if I was sending this string to another program

for automation, I might be convinced that I’m not doing anything wrong. And I’ll, I’ll think it’s

the other side that is wrong or, or our computers are just buggy or something like that. But actually

I’ve outputted a corrupted message for some reason. So how can I really be sure that my

message is what I think I’m seeing in the terminal? That’s the XXD program. Pretty easy.

apt install xxd let me see if I have it on this system oh it’s already installed

okay good so I’m gonna do clear and make run again so there it is I would like to

just redirect the standard output pipe to a file with a special command in the

shell let me just show you real fast I am definitely printing to std out the

standard pipe which is just a number one file descriptor if you don’t understand

If you don’t understand that, I have other videos, but I’m going to run the program again,

but then I’m going to redirect the output to a file and I’m going to call it stdout.txt.

It’s probably a good idea to eliminate spaces.

I think I’ve made mistakes in other videos where I didn’t put a space before or after

this little redirector symbol and I ended up creating a file just called the number

two or the number one.

But pipe number one is standard output.

So I’m going to say anything that comes to pipe one, which is standard output, I’m just

output I’m just going to redirect it to a text file. So when I hit enter notice

how nothing prints to the screen but the standard output text file that I

specified is now created. If I spill the contents of std out it still looks

normal so don’t let that trick you but watch what happens if I use xxd.

xxd std out basically xxd is going to read it as a binary file and tell me

every single character in there while I oh I forgot to change the title of that

that’s not this video but notice right here where it says H E L L O and then

right before that there’s like a little dot if you look at the dot let’s see

what is the dot it’s one two three four five six it’s the sixth thing one two

one two three four five six seven eight nine ten twelve thirteen fourteen fifteen oh there’s

fifteen characters but there’s not that many i think probably they’re packing them by two here

let me see if that makes more sense now one two three four five six one two three four five six

yeah that makes a lot more sense so the sixth uh byte not the sixth uh word uh is basically

to this dot right here and if you recall oa is a decimal 10 which is uh the beginning of a new line

you know like a carriage return line feed um 13 comma 10 so that’s what it is right there

and then so now we know that there’s xxd is figuring out here or helping us understand

that there’s a new line between slash main and then the message which if you recall that’s

exactly what happened and then when we look into our hello string there’s a dot in the middle here

string there’s a dot in the middle here what is that dot well we just have to figure out what

number that corresponds to so the oa was that dot right there so we just got to go a couple more

bytes forward one two three four bytes forward one two three four bytes forward it’s this zero right

so xxd even though the terminal didn’t help us originally xxd has helped us realize that we’re

that we’re actually printing a zero under the hood and we can’t see it in the terminal.

So we have now debugged our output. You know, depending on where you print this,

you might see nothing like in the terminal. It didn’t really show anything. But if you’re on a

webpage somewhere or some other type of thing that’s going to print the data for you, you might

see a weird symbol. I mean, it really depends. This is not something you’ll see everywhere, but

you might see a weird symbol that kind of looks like a black diamond with a question mark inside

mark inside of it or some other weird symbol.

If you start seeing weird symbols all over the place or just in a place where you know

there’s not supposed to be a weird symbol, that might be an indication to you that you

have weird values sitting inside of your string.

And then you should probably try to debug with XXD.

So that’s it.

That’s the basics for debugging with XXD.

Just, you know, file output anyway, for your information.

If you wanted to debug the standard error pipe, you could also do this.

you know because the error pipe is just a two um and that’s basically it i’m not going to

debug right now because that’s that’s too easy but i hope you enjoyed this video thank you for

watching i hope you learned a little bit and had a little bit of fun i’ll see you in the next video

hey everybody thanks for watching this video again from the bottom of my heart i really

appreciate it i do hope you did learn something and have some fun uh if you could do me a please

If you could do me a please, a small little favor, could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

the middle of the night and i just wake up because i know somebody subscribed or followed

it just wakes me up and i get filled with joy that’s exactly what happens every single time

so you could do it as a nice favor to me or you could you could troll me if you want to just wake

me up in the middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s

what will happen also uh if you look at the middle of the screen right now you should see a qr code

which you can scan in order to go to the website which i think is also named somewhere at the

you to my main website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and uh if you have a

suggestion for uh uh clarifications or errata or just future videos that you want to see please

leave a comment or if you just want to say hey what’s up what’s going on you know just send me

a comment whatever I also wake up for those in the middle of the night I get I wake up in a cold

it would really mean the world to me. I would really appreciate it. So again,

thank you so much for watching this video and enjoy the cool music as I fade

into the darkness, which is coming for us all.

Thank you.

The post Master Debugging with xxd: Inspect Program Output at a Byte Level for Automation & Clean Code! appeared first on NeuralLantern.com.

Hey coders! In this video, I’m diving into CGDB, a powerful curses layer on top of GDB that makes terminal debugging a breeze. See your source code and breakpoints side-by-side in one clean interface. I’ll walk you through setup, breakpoints, and why CGDB rocks for C++, C, and assembly projects. Watch my GDB video first for the basics (link in comments)! If you dig this, subscribe and drop a comment for more coding tips. Let’s debug smarter! #CGDB #GDB #Debugging #Coding

Introduction to CGDB 00:00:00
Recommendation to Watch GDB Video 00:00:05
Explanation of CGDB and Curses 00:00:23
Building and Running CGDB 00:01:03
CGDB Interface Overview 00:01:56
Setting Breakpoints in CGDB 00:02:18
Managing Breakpoints 00:02:53
Benefits of CGDB 00:03:47
Closing Remarks and Subscription Request 00:04:00
Call for Comments and Suggestions 00:05:30

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to talk about CGDB which is just a debugging program.

If you haven’t seen my other video on GDB please watch that first because

I go over all the concepts of debugging an assembly program, a C++ program, a C program

and it’ll be much more useful than this video.

This video is just about CGDB which is really a curses layer on top of GDB.

on top of GDB. Curses is a library that allows programmers to kind of make

graphical interfaces in the terminal so the point of this video is just to show

you a slightly different way to use GDB that’s why I’m saying go check out the

previous GDB video first but you know I think you know sometimes people like CG

to be so what am I talking about for starters pretend that I have a program

I’ve got an assembly module a C++ module and a make file you don’t know

or C++, see my other videos.

This video is only about CGDB.

But I can do, you know, make build,

just to build my objects and my executable.

And then normally, if you know GDB,

you can go GDB main and just enter the GDB terminal, right?

This is great, you can do a lot of commands from here,

but it’s not very graphical.

It does have a graphical mode, to be honest,

but it seems to be kind of glitchy,

so I’m not really gonna talk about it.

going to talk about it anyway so instead of launching your program inside of gdb you can

launch your program with c gdb c standing for curses i don’t think this is installed on the

current system so i’ll probably have to install it right okay so you can go sudo apt install c gdb

and then just enter your password

Let me do clear and then we’ll do CGDB main.

And I just want you to see that it’s got two windows.

This is the whole point for me anyway.

The bottom window is actually GDB.

So anything you’ve learned there is going to apply here.

But the difference is that there’s a top panel that shows your source code.

So I don’t know.

Let’s suppose for the sake of argument, I’m going to hit escape so I can go up to the top panel and kind of scroll my source code.

Let’s suppose for the sake of argument, I want to break every time I hit line 36.

time I hit line 36 okay I’m kind of scrolling I just hit escape to get into the top panel

I’m gonna hit I for interactive mode which lets me go back down to the bottom panel

and then I’ll just say B for breakpoints main.cpp line 36 and then just double check that I entered

my breakpoints correctly and then I’ll run the program again if you don’t know GDB see my other

video but notice how I started to run the program and then it immediately hit a breakpoint and then

the top pointed to that line where it broke if you don’t believe me i’ll do another breakpoint

at line let’s see main.cpp line maybe uh 32 and then another one at uh 39 well maybe i should

have done 40. yeah i should have done 40 and then 33 so that means i probably want to uh

delete that one at 32 so i’m gonna delete whichever one shows up at 32 that’s number two

and then info breakpoints again okay so now if i continue the program also by the way notice how

the top panel is showing red line numbers for my breakpoints if i hit c for continue

and it hits the same breakpoint again if i hit enter to continue one more time it’ll do that

eventually it hits a different breakpoint and notice how the source code

moves down to the appropriate breakpoint so for me personally i kind of like to just regularly you

and then go back and forth between that and my code window.

But some people really love having both their code and GDB in the same terminal

so they don’t have to go back and forth between windows.

So if that’s you, then maybe CGDB is for you.

My little doggy wants to go pee.

Okay, that’s all I have for this video.

Thank you so much for watching,

and I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey, everybody.

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

or just i’ll be able to keep making videos in general so please do do me a kindness and uh and

subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because i

know somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you control me if

you want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just wake

up i promise that’s what will happen also uh if you look at the middle of the screen right now you

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

clarifications or errata or just future videos that you want to see please leave a comment or

up what’s going on you know just send me a comment whatever i also wake up for those in the middle of

the night i get i wake up in a cold sweat and i’m like it would really it really mean the world to

me i would really appreciate it so again thank you so much for watching this video and um enjoy the

cool music as as i fade into the darkness which is coming for us all

Thank you.

The post Master CGDB: Boost Your Debugging with GDB’s Curses Interface in Terminal appeared first on NeuralLantern.com.

Hey everybody! Ready to crush those pesky bugs in your C++ and assembly programs? In this video, we’re diving deep into the GNU Debugger (GDB) – the ultimate tool for tracking down crashes, inspecting variables, and mastering your code. From setting up debug symbols to navigating call stacks, setting breakpoints, and even debugging assembly registers, this fun and relatable guide has you covered. Whether you’re a beginner coder or a seasoned dev, you’ll learn practical tips to level up your debugging game. We’ll also tackle null pointers, create GDB scripts, and explore why your program might be misbehaving. Stick around for a few laughs and some serious skills! Don’t forget to subscribe, hit that like button, and check out my website for more coding tutorials. Let’s debug like pros together!

Introduction to GNU Debugger 00:00:00
What is a Debugger 00:00:20
Debug Symbols Explanation 00:02:08
Compiling with Debug Symbols 00:03:13
File Size Comparison 00:05:30
Installing and Launching GDB 00:06:21
GDB Console Basics 00:06:55
Attaching GDB to Program 00:08:12
Running Program in GDB 00:09:09
Handling Program Crash 00:13:02
Understanding Call Stack 00:14:05
Navigating Call Stack 00:18:13
Inspecting Variables 00:19:08
Null Pointer Issues 00:21:25
Using GDB Script 00:25:10
Setting Breakpoints 00:27:04
Managing Breakpoints 00:28:37
Continuing Execution 00:30:41
Debugging Assembly 00:33:24
Global Variables in Assembly 00:35:43
Advanced GDB Commands 00:38:31
Conclusion and Call to Action 00:40:22

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to show you how to use the GNU Debugger to

debug your C++ and assembly programs.

You can also use it for C and some other stuff but we’re just going to focus on

C++ and assembly. What is the GNU Debugger and what is a debugger in the

first place? So for starters the GNU Debugger it’s like it’s called GDB and

the db you can imagine that stands for debugger something like that and the g stands for gnu i

personally don’t know how to uh pronounce gnu so i just say gnu because it it feels more fun to do

it that way it’s more interesting i think probably some people just say new but i don’t like that

because the gdb debugger is really old and robust and powerful it’s not a new tool it’s it’s an old

new debugger someone’s always going to ask what was the old debugger and then I say this is the

old debugger the new debugger is the old debugger anyway so we’re going to use the GNU debugger

if you haven’t yet watched my video on caveman debugging you probably want to watch that first

just for like some basics of you know why you might want to look at information in your program

but for now we’ll just assume that you already know what’s going on with just like why you would

know how to make make files see my other videos but here i just have a basic make file all it’s

really going to do is just sort of compile a very simple program and add debug symbols into it so

let’s double check that i’m actually doing that here yeah there we go okay so the first thing

that i should probably show you is uh we are compiling a c plus plus source module so i’ve

actually using c but i i have that left over in there anyway and then we’re assembling something

in yasm we’re linking with g plus plus because we want to have a hybrid program and we’ve got

all these flags here those are just variables and so uh so now before i can debug with gdb

i’ve got to talk about something called debug symbols what are debug symbols imagine just a

bunch of extra information explaining all of the design and variables and everything inside of your

about your code stuffed directly into the executable.

So imagine, you know, when we compile a C++ source module

into an object file, usually that’s just, you know,

assembly at that point.

But when we add debug symbols, we’ll have a bunch of information

that can help the debugger figure out where we are in the program,

what the variables look like, you know,

a bunch of extra information to help the debugger pretty much.

The assembler will put debug symbols into the object code

symbols into the object code that you generate the compilers will do that the linker will do that

and so it’s important to understand if you don’t generate debug symbols when you’re compiling and

linking your code then your debugger won’t actually be able to do anything it won’t understand what’s

going on you can debug it but like you’re not going to see anything that’s very uh that’s useful

so let me show you real fast i’m going to do make clean and then i’m going to say make build

that I do not have debug symbols.

All right, okay, if you don’t know how to compile and link from the command line, see

my other videos, but for now it looks like we’re not generating debug symbols.

So if I list the contents of my directory here, just note the size is real fast.

I have an assembly module here that I’m calling ASI.asm, ASI for assembly, and then we’re

assembling it down to an object file.

Notice how it’s just 656 bytes, very small.

plus plus module that I’m creating here is compiling to an object file that is

about four and a half kilobytes so you know not too big the final executable is

called main and it’s about 17 kilobytes so this is without debug symbols when

you’re compiling something on your own you need to add extra switches to enable

debug symbols so you can see here in this make file that I’ve made and again if

you don’t know how to make a make file or compile or link or anything see my

But for now, I’m just going to assume you kind of know your way around to makefile,

or at least you can kind of infer what’s going on.

So I’ve commented out a different version of this variable for the flags of my C++ compiler.

If I uncomment this and then comment out the other one,

you’ll notice the only real difference is this part right here, dash G dwarf 2.

Usually in C++ compilation, it’ll just be dash G to generate debug symbols,

and then the symbol format will default to a format called dwarf2 so I don’t know for these

tutorials I like to just specify the full format but you can just say dash g in your c++ compiler

and linker we do the same thing for the linker down here so I’m going to uncomment this

and comment that and the only difference is just g dwarf2 so I’m just telling my linker that I also

want debug symbols in there too then we do the same thing for the assembler so I’m going to

So I’m going to uncomment that and comment this other one.

And the only difference is that in the assembler,

we kind of have to specify it a little bit differently.

Instead of G dwarf dash two,

it’s just G dwarf two as just one string.

And I think with Yasm, you have to specify the debug symbol format.

So just keep that in mind.

So now I’ve turned on all the debug symbols.

I’m going to do real fast, make clean and make build one more time.

And then if I list everything,

list everything let me just double check that it’s building the symbols now right okay good

notice that the files are bigger so this asio um file is now 1.8 kilobytes instead of you know

half a kilobyte the main.o object file is now 36 kilobytes instead of only 4.5 and the executable

main is 36 kilobytes instead of just 17. so you can feel it already right like there’s a bunch

extra information sitting inside the object files and the binary which allows us to debug our program

okay so now that we’ve generated debug symbols in our program we can actually think about starting

to use gdb so gdb is a program just gdb by the command line if you don’t have it in your system

already you can go sudo apt install gdb or depending on what system you’re on maybe a or

or whatever your package management program is,

but we just need to install GDB.

On Ubuntu and Debian, I think,

there is a meta package called build essential,

which will give you a bunch of compilation tools

and make file stuff and whatever.

So I’m just going to assume at this point

you already have GDB on your system.

To launch GDB and go into its console,

just type GDB by itself.

So now we’re inside of the GDB console or terminal.

console or terminal. We’re no longer inside of a bash terminal. We can’t type normal commands.

Let me show you real fast. Here’s the first command you want to learn on GDB. It’s called

quit. Never quit. Never surrender. So, you know, normally if you’re at the command line,

you can do something like cat, etc. OS release just to see what operating system you’re using.

So you can see for this virtual machine that I’m using right now, I’ve got like Ubuntu 22 on there.

If we go inside of GDB, we can’t use regular bash commands anymore or regular operating

system commands.

We can’t say cat, et cetera, OS release because we can now only use GDB commands.

We’re inside of GDB already.

Notice how it says undefined catch command.

I don’t know what you’re talking about, dude.

Okay.

So remember we do a Q or quit to get out.

You can actually just type Q.

A lot of commands that I’m going to be talking about.

going to be talking about you can abbreviate them with one or two or three letters and it totally

works just for speed so now that we know how to enter gdb and now that we also know that we have

already compiled our program with debug symbols we can attach gdb to our program i mean what’s the

whole point of a debugger we most of the time we will just have our debugger attached to our program

and launch it or i guess launch it while it’s attached you can also attach to a running program

but we’re going to launch a program and stay attached to it.

And then we can sort of catch crashes and see what’s going on.

Or we could also tell the debugger to stop the program at certain points in time,

like when we hit a certain line number or when a variable changes or something like that.

And then we can look around.

We can look at all the variables, look at the state of the program,

even change things if we wanted to.

We can look at all the registers if you’re coding in assembly.

So it’s pretty useful.

Anyway, I’m going to go gdb and the next command we’re going to learn is file, which just tells

gdb to attach to a program so that we can run it.

So, you know, the name of our program here that we compiled is just called main.

And so if I type file main, then gdb should load up that file and try to parse its debug

symbols so it can begin debugging for you.

Notice how it says reading symbols from main.

you know if we did a typo or we had something with no debug symbols it will give us some sort

of an error message so for now i’m just going to quit and then go back in just to make sure that

it’s all clean and we’re going to do file main now it attaches once it’s attached that’s not i guess

it’s not technically attached because the program’s not running but once it has loaded the debug

symbols for that program we can run the program with the run command in gdb also kind of interesting

If you have debug symbols that are generated separately from your executable,

you could tell GDB to load the symbols file and then run your program.

That happens a lot in Linux where people release the non-debug friendly version of a program

and then they’ll release the debug symbols separately if you’re interested.

Anyway, so I’m going to type run and it’ll run the program.

Notice how GDB kind of tells us that it’s starting up now.

here’s like a thread debugger that’s being enabled and it says we’re using this library to do it and

then it says hello you know here’s the hello message so the program is actually running that’s

not my name i wish it was and then it prints the final result and then gdb says your program exited

normally on newer versions of gdb there’s a setting i think by default where it’ll ask you

if you want to start a debug daemon a debug info daemon or something yes or no you can usually just

without actually having to type n.

It’s a little bit faster.

So the whole program ran and finished.

If I type run again, it does the same thing.

In GDB, if you hit enter without typing anything,

it ends up repeating the previous command.

So I’m not going to type run.

If I just hit enter, are you serious?

GDB made me into a liar.

Well, most of the commands will repeat if you hit enter.

I guess not the run command.

So I’ll type run again.

And okay, I mean, the program is pretty good, right?

So if you watched my…

It’s not pretty good.

watched my it’s not pretty good it’s a nonsense program I mean it it doesn’t crash is what I’m

saying if you watched my previous video which you should on caveman debugging I had this uh you know

nonsense portion of code that just sort of updated a variable and we pretended that we were confused

and we didn’t understand what was happening and uh we used gdb to debug it so what I’m going to do

either let’s say we’ll start off with throwing an exception and then we’ll try to use a no pointer

and then we’ll see a crash and then after that I’m going to start using breakpoints where we can stop

automatically inside of our program to print the state of the program print the variables

and then I’m going to do that first in C++ and then hopefully I’ll remember to do that in

assembly right after it’s basically the same thing only with assembly you don’t really have

you know a bunch of variables everywhere you just kind of have registers and maybe some globals

globals but it’s going to be the same deal okay so let’s pretend that uh we are gonna have a crash

okay so this program just kind of runs later on we’ll figure out why the result is wrong we’ll

just pretend that it’s wrong but for now we’ll just say how about we uncomment this line right

here and what will happen is when we’re running the main loop at some point in the loop we get

When F gets called, the input will be looked at here.

And if the input is more than one,

which is definitely gonna happen like right away,

then we’ll call on the G function.

Then the G function will just throw an exception.

We’ll just pretend that something really bad happened.

You crashed or you actually did throw

and you didn’t catch your throw,

or maybe the system threw something at you

or another library threw something at you

and you didn’t catch it.

So just basically a program crash.

Let me run this real fast.

So make run just to show you that the program crashes.

Make run at this point is the same thing as just kind of executing the program.

But you can see that it says terminate called after throwing an instance of runtime error.

And then there’s the message, oh my gosh, and then aborted core dumped.

That’s not good.

So now let’s try to understand why.

Why did that crash?

Pretend you don’t know that it happened in G. You know, you’re trying to investigate.

So we could type GDB and then we could type a file to load the debug symbols, but it’s a little bit faster just to type GDB main and just sort of name the file that you want to load right away.

So if I do that, notice how it automatically tries to load the debug symbols from main.

Then I can just type run and then the program tries to run and notice how it actually catches the crash.

If you look down here, terminate called after throwing an instance of runtime error.

throwing an instance of runtime error so that’s what the program thinks is going on but then the

program is trying to terminate but then down here gdb is like wait wait wait i just caught you know

a termination uh getting invoked here and you can see this is sort of system code like we did not

create this source file p thread kill we didn’t write that that’s the standard library and there’s

a function here called p thread kill implementation with those you know fun c underscore prefixes

prefixes everywhere and so this is like some sort of a c source file and we don’t have that file on

the system so we can’t really debug that file lucky for you most of these standard libraries

work all the time so you don’t really need to debug them you need to debug your code instead

of the standard library code so the question really is how did i get here how did i get to

this crash so the next command we’ll learn in gdb is just the where command the where command will

I’m going to release a video in the future that kind of explains call stacks, but basically

imagine a abstract data type, a data structure called a stack. And every time you want to add

data to the stack, it just sort of stacks up on top of the last piece of data. So like if I add

something, let’s say I want to add the number five, then I would just add the number five on top of

the stack, right? If I wanted to add the number 11, then I would just add the number 11 onto the

off of the stack and the stack is a really good data structure to uh sort of give you a trail of

breadcrumbs to know where you got where did you come from so we call this the call stack because

what’s happening is every single time you call a function then the new scope and then you know the

new function that you’re invoking um it has something called a call frame full of information

current address is and all that stuff.

And we’ll just call that chunk of data that belongs to one instance of a function call.

We’ll just call that a call frame.

And so if you’re stacking call frames one on top of the other,

then we call that whole entire thing the call stack.

And this is what allows us to use recursion and all these complicated call graphs and everything.

It’s really simple, but it’s really powerful.

So you’re looking at the call stack.

Each one of these lines is the call frame or is a call frame.

And so for example, if you just look at number zero here, you’re looking at call frame zero,

which is the closest frame to wherever the crash occurred, which is if you look at it,

that’s exactly what we were looking at when we saw that original message, right? Call frame zero.

So that’s not really useful. You want to go down to higher numbered call frames or I guess

physically lowered number call frames and just kind of scan it until you find some code that

raise no abort no none of this stuff is ours live standard c plus plus no the first frame that

contains code that is ours is call frame number nine or i guess like nine away from our current

position so i guess find the physically highest call frame that is your code or the lowest numbered

call frame that is your code and it’s telling us right here all right we uh we actually seem to

So if I go to 65, right there, it tells you exactly where the crash happened.

If you’re still trying to figure out, well, how did I get to that crash?

I don’t know how that actually happened.

Just keep looking down further in the call frames.

The next one, call frame 10, says, well, we were inside of function f with input equals

three at main.cpb line 46.

So if I just go to 46, I can get another clue.

I can go, all right, so for some reason we called g.

Imagine again, this program is much more complicated.

And then if we’re still confused, we just look down at another one and it’s like, well, this all this whole mess started at CPP main dot CPP line 28.

So if we look at line 28, it’s like, well, we were inside of this loop and we we called the F function and then the F function called the G function.

And then G just kind of did a throw. So that gives us a lot of information.

All right. Next thing we can do is we can sort of move up and down the call stack, because right now we’re sitting at call frame zero, which is just the system code.

which is just the system code, but maybe we don’t understand why the throw actually happened at,

let’s say, line 65, right? So we can use up to go up in the call stack to a different call frame.

So if I hit up, notice how it mentions that we’re now in frame number one instead of zero.

And if I do up again, we’re now in frame two, which is a little bit closer. We can use the

trick finally where we hit the enter key instead of repeating the command. So I’m just going to

and hit enter a couple times until we eventually get to our code,

which I think was supposed to be at frame nine.

So I’m just going to hit it a bunch of times until we get to frame nine.

Now we’re looking sort of back in time at that point

because all these other frames actually did get invoked,

but we don’t really care about what was going on inside of them

because they probably did their job correctly.

We’re looking at our code, so we’re going back in time

right when we were doing this throw.

Oh no, we threw. Why did we throw?

well there’s another command in gdb called info locals

okay the info locals uh there’s there’s really not much to this maybe maybe let me do this again

a equals five and uh then i’ll just say a plus plus just so that we have a local variable

i forgot that gdb doesn’t consider the incoming arguments as locals so there was nothing there

real fast uh gdp oh let’s do make build and then gdp main and then run and then we have a throw

and then i say where and then i go up up up up to a frame you can also use the keyword down if you

go too far if you want to go you know back down in the call stack but i’m just going to use up

okay so now we have it here now finally i think i can do info locals just to see the local variables

notice how the a variable is there now because I just added a local variable a a moment ago

you can also print things directly you can say print the input incoming variable if you’re in

assembly you can also print registers you can say info registers like that and you’ll get a nice

print out of all the registers you could print individual registers you can say let’s print

register r12 you can print register r12 as binary by saying I think it’s p slash t

or print slash t yeah we can probably just do print slash t also

t stands for two because they’re it’s a base two number system

does that mean there’s a p slash h or a p slash f for 15 or 16 s for 16 i don’t know i haven’t

tried that is it going to work hang on p slash s bar 12 it’s not going to work nope didn’t work

i think it thinks it’s a character point or something but anyway so we can print a lot of

So we can print a lot of stuff.

And like I said before, we can go up and down the call stack.

So I can go down a couple times and then go back up again.

And now we can assume that we’ve kind of debugged, you know, where the source of the error was.

So I’m going to comment that call out to G and run the program again one more time with a different error.

So I’ve commented this code out from before, but just imagine now that we’re going to use some pointers.

We’re going to start off with a pointer called P.

a pointer called p we’re going to set it to null at the beginning and then we’re going to just

kind of allocate it and then we’re going to set you know a value and then we’re going to dereference

it and dereferencing a pointer just kind of sets the first value in an array you can do that and

then we’re going to deallocate the pointer and then how about right after that we do something

really really naughty we say p at some index is equal to a five this should be this should be a

a program crash because we deallocated p already at that point we would be dealing with junk data

if we tried to dereference p but to make it even more clear that it’s naughty we’ll set it to a no

pointer and then we’ll try to actually use it so let me let me just restart the program real fast

i’m gonna do quit yes and then we’ll do make a debug just so you know my make debug is just a

Let’s see, where’s that? Where’s that? Where’s that? Do I not have a debug shortcut yet?

Oh dear. I need to add that before this video is over. You know what? I’ll add it right now.

We’ll do this run and we’ll say debug, make debug, and it needs to build first. And then I’ll say

debugging the program. And then we will do the GDB binary and give it an argument of

the executable and then later we can we can upgrade this to take a little script of commands

because the commands are going to start getting out of control so now if i do make debug if i

didn’t screw it up now it at least goes in there and i’ll do run and then we have a seg fault and

notice how it tells us right away hey you have a seg fault right here you’re accessing invalid

memory let’s do info locals just to see what’s up oh the p is actually a zero that’s a null pointer

explicitly oh whoops you know oh what have I done but it’s a really good idea to set your

pointers to null after you deallocate because if you don’t you might end up with undefined

behavior where sometimes the program doesn’t crash while you’re overriding junk data or reading junk

data but sometimes it does and you’re not really sure like why does it work sometimes and why does

it not work sometimes so let me comment this out and see if it’ll crash uh let’s just let’s just

make debug and then i’ll do run and then if we do info locals oh yeah okay so this is uh

it did seg fault so that’s good uh if we were unlucky then the program wouldn’t have crashed

it would have just started behaving strangely and um when we print out the value of p notice how it

looks like a pointer still like if we were to debug the program and print the pointer value

then it doesn’t really it looks the same it looks the same after we deallocated it right so that

this is called a dangling pointer meaning you deallocated the pointer but you forgot to set

it to null afterwards so then later when you’re trying to debug the program it’s a little confusing

because you’re like that looks like a regular pointer what did i do wrong so um it’s really

good practice to set your pointers to null right after you deallocate them that way when you’re

debugging later because something crashed instead of seeing a memory location on p you’ll see

On P, you’ll see something that looks definitely like a null pointer and print P.

Then it’s way easier to realize, oh, whoops, I was trying to use a dead pointer, a pointer that I deallocated.

Hopefully that makes sense so far.

Next thing I want to do is a small upgrade.

I can’t remember if it’s dash X or dash EX.

I think it’s dash X.

But you can write a little script.

I have a little script here called Good Doggo.

called good doggo you can just make any file name it anything you want i’m so i’m just naming it

good doggo.txt because my dog’s taking a little nap behind me as usual um but you could name this

gdb.txt or whatever it is you want so you can put inside of this script file any command that you

want gdb to execute when it launches so let’s just comment this stuff out real fast and i’ll do

I’ll just do run maybe for starters.

Because whenever I’ve been launching for debug,

I launch with GDB and then I type run manually, right?

So I want to save a little time.

So good doggo is the name of the script.

So when I invoke GDB, I am going to,

where is it right there?

Okay, it’s GDB.

And then I’m going to go dot, I think it’s X.

And then I’m going to say good doggo.txt.

If it’s not dash x, then it’s dash ex.

One of those executes the command that comes after,

and one of those executes the command script that comes after.

Let me just double check that this actually is going to work.

So make debug.

All right, okay, so it was dash x.

Dash x specifies a script that will be run.

Dash ex just specifies a command that you can put right in there.

Like I could have said dash ex run, and it would have ran right away.

But the script is more convenient, right?

Because we can save typing.

So notice how it ran right away and then there’s a seg fault.

Okay, so now let’s go a little bit deeper.

Let’s change this to false again now that we understand like null pointers and all that

stuff.

So we can just basically deal a little bit more with only what the main loop is doing.

Suppose we just still don’t really understand what the loop is doing, why our answer is

you know, good or bad.

So maybe I want to do a breakpoint at the top of that for loop.

loop gets to the top of its iteration, I want the program to pause so I can look around.

So I’m going to set up a breakpoint on line 22. And here’s how you set up breakpoints

in GDB. I’m going to go ahead and maybe do the terminal for now. And then I’ll stick that into

the script next. I will not remember that it’s line 22. That’s okay. I’m going to do quit.

And I’m going to do make build. Then I’m going to go GDB main just to jump in there.

and then i’m going to say break or just the letter b just to make a break point you type the name of

the source code file that you want to break in and then a colon and then the line number where

you want it to break so i think i think it actually was line 22 oh i can see it and then

maybe i want to have it break at line i don’t know maybe right here line 25 right before it increases

And then so I’m going to do an up arrow to just repeat the command so I can edit it real fast.

And then I’ll break again at line 28 and then maybe 30 and then 32.

So I’m going to go 28, 30 and 32.

30 and I’m just making up break points.

I just want to inspect the program and then maybe I’ll break at line 36 so I can see what the final answer is.

So I just have a bunch of break points set up.

Remember when the program is running now under GDB, every time it hits one of those lines,

every time it hits one of those lines the program will pause and i’ll have a chance to look around

at the variables and things so i’m not sure if i’ve set up the breakpoints correctly i can say

info breakpoints and it’ll show me all of my breakpoints notice how you can enable them and

disable them so let’s say for the sake of argument i want to disable the breakpoint at line 30 because

maybe i don’t really need that right now but i kind of want to keep it in the system for later

disable four because it’s number four.

It’s breakpoint number four.

So I can say disable four.

Then if I do info breakpoints again,

notice how there’s a little N on there,

meaning breakpoint four is disabled.

So I could re-enable it with a four

and then go info breakpoints again.

So now they’re all enabled.

I am going to maybe copy this into the script file real fast

so I don’t have to keep typing this over and over and over again.

Imagine if every single time you changed your program and recompiled it you had to type all of the breakpoints from scratch

That’s why I want you to use this little breakpoint script

So we’re going to do B to break at main.cpp line 22 and 25 and

28 and

30 and 32. I should have copy pasted the three dang it 36

And after we’re done setting up all the breakpoints

show me the breakpoints just so I can have a visual reminder. Keep in mind if you change too

much of your source code then you’re probably going to have to update these lines and that’s

okay but it’s a good idea to just at least you know kind of look at them a little bit so that’s

why I’m saying info breakpoints. And so then remember again the makefile all it’s doing when

I type make debug is it’s just launching this command right here it’s just saying gdb with the

with my gdb script so let me quit to get out of this and then i’m going to say clear and make

debug and notice how it did all that stuff for me it added the breakpoints it showed me the break

points and then it ran the program like i told it to and then it already broke on a breakpoint it

already break it break breakened it’s broken i don’t know i don’t think it’s broken uh so we’re

So we’re on breakpoint number one on line 22.

And here’s the for loop.

I can type all of my inspection stuff.

I can say info locals.

I can say print I, I can say print A, I can print whatever I want.

And then when I’m done kind of looking around and inspecting things,

I want to continue the program.

I don’t want to just stop it here.

So I’m just going to use the command continue.

And it goes right to the next breakpoint.

If I want to, you know, continue again, I can hit C.

continue again i can hit c or i can just hit enter you know to just sort of keep continuing as i

inspect and print things let’s see when can i get to break point number one is that what’s going on

here hang on a second what is break point number one oh i know what to do info break points

break point number one is that main.cpp line 22 is that actually going to get hit oh it’s

having issues here with my GUI. Okay. Line 22. Okay. So it’s not really hitting that anymore.

I guess it’s not going to think that it hits the top of the forelip. Okay. So I guess breakpoint

two is where we’re always going to be hitting. So let’s just suppose that I’m continuing until

I hit breakpoint number two. Suppose that the next 10 times I see breakpoint two, I don’t

actually want to stop and break on it. I just want to skip the next 10 iterations for some reason.

some reason you can say continue 10 and it’ll skip the next 10 times that it hits the number two

notice how if i hit continue a bunch of times we’re not really seeing the break point number

two anymore we’re seeing other break points and then eventually if i hit it enough times

we’ll probably see two again oh my god oh my god are we seeing it yet no

Okay, wait, are we seeing I’m freaking myself out.

Okay, so let’s continue 10 times on breakpoint three, then we’ll only see

breakpoint four, I guess.

So we can do continue 10 times on breakpoint four.

What is going on here?

Did I write this program in a weird way?

Hmm.

Well, trust me on this.

Let’s continue 100 on breakpoint three and then continue 100 on breakpoint four.

breakpoint 4. Okay, so now we’re just done with the whole entire program. I guess there must have

been a 2 there that I missed. So now we’re finally on breakpoint 6, which is when everything is

finished. Let me show you real fast that we can add more breakpoints in assembly just to prove

that we can debug assembly real fast. So if I want to debug assembly, I just have to type the name of

that source code file. If it was nested in a folder, like if you had like a complicated hierarchy of

of source code files you would just need to type the relative path but for now I’m just going to

be able to type the name of the file so assy.asm and let’s suppose that I want to break at line

16 just so I can see the registers that I set up so I’m going to do 16 and then I’m going to break

at assy.asm line 16 and then I’m going to run and that actually never gets called does it no no it

called does it no no it gets called I think I have a call up here somewhere

nope I don’t have a call okay let’s make a call this is gonna throw off all of my

C++ breakpoints so I’ll just comment them all out right now comment them all

out so I don’t have to redo them and this is a hybrid program so I’m gonna go

extern what is it extern C make a block where I name the function the reason we

name mangling so the AC symbol is going to show up as just its regular function

name rather than a bunch of extra stuff indicating the prototype so that we can

do overloading so we’re just going to disable that and then at the very top of

the program I’m just going to call it this should hopefully work let me just

do a regular make run just to make sure the whole program compiles okay now

debug script we’re gonna break on line 16 which is going to be letting us see

the registers okay so I’m gonna go make debug notice how it hit the breakpoint

in the assembly just the same as the C++ and we can print whatever we want now so

I’m just gonna say info registers and if we look carefully we can kind of see

that we modified racks REX is 15 so that’s expected RDI is 20 which is

R12 should be a giant number. Where’s R12? Right there. So you can see the state of your program at any point in time just by breaking on it.

I’m breaking on a certain line. So this is tremendously useful for debugging not just for higher level languages but also assembly.

What else can I do? Oh let’s put a global in the data section. So I’m gonna do, I don’t know, my thing or something like that and we’ll call it a byte array and I’ll just go hello.

I’ll say we have a thing one and a thing two.

Something like that.

And maybe thing two is a null terminated string,

whereas thing one is a regular thing.

We should be able to print those symbols.

If that’s not true, I’ll come back at a later time

and show you how to do it.

Anyway, so we’ll do make debug

to just kind of assemble everything again.

And we know how to do info registers.

We can print, you know, one register in particular,

print R12 if we wanted to.

History has not reached.

History has not reached 12.

Oh, I got to put R12.

Yeah, then we can get the, wait a minute, wait a minute.

Oh, I threw off the line numbers because I added the variables up here.

So now we’re going to break at 21.

Let me just fix that.

21.

We’ll do a quit.

Make debug again.

And now we’re at 21.

If I say info registers, we can see R12 is that big value.

you, but we can also print R12 directly. And we should be able to print my thing one, hopefully,

has an unknown type, oh, we have to cast it. So we can do like basic casting in GDB. So I’m going

to say this is a character pointer. Remember, all of the assembly symbols are basically pointers,

unless it’s an EQU, EQU variable. In that case, it’s more of a define. So I’m going to print

and then it says error cannot access the memory add address

what the heck did i do wrong how about that cannot access that all right i’ll come back in

another video because this wasn’t something that i prepared for just to print strings in globals

i’ll come back at some later date in the future like five years from now and i’ll just show you

how to print globals but i hope if you’re in assembly you probably don’t need to worry about

You just have globals, but the real problem for you is going to be what’s inside of your registers and so forth.

You can also deref, I think.

Let me see.

Okay, I’m going to move on from that.

So anyway, we got a script and we got a lot of basic GDB commands.

Is there anything else that I wanted to show you?

Let me just look at my notes real fast here to make sure I’m not forgetting to say anything.

make sure I’m not forgetting to say anything.

So we’re going to do debug symbols, console, quit, attach to binary,

launching the program, uncaught exception, breakpoints, info, delete,

enable, disable, run, continue, end times, info registers, printing.

Oh, we can print a register in binary.

Forgot to show that.

So we are at a breakpoint, I think.

And if we printed R12 with the regular print, we can also do P slash T to just

p slash t to just sort of print it in binary if you want to i think i might have said that already

either that or i said that like a couple days ago to some and then we can do info locals and

then print a variable and then we get the script file and then we can quit okay so i think this is

pretty much everything that i wanted to show you you now have a basic idea of what we can do inside

of gdb but keep in mind there is so much more you can do in gdb than i can fit in one video

can type help and you can see a list of other major you know areas that gdb can handle um you

can do uh let’s see i think it’s help and then like we’ve got information on aliases breakpoints

data you know whatever we can do i think help breakpoints to see more information on breakpoint

commands yeah so all of the things you can do with breakpoints is like all of these commands here

one page we have to enter to see one more page or see to see all of the results without using

paging anymore so i’m just hit c and so there’s like you know we can save trace points we can

try to catch exceptions we can enable disable break points there’s like unwinders which i’ve

never even used we can bookmark things we can you know start tracing memory we can rethrow

variables so just keep in mind gdp is incredibly powerful this video barely scratches the surface

but for a programmer who is new to debugging i think this will be very useful to you i hope it is

anyway thanks for watching this video i hope you learned a little bit of stuff and had a

little bit of fun um i will see you in the next video rest yourself and take a nap and have fun

and hug your your loved ones okay I’m out see you later hey everybody thanks

for watching this video again from the bottom of my heart I really appreciate

it I do hope you did learn something and have some fun if you could do me a

please a small little favor could you please subscribe and follow this channel

channel or these videos or whatever it is you do on the current social media

website that you’re looking at right now it would really mean the world to me

and it’ll help make more videos and grow this community so we’ll be able to do

more videos longer videos better videos or just I’ll be able to keep making

videos in general so please do do me a kindness and and subscribe you know

sometimes I’m sleeping in the middle of the night and I just wake up because I

know somebody subscribed or followed it just wakes me up and I get filled with

That’s exactly what happens every single time.

So you could do it as a nice favor to me,

or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe, and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now,

you should see a QR code, which you can scan in order to go to the website,

which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website,

where you can just kind of like see all the videos I published,

and the services and tutorials and things that I offer,

and all that good stuff.

things that I offer and all that good stuff. And, uh, if you have a suggestion for, uh, uh,

clarifications or errata, or just future videos that you want to see, please leave a comment.

Or if you just want to say, Hey, what’s up, what’s going on? You know, just send me a comment,

whatever. I also wake up for those in the middle of the night. I get, I wake up in a cold sweat

and I’m like, it would really, it really mean the world to me. I would really appreciate it. So

watching this video and enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master GNU Debugger: Debug C++ & Assembly Programs with GDB Like a Pro appeared first on NeuralLantern.com.

Get a clear, fun breakdown of data sizes in x86-64 CPUs! This video covers bytes (8 bits), words (16 bits), D words (32 bits), and quad words (64 bits), plus how they fit into assembly and CPU registers. Perfect for programmers, students, or anyone curious about low-level computing. I’ll walk you through the basics with relatable examples, no jargon overload. Subscribe for more coding & tech videos, and scan the QR code to visit my site for extra tutorials! Leave a comment with your thoughts!

Introduction 00:00:00
Data Sizes Overview 00:00:01
Byte Definition 00:00:44
Bits to Bytes Conversion 00:01:27
Word Size Explanation 00:02:20
Double Word (D Word) 00:04:03
Quad Word Definition 00:04:44
CPU Registers and Memory 00:05:21
Conclusion and Outro 00:06:07
Call to Action 00:06:32

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there.

I’d like to talk to you about data sizes within the context of x86,

64 CPUs,

just like 64 bit CPUs for assembly and just whatever.

So what’s going on inside of the machine and how do we describe the sizes of

various clumps of data? So for starters, you know,

of your computer, there’s just a bunch of ones and zeros represented in all the wires,

in all the circuitry.

The human beings with feelings decide, oh, you know, I’m going to take a group of this

many bits, this many ones and zeros, and I’m going to say that it is something else.

I’m going to call it an abstract unit.

So the first thing that we do is we have something called a byte.

That just means eight bits.

So we can say one byte equals eight bits.

equals eight bits. I don’t know why I hit the shift key there. That’s probably going to mess

up my annotator. Nope. Okay. So what is eight bits? Just as a little reminder, you know, we’ll

just say one, two, three, four, five, six, seven, eight, or it could be, you know, something more

random looking one, two, three, four, five, six, seven, eight, you know, so like inside of the

machine, we have eight ones and zeros for eight bits. And when we group them together, we’ll just

Okay, no problem.

So that means by the way, if somebody says,

oh, my internet connection is this many megabits a second.

If you wanna know how many bytes a second,

try dividing by eight.

Or if somebody says I have this many megabytes a second

of transfer speed, try dividing that by eight.

You know, so multiply or divide by eight

to get the right number.

Okay, so if we had two bytes together,

that’s just gonna be 16 bits.

No problem there.

I’m just going to copy paste these bits and you don’t have to do this.

But for me personally, I like to put a little space in between bite groupings just to help

my human brain kind of see, oh, I’m looking at two bites right here when I’m referring

to different data sizes.

So then eventually we kind of need an idea of, you know, let’s come up with a different

word that means more than one bite.

ironically based on what I just said the the term we’re going to use is word a word

the size of a word just kind of depends on the system that you’re on on my system

the size of a word is two bytes so I’m going to say one word equals two bytes

and you can imagine that’s 16 bits maybe I should start doing the double equal sign here just to be

Okay, so equals two bytes.

It also equals 16 bits.

And you can imagine it’s basically the same thing

that we just wrote up above.

So I’m gonna erase this actually, 16.

Oh, I put an E there, embarrassing.

Okay, so one word is two bytes.

Again, the size of a word depends on your system.

If you’re not sure, you should probably look it up.

What’s the word size on my system?

But again, the typical system here in 2024

6664 machines running Ubuntu, um, or just like Linux is going to be like, you know,

two bytes. Okay. So now, uh, we have like words that we can do. So if I had, uh,

let’s say I had two words, uh, two words is going to be double of what we just wrote. Right. So

that means we’re going to have this many, whoops, I blew it. We’re going to have this many bits.

So two words, two words is going to be equal to, um, 32 bits.

And it’s also going to be equal to four bytes because, you know, we multiplied everything

by two.

So this is like four bytes.

So now we need another term to represent this two words, which is four bytes, which

is 32 bits.

We can also call that a D word.

Actually, I’ll say D word like that.

And what does D word mean?

is twice the size of the word length on your system.

So like if we decided our word length is two bytes,

then a D word is four bytes and that’s it.

Four bytes is 32 bits.

You might notice this is similar to like old school CPUs

that ran in 32 bits and maxed out their RAM

at about four gigabytes.

So let’s come up with one more term here.

Let’s come up with the term quad word.

Actually, we’re not coming up with the term.

We’re just using it.

What is a quad word?

A quad word is two D words.

So we’re just kind of doubling it again.

I forgot that extra equal sign there.

Quad word is two D words, which means it’s also four words.

And it also means it’s eight bytes.

64 bits.

And then I guess if I want to represent this to you,

I can just kind of like copy paste that twice.

And this is the size of the memory address space that we have on modern CPUs.

This is also the size of your general purpose registers in modern 64-bit CPUs.

So if somebody says, hey, I got a quad word.

I want you to store it somewhere.

You can instantly think to yourself, well, obviously I could put it in memory.

I could put it in memory.

You could also just put it directly into a CPU register.

And that’s it.

This also means that you could put two D words into one CPU register if you were very clever.

You could also do the same thing.

You could put like four words inside of one CPU register.

Because the CPU registers, they’re always the same size no matter how you use them.

They’re kind of hardwired.

So I hope this has been, you know, kind of helpful.

These are the basics of different data type sizes that we have in CPUs and

assembly language. I’ll see you in the next video.

Hey everybody. Thanks for watching this video again from the bottom of my heart.

I really appreciate it. I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

Follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So, please do do me a kindness and and subscribe

You know sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed

and I get filled with joy. That’s exactly what happens every single time. So you could do it as

a nice favor to me, or you could, you could troll me if you want to just wake me up in the middle

of the night, just subscribe. And then I’ll, I’ll just wake up. I promise that’s what will happen.

Also, uh, if you look at the middle of the screen right now, you should see a QR code,

which you can scan in order to go to the website, which I think is also named somewhere at the

bottom of this video. And it’ll take you to my main website where you can just kind of like see

and tutorials and things that I offer and all that good stuff and if you have a suggestion for

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever I also

wake up for those in the middle of the night I get I wake up in a cold sweat and I’m like this

it would really it really mean the world to me I would really appreciate it so again thank you so

thank you so much for watching this video and enjoy the cool music as as i fade into the

darkness which is coming for us all

Thank you.

The post Master Data Sizes in x86-64 CPUs: Bytes, Words, D Words, and Quad Words Explained appeared first on NeuralLantern.com.

Hey there, coding enthusiasts! Ready to master compiling, linking, and executing programs on Linux? In this fun and approachable video, we dive into the nuts and bolts of turning your code into runnable programs. We’ll create a simple C++ program, compile it with G++, and explore object files, linking, and execute permissions. Plus, we’ll mix in C and assembly code, tackle name mangling, and build a bash script to automate it all! Perfect for beginners or anyone curious about Linux programming, this guide is packed with practical tips and real-world examples. Don’t miss out—subscribe for more coding adventures, leave a comment with your thoughts, and let’s geek out together! Scan the QR code to visit my site for more tutorials. #LinuxProgramming #CodingForBeginners #CPlusPlus

Introduction to Compiling, Linking, and Executing 00:00:00
Overview of the Process 00:00:05
Writing a Simple C++ Program 00:00:28
Compiling with G++ 00:02:01
Understanding Executable Files 00:03:04
Executing a Program 00:04:21
Handling Execute Permissions 00:05:13
Creating a Compile Script 00:07:00
Using Shebang for Scripts 00:08:43
Specifying Output Files 00:10:53
Breaking Down Compilation Steps 00:12:26
Compiling to Object Files 00:13:17
Linking Object Files 00:15:24
Handling Multiple Source Files 00:18:39
Mixing C and C++ with Name Mangling 00:22:52
Enhancing Script with Error Handling 00:24:29
Adding Assembly Source File 00:31:16
Using Bash Variables for Flags 00:41:53
Organizing Compiler Flags 00:44:41
Final Script Enhancements 00:46:36
Conclusion and Call to Action 00:47:35

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there! Let’s talk about compiling, linking and executing.

This video is going to focus on Linux, but I think it’ll be useful for all other operating systems that you might be working with at home.

I’m just going to basically explain like what does it mean to compile?

What does it mean to link a program?

What does it mean to execute a program?

If you don’t know that, then I think this video might be for you.

Okay, so for starters, imagine you have written a program.

I’m going to write the program here real fast.

I’m going to say, let’s do an empty file.

We’ll call it, let’s see, I got my answer key up here.

We’ll call it first.cpp.

First.cpp.

So I’m just like making a first piece of source code and I’m editing it in my little editor.

Notice how I’m not calling this the main.cpp program because a lot of beginners, they always

do main.

I want you to know that you don’t actually need a source code file called main.cpp.

Even if you’re writing a C++ program, all you really need is just one instance of the function main.

Beyond that also, you only need an instance of main if you’re writing a hybrid program

or some kind of program that is in pure C++ or that has the GCC libraries.

GCC libraries call on the main function as your entry point.

But if you’re writing pure assembly, the entry point is actually underscore start as a label.

We’re not really going to do this is not an assembly tutorial.

I just wanted you to know real fast.

Okay.

So I’m going to do like IO stream and then I’m going to say

STDC out and I’m just going to print, you know, hello from first.

Cpp.

STD.

And L.

Okay.

So we kind of have like a hello world program that’ll just

that’ll just basically print a message and do nothing else how do we compile

this program and execute it you know what does that actually even mean okay

so for starters the first thing that you probably do when you’re compiling a

program you’ve probably been told to do something like this let me get my little

command line open here you’ve probably been told to do something like this

let’s compile with GCC or G++ and we’ll say the standard for C++ that we’re

There are a bunch of other standards you can use.

We can turn on all warnings.

We can have the compiler be pedantic in terms of the warnings that it gives us.

You know, these two things at the end don’t really matter that much.

It’s really all about G++ and then STD C++ 23 to get it compiled.

And then we’ll give an input file.

We’ll say burst.cpp.

And then I think probably usually this is where most of you stop.

you stop we just kind of like specify a couple flags specify the input file then

hit enter and it compiles if we list the contents of the directory now this might

be familiar you’ll probably see something called a.out a.out notice how

the permissions look a little bit different for that for that file it’s

kind of printed in green in Ubuntu and if you look at the left side right here

you can see that it’s got a bunch of X’s in the permissions area that just means

That just means it has execute permission.

The compiler does that automatically for you,

but essentially this is like just, you know,

an executable binary file.

It’s not a text file.

It’s just something that the computer is meant to run.

We can look inside of it real fast.

There’s a program called XXD on Linux,

and it’ll sort of spill the contents of that file.

So if I say XXD and then I go a.out,

it just spills like a whole lot of like binary nonsense,

right?

you can see at the very beginning elf that’s uh i think that’s executable linking format

for linux and then there’s like a bunch of stuff and it just doesn’t make sense this is not text

that you can read here’s like some sort of a shared argument that it’s using and then some

register information i don’t even know what most of this is somewhere in here if you look

carefully you’ll probably see that message where is that oh yeah hello from c first.cpp so it’s

saying that the message we typed in the program is actually embedded in the executable.

That makes sense.

So hopefully I’ve proved to you that this is just an executable program.

How do you execute the program?

Well, usually you’ll have to type, you know, the full path to the program that you want to execute

because your custom program is not in the system library paths.

So your system’s not going to know where to find it automatically,

even if it’s in the current folder.

So you would usually do something like, you know, the full path to your executable,

path to your executable like a.out. But there’s a shortcut we can use in Linux. The dot directory

usually just means or it always means the current directory. So if we say dot and then a slash,

that’s the same thing as typing out the full path to the current directory. Then it’s really easy to

just type the name of the file that we compiled. Okay, so a.out. We executed it now. So that’s what

it means to execute. We just compiled without a lot of options. We’re going to try to do that better

We’re going to try to do that better in a second.

And we know that you need execute permissions.

Let me show you what happens if we take away execute permissions.

I’m going to use a command called chamad, like change the mode.

I’m going to say take away execute permissions from the a.out program.

Then if I list the directory again, notice how there are a bunch of X’s missing now

on the left side of that a.out permissions area.

Notice how it’s not in green anymore.

Depending on your system, it might not be green or gray or whatever.

be green or gray or whatever but just look at the permissions so now if i do a dot out

it’ll say permission denied maybe you’ve seen this before especially if you’re syncing with

the cloud that doesn’t carry execute permissions from one machine to another which happens to me

all the time we can reverse this with just the chamad you know plus x execute permissions

and then we can just execute it again the funny thing about execute permissions is

you can actually execute a bash program which is basically a text file without

without needing to execute a binary program so this is not a bash video I’ll

make other videos in the future on my channels for for bash but for now just

know that something you compile is not the only type of thing that you can

actually execute in fact in Linux under the hood a lot of system tools are just

written in bash or Python or something else that looks like a human readable

like a human readable language and they are not necessarily all compiled languages, you

know, like C++.

Okay, so now that we kind of know that we’re compiling a program, let’s be a little bit

better about specifying the name of the output file.

So I just want you to see one more flag here and while I’m doing that, I’m going to create

a script that will compile our program for us.

nano and I’ll just name a file I’ll name it compile and it’ll be our compiler program okay

so what we did before is it was I think G++ and then we named the standard is C++ 23 and then we

said wall wall just means give me all warnings which is good to help your you know to help you

write better code same thing for pedantic just helps you write better code it gives you more

but you know it’s pretty good. Okay so this is where we stopped last time so

I’m going to say now let me remove a dot out now instead of typing the command by

ourselves we can run the compile script. The language I’ve just written was was

well I haven’t really written in any particular language but if we use a

shell interpreter called bash which is actually what’s running in the terminal

right now it’ll interpret any command line that we give it as just something

line that we give it as just something that we want it to execute to the system. So if I type

bash to run the bash interpreter and I just specify the name of the script, it should compile the

program automatically by executing that one line that I put inside of it. See now I’ve got the a.out

again. If you rewind the video you’ll see the a.out wasn’t there when I originally ran it.

One more time just to prove it to you. bash compile. Now you can see that it’s back. Okay

Okay, so let’s make this compile program a little bit better instead of typing bash every single time

I think I just want to try to execute the compile program directly. I

Can do that pretty easily. There’s something in

In our script that we can put that will designate what interpreter we should use to run the program

So right now it’s just like some text and it doesn’t really mean anything

there’s something called the shebang which just means hash bang and

just provide the path to some interpreter. I’m going to type shebang and then a path

to the bash interpreter. If you don’t know where bash is on your system, you can go which bash.

And I guess mine is a user bin bash. I think I can get away with bin bash. Let me see.

Let me just type it out to make sure bin bash. Yeah. Okay. So if I type exit, I’m actually in

another version of bash, which is inside of bash. If I do exit, I should just kind of stay where I

Okay, so bin bash will work, user bin bash will also work.

I’m going to go back to editing this compiler program.

And now all I have to do, because the system is going to know what interpreter to use to execute my little script program here,

all I have to do is add execute permissions on it, and it should work.

So let me first remove a dot out.

And then let me try first to execute compile.

It should not work because I don’t have execute permissions.

Remember we talked about that before.

permissions. Remember we talked about that before? So if I do that it says

permission denied. Oh no! So I’m going to give it permission to execute. I’m going

to say change the mode plus X on compile. If I list the directory again notice how

it’s green notice how there’s a bunch of X’s everywhere. So now I should be able

to just say compile and then it seems to have worked and notice how it has an

because it’s a pain in the butt to type out all the compile commands every single time,

especially if you have a complicated compile command or many files that you want to compile

in the same shot. So, you know, of course, in another video, I’m going to talk about make files,

build systems, proper build systems are a lot better than just making a script. But for now,

let’s just make a script because I just want you to understand, you know, compiling, linking,

some of the surrounding ideas. Okay, so I’m going to, let’s see, I’m going to go nano compile.

And the next upgrade that I want to make is I want to specify the output file because it’s

kind of a bad idea to not specify the output file and just hope that the compiler gives you

the file that you wanted. I don’t know. So I’m going to do dash O main, and that’s going to give

So if I remove a.out just to keep my area clean, I can now do compile.

And if I list again, notice how I’ve got main.

So I can execute main and it’s the same program that we already had.

In fact, maybe sometimes just as a shortcut since this is a script,

what if I’m always hitting ls-la, I always want to list the folder after I compile.

I could just put that into the script.

The more commands you put into the script, the more convenient things can get, unless

I guess it gets too messy.

So I’m going to do, I’m going to list first, and I’m going to remove main, just to prove

to you that we’re doing this from scratch, and then I’ll do compile.

Notice how it compiles and then lists everything for me.

Seems like it didn’t actually turn the compile green.

That’s probably another flag that we have to stick in there.

Let me see if I can do that real fast.

If not, I won’t waste time.

This is not an LS video.

probably color or colors is what I got to do. Let me just do that one more time. Yeah, okay. So

that’s just a flag on LS. That’s not what this video is about. So now we’re compiling directly

to main, but here’s the problem though. We’re actually kind of sort of skipping over some

steps that we could be aware of. When we compile our program, we’re actually taking our source code

and we’re assembling it down to assembly code under the hood, and then we’re compiling it to

And then we’re compiling it to an object file, which is sort of just machine code.

It’s like a level lower than assembly.

And then as a last step, it’s getting linked into an executable named main.

So we’re skipping a ton of steps.

Really what’s supposed to be happening is every single source file.

Oh, whoops.

I’m on the wrong machine right now.

Okay.

Where’s that?

Oh, the machine that I’m recording on.

There we go.

CPP and we’re thinking that it just goes directly to main you know that works if you only have one source file or if you don’t want to have

fine-tuned control over your compiling

But I would like to do something a little bit more detailed. Let’s compile our

CPP source file into an object file. I’ll name it first.o and then we’ll link that into main

Why is that useful because later when we have multiple source files?

We might we might want to compile them all to object files first and then link them all together in one step into main

all together in one step into main this will be even more useful when you later realize that you

can use a build system that does kind of the same thing to save compilation time i won’t talk too

much about make files here but let me just tell you when you start using a build system

your compile time can be drastically reduced uh story i used to have a program a long time ago

that i wrote myself took like an hour to compile i would literally every little change i made i’d

have to get up and leave and go make a sandwich or something and then come back by the time it

back by the time it was finished compiling when i started using object files as intermediate steps

and upgraded to a build system i was using gnu make then my compile time went down to like a

minute each time so it was like so much more efficient anyway let’s do that let’s do that now

let’s let’s uh let’s nano our compile script and you just need another flag in here for the gcc

an object file and not actually produce a fully linked executable that you can execute that means

i should probably rename main to something else because main is supposed to be my executable at

least that’s what i’ve chosen i would like to have every object file be named similarly to the source

file it belongs to so i’m going to type the output now is going to be first.o and then the c flag

just says only compile don’t link this means of course that i’m not going to produce a program

a program that I can run. Let’s see, I’m gonna end up accidentally deleting the

compiler. Okay, but we can see what we’re doing. Okay, so compile and CPP for first.

So I’m gonna compile it and now notice how we have an object file and no main

and just the source file and its corresponding object file. So I can’t run

this program. I have to do the additional linking step now. So I’m gonna do

step now so I’m going to do compile and in my editor here let’s see where is my

command that I wanted to do for linking okay so I’m going to link with the the

GCC libraries I’m gonna use the G++ command I’m just gonna put a couple of

flags I’ll explain them real fast I’m gonna say that I want a 64-bit

executable which you probably actually don’t have to specify I’m going to

anyway and then I’m gonna tell it again that I want it to link up against the

23 libraries. This is important if multiple modules reference the C++ libraries. I’m not

even sure. I think I need it in both the compiling command and the linking command. I’m going to

leave it in both because it should work. Usually if you want to embed debugging symbols into your

program, you want to put a dash G there, which is a great idea. But we’re not going to talk about

debugging in this video. You can also specify the type of debugging symbols that you want.

symbols that you want I’m just gonna put that in here right now G dwarf 2 and

then there’s some new flags that you kind of need there’s one here called no

PI which I think is just an Ubuntu thing your program probably won’t execute if

you don’t do that just just put it in there and trust me there’s another one

that we have to put in now called no exec stack which basically prevents your

program from executing code sitting inside of the stack which is just sort

not get hacked hopefully it’s not bulletproof but you know it might help

and then i’m going to give it input files the input files for the linking

stage maybe i should do a comment linking stage

compile the c++ program or source or something

for the linking stage uh you want to you want to provide all of the object files

that you’re going to link together in this case we just have you know

file named first and then we can specify the output file as main if we didn’t

specify it would probably be a dot out like we saw before so if I got this

right let’s see if I did now this should compile the C++ source code file into

its corresponding object file and then scoop up the object file turn it into an

executable okay so my clear and then list and then I’m gonna remove the object

put star dot o which is a shell trick to basically say that that star dot o is

going to expand to really mean every file that ends in dot o so you know in

this case it’s actually just gonna end up being first dot o but it’s a trick you

can use to grab multiple object files or files of a certain type all in one

command so I’m gonna do that and then I’m gonna list again and then I’m gonna

compile and you can see that the compile command it created first dot o the

the object file, and it also created the executable main.

So if I execute main, the same thing should happen.

So great. We’re ready to move on to another step.

Let me remove star dot O.

I got to be so careful because I’m going to totally ruin this video by erasing the wrong thing.

Okay. Because this is, I should be in a Git repository, but I’m trying to be fast here.

Okay. So let’s nano compile.

Let’s create a second source file actually.

Okay. So let me get out of this.

Let me get out of this.

I want to create a second source file.

I’m going to call it second.c.

It’s going to be a pure C program.

And because we don’t have C++ libraries in C source files,

I’m just going to say, you know,

standard input output dot O for the header.

I’m going to make a function called void second probably.

And it doesn’t do anything except just sort of print

a little message.

So I’m going to say hello from second.

And then do a new line.

because we don’t have endels in c all right i think that’s probably going to work so then

let’s uh edit our compiling script and we’ll just add another line here to compile the c source

okay so i’m going to go gcc because it’s not c plus plus anymore and um i’m going to do all

warnings and pedantic again uh you don’t really need even need to worry about that and i’m going

need even need to worry about that and i’m going to give it an input of second.c because that’s the

file we just worked on and i’m going to tell it i only want you to compile with the dash c flag if i

forgot that on this one then i’ll probably end up with an object file a main and then an a.out that’s

only based on the c source code and that probably wouldn’t work because the second source code

doesn’t have a main function inside of it so um let’s see we’ll do output and it’s going to be

and then I think that should be okay you know something that I just realized I

should mention too is when you’re making hybrid programs like this or or

programs where there are just many many source files like I said before you

don’t need to have a source code named main.cpp you can name all your source

codes anything that you want the one thing that you really do need is a piece

of source code oh I’m editing inside the terminal suddenly sorry I got

Sorry, I got sidetracked.

I wanted to edit all this stuff inside of Genie because it’s a little bit better.

Maybe it doesn’t matter.

So notice how we have the main function inside of our first.cpp program,

and then there’s no main function inside of our other source codes.

For your program that uses the GCC libraries, you need exactly one instance of main.

so that means um you know you have to have at least one and if you have more than one it’s

probably not going to link so if i put a main inside of here probably not going to work

this also kind of means you can arrange your source code in a funny way you could

have a bunch of different pieces of source code that you could consider maybe libraries maybe

there are a bunch of classes or something that will help your program and you can release multiple

different executable files by just having different source code files each with their own

mains and linked separately against the object files that contain your library or classes or

whatever that’s just a little side tip but um anyway let’s see if i actually did this right

we’re linking this and i’m going to see if it works i get stuck inside of the terminal i start

thinking i’m going to edit everything inside there okay so it compiled well let me let me

remove the main and then just clear it again in the list okay so now I’m gonna

run the compiler and after the compiler ran everything seemed to be okay it

compiled first into its object file and it also compiled second into its object

file if I run the main executable notice how it only prints hello from first dot

CPP well what about the second one that we just added well what we need to do is

improve our linking stage notice how in the linking stage right here we just

stage right here we just only link first.o so we should also include the other object file that we

want i’m going to glob that in a second but uh let me show you compile now if we run main

what did i do wrong hold on let’s see here second.c oh i forgot to actually call the second

function so that’s cool just uh wrote a bunch of stuff for no reason at all let me uh let me have

have the main function call on the second function we’re going to encounter an issue here too the

second function is written in c and the first function uh its its source code is in c plus plus

and the thing is c plus plus uses something called name mangling i won’t go over it too much in this

video but it uses name mangling so you can overload functions you can have functions with the same

name but like different signatures right so it’ll go in there and it’ll mangle the name of a function

the name of a function according to its overload prototype so that we can actually call overloaded

functions but we don’t really have that in C so that means if we try to call a C function

from C++ we’re probably going to end up calling the wrong name because there’s the expectation

that the other module has name mangling enabled but it’s not because it’s C so I just have

to do this little block extern C and just name all the stuff that is not going to be

name mangled i’ll just provide the prototypes of all the functions that i want to be able to call

so just void second if you look here again we just have void second and now when um when the c plus

plus module calls on second it won’t expect name mangling so it should work so we’re calling it

and then we linked it now everything i think should be okay i’m going to compile one more time

and then i’m going to run the main program and now you see that we have both calls in there

Awesome. Let’s give this script a little bit more output though. This is kind of

precarious. What if something failed inside of there? Maybe you don’t want the script to continue

if something fails and maybe you kind of want to know where the script is at while it’s compiling.

So I’m going to upgrade it just a little bit. So compile the source. I’m just going to say echo

compiling the, you know, compiling burst.cbp. And then here I’ll just do another echo and I’ll say

and then here I’ll say echo linking the executable or the binary aka the binary

I don’t even know if that’s the proper term I just like to call these things binaries because

they’re not in text anyway so if we do another I’m going to do I’m going to do a compound

command line here I’m going to go clear and compile so that I don’t have to continue to

continue to clear every single time. Now notice how it prints what it’s doing. So if it kind of

failed somewhere along the way, or if it took a long time, you’d kind of know what’s going on.

Now let’s use a little bash trick, because remember this is a bash script. It’s not just

going to only execute actual commands. I’m going to say or exit with the return code of the previous

We’re going to try to execute G++.

If G++ fails for some reason, then the whole program or the whole script is going to exit

and it’s going to exit with the return code mentioned here.

I think it’s not going to print it.

I’ll show you how to print it in a second, but we can actually make a function called

die up here in a second, which might be better.

So I’m going to do the same thing over here.

I’m going to say or exit with the return code of the GCC command and then here or exit with

And then here or exit with the return code of the linking command.

We’ll do it one more time here.

Notice how it seems to work.

So now let’s make the first C++ program not actually compile.

I’ll put a bunch of Zs there.

And so if we try to compile it again, it should just quit right after it tries to compile the C++ program.

So that saves you some time and helps draw your attention to what went wrong.

The C++ compiler is saying hey, there’s like a type there. It doesn’t show the exit code though. So let’s make a function in bash

That will die and print an exit code. So I’m going to say do die or maybe just die by itself something like that

Functions whoops. I’m in the wrong language

Let me go back to the compiler

make a function in bash

Called die and it’ll take one argument and the argument will just be the exit code

that we want it to alert us of.

So I’m going to say echo,

I’m going to say we are dying now.

Previous exits code was,

maybe I’ll do a little variable here,

I’ll do a local variable.

Exit code is going to be the first incoming argument.

This is a bash program, not C++.

And then here I can just say exit code.

Okay.

So then after writing all that,

then after writing all that I can say or die and then just you know so I’m calling

a function and the first argument I’m giving it is the actual exit code of the

thing that died so we’re just kind of like using indirection to print a pretty

pretty message to get a little bit more information so we’ll try that one more

time notice how it says we are dying now previous exit code was one so that just

that just tells us that gcc exited with the exit code of one not super useful but it’s nice to see

could be something else entirely like i don’t know maybe uh maybe we misname the first source

code file let’s see if the code changes i think it probably will nope maybe this exit code was one

no such file or directory all right exit code am i doing something wrong i guess i’m all right

Alright, okay, so let’s just move on.

I wanted it to be fancier.

We could also upgrade a little bit if we wanted to.

Instead of echoing, I could make a function called log here,

and I could just say that the log command just echoes,

and maybe we’ll put a cute label, and we’ll say, you know,

my super cool program compiler, or how about super cool compiler?

And then just do the $1, because that’s the first incoming argument that you get.

the first incoming argument that you get now I can type log instead of echo so

that’s nice and why would you want to do this well now it’s gonna go inside of a

function which means later on you can start adding extra commands like logger

a log to the system daemon oh no so this would write to your system log in

addition to printing something you could do anything you want you know it’s just

like a regular program adding more power by sticking everything inside of

functions I’m gonna put log here and let’s see if it works

let’s see if it works pile okay nice notice how we have a little message with a little header which

seems pretty cool maybe instead of echoing here let’s make a complaint function let’s do a

complain and same thing as the echo function but maybe I think there’s a flag where you can tell

echo to print to standard error instead of standard output but I’m just going to do it the easy way

it the easy way I’m going to say one goes to two so that the the first pipe standard output is going

to be redirected into the second pipe standard error so now I can use complain instead of um

echo down here complain before I die oh I forgot to actually

or die I forgot to actually exit so that means it was oh yeah it’s still compiling everything

Let me fix that.

So in the actual die function, hopefully you were at home cringing along with me.

Let’s see, let’s exit with the actual exit code that was specified just to make things

a little bit more automatable.

Yeah, now it stops right away.

And the complainer is like, you know, pretty cool.

Let me fix the first source code real fast.

And we’ll say that the second source code is broken.

We’ll put a bunch of Z’s there.

So now the first one compiles, the second one, it breaks.

And we’re starting to, you know, get a hang for a compiler script that’s a lot more sophisticated

than just typing things on the command line, right?

You can take this as far as you want.

The next step above this is using a proper build engine.

So let’s see.

Well, let’s do another source code.

an assembly source code. So we’ll say third dot ASM and it’s just going to be Yasm. This is not

a Yasm or assembly tutorial. I’m just showing you how to, you know, build a, you know, compile,

link and execute. We’ll make a data section so I can just stick some defines in here real fast.

I’ll say system write is going to be equal to a one and then the file descriptor for std out

Do you ever feel like red jumps out at you on the screen?

Does that mean I have eye problems?

I am kind of old now.

I don’t know.

Hello from third dot ASM and I’ll just put a little new line there.

So I don’t have to do it elsewhere.

And then I’ll have to specify the magic message length because this is not a sophisticated program that can loop through the message looking for a null terminator.

And then I’ll do a text section, which is where your code goes.

which is where your code goes and you know in hybrid programs if I have this

third function which is marked as a which is marked using a label and then

in return statement I still have to mark a third as being accessible outside

this module so I’m going to do the global statement and then I’m just going

to do really quickly I’m going to move something into RAX it’s going to be

system right so basically I would like to write something somewhere to some

some file descriptor its first argument wants where I want to write it so I’m

gonna write it to the standard output instead of an actual file and then I’m

gonna move RSI the next argument is going to be the actual message or a

pointer to the message that I defined above and you know check out my other

videos if you want to learn assembly that’s this is not this is not an

assembly learning video I’m just kind of doing it real fast in case you’re

probably unless I ruined it somehow let’s start compiling or assembling the

assembly program so just one more we’ll say assemble the assembly source or

module or whatever you want to call it we’re going to use the ASM to do that

G dwarf 2 is the debugging symbols not necessary in this video the format is I

want a 64-bit executable that’s how you do it in Yasm and I’m going to give it

and I’m going to give it an input of just the third assembly source file.

And I want it to output the third object file.

I got to remind myself to glob line 36 after this or die with the exit code.

Okay. So now this might work.

Oh, I got to put, I got to put third dot O in the linking stage.

I’m going to do clear and I’m going to go here and compile.

and compile.

Unrecognized debug format, dward.

Why didn’t you stop me?

It’s g dwarf.

Let’s see, what did I do wrong?

g dwarf, oh, dwarf dash two.

Oh, it’s not even g, it’s just dwarf two.

Sorry.

And I got to put a dash, I think, for EASM.

Yeah, okay.

Let’s see if that works.

What did I do wrong?

Oh no no, Yasm doesn’t need the dash, but GCC wants the dash.

Okay, I had it right the first time.

Doop doop doop, okay, so it probably linked.

Let me run it and see what happened.

Hello from the second, oh, we still have to actually call it from the C++ module.

So now we’ll do the same thing.

We’ll say that the assembly module, it’s not going to use name mangling.

use name mangling there’s no overloads so we’re going to put it into the extern C

block and we’ll just say you know void third how do we know that’s that it’s a

void function with no arguments well you know that’s just a convenience that

happens under the hood with C and C++ in assembly it’s just a label that you’re

jumping to and returning from void means return type all that means is I’m

trying my best not to make this a C++ or an assembly tutorial but all that

All that means is there is no return value getting returned.

That would be the RAX register if I wanted to move something in there.

And then similarly, if I wanted to catch arguments, I’d be grabbing from other registers.

So I’m not grabbing any register, any arguments from registers, and I’m not sending a value back with RAX or XMM0 or anything.

So that just means it’s void and no arguments.

So let’s do it again.

Compile it and then run main.

then run main hello from second oh i sure put in the name mingling thing but i forgot to call it

let me do that third so now one more time compile and then run it

what’s happening in here

third i guess i should probably open this up now third asm so global third and then third oh

important part of a system call you got to put the keyword or the instruction system call in there

one more time i hope you’re laughing and cringing at home trying to make this more fun maybe i don’t

know okay so now it’s all it’s all working notice how we have a bunch of different modules in

different languages we’re compiling them all to object files first and we’re uh we’re linking

them all into one executable and we’re doing this in a really really easy way by using a script

script instead of typing all the commands out manually. Pretty convenient, right? Let me give

you another upgrade real fast here. So this is kind of irritating. I have like all of these object

files that I have to specify. What if I forget to specify some? Since this line 36 is just going to

be something that goes directly, you know, to the shell as a command line. This is not like bash

wildcards I can say star dot o meaning I’m going to give every object file to

the linker as an input file and that should just work automatically keep in

mind if you want to use an advanced strategy like I mentioned earlier where

you have multiple different object files and they’ve each got their own main

functions because they’re each going to be their own separate executables then

globbing all object files probably not going to work you might want to organize

files or stick the object files for executables in like their own folders or

something like that we’re not going to go that far but I just want you to know

so let’s do that again real fast here we’ll say clear and compile and I’ll

just try to like run main assuming that the compiler works yes so it worked

everything compiled by the way this and end that means only execute the next

So if I, you know, clear is obviously going to succeed and then compile, it might succeed

or not.

Then I’m going to try to run main.

Let me actually, let me actually do that real fast.

Let me show you what I’m talking about.

I’m going to remove main.

You’re okay.

So then I’m going to do clear and compile and main.

So obviously if everything works, then everything works.

But if I do that again, where something is not actually going to compile, like maybe

the second the c source program is not going to compile by putting some z’s in there then the

dot main or yeah that part shouldn’t get executed so it won’t try to execute our program

notice how it just stops so that’s convenient if i do it again though with a different command

if i chain instead of between the commands instead of putting and end to say one must execute before

semicolon then they will all execute no matter whether whether they succeeded or not maybe in

certain things you’re doing you actually want that behavior but in this case it’s going to be bad

watch what happens it fails to compile and then at the end it also tries to run a program that

doesn’t exist because it never got linked because the script stopped so i’m just letting you know

you have lots of different options when you’re writing these scripts we do it again and then let

And I think, well, maybe there’s one other thing I want you to know.

Sometimes these lines get really, really long, right?

And it’s messy and irritating.

At least for me.

Maybe if it goes off the side of the screen for you, it’s like, oh, that’s awful.

You can actually just separate a command across multiple lines with a backslash.

Or sorry, I think that is called a forward slash.

It’s the drive slash.

I don’t remember forward slash backslash.

I just say web slash and drive slash.

So I’m going to do G++ and do a little slash.

Then I can put the whole rest of the thing on the next line.

If I wanted to, I could start separating these out by category.

So maybe I’m like, oh, I don’t know.

Maybe M64 on its own line.

And then I’ll keep these other two on their own line.

And maybe these two on their own line.

You know, it’s up to you how you organize this.

And then I’ll say, give me all the input files on its own line.

And then the output file on another line.

on another line you could even put the or bars for the die part on its own line I

guess I’ll just try that and now let’s just make sure that this still compiles

let me remove star dot o and remove main it’s not there okay so clear and then

list and then two showed up somewhere oh my mistake I probably should have caught

some file got saved as a two I should have noticed okay so let’s do clear and

compile and I just run main okay so now everything works notice how even though

everything was on a different line it all just seemed to work cool what about

something here on line 38 we’re using the C++23 standard but we’re also doing

that up here and we’re also using the all warnings flag up here and down here

and pedantic also and even the linker like what if I want to put all warnings

into the linker we could make variables in bash and by the way this is totally

starting to become a job for for mark for make files but for now we’re just

stay in bash so I can make a variable in bash I can say maybe GCC flags name it something and I’ll

just put equals whatever and I’ll just type the stuff that I know is going to appear in every

single invocation of G++ or GCC so I’m going to go wall because I want to put that everywhere

and I’m going to say C++23 because I’m going to put that everywhere and probably pedantic I’m

I’m not going to put the dash C flag everywhere because notice how I’m only putting that on the compiler commands when I just want to make an object file.

But when I’m linking, there’s no dash C because that means you got to actually link.

So let’s see.

We got G dwarf two, G dwarf two.

Maybe I could put G dwarf two there and see if it still works.

So I want debugging symbols and I want them to be in dwarf dash two format, which honestly is the default format.

which honestly is the default format if you just put dash G.

Let’s see if I can get away with that for now.

So I’m going to go GCC flags.

And here I can get rid of C++23 and wall and pedantic.

And I’ll just insert instead GCC flags.

And if you want to be extra careful,

you can put these little braces around the variable name of that.

Probably should be fine.

But because I don’t want to type that again,

I’m just going to copy paste it into the other command.

So wall pedantic, just paste that.

Just paste that and then I’m going to leave it alone for Yasm because Yasm is different than GCC.

And then here I’m going to do another line where I just kind of put the flags.

That means I can get rid of those two flags.

And then wall and pedantic are going to show up.

No pi is kind of a linker only thing.

So is the no exec stack.

I think probably that will be okay.

Let’s see if I got that right or wrong.

Oh no.

Unrecognized command line option.

Wall pedantic GCC.

Oh, I guess because I quoted it.

I shouldn’t have done that.

Because I quoted it, the command line thought that that was all one argument.

I should have remembered.

So I’m going to unquote it right now.

This should help the command line understand that all of the things inside of that variable,

the GCC flags, are separate arguments instead of just one argument.

Let me try one more time.

Yay, it seems to work.

Okay, we got a warning here.

Command line option C++23 is valid for object,

but not for C.

Okay, so basically I made the mistake

of trying to send a C++ object,

which is this right here, or sorry,

a C++ argument, which is this right here,

into a C compiling command.

Not great.

So what if I did this?

I’ll do C flags, and it will contain only flags for C,

for C and then I’ll have another one for C++ flags

which will only contain things that are for C++ compiling so the regular C compiling can take

wall and pedantic okay and then it can take the G dwarf 2 okay the C++ flags it can take everything

except for um sorry the C++ flags can actually take all of the C flags and then additionally the

and then additionally the the c++ 23 flag so i could embed a variable inside of itself i could

say c flags or sorry i could embed a variable inside of another variable so that i can just

steal all of the flags from the c flags variable stick them also in the c++ flags variable and

then just add one more at the end of that hopefully that works i think it probably will

here and then use the C flags here just for compiling I could probably name the

variable better put the word compile in there or something but I don’t really

want to I think some people put CC to mean like C compiling but I don’t know I

just want to do it this way so we have that and then we’re gonna do CPP flags

like this we could also organize the variables differently so that the we

We could have some linker flags, which basically would probably have all of this stuff minus dash C.

And then we could have linking flags.

No, we can have linking flags that has all that stuff minus the C.

And then we’ll have like some compiler flags that has the linking flags plus the dash C.

But I don’t really want to spend a bunch of time on this now.

For now, we’ll just say we have C flags and CPP flags.

And we’ll just manually add that dash C.

But of course, keep in mind, you can organize these things any way you want.

and organize these things any way you want.

So I’m gonna do,

well, this might actually work.

I’m getting distracted.

I think it works.

Okay.

Let me just double check by removing all the object files.

There’s a two in there still.

Let’s debug that if it happens again,

then I’m gonna remove main.

Okay, then I’m just gonna list everything real fast.

Okay, let’s see.

Is there gonna be a two in there now?

Is there going to be a two in there now?

No, is that only when it fails?

Only when something fails to compile?

I mean, it’s working, so that’s good news.

You know what?

Leave a comment somewhere letting me know

where you think I went wrong with this two,

and maybe I’ll release another video

or something in the future,

at some distant point in the future.

But yeah, anyway, I hope you learned a lot of stuff

in this video and you had a little bit of fun too.

had a little bit of fun too. This has been, you know, a little intro for compiling, linking

and executing in Linux, but also probably on a bunch of other systems if you have these

same tools, and you’re working inside of bash. Thank you so much for watching this video.

I’ll see you in the next one.

of my heart i really appreciate it i do hope you did learn something and have some fun if you could

do me a please a small little favor could you please subscribe and follow this channel or these

videos or whatever it is you do on the current social media website that you’re looking at right

now it would really mean the world to me and it’ll help make more videos and grow this community so

we’ll be able to do more videos longer videos better videos or just i’ll be able to keep making

Do me a kindness and and subscribe. You know sometimes I’m sleeping in the middle of the night

And I just wake up because I know somebody subscribed or followed it just wakes me up and I get filled with joy

That’s exactly what happens every single time

So you could do it as a nice favor to me or you could you could troll me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, uh, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

go to the website which i think is also named somewhere at the bottom of this video and it’ll

take you to my main website where you can just kind of like see all the videos i published and

the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know just

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

coming for us all

Thank you.

The post Compile, Link, Execute: A Beginner’s Guide to Linux Programming with C++, C, and Assembly appeared first on NeuralLantern.com.