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

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

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hi there!

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

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

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

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

have seen a segfault.

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

Segments used to be really, really important.

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

I’ll just talk a little bit about them.

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

just because even in higher level languages,

your languages will typically be compiled down to assembly

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

So if you’re not interested in Yasm Assembly,

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

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

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

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

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

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

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

Perhaps actually this is not the best editor.

I don’t know why I pulled this up.

Let me get Gene here.

It’s a little bit better.

Gene.

There we go.

Maybe I’ll save it somewhere.

I’ll say segments assembly.

And then now the comment gets highlighted.

Okay.

So in assembly in the ASM assembly,

we denote various segments by using the section keywords.

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

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

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

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

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

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

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

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

Think of higher level languages.

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

everything else a local variable or a member variable.

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

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

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

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

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

Sorry, sorry, DW would be for a word.

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

So here quad word is eight bytes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Or say if you have another function in another module,

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

we could say, you know, my other function.

Something like that.

Just mark it as global.

Or sorry, not global.

Extern.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

i don’t know by messing around with the stack pointer increase uh

oh rsp why did i think it was the instruction pointer we could increase the stack pointer and

stack pointer and then decrease the stack pointer.

It doesn’t really help a whole lot.

But in another video, I’m gonna talk more in depth

about what the stack is and how to use it and such.

But just keep in mind that the stack

is where local variables are stored

and you can use it in assembly and C++

and other higher level languages.

You can even make virtual stacks

in any type of program almost

to just sort of have a stack like structure.

But in C++, if you make any local variable,

any local variable, then it’s usually going on the stack.

And the stack tends to have a fixed size.

And so if you sort of put too much data on the stack,

you risk a stack overflow, which will crash your program.

Besides local variables, the stack will hold other information that the current scope needs,

like its return address.

So when we make a function and then let’s say we call another function inside of it,

actually just up here even when we call another function on line 22 the stack will receive the

return address of where we currently are so that later when we return from the other function you

know the program knows where to jump back and forth it’s actually under the hood just jump

instructions when you do call it’s it’s not it’s not like a special thing it’s just jumping to

another location and then pushing the return address on the call stack so that’s other stuff

other stuff that the stack holds, which means if you have like an endless or like a infinite

recursion happening in your function where just a function calls itself over and over

and over again, or you have some complicated call graph and you end up calling too many

functions without ever returning, you could overflow the stack.

So that’s not good.

Let me show you a quick example that I’m going to make for you real fast.

Oh shoot.

Did I actually make this?

Where is the, it’s on the desktop.

Okay, I guess I’m going to make more on the desktop.

Let’s do a stack overflow.

Let me do desktop here.

Let’s do stack overflow.

That’s CBP.

I’m just going to make a quick program.

In C++, that doesn’t really do anything except overflow the stack.

So I just want you to know the stack can overflow.

I’ll make a function called F.

And F just calls itself.

calls itself. So that’s going to be an infinite recursion.

And that means, you know, every single time F calls itself,

the return address of like line five is going to get pushed onto the stack again.

So it’s just going to get pushed and pushed and pushed and pushed.

The stack will overflow faster if I had local variables because every scope that

gets called, even if it’s the same function name, it’ll have its own allocation on

the stack. So if I just sort of like call this from main and then I’ll just need

and then I’ll just need to make a little uh a little make file that just kind of compiles

I don’t really even need to make a make file I could do a build script but I’m going to do it

anyway we’ll say g plus plus standard equals c plus plus 23 show all warnings show pedantic

the input file will be stack overflow cpp and then the output file will be main

main and then assuming that succeeds I’ll just run main so this is like not a make

file video I have other videos for make files let’s see let me get to the

desktop if I run the make file with just the word make you should see a stack

overflow we should also see a warning about the fact that there’s infinite

That’s funny, I must have done something wrong or different because on a different computer

not too long ago I did the same thing and I saw a warning.

Okay, well thanks for not warning me.

But anyway, you can see that we have a segmentation fault here because the stack overflowed.

We just made a stack that was too huge.

This is a reminder that the stack is not necessarily as dynamic as the heap.

You can definitely overflow it.

It’s not really meant to store gigantic amounts of data.

What am I talking about when I say the heap though?

So just keep in mind that whenever you allocate dynamic data,

well, maybe, well, what do you think?

Maybe, maybe inside of, instead of calling F, let’s call G.

The heap is where you allocate dynamic data.

So anytime you use the malloc operator in C or the new allocator in C++,

you’re creating like a dynamic allocation of data.

I’ll do a new integer and then I’ll do like a thousand integers so this is

basically going to allocate a thousand new integers in the heap which is a

segment that is right up against the stack I should mention also that the

stack it’s important the stack its memory locations go down as the stack

grows keep that in mind because typically when you when you imagine a

stack I’ll make more videos in the future so you can visualize the stack better but most of you who

know what a stack is already you imagine that the stack grows upward visually right but in your

computer the memory locations of the stack grow downward so if I add something to the stack then

the new stack head pointer is actually going to be a lesser address and the reason for that is the

stack and the heap they grow in the same direction towards the same unallocated space we’ll call that

We’ll call that space the unallocated memory space or the unmapped memory space.

And it’s just, you know, a segment stack in the heap.

And then there’s the unallocated space that they grow towards each other.

If they ever meet, then your program is out of memory and it’ll crash.

But the heap actually can be dynamically allocated to store tons of RAM.

I’m probably about to crash this computer.

So maybe this video won’t finish recording.

recording so maybe I’ll try to crash this at the very end I just wanted you to

see let me let me do this I’ll say while true we’ll just allocate a new integer

this is kind of bad form because when you allocate you know a new variable

somewhere you want to have access to it after the allocation you would usually

send that into a pointer you’d say like you know integer pointer P equals new

in something like that right but in this case I don’t really care I’m not gonna

that memory i just want you to see how fast the memory can grow when we did the stack overflow

seemed like the program died pretty quickly but here we’re going to be able to see the memory

boom pretty pretty big before the whole computer just starts to you know fall to its knees

so i’m going to do a call to g here and then i won’t actually run this until

i’m ready to crash this whole video let’s see what else can i say

Oh, the reason that the heap can grow so much larger than the stack is our programs now in the modern era, they use virtual memory.

So it’s not like when we allocate, let’s say we’re accessing a memory location via a pointer inside of our program.

It’s not that the pointer has the absolute memory location through the whole system.

Like it doesn’t, it’s not able to name locations outside of the current program.

Every program sees its own start memory location as just zero.

And then under the hood, there are some extra tricks so that when you try to access a memory location,

let’s say memory location 100, because you’ve made, I don’t know, this many integers or whatever.

Then under the hood, the computer will know what is the start offset of the program’s memory.

So maybe the start offset is 1000.

It’s like totally unrealistic, but just pretend.

The start offset is 1000.

1000 then that means if it’s trying to access a pointer with memory location 100 it just gets added to the offset the virtual offset

So it’ll be a thousand and 100 is the real you know physical memory location or at least at that point

It’ll probably go to the paging system, but that’s that’s another video

So just know that it’s virtual which means the program thinks it has the full range of of the 64 bit memory address space

Even if you don’t even have that much memory on your computer, which there’s no way there’s no way you have so much memory

there’s no way you have so much memory that it’s going to overflow or even meet

64 bits at all but the program thinks it can so it’s just going to grow and grow

and grow until you actually run out of physical memory and then eventually

probably your program is going to start going to the page file or to the swap

file and then when you run out of that then your whole computer probably is

going to start crashing to be honest it’ll probably start crashing as soon as

it hits the swap file because at that point none of the other programs really

None of the other programs really have enough leftover memory to to breathe to do extra

allocations and things so everything’s going to start slowing down it’s going to be pretty bad

and well i think that’s all i really need to say this is not supposed to be a really long video

let me uh let me show you this crasher i’m going to say goodbye now thank you so much for watching

the video i hope you learned a little bit and had some fun too and and that way i’ve already said

if it actually crashes the computer. So I’m going to open up this and then I’m going to do maybe

HTOP so that I can see memory. So if you kind of like look at HTOP real fast,

this is just a Linux command line tool that you can install. It’s pretty cool.

What the heck’s going on here? Oh, that’s my recorder. You can see here’s the memory allocation.

So I’m using two gigs of eight gigs on this virtual machine and then I’m not using any swap

space which means I have not exhausted all my memory and and I have not been forced to go to

the disk for like additional memory but in a second we’ll see that will probably change

so I’m going to do make just to run that it looks like it’s stuck but if you keep looking at the

memory allocation oh it already hit eight gigs now it’s into the swap already probably

The out of memory killer, the OOM, successfully killed the program.

Thank goodness.

Or the whole computer would have been down.

I always forget that that’s going to happen lately.

But you can see it spiked, right?

It went right up to the full physical memory allocation of 7.75 gigs.

And then the swap file went all the way up to 2 gigs.

You can see that the swap file still has about 700 megs inside of it.

That just means that there’s memory that isn’t really being accessed.

the operating system doesn’t feel like it’s necessary to pull it back out of swap and put

it into RAM but I wonder if the video skipped when I did that or stuttered or anything I’m

interested to find out now okay so that’s the end of this video I hope you have a decent basic

understanding of segments and then you know like the segments and their purpose you know the heap

and the stack they grow together the heap can dynamically allocate to grow bigger notice how it

Whereas the stack will crash a lot faster.

If the stack and the heap meet, then you’ve ran out of memory.

At that point, you know, you probably want to like resize the heap or the stack just crashes.

And then we got the text section of the program and the data section and the BSS section of the program.

And these sections are a little bit less relevant in the modern era because we have, you know, virtual memory and stuff.

That definitely means you have tried to access outside of your segment and it’s a no go.

Okay.

Thank you for watching this video.

I will see you at a later date and time.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

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

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

as you do on the current social media website

that you’re looking at right now,

it would really mean the world to me

and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos,

longer videos, better videos,

or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping

in the middle of the night

and I just wake up

because I know somebody subscribed or followed.

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

That’s exactly what happens every single time.

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

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

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

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

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

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

and all that good stuff and

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

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

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

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

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

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

Thank you.

The post Demystifying x86-64 Program Segments: Stack, Heap, and More appeared first on NeuralLantern.com.

Ever clicked an icon and wondered how your program starts? Meet the Loader Module, the unsung hero in your operating system! This video breaks down how it loads programs from your disk to RAM, sets up processes, and gets your apps ready to roll. Perfect for tech newbies or curious coders! Join us for a fun, easy-to-follow explanation, and stick around for more OS secrets. Subscribe, comment your thoughts, and scan the QR code to explore more tutorials on our site! Let’s geek out together!

Introduction to Loader Module 00:00:00
What is the Loader Module 00:00:10
Role in Operating Systems 00:00:14
Loading Process Overview 00:00:21
Program Execution Trigger 00:00:44
Signal to Operating System 00:01:00
Executable Validation 00:01:43
Memory Allocation 00:02:31
Process Creation 00:03:05
Process Setup Completion 00:04:22
Operating System Scheduling 00:04:54
Multitasking Illusion 00:05:24
Process Termination 00:05:59
Loader Module Limitations 00:06:11
Conclusion and Summary 00:06:28
Call to Subscribe 00:07:00
Website and Community 00:07:56

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey there! Let’s talk about the Loader Module for just a second.

What is the Loader Module? For starters, you probably have one on your computer at home.

Almost, I mean, as far as I understand, every major operating system has a Loader Module.

I would be surprised if an operating system did not have one.

The Loader Module is basically responsible for getting your program loaded from your hard disk,

your hard disk your ssd or whatever into ram and sort of setting it up setting up an empty process

and getting it all prepared so that the operating system can begin executing your process doesn’t

actually execute it it just gets it set up so i mean think about it what if i click on my desktop

here and i click on this little mouse icon this little text editor icon the mouse pad

it launched what happened it wasn’t running before and now it is running something had to do that

It wasn’t the desktop environment actually the desktop environment when I click this little button

It just sent a signal to the operating system letting it know that I wanted to start executing a program

But it didn’t actually load it up for me. That’s the loader module. The loader module is part of the operating system

and imagine that as soon as I

You know click this button right here a signal gets sent to the operating system or maybe even if I just execute a command like echo

You know test or something or run get get status. Let’s say

status let’s say or even I could run this terminal again terminator and it

shows up in another window something like that let me exit from that you know

anything that I exit whatever the loader module is involved so I click this and

the first thing that will happen is the loader module will inspect the

executable which is just kind of sitting on disk somewhere and it’ll make sure

that it’s actually executable it’ll make sure not just in terms of you know

That’s sort of an operating system thing, a different part of the operating system.

But it’ll check to make sure, let’s say that it’s a binary program that needs to be executed.

It’ll make sure that the data inside of the binary, the actual executable is correct for

the current system that you’re on.

Like right now I’m on Linux 64 bit.

So it’ll make sure that the executable is in a ELF 64 format or a format that can be

executed.

It’ll check that it’ll make sure everything’s okay to make sure it’s got some data. It’s got like a you know an entry point whatever

If everything looks good, then it will go through system RAM and try to find a little place in RAM that’s unoccupied

I’m not going to talk too much about operating system concepts beyond the loader module, but just so you know

There is a paging system that it would go through which sort of lets you have fragmented memory without too much of a penalty

the ram stick directly but for our purposes we’ll just say it’s looking for a free spot in memory

anyway once it finds out that there’s a free spot in memory that’s big enough to accommodate

the program then it actually loads the program from disk from ssd from whatever into that spot

in memory and creates a process in the operating system remember everything that’s actually running

in your operating system is a process there’s a process for this notepad there’s a process

for the mouse stuff there’s a process for this little widget down here there’s a

process for the entire desktop there’s a process for probably every tab in your

browser you know a process just means here’s a little spot in memory on the

computer and it’s got a program inside of it and it wants to be run by the CPU

whenever the CPU thinks that it has some time to run that process so that’s like

a process anyway so it you know it finds a spot in memory it loads the program in

you know checks everything it sets it up as a process which means it has to set up some data

structures in the operating system indicating hey there’s a new process in town and here’s where the

memory is and here’s the first instruction that you should execute and it just kind of sets

everything up so that it’s like a like a ready process a process in the ready state that hasn’t

been actually executed yet but it’s ready to get executed so once it does all of that

new process you know setting everything up maybe figuring out what is the virtual memory address

that the process is going to see and so forth then finally it lets the operating system know

that the process is ready to run so before it was just kind of like loading it and setting it up

marking little flags figuring out the virtual memory offset all that stuff then once that’s

all finished it just tells the operating system now this process is ready to run the process

I’m going to try my best not to talk too much about operating systems concepts beyond the loader module, but

the loader module’s job is not to run the process. It’s just to load it, just to set it up.

At some later point in time, maybe some amount of microseconds or milliseconds in the future,

the operating system will decide, okay, now I’m ready to let that program run for a little while.

Since the process has already been set up by the loader module, the operating system knows where

it is in memory and it knows the next instruction address or offset address to execute. It’ll just

set address to execute it’ll just start bringing those instructions onto the CPU and just execute

them for some amount of time and then the operating system will decide to stop and take it off the CPU

again you know put it back just into a into a ready state and then it just keeps switching back

and forth between that by the way have you ever wondered how it is that maybe your CPU only has

one core or only eight cores but there are hundreds of browser tabs that you have open

hundreds and hundreds of processes that you have open that’s how the operating system does it it

it simulates it provides the illusion that all these programs are running at the same time so

this notepad process right here it’s not actually running at all times it just runs in tiny little

slices again i’ll try to stay away from explaining that too much because i’m really here to talk

about the loader module another thing to keep in mind is that eventually when your process terminates

like the the program terminates itself or the operating system kills it for some reason or just

or just, you know, something happens to where it’s just not going to be running anymore.

It’s not the loader module that has anything to do with that.

And there is no unloader module.

It will just mark itself as, you know, I’m done, I’m terminated, whatever,

or it’ll get marked.

Then the operating system will come along and clean it up.

So loader module is not involved in that step.

It’s just involved in getting everything set up so that it can start to execute.

And that’s the basic idea.

detailed but that’s what the loader module does in general and you probably

have a loader module on your operating system right now unless you’re running

some bizarre operating system that has some other strange method of doing

things okay that’s all I really wanted to say in this video thank you so much

for watching I hope you learned a little bit of stuff and had some fun I’ll see

you in the next video

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?

It’s a 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

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 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’ll happen.

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

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

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 How the Loader Module Works: Launching Programs in Your Operating System Explained! appeared first on NeuralLantern.com.

Hey everyone, let’s talk linkers! In this video, we unpack the general idea of linking in programming—taking your source code, turning it into object files, and stitching them into an executable. We dive into virtual memory, how programs use offsets, and why jump instructions matter across modules. Using simple assembly and C++ examples, we’ll show how linkers lay out modules, handle labels, and make function calls work. Whether you’re a beginner or a coder curious about what happens under the hood, this is for you! Hit subscribe, scan the QR code for more tutorials, and drop a comment with your thoughts or video ideas. Let’s keep learning and have some fun with code! #Programming #Linker #VirtualMemory #CodingExplained

Introduction to Linking 00:00:00
Compilation and Object Files 00:00:05
Linker Overview 00:00:32
Virtual Memory Explanation 00:00:42
Program Memory Offsets 00:01:18
Jump Instructions in Modules 00:02:54
Module Address Space 00:03:38
Assembler and Label Jumps 00:04:02
Linker’s Role in Module Layout 00:07:15
Function Calls Across Modules 00:08:04
Marking Labels as Global 00:09:31
External Function Calls 00:10:23
Data in Executables 00:11:12
Conclusion and Call to Subscribe 00:12:08

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey there, I want to talk to you very quickly about the general idea of linking your programs.

In previous videos I’ve described exactly how to perform the linking stage when you’re compiling

a program. So you write some source code, you compile the source code into object files,

you know each file becomes one individual object file, and then when we’re done we take all the

object files and we link them up into an executable program. So I’ve talked about that

I just wanted to talk to you about the general idea of the linking stage in general.

Like what is the linker? What is its job? What is it actually doing?

So try to keep in mind for starters, each program uses virtual memory.

It uses a virtual memory space.

So obviously on your computer you have real memory,

but there’s lots of layers of abstraction between the physical hardware

the physical hardware and the program that’s running for starters the operating system uses

a paging system the memory stick the memory circuitry might be doing something else for

error checking or just you know transport or whatever so so try and bear in mind that each

program thinks that it’s it thinks that itself is kind of the beginning of memory you could imagine

it as each program thinks that its first memory location that it has assigned to it is memory

location zero but that wouldn’t necessarily be the case on the computer

your operating system probably would have come up with an offset let’s say

for example you know your computer decides to launch your program it

creates a process it finds a chunk of memory that’s available across you know

one or more pages of free memory and let’s say for the sake of argument that

the starting offset for the for the quote-unquote real forgetting the other

layers layers of abstraction the real memory location of your program is going

of your program is going to be let’s just say like a thousand I know that’s

real unrealistically too low but let’s just say a thousand and then let’s say

that your program then thinks that it starts at memory location zero that

means if your program wants to access memory location 100 then under the hood

at the last moment right before you actually hit the RAM stick or hit the

page file system a translation has to be performed so if your program is trying

what actually happens is you know the general offset for the entire program

gets added to memory location 100 and then that tells the computer or the

operating system that what you’re actually trying to do in your program is

access memory location 1100 so keep in mind all of this memory is virtual

and the modules themselves also need to know where to jump when I say where to

Well, suppose for the sake of argument, you have a program that has some jump instructions

or go to instructions or like some conditional branching instructions, anything where execution

is not just going to go to the very next statement.

Execution is going to go somewhere else.

Like maybe you have an if else block.

It’s got to maybe jump sometimes down to the else part instead of the top if part.

And then when it’s done executing, it’s going to jump until after the whole block, you know,

There will be lots of times in all of your programs where execution kind of has to jump

around somewhere if the program is even a little bit complicated.

So that could be a jump instruction, go to in a higher level language, not assembly necessarily,

jump if not equal and so forth.

So if you imagine writing one module, you could also imagine that the module has its

own virtual memory address space.

Just imagine it for now.

And maybe it starts at zero.

at zero that’s that’s not what we’re going to say but just like imagine the module only really knows

about itself and so sometimes when you’re jumping for example if we’re going to jump uh when

something is not equal to something else we’ll jump to some label and in order to jump to that

label the assembler needs to know you know where is that label inside of your source code so pretend

just for a moment this is not like a real assembly program but just pretend for a moment that we have

and maybe this is like I don’t know the main label that gets jumped into from GCC and

so then we have like a label down here outside and we’ll do stuff and then jump back to the

original point so we probably have to do a label here main finish this is this is bad form but I’m

So if we jump, let’s compare, I don’t know, one with two or something.

Let’s compare RAX to RDX and we’ll just move RAX the value one and move RDX the value two

so they’re not actually equal.

And then we compare them and then we say, all right, jump if they’re not equal to this label.

So definitely now we know, oh, we are going to jump down to that label.

So execution is going to go directly down to here.

we’ll do something and then eventually maybe we want to jump back so we’ll say uh

maybe let’s do it again let’s do let’s do like a whole set of statements again we’ll say jump

if it is equal and we’ll just like load those two registers so one and one and then compare

them and then say jump if it is equal to main finish this is not a video about conditional

branching or jumping i’m trying to make this as simple as i can but i hope you understand the

but i hope you understand the point is just basically we’re jumping around within the same

module right so it’s easy for the program to understand where to jump if it’s in the same

module or i guess the the object file when we’re assembling it it’s easy to understand where to jump

because if we’re at line 8 here when we start to jump and then the actual label here has its first

instruction at line 17 well then it you know the amount of instructions to move is just the

the difference you know so it’s easy to say all right if our virtual address is you know this

when we jump and we’re going to jump this much of a difference based on where the label is then now

we can just compute the new virtual address to jump or the absolute address or whatever you want

to whatever you want to do on that particular run but how does it know where to jump in another

module because when we assemble this module as an object file the assembler is only running one pass

one pass on just this object file it doesn’t really know the addresses in the other modules

it doesn’t know their offsets of its labels even if it’s a c plus plus or a c module it doesn’t

really know the offsets it doesn’t know where the functions start and end doesn’t know anything

because right now if we assemble this one source code it’s only going to know about this one source

code right and the same goes for the other modules if we compile a c plus plus program to an object

a function or you know do a go to statement or something into one of these labels from this

module the c plus plus program won’t really know where it is it won’t know what address it’s at it

won’t know the offset right so that’s the job of the linker the linker looks at all of these labels

and all of these uh conditional branching statements and jump statements and everything

and it just decides for starters it decides where each module is going to start in memory so maybe

I don’t know if your C++ module starts up here somewhere and then it’ll say this assembly module

starts right after it and then another module right after that and it’ll just kind of decide

where every module will start in the final executable that we’re actually linking together.

Once it decides the layout then it knows the offset of all the different modules and therefore

it can compute the additional offset that it would take to get to all the labels. So then at that

Your C++ module will make a function call inside of, you know, some assembly module like the one we’re looking at, assuming it was written a little bit differently.

Main finish return.

I guess the way it’s written down here, it’s returning to main if we just kind of execute it as we’re looking at it.

But another module could could call main finish as a function and still get a return statement.

That would actually work, even though it’s probably bad design.

that your assembly sorry your C++ program wants to call a function called

main finish inside of this module the linker having already laid out the

modules and and being aware of all their offsets it knows okay so you know this

assembly module it was underneath the C++ module so it’ll just take that offset

and add it to the offset of the label itself within the module and then also

add that to the the virtual address or I guess the operating system will do the

address. But you know, the point is the linker coordinates all the jumps and the conditional

branches where the functions start, lays out all the modules, gets all the offsets,

and then starts replacing all of the conditional branches and jumps and things with the real

offsets that make it actually doable. Like let’s jump to exactly this memory location

in code exactly in quotes, because we’re still using virtual addressing.

idea of the linker it knows how to jump between modules um wants to link or discuss okay that’s

all i really wanted to say don’t forget if you want a label to be available to jump into or to

call as a function from outside the module you got to mark it as global so if i actually wanted

somebody to be able to call main finish as a function i just have to mark it as global same

thing for some label if i say global some label then now at this point another module could call

call this as a function or jump into it probably bad form to not put a return a return statement

at this point which means when i’m calling it up here instead of jump not equal to i probably have

to add more complicated logic so i can use a function call that gets jumped around if it is

equal but so i’m not going to go that far right now kind of complicated just for this video

and then also of course if you intend to jump somewhere else remember that you have to mark

So let’s say there’s a function in your other module, your C++ module or your C module or your assembly module.

You just have to mark it as extern in the text section, in the text segment, like some other function somewhere else, something like that.

And then once I do that, now I could actually call it, I could say, call, you know, this.

Actually, that’ll never get reached because the jump equal thing is at the bottom.

equal thing is at the bottom but I could do this I could say call it if it was actually a function

or I could say jump if it was just a jump point or I could say you know jump not equal to

the other function instead of some label something like that so lots of stuff you can do and now you

kind of understand the idea of linking is taking all the modules stuffing them inside of the final

executable and also putting data inside of the final executable you know like if you’re creating

So, you know, like if you’re creating a string variable in your globals area of your assembly

program or hard coding, any kind of string anywhere in your C++, then it’s got to be

inside of the executable.

Otherwise, it wouldn’t be anywhere when we ran the program.

So, yeah, it sticks the data in there.

It sticks the segments in there.

It, you know, calculates the jumps and all that stuff.

I just want to point out you could put strings in a configuration file.

of a vanilla C++ or assembly program you probably are making strings directly in the program.

Anyway, so I think that’s the gist of everything that I really wanted to say about what is the

general idea of the linker. Thanks for watching this video I hope you learned a little bit and

had some fun. I will see you in the next video. Hey everybody thanks for watching this video again

it i do hope you did learn something and have some fun if you could do me a please a small little

favor could you please subscribe and follow this channel or these videos or whatever it is you do

on the current social media website that you’re looking at right now it would really mean the

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

videos longer videos better videos or just i’ll be able to keep making videos in general so please

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

because I know somebody subscribed or followed. It just wakes me up and I get filled with joy.

That’s exactly what happens every single time. So you could do it as a nice favor to me or you

could troll me if you want to just wake me up in the middle of the night, just subscribe

and then I’ll just wake up. I promise that’s what will happen. Also, if you look at the middle of

the screen right now, you should see a QR code, which you can scan in order to go to the website,

is also named somewhere at the bottom of this video and it’ll take you to my main website where

you can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

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

say hey what’s up what’s going on you know just send me a comment whatever I also wake up for

I wake up in a cold sweat and I’m like, it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video and enjoy the cool music as I fade into

the darkness, which is coming for us all.

Thank you.

The post How Linkers Work: Linking Code, Virtual Memory, and Module Jumps Explained appeared first on NeuralLantern.com.