Ever wonder how your program remembers where to return after calling a function? That’s the call stack’s job.

In this clear, whiteboard-style explanation we cover:

• What the call stack actually is
• How call frames are built and what they contain
• Return addresses, function arguments, local variables
• Why recursion works (until you overflow the stack)
• Stack vs heap memory differences
• Why too much recursion = crash

Great for beginners to intermediate programmers who want to understand what’s happening under the hood. References Ed Jorgensen’s excellent (and free) x86-64 assembly book.

00:00 Introduction to the Call Stack
00:16 Prerequisites – Understanding Basic Stacks
00:41 Simple Example Program with Function Calls
01:24 Function Call Chain and Recursion Example
02:20 Visualizing the Call Sequence
03:06 Local Variables and Return Values
03:55 Quick Recap – How Generic Stacks Work
04:34 Stacks Can Hold Any Data Type
05:36 Introducing the Call Frame Concept
06:22 What Belongs Inside a Call Frame
07:00 Return Address Explained
07:44 How the CALL Instruction Works
08:32 Function Arguments on the Stack
09:57 Extra Arguments Beyond Registers
10:19 Preserving Registers (Callee-Saved)
11:12 Local Variables on the Stack
11:40 Multiple Call Frames Example
12:54 Tracing Function Calls Step by Step
13:21 Starting with Main’s Call Frame
15:00 Pushing Frames for Nested Calls
16:30 Returning – Popping Frames
18:10 Why the Stack is Perfect for Returns
19:45 Recursion and Multiple Instances
21:30 Stack Grows Downward in Memory
23:10 Stack vs Heap Memory Comparison
25:12 Local Variables vs Dynamically Allocated Memory
26:16 Pointers on Stack Pointing to Heap
27:32 Automatic Cleanup of Stack Variables
28:00 Memory Leaks with Heap Allocations
28:56 Recommended Reading – Ed Jorgensen Book
29:56 Call Frame Layout in x86-64 Assembly
31:16 Process Memory Layout Overview
32:22 Stack Grows Down, Heap Grows Up
33:52 Stack Overflow from Deep Recursion
35:09 Summary – Why the Call Stack Matters
35:28 Closing Remarks and Call to 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. In this video we’re going to talk about the call stack. What is the call stack?

It’s an important data structure inside of your computer that helps your computer call

functions inside of code. It’s pretty cool.

So first off, before you watch this video, you should probably already understand

how a stack works, what a stack is in terms of its interface and how to manipulate it

See my previous video if you don’t understand how to use stacks yet. In this video, I’m just going to talk about the call stack, which is just a special use of the generic stack abstract data type data structure.

Okay, so let’s see. First off, let’s suppose for the sake of argument that I have, you know, a function called main. This is not a C++ video or a coding video, but the call stack is related to coding.

mean when I write down some code. This is just a simple C++ program. You can imagine that

up above main, actually I don’t want to use prototypes, but I’m going to put the other

functions below. Please forgive me. You can imagine that main calls on the function f,

so I’m just going to do a function called f here. And so execution, when it gets to that part of

the program on line three, execution is going to jump down to line nine to just execute the f

And then maybe F calls G and then G it calls H and maybe H sometimes calls itself.

Maybe we’ll say that it’s a recursive function.

We’ll say if, you know, something happens, then we will return a call or we’ll just call H.

So it calls itself sometimes.

Otherwise, we will have it to call on the I function.

then you know execution just kind of returns to the caller which would be G in

this case and then we have the I function that just you know does whatever

right so the code here doesn’t really matter what I’m really trying to show

you is that one function calls another calls another and we can sort of allow

this to happen under the hood with a call stack so I’m just gonna draw this

and G calls on H and H we’ll say that we’ll say for the sake of argument one time H calls on H

just so it’s easier to draw later and then H eventually calls I for some other reason

maybe the deeper H calls I and then eventually this starts to return right so if you’re a

programmer you kind of take this situation for for granted you think like well I just kind of

call a function and then and then when the function’s done I just return to the place

everything is fine. If we had, let’s say, local variables in here, they would be preserved. Let’s

say, I don’t know, maybe h is like a number or something like that. Or how about let’s do g as

a number. We’ll say g returns some kind of a number. And then maybe in the f function, when

we call g, we’ll just print whatever g returned. So g calls h, and then we’ll just say like return

h and then we’ll just say like return whatever just trying to show you that we might have

a local variable so that means um in the g function maybe you’ll have a integer a is equal

to five and integer b is equal to six i’m just making up stuff here and then when we return

our data we might say you know return a plus b for whatever reason this is a nonsense program again

don’t take it too seriously but i’m just trying to show you that we have functions that can call

we have functions that can call each other sometimes call themselves and maybe they have

local variables on top of that so if you understand what is a stack then you understand that a stack

can hold many different types of data just as a quick recap here um you know a regular

generic data structure stack or an abstract data type stack we could say that the stack hold held

integers so if i wanted to put like an eight on there and then put like a five on there it would

it would just kind of stack up as we’re adding data.

And then when eventually we decided to remove data from the stack,

we’d pop it by just removing the thing from the top.

But because stacks are supposed to be abstract data types that hold any type of data,

we’re not limited to putting integers inside of the stack.

So we could invent a totally new data structure

and put instances of that data structure inside of the stack.

For example, if you had a custom class that you wrote yourself

and you just called it my class,

my class let’s see uh let me do class my class and i’ll just put braces here again this is not

a c++ video but you know you can imagine that you sort of made a blueprint for a new type of object

and you called it my class and then later on you’re like let’s make instances of my class

let’s make an instance called mc1 and mc2 and mc3 and so forth right so in the stack you could just

instances of my class i’m just going to put mc1 here if we created mc1 and then pushed it onto

the stack and then we can have mc2 and created an instance of that and just kind of pushed it

on the stack so we can do whatever we want we can put any type of data on the stack m

and this is not exactly the process stack so far i’m just telling you what a stack

in general can do so now instead of imagining that we have a custom class called my class

made a new class called call frame I’ll say we have like an instance let’s say

like a blueprint for a class we’ll call it a call frame I’m a penmanship it’s

because this thing this pen and I push it down and it always like keeps drawing

after I start lifting it up I don’t know what I’m doing wrong I’ve been trying

this for like 50 videos and it’s always bad and wrong so imagine you have a

class called call frame and inside of it you can just put some sort of data in

some sort of data inside the call frame.

You can imagine defining what an object might look like and then creating instances and

filling it up with data and then every instance just like we did with my class we could just

put that onto a stack right?

So now let’s try to understand what might be inside a data structure called a call frame

because when we have a stack under the hood in our machine that holds instances of call

frames then we actually have a process stack or a call stack which allows us to implement

which allows us to implement these function calls.

So let’s see, the first thing that we might imagine,

I’m gonna maybe just do like a little box here,

just to let you know that we’re deciding

what will go inside of a call frame.

So this is one call frame.

So you can imagine that the F function here,

in order for the F function to exist,

the particular call to exist,

what you know what it has what it is to be alive you know it needs its return

address I’m gonna put RA here for its return address what is a return address

well you know when we were inside of the main function let me draw the execution

path real fast when we were inside of the main function then execution was

going from top to bottom when we hit this F function call execution actually

jumped to the first line of the F function under the hood in assembly

there’s a jump instruction that allows you to just kind of jump to a totally

just kind of jump to a totally different memory location and start executing

instructions over there somewhere. In assembly also we have a call

instruction which means I would like to jump to another location but also I want

to remember where I just came from so that it’s easy for me to return later.

Okay so we’ll call that the return address. The return address in this case

would be let’s just call it line 4 meaning when function f returns then the

is this return zero in well I mean this is C++ we don’t it’s not really instructions it’s more

like statements but you can just imagine that F gets called and when it returns then the next

statement is return zero right so if we say that the memory location of wherever line four starts

is the return address of F then you can imagine that in order for F’s you know call instance to

exist it has to remember its return address so therefore we would put the return address inside

call frame. So the return address goes in there and function arguments sometimes go in there. If

you know assembly, and that’s kind of what we’re talking about right now in this video, then

you’ll know that function arguments, at least the integer arguments usually come in certain

registers like RDI and RSI, or if you’re, whoops, or if you’re passing float arguments,

and XMM1 and so forth right so you just kind of like load up registers with

arguments but if you have more arguments than you have registers you know

there’s only so many registers you can actually use to pass arguments into a

function that you’re calling so what if you run out of float registers you run

out of the general purpose registers but you want to have more arguments than

that for example if you look at the ABI then the integer arguments there’s only

integer arguments there’s only six registers that we can use to pass integer or pointer arguments

so if you wanted to have seven arguments or more then you know you should be able to do that but

there has to be a different way to accomplish that so the seventh and beyond arguments will

actually uh show up in the call frame oh I guess ra should probably be blue because the the call

frame I’m just you know making that green I’ll say return address so the seventh and uh the

the seventh and beyond arguments args we’ll just say so the call frame contains the return address

and any argument that’s that’s like the seventh argument and beyond and if you don’t have seven

arguments then there’s not going to be that’s not going to be in the in the call frame it’ll just be

blank at that point sometimes when people are messing around with the stack pointer they will

Basically, anytime you push a register in order to preserve it,

then it will end up on the call frame, at least at the assembly level.

So suppose you’re going to use the base pointer register.

You probably want to preserve the base pointer before you start using it.

So we would push it onto the stack and it would become part of the call frame.

Any registers that are designated as callee saved

would also be pushed into the call frame like R12.

Oh my God.

R13.

my penmanship there’s like it’s the ones the ones are always l’s okay and so forth right so

anything that’s designated as a callee saved register that you intend to use would end up

getting pushed onto the stack at the assembly level and thus it would end up in the call frame

but you know if you aren’t going to use any callee preserved registers then you don’t need to

preserve them and therefore they would not show up in the call frame and let’s see and local

local variables in assembly, you just basically end up pushing them to the stack.

So I’m going to put local variables here.

And in a second, I’ll show you how that kind of works in higher level languages like on

C++.

That’s why I wrote this down right here, line 12.

We’re making local variables.

And let’s see what else.

I should emphasize that local variables are very different from heap variables.

some point let’s say that when when g was called let’s say execution came in here

into main and then execution jumped into the f function so it jumped in there and then f wanted

to call on g in order to get some information right so we have a call frame just for g and we

have a call frame just for f and we have a call frame just for main and so we have like three

items on our stack at least just to get to that point of the program and every call frame you

you know, basically has this sort of information inside of it.

The return address, so the function knows where to jump back to

when it’s time to return from the function.

Seventh and beyond arguments, if any exist.

The base pointer, if you happen to modify that at the assembly level.

And then same thing for Kali saved registers.

And then local variables, which you could probably imagine more clearly.

So now I’m just going to erase this call frame thing here.

Oh God, this eraser needs to be improved.

god this eraser needs to be improved oh my gosh maybe i should make that bigger i need like a

little shortcut to make it bigger for a second because i don’t really want to draw that thing

on top again that’s just annoying i don’t want to do it i won’t do it i won’t do it okay so uh

imagine now that we are trying to sort of trace what’s happening in our uh call graph you know

in our in our program while we’re calling functions so first imagine we have an empty

have an empty stack and again if you don’t understand stacks you better go see my other video

imagine we have an empty stack the stack is not ever really going to be empty when you launch

your program it’s going to be uh there’s going to be stuff on it already but let’s just pretend that

we haven’t put anything on the stack at this point so there would be a you know a call frame just for

the main function i’m just going to write main here to say that this is the call frame for main

so it contains all the information that main needs and um if you have a main function in the first

first place then you’re probably linking against the GCC libraries which means

a main definitely has to return somewhere inside of the GCC library so

this kind of makes sense for our program so it’s a call frame for main

and then when main calls on F then another call frame gets created for F

and then when F calls on G another call frame gets created for G I don’t know if

I need to put these parentheses but I guess I’ve already started to do that

h and then h sometimes calls itself so I’m gonna put another call frame for h

up here oh my god h’s look like just crazy okay that’s been uh every time I

lift up the pen h calls itself sometimes we’ll just say that it calls itself

once in this case and then h calls i and then that’s let’s just say that’s the

end of our little call graph when i is finished doing whatever it’s gonna do

to do then it’ll just return to the caller right so notice how every single time we made a function

call we added a call frame for that particular instance of a call and we called it a call frame

something else that i should point out is that i have been describing to you a call frame as if it’s

a a data structure with sort of like a fixed amount of data inside of it and you would sort of

blob that whole block of data on at the same time that’s not really how it works in assembly in

you kind of just push, you know, one tiny piece of data at a time.

But in the abstract, you imagine that there’s a call frame.

Just keep that in mind.

Anyway, so in the F function, you know, we’ve been making these calls F and then G and then H and then H and then I.

Eventually, when we got to the, let’s say, what did I do wrong?

Oh, I did something wrong.

I put the local variables in the wrong function.

Hang on a second.

I want them to be, I mean, it would be okay to have them inside of the G function, but I really want them.

but I really want them, I really want them to be inside the H function for a certain reason.

So I’m just going to cut and paste here.

And I’m going to do like local variables inside of the H function and not in the G function.

And then G should maybe return an integer result.

And then this return statement shouldn’t even be in G.

It’s just going to be inside of H.

the a and the b variables at some point before returning them modify a and b somehow maybe I can

even put that comment inside of both of the blocks of the if so like so maybe if something happens

we’ll modify them in one way and if it doesn’t happen we’ll modify them in some other way

and then at the very end we return them just to kind of feel like we have more of an excuse

to have return variables in the first place and then when h returns something now we have an excuse to kind of print out whatever h is

doing okay and the reason I moved all that inside of h and not in g is because I just want you to know that

There are two instances of the h, you know call instance on the call stack which means the local variables

They’re not linked. They’re two distinct copies of each local variable inside of the stack think of it this way

When we call our h the first time,

we have an integer a and an integer b.

You could imagine that there’s an integer a

and an integer b sitting inside of the call frame somewhere,

you know, being pushed onto the call stack.

And, but the other called h also has a variable a

and a variable b,

but because those are local variables,

changing one doesn’t actually modify the other copy

that is in the other call frame.

So you could imagine this as A sub one and B sub one,

and then A sub two and B sub two.

This is kind of important later on when you realize

that your operating system is capable of launching multiple threads for your program

and local variables won’t potentially become race conditions,

which is just like for a totally different video.

But for now, just to understand these are totally separate instances.

If I change A sub two, it’s not changing A sub one and vice versa.

And same thing for B.

vice versa and same thing for B so anyway we we make all these calls and

somewhere along the way you know we’re creating a bunch of data and a bunch of

call frames eventually when we are done with the I function when I wants to

return here we don’t have an explicit return statement but if you if you know

C++ or higher level languages if there’s no return statement in most of

the language in most of these languages for a void function it just returns when

when it reaches the end of the function we don’t really need to say return because it doesn’t

return anything it just ends so when i is ready to return what happens is we look inside of its

call frame and we look for the return address which is inside of its call frame the return

address specifies exactly where we’re supposed to return for example maybe we’re supposed to return

right here maybe we’re supposed to return right here maybe to make things a little bit more

so maybe if we called h then we increased a and if not then we increased b something like that

so that means the the call frame for the first h function let’s suppose let’s see if it called

if it called itself then that means this block right here is the first part of the if block so

the return address for h return address would actually be pointing to

would actually be pointing to the next line right so when h called on h

it would look at line 21 or whatever the address was for that instruction

to begin at you know increasing a and it would just say that’s the return address so that

whenever h returns from itself it ends up executing a plus plus and then the same thing for i so

i has a return address so when we’re inside of the i function it’s got its own call frame and it

knows where it’s supposed to return which in this case would be that instruction right there or that

statement right there so whatever is the first instruction that implements that higher level

language statement that’s going to be the return address inside the the i call frame so we look

inside of the call frame for the return address we know where to return it’s going to return to h at

at this point in time.

And once we’re done with that,

then we just deallocate the call frame.

In assembly language,

all we’re really doing is moving the stack pointer

and just sort of ignoring the call frame

from that point forward and we’ll call it junk data.

So the data is kind of actually still there,

but we’re just not using it.

And then later, if we wanna start adding more stuff

on top of the stack,

then it will just override that junk data.

But for now, just imagine that it’s gone.

Anyway, so then we returned from I back to H

from I back to H and so that’s line 26 right here imagine we perform this

instruction the B++ and then execution falls through down to the very end the

return statement so then same thing happens this version or I guess this

version of H had its own no hang on a second we returned from I yeah yeah this

to h so that means execution will will basically jump from here to right here so it kind of jumps

you know back to that next line like we talked about before when it returns based off the return

address then again you can imagine that that call frame is deallocated or just ignored as junk data

and the top of the stack is kind of like moving and then when that call on h uh finishes so you

executed and then execution falls through down to the return statement then again h has its own

return address in its in its call frame or that instance of h has its own call frame then it knows

where to return and this time it knows to return to whoever called h in the very first place so

it’s going to be um i guess it’s going to be like when it returns it’s going to go back to g

h on g but I guess you could imagine under the hood you know instead of like

another statement you can imagine more stuff is happening right like when we

called h and then we returned then we had an expression that evaluated to

something because h returned to value and then we would send that to the stream

operator so in assembly there are many instructions happening after the call to

h but you could just imagine at this point you know it’s just gonna finish up

that that existing statement and then move down to finish and return so then

so then again you know we we just returned from h to g so we de-allocated that call frame the top

of the stack is now somewhere around there in that call frame when g finishes and it returns

same thing it’s got a return address so it knows where to return and then top of the stack kind of

goes down there and g knows to jump to whoever called it because of the return address so it’s

going to be at this point in time again there’s more statements that happen after the return

see out in a stream operator uh you know but uh you know basically when f is done then again it’s

going to use the return address and know where to jump back to which is just going to be this next

line right here so when f was called originally it like ended up calling h and then h uh you know

called itself and h called itself and then it called i and then we returned from i and then we

returned from h and returned from h twice and then eventually we returned to g and then we returned

and all of its calls were finished then execution returned just a line for and

that’s that’s basically saying like oh what happens when F is done let’s look

at its return address hop that off the call stack and then the top of the stack

is basically just sitting inside of the main function so yeah this is how we

implement function calls in the machine you know there’s there’s really no so if

you know, from a certain point of view, there’s no such thing as functions inside the machine.

In assembly language, we certainly see that we have a label and then we have like a return

instruction and we have a call instruction, but you know, there’s no like function. It’s all just

ones and zeros all over the place, right? So the idea of labels and functions and things,

that’s kind of an abstraction just for the human being with feelings to make it a little bit easier

stack we have a stack and we stack things on top of the stack and the things that we stack are

called call frames call frames are kind of flexible because sometimes there’s more data

sometimes there’s less data depending on what the function itself is doing but it allows us to have

a function call itself many times it allows us to have many different instances of function calls

exist at the same time even if we’re only looking at the very top of the call stack in terms of

conflict with each other.

And then, you know, like we have a trail of breadcrumbs when we start returning and

returning and returning, the stack makes it really, really easy.

And so, you know, in the abstract, we can basically say that there are functions in

our machines because this implementation helps make it happen.

One last thing that I wanted to say before I go here is just keep in mind that these

local variables, they’re on the stack, but dynamically allocated memory is not on the

stack.

stack. Let me just show you what I’m talking about right here. You probably understand the

heap already at this point. If you’re watching this video, then you know a little bit about

dynamic memory allocation. So I’m just going to do, let’s say we have like an F function void F.

And inside of the F function, we have let’s say a integer pointer P, and we will allocate P to a new

So just so you know, the variables A and B and also P, they’re considered local variables

because I just declared them.

I declared a pointer on line four.

I declared two integers on line seven.

Maybe I should put those like at the top, I guess.

Okay, so lines four and five, they declare local variables.

The pointer is a special type of variable, right?

That just points to a memory location.

So the thing that it points to might not be a local variable, but the pointer itself is

a local variable.

The pointer itself is a local variable.

So these three variables on lines four and five, A and B and P, those are on the stack.

Any local variable gets put on the stack.

And then when you allocate a new integer with dynamic memory, maybe you could imagine if

you’re a C programmer, this would be a call to malloc rather than new.

Then what’s happening under the hood is that the system goes and tries to find some free

memory in a different area of your process called the heap, not the stack.

heap not the stack it tries to find some free memory in the heap it once it finds some then it

designates that as you know being in use and then it returns to you the memory location of that new

allocation so in this case we’re allocating a new integer so that’s going to be 32 bits of data or

four bytes and uh so it just you know it just finds four bytes somewhere in the heap and it finds the

memory location of the very first byte and it returns that to the caller and so p its value is

is now going to be the memory location of the new integer that you allocated.

But P itself is on the stack.

So P is kind of weird, right?

Like P exists on the stack, but it points to something in the heap.

Keep in mind the difference.

And then if we just let this function go to the very end

without cleaning up that memory, we would have a memory leak.

I should probably just do like a dedicated video on pointers

for people who are interested in pointers in higher level languages later.

But keep in mind that when the function ends

and you pop the call frame off the call stack,

then that automatically cleans up all the local variables.

So A and B and P itself will be deallocated

and not become memory leaks.

However, the thing that P pointed to,

that will be a memory leak.

I guess that’s a topic that’s too advanced

for this stack video,

but I just want you to know the difference

between something that exists on the stack

and something that exists on the heap.

Okay, so then I think the last thing

that I need to show you here

here is uh let me uh shoot let’s see shambler okay so here’s uh uh my favorite book i love to

i love to pump up this book it’s awesome the author is like a brilliant man very kind man

he offers this book for free it’s got a copy left license you can literally just download it for

and it’s legal because this is an open book basically it’s called x86 64 assembly language

programming with ubuntu by the brilliant dr ed jorgensen phd or professor ed jorgensen

this is the latest version that i’m working with right now i think it’s the latest version i don’t

know he updates this thing all the time it’s always getting better but um if we look at this

book uh you can get a copy of it on your own or you can just watch this video i’m going to go to

12.8.3 so 12 section 12 12.8 12.8.3 called the call frame and here you can kind of see a

description of some of the stuff that I talked about in terms of what sort of data you would

expect to see in the call frame but if you just kind of look down a little bit you can see that

we are sort of pushing some preserved registers

sort of like save the stack pointer as the RBP register.

But before we do that, we wanna push the RBP register.

And then notice out here,

it shows that there’s a return address

and the RIP register.

That’s actually the instruction pointer register.

The stack pointer is RSP.

And then other arguments that go into it.

So just keep in mind that we have a little layout here

a little layout here and then somewhere else there was something I wanted to show you here

no no no no no no no no no no no no no no no no no no okay I guess I’m gonna

oh I guess I was just supposed to show you the call frame anyway okay so I guess that’s pretty

much it I just wanted to show you some extra stuff just so you understand this is the basic

Oh, okay, I found it.

I spent a second scrolling through the book to find the other diagram that I really wanted

to show you.

So same book, X-8664 Assembly with Ubuntu by Ed Jorgensen, Professor Ed Jorgensen, PhD.

And if you look at section 9.3, there’s another picture here that’s kind of useful.

And it basically shows, you know, the general idea of how information is laid out inside

information is laid out inside of your process so when you launch a process in

order to execute your program then it’s kind of laid out like this there’s like

a little reserved area and then there is the text section for assembly you know

that’s where you have all your instructions and then there’s the data

section and then there’s uninitialized data which is the BSS section if we’re

talking about Yasm assembly and then notice how in this big blob of an area

and the stack kind of sharing an area inside of available memory it’s important to understand that

the stack when you actually add things onto the process stack like call like call frame data

you’re actually decreasing memory location so the stack grows downward in memory so I think I’m going

to put this in another video but basically right now I just want to show you if we have memory

location let me let’s pretend that we have like a stack here and there’s like a couple of frames

there’s like a couple of frames you know sitting on top of it suppose you had I don’t know memory

location OX you know 99 or something suppose for the sake of argument we’re only pushing one byte

at a time so it’s easier for me to write then that means you know the next thing that shows up

you know a little higher on the stack you would intuitively think that the memory location is

I guess I increased that 9 to a but it actually goes down in memory so I mean

look at this diagram right here the stack goes down in memory so every time

you push to the stack you’re pushing to a lower and lower and lower memory

location so right here I’m just gonna write down OX 9 8 and it just keeps

going down and down and down let’s see 1 2 3 4 5 right and the heap is is

upward in memory so the heap when you call new allocations like if you say new or malloc or you

know some kind of dynamic memory then its memory locations grow up and the stack grows down and if

they ever actually meet then you’ve ran out of memory just keep that in mind but um you know

in modern systems the heap can kind of grow almost endlessly i’m sure i’m sure you’ve all

been running programs in the past and noticed that the program was consuming gigabytes of data right

gigabytes of data right but it’s not like you had gigabytes of data allocated to that process

when you first opened it up like if you have a browser with like 100 million tabs open

i know some of you people do that then when you first open your browser it doesn’t really use

that much memory but then as you start opening more tabs maybe some pages are doing some weird

stuff and you get memory leaks then the heap starts to grow and grow and grow and then you’ll

notice the process takes way more than did in the beginning so the heap can kind of grow in an

of course that is limited to your physical system ram and eventually in the far off future will be

limited by whatever 64 bits can get us i don’t think we’re ever going to reach that in my lifetime

but you know i’ve been wrong many times before however the stack it grows downward in memory

and it’s kind of limited you can actually overflow your stack pretty easily so when the stack grows

downward too much then you just you have a stack overflow and the program crashes but when the heap

But when the heap grows, then it can just be resized again and again and again.

Or that little block can kind of expand again and again and again.

If you don’t believe me, try writing a program with a recursive loop that just goes on forever.

So imagine, actually, I don’t know, don’t do this on your boss’s computer because maybe

it’ll crash things.

Do it on your own personal computer.

like a function f and uh you know you’ll probably want to call f inside of main or something so i’ll

just say like int main and we’ll just call f right away and then return zero when you’re inside of f

you just call f right so this is like a horrible program if you ran this very quickly you’d crash

the program because every single time you call f you’re adding another call frame on top of the

stack your call stack is going to just be filled with f call frames and then you know it runs out

you know, it runs out of available memory locations to use, and then you’re just done.

It just crashes the whole program.

So let’s see.

I think hopefully now you feel like you’re an expert on the process stack and call frames.

Thank you for watching this video.

And I hope you learned a little bit and had some fun.

I guess 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 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

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 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

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 if you have a suggestion for clarifications or errata or just future videos

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 enjoy the cool music as, as I fade into the

darkness, which is coming for us all.

Thank you.

The post The Call Stack Explained: Call Frames, Return Addresses, Local Variables appeared first on NeuralLantern.com.

Want to nail down stacks? This beginner-friendly video breaks down the stack data structure with clear diagrams and a laid-back vibe. We’ll walk you through how stacks work, why they reverse data (hello, LIFO – Last In, First Out), and how they’re used in real-world stuff like browser history, undo features in editors, and even the call stack in your code. Whether you’re just starting out or brushing up on data structures, we keep it simple with hands-on demos of pushing, popping, and checking stack size—no boring jargon here! Subscribe for more coding tutorials to level up your skills, and let us know in the comments what you want to learn next. Check out our site via the QR code in the video for more coding goodness!

Introduction to Stack 00:00:00
Explaining Stack Concept 00:00:06
Drawing Stack Diagram 00:00:30
Adding Elements to Stack 00:00:53
Stack Rules and Operations 00:01:16
Pop Operation and Interface 00:06:09
Stack Size and Empty Check 00:07:59
Tracing Stack Operations 00:11:46
Stack as Data Reverser 00:17:44
LIFO/FILO Explanation 00:21:13
Stack Use Cases 00:24:10
Call Stack Mention 00:26:18
Conclusion and Subscribe Request 00:27:21
Outro and Website Promotion 00:28:34

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.

In this video, I’m going to show you a data structure called a stack.

We’re going to make a diagram of it.

We’re going to explain how it works.

We’re going to look at its typical interface,

and we’re just going to kind of work through the concept

of what is a stack and what does it do and all that stuff.

Where’s your daddy and what does he do?

So for starters, what am I talking about?

What am I talking about?

Let me open up a little notepad here.

And I’m going to start drawing.

A stack is pretty simple when you first think about it.

It just takes a little bit more work to really get all the details down.

Imagine I have a data structure and maybe like at the bottom here,

there’s like some grass.

And so we can say that the data structure is empty when we first start.

Okay, so there’s kind of a stack here, but it’s empty.

So there’s nothing really on screen.

Imagine then I wanted to add integers into this stack.

So I’m going to say let’s add the integers eight and then two and then three and then four for some reason.

Okay, so how do we do this?

The first thing we do is we take the eight and we just put it on top of the stack.

You can imagine this as a stack of boxes or a stack of books or a stack of whatever.

When we add items, we’re always going to add to the top of the stack.

When the stack is empty, we’re obviously just going to add like at the very bottom, you know, at the ground floor.

But that’s sort of the top.

when we add the two here the next thing that happens is we just put the two on top of the eight

and the next thing that we do is we uh put the three on top of the two and so forth right so

it’s important to understand a few a few rules about stacks let me add that four real fast

in stacks you’re only allowed to add to the top or remove from the top you’re not allowed to add

or remove from anywhere else let me put a t for top right here so basically you’re allowed to add

So basically you’re allowed to add and remove from the top.

So if I wanted to add, let’s say a 12, the 12 would have to go on top of the four.

It couldn’t go anywhere else in this data structure.

And if I wanted to remove data from this stack, I could only remove the four.

I could not remove the three or two or the eight or anything.

You’re also not allowed to look at the middle of the stack.

You’re not allowed to look anywhere but the top.

So if I wanted to look at the three, the two or the eight, I wouldn’t be allowed to do it.

I can only look at the four.

look at the four and if I want to see that three I have to pop the four off

first in order to just see what’s under it and technically unless you have the

data you added memorized somewhere else you probably shouldn’t know what’s under

the four until you actually remove it okay so we can add and remove from the

top we can’t look in the middle we can’t look at the bottom or anything like that

and let’s do a little let’s do a little sequence of pops let me show you what

So first off, you can imagine a stack is sort of like a vector or a list with less functionality or more restrictions.

It’s useful to add restrictions on top of more robust data structures for the purposes of, I don’t know, kindling your imagination or allowing yourself to use easier implementations or whatever.

If you’re a musician or artist, probably at some point you’ve been stumped and you’ve had writer’s block and you can’t figure out what to create.

can’t figure out what to create so uh you know i know sometimes musicians when they get writer’s

block they’ll they’ll go to the swap meet and they’ll buy like an old dusty dirty uh casio

keyboard from 1985 and then they’ll write a full song just with that one piece of equipment and it

really stirs their creativity or it sparks their creativity and then when they’re done then they’ll

probably upgrade to better equipment but anyway so there’s there’s a bunch of different reasons to

use you know lesser data structures although this is not really lesser it’s very useful

It’s very useful in its own right.

So let’s see the interface.

So what can we do in a stack?

I’m going to put S for stack.

Actually, I’m just going to type this up as code.

No need to use the pen the whole entire time.

Let’s see.

So I’m going to put S for stack.

Maybe I’ll say, you know, stack that holds integers.

And I’ll just put an S here.

If you don’t know how to code right now, at this point in your career, just bear with

me.

variable of type stack and in C++ these stacks you know stacks are a template of data structure

which means the integers that we are holding inside of the stack they could be any other data

type that we wanted to including custom classes so in C++ we would use these angle brackets to

say I want my stack to hold integers and then I’m going to say s is the variable that I’ll use for

the stack so but this is not really a programming video this is just about stacks so if I wanted to

stack to push something like onto the top of the stack i would use the the method push the method

push usually has this prototype let’s see i’ll do stack push and it usually takes in a t type element

and again the t type it’s a templated data type which means right now if i just declared a stack

that was of type integer it holds integers then the t would actually expand under the hood in c

hood in C++ anyway at compile time to be an integer. So it would be like typing int e, right?

So whenever I type t, just understand that that means one instance of a thing that you could put

into the stack. So we’ve got a push here and usually the return type is void and it takes in

one element to push. And that means if I’m going to actually call, let me put some comments here.

If I’m going to actually call push on the stack, I’ve got to give it something to push and the

type of the thing that I’m pushing has to match what the stack was declared to hold. So in this

case, it’s integers. So I’m going to put an eight to match the diagram up above. And then after that,

maybe I wanted to push another number. So it’s going to be a two. And I’m just going to match

what the diagram has up above. So eight, two, three, four. So that’s the interface for pushing

usually in C++. And other languages should be similar. The other thing you can do with stacks

We haven’t done that yet, but let me show it to you first.

POP usually comes in two forms,

depending on what implementation you’re looking at.

So sometimes POP returns nothing.

It simply removes an item from the top of the stack.

And sometimes it returns a copy of the item

that you’re actually removing.

So I’m going to put like stack here and then like stack

just to show you that it’s inside of the namespace.

Oh, I don’t know.

Maybe that’s too C++y.

I’ll get rid of that stuff.

Hold on.

hold on so we’ll maybe do this just to show you that we have three separate

parts to this little code snip so sometimes pop doesn’t give you a copy of

the thing it removes sometimes it gives you a copy of the thing it removes in

cases where pop does not give you a copy of the thing it removes then you would

probably want to call top right before you popped and top will return a copy of

Just to clarify, if I wanted to remove something and get a copy of it and I had this line 13

form of pop from whatever implementation I was using, then well, I would just call pop

and I would do something like this, you know, auto element equals, you know, the stack dot

pop.

And what would happen is under the hood, it removes the item and then it also returns

a copy to me.

Sorry for being too C++ in this video.

On the other hand, if I have the form that has void for pop,

then I would have to do something like this.

I’d have to say auto element equals stack.top just to get a copy first,

get a copy of that for before I remove it.

And then when I’m finished, then I can say s.pop just to grab a copy of it and then remove it.

So for now, we’re just going to use the form that gives you a copy of the data

at the same time that you’re removing it.

thing to keep in mind let’s see there are two other functions i wanted to mention mention real

fast so for now i’m going to say that we only have the t pop type you can also check to see if a stack

is uh is empty and you can also check its size uh usually those are functions that have those names

but i’m going to do let’s see boolean empty and then i’m going to say size type size again sorry

an unsigned 64-bit integer so just like a count or a size something that’s just

going to be a whole number and never negative so we have this little

interface that this data structure has and we have been calling push so far so

let’s go ahead and do some pops I’m gonna say auto auto elements equals s

dot pop maybe I’ll do two of those in a row maybe instead of calling that

just so that we can have different variables to put our pops in.

And then maybe after that, I’ll do some more pushes.

I’ll say, let’s push like a 15 and let’s push like a 25.

And then I think that means it’s probably time to erase that,

the top part of the diagram with the 8, 2, 3, 4

in favor of just whatever pushes and pops we’re doing.

So let me just do this real fast.

Okay, so we did our pushes.

two three four and then I’m going to try to grab a couple pieces of data with these pops

and for pop all you have to do is just to well I should have mentioned this before but first

check to make sure that there is something to pop for example if I had a blank stack let’s say I had

a blank stack right here there’s just like nothing on it and this green line is non-standard I’m just

drawing it for fun but imagine I had a blank stack with no items and I decided to call pop on it

well you’re not allowed to pop them an empty stack there’s nothing there to pop which means that’s a

stack there’s nothing there to pop which means that’s a really really naughty thing in c++ and

other languages we would say that something exceptionally bad has happened the user tried

to pop something that wasn’t there and so then we would do something called throwing an exception

at the user again this is not really a code video but if you know a little code hopefully you

understand try catch blocks and throwing exceptions when bad things happen so we would just throw an

exception at the user if you don’t know how to code at this point then just keep in mind we would

mind we would refuse to do it we would say something bad has happened we can’t do that

and then when you’re doing your pushes sometimes depending on what what you’re using to implement

the stack under the hood inside of your code you might decide that you’re using let’s say you’re

using an array under the hood which has a fixed capacity if you run out of capacity and you can’t

then you would throw if the user tried to push something into a full stack we would call that a

stack overflow and then when we tried to pop from an empty stack we would call that stack underflow

but for the purposes of this video just assume that the stack is just a diagram and it has no

capacity so we can just add as many things as we want on it or maybe we’re using a linked list

under the hood which would have an unlimited capacity or limited only by the machine’s

But anyway, so let’s go ahead and try to do this pop.

So let’s do a pop here.

Well, in the pop, we just look at the top only, right?

So we say, well, you know what?

Let’s make this more interesting.

Hang on a second.

Let’s make this more interesting.

Let’s do this.

I’m going to do auto a equals s dot top.

So I’m going to grab a value without actually removing it.

Okay.

So more interesting.

So we push the 8 and we push the 2.

So at that point in time, actually let’s trace this from scratch.

So we have like an empty stack here.

There’s nothing there.

And we’re going to push the 8.

So the 8 goes on the very top, just like we did last time.

I’m going to put an 8 there.

And then we’re going to push the 2 next.

So the 2 just kind of goes on top.

And then the next line, line 12, we’re just checking the top.

we’re allowed to actually look at the top if we want to. So since two is at the top, that means

a is equal to two. I’m going to put a two here to remind ourselves that a is now equal to two.

Then we’re going to do a push three. So I’m just going to stick a three on top of the stack.

And then we’re going to push a four, four is on top of the stack. Now, again, we’re not allowed

to look at anything in the middle, anything, anything, but the top. So for example, when the

it and remove it but now that we have a four on top we can no longer even see the three it’s not

available to us anymore so then we’re going to pop and put that value into b so um you know what’s

at the very top it’s a four so that means we’re going to actually remove the four and stick that

into b so i’m going to put four right here to remind ourselves that b is now equal to four

and uh for the purposes of this video you can just imagine that this you know the top of the stack is

of the stack is just totally gone deallocated depending on what implementation you use you

might want to think about crossing it out maybe there’s like some junk data there now but for the

purposes of this video in this diagram we’re just saying it’s gone so it’s just totally gone

okay then let’s do another pop so we’re going to pop and that’s going to become c so obviously the

top is uh is now the three so that means the three is going to go into the c variable so here’s a

c variable so here’s a three right there then the three gets deallocated

and now the top is the two so then we’ll push a 15 and we’ll push a 25 so again we just put those

new items on top of the stack even if there was stuff uh there before it’s gone now so we’re just

be a 15 and a 25 on top of the stack so we got this and then 25 and then we’re done adding our

stuff so uh the other functions that we talked about are empty and size uh at the very beginning

when we had just an empty stack like that if we were to call on the empty function it would tell

us true the stack is empty and then every step after that where we had some data in the stack

data in the stack like as soon as we even added that eight at the very beginning from that point

forward then empty would have returned false to us saying no the stack is uh it’s not empty

the size would have changed uh during every step of the way so you know at line 10 the size would

have been one after we’re finished with line 10 after line 11 the size would have been 2. 12

wouldn’t have changed the size so it still would have been 2. 13 would have upgraded the size to

have upgraded the size to four once we popped after that pop was finished it would have been

three again then the second pop would have brought it back down to two and then those two pushes

would have put it back up to three and then four and so then the final size whoops that was horrible

the final size of the stack is four and you can tell that there’s just four items

another way to double check yourself if you’re kind of trying to trace this on your own is just

count the number of pushes and subtract the number of pops so how many pushes do we have one two three

2, 3, 4, 5, 6.

So that’s like 6 minus however many pops we saw.

We see 2 pops.

So 6 minus 2 is equal to 4.

So, you know, when you’re writing this sort of thing down on,

like as a diagram to practice,

then you know it’s a 4 just by looking.

But what if you did something wrong?

It’s a great idea to double check yourself at all times.

So 6 minus 2 is 4.

So we know that the size of the stack is 4.

Looks pretty good.

Looks pretty good and we know the values of A, B, and C and you know one of those was

top two of those were pops.

And yeah, okay.

So notice something though that’s kind of peculiar about the data that came out.

If we added the data, like I guess while we were adding the data, we added first an eight

and then a two and then a three and then a four.

I’m just looking at the pushes right now and then a 15 and then a 25, right?

So we added the data in that order.

order. But then when we grab the data out, let me put this in, but maybe like a red bracket

or something. When we grab data out of it, the pops and the tops gave us two and then

a, okay, nevermind. That was not a pop. It gave us a four and then a three if we’re just

look at the, look at the first two items. Sorry, sorry, sorry. Look at the last two items right

before, and I didn’t draw this very well. Imagine that we had just pushed the eight and the two and

the three and the four only forget about these other pieces of data. So at this point, when we

start calling our pops, we have only an eight, two, three, four stack, right? So the data that

has a four and then a three if we’re removing data from the stack.

So notice how the four and the three are backwards.

Notice also like if we kept popping out data, you know, we got the four and then we got

the three, the next, what’s the next thing that would come out?

It would be the 25, right?

And then it would be the 15.

And then it would be the two.

And then it would be the eight.

So if you really think about it, the stack is reversing our input data.

We added a three and then a four, but we received a four and then a three.

And of course, it’s a little bit muddled because we have some pushes in between some tops and pops and stuff.

But just looking at what goes into the stack, it’s backwards, right?

Eight, two, 15, 25.

Let me finish this push sequence up here.

So we added three and four, and then we added a 15.

And then, oh, my penmanship, dude.

shit dude 15 and then we added a 25 so if you look at the data that comes out this is like a 15 and a

25 backwards and then the three and the four are backwards and then the two and the eight are also

backwards and so one thing that a stack does is it reverses data let me give you a cleaner example

with no pops in between the pushes just to show you what we’re talking about a little bit more

bit more clearly okay so i’m going to do maybe like another code page here whoops do that and

then i’m going to say got our stack and we’re just going to push in some data

and then we’ll just say s.pop and maybe i’ll just do that however many times

six two three four five six so now just a very quick trace because this is basically the same

intermixed. So I’m going to do like the bottom of the stack here. And then, well, I mean like an

empty stack. That’s not really a bottom of a stack. So we’re going to push an eight.

And then we’re going to push a two. And then we’re going to push a three. And then we’re

going to push a four. Then a 15. Got to work on my fives, dude. Okay. And then 25.

Okay, one more time.

Oh yeah, I guess I got to slow down.

So what’s going to come out?

Remember the top is the only place that will give us data.

So if we start popping all these one by one, we’re going to end up with a 25 for that first

pop.

Maybe I should write it down over here.

Do like a 25 and maybe I’ll add some line breaks in the code here so that it’s easier

for me to write with a pen.

Do this and that.

Okay, so the 25, I’m just going to do a red line through it to designate or to denote

deallocation or just like gone-ness.

Then the top is at the 15.

We do another pop.

It’s going to be 15.

Oh, I did my first perfect five today.

And then the top of the stack is now at the four.

So then the four is going to pop out next.

And then the three is going to pop out next.

The top is now at the three.

the three so the three is coming out for that pop we deallocate the three the top goes down one and

then we pop it becomes the two that’s deallocated now and then we grab the eight because that’s

where the top is so now we’ve grabbed all of our data out and I just want you to look at this one

more time notice the data is eight that the data that went in was eight two three four fifteen twenty

The data that came out was backwards 25, 15, 4, 3, 2, 8 or 8, 2, 3, 4, 15, 25.

If you kind of like look up.

So a stack is a data reverser.

A stack is also known as something called a, let’s see,

last in first out data structure, LIFO,

or first in last out, phylo data structure.

What that basically means is just it’s reversing the data or priority goes to the item that is the youngest.

So if you looked at the stack at the point where we were about to remove the 25,

25 was the most recently added or the youngest item or the item with, I guess, the timestamp, the furthest in the future,

however you want to look at it.

And that’s the item that came out.

So if you think about it, it was the last item in.

And therefore, when we did another pop, it was the first item out.

So LIFO or PHILO.

and uh you know this eight down here that was obviously the last item that we were able to grab

out of it so when we said you know hop our final pop before the stack became empty uh the eight was

definitely the first item in so first in was the last out if you really want to you can kind of like

jumble these uh these acronyms uh i think most like people just use lipo or phylo

life if you say something to me that I understand I think it’s probably fine

but it’s it’s non-standard I like to say you know foley first out last in that

definitely makes sense it’s just not very common another thing that I like to

do for fun is also I’ll mix up the phylo and I’ll say lo-fi because last out is

first in and now I’m cooler than other computer people because I use the word

lo-fi I’ve now got like a giant mustache and like a little like swap meet shirt

like swap meat shirt and I have craft beers and I have work boots on and I’d

roll up my jeans and my, my, my, my, my sleeves are rolled up and all that stuff.

You know what I’m saying?

I’m cooler than everybody else now because I used loaf pie anyway.

So we used integers.

It’s just important to understand that in modern coding,

I think I might’ve mentioned this before with the T’s,

these stacks are templated data structures,

we can hold another data type besides integers as long as we declare what the stack will hold in

advance. So instead of integers, you could imagine there’s like a custom class, like my class,

every single, you know, item in the stack is actually a full instance of a my class object,

or, you know, floats or strings or just, you know, any data structure you want,

you could put another data structure inside of a stack. People do that sometimes just for fun,

sometimes just for fun you could take a vector and stick it inside of a stack a list put it inside

of a stack you know whatever you want to do just to show that you understand everything

um so again by the way the stack is empty if we tried to pop from it at this point

this would be called a stack underflow we would probably want to throw an exception at the user

or just say we’re not allowed to do it let’s see um so i guess now i should tell you some

common uses for stacks i’m looking at my notes right here uh obviously our stack has reversed

has reversed the data. So stacks are kind of good for data reversing. Imagine if you had like a word

and you wanted to detect if the word was a palindrome or not, you would just like put all

the letters of the word into your stack and then grab them back out and see if the word was still

in the same order. If it was, then your word was probably a palindrome. If you don’t remember what

a palindrome is, I’m going to write down the word radar in reverse from backwards, from back to

front, right? It’s the same word. So that’s a palindrome. You could also use stacks kind of

as a trail of breadcrumbs. Like you could imagine that early implementations of browsers

had your browsing history in a stack somewhere so that every time you visited a webpage, then

some kind of block of information, maybe like a custom class instance was put onto a stack

somewhere and it contained information about like when you visited the webpage, what the URL was,

it is that the browser wants to remember and then later when you hit the back button then you can

imagine the browser is popping from the stack in order to go backwards in your history or your

spotify playlist or whatever it is you’re doing honestly you know these systems are much more

advanced than just using you know vanilla stacks now but you could imagine doing something on your

own for fun or just what it might have been like in the very beginning i’m going to erase fully

because that’s just that’s just that’s just cringe lo-fi i think is way cooler um so trail of bread

So a trail of breadcrumbs, like browser history, you could also imagine undo history, like

if you had a, I don’t know, like a text editor of some sort or like a image editor of some

sort, every major change that you did to it, maybe the program under the hood is adding

your change to the stack.

And that makes it easier to sort of reverse your changes as those changes are popped.

And there’s like a sort of mathematical uses like balancing parentheses and things, but

balancing parentheses and things, but I’m not going to talk about that too much.

And one of the most important uses for stacks inside of your computer is actually the call

stack. I’m going to talk about that in a future video. But again, remember each, you know, little

item on the stack, it could be a different data structure on its own. It doesn’t have to be an

integer. So imagine that I bundled up a bunch of information about a function call, and I called it

I just stuck a call frame on the stack.

That’s basically the call stack.

But that’s for another video.

Anyway, so let’s see.

Is there anything else that I wanted to show you?

I think we’re actually done just talking about the basics of stacks.

I’m not talking about time complexities or anything like that in this video.

Check a future video if you’re interested in time complexities per certain implementations

and so forth.

But for now, this is how a stack works.

or LIFO or LOFI data structure.

Nobody’s going to say LOFI but me, just FYI.

But maybe everybody will start doing it now.

I don’t know.

If it becomes a trend, okay?

You heard it here first.

Give everybody this link.

All right, I hope you feel like an expert on stacks

at this point.

I hope you had a little bit of fun

and learned a little bit of something, some stuffs.

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 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

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

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 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 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 Stacks: Fun Guide to Data Structures, LIFO & Real-World Uses 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.